pinctrl: simplify the re-enable old state code in pinctrl_select_state
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / pinctrl / core.c
1 /*
2 * Core driver for 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) "pinctrl core: " fmt
15
16 #include <linux/kernel.h>
17 #include <linux/kref.h>
18 #include <linux/export.h>
19 #include <linux/init.h>
20 #include <linux/device.h>
21 #include <linux/slab.h>
22 #include <linux/err.h>
23 #include <linux/list.h>
24 #include <linux/sysfs.h>
25 #include <linux/debugfs.h>
26 #include <linux/seq_file.h>
27 #include <linux/pinctrl/consumer.h>
28 #include <linux/pinctrl/pinctrl.h>
29 #include <linux/pinctrl/machine.h>
30
31 #ifdef CONFIG_GPIOLIB
32 #include <asm-generic/gpio.h>
33 #endif
34
35 #include "core.h"
36 #include "devicetree.h"
37 #include "pinmux.h"
38 #include "pinconf.h"
39
40
41 static bool pinctrl_dummy_state;
42
43 /* Mutex taken by all entry points */
44 DEFINE_MUTEX(pinctrl_mutex);
45
46 /* Global list of pin control devices (struct pinctrl_dev) */
47 LIST_HEAD(pinctrldev_list);
48
49 /* List of pin controller handles (struct pinctrl) */
50 static LIST_HEAD(pinctrl_list);
51
52 /* List of pinctrl maps (struct pinctrl_maps) */
53 LIST_HEAD(pinctrl_maps);
54
55
56 /**
57 * pinctrl_provide_dummies() - indicate if pinctrl provides dummy state support
58 *
59 * Usually this function is called by platforms without pinctrl driver support
60 * but run with some shared drivers using pinctrl APIs.
61 * After calling this function, the pinctrl core will return successfully
62 * with creating a dummy state for the driver to keep going smoothly.
63 */
64 void pinctrl_provide_dummies(void)
65 {
66 pinctrl_dummy_state = true;
67 }
68
69 const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev)
70 {
71 /* We're not allowed to register devices without name */
72 return pctldev->desc->name;
73 }
74 EXPORT_SYMBOL_GPL(pinctrl_dev_get_name);
75
76 const char *pinctrl_dev_get_devname(struct pinctrl_dev *pctldev)
77 {
78 return dev_name(pctldev->dev);
79 }
80 EXPORT_SYMBOL_GPL(pinctrl_dev_get_devname);
81
82 void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev)
83 {
84 return pctldev->driver_data;
85 }
86 EXPORT_SYMBOL_GPL(pinctrl_dev_get_drvdata);
87
88 /**
89 * get_pinctrl_dev_from_devname() - look up pin controller device
90 * @devname: the name of a device instance, as returned by dev_name()
91 *
92 * Looks up a pin control device matching a certain device name or pure device
93 * pointer, the pure device pointer will take precedence.
94 */
95 struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *devname)
96 {
97 struct pinctrl_dev *pctldev = NULL;
98 bool found = false;
99
100 if (!devname)
101 return NULL;
102
103 list_for_each_entry(pctldev, &pinctrldev_list, node) {
104 if (!strcmp(dev_name(pctldev->dev), devname)) {
105 /* Matched on device name */
106 found = true;
107 break;
108 }
109 }
110
111 return found ? pctldev : NULL;
112 }
113
114 /**
115 * pin_get_from_name() - look up a pin number from a name
116 * @pctldev: the pin control device to lookup the pin on
117 * @name: the name of the pin to look up
118 */
119 int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name)
120 {
121 unsigned i, pin;
122
123 /* The pin number can be retrived from the pin controller descriptor */
124 for (i = 0; i < pctldev->desc->npins; i++) {
125 struct pin_desc *desc;
126
127 pin = pctldev->desc->pins[i].number;
128 desc = pin_desc_get(pctldev, pin);
129 /* Pin space may be sparse */
130 if (desc == NULL)
131 continue;
132 if (desc->name && !strcmp(name, desc->name))
133 return pin;
134 }
135
136 return -EINVAL;
137 }
138
139 /**
140 * pin_get_name_from_id() - look up a pin name from a pin id
141 * @pctldev: the pin control device to lookup the pin on
142 * @name: the name of the pin to look up
143 */
144 const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned pin)
145 {
146 const struct pin_desc *desc;
147
148 desc = pin_desc_get(pctldev, pin);
149 if (desc == NULL) {
150 dev_err(pctldev->dev, "failed to get pin(%d) name\n",
151 pin);
152 return NULL;
153 }
154
155 return desc->name;
156 }
157
158 /**
159 * pin_is_valid() - check if pin exists on controller
160 * @pctldev: the pin control device to check the pin on
161 * @pin: pin to check, use the local pin controller index number
162 *
163 * This tells us whether a certain pin exist on a certain pin controller or
164 * not. Pin lists may be sparse, so some pins may not exist.
165 */
166 bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
167 {
168 struct pin_desc *pindesc;
169
170 if (pin < 0)
171 return false;
172
173 mutex_lock(&pinctrl_mutex);
174 pindesc = pin_desc_get(pctldev, pin);
175 mutex_unlock(&pinctrl_mutex);
176
177 return pindesc != NULL;
178 }
179 EXPORT_SYMBOL_GPL(pin_is_valid);
180
181 /* Deletes a range of pin descriptors */
182 static void pinctrl_free_pindescs(struct pinctrl_dev *pctldev,
183 const struct pinctrl_pin_desc *pins,
184 unsigned num_pins)
185 {
186 int i;
187
188 for (i = 0; i < num_pins; i++) {
189 struct pin_desc *pindesc;
190
191 pindesc = radix_tree_lookup(&pctldev->pin_desc_tree,
192 pins[i].number);
193 if (pindesc != NULL) {
194 radix_tree_delete(&pctldev->pin_desc_tree,
195 pins[i].number);
196 if (pindesc->dynamic_name)
197 kfree(pindesc->name);
198 }
199 kfree(pindesc);
200 }
201 }
202
203 static int pinctrl_register_one_pin(struct pinctrl_dev *pctldev,
204 unsigned number, const char *name)
205 {
206 struct pin_desc *pindesc;
207
208 pindesc = pin_desc_get(pctldev, number);
209 if (pindesc != NULL) {
210 pr_err("pin %d already registered on %s\n", number,
211 pctldev->desc->name);
212 return -EINVAL;
213 }
214
215 pindesc = kzalloc(sizeof(*pindesc), GFP_KERNEL);
216 if (pindesc == NULL) {
217 dev_err(pctldev->dev, "failed to alloc struct pin_desc\n");
218 return -ENOMEM;
219 }
220
221 /* Set owner */
222 pindesc->pctldev = pctldev;
223
224 /* Copy basic pin info */
225 if (name) {
226 pindesc->name = name;
227 } else {
228 pindesc->name = kasprintf(GFP_KERNEL, "PIN%u", number);
229 if (pindesc->name == NULL) {
230 kfree(pindesc);
231 return -ENOMEM;
232 }
233 pindesc->dynamic_name = true;
234 }
235
236 radix_tree_insert(&pctldev->pin_desc_tree, number, pindesc);
237 pr_debug("registered pin %d (%s) on %s\n",
238 number, pindesc->name, pctldev->desc->name);
239 return 0;
240 }
241
242 static int pinctrl_register_pins(struct pinctrl_dev *pctldev,
243 struct pinctrl_pin_desc const *pins,
244 unsigned num_descs)
245 {
246 unsigned i;
247 int ret = 0;
248
249 for (i = 0; i < num_descs; i++) {
250 ret = pinctrl_register_one_pin(pctldev,
251 pins[i].number, pins[i].name);
252 if (ret)
253 return ret;
254 }
255
256 return 0;
257 }
258
259 /**
260 * pinctrl_match_gpio_range() - check if a certain GPIO pin is in range
261 * @pctldev: pin controller device to check
262 * @gpio: gpio pin to check taken from the global GPIO pin space
263 *
264 * Tries to match a GPIO pin number to the ranges handled by a certain pin
265 * controller, return the range or NULL
266 */
267 static struct pinctrl_gpio_range *
268 pinctrl_match_gpio_range(struct pinctrl_dev *pctldev, unsigned gpio)
269 {
270 struct pinctrl_gpio_range *range = NULL;
271
272 /* Loop over the ranges */
273 list_for_each_entry(range, &pctldev->gpio_ranges, node) {
274 /* Check if we're in the valid range */
275 if (gpio >= range->base &&
276 gpio < range->base + range->npins) {
277 return range;
278 }
279 }
280
281 return NULL;
282 }
283
284 /**
285 * pinctrl_ready_for_gpio_range() - check if other GPIO pins of
286 * the same GPIO chip are in range
287 * @gpio: gpio pin to check taken from the global GPIO pin space
288 *
289 * This function is complement of pinctrl_match_gpio_range(). If the return
290 * value of pinctrl_match_gpio_range() is NULL, this function could be used
291 * to check whether pinctrl device is ready or not. Maybe some GPIO pins
292 * of the same GPIO chip don't have back-end pinctrl interface.
293 * If the return value is true, it means that pinctrl device is ready & the
294 * certain GPIO pin doesn't have back-end pinctrl device. If the return value
295 * is false, it means that pinctrl device may not be ready.
296 */
297 #ifdef CONFIG_GPIOLIB
298 static bool pinctrl_ready_for_gpio_range(unsigned gpio)
299 {
300 struct pinctrl_dev *pctldev;
301 struct pinctrl_gpio_range *range = NULL;
302 struct gpio_chip *chip = gpio_to_chip(gpio);
303
304 /* Loop over the pin controllers */
305 list_for_each_entry(pctldev, &pinctrldev_list, node) {
306 /* Loop over the ranges */
307 list_for_each_entry(range, &pctldev->gpio_ranges, node) {
308 /* Check if any gpio range overlapped with gpio chip */
309 if (range->base + range->npins - 1 < chip->base ||
310 range->base > chip->base + chip->ngpio - 1)
311 continue;
312 return true;
313 }
314 }
315 return false;
316 }
317 #else
318 static bool pinctrl_ready_for_gpio_range(unsigned gpio) { return true; }
319 #endif
320
321 /**
322 * pinctrl_get_device_gpio_range() - find device for GPIO range
323 * @gpio: the pin to locate the pin controller for
324 * @outdev: the pin control device if found
325 * @outrange: the GPIO range if found
326 *
327 * Find the pin controller handling a certain GPIO pin from the pinspace of
328 * the GPIO subsystem, return the device and the matching GPIO range. Returns
329 * -EPROBE_DEFER if the GPIO range could not be found in any device since it
330 * may still have not been registered.
331 */
332 static int pinctrl_get_device_gpio_range(unsigned gpio,
333 struct pinctrl_dev **outdev,
334 struct pinctrl_gpio_range **outrange)
335 {
336 struct pinctrl_dev *pctldev = NULL;
337
338 /* Loop over the pin controllers */
339 list_for_each_entry(pctldev, &pinctrldev_list, node) {
340 struct pinctrl_gpio_range *range;
341
342 range = pinctrl_match_gpio_range(pctldev, gpio);
343 if (range != NULL) {
344 *outdev = pctldev;
345 *outrange = range;
346 return 0;
347 }
348 }
349
350 return -EPROBE_DEFER;
351 }
352
353 /**
354 * pinctrl_add_gpio_range() - register a GPIO range for a controller
355 * @pctldev: pin controller device to add the range to
356 * @range: the GPIO range to add
357 *
358 * This adds a range of GPIOs to be handled by a certain pin controller. Call
359 * this to register handled ranges after registering your pin controller.
360 */
361 void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
362 struct pinctrl_gpio_range *range)
363 {
364 mutex_lock(&pinctrl_mutex);
365 list_add_tail(&range->node, &pctldev->gpio_ranges);
366 mutex_unlock(&pinctrl_mutex);
367 }
368 EXPORT_SYMBOL_GPL(pinctrl_add_gpio_range);
369
370 void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev,
371 struct pinctrl_gpio_range *ranges,
372 unsigned nranges)
373 {
374 int i;
375
376 for (i = 0; i < nranges; i++)
377 pinctrl_add_gpio_range(pctldev, &ranges[i]);
378 }
379 EXPORT_SYMBOL_GPL(pinctrl_add_gpio_ranges);
380
381 struct pinctrl_dev *pinctrl_find_and_add_gpio_range(const char *devname,
382 struct pinctrl_gpio_range *range)
383 {
384 struct pinctrl_dev *pctldev = get_pinctrl_dev_from_devname(devname);
385
386 /*
387 * If we can't find this device, let's assume that is because
388 * it has not probed yet, so the driver trying to register this
389 * range need to defer probing.
390 */
391 if (!pctldev)
392 return ERR_PTR(-EPROBE_DEFER);
393
394 pinctrl_add_gpio_range(pctldev, range);
395 return pctldev;
396 }
397 EXPORT_SYMBOL_GPL(pinctrl_find_and_add_gpio_range);
398
399 /**
400 * pinctrl_find_gpio_range_from_pin() - locate the GPIO range for a pin
401 * @pctldev: the pin controller device to look in
402 * @pin: a controller-local number to find the range for
403 */
404 struct pinctrl_gpio_range *
405 pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev,
406 unsigned int pin)
407 {
408 struct pinctrl_gpio_range *range = NULL;
409
410 /* Loop over the ranges */
411 list_for_each_entry(range, &pctldev->gpio_ranges, node) {
412 /* Check if we're in the valid range */
413 if (pin >= range->pin_base &&
414 pin < range->pin_base + range->npins) {
415 return range;
416 }
417 }
418
419 return NULL;
420 }
421 EXPORT_SYMBOL_GPL(pinctrl_find_gpio_range_from_pin);
422
423 /**
424 * pinctrl_remove_gpio_range() - remove a range of GPIOs fro a pin controller
425 * @pctldev: pin controller device to remove the range from
426 * @range: the GPIO range to remove
427 */
428 void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
429 struct pinctrl_gpio_range *range)
430 {
431 mutex_lock(&pinctrl_mutex);
432 list_del(&range->node);
433 mutex_unlock(&pinctrl_mutex);
434 }
435 EXPORT_SYMBOL_GPL(pinctrl_remove_gpio_range);
436
437 /**
438 * pinctrl_get_group_selector() - returns the group selector for a group
439 * @pctldev: the pin controller handling the group
440 * @pin_group: the pin group to look up
441 */
442 int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
443 const char *pin_group)
444 {
445 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
446 unsigned ngroups = pctlops->get_groups_count(pctldev);
447 unsigned group_selector = 0;
448
449 while (group_selector < ngroups) {
450 const char *gname = pctlops->get_group_name(pctldev,
451 group_selector);
452 if (!strcmp(gname, pin_group)) {
453 dev_dbg(pctldev->dev,
454 "found group selector %u for %s\n",
455 group_selector,
456 pin_group);
457 return group_selector;
458 }
459
460 group_selector++;
461 }
462
463 dev_err(pctldev->dev, "does not have pin group %s\n",
464 pin_group);
465
466 return -EINVAL;
467 }
468
469 /**
470 * pinctrl_request_gpio() - request a single pin to be used in as GPIO
471 * @gpio: the GPIO pin number from the GPIO subsystem number space
472 *
473 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
474 * as part of their gpio_request() semantics, platforms and individual drivers
475 * shall *NOT* request GPIO pins to be muxed in.
476 */
477 int pinctrl_request_gpio(unsigned gpio)
478 {
479 struct pinctrl_dev *pctldev;
480 struct pinctrl_gpio_range *range;
481 int ret;
482 int pin;
483
484 mutex_lock(&pinctrl_mutex);
485
486 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
487 if (ret) {
488 if (pinctrl_ready_for_gpio_range(gpio))
489 ret = 0;
490 mutex_unlock(&pinctrl_mutex);
491 return ret;
492 }
493
494 /* Convert to the pin controllers number space */
495 pin = gpio - range->base + range->pin_base;
496
497 ret = pinmux_request_gpio(pctldev, range, pin, gpio);
498
499 mutex_unlock(&pinctrl_mutex);
500 return ret;
501 }
502 EXPORT_SYMBOL_GPL(pinctrl_request_gpio);
503
504 /**
505 * pinctrl_free_gpio() - free control on a single pin, currently used as GPIO
506 * @gpio: the GPIO pin number from the GPIO subsystem number space
507 *
508 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
509 * as part of their gpio_free() semantics, platforms and individual drivers
510 * shall *NOT* request GPIO pins to be muxed out.
511 */
512 void pinctrl_free_gpio(unsigned gpio)
513 {
514 struct pinctrl_dev *pctldev;
515 struct pinctrl_gpio_range *range;
516 int ret;
517 int pin;
518
519 mutex_lock(&pinctrl_mutex);
520
521 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
522 if (ret) {
523 mutex_unlock(&pinctrl_mutex);
524 return;
525 }
526
527 /* Convert to the pin controllers number space */
528 pin = gpio - range->base + range->pin_base;
529
530 pinmux_free_gpio(pctldev, pin, range);
531
532 mutex_unlock(&pinctrl_mutex);
533 }
534 EXPORT_SYMBOL_GPL(pinctrl_free_gpio);
535
536 static int pinctrl_gpio_direction(unsigned gpio, bool input)
537 {
538 struct pinctrl_dev *pctldev;
539 struct pinctrl_gpio_range *range;
540 int ret;
541 int pin;
542
543 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
544 if (ret)
545 return ret;
546
547 /* Convert to the pin controllers number space */
548 pin = gpio - range->base + range->pin_base;
549
550 return pinmux_gpio_direction(pctldev, range, pin, input);
551 }
552
553 /**
554 * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode
555 * @gpio: the GPIO pin number from the GPIO subsystem number space
556 *
557 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
558 * as part of their gpio_direction_input() semantics, platforms and individual
559 * drivers shall *NOT* touch pin control GPIO calls.
560 */
561 int pinctrl_gpio_direction_input(unsigned gpio)
562 {
563 int ret;
564 mutex_lock(&pinctrl_mutex);
565 ret = pinctrl_gpio_direction(gpio, true);
566 mutex_unlock(&pinctrl_mutex);
567 return ret;
568 }
569 EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_input);
570
571 /**
572 * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode
573 * @gpio: the GPIO pin number from the GPIO subsystem number space
574 *
575 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
576 * as part of their gpio_direction_output() semantics, platforms and individual
577 * drivers shall *NOT* touch pin control GPIO calls.
578 */
579 int pinctrl_gpio_direction_output(unsigned gpio)
580 {
581 int ret;
582 mutex_lock(&pinctrl_mutex);
583 ret = pinctrl_gpio_direction(gpio, false);
584 mutex_unlock(&pinctrl_mutex);
585 return ret;
586 }
587 EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_output);
588
589 static struct pinctrl_state *find_state(struct pinctrl *p,
590 const char *name)
591 {
592 struct pinctrl_state *state;
593
594 list_for_each_entry(state, &p->states, node)
595 if (!strcmp(state->name, name))
596 return state;
597
598 return NULL;
599 }
600
601 static struct pinctrl_state *create_state(struct pinctrl *p,
602 const char *name)
603 {
604 struct pinctrl_state *state;
605
606 state = kzalloc(sizeof(*state), GFP_KERNEL);
607 if (state == NULL) {
608 dev_err(p->dev,
609 "failed to alloc struct pinctrl_state\n");
610 return ERR_PTR(-ENOMEM);
611 }
612
613 state->name = name;
614 INIT_LIST_HEAD(&state->settings);
615
616 list_add_tail(&state->node, &p->states);
617
618 return state;
619 }
620
621 static int add_setting(struct pinctrl *p, struct pinctrl_map const *map)
622 {
623 struct pinctrl_state *state;
624 struct pinctrl_setting *setting;
625 int ret;
626
627 state = find_state(p, map->name);
628 if (!state)
629 state = create_state(p, map->name);
630 if (IS_ERR(state))
631 return PTR_ERR(state);
632
633 if (map->type == PIN_MAP_TYPE_DUMMY_STATE)
634 return 0;
635
636 setting = kzalloc(sizeof(*setting), GFP_KERNEL);
637 if (setting == NULL) {
638 dev_err(p->dev,
639 "failed to alloc struct pinctrl_setting\n");
640 return -ENOMEM;
641 }
642
643 setting->type = map->type;
644
645 setting->pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name);
646 if (setting->pctldev == NULL) {
647 kfree(setting);
648 /* Do not defer probing of hogs (circular loop) */
649 if (!strcmp(map->ctrl_dev_name, map->dev_name))
650 return -ENODEV;
651 /*
652 * OK let us guess that the driver is not there yet, and
653 * let's defer obtaining this pinctrl handle to later...
654 */
655 dev_info(p->dev, "unknown pinctrl device %s in map entry, deferring probe",
656 map->ctrl_dev_name);
657 return -EPROBE_DEFER;
658 }
659
660 setting->dev_name = map->dev_name;
661
662 switch (map->type) {
663 case PIN_MAP_TYPE_MUX_GROUP:
664 ret = pinmux_map_to_setting(map, setting);
665 break;
666 case PIN_MAP_TYPE_CONFIGS_PIN:
667 case PIN_MAP_TYPE_CONFIGS_GROUP:
668 ret = pinconf_map_to_setting(map, setting);
669 break;
670 default:
671 ret = -EINVAL;
672 break;
673 }
674 if (ret < 0) {
675 kfree(setting);
676 return ret;
677 }
678
679 list_add_tail(&setting->node, &state->settings);
680
681 return 0;
682 }
683
684 static struct pinctrl *find_pinctrl(struct device *dev)
685 {
686 struct pinctrl *p;
687
688 list_for_each_entry(p, &pinctrl_list, node)
689 if (p->dev == dev)
690 return p;
691
692 return NULL;
693 }
694
695 static void pinctrl_put_locked(struct pinctrl *p, bool inlist);
696
697 static struct pinctrl *create_pinctrl(struct device *dev)
698 {
699 struct pinctrl *p;
700 const char *devname;
701 struct pinctrl_maps *maps_node;
702 int i;
703 struct pinctrl_map const *map;
704 int ret;
705
706 /*
707 * create the state cookie holder struct pinctrl for each
708 * mapping, this is what consumers will get when requesting
709 * a pin control handle with pinctrl_get()
710 */
711 p = kzalloc(sizeof(*p), GFP_KERNEL);
712 if (p == NULL) {
713 dev_err(dev, "failed to alloc struct pinctrl\n");
714 return ERR_PTR(-ENOMEM);
715 }
716 p->dev = dev;
717 INIT_LIST_HEAD(&p->states);
718 INIT_LIST_HEAD(&p->dt_maps);
719
720 ret = pinctrl_dt_to_map(p);
721 if (ret < 0) {
722 kfree(p);
723 return ERR_PTR(ret);
724 }
725
726 devname = dev_name(dev);
727
728 /* Iterate over the pin control maps to locate the right ones */
729 for_each_maps(maps_node, i, map) {
730 /* Map must be for this device */
731 if (strcmp(map->dev_name, devname))
732 continue;
733
734 ret = add_setting(p, map);
735 /*
736 * At this point the adding of a setting may:
737 *
738 * - Defer, if the pinctrl device is not yet available
739 * - Fail, if the pinctrl device is not yet available,
740 * AND the setting is a hog. We cannot defer that, since
741 * the hog will kick in immediately after the device
742 * is registered.
743 *
744 * If the error returned was not -EPROBE_DEFER then we
745 * accumulate the errors to see if we end up with
746 * an -EPROBE_DEFER later, as that is the worst case.
747 */
748 if (ret == -EPROBE_DEFER) {
749 pinctrl_put_locked(p, false);
750 return ERR_PTR(ret);
751 }
752 }
753 if (ret < 0) {
754 /* If some other error than deferral occured, return here */
755 pinctrl_put_locked(p, false);
756 return ERR_PTR(ret);
757 }
758
759 kref_init(&p->users);
760
761 /* Add the pinctrl handle to the global list */
762 list_add_tail(&p->node, &pinctrl_list);
763
764 return p;
765 }
766
767 static struct pinctrl *pinctrl_get_locked(struct device *dev)
768 {
769 struct pinctrl *p;
770
771 if (WARN_ON(!dev))
772 return ERR_PTR(-EINVAL);
773
774 /*
775 * See if somebody else (such as the device core) has already
776 * obtained a handle to the pinctrl for this device. In that case,
777 * return another pointer to it.
778 */
779 p = find_pinctrl(dev);
780 if (p != NULL) {
781 dev_dbg(dev, "obtain a copy of previously claimed pinctrl\n");
782 kref_get(&p->users);
783 return p;
784 }
785
786 return create_pinctrl(dev);
787 }
788
789 /**
790 * pinctrl_get() - retrieves the pinctrl handle for a device
791 * @dev: the device to obtain the handle for
792 */
793 struct pinctrl *pinctrl_get(struct device *dev)
794 {
795 struct pinctrl *p;
796
797 mutex_lock(&pinctrl_mutex);
798 p = pinctrl_get_locked(dev);
799 mutex_unlock(&pinctrl_mutex);
800
801 return p;
802 }
803 EXPORT_SYMBOL_GPL(pinctrl_get);
804
805 static void pinctrl_free_setting(bool disable_setting,
806 struct pinctrl_setting *setting)
807 {
808 switch (setting->type) {
809 case PIN_MAP_TYPE_MUX_GROUP:
810 if (disable_setting)
811 pinmux_disable_setting(setting);
812 pinmux_free_setting(setting);
813 break;
814 case PIN_MAP_TYPE_CONFIGS_PIN:
815 case PIN_MAP_TYPE_CONFIGS_GROUP:
816 pinconf_free_setting(setting);
817 break;
818 default:
819 break;
820 }
821 }
822
823 static void pinctrl_put_locked(struct pinctrl *p, bool inlist)
824 {
825 struct pinctrl_state *state, *n1;
826 struct pinctrl_setting *setting, *n2;
827
828 list_for_each_entry_safe(state, n1, &p->states, node) {
829 list_for_each_entry_safe(setting, n2, &state->settings, node) {
830 pinctrl_free_setting(state == p->state, setting);
831 list_del(&setting->node);
832 kfree(setting);
833 }
834 list_del(&state->node);
835 kfree(state);
836 }
837
838 pinctrl_dt_free_maps(p);
839
840 if (inlist)
841 list_del(&p->node);
842 kfree(p);
843 }
844
845 /**
846 * pinctrl_release() - release the pinctrl handle
847 * @kref: the kref in the pinctrl being released
848 */
849 static void pinctrl_release(struct kref *kref)
850 {
851 struct pinctrl *p = container_of(kref, struct pinctrl, users);
852
853 pinctrl_put_locked(p, true);
854 }
855
856 /**
857 * pinctrl_put() - decrease use count on a previously claimed pinctrl handle
858 * @p: the pinctrl handle to release
859 */
860 void pinctrl_put(struct pinctrl *p)
861 {
862 mutex_lock(&pinctrl_mutex);
863 kref_put(&p->users, pinctrl_release);
864 mutex_unlock(&pinctrl_mutex);
865 }
866 EXPORT_SYMBOL_GPL(pinctrl_put);
867
868 static struct pinctrl_state *pinctrl_lookup_state_locked(struct pinctrl *p,
869 const char *name)
870 {
871 struct pinctrl_state *state;
872
873 state = find_state(p, name);
874 if (!state) {
875 if (pinctrl_dummy_state) {
876 /* create dummy state */
877 dev_dbg(p->dev, "using pinctrl dummy state (%s)\n",
878 name);
879 state = create_state(p, name);
880 } else
881 state = ERR_PTR(-ENODEV);
882 }
883
884 return state;
885 }
886
887 /**
888 * pinctrl_lookup_state() - retrieves a state handle from a pinctrl handle
889 * @p: the pinctrl handle to retrieve the state from
890 * @name: the state name to retrieve
891 */
892 struct pinctrl_state *pinctrl_lookup_state(struct pinctrl *p, const char *name)
893 {
894 struct pinctrl_state *s;
895
896 mutex_lock(&pinctrl_mutex);
897 s = pinctrl_lookup_state_locked(p, name);
898 mutex_unlock(&pinctrl_mutex);
899
900 return s;
901 }
902 EXPORT_SYMBOL_GPL(pinctrl_lookup_state);
903
904 static int pinctrl_select_state_locked(struct pinctrl *p,
905 struct pinctrl_state *state)
906 {
907 struct pinctrl_setting *setting, *setting2;
908 struct pinctrl_state *old_state = p->state;
909 int ret;
910
911 if (p->state == state)
912 return 0;
913
914 if (p->state) {
915 /*
916 * The set of groups with a mux configuration in the old state
917 * may not be identical to the set of groups with a mux setting
918 * in the new state. While this might be unusual, it's entirely
919 * possible for the "user"-supplied mapping table to be written
920 * that way. For each group that was configured in the old state
921 * but not in the new state, this code puts that group into a
922 * safe/disabled state.
923 */
924 list_for_each_entry(setting, &p->state->settings, node) {
925 bool found = false;
926 if (setting->type != PIN_MAP_TYPE_MUX_GROUP)
927 continue;
928 list_for_each_entry(setting2, &state->settings, node) {
929 if (setting2->type != PIN_MAP_TYPE_MUX_GROUP)
930 continue;
931 if (setting2->data.mux.group ==
932 setting->data.mux.group) {
933 found = true;
934 break;
935 }
936 }
937 if (!found)
938 pinmux_disable_setting(setting);
939 }
940 }
941
942 p->state = NULL;
943
944 /* Apply all the settings for the new state */
945 list_for_each_entry(setting, &state->settings, node) {
946 switch (setting->type) {
947 case PIN_MAP_TYPE_MUX_GROUP:
948 ret = pinmux_enable_setting(setting);
949 break;
950 case PIN_MAP_TYPE_CONFIGS_PIN:
951 case PIN_MAP_TYPE_CONFIGS_GROUP:
952 ret = pinconf_apply_setting(setting);
953 break;
954 default:
955 ret = -EINVAL;
956 break;
957 }
958
959 if (ret < 0)
960 goto unapply_new_state;
961 }
962
963 p->state = state;
964
965 return 0;
966
967 unapply_new_state:
968 dev_err(p->dev, "Error applying setting, reverse things back\n");
969
970 list_for_each_entry(setting2, &state->settings, node) {
971 if (&setting2->node == &setting->node)
972 break;
973 /*
974 * All we can do here is pinmux_disable_setting.
975 * That means that some pins are muxed differently now
976 * than they were before applying the setting (We can't
977 * "unmux a pin"!), but it's not a big deal since the pins
978 * are free to be muxed by another apply_setting.
979 */
980 if (setting2->type == PIN_MAP_TYPE_MUX_GROUP)
981 pinmux_disable_setting(setting2);
982 }
983
984 /* There's no infinite recursive loop here because p->state is NULL */
985 if (old_state)
986 pinctrl_select_state_locked(p, old_state);
987
988 return ret;
989 }
990
991 /**
992 * pinctrl_select() - select/activate/program a pinctrl state to HW
993 * @p: the pinctrl handle for the device that requests configuratio
994 * @state: the state handle to select/activate/program
995 */
996 int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *state)
997 {
998 int ret;
999
1000 mutex_lock(&pinctrl_mutex);
1001 ret = pinctrl_select_state_locked(p, state);
1002 mutex_unlock(&pinctrl_mutex);
1003
1004 return ret;
1005 }
1006 EXPORT_SYMBOL_GPL(pinctrl_select_state);
1007
1008 static void devm_pinctrl_release(struct device *dev, void *res)
1009 {
1010 pinctrl_put(*(struct pinctrl **)res);
1011 }
1012
1013 /**
1014 * struct devm_pinctrl_get() - Resource managed pinctrl_get()
1015 * @dev: the device to obtain the handle for
1016 *
1017 * If there is a need to explicitly destroy the returned struct pinctrl,
1018 * devm_pinctrl_put() should be used, rather than plain pinctrl_put().
1019 */
1020 struct pinctrl *devm_pinctrl_get(struct device *dev)
1021 {
1022 struct pinctrl **ptr, *p;
1023
1024 ptr = devres_alloc(devm_pinctrl_release, sizeof(*ptr), GFP_KERNEL);
1025 if (!ptr)
1026 return ERR_PTR(-ENOMEM);
1027
1028 p = pinctrl_get(dev);
1029 if (!IS_ERR(p)) {
1030 *ptr = p;
1031 devres_add(dev, ptr);
1032 } else {
1033 devres_free(ptr);
1034 }
1035
1036 return p;
1037 }
1038 EXPORT_SYMBOL_GPL(devm_pinctrl_get);
1039
1040 static int devm_pinctrl_match(struct device *dev, void *res, void *data)
1041 {
1042 struct pinctrl **p = res;
1043
1044 return *p == data;
1045 }
1046
1047 /**
1048 * devm_pinctrl_put() - Resource managed pinctrl_put()
1049 * @p: the pinctrl handle to release
1050 *
1051 * Deallocate a struct pinctrl obtained via devm_pinctrl_get(). Normally
1052 * this function will not need to be called and the resource management
1053 * code will ensure that the resource is freed.
1054 */
1055 void devm_pinctrl_put(struct pinctrl *p)
1056 {
1057 WARN_ON(devres_release(p->dev, devm_pinctrl_release,
1058 devm_pinctrl_match, p));
1059 }
1060 EXPORT_SYMBOL_GPL(devm_pinctrl_put);
1061
1062 int pinctrl_register_map(struct pinctrl_map const *maps, unsigned num_maps,
1063 bool dup, bool locked)
1064 {
1065 int i, ret;
1066 struct pinctrl_maps *maps_node;
1067
1068 pr_debug("add %d pinmux maps\n", num_maps);
1069
1070 /* First sanity check the new mapping */
1071 for (i = 0; i < num_maps; i++) {
1072 if (!maps[i].dev_name) {
1073 pr_err("failed to register map %s (%d): no device given\n",
1074 maps[i].name, i);
1075 return -EINVAL;
1076 }
1077
1078 if (!maps[i].name) {
1079 pr_err("failed to register map %d: no map name given\n",
1080 i);
1081 return -EINVAL;
1082 }
1083
1084 if (maps[i].type != PIN_MAP_TYPE_DUMMY_STATE &&
1085 !maps[i].ctrl_dev_name) {
1086 pr_err("failed to register map %s (%d): no pin control device given\n",
1087 maps[i].name, i);
1088 return -EINVAL;
1089 }
1090
1091 switch (maps[i].type) {
1092 case PIN_MAP_TYPE_DUMMY_STATE:
1093 break;
1094 case PIN_MAP_TYPE_MUX_GROUP:
1095 ret = pinmux_validate_map(&maps[i], i);
1096 if (ret < 0)
1097 return ret;
1098 break;
1099 case PIN_MAP_TYPE_CONFIGS_PIN:
1100 case PIN_MAP_TYPE_CONFIGS_GROUP:
1101 ret = pinconf_validate_map(&maps[i], i);
1102 if (ret < 0)
1103 return ret;
1104 break;
1105 default:
1106 pr_err("failed to register map %s (%d): invalid type given\n",
1107 maps[i].name, i);
1108 return -EINVAL;
1109 }
1110 }
1111
1112 maps_node = kzalloc(sizeof(*maps_node), GFP_KERNEL);
1113 if (!maps_node) {
1114 pr_err("failed to alloc struct pinctrl_maps\n");
1115 return -ENOMEM;
1116 }
1117
1118 maps_node->num_maps = num_maps;
1119 if (dup) {
1120 maps_node->maps = kmemdup(maps, sizeof(*maps) * num_maps,
1121 GFP_KERNEL);
1122 if (!maps_node->maps) {
1123 pr_err("failed to duplicate mapping table\n");
1124 kfree(maps_node);
1125 return -ENOMEM;
1126 }
1127 } else {
1128 maps_node->maps = maps;
1129 }
1130
1131 if (!locked)
1132 mutex_lock(&pinctrl_mutex);
1133 list_add_tail(&maps_node->node, &pinctrl_maps);
1134 if (!locked)
1135 mutex_unlock(&pinctrl_mutex);
1136
1137 return 0;
1138 }
1139
1140 /**
1141 * pinctrl_register_mappings() - register a set of pin controller mappings
1142 * @maps: the pincontrol mappings table to register. This should probably be
1143 * marked with __initdata so it can be discarded after boot. This
1144 * function will perform a shallow copy for the mapping entries.
1145 * @num_maps: the number of maps in the mapping table
1146 */
1147 int pinctrl_register_mappings(struct pinctrl_map const *maps,
1148 unsigned num_maps)
1149 {
1150 return pinctrl_register_map(maps, num_maps, true, false);
1151 }
1152
1153 void pinctrl_unregister_map(struct pinctrl_map const *map)
1154 {
1155 struct pinctrl_maps *maps_node;
1156
1157 list_for_each_entry(maps_node, &pinctrl_maps, node) {
1158 if (maps_node->maps == map) {
1159 list_del(&maps_node->node);
1160 return;
1161 }
1162 }
1163 }
1164
1165 /**
1166 * pinctrl_force_sleep() - turn a given controller device into sleep state
1167 * @pctldev: pin controller device
1168 */
1169 int pinctrl_force_sleep(struct pinctrl_dev *pctldev)
1170 {
1171 if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_sleep))
1172 return pinctrl_select_state(pctldev->p, pctldev->hog_sleep);
1173 return 0;
1174 }
1175 EXPORT_SYMBOL_GPL(pinctrl_force_sleep);
1176
1177 /**
1178 * pinctrl_force_default() - turn a given controller device into default state
1179 * @pctldev: pin controller device
1180 */
1181 int pinctrl_force_default(struct pinctrl_dev *pctldev)
1182 {
1183 if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_default))
1184 return pinctrl_select_state(pctldev->p, pctldev->hog_default);
1185 return 0;
1186 }
1187 EXPORT_SYMBOL_GPL(pinctrl_force_default);
1188
1189 #ifdef CONFIG_DEBUG_FS
1190
1191 static int pinctrl_pins_show(struct seq_file *s, void *what)
1192 {
1193 struct pinctrl_dev *pctldev = s->private;
1194 const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1195 unsigned i, pin;
1196
1197 seq_printf(s, "registered pins: %d\n", pctldev->desc->npins);
1198
1199 mutex_lock(&pinctrl_mutex);
1200
1201 /* The pin number can be retrived from the pin controller descriptor */
1202 for (i = 0; i < pctldev->desc->npins; i++) {
1203 struct pin_desc *desc;
1204
1205 pin = pctldev->desc->pins[i].number;
1206 desc = pin_desc_get(pctldev, pin);
1207 /* Pin space may be sparse */
1208 if (desc == NULL)
1209 continue;
1210
1211 seq_printf(s, "pin %d (%s) ", pin,
1212 desc->name ? desc->name : "unnamed");
1213
1214 /* Driver-specific info per pin */
1215 if (ops->pin_dbg_show)
1216 ops->pin_dbg_show(pctldev, s, pin);
1217
1218 seq_puts(s, "\n");
1219 }
1220
1221 mutex_unlock(&pinctrl_mutex);
1222
1223 return 0;
1224 }
1225
1226 static int pinctrl_groups_show(struct seq_file *s, void *what)
1227 {
1228 struct pinctrl_dev *pctldev = s->private;
1229 const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1230 unsigned ngroups, selector = 0;
1231
1232 ngroups = ops->get_groups_count(pctldev);
1233 mutex_lock(&pinctrl_mutex);
1234
1235 seq_puts(s, "registered pin groups:\n");
1236 while (selector < ngroups) {
1237 const unsigned *pins;
1238 unsigned num_pins;
1239 const char *gname = ops->get_group_name(pctldev, selector);
1240 const char *pname;
1241 int ret;
1242 int i;
1243
1244 ret = ops->get_group_pins(pctldev, selector,
1245 &pins, &num_pins);
1246 if (ret)
1247 seq_printf(s, "%s [ERROR GETTING PINS]\n",
1248 gname);
1249 else {
1250 seq_printf(s, "group: %s\n", gname);
1251 for (i = 0; i < num_pins; i++) {
1252 pname = pin_get_name(pctldev, pins[i]);
1253 if (WARN_ON(!pname)) {
1254 mutex_unlock(&pinctrl_mutex);
1255 return -EINVAL;
1256 }
1257 seq_printf(s, "pin %d (%s)\n", pins[i], pname);
1258 }
1259 seq_puts(s, "\n");
1260 }
1261 selector++;
1262 }
1263
1264 mutex_unlock(&pinctrl_mutex);
1265
1266 return 0;
1267 }
1268
1269 static int pinctrl_gpioranges_show(struct seq_file *s, void *what)
1270 {
1271 struct pinctrl_dev *pctldev = s->private;
1272 struct pinctrl_gpio_range *range = NULL;
1273
1274 seq_puts(s, "GPIO ranges handled:\n");
1275
1276 mutex_lock(&pinctrl_mutex);
1277
1278 /* Loop over the ranges */
1279 list_for_each_entry(range, &pctldev->gpio_ranges, node) {
1280 seq_printf(s, "%u: %s GPIOS [%u - %u] PINS [%u - %u]\n",
1281 range->id, range->name,
1282 range->base, (range->base + range->npins - 1),
1283 range->pin_base,
1284 (range->pin_base + range->npins - 1));
1285 }
1286
1287 mutex_unlock(&pinctrl_mutex);
1288
1289 return 0;
1290 }
1291
1292 static int pinctrl_devices_show(struct seq_file *s, void *what)
1293 {
1294 struct pinctrl_dev *pctldev;
1295
1296 seq_puts(s, "name [pinmux] [pinconf]\n");
1297
1298 mutex_lock(&pinctrl_mutex);
1299
1300 list_for_each_entry(pctldev, &pinctrldev_list, node) {
1301 seq_printf(s, "%s ", pctldev->desc->name);
1302 if (pctldev->desc->pmxops)
1303 seq_puts(s, "yes ");
1304 else
1305 seq_puts(s, "no ");
1306 if (pctldev->desc->confops)
1307 seq_puts(s, "yes");
1308 else
1309 seq_puts(s, "no");
1310 seq_puts(s, "\n");
1311 }
1312
1313 mutex_unlock(&pinctrl_mutex);
1314
1315 return 0;
1316 }
1317
1318 static inline const char *map_type(enum pinctrl_map_type type)
1319 {
1320 static const char * const names[] = {
1321 "INVALID",
1322 "DUMMY_STATE",
1323 "MUX_GROUP",
1324 "CONFIGS_PIN",
1325 "CONFIGS_GROUP",
1326 };
1327
1328 if (type >= ARRAY_SIZE(names))
1329 return "UNKNOWN";
1330
1331 return names[type];
1332 }
1333
1334 static int pinctrl_maps_show(struct seq_file *s, void *what)
1335 {
1336 struct pinctrl_maps *maps_node;
1337 int i;
1338 struct pinctrl_map const *map;
1339
1340 seq_puts(s, "Pinctrl maps:\n");
1341
1342 mutex_lock(&pinctrl_mutex);
1343
1344 for_each_maps(maps_node, i, map) {
1345 seq_printf(s, "device %s\nstate %s\ntype %s (%d)\n",
1346 map->dev_name, map->name, map_type(map->type),
1347 map->type);
1348
1349 if (map->type != PIN_MAP_TYPE_DUMMY_STATE)
1350 seq_printf(s, "controlling device %s\n",
1351 map->ctrl_dev_name);
1352
1353 switch (map->type) {
1354 case PIN_MAP_TYPE_MUX_GROUP:
1355 pinmux_show_map(s, map);
1356 break;
1357 case PIN_MAP_TYPE_CONFIGS_PIN:
1358 case PIN_MAP_TYPE_CONFIGS_GROUP:
1359 pinconf_show_map(s, map);
1360 break;
1361 default:
1362 break;
1363 }
1364
1365 seq_printf(s, "\n");
1366 }
1367
1368 mutex_unlock(&pinctrl_mutex);
1369
1370 return 0;
1371 }
1372
1373 static int pinctrl_show(struct seq_file *s, void *what)
1374 {
1375 struct pinctrl *p;
1376 struct pinctrl_state *state;
1377 struct pinctrl_setting *setting;
1378
1379 seq_puts(s, "Requested pin control handlers their pinmux maps:\n");
1380
1381 mutex_lock(&pinctrl_mutex);
1382
1383 list_for_each_entry(p, &pinctrl_list, node) {
1384 seq_printf(s, "device: %s current state: %s\n",
1385 dev_name(p->dev),
1386 p->state ? p->state->name : "none");
1387
1388 list_for_each_entry(state, &p->states, node) {
1389 seq_printf(s, " state: %s\n", state->name);
1390
1391 list_for_each_entry(setting, &state->settings, node) {
1392 struct pinctrl_dev *pctldev = setting->pctldev;
1393
1394 seq_printf(s, " type: %s controller %s ",
1395 map_type(setting->type),
1396 pinctrl_dev_get_name(pctldev));
1397
1398 switch (setting->type) {
1399 case PIN_MAP_TYPE_MUX_GROUP:
1400 pinmux_show_setting(s, setting);
1401 break;
1402 case PIN_MAP_TYPE_CONFIGS_PIN:
1403 case PIN_MAP_TYPE_CONFIGS_GROUP:
1404 pinconf_show_setting(s, setting);
1405 break;
1406 default:
1407 break;
1408 }
1409 }
1410 }
1411 }
1412
1413 mutex_unlock(&pinctrl_mutex);
1414
1415 return 0;
1416 }
1417
1418 static int pinctrl_pins_open(struct inode *inode, struct file *file)
1419 {
1420 return single_open(file, pinctrl_pins_show, inode->i_private);
1421 }
1422
1423 static int pinctrl_groups_open(struct inode *inode, struct file *file)
1424 {
1425 return single_open(file, pinctrl_groups_show, inode->i_private);
1426 }
1427
1428 static int pinctrl_gpioranges_open(struct inode *inode, struct file *file)
1429 {
1430 return single_open(file, pinctrl_gpioranges_show, inode->i_private);
1431 }
1432
1433 static int pinctrl_devices_open(struct inode *inode, struct file *file)
1434 {
1435 return single_open(file, pinctrl_devices_show, NULL);
1436 }
1437
1438 static int pinctrl_maps_open(struct inode *inode, struct file *file)
1439 {
1440 return single_open(file, pinctrl_maps_show, NULL);
1441 }
1442
1443 static int pinctrl_open(struct inode *inode, struct file *file)
1444 {
1445 return single_open(file, pinctrl_show, NULL);
1446 }
1447
1448 static const struct file_operations pinctrl_pins_ops = {
1449 .open = pinctrl_pins_open,
1450 .read = seq_read,
1451 .llseek = seq_lseek,
1452 .release = single_release,
1453 };
1454
1455 static const struct file_operations pinctrl_groups_ops = {
1456 .open = pinctrl_groups_open,
1457 .read = seq_read,
1458 .llseek = seq_lseek,
1459 .release = single_release,
1460 };
1461
1462 static const struct file_operations pinctrl_gpioranges_ops = {
1463 .open = pinctrl_gpioranges_open,
1464 .read = seq_read,
1465 .llseek = seq_lseek,
1466 .release = single_release,
1467 };
1468
1469 static const struct file_operations pinctrl_devices_ops = {
1470 .open = pinctrl_devices_open,
1471 .read = seq_read,
1472 .llseek = seq_lseek,
1473 .release = single_release,
1474 };
1475
1476 static const struct file_operations pinctrl_maps_ops = {
1477 .open = pinctrl_maps_open,
1478 .read = seq_read,
1479 .llseek = seq_lseek,
1480 .release = single_release,
1481 };
1482
1483 static const struct file_operations pinctrl_ops = {
1484 .open = pinctrl_open,
1485 .read = seq_read,
1486 .llseek = seq_lseek,
1487 .release = single_release,
1488 };
1489
1490 static struct dentry *debugfs_root;
1491
1492 static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
1493 {
1494 struct dentry *device_root;
1495
1496 device_root = debugfs_create_dir(dev_name(pctldev->dev),
1497 debugfs_root);
1498 pctldev->device_root = device_root;
1499
1500 if (IS_ERR(device_root) || !device_root) {
1501 pr_warn("failed to create debugfs directory for %s\n",
1502 dev_name(pctldev->dev));
1503 return;
1504 }
1505 debugfs_create_file("pins", S_IFREG | S_IRUGO,
1506 device_root, pctldev, &pinctrl_pins_ops);
1507 debugfs_create_file("pingroups", S_IFREG | S_IRUGO,
1508 device_root, pctldev, &pinctrl_groups_ops);
1509 debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO,
1510 device_root, pctldev, &pinctrl_gpioranges_ops);
1511 pinmux_init_device_debugfs(device_root, pctldev);
1512 pinconf_init_device_debugfs(device_root, pctldev);
1513 }
1514
1515 static void pinctrl_remove_device_debugfs(struct pinctrl_dev *pctldev)
1516 {
1517 debugfs_remove_recursive(pctldev->device_root);
1518 }
1519
1520 static void pinctrl_init_debugfs(void)
1521 {
1522 debugfs_root = debugfs_create_dir("pinctrl", NULL);
1523 if (IS_ERR(debugfs_root) || !debugfs_root) {
1524 pr_warn("failed to create debugfs directory\n");
1525 debugfs_root = NULL;
1526 return;
1527 }
1528
1529 debugfs_create_file("pinctrl-devices", S_IFREG | S_IRUGO,
1530 debugfs_root, NULL, &pinctrl_devices_ops);
1531 debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO,
1532 debugfs_root, NULL, &pinctrl_maps_ops);
1533 debugfs_create_file("pinctrl-handles", S_IFREG | S_IRUGO,
1534 debugfs_root, NULL, &pinctrl_ops);
1535 }
1536
1537 #else /* CONFIG_DEBUG_FS */
1538
1539 static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
1540 {
1541 }
1542
1543 static void pinctrl_init_debugfs(void)
1544 {
1545 }
1546
1547 static void pinctrl_remove_device_debugfs(struct pinctrl_dev *pctldev)
1548 {
1549 }
1550
1551 #endif
1552
1553 static int pinctrl_check_ops(struct pinctrl_dev *pctldev)
1554 {
1555 const struct pinctrl_ops *ops = pctldev->desc->pctlops;
1556
1557 if (!ops ||
1558 !ops->get_groups_count ||
1559 !ops->get_group_name ||
1560 !ops->get_group_pins)
1561 return -EINVAL;
1562
1563 if (ops->dt_node_to_map && !ops->dt_free_map)
1564 return -EINVAL;
1565
1566 return 0;
1567 }
1568
1569 /**
1570 * pinctrl_register() - register a pin controller device
1571 * @pctldesc: descriptor for this pin controller
1572 * @dev: parent device for this pin controller
1573 * @driver_data: private pin controller data for this pin controller
1574 */
1575 struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
1576 struct device *dev, void *driver_data)
1577 {
1578 struct pinctrl_dev *pctldev;
1579 int ret;
1580
1581 if (!pctldesc)
1582 return NULL;
1583 if (!pctldesc->name)
1584 return NULL;
1585
1586 pctldev = kzalloc(sizeof(*pctldev), GFP_KERNEL);
1587 if (pctldev == NULL) {
1588 dev_err(dev, "failed to alloc struct pinctrl_dev\n");
1589 return NULL;
1590 }
1591
1592 /* Initialize pin control device struct */
1593 pctldev->owner = pctldesc->owner;
1594 pctldev->desc = pctldesc;
1595 pctldev->driver_data = driver_data;
1596 INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL);
1597 INIT_LIST_HEAD(&pctldev->gpio_ranges);
1598 pctldev->dev = dev;
1599
1600 /* check core ops for sanity */
1601 if (pinctrl_check_ops(pctldev)) {
1602 dev_err(dev, "pinctrl ops lacks necessary functions\n");
1603 goto out_err;
1604 }
1605
1606 /* If we're implementing pinmuxing, check the ops for sanity */
1607 if (pctldesc->pmxops) {
1608 if (pinmux_check_ops(pctldev))
1609 goto out_err;
1610 }
1611
1612 /* If we're implementing pinconfig, check the ops for sanity */
1613 if (pctldesc->confops) {
1614 if (pinconf_check_ops(pctldev))
1615 goto out_err;
1616 }
1617
1618 /* Register all the pins */
1619 dev_dbg(dev, "try to register %d pins ...\n", pctldesc->npins);
1620 ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);
1621 if (ret) {
1622 dev_err(dev, "error during pin registration\n");
1623 pinctrl_free_pindescs(pctldev, pctldesc->pins,
1624 pctldesc->npins);
1625 goto out_err;
1626 }
1627
1628 mutex_lock(&pinctrl_mutex);
1629
1630 list_add_tail(&pctldev->node, &pinctrldev_list);
1631
1632 pctldev->p = pinctrl_get_locked(pctldev->dev);
1633 if (!IS_ERR(pctldev->p)) {
1634 pctldev->hog_default =
1635 pinctrl_lookup_state_locked(pctldev->p,
1636 PINCTRL_STATE_DEFAULT);
1637 if (IS_ERR(pctldev->hog_default)) {
1638 dev_dbg(dev, "failed to lookup the default state\n");
1639 } else {
1640 if (pinctrl_select_state_locked(pctldev->p,
1641 pctldev->hog_default))
1642 dev_err(dev,
1643 "failed to select default state\n");
1644 }
1645
1646 pctldev->hog_sleep =
1647 pinctrl_lookup_state_locked(pctldev->p,
1648 PINCTRL_STATE_SLEEP);
1649 if (IS_ERR(pctldev->hog_sleep))
1650 dev_dbg(dev, "failed to lookup the sleep state\n");
1651 }
1652
1653 mutex_unlock(&pinctrl_mutex);
1654
1655 pinctrl_init_device_debugfs(pctldev);
1656
1657 return pctldev;
1658
1659 out_err:
1660 kfree(pctldev);
1661 return NULL;
1662 }
1663 EXPORT_SYMBOL_GPL(pinctrl_register);
1664
1665 /**
1666 * pinctrl_unregister() - unregister pinmux
1667 * @pctldev: pin controller to unregister
1668 *
1669 * Called by pinmux drivers to unregister a pinmux.
1670 */
1671 void pinctrl_unregister(struct pinctrl_dev *pctldev)
1672 {
1673 struct pinctrl_gpio_range *range, *n;
1674 if (pctldev == NULL)
1675 return;
1676
1677 pinctrl_remove_device_debugfs(pctldev);
1678
1679 mutex_lock(&pinctrl_mutex);
1680
1681 if (!IS_ERR(pctldev->p))
1682 pinctrl_put_locked(pctldev->p, true);
1683
1684 /* TODO: check that no pinmuxes are still active? */
1685 list_del(&pctldev->node);
1686 /* Destroy descriptor tree */
1687 pinctrl_free_pindescs(pctldev, pctldev->desc->pins,
1688 pctldev->desc->npins);
1689 /* remove gpio ranges map */
1690 list_for_each_entry_safe(range, n, &pctldev->gpio_ranges, node)
1691 list_del(&range->node);
1692
1693 kfree(pctldev);
1694
1695 mutex_unlock(&pinctrl_mutex);
1696 }
1697 EXPORT_SYMBOL_GPL(pinctrl_unregister);
1698
1699 static int __init pinctrl_init(void)
1700 {
1701 pr_info("initialized pinctrl subsystem\n");
1702 pinctrl_init_debugfs();
1703 return 0;
1704 }
1705
1706 /* init early since many drivers really need to initialized pinmux early */
1707 core_initcall(pinctrl_init);