Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Core driver for the pin muxing portions of the pin control subsystem
4 *
5 * Copyright (C) 2011-2012 ST-Ericsson SA
6 * Written on behalf of Linaro for ST-Ericsson
7 * Based on bits of regulator core, gpio core and clk core
8 *
9 * Author: Linus Walleij <linus.walleij@linaro.org>
10 *
11 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
12 */
13#define pr_fmt(fmt) "pinmux core: " fmt
14
15#include <linux/array_size.h>
16#include <linux/ctype.h>
17#include <linux/cleanup.h>
18#include <linux/debugfs.h>
19#include <linux/device.h>
20#include <linux/err.h>
21#include <linux/init.h>
22#include <linux/list.h>
23#include <linux/module.h>
24#include <linux/radix-tree.h>
25#include <linux/seq_file.h>
26#include <linux/slab.h>
27#include <linux/string.h>
28
29#include <linux/pinctrl/machine.h>
30#include <linux/pinctrl/pinctrl.h>
31#include <linux/pinctrl/pinmux.h>
32
33#include "core.h"
34#include "pinmux.h"
35
36int pinmux_check_ops(struct pinctrl_dev *pctldev)
37{
38 const struct pinmux_ops *ops = pctldev->desc->pmxops;
39 unsigned int nfuncs;
40 unsigned int selector = 0;
41
42 /* Check that we implement required operations */
43 if (!ops ||
44 !ops->get_functions_count ||
45 !ops->get_function_name ||
46 !ops->get_function_groups ||
47 !ops->set_mux) {
48 dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n");
49 return -EINVAL;
50 }
51 /* Check that all functions registered have names */
52 nfuncs = ops->get_functions_count(pctldev);
53 while (selector < nfuncs) {
54 const char *fname = ops->get_function_name(pctldev,
55 selector);
56 if (!fname) {
57 dev_err(pctldev->dev, "pinmux ops has no name for function%u\n",
58 selector);
59 return -EINVAL;
60 }
61 selector++;
62 }
63
64 return 0;
65}
66
67int pinmux_validate_map(const struct pinctrl_map *map, int i)
68{
69 if (!map->data.mux.function) {
70 pr_err("failed to register map %s (%d): no function given\n",
71 map->name, i);
72 return -EINVAL;
73 }
74
75 return 0;
76}
77
78/**
79 * pinmux_can_be_used_for_gpio() - check if a specific pin
80 * is either muxed to a different function or used as gpio.
81 *
82 * @pctldev: the associated pin controller device
83 * @pin: the pin number in the global pin space
84 *
85 * Controllers not defined as strict will always return true,
86 * menaning that the gpio can be used.
87 */
88bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned int pin)
89{
90 struct pin_desc *desc = pin_desc_get(pctldev, pin);
91 const struct pinmux_ops *ops = pctldev->desc->pmxops;
92
93 /* Can't inspect pin, assume it can be used */
94 if (!desc || !ops)
95 return true;
96
97 guard(mutex)(&desc->mux_lock);
98 if (ops->strict && desc->mux_usecount)
99 return false;
100
101 return !(ops->strict && !!desc->gpio_owner);
102}
103
104/**
105 * pin_request() - request a single pin to be muxed in, typically for GPIO
106 * @pctldev: the associated pin controller device
107 * @pin: the pin number in the global pin space
108 * @owner: a representation of the owner of this pin; typically the device
109 * name that controls its mux function, or the requested GPIO name
110 * @gpio_range: the range matching the GPIO pin if this is a request for a
111 * single GPIO pin
112 */
113static int pin_request(struct pinctrl_dev *pctldev,
114 int pin, const char *owner,
115 struct pinctrl_gpio_range *gpio_range)
116{
117 struct pin_desc *desc;
118 const struct pinmux_ops *ops = pctldev->desc->pmxops;
119 int status = -EINVAL;
120
121 desc = pin_desc_get(pctldev, pin);
122 if (desc == NULL) {
123 dev_err(pctldev->dev,
124 "pin %d is not registered so it cannot be requested\n",
125 pin);
126 goto out;
127 }
128
129 dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n",
130 pin, desc->name, owner);
131
132 scoped_guard(mutex, &desc->mux_lock) {
133 if ((!gpio_range || ops->strict) &&
134 desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
135 dev_err(pctldev->dev,
136 "pin %s already requested by %s; cannot claim for %s\n",
137 desc->name, desc->mux_owner, owner);
138 goto out;
139 }
140
141 if ((gpio_range || ops->strict) && desc->gpio_owner) {
142 dev_err(pctldev->dev,
143 "pin %s already requested by %s; cannot claim for %s\n",
144 desc->name, desc->gpio_owner, owner);
145 goto out;
146 }
147
148 if (gpio_range) {
149 desc->gpio_owner = owner;
150 } else {
151 desc->mux_usecount++;
152 if (desc->mux_usecount > 1)
153 return 0;
154
155 desc->mux_owner = owner;
156 }
157 }
158
159 /* Let each pin increase references to this module */
160 if (!try_module_get(pctldev->owner)) {
161 dev_err(pctldev->dev,
162 "could not increase module refcount for pin %d\n",
163 pin);
164 status = -EINVAL;
165 goto out_free_pin;
166 }
167
168 /*
169 * If there is no kind of request function for the pin we just assume
170 * we got it by default and proceed.
171 */
172 if (gpio_range && ops->gpio_request_enable)
173 /* This requests and enables a single GPIO pin */
174 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
175 else if (ops->request)
176 status = ops->request(pctldev, pin);
177 else
178 status = 0;
179
180 if (status)
181 module_put(pctldev->owner);
182
183out_free_pin:
184 if (status) {
185 scoped_guard(mutex, &desc->mux_lock) {
186 if (gpio_range) {
187 desc->gpio_owner = NULL;
188 } else {
189 desc->mux_usecount--;
190 if (!desc->mux_usecount)
191 desc->mux_owner = NULL;
192 }
193 }
194 }
195out:
196 if (status)
197 dev_err_probe(pctldev->dev, status, "pin-%d (%s)\n",
198 pin, owner);
199
200 return status;
201}
202
203/**
204 * pin_free() - release a single muxed in pin so something else can be muxed
205 * @pctldev: pin controller device handling this pin
206 * @pin: the pin to free
207 * @gpio_range: the range matching the GPIO pin if this is a request for a
208 * single GPIO pin
209 *
210 * This function returns a pointer to the previous owner. This is used
211 * for callers that dynamically allocate an owner name so it can be freed
212 * once the pin is free. This is done for GPIO request functions.
213 */
214static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
215 struct pinctrl_gpio_range *gpio_range)
216{
217 const struct pinmux_ops *ops = pctldev->desc->pmxops;
218 struct pin_desc *desc;
219 const char *owner;
220
221 desc = pin_desc_get(pctldev, pin);
222 if (desc == NULL) {
223 dev_err(pctldev->dev,
224 "pin is not registered so it cannot be freed\n");
225 return NULL;
226 }
227
228 scoped_guard(mutex, &desc->mux_lock) {
229 if (!gpio_range) {
230 /*
231 * A pin should not be freed more times than allocated.
232 */
233 if (WARN_ON(!desc->mux_usecount))
234 return NULL;
235 desc->mux_usecount--;
236 if (desc->mux_usecount)
237 return NULL;
238 }
239 }
240
241 /*
242 * If there is no kind of request function for the pin we just assume
243 * we got it by default and proceed.
244 */
245 if (gpio_range && ops->gpio_disable_free)
246 ops->gpio_disable_free(pctldev, gpio_range, pin);
247 else if (ops->free)
248 ops->free(pctldev, pin);
249
250 scoped_guard(mutex, &desc->mux_lock) {
251 if (gpio_range) {
252 owner = desc->gpio_owner;
253 desc->gpio_owner = NULL;
254 } else {
255 owner = desc->mux_owner;
256 desc->mux_owner = NULL;
257 desc->mux_setting = NULL;
258 }
259 }
260
261 module_put(pctldev->owner);
262
263 return owner;
264}
265
266/**
267 * pinmux_request_gpio() - request pinmuxing for a GPIO pin
268 * @pctldev: pin controller device affected
269 * @pin: the pin to mux in for GPIO
270 * @range: the applicable GPIO range
271 * @gpio: number of requested GPIO
272 */
273int pinmux_request_gpio(struct pinctrl_dev *pctldev,
274 struct pinctrl_gpio_range *range,
275 unsigned int pin, unsigned int gpio)
276{
277 const char *owner;
278 int ret;
279
280 /* Conjure some name stating what chip and pin this is taken by */
281 owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
282 if (!owner)
283 return -ENOMEM;
284
285 ret = pin_request(pctldev, pin, owner, range);
286 if (ret < 0)
287 kfree(owner);
288
289 return ret;
290}
291
292/**
293 * pinmux_free_gpio() - release a pin from GPIO muxing
294 * @pctldev: the pin controller device for the pin
295 * @pin: the affected currently GPIO-muxed in pin
296 * @range: applicable GPIO range
297 */
298void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned int pin,
299 struct pinctrl_gpio_range *range)
300{
301 const char *owner;
302
303 owner = pin_free(pctldev, pin, range);
304 kfree(owner);
305}
306
307/**
308 * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
309 * @pctldev: the pin controller handling this pin
310 * @range: applicable GPIO range
311 * @pin: the affected GPIO pin in this controller
312 * @input: true if we set the pin as input, false for output
313 */
314int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
315 struct pinctrl_gpio_range *range,
316 unsigned int pin, bool input)
317{
318 const struct pinmux_ops *ops;
319 int ret;
320
321 ops = pctldev->desc->pmxops;
322
323 if (ops->gpio_set_direction)
324 ret = ops->gpio_set_direction(pctldev, range, pin, input);
325 else
326 ret = 0;
327
328 return ret;
329}
330
331static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
332 const char *function)
333{
334 const struct pinmux_ops *ops = pctldev->desc->pmxops;
335 unsigned int nfuncs = ops->get_functions_count(pctldev);
336 unsigned int selector = 0;
337
338 /* See if this pctldev has this function */
339 while (selector < nfuncs) {
340 const char *fname = ops->get_function_name(pctldev, selector);
341
342 if (!strcmp(function, fname))
343 return selector;
344
345 selector++;
346 }
347
348 return -EINVAL;
349}
350
351int pinmux_map_to_setting(const struct pinctrl_map *map,
352 struct pinctrl_setting *setting)
353{
354 struct pinctrl_dev *pctldev = setting->pctldev;
355 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
356 char const * const *groups;
357 unsigned int num_groups;
358 int ret;
359 const char *group;
360
361 if (!pmxops) {
362 dev_err(pctldev->dev, "does not support mux function\n");
363 return -EINVAL;
364 }
365
366 ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
367 if (ret < 0) {
368 dev_err(pctldev->dev, "invalid function %s in map table\n",
369 map->data.mux.function);
370 return ret;
371 }
372 setting->data.mux.func = ret;
373
374 ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
375 &groups, &num_groups);
376 if (ret < 0) {
377 dev_err(pctldev->dev, "can't query groups for function %s\n",
378 map->data.mux.function);
379 return ret;
380 }
381 if (!num_groups) {
382 dev_err(pctldev->dev,
383 "function %s can't be selected on any group\n",
384 map->data.mux.function);
385 return -EINVAL;
386 }
387 if (map->data.mux.group) {
388 group = map->data.mux.group;
389 ret = match_string(groups, num_groups, group);
390 if (ret < 0) {
391 dev_err(pctldev->dev,
392 "invalid group \"%s\" for function \"%s\"\n",
393 group, map->data.mux.function);
394 return ret;
395 }
396 } else {
397 group = groups[0];
398 }
399
400 ret = pinctrl_get_group_selector(pctldev, group);
401 if (ret < 0) {
402 dev_err(pctldev->dev, "invalid group %s in map table\n",
403 map->data.mux.group);
404 return ret;
405 }
406 setting->data.mux.group = ret;
407
408 return 0;
409}
410
411void pinmux_free_setting(const struct pinctrl_setting *setting)
412{
413 /* This function is currently unused */
414}
415
416int pinmux_enable_setting(const struct pinctrl_setting *setting)
417{
418 struct pinctrl_dev *pctldev = setting->pctldev;
419 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
420 const struct pinmux_ops *ops = pctldev->desc->pmxops;
421 int ret = 0;
422 const unsigned int *pins = NULL;
423 unsigned int num_pins = 0;
424 int i;
425 struct pin_desc *desc;
426
427 if (pctlops->get_group_pins)
428 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
429 &pins, &num_pins);
430
431 if (ret) {
432 const char *gname;
433
434 /* errors only affect debug data, so just warn */
435 gname = pctlops->get_group_name(pctldev,
436 setting->data.mux.group);
437 dev_warn(pctldev->dev,
438 "could not get pins for group %s\n",
439 gname);
440 num_pins = 0;
441 }
442
443 /* Try to allocate all pins in this group, one by one */
444 for (i = 0; i < num_pins; i++) {
445 ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
446 if (ret) {
447 const char *gname;
448 const char *pname;
449
450 desc = pin_desc_get(pctldev, pins[i]);
451 pname = desc ? desc->name : "non-existing";
452 gname = pctlops->get_group_name(pctldev,
453 setting->data.mux.group);
454 dev_err_probe(pctldev->dev, ret,
455 "could not request pin %d (%s) from group %s on device %s\n",
456 pins[i], pname, gname,
457 pinctrl_dev_get_name(pctldev));
458 goto err_pin_request;
459 }
460 }
461
462 /* Now that we have acquired the pins, encode the mux setting */
463 for (i = 0; i < num_pins; i++) {
464 desc = pin_desc_get(pctldev, pins[i]);
465 if (desc == NULL) {
466 dev_warn(pctldev->dev,
467 "could not get pin desc for pin %d\n",
468 pins[i]);
469 continue;
470 }
471 scoped_guard(mutex, &desc->mux_lock)
472 desc->mux_setting = &(setting->data.mux);
473 }
474
475 ret = ops->set_mux(pctldev, setting->data.mux.func,
476 setting->data.mux.group);
477
478 if (ret)
479 goto err_set_mux;
480
481 return 0;
482
483err_set_mux:
484 for (i = 0; i < num_pins; i++) {
485 desc = pin_desc_get(pctldev, pins[i]);
486 if (desc) {
487 scoped_guard(mutex, &desc->mux_lock)
488 desc->mux_setting = NULL;
489 }
490 }
491err_pin_request:
492 /* On error release all taken pins */
493 while (--i >= 0)
494 pin_free(pctldev, pins[i], NULL);
495
496 return ret;
497}
498
499void pinmux_disable_setting(const struct pinctrl_setting *setting)
500{
501 struct pinctrl_dev *pctldev = setting->pctldev;
502 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
503 int ret = 0;
504 const unsigned int *pins = NULL;
505 unsigned int num_pins = 0;
506 int i;
507 struct pin_desc *desc;
508 bool is_equal;
509
510 if (pctlops->get_group_pins)
511 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
512 &pins, &num_pins);
513 if (ret) {
514 const char *gname;
515
516 /* errors only affect debug data, so just warn */
517 gname = pctlops->get_group_name(pctldev,
518 setting->data.mux.group);
519 dev_warn(pctldev->dev,
520 "could not get pins for group %s\n",
521 gname);
522 num_pins = 0;
523 }
524
525 /* Flag the descs that no setting is active */
526 for (i = 0; i < num_pins; i++) {
527 desc = pin_desc_get(pctldev, pins[i]);
528 if (desc == NULL) {
529 dev_warn(pctldev->dev,
530 "could not get pin desc for pin %d\n",
531 pins[i]);
532 continue;
533 }
534 scoped_guard(mutex, &desc->mux_lock)
535 is_equal = (desc->mux_setting == &(setting->data.mux));
536
537 if (is_equal) {
538 pin_free(pctldev, pins[i], NULL);
539 } else {
540 const char *gname;
541
542 gname = pctlops->get_group_name(pctldev,
543 setting->data.mux.group);
544 dev_warn(pctldev->dev,
545 "not freeing pin %d (%s) as part of deactivating group %s - it is already used for some other setting",
546 pins[i], desc->name, gname);
547 }
548 }
549}
550
551#ifdef CONFIG_DEBUG_FS
552
553/* Called from pincontrol core */
554static int pinmux_functions_show(struct seq_file *s, void *what)
555{
556 struct pinctrl_dev *pctldev = s->private;
557 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
558 unsigned int nfuncs;
559 unsigned int func_selector = 0;
560
561 if (!pmxops)
562 return 0;
563
564 mutex_lock(&pctldev->mutex);
565 nfuncs = pmxops->get_functions_count(pctldev);
566 while (func_selector < nfuncs) {
567 const char *func = pmxops->get_function_name(pctldev,
568 func_selector);
569 const char * const *groups;
570 unsigned int num_groups;
571 int ret;
572 int i;
573
574 ret = pmxops->get_function_groups(pctldev, func_selector,
575 &groups, &num_groups);
576 if (ret) {
577 seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
578 func);
579 func_selector++;
580 continue;
581 }
582
583 seq_printf(s, "function %d: %s, groups = [ ", func_selector, func);
584 for (i = 0; i < num_groups; i++)
585 seq_printf(s, "%s ", groups[i]);
586 seq_puts(s, "]\n");
587
588 func_selector++;
589 }
590
591 mutex_unlock(&pctldev->mutex);
592
593 return 0;
594}
595DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
596
597static int pinmux_pins_show(struct seq_file *s, void *what)
598{
599 struct pinctrl_dev *pctldev = s->private;
600 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
601 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
602 unsigned int i, pin;
603
604 if (!pmxops)
605 return 0;
606
607 seq_puts(s, "Pinmux settings per pin\n");
608 if (pmxops->strict)
609 seq_puts(s,
610 "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n");
611 else
612 seq_puts(s,
613 "Format: pin (name): mux_owner gpio_owner hog?\n");
614
615 mutex_lock(&pctldev->mutex);
616
617 /* The pin number can be retrived from the pin controller descriptor */
618 for (i = 0; i < pctldev->desc->npins; i++) {
619 struct pin_desc *desc;
620 bool is_hog = false;
621
622 pin = pctldev->desc->pins[i].number;
623 desc = pin_desc_get(pctldev, pin);
624 /* Skip if we cannot search the pin */
625 if (desc == NULL)
626 continue;
627
628 scoped_guard(mutex, &desc->mux_lock) {
629 if (desc->mux_owner &&
630 !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
631 is_hog = true;
632
633 if (pmxops->strict) {
634 if (desc->mux_owner)
635 seq_printf(s, "pin %d (%s): device %s%s",
636 pin, desc->name, desc->mux_owner,
637 is_hog ? " (HOG)" : "");
638 else if (desc->gpio_owner)
639 seq_printf(s, "pin %d (%s): GPIO %s",
640 pin, desc->name, desc->gpio_owner);
641 else
642 seq_printf(s, "pin %d (%s): UNCLAIMED",
643 pin, desc->name);
644 } else {
645 /* For non-strict controllers */
646 seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name,
647 desc->mux_owner ? desc->mux_owner
648 : "(MUX UNCLAIMED)",
649 desc->gpio_owner ? desc->gpio_owner
650 : "(GPIO UNCLAIMED)",
651 is_hog ? " (HOG)" : "");
652 }
653
654 /* If mux: print function+group claiming the pin */
655 if (desc->mux_setting)
656 seq_printf(s, " function %s group %s\n",
657 pmxops->get_function_name(pctldev,
658 desc->mux_setting->func),
659 pctlops->get_group_name(pctldev,
660 desc->mux_setting->group));
661 else
662 seq_putc(s, '\n');
663 }
664 }
665
666 mutex_unlock(&pctldev->mutex);
667
668 return 0;
669}
670DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
671
672void pinmux_show_map(struct seq_file *s, const struct pinctrl_map *map)
673{
674 seq_printf(s, "group %s\nfunction %s\n",
675 map->data.mux.group ? map->data.mux.group : "(default)",
676 map->data.mux.function);
677}
678
679void pinmux_show_setting(struct seq_file *s,
680 const struct pinctrl_setting *setting)
681{
682 struct pinctrl_dev *pctldev = setting->pctldev;
683 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
684 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
685
686 seq_printf(s, "group: %s (%u) function: %s (%u)\n",
687 pctlops->get_group_name(pctldev, setting->data.mux.group),
688 setting->data.mux.group,
689 pmxops->get_function_name(pctldev, setting->data.mux.func),
690 setting->data.mux.func);
691}
692
693static int pinmux_select_show(struct seq_file *s, void *unused)
694{
695 return -EPERM;
696}
697
698static ssize_t pinmux_select_write(struct file *file, const char __user *user_buf,
699 size_t len, loff_t *ppos)
700{
701 struct seq_file *sfile = file->private_data;
702 struct pinctrl_dev *pctldev = sfile->private;
703 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
704 const char *const *groups;
705 char *buf, *gname, *fname;
706 unsigned int num_groups;
707 int fsel, gsel, ret;
708
709 buf = memdup_user_nul(user_buf, len);
710 if (IS_ERR(buf))
711 return PTR_ERR(buf);
712
713 /* remove leading and trailing spaces of input buffer */
714 gname = strstrip(buf);
715 if (*gname == '\0') {
716 ret = -EINVAL;
717 goto exit_free_buf;
718 }
719
720 /* find a separator which is a spacelike character */
721 for (fname = gname; !isspace(*fname); fname++) {
722 if (*fname == '\0') {
723 ret = -EINVAL;
724 goto exit_free_buf;
725 }
726 }
727 *fname = '\0';
728
729 /* drop extra spaces between function and group names */
730 fname = skip_spaces(fname + 1);
731 if (*fname == '\0') {
732 ret = -EINVAL;
733 goto exit_free_buf;
734 }
735
736 ret = pinmux_func_name_to_selector(pctldev, fname);
737 if (ret < 0) {
738 dev_err(pctldev->dev, "invalid function %s in map table\n", fname);
739 goto exit_free_buf;
740 }
741 fsel = ret;
742
743 ret = pmxops->get_function_groups(pctldev, fsel, &groups, &num_groups);
744 if (ret) {
745 dev_err(pctldev->dev, "no groups for function %d (%s)", fsel, fname);
746 goto exit_free_buf;
747 }
748
749 ret = match_string(groups, num_groups, gname);
750 if (ret < 0) {
751 dev_err(pctldev->dev, "invalid group %s", gname);
752 goto exit_free_buf;
753 }
754
755 ret = pinctrl_get_group_selector(pctldev, gname);
756 if (ret < 0)
757 goto exit_free_buf;
758 gsel = ret;
759
760 ret = pmxops->set_mux(pctldev, fsel, gsel);
761 if (ret) {
762 dev_err(pctldev->dev, "set_mux() failed: %d", ret);
763 goto exit_free_buf;
764 }
765 ret = len;
766
767exit_free_buf:
768 kfree(buf);
769
770 return ret;
771}
772DEFINE_SHOW_STORE_ATTRIBUTE(pinmux_select);
773
774void pinmux_init_device_debugfs(struct dentry *devroot,
775 struct pinctrl_dev *pctldev)
776{
777 debugfs_create_file("pinmux-functions", 0444,
778 devroot, pctldev, &pinmux_functions_fops);
779 debugfs_create_file("pinmux-pins", 0444,
780 devroot, pctldev, &pinmux_pins_fops);
781 debugfs_create_file("pinmux-select", 0200,
782 devroot, pctldev, &pinmux_select_fops);
783}
784
785#endif /* CONFIG_DEBUG_FS */
786
787#ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
788
789/**
790 * pinmux_generic_get_function_count() - returns number of functions
791 * @pctldev: pin controller device
792 */
793int pinmux_generic_get_function_count(struct pinctrl_dev *pctldev)
794{
795 return pctldev->num_functions;
796}
797EXPORT_SYMBOL_GPL(pinmux_generic_get_function_count);
798
799/**
800 * pinmux_generic_get_function_name() - returns the function name
801 * @pctldev: pin controller device
802 * @selector: function number
803 */
804const char *
805pinmux_generic_get_function_name(struct pinctrl_dev *pctldev,
806 unsigned int selector)
807{
808 struct function_desc *function;
809
810 function = radix_tree_lookup(&pctldev->pin_function_tree,
811 selector);
812 if (!function)
813 return NULL;
814
815 return function->func.name;
816}
817EXPORT_SYMBOL_GPL(pinmux_generic_get_function_name);
818
819/**
820 * pinmux_generic_get_function_groups() - gets the function groups
821 * @pctldev: pin controller device
822 * @selector: function number
823 * @groups: array of pin groups
824 * @ngroups: number of pin groups
825 */
826int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev,
827 unsigned int selector,
828 const char * const **groups,
829 unsigned int * const ngroups)
830{
831 struct function_desc *function;
832
833 function = radix_tree_lookup(&pctldev->pin_function_tree,
834 selector);
835 if (!function) {
836 dev_err(pctldev->dev, "%s could not find function%i\n",
837 __func__, selector);
838 return -EINVAL;
839 }
840 *groups = function->func.groups;
841 *ngroups = function->func.ngroups;
842
843 return 0;
844}
845EXPORT_SYMBOL_GPL(pinmux_generic_get_function_groups);
846
847/**
848 * pinmux_generic_get_function() - returns a function based on the number
849 * @pctldev: pin controller device
850 * @selector: function number
851 */
852struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev,
853 unsigned int selector)
854{
855 struct function_desc *function;
856
857 function = radix_tree_lookup(&pctldev->pin_function_tree,
858 selector);
859 if (!function)
860 return NULL;
861
862 return function;
863}
864EXPORT_SYMBOL_GPL(pinmux_generic_get_function);
865
866/**
867 * pinmux_generic_add_function() - adds a function group
868 * @pctldev: pin controller device
869 * @name: name of the function
870 * @groups: array of pin groups
871 * @ngroups: number of pin groups
872 * @data: pin controller driver specific data
873 */
874int pinmux_generic_add_function(struct pinctrl_dev *pctldev,
875 const char *name,
876 const char * const *groups,
877 const unsigned int ngroups,
878 void *data)
879{
880 struct function_desc *function;
881 int selector, error;
882
883 if (!name)
884 return -EINVAL;
885
886 selector = pinmux_func_name_to_selector(pctldev, name);
887 if (selector >= 0)
888 return selector;
889
890 selector = pctldev->num_functions;
891
892 function = devm_kzalloc(pctldev->dev, sizeof(*function), GFP_KERNEL);
893 if (!function)
894 return -ENOMEM;
895
896 *function = PINCTRL_FUNCTION_DESC(name, groups, ngroups, data);
897
898 error = radix_tree_insert(&pctldev->pin_function_tree, selector, function);
899 if (error)
900 return error;
901
902 pctldev->num_functions++;
903
904 return selector;
905}
906EXPORT_SYMBOL_GPL(pinmux_generic_add_function);
907
908/**
909 * pinmux_generic_remove_function() - removes a numbered function
910 * @pctldev: pin controller device
911 * @selector: function number
912 *
913 * Note that the caller must take care of locking.
914 */
915int pinmux_generic_remove_function(struct pinctrl_dev *pctldev,
916 unsigned int selector)
917{
918 struct function_desc *function;
919
920 function = radix_tree_lookup(&pctldev->pin_function_tree,
921 selector);
922 if (!function)
923 return -ENOENT;
924
925 radix_tree_delete(&pctldev->pin_function_tree, selector);
926 devm_kfree(pctldev->dev, function);
927
928 pctldev->num_functions--;
929
930 return 0;
931}
932EXPORT_SYMBOL_GPL(pinmux_generic_remove_function);
933
934/**
935 * pinmux_generic_free_functions() - removes all functions
936 * @pctldev: pin controller device
937 *
938 * Note that the caller must take care of locking. The pinctrl
939 * functions are allocated with devm_kzalloc() so no need to free
940 * them here.
941 */
942void pinmux_generic_free_functions(struct pinctrl_dev *pctldev)
943{
944 struct radix_tree_iter iter;
945 void __rcu **slot;
946
947 radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0)
948 radix_tree_delete(&pctldev->pin_function_tree, iter.index);
949
950 pctldev->num_functions = 0;
951}
952
953#endif /* CONFIG_GENERIC_PINMUX_FUNCTIONS */