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