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