Loading...
Note: File does not exist in v3.1.
1/*
2 * Core driver for the pin muxing portions of the pin control subsystem
3 *
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
7 *
8 * Author: Linus Walleij <linus.walleij@linaro.org>
9 *
10 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
11 *
12 * License terms: GNU General Public License (GPL) version 2
13 */
14#define pr_fmt(fmt) "pinmux core: " fmt
15
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>
30#include "core.h"
31#include "pinmux.h"
32
33int pinmux_check_ops(struct pinctrl_dev *pctldev)
34{
35 const struct pinmux_ops *ops = pctldev->desc->pmxops;
36 unsigned nfuncs;
37 unsigned selector = 0;
38
39 /* Check that we implement required operations */
40 if (!ops ||
41 !ops->get_functions_count ||
42 !ops->get_function_name ||
43 !ops->get_function_groups ||
44 !ops->set_mux) {
45 dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n");
46 return -EINVAL;
47 }
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,
52 selector);
53 if (!fname) {
54 dev_err(pctldev->dev, "pinmux ops has no name for function%u\n",
55 selector);
56 return -EINVAL;
57 }
58 selector++;
59 }
60
61 return 0;
62}
63
64int pinmux_validate_map(struct pinctrl_map const *map, int i)
65{
66 if (!map->data.mux.function) {
67 pr_err("failed to register map %s (%d): no function given\n",
68 map->name, i);
69 return -EINVAL;
70 }
71
72 return 0;
73}
74
75/**
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
81 * single GPIO pin
82 */
83static int pin_request(struct pinctrl_dev *pctldev,
84 int pin, const char *owner,
85 struct pinctrl_gpio_range *gpio_range)
86{
87 struct pin_desc *desc;
88 const struct pinmux_ops *ops = pctldev->desc->pmxops;
89 int status = -EINVAL;
90
91 desc = pin_desc_get(pctldev, pin);
92 if (desc == NULL) {
93 dev_err(pctldev->dev,
94 "pin %d is not registered so it cannot be requested\n",
95 pin);
96 goto out;
97 }
98
99 dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n",
100 pin, desc->name, owner);
101
102 if (gpio_range) {
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);
108 goto out;
109 }
110 if (ops->strict && desc->mux_usecount &&
111 strcmp(desc->mux_owner, owner)) {
112 dev_err(pctldev->dev,
113 "pin %s already requested by %s; cannot claim for %s\n",
114 desc->name, desc->mux_owner, owner);
115 goto out;
116 }
117
118 desc->gpio_owner = owner;
119 } else {
120 if (desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
121 dev_err(pctldev->dev,
122 "pin %s already requested by %s; cannot claim for %s\n",
123 desc->name, desc->mux_owner, owner);
124 goto out;
125 }
126 if (ops->strict && desc->gpio_owner) {
127 dev_err(pctldev->dev,
128 "pin %s already requested by %s; cannot claim for %s\n",
129 desc->name, desc->gpio_owner, owner);
130 goto out;
131 }
132
133 desc->mux_usecount++;
134 if (desc->mux_usecount > 1)
135 return 0;
136
137 desc->mux_owner = owner;
138 }
139
140 /* Let each pin increase references to this module */
141 if (!try_module_get(pctldev->owner)) {
142 dev_err(pctldev->dev,
143 "could not increase module refcount for pin %d\n",
144 pin);
145 status = -EINVAL;
146 goto out_free_pin;
147 }
148
149 /*
150 * If there is no kind of request function for the pin we just assume
151 * we got it by default and proceed.
152 */
153 if (gpio_range && ops->gpio_request_enable)
154 /* This requests and enables a single GPIO pin */
155 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
156 else if (ops->request)
157 status = ops->request(pctldev, pin);
158 else
159 status = 0;
160
161 if (status) {
162 dev_err(pctldev->dev, "request() failed for pin %d\n", pin);
163 module_put(pctldev->owner);
164 }
165
166out_free_pin:
167 if (status) {
168 if (gpio_range) {
169 desc->gpio_owner = NULL;
170 } else {
171 desc->mux_usecount--;
172 if (!desc->mux_usecount)
173 desc->mux_owner = NULL;
174 }
175 }
176out:
177 if (status)
178 dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
179 pin, owner, status);
180
181 return status;
182}
183
184/**
185 * pin_free() - release a single muxed in pin so something else can be muxed
186 * @pctldev: pin controller device handling this pin
187 * @pin: the pin to free
188 * @gpio_range: the range matching the GPIO pin if this is a request for a
189 * single GPIO pin
190 *
191 * This function returns a pointer to the previous owner. This is used
192 * for callers that dynamically allocate an owner name so it can be freed
193 * once the pin is free. This is done for GPIO request functions.
194 */
195static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
196 struct pinctrl_gpio_range *gpio_range)
197{
198 const struct pinmux_ops *ops = pctldev->desc->pmxops;
199 struct pin_desc *desc;
200 const char *owner;
201
202 desc = pin_desc_get(pctldev, pin);
203 if (desc == NULL) {
204 dev_err(pctldev->dev,
205 "pin is not registered so it cannot be freed\n");
206 return NULL;
207 }
208
209 if (!gpio_range) {
210 /*
211 * A pin should not be freed more times than allocated.
212 */
213 if (WARN_ON(!desc->mux_usecount))
214 return NULL;
215 desc->mux_usecount--;
216 if (desc->mux_usecount)
217 return NULL;
218 }
219
220 /*
221 * If there is no kind of request function for the pin we just assume
222 * we got it by default and proceed.
223 */
224 if (gpio_range && ops->gpio_disable_free)
225 ops->gpio_disable_free(pctldev, gpio_range, pin);
226 else if (ops->free)
227 ops->free(pctldev, pin);
228
229 if (gpio_range) {
230 owner = desc->gpio_owner;
231 desc->gpio_owner = NULL;
232 } else {
233 owner = desc->mux_owner;
234 desc->mux_owner = NULL;
235 desc->mux_setting = NULL;
236 }
237
238 module_put(pctldev->owner);
239
240 return owner;
241}
242
243/**
244 * pinmux_request_gpio() - request pinmuxing for a GPIO pin
245 * @pctldev: pin controller device affected
246 * @pin: the pin to mux in for GPIO
247 * @range: the applicable GPIO range
248 */
249int pinmux_request_gpio(struct pinctrl_dev *pctldev,
250 struct pinctrl_gpio_range *range,
251 unsigned pin, unsigned gpio)
252{
253 const char *owner;
254 int ret;
255
256 /* Conjure some name stating what chip and pin this is taken by */
257 owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
258 if (!owner)
259 return -ENOMEM;
260
261 ret = pin_request(pctldev, pin, owner, range);
262 if (ret < 0)
263 kfree(owner);
264
265 return ret;
266}
267
268/**
269 * pinmux_free_gpio() - release a pin from GPIO muxing
270 * @pctldev: the pin controller device for the pin
271 * @pin: the affected currently GPIO-muxed in pin
272 * @range: applicable GPIO range
273 */
274void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
275 struct pinctrl_gpio_range *range)
276{
277 const char *owner;
278
279 owner = pin_free(pctldev, pin, range);
280 kfree(owner);
281}
282
283/**
284 * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
285 * @pctldev: the pin controller handling this pin
286 * @range: applicable GPIO range
287 * @pin: the affected GPIO pin in this controller
288 * @input: true if we set the pin as input, false for output
289 */
290int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
291 struct pinctrl_gpio_range *range,
292 unsigned pin, bool input)
293{
294 const struct pinmux_ops *ops;
295 int ret;
296
297 ops = pctldev->desc->pmxops;
298
299 if (ops->gpio_set_direction)
300 ret = ops->gpio_set_direction(pctldev, range, pin, input);
301 else
302 ret = 0;
303
304 return ret;
305}
306
307static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
308 const char *function)
309{
310 const struct pinmux_ops *ops = pctldev->desc->pmxops;
311 unsigned nfuncs = ops->get_functions_count(pctldev);
312 unsigned selector = 0;
313
314 /* See if this pctldev has this function */
315 while (selector < nfuncs) {
316 const char *fname = ops->get_function_name(pctldev, selector);
317
318 if (!strcmp(function, fname))
319 return selector;
320
321 selector++;
322 }
323
324 dev_err(pctldev->dev, "function '%s' not supported\n", function);
325 return -EINVAL;
326}
327
328int pinmux_map_to_setting(struct pinctrl_map const *map,
329 struct pinctrl_setting *setting)
330{
331 struct pinctrl_dev *pctldev = setting->pctldev;
332 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
333 char const * const *groups;
334 unsigned num_groups;
335 int ret;
336 const char *group;
337
338 if (!pmxops) {
339 dev_err(pctldev->dev, "does not support mux function\n");
340 return -EINVAL;
341 }
342
343 ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
344 if (ret < 0) {
345 dev_err(pctldev->dev, "invalid function %s in map table\n",
346 map->data.mux.function);
347 return ret;
348 }
349 setting->data.mux.func = ret;
350
351 ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
352 &groups, &num_groups);
353 if (ret < 0) {
354 dev_err(pctldev->dev, "can't query groups for function %s\n",
355 map->data.mux.function);
356 return ret;
357 }
358 if (!num_groups) {
359 dev_err(pctldev->dev,
360 "function %s can't be selected on any group\n",
361 map->data.mux.function);
362 return -EINVAL;
363 }
364 if (map->data.mux.group) {
365 group = map->data.mux.group;
366 ret = match_string(groups, num_groups, group);
367 if (ret < 0) {
368 dev_err(pctldev->dev,
369 "invalid group \"%s\" for function \"%s\"\n",
370 group, map->data.mux.function);
371 return ret;
372 }
373 } else {
374 group = groups[0];
375 }
376
377 ret = pinctrl_get_group_selector(pctldev, group);
378 if (ret < 0) {
379 dev_err(pctldev->dev, "invalid group %s in map table\n",
380 map->data.mux.group);
381 return ret;
382 }
383 setting->data.mux.group = ret;
384
385 return 0;
386}
387
388void pinmux_free_setting(struct pinctrl_setting const *setting)
389{
390 /* This function is currently unused */
391}
392
393int pinmux_enable_setting(struct pinctrl_setting const *setting)
394{
395 struct pinctrl_dev *pctldev = setting->pctldev;
396 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
397 const struct pinmux_ops *ops = pctldev->desc->pmxops;
398 int ret = 0;
399 const unsigned *pins = NULL;
400 unsigned num_pins = 0;
401 int i;
402 struct pin_desc *desc;
403
404 if (pctlops->get_group_pins)
405 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
406 &pins, &num_pins);
407
408 if (ret) {
409 const char *gname;
410
411 /* errors only affect debug data, so just warn */
412 gname = pctlops->get_group_name(pctldev,
413 setting->data.mux.group);
414 dev_warn(pctldev->dev,
415 "could not get pins for group %s\n",
416 gname);
417 num_pins = 0;
418 }
419
420 /* Try to allocate all pins in this group, one by one */
421 for (i = 0; i < num_pins; i++) {
422 ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
423 if (ret) {
424 const char *gname;
425 const char *pname;
426
427 desc = pin_desc_get(pctldev, pins[i]);
428 pname = desc ? desc->name : "non-existing";
429 gname = pctlops->get_group_name(pctldev,
430 setting->data.mux.group);
431 dev_err(pctldev->dev,
432 "could not request pin %d (%s) from group %s "
433 " on device %s\n",
434 pins[i], pname, gname,
435 pinctrl_dev_get_name(pctldev));
436 goto err_pin_request;
437 }
438 }
439
440 /* Now that we have acquired the pins, encode the mux setting */
441 for (i = 0; i < num_pins; i++) {
442 desc = pin_desc_get(pctldev, pins[i]);
443 if (desc == NULL) {
444 dev_warn(pctldev->dev,
445 "could not get pin desc for pin %d\n",
446 pins[i]);
447 continue;
448 }
449 desc->mux_setting = &(setting->data.mux);
450 }
451
452 ret = ops->set_mux(pctldev, setting->data.mux.func,
453 setting->data.mux.group);
454
455 if (ret)
456 goto err_set_mux;
457
458 return 0;
459
460err_set_mux:
461 for (i = 0; i < num_pins; i++) {
462 desc = pin_desc_get(pctldev, pins[i]);
463 if (desc)
464 desc->mux_setting = NULL;
465 }
466err_pin_request:
467 /* On error release all taken pins */
468 while (--i >= 0)
469 pin_free(pctldev, pins[i], NULL);
470
471 return ret;
472}
473
474void pinmux_disable_setting(struct pinctrl_setting const *setting)
475{
476 struct pinctrl_dev *pctldev = setting->pctldev;
477 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
478 int ret = 0;
479 const unsigned *pins = NULL;
480 unsigned num_pins = 0;
481 int i;
482 struct pin_desc *desc;
483
484 if (pctlops->get_group_pins)
485 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
486 &pins, &num_pins);
487 if (ret) {
488 const char *gname;
489
490 /* errors only affect debug data, so just warn */
491 gname = pctlops->get_group_name(pctldev,
492 setting->data.mux.group);
493 dev_warn(pctldev->dev,
494 "could not get pins for group %s\n",
495 gname);
496 num_pins = 0;
497 }
498
499 /* Flag the descs that no setting is active */
500 for (i = 0; i < num_pins; i++) {
501 desc = pin_desc_get(pctldev, pins[i]);
502 if (desc == NULL) {
503 dev_warn(pctldev->dev,
504 "could not get pin desc for pin %d\n",
505 pins[i]);
506 continue;
507 }
508 if (desc->mux_setting == &(setting->data.mux)) {
509 desc->mux_setting = NULL;
510 /* And release the pin */
511 pin_free(pctldev, pins[i], NULL);
512 } else {
513 const char *gname;
514
515 gname = pctlops->get_group_name(pctldev,
516 setting->data.mux.group);
517 dev_warn(pctldev->dev,
518 "not freeing pin %d (%s) as part of "
519 "deactivating group %s - it is already "
520 "used for some other setting",
521 pins[i], desc->name, gname);
522 }
523 }
524}
525
526#ifdef CONFIG_DEBUG_FS
527
528/* Called from pincontrol core */
529static int pinmux_functions_show(struct seq_file *s, void *what)
530{
531 struct pinctrl_dev *pctldev = s->private;
532 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
533 unsigned nfuncs;
534 unsigned func_selector = 0;
535
536 if (!pmxops)
537 return 0;
538
539 mutex_lock(&pctldev->mutex);
540 nfuncs = pmxops->get_functions_count(pctldev);
541 while (func_selector < nfuncs) {
542 const char *func = pmxops->get_function_name(pctldev,
543 func_selector);
544 const char * const *groups;
545 unsigned num_groups;
546 int ret;
547 int i;
548
549 ret = pmxops->get_function_groups(pctldev, func_selector,
550 &groups, &num_groups);
551 if (ret) {
552 seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
553 func);
554 func_selector++;
555 continue;
556 }
557
558 seq_printf(s, "function: %s, groups = [ ", func);
559 for (i = 0; i < num_groups; i++)
560 seq_printf(s, "%s ", groups[i]);
561 seq_puts(s, "]\n");
562
563 func_selector++;
564 }
565
566 mutex_unlock(&pctldev->mutex);
567
568 return 0;
569}
570
571static int pinmux_pins_show(struct seq_file *s, void *what)
572{
573 struct pinctrl_dev *pctldev = s->private;
574 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
575 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
576 unsigned i, pin;
577
578 if (!pmxops)
579 return 0;
580
581 seq_puts(s, "Pinmux settings per pin\n");
582 if (pmxops->strict)
583 seq_puts(s,
584 "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n");
585 else
586 seq_puts(s,
587 "Format: pin (name): mux_owner gpio_owner hog?\n");
588
589 mutex_lock(&pctldev->mutex);
590
591 /* The pin number can be retrived from the pin controller descriptor */
592 for (i = 0; i < pctldev->desc->npins; i++) {
593 struct pin_desc *desc;
594 bool is_hog = false;
595
596 pin = pctldev->desc->pins[i].number;
597 desc = pin_desc_get(pctldev, pin);
598 /* Skip if we cannot search the pin */
599 if (desc == NULL)
600 continue;
601
602 if (desc->mux_owner &&
603 !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
604 is_hog = true;
605
606 if (pmxops->strict) {
607 if (desc->mux_owner)
608 seq_printf(s, "pin %d (%s): device %s%s",
609 pin, desc->name, desc->mux_owner,
610 is_hog ? " (HOG)" : "");
611 else if (desc->gpio_owner)
612 seq_printf(s, "pin %d (%s): GPIO %s",
613 pin, desc->name, desc->gpio_owner);
614 else
615 seq_printf(s, "pin %d (%s): UNCLAIMED",
616 pin, desc->name);
617 } else {
618 /* For non-strict controllers */
619 seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name,
620 desc->mux_owner ? desc->mux_owner
621 : "(MUX UNCLAIMED)",
622 desc->gpio_owner ? desc->gpio_owner
623 : "(GPIO UNCLAIMED)",
624 is_hog ? " (HOG)" : "");
625 }
626
627 /* If mux: print function+group claiming the pin */
628 if (desc->mux_setting)
629 seq_printf(s, " function %s group %s\n",
630 pmxops->get_function_name(pctldev,
631 desc->mux_setting->func),
632 pctlops->get_group_name(pctldev,
633 desc->mux_setting->group));
634 else
635 seq_printf(s, "\n");
636 }
637
638 mutex_unlock(&pctldev->mutex);
639
640 return 0;
641}
642
643void pinmux_show_map(struct seq_file *s, struct pinctrl_map const *map)
644{
645 seq_printf(s, "group %s\nfunction %s\n",
646 map->data.mux.group ? map->data.mux.group : "(default)",
647 map->data.mux.function);
648}
649
650void pinmux_show_setting(struct seq_file *s,
651 struct pinctrl_setting const *setting)
652{
653 struct pinctrl_dev *pctldev = setting->pctldev;
654 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
655 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
656
657 seq_printf(s, "group: %s (%u) function: %s (%u)\n",
658 pctlops->get_group_name(pctldev, setting->data.mux.group),
659 setting->data.mux.group,
660 pmxops->get_function_name(pctldev, setting->data.mux.func),
661 setting->data.mux.func);
662}
663
664static int pinmux_functions_open(struct inode *inode, struct file *file)
665{
666 return single_open(file, pinmux_functions_show, inode->i_private);
667}
668
669static int pinmux_pins_open(struct inode *inode, struct file *file)
670{
671 return single_open(file, pinmux_pins_show, inode->i_private);
672}
673
674static const struct file_operations pinmux_functions_ops = {
675 .open = pinmux_functions_open,
676 .read = seq_read,
677 .llseek = seq_lseek,
678 .release = single_release,
679};
680
681static const struct file_operations pinmux_pins_ops = {
682 .open = pinmux_pins_open,
683 .read = seq_read,
684 .llseek = seq_lseek,
685 .release = single_release,
686};
687
688void pinmux_init_device_debugfs(struct dentry *devroot,
689 struct pinctrl_dev *pctldev)
690{
691 debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
692 devroot, pctldev, &pinmux_functions_ops);
693 debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
694 devroot, pctldev, &pinmux_pins_ops);
695}
696
697#endif /* CONFIG_DEBUG_FS */