d7c5b4abd7417cc4ff03cf2684adec4764b51758
[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         dev_err(pctldev->dev, "function '%s' not supported\n", function);
311         return -EINVAL;
312 }
313
314 int pinmux_map_to_setting(const struct pinctrl_map *map,
315                           struct pinctrl_setting *setting)
316 {
317         struct pinctrl_dev *pctldev = setting->pctldev;
318         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
319         char const * const *groups;
320         unsigned num_groups;
321         int ret;
322         const char *group;
323
324         if (!pmxops) {
325                 dev_err(pctldev->dev, "does not support mux function\n");
326                 return -EINVAL;
327         }
328
329         ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
330         if (ret < 0) {
331                 dev_err(pctldev->dev, "invalid function %s in map table\n",
332                         map->data.mux.function);
333                 return ret;
334         }
335         setting->data.mux.func = ret;
336
337         ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
338                                           &groups, &num_groups);
339         if (ret < 0) {
340                 dev_err(pctldev->dev, "can't query groups for function %s\n",
341                         map->data.mux.function);
342                 return ret;
343         }
344         if (!num_groups) {
345                 dev_err(pctldev->dev,
346                         "function %s can't be selected on any group\n",
347                         map->data.mux.function);
348                 return -EINVAL;
349         }
350         if (map->data.mux.group) {
351                 group = map->data.mux.group;
352                 ret = match_string(groups, num_groups, group);
353                 if (ret < 0) {
354                         dev_err(pctldev->dev,
355                                 "invalid group \"%s\" for function \"%s\"\n",
356                                 group, map->data.mux.function);
357                         return ret;
358                 }
359         } else {
360                 group = groups[0];
361         }
362
363         ret = pinctrl_get_group_selector(pctldev, group);
364         if (ret < 0) {
365                 dev_err(pctldev->dev, "invalid group %s in map table\n",
366                         map->data.mux.group);
367                 return ret;
368         }
369         setting->data.mux.group = ret;
370
371         return 0;
372 }
373
374 void pinmux_free_setting(const struct pinctrl_setting *setting)
375 {
376         /* This function is currently unused */
377 }
378
379 int pinmux_enable_setting(const struct pinctrl_setting *setting)
380 {
381         struct pinctrl_dev *pctldev = setting->pctldev;
382         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
383         const struct pinmux_ops *ops = pctldev->desc->pmxops;
384         int ret = 0;
385         const unsigned *pins = NULL;
386         unsigned num_pins = 0;
387         int i;
388         struct pin_desc *desc;
389
390         if (pctlops->get_group_pins)
391                 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
392                                               &pins, &num_pins);
393
394         if (ret) {
395                 const char *gname;
396
397                 /* errors only affect debug data, so just warn */
398                 gname = pctlops->get_group_name(pctldev,
399                                                 setting->data.mux.group);
400                 dev_warn(pctldev->dev,
401                          "could not get pins for group %s\n",
402                          gname);
403                 num_pins = 0;
404         }
405
406         /* Try to allocate all pins in this group, one by one */
407         for (i = 0; i < num_pins; i++) {
408                 ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
409                 if (ret) {
410                         const char *gname;
411                         const char *pname;
412
413                         desc = pin_desc_get(pctldev, pins[i]);
414                         pname = desc ? desc->name : "non-existing";
415                         gname = pctlops->get_group_name(pctldev,
416                                                 setting->data.mux.group);
417                         dev_err(pctldev->dev,
418                                 "could not request pin %d (%s) from group %s "
419                                 " on device %s\n",
420                                 pins[i], pname, gname,
421                                 pinctrl_dev_get_name(pctldev));
422                         goto err_pin_request;
423                 }
424         }
425
426         /* Now that we have acquired the pins, encode the mux setting */
427         for (i = 0; i < num_pins; i++) {
428                 desc = pin_desc_get(pctldev, pins[i]);
429                 if (desc == NULL) {
430                         dev_warn(pctldev->dev,
431                                  "could not get pin desc for pin %d\n",
432                                  pins[i]);
433                         continue;
434                 }
435                 desc->mux_setting = &(setting->data.mux);
436         }
437
438         ret = ops->set_mux(pctldev, setting->data.mux.func,
439                            setting->data.mux.group);
440
441         if (ret)
442                 goto err_set_mux;
443
444         return 0;
445
446 err_set_mux:
447         for (i = 0; i < num_pins; i++) {
448                 desc = pin_desc_get(pctldev, pins[i]);
449                 if (desc)
450                         desc->mux_setting = NULL;
451         }
452 err_pin_request:
453         /* On error release all taken pins */
454         while (--i >= 0)
455                 pin_free(pctldev, pins[i], NULL);
456
457         return ret;
458 }
459
460 void pinmux_disable_setting(const struct pinctrl_setting *setting)
461 {
462         struct pinctrl_dev *pctldev = setting->pctldev;
463         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
464         int ret = 0;
465         const unsigned *pins = NULL;
466         unsigned num_pins = 0;
467         int i;
468         struct pin_desc *desc;
469
470         if (pctlops->get_group_pins)
471                 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
472                                               &pins, &num_pins);
473         if (ret) {
474                 const char *gname;
475
476                 /* errors only affect debug data, so just warn */
477                 gname = pctlops->get_group_name(pctldev,
478                                                 setting->data.mux.group);
479                 dev_warn(pctldev->dev,
480                          "could not get pins for group %s\n",
481                          gname);
482                 num_pins = 0;
483         }
484
485         /* Flag the descs that no setting is active */
486         for (i = 0; i < num_pins; i++) {
487                 desc = pin_desc_get(pctldev, pins[i]);
488                 if (desc == NULL) {
489                         dev_warn(pctldev->dev,
490                                  "could not get pin desc for pin %d\n",
491                                  pins[i]);
492                         continue;
493                 }
494                 if (desc->mux_setting == &(setting->data.mux)) {
495                         pin_free(pctldev, pins[i], NULL);
496                 } else {
497                         const char *gname;
498
499                         gname = pctlops->get_group_name(pctldev,
500                                                 setting->data.mux.group);
501                         dev_warn(pctldev->dev,
502                                  "not freeing pin %d (%s) as part of "
503                                  "deactivating group %s - it is already "
504                                  "used for some other setting",
505                                  pins[i], desc->name, gname);
506                 }
507         }
508 }
509
510 #ifdef CONFIG_DEBUG_FS
511
512 /* Called from pincontrol core */
513 static int pinmux_functions_show(struct seq_file *s, void *what)
514 {
515         struct pinctrl_dev *pctldev = s->private;
516         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
517         unsigned nfuncs;
518         unsigned func_selector = 0;
519
520         if (!pmxops)
521                 return 0;
522
523         mutex_lock(&pctldev->mutex);
524         nfuncs = pmxops->get_functions_count(pctldev);
525         while (func_selector < nfuncs) {
526                 const char *func = pmxops->get_function_name(pctldev,
527                                                           func_selector);
528                 const char * const *groups;
529                 unsigned num_groups;
530                 int ret;
531                 int i;
532
533                 ret = pmxops->get_function_groups(pctldev, func_selector,
534                                                   &groups, &num_groups);
535                 if (ret) {
536                         seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
537                                    func);
538                         func_selector++;
539                         continue;
540                 }
541
542                 seq_printf(s, "function: %s, groups = [ ", func);
543                 for (i = 0; i < num_groups; i++)
544                         seq_printf(s, "%s ", groups[i]);
545                 seq_puts(s, "]\n");
546
547                 func_selector++;
548         }
549
550         mutex_unlock(&pctldev->mutex);
551
552         return 0;
553 }
554
555 static int pinmux_pins_show(struct seq_file *s, void *what)
556 {
557         struct pinctrl_dev *pctldev = s->private;
558         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
559         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
560         unsigned i, pin;
561
562         if (!pmxops)
563                 return 0;
564
565         seq_puts(s, "Pinmux settings per pin\n");
566         if (pmxops->strict)
567                 seq_puts(s,
568                  "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n");
569         else
570                 seq_puts(s,
571                 "Format: pin (name): mux_owner gpio_owner hog?\n");
572
573         mutex_lock(&pctldev->mutex);
574
575         /* The pin number can be retrived from the pin controller descriptor */
576         for (i = 0; i < pctldev->desc->npins; i++) {
577                 struct pin_desc *desc;
578                 bool is_hog = false;
579
580                 pin = pctldev->desc->pins[i].number;
581                 desc = pin_desc_get(pctldev, pin);
582                 /* Skip if we cannot search the pin */
583                 if (desc == NULL)
584                         continue;
585
586                 if (desc->mux_owner &&
587                     !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
588                         is_hog = true;
589
590                 if (pmxops->strict) {
591                         if (desc->mux_owner)
592                                 seq_printf(s, "pin %d (%s): device %s%s",
593                                            pin, desc->name, desc->mux_owner,
594                                            is_hog ? " (HOG)" : "");
595                         else if (desc->gpio_owner)
596                                 seq_printf(s, "pin %d (%s): GPIO %s",
597                                            pin, desc->name, desc->gpio_owner);
598                         else
599                                 seq_printf(s, "pin %d (%s): UNCLAIMED",
600                                            pin, desc->name);
601                 } else {
602                         /* For non-strict controllers */
603                         seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name,
604                                    desc->mux_owner ? desc->mux_owner
605                                    : "(MUX UNCLAIMED)",
606                                    desc->gpio_owner ? desc->gpio_owner
607                                    : "(GPIO UNCLAIMED)",
608                                    is_hog ? " (HOG)" : "");
609                 }
610
611                 /* If mux: print function+group claiming the pin */
612                 if (desc->mux_setting)
613                         seq_printf(s, " function %s group %s\n",
614                                    pmxops->get_function_name(pctldev,
615                                         desc->mux_setting->func),
616                                    pctlops->get_group_name(pctldev,
617                                         desc->mux_setting->group));
618                 else
619                         seq_putc(s, '\n');
620         }
621
622         mutex_unlock(&pctldev->mutex);
623
624         return 0;
625 }
626
627 void pinmux_show_map(struct seq_file *s, const struct pinctrl_map *map)
628 {
629         seq_printf(s, "group %s\nfunction %s\n",
630                 map->data.mux.group ? map->data.mux.group : "(default)",
631                 map->data.mux.function);
632 }
633
634 void pinmux_show_setting(struct seq_file *s,
635                          const struct pinctrl_setting *setting)
636 {
637         struct pinctrl_dev *pctldev = setting->pctldev;
638         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
639         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
640
641         seq_printf(s, "group: %s (%u) function: %s (%u)\n",
642                    pctlops->get_group_name(pctldev, setting->data.mux.group),
643                    setting->data.mux.group,
644                    pmxops->get_function_name(pctldev, setting->data.mux.func),
645                    setting->data.mux.func);
646 }
647
648 static int pinmux_functions_open(struct inode *inode, struct file *file)
649 {
650         return single_open(file, pinmux_functions_show, inode->i_private);
651 }
652
653 static int pinmux_pins_open(struct inode *inode, struct file *file)
654 {
655         return single_open(file, pinmux_pins_show, inode->i_private);
656 }
657
658 static const struct file_operations pinmux_functions_ops = {
659         .open           = pinmux_functions_open,
660         .read           = seq_read,
661         .llseek         = seq_lseek,
662         .release        = single_release,
663 };
664
665 static const struct file_operations pinmux_pins_ops = {
666         .open           = pinmux_pins_open,
667         .read           = seq_read,
668         .llseek         = seq_lseek,
669         .release        = single_release,
670 };
671
672 void pinmux_init_device_debugfs(struct dentry *devroot,
673                          struct pinctrl_dev *pctldev)
674 {
675         debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
676                             devroot, pctldev, &pinmux_functions_ops);
677         debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
678                             devroot, pctldev, &pinmux_pins_ops);
679 }
680
681 #endif /* CONFIG_DEBUG_FS */
682
683 #ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
684
685 /**
686  * pinmux_generic_get_function_count() - returns number of functions
687  * @pctldev: pin controller device
688  */
689 int pinmux_generic_get_function_count(struct pinctrl_dev *pctldev)
690 {
691         return pctldev->num_functions;
692 }
693 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_count);
694
695 /**
696  * pinmux_generic_get_function_name() - returns the function name
697  * @pctldev: pin controller device
698  * @selector: function number
699  */
700 const char *
701 pinmux_generic_get_function_name(struct pinctrl_dev *pctldev,
702                                  unsigned int selector)
703 {
704         struct function_desc *function;
705
706         function = radix_tree_lookup(&pctldev->pin_function_tree,
707                                      selector);
708         if (!function)
709                 return NULL;
710
711         return function->name;
712 }
713 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_name);
714
715 /**
716  * pinmux_generic_get_function_groups() - gets the function groups
717  * @pctldev: pin controller device
718  * @selector: function number
719  * @groups: array of pin groups
720  * @num_groups: number of pin groups
721  */
722 int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev,
723                                        unsigned int selector,
724                                        const char * const **groups,
725                                        unsigned * const num_groups)
726 {
727         struct function_desc *function;
728
729         function = radix_tree_lookup(&pctldev->pin_function_tree,
730                                      selector);
731         if (!function) {
732                 dev_err(pctldev->dev, "%s could not find function%i\n",
733                         __func__, selector);
734                 return -EINVAL;
735         }
736         *groups = function->group_names;
737         *num_groups = function->num_group_names;
738
739         return 0;
740 }
741 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_groups);
742
743 /**
744  * pinmux_generic_get_function() - returns a function based on the number
745  * @pctldev: pin controller device
746  * @group_selector: function number
747  */
748 struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev,
749                                                   unsigned int selector)
750 {
751         struct function_desc *function;
752
753         function = radix_tree_lookup(&pctldev->pin_function_tree,
754                                      selector);
755         if (!function)
756                 return NULL;
757
758         return function;
759 }
760 EXPORT_SYMBOL_GPL(pinmux_generic_get_function);
761
762 /**
763  * pinmux_generic_add_function() - adds a function group
764  * @pctldev: pin controller device
765  * @name: name of the function
766  * @groups: array of pin groups
767  * @num_groups: number of pin groups
768  * @data: pin controller driver specific data
769  */
770 int pinmux_generic_add_function(struct pinctrl_dev *pctldev,
771                                 const char *name,
772                                 const char **groups,
773                                 const unsigned int num_groups,
774                                 void *data)
775 {
776         struct function_desc *function;
777
778         function = devm_kzalloc(pctldev->dev, sizeof(*function), GFP_KERNEL);
779         if (!function)
780                 return -ENOMEM;
781
782         function->name = name;
783         function->group_names = groups;
784         function->num_group_names = num_groups;
785         function->data = data;
786
787         radix_tree_insert(&pctldev->pin_function_tree, pctldev->num_functions,
788                           function);
789
790         pctldev->num_functions++;
791
792         return 0;
793 }
794 EXPORT_SYMBOL_GPL(pinmux_generic_add_function);
795
796 /**
797  * pinmux_generic_remove_function() - removes a numbered function
798  * @pctldev: pin controller device
799  * @selector: function number
800  *
801  * Note that the caller must take care of locking.
802  */
803 int pinmux_generic_remove_function(struct pinctrl_dev *pctldev,
804                                    unsigned int selector)
805 {
806         struct function_desc *function;
807
808         function = radix_tree_lookup(&pctldev->pin_function_tree,
809                                      selector);
810         if (!function)
811                 return -ENOENT;
812
813         radix_tree_delete(&pctldev->pin_function_tree, selector);
814         devm_kfree(pctldev->dev, function);
815
816         pctldev->num_functions--;
817
818         return 0;
819 }
820 EXPORT_SYMBOL_GPL(pinmux_generic_remove_function);
821
822 /**
823  * pinmux_generic_free_functions() - removes all functions
824  * @pctldev: pin controller device
825  *
826  * Note that the caller must take care of locking. The pinctrl
827  * functions are allocated with devm_kzalloc() so no need to free
828  * them here.
829  */
830 void pinmux_generic_free_functions(struct pinctrl_dev *pctldev)
831 {
832         struct radix_tree_iter iter;
833         void __rcu **slot;
834
835         radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0)
836                 radix_tree_delete(&pctldev->pin_function_tree, iter.index);
837
838         pctldev->num_functions = 0;
839 }
840
841 #endif /* CONFIG_GENERIC_PINMUX_FUNCTIONS */