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(const struct pinctrl_map *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 || ops->strict) &&
103 desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
104 dev_err(pctldev->dev,
105 "pin %s already requested by %s; cannot claim for %s\n",
106 desc->name, desc->mux_owner, owner);
107 goto out;
108 }
109
110 if ((gpio_range || ops->strict) && desc->gpio_owner) {
111 dev_err(pctldev->dev,
112 "pin %s already requested by %s; cannot claim for %s\n",
113 desc->name, desc->gpio_owner, owner);
114 goto out;
115 }
116
117 if (gpio_range) {
118 desc->gpio_owner = owner;
119 } else {
120 desc->mux_usecount++;
121 if (desc->mux_usecount > 1)
122 return 0;
123
124 desc->mux_owner = owner;
125 }
126
127 /* Let each pin increase references to this module */
128 if (!try_module_get(pctldev->owner)) {
129 dev_err(pctldev->dev,
130 "could not increase module refcount for pin %d\n",
131 pin);
132 status = -EINVAL;
133 goto out_free_pin;
134 }
135
136 /*
137 * If there is no kind of request function for the pin we just assume
138 * we got it by default and proceed.
139 */
140 if (gpio_range && ops->gpio_request_enable)
141 /* This requests and enables a single GPIO pin */
142 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
143 else if (ops->request)
144 status = ops->request(pctldev, pin);
145 else
146 status = 0;
147
148 if (status) {
149 dev_err(pctldev->dev, "request() failed for pin %d\n", pin);
150 module_put(pctldev->owner);
151 }
152
153out_free_pin:
154 if (status) {
155 if (gpio_range) {
156 desc->gpio_owner = NULL;
157 } else {
158 desc->mux_usecount--;
159 if (!desc->mux_usecount)
160 desc->mux_owner = NULL;
161 }
162 }
163out:
164 if (status)
165 dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
166 pin, owner, status);
167
168 return status;
169}
170
171/**
172 * pin_free() - release a single muxed in pin so something else can be muxed
173 * @pctldev: pin controller device handling this pin
174 * @pin: the pin to free
175 * @gpio_range: the range matching the GPIO pin if this is a request for a
176 * single GPIO pin
177 *
178 * This function returns a pointer to the previous owner. This is used
179 * for callers that dynamically allocate an owner name so it can be freed
180 * once the pin is free. This is done for GPIO request functions.
181 */
182static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
183 struct pinctrl_gpio_range *gpio_range)
184{
185 const struct pinmux_ops *ops = pctldev->desc->pmxops;
186 struct pin_desc *desc;
187 const char *owner;
188
189 desc = pin_desc_get(pctldev, pin);
190 if (desc == NULL) {
191 dev_err(pctldev->dev,
192 "pin is not registered so it cannot be freed\n");
193 return NULL;
194 }
195
196 if (!gpio_range) {
197 /*
198 * A pin should not be freed more times than allocated.
199 */
200 if (WARN_ON(!desc->mux_usecount))
201 return NULL;
202 desc->mux_usecount--;
203 if (desc->mux_usecount)
204 return NULL;
205 }
206
207 /*
208 * If there is no kind of request function for the pin we just assume
209 * we got it by default and proceed.
210 */
211 if (gpio_range && ops->gpio_disable_free)
212 ops->gpio_disable_free(pctldev, gpio_range, pin);
213 else if (ops->free)
214 ops->free(pctldev, pin);
215
216 if (gpio_range) {
217 owner = desc->gpio_owner;
218 desc->gpio_owner = NULL;
219 } else {
220 owner = desc->mux_owner;
221 desc->mux_owner = NULL;
222 desc->mux_setting = NULL;
223 }
224
225 module_put(pctldev->owner);
226
227 return owner;
228}
229
230/**
231 * pinmux_request_gpio() - request pinmuxing for a GPIO pin
232 * @pctldev: pin controller device affected
233 * @pin: the pin to mux in for GPIO
234 * @range: the applicable GPIO range
235 */
236int pinmux_request_gpio(struct pinctrl_dev *pctldev,
237 struct pinctrl_gpio_range *range,
238 unsigned pin, unsigned gpio)
239{
240 const char *owner;
241 int ret;
242
243 /* Conjure some name stating what chip and pin this is taken by */
244 owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
245 if (!owner)
246 return -ENOMEM;
247
248 ret = pin_request(pctldev, pin, owner, range);
249 if (ret < 0)
250 kfree(owner);
251
252 return ret;
253}
254
255/**
256 * pinmux_free_gpio() - release a pin from GPIO muxing
257 * @pctldev: the pin controller device for the pin
258 * @pin: the affected currently GPIO-muxed in pin
259 * @range: applicable GPIO range
260 */
261void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
262 struct pinctrl_gpio_range *range)
263{
264 const char *owner;
265
266 owner = pin_free(pctldev, pin, range);
267 kfree(owner);
268}
269
270/**
271 * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
272 * @pctldev: the pin controller handling this pin
273 * @range: applicable GPIO range
274 * @pin: the affected GPIO pin in this controller
275 * @input: true if we set the pin as input, false for output
276 */
277int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
278 struct pinctrl_gpio_range *range,
279 unsigned pin, bool input)
280{
281 const struct pinmux_ops *ops;
282 int ret;
283
284 ops = pctldev->desc->pmxops;
285
286 if (ops->gpio_set_direction)
287 ret = ops->gpio_set_direction(pctldev, range, pin, input);
288 else
289 ret = 0;
290
291 return ret;
292}
293
294static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
295 const char *function)
296{
297 const struct pinmux_ops *ops = pctldev->desc->pmxops;
298 unsigned nfuncs = ops->get_functions_count(pctldev);
299 unsigned selector = 0;
300
301 /* See if this pctldev has this function */
302 while (selector < nfuncs) {
303 const char *fname = ops->get_function_name(pctldev, selector);
304
305 if (!strcmp(function, fname))
306 return selector;
307
308 selector++;
309 }
310
311 dev_err(pctldev->dev, "function '%s' not supported\n", function);
312 return -EINVAL;
313}
314
315int pinmux_map_to_setting(const struct pinctrl_map *map,
316 struct pinctrl_setting *setting)
317{
318 struct pinctrl_dev *pctldev = setting->pctldev;
319 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
320 char const * const *groups;
321 unsigned num_groups;
322 int ret;
323 const char *group;
324
325 if (!pmxops) {
326 dev_err(pctldev->dev, "does not support mux function\n");
327 return -EINVAL;
328 }
329
330 ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
331 if (ret < 0) {
332 dev_err(pctldev->dev, "invalid function %s in map table\n",
333 map->data.mux.function);
334 return ret;
335 }
336 setting->data.mux.func = ret;
337
338 ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
339 &groups, &num_groups);
340 if (ret < 0) {
341 dev_err(pctldev->dev, "can't query groups for function %s\n",
342 map->data.mux.function);
343 return ret;
344 }
345 if (!num_groups) {
346 dev_err(pctldev->dev,
347 "function %s can't be selected on any group\n",
348 map->data.mux.function);
349 return -EINVAL;
350 }
351 if (map->data.mux.group) {
352 group = map->data.mux.group;
353 ret = match_string(groups, num_groups, group);
354 if (ret < 0) {
355 dev_err(pctldev->dev,
356 "invalid group \"%s\" for function \"%s\"\n",
357 group, map->data.mux.function);
358 return ret;
359 }
360 } else {
361 group = groups[0];
362 }
363
364 ret = pinctrl_get_group_selector(pctldev, group);
365 if (ret < 0) {
366 dev_err(pctldev->dev, "invalid group %s in map table\n",
367 map->data.mux.group);
368 return ret;
369 }
370 setting->data.mux.group = ret;
371
372 return 0;
373}
374
375void pinmux_free_setting(const struct pinctrl_setting *setting)
376{
377 /* This function is currently unused */
378}
379
380int pinmux_enable_setting(const struct pinctrl_setting *setting)
381{
382 struct pinctrl_dev *pctldev = setting->pctldev;
383 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
384 const struct pinmux_ops *ops = pctldev->desc->pmxops;
385 int ret = 0;
386 const unsigned *pins = NULL;
387 unsigned num_pins = 0;
388 int i;
389 struct pin_desc *desc;
390
391 if (pctlops->get_group_pins)
392 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
393 &pins, &num_pins);
394
395 if (ret) {
396 const char *gname;
397
398 /* errors only affect debug data, so just warn */
399 gname = pctlops->get_group_name(pctldev,
400 setting->data.mux.group);
401 dev_warn(pctldev->dev,
402 "could not get pins for group %s\n",
403 gname);
404 num_pins = 0;
405 }
406
407 /* Try to allocate all pins in this group, one by one */
408 for (i = 0; i < num_pins; i++) {
409 ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
410 if (ret) {
411 const char *gname;
412 const char *pname;
413
414 desc = pin_desc_get(pctldev, pins[i]);
415 pname = desc ? desc->name : "non-existing";
416 gname = pctlops->get_group_name(pctldev,
417 setting->data.mux.group);
418 dev_err(pctldev->dev,
419 "could not request pin %d (%s) from group %s "
420 " on device %s\n",
421 pins[i], pname, gname,
422 pinctrl_dev_get_name(pctldev));
423 goto err_pin_request;
424 }
425 }
426
427 /* Now that we have acquired the pins, encode the mux setting */
428 for (i = 0; i < num_pins; i++) {
429 desc = pin_desc_get(pctldev, pins[i]);
430 if (desc == NULL) {
431 dev_warn(pctldev->dev,
432 "could not get pin desc for pin %d\n",
433 pins[i]);
434 continue;
435 }
436 desc->mux_setting = &(setting->data.mux);
437 }
438
439 ret = ops->set_mux(pctldev, setting->data.mux.func,
440 setting->data.mux.group);
441
442 if (ret)
443 goto err_set_mux;
444
445 return 0;
446
447err_set_mux:
448 for (i = 0; i < num_pins; i++) {
449 desc = pin_desc_get(pctldev, pins[i]);
450 if (desc)
451 desc->mux_setting = NULL;
452 }
453err_pin_request:
454 /* On error release all taken pins */
455 while (--i >= 0)
456 pin_free(pctldev, pins[i], NULL);
457
458 return ret;
459}
460
461void pinmux_disable_setting(const struct pinctrl_setting *setting)
462{
463 struct pinctrl_dev *pctldev = setting->pctldev;
464 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
465 int ret = 0;
466 const unsigned *pins = NULL;
467 unsigned num_pins = 0;
468 int i;
469 struct pin_desc *desc;
470
471 if (pctlops->get_group_pins)
472 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
473 &pins, &num_pins);
474 if (ret) {
475 const char *gname;
476
477 /* errors only affect debug data, so just warn */
478 gname = pctlops->get_group_name(pctldev,
479 setting->data.mux.group);
480 dev_warn(pctldev->dev,
481 "could not get pins for group %s\n",
482 gname);
483 num_pins = 0;
484 }
485
486 /* Flag the descs that no setting is active */
487 for (i = 0; i < num_pins; i++) {
488 desc = pin_desc_get(pctldev, pins[i]);
489 if (desc == NULL) {
490 dev_warn(pctldev->dev,
491 "could not get pin desc for pin %d\n",
492 pins[i]);
493 continue;
494 }
495 if (desc->mux_setting == &(setting->data.mux)) {
496 pin_free(pctldev, pins[i], NULL);
497 } else {
498 const char *gname;
499
500 gname = pctlops->get_group_name(pctldev,
501 setting->data.mux.group);
502 dev_warn(pctldev->dev,
503 "not freeing pin %d (%s) as part of "
504 "deactivating group %s - it is already "
505 "used for some other setting",
506 pins[i], desc->name, gname);
507 }
508 }
509}
510
511#ifdef CONFIG_DEBUG_FS
512
513/* Called from pincontrol core */
514static int pinmux_functions_show(struct seq_file *s, void *what)
515{
516 struct pinctrl_dev *pctldev = s->private;
517 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
518 unsigned nfuncs;
519 unsigned func_selector = 0;
520
521 if (!pmxops)
522 return 0;
523
524 mutex_lock(&pctldev->mutex);
525 nfuncs = pmxops->get_functions_count(pctldev);
526 while (func_selector < nfuncs) {
527 const char *func = pmxops->get_function_name(pctldev,
528 func_selector);
529 const char * const *groups;
530 unsigned num_groups;
531 int ret;
532 int i;
533
534 ret = pmxops->get_function_groups(pctldev, func_selector,
535 &groups, &num_groups);
536 if (ret) {
537 seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
538 func);
539 func_selector++;
540 continue;
541 }
542
543 seq_printf(s, "function: %s, groups = [ ", func);
544 for (i = 0; i < num_groups; i++)
545 seq_printf(s, "%s ", groups[i]);
546 seq_puts(s, "]\n");
547
548 func_selector++;
549 }
550
551 mutex_unlock(&pctldev->mutex);
552
553 return 0;
554}
555
556static int pinmux_pins_show(struct seq_file *s, void *what)
557{
558 struct pinctrl_dev *pctldev = s->private;
559 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
560 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
561 unsigned i, pin;
562
563 if (!pmxops)
564 return 0;
565
566 seq_puts(s, "Pinmux settings per pin\n");
567 if (pmxops->strict)
568 seq_puts(s,
569 "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n");
570 else
571 seq_puts(s,
572 "Format: pin (name): mux_owner gpio_owner hog?\n");
573
574 mutex_lock(&pctldev->mutex);
575
576 /* The pin number can be retrived from the pin controller descriptor */
577 for (i = 0; i < pctldev->desc->npins; i++) {
578 struct pin_desc *desc;
579 bool is_hog = false;
580
581 pin = pctldev->desc->pins[i].number;
582 desc = pin_desc_get(pctldev, pin);
583 /* Skip if we cannot search the pin */
584 if (desc == NULL)
585 continue;
586
587 if (desc->mux_owner &&
588 !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
589 is_hog = true;
590
591 if (pmxops->strict) {
592 if (desc->mux_owner)
593 seq_printf(s, "pin %d (%s): device %s%s",
594 pin, desc->name, desc->mux_owner,
595 is_hog ? " (HOG)" : "");
596 else if (desc->gpio_owner)
597 seq_printf(s, "pin %d (%s): GPIO %s",
598 pin, desc->name, desc->gpio_owner);
599 else
600 seq_printf(s, "pin %d (%s): UNCLAIMED",
601 pin, desc->name);
602 } else {
603 /* For non-strict controllers */
604 seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name,
605 desc->mux_owner ? desc->mux_owner
606 : "(MUX UNCLAIMED)",
607 desc->gpio_owner ? desc->gpio_owner
608 : "(GPIO UNCLAIMED)",
609 is_hog ? " (HOG)" : "");
610 }
611
612 /* If mux: print function+group claiming the pin */
613 if (desc->mux_setting)
614 seq_printf(s, " function %s group %s\n",
615 pmxops->get_function_name(pctldev,
616 desc->mux_setting->func),
617 pctlops->get_group_name(pctldev,
618 desc->mux_setting->group));
619 else
620 seq_putc(s, '\n');
621 }
622
623 mutex_unlock(&pctldev->mutex);
624
625 return 0;
626}
627
628void pinmux_show_map(struct seq_file *s, const struct pinctrl_map *map)
629{
630 seq_printf(s, "group %s\nfunction %s\n",
631 map->data.mux.group ? map->data.mux.group : "(default)",
632 map->data.mux.function);
633}
634
635void pinmux_show_setting(struct seq_file *s,
636 const struct pinctrl_setting *setting)
637{
638 struct pinctrl_dev *pctldev = setting->pctldev;
639 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
640 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
641
642 seq_printf(s, "group: %s (%u) function: %s (%u)\n",
643 pctlops->get_group_name(pctldev, setting->data.mux.group),
644 setting->data.mux.group,
645 pmxops->get_function_name(pctldev, setting->data.mux.func),
646 setting->data.mux.func);
647}
648
649static int pinmux_functions_open(struct inode *inode, struct file *file)
650{
651 return single_open(file, pinmux_functions_show, inode->i_private);
652}
653
654static int pinmux_pins_open(struct inode *inode, struct file *file)
655{
656 return single_open(file, pinmux_pins_show, inode->i_private);
657}
658
659static const struct file_operations pinmux_functions_ops = {
660 .open = pinmux_functions_open,
661 .read = seq_read,
662 .llseek = seq_lseek,
663 .release = single_release,
664};
665
666static const struct file_operations pinmux_pins_ops = {
667 .open = pinmux_pins_open,
668 .read = seq_read,
669 .llseek = seq_lseek,
670 .release = single_release,
671};
672
673void pinmux_init_device_debugfs(struct dentry *devroot,
674 struct pinctrl_dev *pctldev)
675{
676 debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
677 devroot, pctldev, &pinmux_functions_ops);
678 debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
679 devroot, pctldev, &pinmux_pins_ops);
680}
681
682#endif /* CONFIG_DEBUG_FS */
683
684#ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
685
686/**
687 * pinmux_generic_get_function_count() - returns number of functions
688 * @pctldev: pin controller device
689 */
690int pinmux_generic_get_function_count(struct pinctrl_dev *pctldev)
691{
692 return pctldev->num_functions;
693}
694EXPORT_SYMBOL_GPL(pinmux_generic_get_function_count);
695
696/**
697 * pinmux_generic_get_function_name() - returns the function name
698 * @pctldev: pin controller device
699 * @selector: function number
700 */
701const char *
702pinmux_generic_get_function_name(struct pinctrl_dev *pctldev,
703 unsigned int selector)
704{
705 struct function_desc *function;
706
707 function = radix_tree_lookup(&pctldev->pin_function_tree,
708 selector);
709 if (!function)
710 return NULL;
711
712 return function->name;
713}
714EXPORT_SYMBOL_GPL(pinmux_generic_get_function_name);
715
716/**
717 * pinmux_generic_get_function_groups() - gets the function groups
718 * @pctldev: pin controller device
719 * @selector: function number
720 * @groups: array of pin groups
721 * @num_groups: number of pin groups
722 */
723int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev,
724 unsigned int selector,
725 const char * const **groups,
726 unsigned * const num_groups)
727{
728 struct function_desc *function;
729
730 function = radix_tree_lookup(&pctldev->pin_function_tree,
731 selector);
732 if (!function) {
733 dev_err(pctldev->dev, "%s could not find function%i\n",
734 __func__, selector);
735 return -EINVAL;
736 }
737 *groups = function->group_names;
738 *num_groups = function->num_group_names;
739
740 return 0;
741}
742EXPORT_SYMBOL_GPL(pinmux_generic_get_function_groups);
743
744/**
745 * pinmux_generic_get_function() - returns a function based on the number
746 * @pctldev: pin controller device
747 * @group_selector: function number
748 */
749struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev,
750 unsigned int selector)
751{
752 struct function_desc *function;
753
754 function = radix_tree_lookup(&pctldev->pin_function_tree,
755 selector);
756 if (!function)
757 return NULL;
758
759 return function;
760}
761EXPORT_SYMBOL_GPL(pinmux_generic_get_function);
762
763/**
764 * pinmux_generic_add_function() - adds a function group
765 * @pctldev: pin controller device
766 * @name: name of the function
767 * @groups: array of pin groups
768 * @num_groups: number of pin groups
769 * @data: pin controller driver specific data
770 */
771int pinmux_generic_add_function(struct pinctrl_dev *pctldev,
772 const char *name,
773 const char **groups,
774 const unsigned int num_groups,
775 void *data)
776{
777 struct function_desc *function;
778
779 function = devm_kzalloc(pctldev->dev, sizeof(*function), GFP_KERNEL);
780 if (!function)
781 return -ENOMEM;
782
783 function->name = name;
784 function->group_names = groups;
785 function->num_group_names = num_groups;
786 function->data = data;
787
788 radix_tree_insert(&pctldev->pin_function_tree, pctldev->num_functions,
789 function);
790
791 pctldev->num_functions++;
792
793 return 0;
794}
795EXPORT_SYMBOL_GPL(pinmux_generic_add_function);
796
797/**
798 * pinmux_generic_remove_function() - removes a numbered function
799 * @pctldev: pin controller device
800 * @selector: function number
801 *
802 * Note that the caller must take care of locking.
803 */
804int pinmux_generic_remove_function(struct pinctrl_dev *pctldev,
805 unsigned int selector)
806{
807 struct function_desc *function;
808
809 function = radix_tree_lookup(&pctldev->pin_function_tree,
810 selector);
811 if (!function)
812 return -ENOENT;
813
814 radix_tree_delete(&pctldev->pin_function_tree, selector);
815 devm_kfree(pctldev->dev, function);
816
817 pctldev->num_functions--;
818
819 return 0;
820}
821EXPORT_SYMBOL_GPL(pinmux_generic_remove_function);
822
823/**
824 * pinmux_generic_free_functions() - removes all functions
825 * @pctldev: pin controller device
826 *
827 * Note that the caller must take care of locking. The pinctrl
828 * functions are allocated with devm_kzalloc() so no need to free
829 * them here.
830 */
831void pinmux_generic_free_functions(struct pinctrl_dev *pctldev)
832{
833 struct radix_tree_iter iter;
834 void __rcu **slot;
835
836 radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0)
837 radix_tree_delete(&pctldev->pin_function_tree, iter.index);
838
839 pctldev->num_functions = 0;
840}
841
842#endif /* CONFIG_GENERIC_PINMUX_FUNCTIONS */