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