xref: /openbmc/linux/drivers/gpio/gpiolib.c (revision b34e08d5)
1 #include <linux/kernel.h>
2 #include <linux/module.h>
3 #include <linux/interrupt.h>
4 #include <linux/irq.h>
5 #include <linux/spinlock.h>
6 #include <linux/list.h>
7 #include <linux/device.h>
8 #include <linux/err.h>
9 #include <linux/debugfs.h>
10 #include <linux/seq_file.h>
11 #include <linux/gpio.h>
12 #include <linux/of_gpio.h>
13 #include <linux/idr.h>
14 #include <linux/slab.h>
15 #include <linux/acpi.h>
16 #include <linux/gpio/driver.h>
17 
18 #include "gpiolib.h"
19 
20 #define CREATE_TRACE_POINTS
21 #include <trace/events/gpio.h>
22 
23 /* Implementation infrastructure for GPIO interfaces.
24  *
25  * The GPIO programming interface allows for inlining speed-critical
26  * get/set operations for common cases, so that access to SOC-integrated
27  * GPIOs can sometimes cost only an instruction or two per bit.
28  */
29 
30 
31 /* When debugging, extend minimal trust to callers and platform code.
32  * Also emit diagnostic messages that may help initial bringup, when
33  * board setup or driver bugs are most common.
34  *
35  * Otherwise, minimize overhead in what may be bitbanging codepaths.
36  */
37 #ifdef	DEBUG
38 #define	extra_checks	1
39 #else
40 #define	extra_checks	0
41 #endif
42 
43 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
44  * While any GPIO is requested, its gpio_chip is not removable;
45  * each GPIO's "requested" flag serves as a lock and refcount.
46  */
47 static DEFINE_SPINLOCK(gpio_lock);
48 
49 struct gpio_desc {
50 	struct gpio_chip	*chip;
51 	unsigned long		flags;
52 /* flag symbols are bit numbers */
53 #define FLAG_REQUESTED	0
54 #define FLAG_IS_OUT	1
55 #define FLAG_EXPORT	2	/* protected by sysfs_lock */
56 #define FLAG_SYSFS	3	/* exported via /sys/class/gpio/control */
57 #define FLAG_TRIG_FALL	4	/* trigger on falling edge */
58 #define FLAG_TRIG_RISE	5	/* trigger on rising edge */
59 #define FLAG_ACTIVE_LOW	6	/* value has active low */
60 #define FLAG_OPEN_DRAIN	7	/* Gpio is open drain type */
61 #define FLAG_OPEN_SOURCE 8	/* Gpio is open source type */
62 #define FLAG_USED_AS_IRQ 9	/* GPIO is connected to an IRQ */
63 
64 #define ID_SHIFT	16	/* add new flags before this one */
65 
66 #define GPIO_FLAGS_MASK		((1 << ID_SHIFT) - 1)
67 #define GPIO_TRIGGER_MASK	(BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
68 
69 #ifdef CONFIG_DEBUG_FS
70 	const char		*label;
71 #endif
72 };
73 static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
74 
75 #define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio)
76 
77 static DEFINE_MUTEX(gpio_lookup_lock);
78 static LIST_HEAD(gpio_lookup_list);
79 static LIST_HEAD(gpio_chips);
80 
81 #ifdef CONFIG_GPIO_SYSFS
82 static DEFINE_IDR(dirent_idr);
83 #endif
84 
85 static int gpiod_request(struct gpio_desc *desc, const char *label);
86 static void gpiod_free(struct gpio_desc *desc);
87 
88 /* With descriptor prefix */
89 
90 #ifdef CONFIG_DEBUG_FS
91 #define gpiod_emerg(desc, fmt, ...)					       \
92 	pr_emerg("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
93                  ##__VA_ARGS__)
94 #define gpiod_crit(desc, fmt, ...)					       \
95 	pr_crit("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
96                  ##__VA_ARGS__)
97 #define gpiod_err(desc, fmt, ...)					       \
98 	pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",  \
99                  ##__VA_ARGS__)
100 #define gpiod_warn(desc, fmt, ...)					       \
101 	pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
102                  ##__VA_ARGS__)
103 #define gpiod_info(desc, fmt, ...)					       \
104 	pr_info("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
105                 ##__VA_ARGS__)
106 #define gpiod_dbg(desc, fmt, ...)					       \
107 	pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
108                  ##__VA_ARGS__)
109 #else
110 #define gpiod_emerg(desc, fmt, ...)					\
111 	pr_emerg("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
112 #define gpiod_crit(desc, fmt, ...)					\
113 	pr_crit("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
114 #define gpiod_err(desc, fmt, ...)					\
115 	pr_err("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
116 #define gpiod_warn(desc, fmt, ...)					\
117 	pr_warn("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
118 #define gpiod_info(desc, fmt, ...)					\
119 	pr_info("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
120 #define gpiod_dbg(desc, fmt, ...)					\
121 	pr_debug("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
122 #endif
123 
124 /* With chip prefix */
125 
126 #define chip_emerg(chip, fmt, ...)					\
127 	pr_emerg("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
128 #define chip_crit(chip, fmt, ...)					\
129 	pr_crit("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
130 #define chip_err(chip, fmt, ...)					\
131 	pr_err("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
132 #define chip_warn(chip, fmt, ...)					\
133 	pr_warn("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
134 #define chip_info(chip, fmt, ...)					\
135 	pr_info("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
136 #define chip_dbg(chip, fmt, ...)					\
137 	pr_debug("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
138 
139 static inline void desc_set_label(struct gpio_desc *d, const char *label)
140 {
141 #ifdef CONFIG_DEBUG_FS
142 	d->label = label;
143 #endif
144 }
145 
146 /*
147  * Return the GPIO number of the passed descriptor relative to its chip
148  */
149 static int gpio_chip_hwgpio(const struct gpio_desc *desc)
150 {
151 	return desc - &desc->chip->desc[0];
152 }
153 
154 /**
155  * Convert a GPIO number to its descriptor
156  */
157 struct gpio_desc *gpio_to_desc(unsigned gpio)
158 {
159 	if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
160 		return NULL;
161 	else
162 		return &gpio_desc[gpio];
163 }
164 EXPORT_SYMBOL_GPL(gpio_to_desc);
165 
166 /**
167  * Get the GPIO descriptor corresponding to the given hw number for this chip.
168  */
169 struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
170 				    u16 hwnum)
171 {
172 	if (hwnum >= chip->ngpio)
173 		return ERR_PTR(-EINVAL);
174 
175 	return &chip->desc[hwnum];
176 }
177 EXPORT_SYMBOL_GPL(gpiochip_get_desc);
178 
179 /**
180  * Convert a GPIO descriptor to the integer namespace.
181  * This should disappear in the future but is needed since we still
182  * use GPIO numbers for error messages and sysfs nodes
183  */
184 int desc_to_gpio(const struct gpio_desc *desc)
185 {
186 	return desc - &gpio_desc[0];
187 }
188 EXPORT_SYMBOL_GPL(desc_to_gpio);
189 
190 
191 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
192  * when setting direction, and otherwise illegal.  Until board setup code
193  * and drivers use explicit requests everywhere (which won't happen when
194  * those calls have no teeth) we can't avoid autorequesting.  This nag
195  * message should motivate switching to explicit requests... so should
196  * the weaker cleanup after faults, compared to gpio_request().
197  *
198  * NOTE: the autorequest mechanism is going away; at this point it's
199  * only "legal" in the sense that (old) code using it won't break yet,
200  * but instead only triggers a WARN() stack dump.
201  */
202 static int gpio_ensure_requested(struct gpio_desc *desc)
203 {
204 	const struct gpio_chip *chip = desc->chip;
205 	const int gpio = desc_to_gpio(desc);
206 
207 	if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
208 			"autorequest GPIO-%d\n", gpio)) {
209 		if (!try_module_get(chip->owner)) {
210 			gpiod_err(desc, "%s: module can't be gotten\n",
211 					__func__);
212 			clear_bit(FLAG_REQUESTED, &desc->flags);
213 			/* lose */
214 			return -EIO;
215 		}
216 		desc_set_label(desc, "[auto]");
217 		/* caller must chip->request() w/o spinlock */
218 		if (chip->request)
219 			return 1;
220 	}
221 	return 0;
222 }
223 
224 /**
225  * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
226  * @desc:	descriptor to return the chip of
227  */
228 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
229 {
230 	return desc ? desc->chip : NULL;
231 }
232 EXPORT_SYMBOL_GPL(gpiod_to_chip);
233 
234 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
235 static int gpiochip_find_base(int ngpio)
236 {
237 	struct gpio_chip *chip;
238 	int base = ARCH_NR_GPIOS - ngpio;
239 
240 	list_for_each_entry_reverse(chip, &gpio_chips, list) {
241 		/* found a free space? */
242 		if (chip->base + chip->ngpio <= base)
243 			break;
244 		else
245 			/* nope, check the space right before the chip */
246 			base = chip->base - ngpio;
247 	}
248 
249 	if (gpio_is_valid(base)) {
250 		pr_debug("%s: found new base at %d\n", __func__, base);
251 		return base;
252 	} else {
253 		pr_err("%s: cannot find free range\n", __func__);
254 		return -ENOSPC;
255 	}
256 }
257 
258 /**
259  * gpiod_get_direction - return the current direction of a GPIO
260  * @desc:	GPIO to get the direction of
261  *
262  * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
263  *
264  * This function may sleep if gpiod_cansleep() is true.
265  */
266 int gpiod_get_direction(const struct gpio_desc *desc)
267 {
268 	struct gpio_chip	*chip;
269 	unsigned		offset;
270 	int			status = -EINVAL;
271 
272 	chip = gpiod_to_chip(desc);
273 	offset = gpio_chip_hwgpio(desc);
274 
275 	if (!chip->get_direction)
276 		return status;
277 
278 	status = chip->get_direction(chip, offset);
279 	if (status > 0) {
280 		/* GPIOF_DIR_IN, or other positive */
281 		status = 1;
282 		/* FLAG_IS_OUT is just a cache of the result of get_direction(),
283 		 * so it does not affect constness per se */
284 		clear_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
285 	}
286 	if (status == 0) {
287 		/* GPIOF_DIR_OUT */
288 		set_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
289 	}
290 	return status;
291 }
292 EXPORT_SYMBOL_GPL(gpiod_get_direction);
293 
294 #ifdef CONFIG_GPIO_SYSFS
295 
296 /* lock protects against unexport_gpio() being called while
297  * sysfs files are active.
298  */
299 static DEFINE_MUTEX(sysfs_lock);
300 
301 /*
302  * /sys/class/gpio/gpioN... only for GPIOs that are exported
303  *   /direction
304  *      * MAY BE OMITTED if kernel won't allow direction changes
305  *      * is read/write as "in" or "out"
306  *      * may also be written as "high" or "low", initializing
307  *        output value as specified ("out" implies "low")
308  *   /value
309  *      * always readable, subject to hardware behavior
310  *      * may be writable, as zero/nonzero
311  *   /edge
312  *      * configures behavior of poll(2) on /value
313  *      * available only if pin can generate IRQs on input
314  *      * is read/write as "none", "falling", "rising", or "both"
315  *   /active_low
316  *      * configures polarity of /value
317  *      * is read/write as zero/nonzero
318  *      * also affects existing and subsequent "falling" and "rising"
319  *        /edge configuration
320  */
321 
322 static ssize_t gpio_direction_show(struct device *dev,
323 		struct device_attribute *attr, char *buf)
324 {
325 	const struct gpio_desc	*desc = dev_get_drvdata(dev);
326 	ssize_t			status;
327 
328 	mutex_lock(&sysfs_lock);
329 
330 	if (!test_bit(FLAG_EXPORT, &desc->flags)) {
331 		status = -EIO;
332 	} else {
333 		gpiod_get_direction(desc);
334 		status = sprintf(buf, "%s\n",
335 			test_bit(FLAG_IS_OUT, &desc->flags)
336 				? "out" : "in");
337 	}
338 
339 	mutex_unlock(&sysfs_lock);
340 	return status;
341 }
342 
343 static ssize_t gpio_direction_store(struct device *dev,
344 		struct device_attribute *attr, const char *buf, size_t size)
345 {
346 	struct gpio_desc	*desc = dev_get_drvdata(dev);
347 	ssize_t			status;
348 
349 	mutex_lock(&sysfs_lock);
350 
351 	if (!test_bit(FLAG_EXPORT, &desc->flags))
352 		status = -EIO;
353 	else if (sysfs_streq(buf, "high"))
354 		status = gpiod_direction_output_raw(desc, 1);
355 	else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
356 		status = gpiod_direction_output_raw(desc, 0);
357 	else if (sysfs_streq(buf, "in"))
358 		status = gpiod_direction_input(desc);
359 	else
360 		status = -EINVAL;
361 
362 	mutex_unlock(&sysfs_lock);
363 	return status ? : size;
364 }
365 
366 static /* const */ DEVICE_ATTR(direction, 0644,
367 		gpio_direction_show, gpio_direction_store);
368 
369 static ssize_t gpio_value_show(struct device *dev,
370 		struct device_attribute *attr, char *buf)
371 {
372 	struct gpio_desc	*desc = dev_get_drvdata(dev);
373 	ssize_t			status;
374 
375 	mutex_lock(&sysfs_lock);
376 
377 	if (!test_bit(FLAG_EXPORT, &desc->flags))
378 		status = -EIO;
379 	else
380 		status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
381 
382 	mutex_unlock(&sysfs_lock);
383 	return status;
384 }
385 
386 static ssize_t gpio_value_store(struct device *dev,
387 		struct device_attribute *attr, const char *buf, size_t size)
388 {
389 	struct gpio_desc	*desc = dev_get_drvdata(dev);
390 	ssize_t			status;
391 
392 	mutex_lock(&sysfs_lock);
393 
394 	if (!test_bit(FLAG_EXPORT, &desc->flags))
395 		status = -EIO;
396 	else if (!test_bit(FLAG_IS_OUT, &desc->flags))
397 		status = -EPERM;
398 	else {
399 		long		value;
400 
401 		status = kstrtol(buf, 0, &value);
402 		if (status == 0) {
403 			gpiod_set_value_cansleep(desc, value);
404 			status = size;
405 		}
406 	}
407 
408 	mutex_unlock(&sysfs_lock);
409 	return status;
410 }
411 
412 static const DEVICE_ATTR(value, 0644,
413 		gpio_value_show, gpio_value_store);
414 
415 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
416 {
417 	struct kernfs_node	*value_sd = priv;
418 
419 	sysfs_notify_dirent(value_sd);
420 	return IRQ_HANDLED;
421 }
422 
423 static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
424 		unsigned long gpio_flags)
425 {
426 	struct kernfs_node	*value_sd;
427 	unsigned long		irq_flags;
428 	int			ret, irq, id;
429 
430 	if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
431 		return 0;
432 
433 	irq = gpiod_to_irq(desc);
434 	if (irq < 0)
435 		return -EIO;
436 
437 	id = desc->flags >> ID_SHIFT;
438 	value_sd = idr_find(&dirent_idr, id);
439 	if (value_sd)
440 		free_irq(irq, value_sd);
441 
442 	desc->flags &= ~GPIO_TRIGGER_MASK;
443 
444 	if (!gpio_flags) {
445 		gpiod_unlock_as_irq(desc);
446 		ret = 0;
447 		goto free_id;
448 	}
449 
450 	irq_flags = IRQF_SHARED;
451 	if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
452 		irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
453 			IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
454 	if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
455 		irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
456 			IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
457 
458 	if (!value_sd) {
459 		value_sd = sysfs_get_dirent(dev->kobj.sd, "value");
460 		if (!value_sd) {
461 			ret = -ENODEV;
462 			goto err_out;
463 		}
464 
465 		ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
466 		if (ret < 0)
467 			goto free_sd;
468 		id = ret;
469 
470 		desc->flags &= GPIO_FLAGS_MASK;
471 		desc->flags |= (unsigned long)id << ID_SHIFT;
472 
473 		if (desc->flags >> ID_SHIFT != id) {
474 			ret = -ERANGE;
475 			goto free_id;
476 		}
477 	}
478 
479 	ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
480 				"gpiolib", value_sd);
481 	if (ret < 0)
482 		goto free_id;
483 
484 	ret = gpiod_lock_as_irq(desc);
485 	if (ret < 0) {
486 		gpiod_warn(desc, "failed to flag the GPIO for IRQ\n");
487 		goto free_id;
488 	}
489 
490 	desc->flags |= gpio_flags;
491 	return 0;
492 
493 free_id:
494 	idr_remove(&dirent_idr, id);
495 	desc->flags &= GPIO_FLAGS_MASK;
496 free_sd:
497 	if (value_sd)
498 		sysfs_put(value_sd);
499 err_out:
500 	return ret;
501 }
502 
503 static const struct {
504 	const char *name;
505 	unsigned long flags;
506 } trigger_types[] = {
507 	{ "none",    0 },
508 	{ "falling", BIT(FLAG_TRIG_FALL) },
509 	{ "rising",  BIT(FLAG_TRIG_RISE) },
510 	{ "both",    BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
511 };
512 
513 static ssize_t gpio_edge_show(struct device *dev,
514 		struct device_attribute *attr, char *buf)
515 {
516 	const struct gpio_desc	*desc = dev_get_drvdata(dev);
517 	ssize_t			status;
518 
519 	mutex_lock(&sysfs_lock);
520 
521 	if (!test_bit(FLAG_EXPORT, &desc->flags))
522 		status = -EIO;
523 	else {
524 		int i;
525 
526 		status = 0;
527 		for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
528 			if ((desc->flags & GPIO_TRIGGER_MASK)
529 					== trigger_types[i].flags) {
530 				status = sprintf(buf, "%s\n",
531 						 trigger_types[i].name);
532 				break;
533 			}
534 	}
535 
536 	mutex_unlock(&sysfs_lock);
537 	return status;
538 }
539 
540 static ssize_t gpio_edge_store(struct device *dev,
541 		struct device_attribute *attr, const char *buf, size_t size)
542 {
543 	struct gpio_desc	*desc = dev_get_drvdata(dev);
544 	ssize_t			status;
545 	int			i;
546 
547 	for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
548 		if (sysfs_streq(trigger_types[i].name, buf))
549 			goto found;
550 	return -EINVAL;
551 
552 found:
553 	mutex_lock(&sysfs_lock);
554 
555 	if (!test_bit(FLAG_EXPORT, &desc->flags))
556 		status = -EIO;
557 	else {
558 		status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
559 		if (!status)
560 			status = size;
561 	}
562 
563 	mutex_unlock(&sysfs_lock);
564 
565 	return status;
566 }
567 
568 static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
569 
570 static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
571 				int value)
572 {
573 	int			status = 0;
574 
575 	if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
576 		return 0;
577 
578 	if (value)
579 		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
580 	else
581 		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
582 
583 	/* reconfigure poll(2) support if enabled on one edge only */
584 	if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
585 				!!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
586 		unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
587 
588 		gpio_setup_irq(desc, dev, 0);
589 		status = gpio_setup_irq(desc, dev, trigger_flags);
590 	}
591 
592 	return status;
593 }
594 
595 static ssize_t gpio_active_low_show(struct device *dev,
596 		struct device_attribute *attr, char *buf)
597 {
598 	const struct gpio_desc	*desc = dev_get_drvdata(dev);
599 	ssize_t			status;
600 
601 	mutex_lock(&sysfs_lock);
602 
603 	if (!test_bit(FLAG_EXPORT, &desc->flags))
604 		status = -EIO;
605 	else
606 		status = sprintf(buf, "%d\n",
607 				!!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
608 
609 	mutex_unlock(&sysfs_lock);
610 
611 	return status;
612 }
613 
614 static ssize_t gpio_active_low_store(struct device *dev,
615 		struct device_attribute *attr, const char *buf, size_t size)
616 {
617 	struct gpio_desc	*desc = dev_get_drvdata(dev);
618 	ssize_t			status;
619 
620 	mutex_lock(&sysfs_lock);
621 
622 	if (!test_bit(FLAG_EXPORT, &desc->flags)) {
623 		status = -EIO;
624 	} else {
625 		long		value;
626 
627 		status = kstrtol(buf, 0, &value);
628 		if (status == 0)
629 			status = sysfs_set_active_low(desc, dev, value != 0);
630 	}
631 
632 	mutex_unlock(&sysfs_lock);
633 
634 	return status ? : size;
635 }
636 
637 static const DEVICE_ATTR(active_low, 0644,
638 		gpio_active_low_show, gpio_active_low_store);
639 
640 static const struct attribute *gpio_attrs[] = {
641 	&dev_attr_value.attr,
642 	&dev_attr_active_low.attr,
643 	NULL,
644 };
645 
646 static const struct attribute_group gpio_attr_group = {
647 	.attrs = (struct attribute **) gpio_attrs,
648 };
649 
650 /*
651  * /sys/class/gpio/gpiochipN/
652  *   /base ... matching gpio_chip.base (N)
653  *   /label ... matching gpio_chip.label
654  *   /ngpio ... matching gpio_chip.ngpio
655  */
656 
657 static ssize_t chip_base_show(struct device *dev,
658 			       struct device_attribute *attr, char *buf)
659 {
660 	const struct gpio_chip	*chip = dev_get_drvdata(dev);
661 
662 	return sprintf(buf, "%d\n", chip->base);
663 }
664 static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
665 
666 static ssize_t chip_label_show(struct device *dev,
667 			       struct device_attribute *attr, char *buf)
668 {
669 	const struct gpio_chip	*chip = dev_get_drvdata(dev);
670 
671 	return sprintf(buf, "%s\n", chip->label ? : "");
672 }
673 static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
674 
675 static ssize_t chip_ngpio_show(struct device *dev,
676 			       struct device_attribute *attr, char *buf)
677 {
678 	const struct gpio_chip	*chip = dev_get_drvdata(dev);
679 
680 	return sprintf(buf, "%u\n", chip->ngpio);
681 }
682 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
683 
684 static const struct attribute *gpiochip_attrs[] = {
685 	&dev_attr_base.attr,
686 	&dev_attr_label.attr,
687 	&dev_attr_ngpio.attr,
688 	NULL,
689 };
690 
691 static const struct attribute_group gpiochip_attr_group = {
692 	.attrs = (struct attribute **) gpiochip_attrs,
693 };
694 
695 /*
696  * /sys/class/gpio/export ... write-only
697  *	integer N ... number of GPIO to export (full access)
698  * /sys/class/gpio/unexport ... write-only
699  *	integer N ... number of GPIO to unexport
700  */
701 static ssize_t export_store(struct class *class,
702 				struct class_attribute *attr,
703 				const char *buf, size_t len)
704 {
705 	long			gpio;
706 	struct gpio_desc	*desc;
707 	int			status;
708 
709 	status = kstrtol(buf, 0, &gpio);
710 	if (status < 0)
711 		goto done;
712 
713 	desc = gpio_to_desc(gpio);
714 	/* reject invalid GPIOs */
715 	if (!desc) {
716 		pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
717 		return -EINVAL;
718 	}
719 
720 	/* No extra locking here; FLAG_SYSFS just signifies that the
721 	 * request and export were done by on behalf of userspace, so
722 	 * they may be undone on its behalf too.
723 	 */
724 
725 	status = gpiod_request(desc, "sysfs");
726 	if (status < 0) {
727 		if (status == -EPROBE_DEFER)
728 			status = -ENODEV;
729 		goto done;
730 	}
731 	status = gpiod_export(desc, true);
732 	if (status < 0)
733 		gpiod_free(desc);
734 	else
735 		set_bit(FLAG_SYSFS, &desc->flags);
736 
737 done:
738 	if (status)
739 		pr_debug("%s: status %d\n", __func__, status);
740 	return status ? : len;
741 }
742 
743 static ssize_t unexport_store(struct class *class,
744 				struct class_attribute *attr,
745 				const char *buf, size_t len)
746 {
747 	long			gpio;
748 	struct gpio_desc	*desc;
749 	int			status;
750 
751 	status = kstrtol(buf, 0, &gpio);
752 	if (status < 0)
753 		goto done;
754 
755 	desc = gpio_to_desc(gpio);
756 	/* reject bogus commands (gpio_unexport ignores them) */
757 	if (!desc) {
758 		pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
759 		return -EINVAL;
760 	}
761 
762 	status = -EINVAL;
763 
764 	/* No extra locking here; FLAG_SYSFS just signifies that the
765 	 * request and export were done by on behalf of userspace, so
766 	 * they may be undone on its behalf too.
767 	 */
768 	if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
769 		status = 0;
770 		gpiod_free(desc);
771 	}
772 done:
773 	if (status)
774 		pr_debug("%s: status %d\n", __func__, status);
775 	return status ? : len;
776 }
777 
778 static struct class_attribute gpio_class_attrs[] = {
779 	__ATTR(export, 0200, NULL, export_store),
780 	__ATTR(unexport, 0200, NULL, unexport_store),
781 	__ATTR_NULL,
782 };
783 
784 static struct class gpio_class = {
785 	.name =		"gpio",
786 	.owner =	THIS_MODULE,
787 
788 	.class_attrs =	gpio_class_attrs,
789 };
790 
791 
792 /**
793  * gpiod_export - export a GPIO through sysfs
794  * @gpio: gpio to make available, already requested
795  * @direction_may_change: true if userspace may change gpio direction
796  * Context: arch_initcall or later
797  *
798  * When drivers want to make a GPIO accessible to userspace after they
799  * have requested it -- perhaps while debugging, or as part of their
800  * public interface -- they may use this routine.  If the GPIO can
801  * change direction (some can't) and the caller allows it, userspace
802  * will see "direction" sysfs attribute which may be used to change
803  * the gpio's direction.  A "value" attribute will always be provided.
804  *
805  * Returns zero on success, else an error.
806  */
807 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
808 {
809 	unsigned long		flags;
810 	int			status;
811 	const char		*ioname = NULL;
812 	struct device		*dev;
813 	int			offset;
814 
815 	/* can't export until sysfs is available ... */
816 	if (!gpio_class.p) {
817 		pr_debug("%s: called too early!\n", __func__);
818 		return -ENOENT;
819 	}
820 
821 	if (!desc) {
822 		pr_debug("%s: invalid gpio descriptor\n", __func__);
823 		return -EINVAL;
824 	}
825 
826 	mutex_lock(&sysfs_lock);
827 
828 	spin_lock_irqsave(&gpio_lock, flags);
829 	if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
830 	     test_bit(FLAG_EXPORT, &desc->flags)) {
831 		spin_unlock_irqrestore(&gpio_lock, flags);
832 		gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
833 				__func__,
834 				test_bit(FLAG_REQUESTED, &desc->flags),
835 				test_bit(FLAG_EXPORT, &desc->flags));
836 		status = -EPERM;
837 		goto fail_unlock;
838 	}
839 
840 	if (!desc->chip->direction_input || !desc->chip->direction_output)
841 		direction_may_change = false;
842 	spin_unlock_irqrestore(&gpio_lock, flags);
843 
844 	offset = gpio_chip_hwgpio(desc);
845 	if (desc->chip->names && desc->chip->names[offset])
846 		ioname = desc->chip->names[offset];
847 
848 	dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
849 			    desc, ioname ? ioname : "gpio%u",
850 			    desc_to_gpio(desc));
851 	if (IS_ERR(dev)) {
852 		status = PTR_ERR(dev);
853 		goto fail_unlock;
854 	}
855 
856 	status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
857 	if (status)
858 		goto fail_unregister_device;
859 
860 	if (direction_may_change) {
861 		status = device_create_file(dev, &dev_attr_direction);
862 		if (status)
863 			goto fail_unregister_device;
864 	}
865 
866 	if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
867 				       !test_bit(FLAG_IS_OUT, &desc->flags))) {
868 		status = device_create_file(dev, &dev_attr_edge);
869 		if (status)
870 			goto fail_unregister_device;
871 	}
872 
873 	set_bit(FLAG_EXPORT, &desc->flags);
874 	mutex_unlock(&sysfs_lock);
875 	return 0;
876 
877 fail_unregister_device:
878 	device_unregister(dev);
879 fail_unlock:
880 	mutex_unlock(&sysfs_lock);
881 	gpiod_dbg(desc, "%s: status %d\n", __func__, status);
882 	return status;
883 }
884 EXPORT_SYMBOL_GPL(gpiod_export);
885 
886 static int match_export(struct device *dev, const void *data)
887 {
888 	return dev_get_drvdata(dev) == data;
889 }
890 
891 /**
892  * gpiod_export_link - create a sysfs link to an exported GPIO node
893  * @dev: device under which to create symlink
894  * @name: name of the symlink
895  * @gpio: gpio to create symlink to, already exported
896  *
897  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
898  * node. Caller is responsible for unlinking.
899  *
900  * Returns zero on success, else an error.
901  */
902 int gpiod_export_link(struct device *dev, const char *name,
903 		      struct gpio_desc *desc)
904 {
905 	int			status = -EINVAL;
906 
907 	if (!desc) {
908 		pr_warn("%s: invalid GPIO\n", __func__);
909 		return -EINVAL;
910 	}
911 
912 	mutex_lock(&sysfs_lock);
913 
914 	if (test_bit(FLAG_EXPORT, &desc->flags)) {
915 		struct device *tdev;
916 
917 		tdev = class_find_device(&gpio_class, NULL, desc, match_export);
918 		if (tdev != NULL) {
919 			status = sysfs_create_link(&dev->kobj, &tdev->kobj,
920 						name);
921 		} else {
922 			status = -ENODEV;
923 		}
924 	}
925 
926 	mutex_unlock(&sysfs_lock);
927 
928 	if (status)
929 		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
930 
931 	return status;
932 }
933 EXPORT_SYMBOL_GPL(gpiod_export_link);
934 
935 /**
936  * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
937  * @gpio: gpio to change
938  * @value: non-zero to use active low, i.e. inverted values
939  *
940  * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
941  * The GPIO does not have to be exported yet.  If poll(2) support has
942  * been enabled for either rising or falling edge, it will be
943  * reconfigured to follow the new polarity.
944  *
945  * Returns zero on success, else an error.
946  */
947 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
948 {
949 	struct device		*dev = NULL;
950 	int			status = -EINVAL;
951 
952 	if (!desc) {
953 		pr_warn("%s: invalid GPIO\n", __func__);
954 		return -EINVAL;
955 	}
956 
957 	mutex_lock(&sysfs_lock);
958 
959 	if (test_bit(FLAG_EXPORT, &desc->flags)) {
960 		dev = class_find_device(&gpio_class, NULL, desc, match_export);
961 		if (dev == NULL) {
962 			status = -ENODEV;
963 			goto unlock;
964 		}
965 	}
966 
967 	status = sysfs_set_active_low(desc, dev, value);
968 
969 unlock:
970 	mutex_unlock(&sysfs_lock);
971 
972 	if (status)
973 		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
974 
975 	return status;
976 }
977 EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low);
978 
979 /**
980  * gpiod_unexport - reverse effect of gpio_export()
981  * @gpio: gpio to make unavailable
982  *
983  * This is implicit on gpio_free().
984  */
985 void gpiod_unexport(struct gpio_desc *desc)
986 {
987 	int			status = 0;
988 	struct device		*dev = NULL;
989 
990 	if (!desc) {
991 		pr_warn("%s: invalid GPIO\n", __func__);
992 		return;
993 	}
994 
995 	mutex_lock(&sysfs_lock);
996 
997 	if (test_bit(FLAG_EXPORT, &desc->flags)) {
998 
999 		dev = class_find_device(&gpio_class, NULL, desc, match_export);
1000 		if (dev) {
1001 			gpio_setup_irq(desc, dev, 0);
1002 			clear_bit(FLAG_EXPORT, &desc->flags);
1003 		} else
1004 			status = -ENODEV;
1005 	}
1006 
1007 	mutex_unlock(&sysfs_lock);
1008 
1009 	if (dev) {
1010 		device_unregister(dev);
1011 		put_device(dev);
1012 	}
1013 
1014 	if (status)
1015 		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1016 }
1017 EXPORT_SYMBOL_GPL(gpiod_unexport);
1018 
1019 static int gpiochip_export(struct gpio_chip *chip)
1020 {
1021 	int		status;
1022 	struct device	*dev;
1023 
1024 	/* Many systems register gpio chips for SOC support very early,
1025 	 * before driver model support is available.  In those cases we
1026 	 * export this later, in gpiolib_sysfs_init() ... here we just
1027 	 * verify that _some_ field of gpio_class got initialized.
1028 	 */
1029 	if (!gpio_class.p)
1030 		return 0;
1031 
1032 	/* use chip->base for the ID; it's already known to be unique */
1033 	mutex_lock(&sysfs_lock);
1034 	dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1035 				"gpiochip%d", chip->base);
1036 	if (!IS_ERR(dev)) {
1037 		status = sysfs_create_group(&dev->kobj,
1038 				&gpiochip_attr_group);
1039 	} else
1040 		status = PTR_ERR(dev);
1041 	chip->exported = (status == 0);
1042 	mutex_unlock(&sysfs_lock);
1043 
1044 	if (status) {
1045 		unsigned long	flags;
1046 		unsigned	gpio;
1047 
1048 		spin_lock_irqsave(&gpio_lock, flags);
1049 		gpio = 0;
1050 		while (gpio < chip->ngpio)
1051 			chip->desc[gpio++].chip = NULL;
1052 		spin_unlock_irqrestore(&gpio_lock, flags);
1053 
1054 		chip_dbg(chip, "%s: status %d\n", __func__, status);
1055 	}
1056 
1057 	return status;
1058 }
1059 
1060 static void gpiochip_unexport(struct gpio_chip *chip)
1061 {
1062 	int			status;
1063 	struct device		*dev;
1064 
1065 	mutex_lock(&sysfs_lock);
1066 	dev = class_find_device(&gpio_class, NULL, chip, match_export);
1067 	if (dev) {
1068 		put_device(dev);
1069 		device_unregister(dev);
1070 		chip->exported = false;
1071 		status = 0;
1072 	} else
1073 		status = -ENODEV;
1074 	mutex_unlock(&sysfs_lock);
1075 
1076 	if (status)
1077 		chip_dbg(chip, "%s: status %d\n", __func__, status);
1078 }
1079 
1080 static int __init gpiolib_sysfs_init(void)
1081 {
1082 	int		status;
1083 	unsigned long	flags;
1084 	struct gpio_chip *chip;
1085 
1086 	status = class_register(&gpio_class);
1087 	if (status < 0)
1088 		return status;
1089 
1090 	/* Scan and register the gpio_chips which registered very
1091 	 * early (e.g. before the class_register above was called).
1092 	 *
1093 	 * We run before arch_initcall() so chip->dev nodes can have
1094 	 * registered, and so arch_initcall() can always gpio_export().
1095 	 */
1096 	spin_lock_irqsave(&gpio_lock, flags);
1097 	list_for_each_entry(chip, &gpio_chips, list) {
1098 		if (!chip || chip->exported)
1099 			continue;
1100 
1101 		spin_unlock_irqrestore(&gpio_lock, flags);
1102 		status = gpiochip_export(chip);
1103 		spin_lock_irqsave(&gpio_lock, flags);
1104 	}
1105 	spin_unlock_irqrestore(&gpio_lock, flags);
1106 
1107 
1108 	return status;
1109 }
1110 postcore_initcall(gpiolib_sysfs_init);
1111 
1112 #else
1113 static inline int gpiochip_export(struct gpio_chip *chip)
1114 {
1115 	return 0;
1116 }
1117 
1118 static inline void gpiochip_unexport(struct gpio_chip *chip)
1119 {
1120 }
1121 
1122 #endif /* CONFIG_GPIO_SYSFS */
1123 
1124 /*
1125  * Add a new chip to the global chips list, keeping the list of chips sorted
1126  * by base order.
1127  *
1128  * Return -EBUSY if the new chip overlaps with some other chip's integer
1129  * space.
1130  */
1131 static int gpiochip_add_to_list(struct gpio_chip *chip)
1132 {
1133 	struct list_head *pos = &gpio_chips;
1134 	struct gpio_chip *_chip;
1135 	int err = 0;
1136 
1137 	/* find where to insert our chip */
1138 	list_for_each(pos, &gpio_chips) {
1139 		_chip = list_entry(pos, struct gpio_chip, list);
1140 		/* shall we insert before _chip? */
1141 		if (_chip->base >= chip->base + chip->ngpio)
1142 			break;
1143 	}
1144 
1145 	/* are we stepping on the chip right before? */
1146 	if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1147 		_chip = list_entry(pos->prev, struct gpio_chip, list);
1148 		if (_chip->base + _chip->ngpio > chip->base) {
1149 			dev_err(chip->dev,
1150 			       "GPIO integer space overlap, cannot add chip\n");
1151 			err = -EBUSY;
1152 		}
1153 	}
1154 
1155 	if (!err)
1156 		list_add_tail(&chip->list, pos);
1157 
1158 	return err;
1159 }
1160 
1161 /**
1162  * gpiochip_add() - register a gpio_chip
1163  * @chip: the chip to register, with chip->base initialized
1164  * Context: potentially before irqs or kmalloc will work
1165  *
1166  * Returns a negative errno if the chip can't be registered, such as
1167  * because the chip->base is invalid or already associated with a
1168  * different chip.  Otherwise it returns zero as a success code.
1169  *
1170  * When gpiochip_add() is called very early during boot, so that GPIOs
1171  * can be freely used, the chip->dev device must be registered before
1172  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1173  * for GPIOs will fail rudely.
1174  *
1175  * If chip->base is negative, this requests dynamic assignment of
1176  * a range of valid GPIOs.
1177  */
1178 int gpiochip_add(struct gpio_chip *chip)
1179 {
1180 	unsigned long	flags;
1181 	int		status = 0;
1182 	unsigned	id;
1183 	int		base = chip->base;
1184 
1185 	if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1186 			&& base >= 0) {
1187 		status = -EINVAL;
1188 		goto fail;
1189 	}
1190 
1191 	spin_lock_irqsave(&gpio_lock, flags);
1192 
1193 	if (base < 0) {
1194 		base = gpiochip_find_base(chip->ngpio);
1195 		if (base < 0) {
1196 			status = base;
1197 			goto unlock;
1198 		}
1199 		chip->base = base;
1200 	}
1201 
1202 	status = gpiochip_add_to_list(chip);
1203 
1204 	if (status == 0) {
1205 		chip->desc = &gpio_desc[chip->base];
1206 
1207 		for (id = 0; id < chip->ngpio; id++) {
1208 			struct gpio_desc *desc = &chip->desc[id];
1209 			desc->chip = chip;
1210 
1211 			/* REVISIT:  most hardware initializes GPIOs as
1212 			 * inputs (often with pullups enabled) so power
1213 			 * usage is minimized.  Linux code should set the
1214 			 * gpio direction first thing; but until it does,
1215 			 * and in case chip->get_direction is not set,
1216 			 * we may expose the wrong direction in sysfs.
1217 			 */
1218 			desc->flags = !chip->direction_input
1219 				? (1 << FLAG_IS_OUT)
1220 				: 0;
1221 		}
1222 	}
1223 
1224 	spin_unlock_irqrestore(&gpio_lock, flags);
1225 
1226 #ifdef CONFIG_PINCTRL
1227 	INIT_LIST_HEAD(&chip->pin_ranges);
1228 #endif
1229 
1230 	of_gpiochip_add(chip);
1231 	acpi_gpiochip_add(chip);
1232 
1233 	if (status)
1234 		goto fail;
1235 
1236 	status = gpiochip_export(chip);
1237 	if (status)
1238 		goto fail;
1239 
1240 	pr_debug("%s: registered GPIOs %d to %d on device: %s\n", __func__,
1241 		chip->base, chip->base + chip->ngpio - 1,
1242 		chip->label ? : "generic");
1243 
1244 	return 0;
1245 
1246 unlock:
1247 	spin_unlock_irqrestore(&gpio_lock, flags);
1248 fail:
1249 	/* failures here can mean systems won't boot... */
1250 	pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1251 		chip->base, chip->base + chip->ngpio - 1,
1252 		chip->label ? : "generic");
1253 	return status;
1254 }
1255 EXPORT_SYMBOL_GPL(gpiochip_add);
1256 
1257 /* Forward-declaration */
1258 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
1259 
1260 /**
1261  * gpiochip_remove() - unregister a gpio_chip
1262  * @chip: the chip to unregister
1263  *
1264  * A gpio_chip with any GPIOs still requested may not be removed.
1265  */
1266 int gpiochip_remove(struct gpio_chip *chip)
1267 {
1268 	unsigned long	flags;
1269 	int		status = 0;
1270 	unsigned	id;
1271 
1272 	acpi_gpiochip_remove(chip);
1273 
1274 	spin_lock_irqsave(&gpio_lock, flags);
1275 
1276 	gpiochip_irqchip_remove(chip);
1277 	gpiochip_remove_pin_ranges(chip);
1278 	of_gpiochip_remove(chip);
1279 
1280 	for (id = 0; id < chip->ngpio; id++) {
1281 		if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
1282 			status = -EBUSY;
1283 			break;
1284 		}
1285 	}
1286 	if (status == 0) {
1287 		for (id = 0; id < chip->ngpio; id++)
1288 			chip->desc[id].chip = NULL;
1289 
1290 		list_del(&chip->list);
1291 	}
1292 
1293 	spin_unlock_irqrestore(&gpio_lock, flags);
1294 
1295 	if (status == 0)
1296 		gpiochip_unexport(chip);
1297 
1298 	return status;
1299 }
1300 EXPORT_SYMBOL_GPL(gpiochip_remove);
1301 
1302 /**
1303  * gpiochip_find() - iterator for locating a specific gpio_chip
1304  * @data: data to pass to match function
1305  * @callback: Callback function to check gpio_chip
1306  *
1307  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1308  * determined by a user supplied @match callback.  The callback should return
1309  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1310  * non-zero, this function will return to the caller and not iterate over any
1311  * more gpio_chips.
1312  */
1313 struct gpio_chip *gpiochip_find(void *data,
1314 				int (*match)(struct gpio_chip *chip,
1315 					     void *data))
1316 {
1317 	struct gpio_chip *chip;
1318 	unsigned long flags;
1319 
1320 	spin_lock_irqsave(&gpio_lock, flags);
1321 	list_for_each_entry(chip, &gpio_chips, list)
1322 		if (match(chip, data))
1323 			break;
1324 
1325 	/* No match? */
1326 	if (&chip->list == &gpio_chips)
1327 		chip = NULL;
1328 	spin_unlock_irqrestore(&gpio_lock, flags);
1329 
1330 	return chip;
1331 }
1332 EXPORT_SYMBOL_GPL(gpiochip_find);
1333 
1334 static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1335 {
1336 	const char *name = data;
1337 
1338 	return !strcmp(chip->label, name);
1339 }
1340 
1341 static struct gpio_chip *find_chip_by_name(const char *name)
1342 {
1343 	return gpiochip_find((void *)name, gpiochip_match_name);
1344 }
1345 
1346 #ifdef CONFIG_GPIOLIB_IRQCHIP
1347 
1348 /*
1349  * The following is irqchip helper code for gpiochips.
1350  */
1351 
1352 /**
1353  * gpiochip_add_chained_irqchip() - adds a chained irqchip to a gpiochip
1354  * @gpiochip: the gpiochip to add the irqchip to
1355  * @irqchip: the irqchip to add to the gpiochip
1356  * @parent_irq: the irq number corresponding to the parent IRQ for this
1357  * chained irqchip
1358  * @parent_handler: the parent interrupt handler for the accumulated IRQ
1359  * coming out of the gpiochip
1360  */
1361 void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
1362 				  struct irq_chip *irqchip,
1363 				  int parent_irq,
1364 				  irq_flow_handler_t parent_handler)
1365 {
1366 	irq_set_chained_handler(parent_irq, parent_handler);
1367 	/*
1368 	 * The parent irqchip is already using the chip_data for this
1369 	 * irqchip, so our callbacks simply use the handler_data.
1370 	 */
1371 	irq_set_handler_data(parent_irq, gpiochip);
1372 }
1373 EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
1374 
1375 /**
1376  * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
1377  * @d: the irqdomain used by this irqchip
1378  * @irq: the global irq number used by this GPIO irqchip irq
1379  * @hwirq: the local IRQ/GPIO line offset on this gpiochip
1380  *
1381  * This function will set up the mapping for a certain IRQ line on a
1382  * gpiochip by assigning the gpiochip as chip data, and using the irqchip
1383  * stored inside the gpiochip.
1384  */
1385 static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
1386 			    irq_hw_number_t hwirq)
1387 {
1388 	struct gpio_chip *chip = d->host_data;
1389 
1390 	irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
1391 	irq_set_chip_data(irq, chip);
1392 #ifdef CONFIG_ARM
1393 	set_irq_flags(irq, IRQF_VALID);
1394 #else
1395 	irq_set_noprobe(irq);
1396 #endif
1397 	irq_set_irq_type(irq, chip->irq_default_type);
1398 
1399 	return 0;
1400 }
1401 
1402 static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
1403 {
1404 #ifdef CONFIG_ARM
1405 	set_irq_flags(irq, 0);
1406 #endif
1407 	irq_set_chip_and_handler(irq, NULL, NULL);
1408 	irq_set_chip_data(irq, NULL);
1409 }
1410 
1411 static const struct irq_domain_ops gpiochip_domain_ops = {
1412 	.map	= gpiochip_irq_map,
1413 	.unmap	= gpiochip_irq_unmap,
1414 	/* Virtually all GPIO irqchips are twocell:ed */
1415 	.xlate	= irq_domain_xlate_twocell,
1416 };
1417 
1418 static int gpiochip_irq_reqres(struct irq_data *d)
1419 {
1420 	struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1421 
1422 	if (gpio_lock_as_irq(chip, d->hwirq)) {
1423 		chip_err(chip,
1424 			"unable to lock HW IRQ %lu for IRQ\n",
1425 			d->hwirq);
1426 		return -EINVAL;
1427 	}
1428 	return 0;
1429 }
1430 
1431 static void gpiochip_irq_relres(struct irq_data *d)
1432 {
1433 	struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1434 
1435 	gpio_unlock_as_irq(chip, d->hwirq);
1436 }
1437 
1438 static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
1439 {
1440 	return irq_find_mapping(chip->irqdomain, offset);
1441 }
1442 
1443 /**
1444  * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
1445  * @gpiochip: the gpiochip to remove the irqchip from
1446  *
1447  * This is called only from gpiochip_remove()
1448  */
1449 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
1450 {
1451 	unsigned int offset;
1452 
1453 	/* Remove all IRQ mappings and delete the domain */
1454 	if (gpiochip->irqdomain) {
1455 		for (offset = 0; offset < gpiochip->ngpio; offset++)
1456 			irq_dispose_mapping(gpiochip->irq_base + offset);
1457 		irq_domain_remove(gpiochip->irqdomain);
1458 	}
1459 
1460 	if (gpiochip->irqchip) {
1461 		gpiochip->irqchip->irq_request_resources = NULL;
1462 		gpiochip->irqchip->irq_release_resources = NULL;
1463 		gpiochip->irqchip = NULL;
1464 	}
1465 }
1466 
1467 /**
1468  * gpiochip_irqchip_add() - adds an irqchip to a gpiochip
1469  * @gpiochip: the gpiochip to add the irqchip to
1470  * @irqchip: the irqchip to add to the gpiochip
1471  * @first_irq: if not dynamically assigned, the base (first) IRQ to
1472  * allocate gpiochip irqs from
1473  * @handler: the irq handler to use (often a predefined irq core function)
1474  * @type: the default type for IRQs on this irqchip
1475  *
1476  * This function closely associates a certain irqchip with a certain
1477  * gpiochip, providing an irq domain to translate the local IRQs to
1478  * global irqs in the gpiolib core, and making sure that the gpiochip
1479  * is passed as chip data to all related functions. Driver callbacks
1480  * need to use container_of() to get their local state containers back
1481  * from the gpiochip passed as chip data. An irqdomain will be stored
1482  * in the gpiochip that shall be used by the driver to handle IRQ number
1483  * translation. The gpiochip will need to be initialized and registered
1484  * before calling this function.
1485  *
1486  * This function will handle two cell:ed simple IRQs and assumes all
1487  * the pins on the gpiochip can generate a unique IRQ. Everything else
1488  * need to be open coded.
1489  */
1490 int gpiochip_irqchip_add(struct gpio_chip *gpiochip,
1491 			 struct irq_chip *irqchip,
1492 			 unsigned int first_irq,
1493 			 irq_flow_handler_t handler,
1494 			 unsigned int type)
1495 {
1496 	struct device_node *of_node;
1497 	unsigned int offset;
1498 	unsigned irq_base = 0;
1499 
1500 	if (!gpiochip || !irqchip)
1501 		return -EINVAL;
1502 
1503 	if (!gpiochip->dev) {
1504 		pr_err("missing gpiochip .dev parent pointer\n");
1505 		return -EINVAL;
1506 	}
1507 	of_node = gpiochip->dev->of_node;
1508 #ifdef CONFIG_OF_GPIO
1509 	/*
1510 	 * If the gpiochip has an assigned OF node this takes precendence
1511 	 * FIXME: get rid of this and use gpiochip->dev->of_node everywhere
1512 	 */
1513 	if (gpiochip->of_node)
1514 		of_node = gpiochip->of_node;
1515 #endif
1516 	gpiochip->irqchip = irqchip;
1517 	gpiochip->irq_handler = handler;
1518 	gpiochip->irq_default_type = type;
1519 	gpiochip->to_irq = gpiochip_to_irq;
1520 	gpiochip->irqdomain = irq_domain_add_simple(of_node,
1521 					gpiochip->ngpio, first_irq,
1522 					&gpiochip_domain_ops, gpiochip);
1523 	if (!gpiochip->irqdomain) {
1524 		gpiochip->irqchip = NULL;
1525 		return -EINVAL;
1526 	}
1527 	irqchip->irq_request_resources = gpiochip_irq_reqres;
1528 	irqchip->irq_release_resources = gpiochip_irq_relres;
1529 
1530 	/*
1531 	 * Prepare the mapping since the irqchip shall be orthogonal to
1532 	 * any gpiochip calls. If the first_irq was zero, this is
1533 	 * necessary to allocate descriptors for all IRQs.
1534 	 */
1535 	for (offset = 0; offset < gpiochip->ngpio; offset++) {
1536 		irq_base = irq_create_mapping(gpiochip->irqdomain, offset);
1537 		if (offset == 0)
1538 			/*
1539 			 * Store the base into the gpiochip to be used when
1540 			 * unmapping the irqs.
1541 			 */
1542 			gpiochip->irq_base = irq_base;
1543 	}
1544 
1545 	return 0;
1546 }
1547 EXPORT_SYMBOL_GPL(gpiochip_irqchip_add);
1548 
1549 #else /* CONFIG_GPIOLIB_IRQCHIP */
1550 
1551 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1552 
1553 #endif /* CONFIG_GPIOLIB_IRQCHIP */
1554 
1555 #ifdef CONFIG_PINCTRL
1556 
1557 /**
1558  * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
1559  * @chip: the gpiochip to add the range for
1560  * @pinctrl: the dev_name() of the pin controller to map to
1561  * @gpio_offset: the start offset in the current gpio_chip number space
1562  * @pin_group: name of the pin group inside the pin controller
1563  */
1564 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
1565 			struct pinctrl_dev *pctldev,
1566 			unsigned int gpio_offset, const char *pin_group)
1567 {
1568 	struct gpio_pin_range *pin_range;
1569 	int ret;
1570 
1571 	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1572 	if (!pin_range) {
1573 		chip_err(chip, "failed to allocate pin ranges\n");
1574 		return -ENOMEM;
1575 	}
1576 
1577 	/* Use local offset as range ID */
1578 	pin_range->range.id = gpio_offset;
1579 	pin_range->range.gc = chip;
1580 	pin_range->range.name = chip->label;
1581 	pin_range->range.base = chip->base + gpio_offset;
1582 	pin_range->pctldev = pctldev;
1583 
1584 	ret = pinctrl_get_group_pins(pctldev, pin_group,
1585 					&pin_range->range.pins,
1586 					&pin_range->range.npins);
1587 	if (ret < 0) {
1588 		kfree(pin_range);
1589 		return ret;
1590 	}
1591 
1592 	pinctrl_add_gpio_range(pctldev, &pin_range->range);
1593 
1594 	chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
1595 		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
1596 		 pinctrl_dev_get_devname(pctldev), pin_group);
1597 
1598 	list_add_tail(&pin_range->node, &chip->pin_ranges);
1599 
1600 	return 0;
1601 }
1602 EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
1603 
1604 /**
1605  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1606  * @chip: the gpiochip to add the range for
1607  * @pinctrl_name: the dev_name() of the pin controller to map to
1608  * @gpio_offset: the start offset in the current gpio_chip number space
1609  * @pin_offset: the start offset in the pin controller number space
1610  * @npins: the number of pins from the offset of each pin space (GPIO and
1611  *	pin controller) to accumulate in this range
1612  */
1613 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1614 			   unsigned int gpio_offset, unsigned int pin_offset,
1615 			   unsigned int npins)
1616 {
1617 	struct gpio_pin_range *pin_range;
1618 	int ret;
1619 
1620 	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1621 	if (!pin_range) {
1622 		chip_err(chip, "failed to allocate pin ranges\n");
1623 		return -ENOMEM;
1624 	}
1625 
1626 	/* Use local offset as range ID */
1627 	pin_range->range.id = gpio_offset;
1628 	pin_range->range.gc = chip;
1629 	pin_range->range.name = chip->label;
1630 	pin_range->range.base = chip->base + gpio_offset;
1631 	pin_range->range.pin_base = pin_offset;
1632 	pin_range->range.npins = npins;
1633 	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1634 			&pin_range->range);
1635 	if (IS_ERR(pin_range->pctldev)) {
1636 		ret = PTR_ERR(pin_range->pctldev);
1637 		chip_err(chip, "could not create pin range\n");
1638 		kfree(pin_range);
1639 		return ret;
1640 	}
1641 	chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
1642 		 gpio_offset, gpio_offset + npins - 1,
1643 		 pinctl_name,
1644 		 pin_offset, pin_offset + npins - 1);
1645 
1646 	list_add_tail(&pin_range->node, &chip->pin_ranges);
1647 
1648 	return 0;
1649 }
1650 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1651 
1652 /**
1653  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1654  * @chip: the chip to remove all the mappings for
1655  */
1656 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1657 {
1658 	struct gpio_pin_range *pin_range, *tmp;
1659 
1660 	list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1661 		list_del(&pin_range->node);
1662 		pinctrl_remove_gpio_range(pin_range->pctldev,
1663 				&pin_range->range);
1664 		kfree(pin_range);
1665 	}
1666 }
1667 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1668 
1669 #endif /* CONFIG_PINCTRL */
1670 
1671 /* These "optional" allocation calls help prevent drivers from stomping
1672  * on each other, and help provide better diagnostics in debugfs.
1673  * They're called even less than the "set direction" calls.
1674  */
1675 static int __gpiod_request(struct gpio_desc *desc, const char *label)
1676 {
1677 	struct gpio_chip	*chip = desc->chip;
1678 	int			status;
1679 	unsigned long		flags;
1680 
1681 	spin_lock_irqsave(&gpio_lock, flags);
1682 
1683 	/* NOTE:  gpio_request() can be called in early boot,
1684 	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1685 	 */
1686 
1687 	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1688 		desc_set_label(desc, label ? : "?");
1689 		status = 0;
1690 	} else {
1691 		status = -EBUSY;
1692 		goto done;
1693 	}
1694 
1695 	if (chip->request) {
1696 		/* chip->request may sleep */
1697 		spin_unlock_irqrestore(&gpio_lock, flags);
1698 		status = chip->request(chip, gpio_chip_hwgpio(desc));
1699 		spin_lock_irqsave(&gpio_lock, flags);
1700 
1701 		if (status < 0) {
1702 			desc_set_label(desc, NULL);
1703 			clear_bit(FLAG_REQUESTED, &desc->flags);
1704 			goto done;
1705 		}
1706 	}
1707 	if (chip->get_direction) {
1708 		/* chip->get_direction may sleep */
1709 		spin_unlock_irqrestore(&gpio_lock, flags);
1710 		gpiod_get_direction(desc);
1711 		spin_lock_irqsave(&gpio_lock, flags);
1712 	}
1713 done:
1714 	spin_unlock_irqrestore(&gpio_lock, flags);
1715 	return status;
1716 }
1717 
1718 static int gpiod_request(struct gpio_desc *desc, const char *label)
1719 {
1720 	int status = -EPROBE_DEFER;
1721 	struct gpio_chip *chip;
1722 
1723 	if (!desc) {
1724 		pr_warn("%s: invalid GPIO\n", __func__);
1725 		return -EINVAL;
1726 	}
1727 
1728 	chip = desc->chip;
1729 	if (!chip)
1730 		goto done;
1731 
1732 	if (try_module_get(chip->owner)) {
1733 		status = __gpiod_request(desc, label);
1734 		if (status < 0)
1735 			module_put(chip->owner);
1736 	}
1737 
1738 done:
1739 	if (status)
1740 		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1741 
1742 	return status;
1743 }
1744 
1745 int gpio_request(unsigned gpio, const char *label)
1746 {
1747 	return gpiod_request(gpio_to_desc(gpio), label);
1748 }
1749 EXPORT_SYMBOL_GPL(gpio_request);
1750 
1751 static bool __gpiod_free(struct gpio_desc *desc)
1752 {
1753 	bool			ret = false;
1754 	unsigned long		flags;
1755 	struct gpio_chip	*chip;
1756 
1757 	might_sleep();
1758 
1759 	gpiod_unexport(desc);
1760 
1761 	spin_lock_irqsave(&gpio_lock, flags);
1762 
1763 	chip = desc->chip;
1764 	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1765 		if (chip->free) {
1766 			spin_unlock_irqrestore(&gpio_lock, flags);
1767 			might_sleep_if(chip->can_sleep);
1768 			chip->free(chip, gpio_chip_hwgpio(desc));
1769 			spin_lock_irqsave(&gpio_lock, flags);
1770 		}
1771 		desc_set_label(desc, NULL);
1772 		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1773 		clear_bit(FLAG_REQUESTED, &desc->flags);
1774 		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1775 		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1776 		ret = true;
1777 	}
1778 
1779 	spin_unlock_irqrestore(&gpio_lock, flags);
1780 	return ret;
1781 }
1782 
1783 static void gpiod_free(struct gpio_desc *desc)
1784 {
1785 	if (desc && __gpiod_free(desc))
1786 		module_put(desc->chip->owner);
1787 	else
1788 		WARN_ON(extra_checks);
1789 }
1790 
1791 void gpio_free(unsigned gpio)
1792 {
1793 	gpiod_free(gpio_to_desc(gpio));
1794 }
1795 EXPORT_SYMBOL_GPL(gpio_free);
1796 
1797 /**
1798  * gpio_request_one - request a single GPIO with initial configuration
1799  * @gpio:	the GPIO number
1800  * @flags:	GPIO configuration as specified by GPIOF_*
1801  * @label:	a literal description string of this GPIO
1802  */
1803 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1804 {
1805 	struct gpio_desc *desc;
1806 	int err;
1807 
1808 	desc = gpio_to_desc(gpio);
1809 
1810 	err = gpiod_request(desc, label);
1811 	if (err)
1812 		return err;
1813 
1814 	if (flags & GPIOF_OPEN_DRAIN)
1815 		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1816 
1817 	if (flags & GPIOF_OPEN_SOURCE)
1818 		set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1819 
1820 	if (flags & GPIOF_DIR_IN)
1821 		err = gpiod_direction_input(desc);
1822 	else
1823 		err = gpiod_direction_output_raw(desc,
1824 				(flags & GPIOF_INIT_HIGH) ? 1 : 0);
1825 
1826 	if (err)
1827 		goto free_gpio;
1828 
1829 	if (flags & GPIOF_EXPORT) {
1830 		err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1831 		if (err)
1832 			goto free_gpio;
1833 	}
1834 
1835 	return 0;
1836 
1837  free_gpio:
1838 	gpiod_free(desc);
1839 	return err;
1840 }
1841 EXPORT_SYMBOL_GPL(gpio_request_one);
1842 
1843 /**
1844  * gpio_request_array - request multiple GPIOs in a single call
1845  * @array:	array of the 'struct gpio'
1846  * @num:	how many GPIOs in the array
1847  */
1848 int gpio_request_array(const struct gpio *array, size_t num)
1849 {
1850 	int i, err;
1851 
1852 	for (i = 0; i < num; i++, array++) {
1853 		err = gpio_request_one(array->gpio, array->flags, array->label);
1854 		if (err)
1855 			goto err_free;
1856 	}
1857 	return 0;
1858 
1859 err_free:
1860 	while (i--)
1861 		gpio_free((--array)->gpio);
1862 	return err;
1863 }
1864 EXPORT_SYMBOL_GPL(gpio_request_array);
1865 
1866 /**
1867  * gpio_free_array - release multiple GPIOs in a single call
1868  * @array:	array of the 'struct gpio'
1869  * @num:	how many GPIOs in the array
1870  */
1871 void gpio_free_array(const struct gpio *array, size_t num)
1872 {
1873 	while (num--)
1874 		gpio_free((array++)->gpio);
1875 }
1876 EXPORT_SYMBOL_GPL(gpio_free_array);
1877 
1878 /**
1879  * gpiochip_is_requested - return string iff signal was requested
1880  * @chip: controller managing the signal
1881  * @offset: of signal within controller's 0..(ngpio - 1) range
1882  *
1883  * Returns NULL if the GPIO is not currently requested, else a string.
1884  * If debugfs support is enabled, the string returned is the label passed
1885  * to gpio_request(); otherwise it is a meaningless constant.
1886  *
1887  * This function is for use by GPIO controller drivers.  The label can
1888  * help with diagnostics, and knowing that the signal is used as a GPIO
1889  * can help avoid accidentally multiplexing it to another controller.
1890  */
1891 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1892 {
1893 	struct gpio_desc *desc;
1894 
1895 	if (!GPIO_OFFSET_VALID(chip, offset))
1896 		return NULL;
1897 
1898 	desc = &chip->desc[offset];
1899 
1900 	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1901 		return NULL;
1902 #ifdef CONFIG_DEBUG_FS
1903 	return desc->label;
1904 #else
1905 	return "?";
1906 #endif
1907 }
1908 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1909 
1910 /**
1911  * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
1912  * @desc: GPIO descriptor to request
1913  * @label: label for the GPIO
1914  *
1915  * Function allows GPIO chip drivers to request and use their own GPIO
1916  * descriptors via gpiolib API. Difference to gpiod_request() is that this
1917  * function will not increase reference count of the GPIO chip module. This
1918  * allows the GPIO chip module to be unloaded as needed (we assume that the
1919  * GPIO chip driver handles freeing the GPIOs it has requested).
1920  */
1921 int gpiochip_request_own_desc(struct gpio_desc *desc, const char *label)
1922 {
1923 	if (!desc || !desc->chip)
1924 		return -EINVAL;
1925 
1926 	return __gpiod_request(desc, label);
1927 }
1928 
1929 /**
1930  * gpiochip_free_own_desc - Free GPIO requested by the chip driver
1931  * @desc: GPIO descriptor to free
1932  *
1933  * Function frees the given GPIO requested previously with
1934  * gpiochip_request_own_desc().
1935  */
1936 void gpiochip_free_own_desc(struct gpio_desc *desc)
1937 {
1938 	if (desc)
1939 		__gpiod_free(desc);
1940 }
1941 
1942 /* Drivers MUST set GPIO direction before making get/set calls.  In
1943  * some cases this is done in early boot, before IRQs are enabled.
1944  *
1945  * As a rule these aren't called more than once (except for drivers
1946  * using the open-drain emulation idiom) so these are natural places
1947  * to accumulate extra debugging checks.  Note that we can't (yet)
1948  * rely on gpio_request() having been called beforehand.
1949  */
1950 
1951 /**
1952  * gpiod_direction_input - set the GPIO direction to input
1953  * @desc:	GPIO to set to input
1954  *
1955  * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
1956  * be called safely on it.
1957  *
1958  * Return 0 in case of success, else an error code.
1959  */
1960 int gpiod_direction_input(struct gpio_desc *desc)
1961 {
1962 	unsigned long		flags;
1963 	struct gpio_chip	*chip;
1964 	int			status = -EINVAL;
1965 	int			offset;
1966 
1967 	if (!desc || !desc->chip) {
1968 		pr_warn("%s: invalid GPIO\n", __func__);
1969 		return -EINVAL;
1970 	}
1971 
1972 	chip = desc->chip;
1973 	if (!chip->get || !chip->direction_input) {
1974 		gpiod_warn(desc,
1975 			"%s: missing get() or direction_input() operations\n",
1976 			__func__);
1977 		return -EIO;
1978 	}
1979 
1980 	spin_lock_irqsave(&gpio_lock, flags);
1981 
1982 	status = gpio_ensure_requested(desc);
1983 	if (status < 0)
1984 		goto fail;
1985 
1986 	/* now we know the gpio is valid and chip won't vanish */
1987 
1988 	spin_unlock_irqrestore(&gpio_lock, flags);
1989 
1990 	might_sleep_if(chip->can_sleep);
1991 
1992 	offset = gpio_chip_hwgpio(desc);
1993 	if (status) {
1994 		status = chip->request(chip, offset);
1995 		if (status < 0) {
1996 			gpiod_dbg(desc, "%s: chip request fail, %d\n",
1997 					__func__, status);
1998 			/* and it's not available to anyone else ...
1999 			 * gpio_request() is the fully clean solution.
2000 			 */
2001 			goto lose;
2002 		}
2003 	}
2004 
2005 	status = chip->direction_input(chip, offset);
2006 	if (status == 0)
2007 		clear_bit(FLAG_IS_OUT, &desc->flags);
2008 
2009 	trace_gpio_direction(desc_to_gpio(desc), 1, status);
2010 lose:
2011 	return status;
2012 fail:
2013 	spin_unlock_irqrestore(&gpio_lock, flags);
2014 	if (status)
2015 		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2016 	return status;
2017 }
2018 EXPORT_SYMBOL_GPL(gpiod_direction_input);
2019 
2020 static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2021 {
2022 	unsigned long		flags;
2023 	struct gpio_chip	*chip;
2024 	int			status = -EINVAL;
2025 	int offset;
2026 
2027 	/* GPIOs used for IRQs shall not be set as output */
2028 	if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
2029 		gpiod_err(desc,
2030 			  "%s: tried to set a GPIO tied to an IRQ as output\n",
2031 			  __func__);
2032 		return -EIO;
2033 	}
2034 
2035 	/* Open drain pin should not be driven to 1 */
2036 	if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
2037 		return gpiod_direction_input(desc);
2038 
2039 	/* Open source pin should not be driven to 0 */
2040 	if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
2041 		return gpiod_direction_input(desc);
2042 
2043 	chip = desc->chip;
2044 	if (!chip->set || !chip->direction_output) {
2045 		gpiod_warn(desc,
2046 		       "%s: missing set() or direction_output() operations\n",
2047 		       __func__);
2048 		return -EIO;
2049 	}
2050 
2051 	spin_lock_irqsave(&gpio_lock, flags);
2052 
2053 	status = gpio_ensure_requested(desc);
2054 	if (status < 0)
2055 		goto fail;
2056 
2057 	/* now we know the gpio is valid and chip won't vanish */
2058 
2059 	spin_unlock_irqrestore(&gpio_lock, flags);
2060 
2061 	might_sleep_if(chip->can_sleep);
2062 
2063 	offset = gpio_chip_hwgpio(desc);
2064 	if (status) {
2065 		status = chip->request(chip, offset);
2066 		if (status < 0) {
2067 			gpiod_dbg(desc, "%s: chip request fail, %d\n",
2068 					__func__, status);
2069 			/* and it's not available to anyone else ...
2070 			 * gpio_request() is the fully clean solution.
2071 			 */
2072 			goto lose;
2073 		}
2074 	}
2075 
2076 	status = chip->direction_output(chip, offset, value);
2077 	if (status == 0)
2078 		set_bit(FLAG_IS_OUT, &desc->flags);
2079 	trace_gpio_value(desc_to_gpio(desc), 0, value);
2080 	trace_gpio_direction(desc_to_gpio(desc), 0, status);
2081 lose:
2082 	return status;
2083 fail:
2084 	spin_unlock_irqrestore(&gpio_lock, flags);
2085 	if (status)
2086 		gpiod_dbg(desc, "%s: gpio status %d\n", __func__, status);
2087 	return status;
2088 }
2089 
2090 /**
2091  * gpiod_direction_output_raw - set the GPIO direction to output
2092  * @desc:	GPIO to set to output
2093  * @value:	initial output value of the GPIO
2094  *
2095  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2096  * be called safely on it. The initial value of the output must be specified
2097  * as raw value on the physical line without regard for the ACTIVE_LOW status.
2098  *
2099  * Return 0 in case of success, else an error code.
2100  */
2101 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2102 {
2103 	if (!desc || !desc->chip) {
2104 		pr_warn("%s: invalid GPIO\n", __func__);
2105 		return -EINVAL;
2106 	}
2107 	return _gpiod_direction_output_raw(desc, value);
2108 }
2109 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
2110 
2111 /**
2112  * gpiod_direction_output - set the GPIO direction to output
2113  * @desc:	GPIO to set to output
2114  * @value:	initial output value of the GPIO
2115  *
2116  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2117  * be called safely on it. The initial value of the output must be specified
2118  * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2119  * account.
2120  *
2121  * Return 0 in case of success, else an error code.
2122  */
2123 int gpiod_direction_output(struct gpio_desc *desc, int value)
2124 {
2125 	if (!desc || !desc->chip) {
2126 		pr_warn("%s: invalid GPIO\n", __func__);
2127 		return -EINVAL;
2128 	}
2129 	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2130 		value = !value;
2131 	return _gpiod_direction_output_raw(desc, value);
2132 }
2133 EXPORT_SYMBOL_GPL(gpiod_direction_output);
2134 
2135 /**
2136  * gpiod_set_debounce - sets @debounce time for a @gpio
2137  * @gpio: the gpio to set debounce time
2138  * @debounce: debounce time is microseconds
2139  *
2140  * returns -ENOTSUPP if the controller does not support setting
2141  * debounce.
2142  */
2143 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2144 {
2145 	unsigned long		flags;
2146 	struct gpio_chip	*chip;
2147 	int			status = -EINVAL;
2148 	int			offset;
2149 
2150 	if (!desc || !desc->chip) {
2151 		pr_warn("%s: invalid GPIO\n", __func__);
2152 		return -EINVAL;
2153 	}
2154 
2155 	chip = desc->chip;
2156 	if (!chip->set || !chip->set_debounce) {
2157 		gpiod_dbg(desc,
2158 			  "%s: missing set() or set_debounce() operations\n",
2159 			  __func__);
2160 		return -ENOTSUPP;
2161 	}
2162 
2163 	spin_lock_irqsave(&gpio_lock, flags);
2164 
2165 	status = gpio_ensure_requested(desc);
2166 	if (status < 0)
2167 		goto fail;
2168 
2169 	/* now we know the gpio is valid and chip won't vanish */
2170 
2171 	spin_unlock_irqrestore(&gpio_lock, flags);
2172 
2173 	might_sleep_if(chip->can_sleep);
2174 
2175 	offset = gpio_chip_hwgpio(desc);
2176 	return chip->set_debounce(chip, offset, debounce);
2177 
2178 fail:
2179 	spin_unlock_irqrestore(&gpio_lock, flags);
2180 	if (status)
2181 		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2182 
2183 	return status;
2184 }
2185 EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2186 
2187 /**
2188  * gpiod_is_active_low - test whether a GPIO is active-low or not
2189  * @desc: the gpio descriptor to test
2190  *
2191  * Returns 1 if the GPIO is active-low, 0 otherwise.
2192  */
2193 int gpiod_is_active_low(const struct gpio_desc *desc)
2194 {
2195 	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2196 }
2197 EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2198 
2199 /* I/O calls are only valid after configuration completed; the relevant
2200  * "is this a valid GPIO" error checks should already have been done.
2201  *
2202  * "Get" operations are often inlinable as reading a pin value register,
2203  * and masking the relevant bit in that register.
2204  *
2205  * When "set" operations are inlinable, they involve writing that mask to
2206  * one register to set a low value, or a different register to set it high.
2207  * Otherwise locking is needed, so there may be little value to inlining.
2208  *
2209  *------------------------------------------------------------------------
2210  *
2211  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
2212  * have requested the GPIO.  That can include implicit requesting by
2213  * a direction setting call.  Marking a gpio as requested locks its chip
2214  * in memory, guaranteeing that these table lookups need no more locking
2215  * and that gpiochip_remove() will fail.
2216  *
2217  * REVISIT when debugging, consider adding some instrumentation to ensure
2218  * that the GPIO was actually requested.
2219  */
2220 
2221 static bool _gpiod_get_raw_value(const struct gpio_desc *desc)
2222 {
2223 	struct gpio_chip	*chip;
2224 	bool value;
2225 	int offset;
2226 
2227 	chip = desc->chip;
2228 	offset = gpio_chip_hwgpio(desc);
2229 	value = chip->get ? chip->get(chip, offset) : false;
2230 	trace_gpio_value(desc_to_gpio(desc), 1, value);
2231 	return value;
2232 }
2233 
2234 /**
2235  * gpiod_get_raw_value() - return a gpio's raw value
2236  * @desc: gpio whose value will be returned
2237  *
2238  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2239  * its ACTIVE_LOW status.
2240  *
2241  * This function should be called from contexts where we cannot sleep, and will
2242  * complain if the GPIO chip functions potentially sleep.
2243  */
2244 int gpiod_get_raw_value(const struct gpio_desc *desc)
2245 {
2246 	if (!desc)
2247 		return 0;
2248 	/* Should be using gpio_get_value_cansleep() */
2249 	WARN_ON(desc->chip->can_sleep);
2250 	return _gpiod_get_raw_value(desc);
2251 }
2252 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2253 
2254 /**
2255  * gpiod_get_value() - return a gpio's value
2256  * @desc: gpio whose value will be returned
2257  *
2258  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2259  * account.
2260  *
2261  * This function should be called from contexts where we cannot sleep, and will
2262  * complain if the GPIO chip functions potentially sleep.
2263  */
2264 int gpiod_get_value(const struct gpio_desc *desc)
2265 {
2266 	int value;
2267 	if (!desc)
2268 		return 0;
2269 	/* Should be using gpio_get_value_cansleep() */
2270 	WARN_ON(desc->chip->can_sleep);
2271 
2272 	value = _gpiod_get_raw_value(desc);
2273 	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2274 		value = !value;
2275 
2276 	return value;
2277 }
2278 EXPORT_SYMBOL_GPL(gpiod_get_value);
2279 
2280 /*
2281  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
2282  * @desc: gpio descriptor whose state need to be set.
2283  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2284  */
2285 static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
2286 {
2287 	int err = 0;
2288 	struct gpio_chip *chip = desc->chip;
2289 	int offset = gpio_chip_hwgpio(desc);
2290 
2291 	if (value) {
2292 		err = chip->direction_input(chip, offset);
2293 		if (!err)
2294 			clear_bit(FLAG_IS_OUT, &desc->flags);
2295 	} else {
2296 		err = chip->direction_output(chip, offset, 0);
2297 		if (!err)
2298 			set_bit(FLAG_IS_OUT, &desc->flags);
2299 	}
2300 	trace_gpio_direction(desc_to_gpio(desc), value, err);
2301 	if (err < 0)
2302 		gpiod_err(desc,
2303 			  "%s: Error in set_value for open drain err %d\n",
2304 			  __func__, err);
2305 }
2306 
2307 /*
2308  *  _gpio_set_open_source_value() - Set the open source gpio's value.
2309  * @desc: gpio descriptor whose state need to be set.
2310  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2311  */
2312 static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
2313 {
2314 	int err = 0;
2315 	struct gpio_chip *chip = desc->chip;
2316 	int offset = gpio_chip_hwgpio(desc);
2317 
2318 	if (value) {
2319 		err = chip->direction_output(chip, offset, 1);
2320 		if (!err)
2321 			set_bit(FLAG_IS_OUT, &desc->flags);
2322 	} else {
2323 		err = chip->direction_input(chip, offset);
2324 		if (!err)
2325 			clear_bit(FLAG_IS_OUT, &desc->flags);
2326 	}
2327 	trace_gpio_direction(desc_to_gpio(desc), !value, err);
2328 	if (err < 0)
2329 		gpiod_err(desc,
2330 			  "%s: Error in set_value for open source err %d\n",
2331 			  __func__, err);
2332 }
2333 
2334 static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
2335 {
2336 	struct gpio_chip	*chip;
2337 
2338 	chip = desc->chip;
2339 	trace_gpio_value(desc_to_gpio(desc), 0, value);
2340 	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2341 		_gpio_set_open_drain_value(desc, value);
2342 	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2343 		_gpio_set_open_source_value(desc, value);
2344 	else
2345 		chip->set(chip, gpio_chip_hwgpio(desc), value);
2346 }
2347 
2348 /**
2349  * gpiod_set_raw_value() - assign a gpio's raw value
2350  * @desc: gpio whose value will be assigned
2351  * @value: value to assign
2352  *
2353  * Set the raw value of the GPIO, i.e. the value of its physical line without
2354  * regard for its ACTIVE_LOW status.
2355  *
2356  * This function should be called from contexts where we cannot sleep, and will
2357  * complain if the GPIO chip functions potentially sleep.
2358  */
2359 void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2360 {
2361 	if (!desc)
2362 		return;
2363 	/* Should be using gpio_set_value_cansleep() */
2364 	WARN_ON(desc->chip->can_sleep);
2365 	_gpiod_set_raw_value(desc, value);
2366 }
2367 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2368 
2369 /**
2370  * gpiod_set_value() - assign a gpio's value
2371  * @desc: gpio whose value will be assigned
2372  * @value: value to assign
2373  *
2374  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2375  * account
2376  *
2377  * This function should be called from contexts where we cannot sleep, and will
2378  * complain if the GPIO chip functions potentially sleep.
2379  */
2380 void gpiod_set_value(struct gpio_desc *desc, int value)
2381 {
2382 	if (!desc)
2383 		return;
2384 	/* Should be using gpio_set_value_cansleep() */
2385 	WARN_ON(desc->chip->can_sleep);
2386 	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2387 		value = !value;
2388 	_gpiod_set_raw_value(desc, value);
2389 }
2390 EXPORT_SYMBOL_GPL(gpiod_set_value);
2391 
2392 /**
2393  * gpiod_cansleep() - report whether gpio value access may sleep
2394  * @desc: gpio to check
2395  *
2396  */
2397 int gpiod_cansleep(const struct gpio_desc *desc)
2398 {
2399 	if (!desc)
2400 		return 0;
2401 	return desc->chip->can_sleep;
2402 }
2403 EXPORT_SYMBOL_GPL(gpiod_cansleep);
2404 
2405 /**
2406  * gpiod_to_irq() - return the IRQ corresponding to a GPIO
2407  * @desc: gpio whose IRQ will be returned (already requested)
2408  *
2409  * Return the IRQ corresponding to the passed GPIO, or an error code in case of
2410  * error.
2411  */
2412 int gpiod_to_irq(const struct gpio_desc *desc)
2413 {
2414 	struct gpio_chip	*chip;
2415 	int			offset;
2416 
2417 	if (!desc)
2418 		return -EINVAL;
2419 	chip = desc->chip;
2420 	offset = gpio_chip_hwgpio(desc);
2421 	return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2422 }
2423 EXPORT_SYMBOL_GPL(gpiod_to_irq);
2424 
2425 /**
2426  * gpiod_lock_as_irq() - lock a GPIO to be used as IRQ
2427  * @gpio: the GPIO line to lock as used for IRQ
2428  *
2429  * This is used directly by GPIO drivers that want to lock down
2430  * a certain GPIO line to be used for IRQs.
2431  */
2432 int gpiod_lock_as_irq(struct gpio_desc *desc)
2433 {
2434 	if (!desc)
2435 		return -EINVAL;
2436 
2437 	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2438 		gpiod_err(desc,
2439 			  "%s: tried to flag a GPIO set as output for IRQ\n",
2440 			  __func__);
2441 		return -EIO;
2442 	}
2443 
2444 	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2445 	return 0;
2446 }
2447 EXPORT_SYMBOL_GPL(gpiod_lock_as_irq);
2448 
2449 int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2450 {
2451 	return gpiod_lock_as_irq(gpiochip_get_desc(chip, offset));
2452 }
2453 EXPORT_SYMBOL_GPL(gpio_lock_as_irq);
2454 
2455 /**
2456  * gpiod_unlock_as_irq() - unlock a GPIO used as IRQ
2457  * @gpio: the GPIO line to unlock from IRQ usage
2458  *
2459  * This is used directly by GPIO drivers that want to indicate
2460  * that a certain GPIO is no longer used exclusively for IRQ.
2461  */
2462 void gpiod_unlock_as_irq(struct gpio_desc *desc)
2463 {
2464 	if (!desc)
2465 		return;
2466 
2467 	clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
2468 }
2469 EXPORT_SYMBOL_GPL(gpiod_unlock_as_irq);
2470 
2471 void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2472 {
2473 	return gpiod_unlock_as_irq(gpiochip_get_desc(chip, offset));
2474 }
2475 EXPORT_SYMBOL_GPL(gpio_unlock_as_irq);
2476 
2477 /**
2478  * gpiod_get_raw_value_cansleep() - return a gpio's raw value
2479  * @desc: gpio whose value will be returned
2480  *
2481  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2482  * its ACTIVE_LOW status.
2483  *
2484  * This function is to be called from contexts that can sleep.
2485  */
2486 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2487 {
2488 	might_sleep_if(extra_checks);
2489 	if (!desc)
2490 		return 0;
2491 	return _gpiod_get_raw_value(desc);
2492 }
2493 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2494 
2495 /**
2496  * gpiod_get_value_cansleep() - return a gpio's value
2497  * @desc: gpio whose value will be returned
2498  *
2499  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2500  * account.
2501  *
2502  * This function is to be called from contexts that can sleep.
2503  */
2504 int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2505 {
2506 	int value;
2507 
2508 	might_sleep_if(extra_checks);
2509 	if (!desc)
2510 		return 0;
2511 
2512 	value = _gpiod_get_raw_value(desc);
2513 	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2514 		value = !value;
2515 
2516 	return value;
2517 }
2518 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2519 
2520 /**
2521  * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
2522  * @desc: gpio whose value will be assigned
2523  * @value: value to assign
2524  *
2525  * Set the raw value of the GPIO, i.e. the value of its physical line without
2526  * regard for its ACTIVE_LOW status.
2527  *
2528  * This function is to be called from contexts that can sleep.
2529  */
2530 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
2531 {
2532 	might_sleep_if(extra_checks);
2533 	if (!desc)
2534 		return;
2535 	_gpiod_set_raw_value(desc, value);
2536 }
2537 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2538 
2539 /**
2540  * gpiod_set_value_cansleep() - assign a gpio's value
2541  * @desc: gpio whose value will be assigned
2542  * @value: value to assign
2543  *
2544  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2545  * account
2546  *
2547  * This function is to be called from contexts that can sleep.
2548  */
2549 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2550 {
2551 	might_sleep_if(extra_checks);
2552 	if (!desc)
2553 		return;
2554 
2555 	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2556 		value = !value;
2557 	_gpiod_set_raw_value(desc, value);
2558 }
2559 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2560 
2561 /**
2562  * gpiod_add_lookup_table() - register GPIO device consumers
2563  * @table: table of consumers to register
2564  */
2565 void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2566 {
2567 	mutex_lock(&gpio_lookup_lock);
2568 
2569 	list_add_tail(&table->list, &gpio_lookup_list);
2570 
2571 	mutex_unlock(&gpio_lookup_lock);
2572 }
2573 
2574 #ifdef CONFIG_OF
2575 static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2576 				      unsigned int idx,
2577 				      enum gpio_lookup_flags *flags)
2578 {
2579 	char prop_name[32]; /* 32 is max size of property name */
2580 	enum of_gpio_flags of_flags;
2581 	struct gpio_desc *desc;
2582 
2583 	if (con_id)
2584 		snprintf(prop_name, 32, "%s-gpios", con_id);
2585 	else
2586 		snprintf(prop_name, 32, "gpios");
2587 
2588 	desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
2589 					&of_flags);
2590 
2591 	if (IS_ERR(desc))
2592 		return desc;
2593 
2594 	if (of_flags & OF_GPIO_ACTIVE_LOW)
2595 		*flags |= GPIO_ACTIVE_LOW;
2596 
2597 	return desc;
2598 }
2599 #else
2600 static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2601 				      unsigned int idx,
2602 				      enum gpio_lookup_flags *flags)
2603 {
2604 	return ERR_PTR(-ENODEV);
2605 }
2606 #endif
2607 
2608 static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
2609 					unsigned int idx,
2610 					enum gpio_lookup_flags *flags)
2611 {
2612 	struct acpi_gpio_info info;
2613 	struct gpio_desc *desc;
2614 
2615 	desc = acpi_get_gpiod_by_index(dev, idx, &info);
2616 	if (IS_ERR(desc))
2617 		return desc;
2618 
2619 	if (info.gpioint && info.active_low)
2620 		*flags |= GPIO_ACTIVE_LOW;
2621 
2622 	return desc;
2623 }
2624 
2625 static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2626 {
2627 	const char *dev_id = dev ? dev_name(dev) : NULL;
2628 	struct gpiod_lookup_table *table;
2629 
2630 	mutex_lock(&gpio_lookup_lock);
2631 
2632 	list_for_each_entry(table, &gpio_lookup_list, list) {
2633 		if (table->dev_id && dev_id) {
2634 			/*
2635 			 * Valid strings on both ends, must be identical to have
2636 			 * a match
2637 			 */
2638 			if (!strcmp(table->dev_id, dev_id))
2639 				goto found;
2640 		} else {
2641 			/*
2642 			 * One of the pointers is NULL, so both must be to have
2643 			 * a match
2644 			 */
2645 			if (dev_id == table->dev_id)
2646 				goto found;
2647 		}
2648 	}
2649 	table = NULL;
2650 
2651 found:
2652 	mutex_unlock(&gpio_lookup_lock);
2653 	return table;
2654 }
2655 
2656 static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
2657 				    unsigned int idx,
2658 				    enum gpio_lookup_flags *flags)
2659 {
2660 	struct gpio_desc *desc = ERR_PTR(-ENOENT);
2661 	struct gpiod_lookup_table *table;
2662 	struct gpiod_lookup *p;
2663 
2664 	table = gpiod_find_lookup_table(dev);
2665 	if (!table)
2666 		return desc;
2667 
2668 	for (p = &table->table[0]; p->chip_label; p++) {
2669 		struct gpio_chip *chip;
2670 
2671 		/* idx must always match exactly */
2672 		if (p->idx != idx)
2673 			continue;
2674 
2675 		/* If the lookup entry has a con_id, require exact match */
2676 		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
2677 			continue;
2678 
2679 		chip = find_chip_by_name(p->chip_label);
2680 
2681 		if (!chip) {
2682 			dev_err(dev, "cannot find GPIO chip %s\n",
2683 				p->chip_label);
2684 			return ERR_PTR(-ENODEV);
2685 		}
2686 
2687 		if (chip->ngpio <= p->chip_hwnum) {
2688 			dev_err(dev,
2689 				"requested GPIO %d is out of range [0..%d] for chip %s\n",
2690 				idx, chip->ngpio, chip->label);
2691 			return ERR_PTR(-EINVAL);
2692 		}
2693 
2694 		desc = gpiochip_get_desc(chip, p->chip_hwnum);
2695 		*flags = p->flags;
2696 
2697 		return desc;
2698 	}
2699 
2700 	return desc;
2701 }
2702 
2703 /**
2704  * gpio_get - obtain a GPIO for a given GPIO function
2705  * @dev:	GPIO consumer, can be NULL for system-global GPIOs
2706  * @con_id:	function within the GPIO consumer
2707  *
2708  * Return the GPIO descriptor corresponding to the function con_id of device
2709  * dev, -ENOENT if no GPIO has been assigned to the requested function, or
2710  * another IS_ERR() code if an error occured while trying to acquire the GPIO.
2711  */
2712 struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id)
2713 {
2714 	return gpiod_get_index(dev, con_id, 0);
2715 }
2716 EXPORT_SYMBOL_GPL(gpiod_get);
2717 
2718 /**
2719  * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
2720  * @dev:	GPIO consumer, can be NULL for system-global GPIOs
2721  * @con_id:	function within the GPIO consumer
2722  * @idx:	index of the GPIO to obtain in the consumer
2723  *
2724  * This variant of gpiod_get() allows to access GPIOs other than the first
2725  * defined one for functions that define several GPIOs.
2726  *
2727  * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
2728  * requested function and/or index, or another IS_ERR() code if an error
2729  * occured while trying to acquire the GPIO.
2730  */
2731 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
2732 					       const char *con_id,
2733 					       unsigned int idx)
2734 {
2735 	struct gpio_desc *desc = NULL;
2736 	int status;
2737 	enum gpio_lookup_flags flags = 0;
2738 
2739 	dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
2740 
2741 	/* Using device tree? */
2742 	if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) {
2743 		dev_dbg(dev, "using device tree for GPIO lookup\n");
2744 		desc = of_find_gpio(dev, con_id, idx, &flags);
2745 	} else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev)) {
2746 		dev_dbg(dev, "using ACPI for GPIO lookup\n");
2747 		desc = acpi_find_gpio(dev, con_id, idx, &flags);
2748 	}
2749 
2750 	/*
2751 	 * Either we are not using DT or ACPI, or their lookup did not return
2752 	 * a result. In that case, use platform lookup as a fallback.
2753 	 */
2754 	if (!desc || desc == ERR_PTR(-ENOENT)) {
2755 		dev_dbg(dev, "using lookup tables for GPIO lookup");
2756 		desc = gpiod_find(dev, con_id, idx, &flags);
2757 	}
2758 
2759 	if (IS_ERR(desc)) {
2760 		dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
2761 		return desc;
2762 	}
2763 
2764 	status = gpiod_request(desc, con_id);
2765 
2766 	if (status < 0)
2767 		return ERR_PTR(status);
2768 
2769 	if (flags & GPIO_ACTIVE_LOW)
2770 		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
2771 	if (flags & GPIO_OPEN_DRAIN)
2772 		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
2773 	if (flags & GPIO_OPEN_SOURCE)
2774 		set_bit(FLAG_OPEN_SOURCE, &desc->flags);
2775 
2776 	return desc;
2777 }
2778 EXPORT_SYMBOL_GPL(gpiod_get_index);
2779 
2780 /**
2781  * gpiod_put - dispose of a GPIO descriptor
2782  * @desc:	GPIO descriptor to dispose of
2783  *
2784  * No descriptor can be used after gpiod_put() has been called on it.
2785  */
2786 void gpiod_put(struct gpio_desc *desc)
2787 {
2788 	gpiod_free(desc);
2789 }
2790 EXPORT_SYMBOL_GPL(gpiod_put);
2791 
2792 #ifdef CONFIG_DEBUG_FS
2793 
2794 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2795 {
2796 	unsigned		i;
2797 	unsigned		gpio = chip->base;
2798 	struct gpio_desc	*gdesc = &chip->desc[0];
2799 	int			is_out;
2800 	int			is_irq;
2801 
2802 	for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2803 		if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2804 			continue;
2805 
2806 		gpiod_get_direction(gdesc);
2807 		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2808 		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
2809 		seq_printf(s, " gpio-%-3d (%-20.20s) %s %s %s",
2810 			gpio, gdesc->label,
2811 			is_out ? "out" : "in ",
2812 			chip->get
2813 				? (chip->get(chip, i) ? "hi" : "lo")
2814 				: "?  ",
2815 			is_irq ? "IRQ" : "   ");
2816 		seq_printf(s, "\n");
2817 	}
2818 }
2819 
2820 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2821 {
2822 	unsigned long flags;
2823 	struct gpio_chip *chip = NULL;
2824 	loff_t index = *pos;
2825 
2826 	s->private = "";
2827 
2828 	spin_lock_irqsave(&gpio_lock, flags);
2829 	list_for_each_entry(chip, &gpio_chips, list)
2830 		if (index-- == 0) {
2831 			spin_unlock_irqrestore(&gpio_lock, flags);
2832 			return chip;
2833 		}
2834 	spin_unlock_irqrestore(&gpio_lock, flags);
2835 
2836 	return NULL;
2837 }
2838 
2839 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2840 {
2841 	unsigned long flags;
2842 	struct gpio_chip *chip = v;
2843 	void *ret = NULL;
2844 
2845 	spin_lock_irqsave(&gpio_lock, flags);
2846 	if (list_is_last(&chip->list, &gpio_chips))
2847 		ret = NULL;
2848 	else
2849 		ret = list_entry(chip->list.next, struct gpio_chip, list);
2850 	spin_unlock_irqrestore(&gpio_lock, flags);
2851 
2852 	s->private = "\n";
2853 	++*pos;
2854 
2855 	return ret;
2856 }
2857 
2858 static void gpiolib_seq_stop(struct seq_file *s, void *v)
2859 {
2860 }
2861 
2862 static int gpiolib_seq_show(struct seq_file *s, void *v)
2863 {
2864 	struct gpio_chip *chip = v;
2865 	struct device *dev;
2866 
2867 	seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2868 			chip->base, chip->base + chip->ngpio - 1);
2869 	dev = chip->dev;
2870 	if (dev)
2871 		seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2872 			dev_name(dev));
2873 	if (chip->label)
2874 		seq_printf(s, ", %s", chip->label);
2875 	if (chip->can_sleep)
2876 		seq_printf(s, ", can sleep");
2877 	seq_printf(s, ":\n");
2878 
2879 	if (chip->dbg_show)
2880 		chip->dbg_show(s, chip);
2881 	else
2882 		gpiolib_dbg_show(s, chip);
2883 
2884 	return 0;
2885 }
2886 
2887 static const struct seq_operations gpiolib_seq_ops = {
2888 	.start = gpiolib_seq_start,
2889 	.next = gpiolib_seq_next,
2890 	.stop = gpiolib_seq_stop,
2891 	.show = gpiolib_seq_show,
2892 };
2893 
2894 static int gpiolib_open(struct inode *inode, struct file *file)
2895 {
2896 	return seq_open(file, &gpiolib_seq_ops);
2897 }
2898 
2899 static const struct file_operations gpiolib_operations = {
2900 	.owner		= THIS_MODULE,
2901 	.open		= gpiolib_open,
2902 	.read		= seq_read,
2903 	.llseek		= seq_lseek,
2904 	.release	= seq_release,
2905 };
2906 
2907 static int __init gpiolib_debugfs_init(void)
2908 {
2909 	/* /sys/kernel/debug/gpio */
2910 	(void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2911 				NULL, NULL, &gpiolib_operations);
2912 	return 0;
2913 }
2914 subsys_initcall(gpiolib_debugfs_init);
2915 
2916 #endif	/* DEBUG_FS */
2917