gpiolib.c 113.4 KB
Newer Older
1
#include <linux/bitmap.h>
2 3
#include <linux/kernel.h>
#include <linux/module.h>
4
#include <linux/interrupt.h>
5 6
#include <linux/irq.h>
#include <linux/spinlock.h>
7
#include <linux/list.h>
D
David Brownell 已提交
8 9 10 11 12
#include <linux/device.h>
#include <linux/err.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/gpio.h>
13
#include <linux/of_gpio.h>
14
#include <linux/idr.h>
15
#include <linux/slab.h>
16
#include <linux/acpi.h>
17
#include <linux/gpio/driver.h>
18
#include <linux/gpio/machine.h>
19
#include <linux/pinctrl/consumer.h>
20 21 22
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
23
#include <linux/compat.h>
24
#include <linux/anon_inodes.h>
25
#include <linux/file.h>
26 27 28
#include <linux/kfifo.h>
#include <linux/poll.h>
#include <linux/timekeeping.h>
29
#include <uapi/linux/gpio.h>
30

31 32
#include "gpiolib.h"

33 34
#define CREATE_TRACE_POINTS
#include <trace/events/gpio.h>
35

36
/* Implementation infrastructure for GPIO interfaces.
37
 *
38 39 40
 * The GPIO programming interface allows for inlining speed-critical
 * get/set operations for common cases, so that access to SOC-integrated
 * GPIOs can sometimes cost only an instruction or two per bit.
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
 */


/* When debugging, extend minimal trust to callers and platform code.
 * Also emit diagnostic messages that may help initial bringup, when
 * board setup or driver bugs are most common.
 *
 * Otherwise, minimize overhead in what may be bitbanging codepaths.
 */
#ifdef	DEBUG
#define	extra_checks	1
#else
#define	extra_checks	0
#endif

56 57
/* Device and char device-related information */
static DEFINE_IDA(gpio_ida);
58 59 60 61 62
static dev_t gpio_devt;
#define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */
static struct bus_type gpio_bus_type = {
	.name = "gpio",
};
63

64 65 66 67
/* gpio_lock prevents conflicts during gpio_desc[] table updates.
 * While any GPIO is requested, its gpio_chip is not removable;
 * each GPIO's "requested" flag serves as a lock and refcount.
 */
68
DEFINE_SPINLOCK(gpio_lock);
69

70 71
static DEFINE_MUTEX(gpio_lookup_lock);
static LIST_HEAD(gpio_lookup_list);
72
LIST_HEAD(gpio_devices);
73 74

static void gpiochip_free_hogs(struct gpio_chip *chip);
75
static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
76 77
				struct lock_class_key *lock_key,
				struct lock_class_key *request_key);
78
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
79 80
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
81

82
static bool gpiolib_initialized;
83

84 85 86 87 88
static inline void desc_set_label(struct gpio_desc *d, const char *label)
{
	d->label = label;
}

89
/**
T
Thierry Reding 已提交
90 91 92 93 94 95
 * gpio_to_desc - Convert a GPIO number to its descriptor
 * @gpio: global GPIO number
 *
 * Returns:
 * The GPIO descriptor associated with the given GPIO, or %NULL if no GPIO
 * with the given number exists in the system.
96
 */
97
struct gpio_desc *gpio_to_desc(unsigned gpio)
98
{
99
	struct gpio_device *gdev;
100 101 102 103
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

104
	list_for_each_entry(gdev, &gpio_devices, list) {
105 106
		if (gdev->base <= gpio &&
		    gdev->base + gdev->ngpio > gpio) {
107
			spin_unlock_irqrestore(&gpio_lock, flags);
108
			return &gdev->descs[gpio - gdev->base];
109 110 111 112 113
		}
	}

	spin_unlock_irqrestore(&gpio_lock, flags);

114 115 116
	if (!gpio_is_valid(gpio))
		WARN(1, "invalid GPIO %d\n", gpio);

117
	return NULL;
118
}
119
EXPORT_SYMBOL_GPL(gpio_to_desc);
120

121
/**
T
Thierry Reding 已提交
122 123 124 125 126 127 128 129
 * gpiochip_get_desc - get the GPIO descriptor corresponding to the given
 *                     hardware number for this chip
 * @chip: GPIO chip
 * @hwnum: hardware number of the GPIO for this chip
 *
 * Returns:
 * A pointer to the GPIO descriptor or %ERR_PTR(-EINVAL) if no GPIO exists
 * in the given chip for the specified hardware number.
130
 */
131 132
struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
				    u16 hwnum)
133
{
134 135 136
	struct gpio_device *gdev = chip->gpiodev;

	if (hwnum >= gdev->ngpio)
137
		return ERR_PTR(-EINVAL);
138

139
	return &gdev->descs[hwnum];
140
}
141 142

/**
T
Thierry Reding 已提交
143 144 145
 * desc_to_gpio - convert a GPIO descriptor to the integer namespace
 * @desc: GPIO descriptor
 *
146
 * This should disappear in the future but is needed since we still
T
Thierry Reding 已提交
147 148 149 150
 * use GPIO numbers for error messages and sysfs nodes.
 *
 * Returns:
 * The global GPIO number for the GPIO specified by its descriptor.
151
 */
152
int desc_to_gpio(const struct gpio_desc *desc)
153
{
154
	return desc->gdev->base + (desc - &desc->gdev->descs[0]);
155
}
156
EXPORT_SYMBOL_GPL(desc_to_gpio);
157 158


159 160 161 162 163
/**
 * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
 * @desc:	descriptor to return the chip of
 */
struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
164
{
165
	if (!desc || !desc->gdev)
166 167
		return NULL;
	return desc->gdev->chip;
168
}
169
EXPORT_SYMBOL_GPL(gpiod_to_chip);
170

171 172 173
/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
static int gpiochip_find_base(int ngpio)
{
174
	struct gpio_device *gdev;
175
	int base = ARCH_NR_GPIOS - ngpio;
176

177
	list_for_each_entry_reverse(gdev, &gpio_devices, list) {
178
		/* found a free space? */
179
		if (gdev->base + gdev->ngpio <= base)
180 181 182
			break;
		else
			/* nope, check the space right before the chip */
183
			base = gdev->base - ngpio;
184 185
	}

186
	if (gpio_is_valid(base)) {
187
		pr_debug("%s: found new base at %d\n", __func__, base);
188 189 190 191
		return base;
	} else {
		pr_err("%s: cannot find free range\n", __func__);
		return -ENOSPC;
A
Anton Vorontsov 已提交
192 193 194
	}
}

195 196 197 198
/**
 * gpiod_get_direction - return the current direction of a GPIO
 * @desc:	GPIO to get the direction of
 *
199
 * Returns 0 for output, 1 for input, or an error code in case of error.
200 201 202
 *
 * This function may sleep if gpiod_cansleep() is true.
 */
203
int gpiod_get_direction(struct gpio_desc *desc)
204 205
{
	struct gpio_chip	*chip;
206
	unsigned		offset;
207 208
	int			status = -EINVAL;

209 210
	chip = gpiod_to_chip(desc);
	offset = gpio_chip_hwgpio(desc);
211 212 213 214

	if (!chip->get_direction)
		return status;

215
	status = chip->get_direction(chip, offset);
216 217 218
	if (status > 0) {
		/* GPIOF_DIR_IN, or other positive */
		status = 1;
219
		clear_bit(FLAG_IS_OUT, &desc->flags);
220 221 222
	}
	if (status == 0) {
		/* GPIOF_DIR_OUT */
223
		set_bit(FLAG_IS_OUT, &desc->flags);
224 225 226
	}
	return status;
}
227
EXPORT_SYMBOL_GPL(gpiod_get_direction);
228

229 230
/*
 * Add a new chip to the global chips list, keeping the list of chips sorted
231
 * by range(means [base, base + ngpio - 1]) order.
232 233 234 235
 *
 * Return -EBUSY if the new chip overlaps with some other chip's integer
 * space.
 */
236
static int gpiodev_add_to_list(struct gpio_device *gdev)
237
{
238
	struct gpio_device *prev, *next;
239

240
	if (list_empty(&gpio_devices)) {
241
		/* initial entry in list */
242
		list_add_tail(&gdev->list, &gpio_devices);
S
Sudip Mukherjee 已提交
243
		return 0;
244 245
	}

246 247 248 249 250
	next = list_entry(gpio_devices.next, struct gpio_device, list);
	if (gdev->base + gdev->ngpio <= next->base) {
		/* add before first entry */
		list_add(&gdev->list, &gpio_devices);
		return 0;
251 252
	}

253 254 255 256
	prev = list_entry(gpio_devices.prev, struct gpio_device, list);
	if (prev->base + prev->ngpio <= gdev->base) {
		/* add behind last entry */
		list_add_tail(&gdev->list, &gpio_devices);
257
		return 0;
258 259
	}

260 261 262 263
	list_for_each_entry_safe(prev, next, &gpio_devices, list) {
		/* at the end of the list */
		if (&next->list == &gpio_devices)
			break;
264

265 266 267 268 269 270 271 272 273 274
		/* add between prev and next */
		if (prev->base + prev->ngpio <= gdev->base
				&& gdev->base + gdev->ngpio <= next->base) {
			list_add(&gdev->list, &prev->list);
			return 0;
		}
	}

	dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
	return -EBUSY;
275 276
}

T
Thierry Reding 已提交
277
/*
278 279 280 281
 * Convert a GPIO name to its descriptor
 */
static struct gpio_desc *gpio_name_to_desc(const char * const name)
{
282
	struct gpio_device *gdev;
283 284 285 286
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

287
	list_for_each_entry(gdev, &gpio_devices, list) {
288 289
		int i;

290 291
		for (i = 0; i != gdev->ngpio; ++i) {
			struct gpio_desc *desc = &gdev->descs[i];
292

293
			if (!desc->name || !name)
294 295
				continue;

296
			if (!strcmp(desc->name, name)) {
297
				spin_unlock_irqrestore(&gpio_lock, flags);
298
				return desc;
299 300 301 302 303 304 305 306 307
			}
		}
	}

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

308 309 310 311
/*
 * Takes the names from gc->names and checks if they are all unique. If they
 * are, they are assigned to their gpio descriptors.
 *
312
 * Warning if one of the names is already used for a different GPIO.
313 314 315
 */
static int gpiochip_set_desc_names(struct gpio_chip *gc)
{
316
	struct gpio_device *gdev = gc->gpiodev;
317 318 319 320 321 322 323 324 325 326
	int i;

	if (!gc->names)
		return 0;

	/* First check all names if they are unique */
	for (i = 0; i != gc->ngpio; ++i) {
		struct gpio_desc *gpio;

		gpio = gpio_name_to_desc(gc->names[i]);
327
		if (gpio)
328
			dev_warn(&gdev->dev,
329
				 "Detected name collision for GPIO name '%s'\n",
330
				 gc->names[i]);
331 332 333 334
	}

	/* Then add all names to the GPIO descriptors */
	for (i = 0; i != gc->ngpio; ++i)
335
		gdev->descs[i].name = gc->names[i];
336 337 338 339

	return 0;
}

340 341 342 343
static unsigned long *gpiochip_allocate_mask(struct gpio_chip *chip)
{
	unsigned long *p;

344
	p = kmalloc_array(BITS_TO_LONGS(chip->ngpio), sizeof(*p), GFP_KERNEL);
345 346 347 348 349 350 351 352 353
	if (!p)
		return NULL;

	/* Assume by default all GPIOs are valid */
	bitmap_fill(p, chip->ngpio);

	return p;
}

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
static int gpiochip_init_valid_mask(struct gpio_chip *gpiochip)
{
#ifdef CONFIG_OF_GPIO
	int size;
	struct device_node *np = gpiochip->of_node;

	size = of_property_count_u32_elems(np,  "gpio-reserved-ranges");
	if (size > 0 && size % 2 == 0)
		gpiochip->need_valid_mask = true;
#endif

	if (!gpiochip->need_valid_mask)
		return 0;

	gpiochip->valid_mask = gpiochip_allocate_mask(gpiochip);
	if (!gpiochip->valid_mask)
		return -ENOMEM;

	return 0;
}

static void gpiochip_free_valid_mask(struct gpio_chip *gpiochip)
{
	kfree(gpiochip->valid_mask);
	gpiochip->valid_mask = NULL;
}

bool gpiochip_line_is_valid(const struct gpio_chip *gpiochip,
				unsigned int offset)
{
	/* No mask means all valid */
	if (likely(!gpiochip->valid_mask))
		return true;
	return test_bit(offset, gpiochip->valid_mask);
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_valid);

391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
/*
 * GPIO line handle management
 */

/**
 * struct linehandle_state - contains the state of a userspace handle
 * @gdev: the GPIO device the handle pertains to
 * @label: consumer label used to tag descriptors
 * @descs: the GPIO descriptors held by this handle
 * @numdescs: the number of descriptors held in the descs array
 */
struct linehandle_state {
	struct gpio_device *gdev;
	const char *label;
	struct gpio_desc *descs[GPIOHANDLES_MAX];
	u32 numdescs;
};

409 410 411 412 413 414 415
#define GPIOHANDLE_REQUEST_VALID_FLAGS \
	(GPIOHANDLE_REQUEST_INPUT | \
	GPIOHANDLE_REQUEST_OUTPUT | \
	GPIOHANDLE_REQUEST_ACTIVE_LOW | \
	GPIOHANDLE_REQUEST_OPEN_DRAIN | \
	GPIOHANDLE_REQUEST_OPEN_SOURCE)

416 417 418 419 420 421
static long linehandle_ioctl(struct file *filep, unsigned int cmd,
			     unsigned long arg)
{
	struct linehandle_state *lh = filep->private_data;
	void __user *ip = (void __user *)arg;
	struct gpiohandle_data ghd;
422
	int vals[GPIOHANDLES_MAX];
423 424 425
	int i;

	if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
426 427 428 429 430 431 432 433
		/* TODO: check if descriptors are really input */
		int ret = gpiod_get_array_value_complex(false,
							true,
							lh->numdescs,
							lh->descs,
							vals);
		if (ret)
			return ret;
434

435
		memset(&ghd, 0, sizeof(ghd));
436 437
		for (i = 0; i < lh->numdescs; i++)
			ghd.values[i] = vals[i];
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498

		if (copy_to_user(ip, &ghd, sizeof(ghd)))
			return -EFAULT;

		return 0;
	} else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
		/* TODO: check if descriptors are really output */
		if (copy_from_user(&ghd, ip, sizeof(ghd)))
			return -EFAULT;

		/* Clamp all values to [0,1] */
		for (i = 0; i < lh->numdescs; i++)
			vals[i] = !!ghd.values[i];

		/* Reuse the array setting function */
		gpiod_set_array_value_complex(false,
					      true,
					      lh->numdescs,
					      lh->descs,
					      vals);
		return 0;
	}
	return -EINVAL;
}

#ifdef CONFIG_COMPAT
static long linehandle_ioctl_compat(struct file *filep, unsigned int cmd,
			     unsigned long arg)
{
	return linehandle_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
}
#endif

static int linehandle_release(struct inode *inode, struct file *filep)
{
	struct linehandle_state *lh = filep->private_data;
	struct gpio_device *gdev = lh->gdev;
	int i;

	for (i = 0; i < lh->numdescs; i++)
		gpiod_free(lh->descs[i]);
	kfree(lh->label);
	kfree(lh);
	put_device(&gdev->dev);
	return 0;
}

static const struct file_operations linehandle_fileops = {
	.release = linehandle_release,
	.owner = THIS_MODULE,
	.llseek = noop_llseek,
	.unlocked_ioctl = linehandle_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = linehandle_ioctl_compat,
#endif
};

static int linehandle_create(struct gpio_device *gdev, void __user *ip)
{
	struct gpiohandle_request handlereq;
	struct linehandle_state *lh;
499
	struct file *file;
500
	int fd, i, ret;
501
	u32 lflags;
502 503 504 505 506 507

	if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
		return -EFAULT;
	if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
		return -EINVAL;

508 509 510 511 512 513
	lflags = handlereq.flags;

	/* Return an error if an unknown flag is set */
	if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS)
		return -EINVAL;

514 515 516 517 518 519 520 521 522
	/*
	 * Do not allow OPEN_SOURCE & OPEN_DRAIN flags in a single request. If
	 * the hardware actually supports enabling both at the same time the
	 * electrical result would be disastrous.
	 */
	if ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) &&
	    (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE))
		return -EINVAL;

523 524 525 526 527 528
	/* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */
	if (!(lflags & GPIOHANDLE_REQUEST_OUTPUT) &&
	    ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
	     (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
		return -EINVAL;

529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
	lh = kzalloc(sizeof(*lh), GFP_KERNEL);
	if (!lh)
		return -ENOMEM;
	lh->gdev = gdev;
	get_device(&gdev->dev);

	/* Make sure this is terminated */
	handlereq.consumer_label[sizeof(handlereq.consumer_label)-1] = '\0';
	if (strlen(handlereq.consumer_label)) {
		lh->label = kstrdup(handlereq.consumer_label,
				    GFP_KERNEL);
		if (!lh->label) {
			ret = -ENOMEM;
			goto out_free_lh;
		}
	}

	/* Request each GPIO */
	for (i = 0; i < handlereq.lines; i++) {
		u32 offset = handlereq.lineoffsets[i];
		struct gpio_desc *desc;

551 552 553 554 555
		if (offset >= gdev->ngpio) {
			ret = -EINVAL;
			goto out_free_descs;
		}

556 557 558 559 560 561 562 563 564 565 566 567 568
		desc = &gdev->descs[offset];
		ret = gpiod_request(desc, lh->label);
		if (ret)
			goto out_free_descs;
		lh->descs[i] = desc;

		if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
			set_bit(FLAG_ACTIVE_LOW, &desc->flags);
		if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
			set_bit(FLAG_OPEN_DRAIN, &desc->flags);
		if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
			set_bit(FLAG_OPEN_SOURCE, &desc->flags);

569 570 571 572
		ret = gpiod_set_transitory(desc, false);
		if (ret < 0)
			goto out_free_descs;

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
		/*
		 * Lines have to be requested explicitly for input
		 * or output, else the line will be treated "as is".
		 */
		if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
			int val = !!handlereq.default_values[i];

			ret = gpiod_direction_output(desc, val);
			if (ret)
				goto out_free_descs;
		} else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
			ret = gpiod_direction_input(desc);
			if (ret)
				goto out_free_descs;
		}
		dev_dbg(&gdev->dev, "registered chardev handle for line %d\n",
			offset);
	}
591 592
	/* Let i point at the last handle */
	i--;
593 594
	lh->numdescs = handlereq.lines;

595
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
596 597 598 599 600
	if (fd < 0) {
		ret = fd;
		goto out_free_descs;
	}

601 602 603 604 605 606 607 608 609
	file = anon_inode_getfile("gpio-linehandle",
				  &linehandle_fileops,
				  lh,
				  O_RDONLY | O_CLOEXEC);
	if (IS_ERR(file)) {
		ret = PTR_ERR(file);
		goto out_put_unused_fd;
	}

610
	handlereq.fd = fd;
611
	if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
612 613 614 615 616 617 618
		/*
		 * fput() will trigger the release() callback, so do not go onto
		 * the regular error cleanup path here.
		 */
		fput(file);
		put_unused_fd(fd);
		return -EFAULT;
619
	}
620

621 622
	fd_install(fd, file);

623 624 625 626 627
	dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
		lh->numdescs);

	return 0;

628 629
out_put_unused_fd:
	put_unused_fd(fd);
630 631 632 633 634 635 636 637 638 639
out_free_descs:
	for (; i >= 0; i--)
		gpiod_free(lh->descs[i]);
	kfree(lh->label);
out_free_lh:
	kfree(lh);
	put_device(&gdev->dev);
	return ret;
}

640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
/*
 * GPIO line event management
 */

/**
 * struct lineevent_state - contains the state of a userspace event
 * @gdev: the GPIO device the event pertains to
 * @label: consumer label used to tag descriptors
 * @desc: the GPIO descriptor held by this event
 * @eflags: the event flags this line was requested with
 * @irq: the interrupt that trigger in response to events on this GPIO
 * @wait: wait queue that handles blocking reads of events
 * @events: KFIFO for the GPIO events
 * @read_lock: mutex lock to protect reads from colliding with adding
 * new events to the FIFO
655 656 657
 * @timestamp: cache for the timestamp storing it between hardirq
 * and IRQ thread, used to bring the timestamp close to the actual
 * event
658 659 660 661 662 663 664 665 666 667
 */
struct lineevent_state {
	struct gpio_device *gdev;
	const char *label;
	struct gpio_desc *desc;
	u32 eflags;
	int irq;
	wait_queue_head_t wait;
	DECLARE_KFIFO(events, struct gpioevent_data, 16);
	struct mutex read_lock;
668
	u64 timestamp;
669 670
};

671 672 673 674
#define GPIOEVENT_REQUEST_VALID_FLAGS \
	(GPIOEVENT_REQUEST_RISING_EDGE | \
	GPIOEVENT_REQUEST_FALLING_EDGE)

675
static __poll_t lineevent_poll(struct file *filep,
676 677 678
				   struct poll_table_struct *wait)
{
	struct lineevent_state *le = filep->private_data;
679
	__poll_t events = 0;
680 681 682 683

	poll_wait(filep, &le->wait, wait);

	if (!kfifo_is_empty(&le->events))
684
		events = EPOLLIN | EPOLLRDNORM;
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761

	return events;
}


static ssize_t lineevent_read(struct file *filep,
			      char __user *buf,
			      size_t count,
			      loff_t *f_ps)
{
	struct lineevent_state *le = filep->private_data;
	unsigned int copied;
	int ret;

	if (count < sizeof(struct gpioevent_data))
		return -EINVAL;

	do {
		if (kfifo_is_empty(&le->events)) {
			if (filep->f_flags & O_NONBLOCK)
				return -EAGAIN;

			ret = wait_event_interruptible(le->wait,
					!kfifo_is_empty(&le->events));
			if (ret)
				return ret;
		}

		if (mutex_lock_interruptible(&le->read_lock))
			return -ERESTARTSYS;
		ret = kfifo_to_user(&le->events, buf, count, &copied);
		mutex_unlock(&le->read_lock);

		if (ret)
			return ret;

		/*
		 * If we couldn't read anything from the fifo (a different
		 * thread might have been faster) we either return -EAGAIN if
		 * the file descriptor is non-blocking, otherwise we go back to
		 * sleep and wait for more data to arrive.
		 */
		if (copied == 0 && (filep->f_flags & O_NONBLOCK))
			return -EAGAIN;

	} while (copied == 0);

	return copied;
}

static int lineevent_release(struct inode *inode, struct file *filep)
{
	struct lineevent_state *le = filep->private_data;
	struct gpio_device *gdev = le->gdev;

	free_irq(le->irq, le);
	gpiod_free(le->desc);
	kfree(le->label);
	kfree(le);
	put_device(&gdev->dev);
	return 0;
}

static long lineevent_ioctl(struct file *filep, unsigned int cmd,
			    unsigned long arg)
{
	struct lineevent_state *le = filep->private_data;
	void __user *ip = (void __user *)arg;
	struct gpiohandle_data ghd;

	/*
	 * We can get the value for an event line but not set it,
	 * because it is input by definition.
	 */
	if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
		int val;

762 763
		memset(&ghd, 0, sizeof(ghd));

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
		val = gpiod_get_value_cansleep(le->desc);
		if (val < 0)
			return val;
		ghd.values[0] = val;

		if (copy_to_user(ip, &ghd, sizeof(ghd)))
			return -EFAULT;

		return 0;
	}
	return -EINVAL;
}

#ifdef CONFIG_COMPAT
static long lineevent_ioctl_compat(struct file *filep, unsigned int cmd,
				   unsigned long arg)
{
	return lineevent_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
}
#endif

static const struct file_operations lineevent_fileops = {
	.release = lineevent_release,
	.read = lineevent_read,
	.poll = lineevent_poll,
	.owner = THIS_MODULE,
	.llseek = noop_llseek,
	.unlocked_ioctl = lineevent_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = lineevent_ioctl_compat,
#endif
};

797
static irqreturn_t lineevent_irq_thread(int irq, void *p)
798 799 800
{
	struct lineevent_state *le = p;
	struct gpioevent_data ge;
801
	int ret, level;
802

803 804 805
	/* Do not leak kernel stack to userspace */
	memset(&ge, 0, sizeof(ge));

806
	ge.timestamp = le->timestamp;
807
	level = gpiod_get_value_cansleep(le->desc);
808

809 810
	if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
	    && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
811 812 813 814 815 816
		if (level)
			/* Emit low-to-high event */
			ge.id = GPIOEVENT_EVENT_RISING_EDGE;
		else
			/* Emit high-to-low event */
			ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
817
	} else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE && level) {
818 819
		/* Emit low-to-high event */
		ge.id = GPIOEVENT_EVENT_RISING_EDGE;
820
	} else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE && !level) {
821 822
		/* Emit high-to-low event */
		ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
823 824
	} else {
		return IRQ_NONE;
825 826 827 828
	}

	ret = kfifo_put(&le->events, ge);
	if (ret != 0)
829
		wake_up_poll(&le->wait, EPOLLIN);
830 831 832 833

	return IRQ_HANDLED;
}

834 835 836 837 838 839 840 841 842 843 844 845 846
static irqreturn_t lineevent_irq_handler(int irq, void *p)
{
	struct lineevent_state *le = p;

	/*
	 * Just store the timestamp in hardirq context so we get it as
	 * close in time as possible to the actual event.
	 */
	le->timestamp = ktime_get_real_ns();

	return IRQ_WAKE_THREAD;
}

847 848 849 850 851
static int lineevent_create(struct gpio_device *gdev, void __user *ip)
{
	struct gpioevent_request eventreq;
	struct lineevent_state *le;
	struct gpio_desc *desc;
852
	struct file *file;
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883
	u32 offset;
	u32 lflags;
	u32 eflags;
	int fd;
	int ret;
	int irqflags = 0;

	if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
		return -EFAULT;

	le = kzalloc(sizeof(*le), GFP_KERNEL);
	if (!le)
		return -ENOMEM;
	le->gdev = gdev;
	get_device(&gdev->dev);

	/* Make sure this is terminated */
	eventreq.consumer_label[sizeof(eventreq.consumer_label)-1] = '\0';
	if (strlen(eventreq.consumer_label)) {
		le->label = kstrdup(eventreq.consumer_label,
				    GFP_KERNEL);
		if (!le->label) {
			ret = -ENOMEM;
			goto out_free_le;
		}
	}

	offset = eventreq.lineoffset;
	lflags = eventreq.handleflags;
	eflags = eventreq.eventflags;

884 885 886 887 888
	if (offset >= gdev->ngpio) {
		ret = -EINVAL;
		goto out_free_label;
	}

889 890 891 892 893 894 895
	/* Return an error if a unknown flag is set */
	if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) ||
	    (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS)) {
		ret = -EINVAL;
		goto out_free_label;
	}

896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
	/* This is just wrong: we don't look for events on output lines */
	if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
		ret = -EINVAL;
		goto out_free_label;
	}

	desc = &gdev->descs[offset];
	ret = gpiod_request(desc, le->label);
	if (ret)
		goto out_free_desc;
	le->desc = desc;
	le->eflags = eflags;

	if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
	if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
	if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
		set_bit(FLAG_OPEN_SOURCE, &desc->flags);

	ret = gpiod_direction_input(desc);
	if (ret)
		goto out_free_desc;

	le->irq = gpiod_to_irq(desc);
	if (le->irq <= 0) {
		ret = -ENODEV;
		goto out_free_desc;
	}

	if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
		irqflags |= IRQF_TRIGGER_RISING;
	if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
		irqflags |= IRQF_TRIGGER_FALLING;
	irqflags |= IRQF_ONESHOT;
	irqflags |= IRQF_SHARED;

	INIT_KFIFO(le->events);
	init_waitqueue_head(&le->wait);
	mutex_init(&le->read_lock);

	/* Request a thread to read the events */
	ret = request_threaded_irq(le->irq,
939
			lineevent_irq_handler,
940 941 942 943 944 945 946
			lineevent_irq_thread,
			irqflags,
			le->label,
			le);
	if (ret)
		goto out_free_desc;

947
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
948 949 950 951 952
	if (fd < 0) {
		ret = fd;
		goto out_free_irq;
	}

953 954 955 956 957 958 959 960 961
	file = anon_inode_getfile("gpio-event",
				  &lineevent_fileops,
				  le,
				  O_RDONLY | O_CLOEXEC);
	if (IS_ERR(file)) {
		ret = PTR_ERR(file);
		goto out_put_unused_fd;
	}

962
	eventreq.fd = fd;
963
	if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
964 965 966 967 968 969 970
		/*
		 * fput() will trigger the release() callback, so do not go onto
		 * the regular error cleanup path here.
		 */
		fput(file);
		put_unused_fd(fd);
		return -EFAULT;
971
	}
972

973 974
	fd_install(fd, file);

975 976
	return 0;

977 978
out_put_unused_fd:
	put_unused_fd(fd);
979 980 981 982 983 984 985 986 987 988 989 990
out_free_irq:
	free_irq(le->irq, le);
out_free_desc:
	gpiod_free(le->desc);
out_free_label:
	kfree(le->label);
out_free_le:
	kfree(le);
	put_device(&gdev->dev);
	return ret;
}

T
Thierry Reding 已提交
991
/*
992 993 994 995 996 997
 * gpio_ioctl() - ioctl handler for the GPIO chardev
 */
static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct gpio_device *gdev = filp->private_data;
	struct gpio_chip *chip = gdev->chip;
998
	void __user *ip = (void __user *)arg;
999 1000 1001 1002 1003

	/* We fail any subsequent ioctl():s when the chip is gone */
	if (!chip)
		return -ENODEV;

1004
	/* Fill in the struct and pass to userspace */
1005
	if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
1006 1007
		struct gpiochip_info chipinfo;

1008 1009
		memset(&chipinfo, 0, sizeof(chipinfo));

1010 1011 1012
		strncpy(chipinfo.name, dev_name(&gdev->dev),
			sizeof(chipinfo.name));
		chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
1013 1014 1015
		strncpy(chipinfo.label, gdev->label,
			sizeof(chipinfo.label));
		chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
1016
		chipinfo.lines = gdev->ngpio;
1017 1018 1019
		if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
			return -EFAULT;
		return 0;
1020 1021 1022 1023 1024 1025
	} else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
		struct gpioline_info lineinfo;
		struct gpio_desc *desc;

		if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
			return -EFAULT;
1026
		if (lineinfo.line_offset >= gdev->ngpio)
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
			return -EINVAL;

		desc = &gdev->descs[lineinfo.line_offset];
		if (desc->name) {
			strncpy(lineinfo.name, desc->name,
				sizeof(lineinfo.name));
			lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
		} else {
			lineinfo.name[0] = '\0';
		}
		if (desc->label) {
1038 1039 1040
			strncpy(lineinfo.consumer, desc->label,
				sizeof(lineinfo.consumer));
			lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
1041
		} else {
1042
			lineinfo.consumer[0] = '\0';
1043 1044 1045 1046 1047 1048 1049
		}

		/*
		 * Userspace only need to know that the kernel is using
		 * this GPIO so it can't use it.
		 */
		lineinfo.flags = 0;
1050 1051 1052 1053 1054
		if (test_bit(FLAG_REQUESTED, &desc->flags) ||
		    test_bit(FLAG_IS_HOGGED, &desc->flags) ||
		    test_bit(FLAG_USED_AS_IRQ, &desc->flags) ||
		    test_bit(FLAG_EXPORT, &desc->flags) ||
		    test_bit(FLAG_SYSFS, &desc->flags))
1055
			lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
1056
		if (test_bit(FLAG_IS_OUT, &desc->flags))
1057
			lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
1058
		if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1059
			lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
1060
		if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1061
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
1062
		if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1063 1064 1065 1066 1067
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;

		if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
			return -EFAULT;
		return 0;
1068 1069
	} else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
		return linehandle_create(gdev, ip);
1070 1071
	} else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
		return lineevent_create(gdev, ip);
1072 1073 1074 1075
	}
	return -EINVAL;
}

1076 1077 1078 1079 1080 1081 1082 1083
#ifdef CONFIG_COMPAT
static long gpio_ioctl_compat(struct file *filp, unsigned int cmd,
			      unsigned long arg)
{
	return gpio_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
}
#endif

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
/**
 * gpio_chrdev_open() - open the chardev for ioctl operations
 * @inode: inode for this chardev
 * @filp: file struct for storing private data
 * Returns 0 on success
 */
static int gpio_chrdev_open(struct inode *inode, struct file *filp)
{
	struct gpio_device *gdev = container_of(inode->i_cdev,
					      struct gpio_device, chrdev);

	/* Fail on open if the backing gpiochip is gone */
1096
	if (!gdev->chip)
1097 1098 1099
		return -ENODEV;
	get_device(&gdev->dev);
	filp->private_data = gdev;
1100 1101

	return nonseekable_open(inode, filp);
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
}

/**
 * gpio_chrdev_release() - close chardev after ioctl operations
 * @inode: inode for this chardev
 * @filp: file struct for storing private data
 * Returns 0 on success
 */
static int gpio_chrdev_release(struct inode *inode, struct file *filp)
{
	struct gpio_device *gdev = container_of(inode->i_cdev,
					      struct gpio_device, chrdev);

	put_device(&gdev->dev);
	return 0;
}


static const struct file_operations gpio_fileops = {
	.release = gpio_chrdev_release,
	.open = gpio_chrdev_open,
	.owner = THIS_MODULE,
1124
	.llseek = no_llseek,
1125
	.unlocked_ioctl = gpio_ioctl,
1126 1127 1128
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
1129 1130
};

1131 1132 1133 1134 1135 1136
static void gpiodevice_release(struct device *dev)
{
	struct gpio_device *gdev = dev_get_drvdata(dev);

	list_del(&gdev->list);
	ida_simple_remove(&gpio_ida, gdev->id);
1137
	kfree_const(gdev->label);
1138
	kfree(gdev->descs);
1139
	kfree(gdev);
1140 1141
}

1142 1143 1144 1145 1146 1147 1148
static int gpiochip_setup_dev(struct gpio_device *gdev)
{
	int status;

	cdev_init(&gdev->chrdev, &gpio_fileops);
	gdev->chrdev.owner = THIS_MODULE;
	gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
1149 1150

	status = cdev_device_add(&gdev->chrdev, &gdev->dev);
1151
	if (status)
1152 1153 1154 1155
		return status;

	chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
		 MAJOR(gpio_devt), gdev->id);
1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169

	status = gpiochip_sysfs_register(gdev);
	if (status)
		goto err_remove_device;

	/* From this point, the .release() function cleans up gpio_device */
	gdev->dev.release = gpiodevice_release;
	pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
		 __func__, gdev->base, gdev->base + gdev->ngpio - 1,
		 dev_name(&gdev->dev), gdev->chip->label ? : "generic");

	return 0;

err_remove_device:
1170
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
	return status;
}

static void gpiochip_setup_devs(void)
{
	struct gpio_device *gdev;
	int err;

	list_for_each_entry(gdev, &gpio_devices, list) {
		err = gpiochip_setup_dev(gdev);
		if (err)
			pr_err("%s: Failed to initialize gpio device (%d)\n",
			       dev_name(&gdev->dev), err);
	}
}

1187
int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
1188 1189
			       struct lock_class_key *lock_key,
			       struct lock_class_key *request_key)
1190 1191 1192
{
	unsigned long	flags;
	int		status = 0;
1193
	unsigned	i;
1194
	int		base = chip->base;
1195
	struct gpio_device *gdev;
1196

1197 1198 1199 1200
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
1201
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1202
	if (!gdev)
1203
		return -ENOMEM;
1204
	gdev->dev.bus = &gpio_bus_type;
1205 1206 1207 1208 1209
	gdev->chip = chip;
	chip->gpiodev = gdev;
	if (chip->parent) {
		gdev->dev.parent = chip->parent;
		gdev->dev.of_node = chip->parent->of_node;
1210 1211
	}

1212 1213
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
1214 1215
	if (chip->of_node)
		gdev->dev.of_node = chip->of_node;
1216
#endif
1217

1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
	gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
	if (gdev->id < 0) {
		status = gdev->id;
		goto err_free_gdev;
	}
	dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
	device_initialize(&gdev->dev);
	dev_set_drvdata(&gdev->dev, gdev);
	if (chip->parent && chip->parent->driver)
		gdev->owner = chip->parent->driver->owner;
	else if (chip->owner)
		/* TODO: remove chip->owner */
		gdev->owner = chip->owner;
	else
		gdev->owner = THIS_MODULE;
1233

1234
	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1235
	if (!gdev->descs) {
1236 1237 1238 1239
		status = -ENOMEM;
		goto err_free_gdev;
	}

1240 1241
	if (chip->ngpio == 0) {
		chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1242
		status = -EINVAL;
1243
		goto err_free_descs;
1244
	}
1245

1246
	gdev->label = kstrdup_const(chip->label ?: "unknown", GFP_KERNEL);
1247 1248
	if (!gdev->label) {
		status = -ENOMEM;
1249
		goto err_free_descs;
1250 1251
	}

1252
	gdev->ngpio = chip->ngpio;
1253
	gdev->data = data;
1254

1255 1256
	spin_lock_irqsave(&gpio_lock, flags);

1257 1258 1259 1260 1261 1262 1263
	/*
	 * TODO: this allocates a Linux GPIO number base in the global
	 * GPIO numberspace for this chip. In the long run we want to
	 * get *rid* of this numberspace and use only descriptors, but
	 * it may be a pipe dream. It will not happen before we get rid
	 * of the sysfs interface anyways.
	 */
1264 1265 1266 1267
	if (base < 0) {
		base = gpiochip_find_base(chip->ngpio);
		if (base < 0) {
			status = base;
1268
			spin_unlock_irqrestore(&gpio_lock, flags);
1269
			goto err_free_label;
1270
		}
1271 1272 1273 1274 1275 1276
		/*
		 * TODO: it should not be necessary to reflect the assigned
		 * base outside of the GPIO subsystem. Go over drivers and
		 * see if anyone makes use of this, else drop this and assign
		 * a poison instead.
		 */
1277 1278
		chip->base = base;
	}
1279
	gdev->base = base;
1280

1281
	status = gpiodev_add_to_list(gdev);
1282 1283
	if (status) {
		spin_unlock_irqrestore(&gpio_lock, flags);
1284
		goto err_free_label;
1285
	}
1286

1287 1288
	spin_unlock_irqrestore(&gpio_lock, flags);

1289
	for (i = 0; i < chip->ngpio; i++) {
1290
		struct gpio_desc *desc = &gdev->descs[i];
1291

1292
		desc->gdev = gdev;
1293

1294 1295 1296 1297 1298 1299 1300
		/* REVISIT: most hardware initializes GPIOs as inputs (often
		 * with pullups enabled) so power usage is minimized. Linux
		 * code should set the gpio direction first thing; but until
		 * it does, and in case chip->get_direction is not set, we may
		 * expose the wrong direction in sysfs.
		 */
		desc->flags = !chip->direction_input ? (1 << FLAG_IS_OUT) : 0;
1301
	}
1302

1303
#ifdef CONFIG_PINCTRL
1304
	INIT_LIST_HEAD(&gdev->pin_ranges);
1305 1306
#endif

1307 1308 1309 1310
	status = gpiochip_set_desc_names(chip);
	if (status)
		goto err_remove_from_list;

1311 1312 1313 1314
	status = gpiochip_irqchip_init_valid_mask(chip);
	if (status)
		goto err_remove_from_list;

1315 1316 1317 1318
	status = gpiochip_init_valid_mask(chip);
	if (status)
		goto err_remove_irqchip_mask;

1319
	status = gpiochip_add_irqchip(chip, lock_key, request_key);
1320 1321 1322
	if (status)
		goto err_remove_chip;

1323 1324 1325 1326
	status = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

1327
	acpi_gpiochip_add(chip);
1328

1329 1330 1331 1332 1333
	/*
	 * By first adding the chardev, and then adding the device,
	 * we get a device node entry in sysfs under
	 * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
	 * coldplug of device nodes and other udev business.
1334 1335
	 * We can do this only if gpiolib has been initialized.
	 * Otherwise, defer until later.
1336
	 */
1337 1338 1339 1340 1341
	if (gpiolib_initialized) {
		status = gpiochip_setup_dev(gdev);
		if (status)
			goto err_remove_chip;
	}
1342
	return 0;
1343

1344 1345
err_remove_chip:
	acpi_gpiochip_remove(chip);
1346
	gpiochip_free_hogs(chip);
1347
	of_gpiochip_remove(chip);
1348 1349
	gpiochip_free_valid_mask(chip);
err_remove_irqchip_mask:
1350
	gpiochip_irqchip_free_valid_mask(chip);
1351
err_remove_from_list:
1352
	spin_lock_irqsave(&gpio_lock, flags);
1353
	list_del(&gdev->list);
1354
	spin_unlock_irqrestore(&gpio_lock, flags);
1355
err_free_label:
1356
	kfree_const(gdev->label);
1357 1358
err_free_descs:
	kfree(gdev->descs);
1359 1360
err_free_gdev:
	ida_simple_remove(&gpio_ida, gdev->id);
1361
	/* failures here can mean systems won't boot... */
1362
	pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1363 1364 1365
	       gdev->base, gdev->base + gdev->ngpio - 1,
	       chip->label ? : "generic");
	kfree(gdev);
1366 1367
	return status;
}
1368
EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
1369

1370 1371
/**
 * gpiochip_get_data() - get per-subdriver data for the chip
T
Thierry Reding 已提交
1372 1373 1374 1375
 * @chip: GPIO chip
 *
 * Returns:
 * The per-subdriver data for the chip.
1376 1377 1378 1379 1380 1381 1382
 */
void *gpiochip_get_data(struct gpio_chip *chip)
{
	return chip->gpiodev->data;
}
EXPORT_SYMBOL_GPL(gpiochip_get_data);

1383 1384 1385 1386 1387 1388
/**
 * gpiochip_remove() - unregister a gpio_chip
 * @chip: the chip to unregister
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
1389
void gpiochip_remove(struct gpio_chip *chip)
1390
{
1391
	struct gpio_device *gdev = chip->gpiodev;
J
Johan Hovold 已提交
1392
	struct gpio_desc *desc;
1393
	unsigned long	flags;
1394
	unsigned	i;
J
Johan Hovold 已提交
1395
	bool		requested = false;
1396

1397
	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1398
	gpiochip_sysfs_unregister(gdev);
1399
	gpiochip_free_hogs(chip);
1400 1401
	/* Numb the device, cancelling all outstanding operations */
	gdev->chip = NULL;
1402
	gpiochip_irqchip_remove(chip);
1403
	acpi_gpiochip_remove(chip);
1404
	gpiochip_remove_pin_ranges(chip);
1405
	of_gpiochip_remove(chip);
1406
	gpiochip_free_valid_mask(chip);
1407 1408 1409 1410 1411
	/*
	 * We accept no more calls into the driver from this point, so
	 * NULL the driver data pointer
	 */
	gdev->data = NULL;
1412

1413
	spin_lock_irqsave(&gpio_lock, flags);
1414
	for (i = 0; i < gdev->ngpio; i++) {
1415
		desc = &gdev->descs[i];
J
Johan Hovold 已提交
1416 1417
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
1418 1419
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
1420

J
Johan Hovold 已提交
1421
	if (requested)
1422
		dev_crit(&gdev->dev,
1423
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
J
Johan Hovold 已提交
1424

1425 1426 1427 1428 1429 1430
	/*
	 * The gpiochip side puts its use of the device to rest here:
	 * if there are no userspace clients, the chardev and device will
	 * be removed, else it will be dangling until the last user is
	 * gone.
	 */
1431
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1432
	put_device(&gdev->dev);
1433 1434 1435
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
static void devm_gpio_chip_release(struct device *dev, void *res)
{
	struct gpio_chip *chip = *(struct gpio_chip **)res;

	gpiochip_remove(chip);
}

static int devm_gpio_chip_match(struct device *dev, void *res, void *data)

{
	struct gpio_chip **r = res;

	if (!r || !*r) {
		WARN_ON(!r || !*r);
		return 0;
	}

	return *r == data;
}

/**
1457
 * devm_gpiochip_add_data() - Resource manager gpiochip_add_data()
1458 1459
 * @dev: the device pointer on which irq_chip belongs to.
 * @chip: the chip to register, with chip->base initialized
T
Thierry Reding 已提交
1460
 * @data: driver-private data associated with this chip
1461
 *
T
Thierry Reding 已提交
1462
 * Context: potentially before irqs will work
1463 1464
 *
 * The gpio chip automatically be released when the device is unbound.
T
Thierry Reding 已提交
1465 1466 1467 1468 1469
 *
 * Returns:
 * A negative errno if the chip can't be registered, such as because the
 * chip->base is invalid or already associated with a different chip.
 * Otherwise it returns zero as a success code.
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
 */
int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
			   void *data)
{
	struct gpio_chip **ptr;
	int ret;

	ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
			     GFP_KERNEL);
	if (!ptr)
		return -ENOMEM;

	ret = gpiochip_add_data(chip, data);
	if (ret < 0) {
		devres_free(ptr);
		return ret;
	}

	*ptr = chip;
	devres_add(dev, ptr);

	return 0;
}
EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);

/**
 * devm_gpiochip_remove() - Resource manager of gpiochip_remove()
 * @dev: device for which which resource was allocated
 * @chip: the chip to remove
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
void devm_gpiochip_remove(struct device *dev, struct gpio_chip *chip)
{
	int ret;

	ret = devres_release(dev, devm_gpio_chip_release,
			     devm_gpio_chip_match, chip);
1508
	WARN_ON(ret);
1509 1510 1511
}
EXPORT_SYMBOL_GPL(devm_gpiochip_remove);

1512 1513 1514
/**
 * gpiochip_find() - iterator for locating a specific gpio_chip
 * @data: data to pass to match function
T
Thierry Reding 已提交
1515
 * @match: Callback function to check gpio_chip
1516 1517 1518 1519 1520 1521 1522
 *
 * Similar to bus_find_device.  It returns a reference to a gpio_chip as
 * determined by a user supplied @match callback.  The callback should return
 * 0 if the device doesn't match and non-zero if it does.  If the callback is
 * non-zero, this function will return to the caller and not iterate over any
 * more gpio_chips.
 */
1523
struct gpio_chip *gpiochip_find(void *data,
1524
				int (*match)(struct gpio_chip *chip,
1525
					     void *data))
1526
{
1527
	struct gpio_device *gdev;
1528
	struct gpio_chip *chip = NULL;
1529 1530 1531
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
1532
	list_for_each_entry(gdev, &gpio_devices, list)
1533 1534
		if (gdev->chip && match(gdev->chip, data)) {
			chip = gdev->chip;
1535
			break;
1536
		}
1537

1538 1539 1540 1541
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
J
Jean Delvare 已提交
1542
EXPORT_SYMBOL_GPL(gpiochip_find);
1543

1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
static int gpiochip_match_name(struct gpio_chip *chip, void *data)
{
	const char *name = data;

	return !strcmp(chip->label, name);
}

static struct gpio_chip *find_chip_by_name(const char *name)
{
	return gpiochip_find((void *)name, gpiochip_match_name);
}

1556 1557 1558 1559 1560 1561
#ifdef CONFIG_GPIOLIB_IRQCHIP

/*
 * The following is irqchip helper code for gpiochips.
 */

1562 1563
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
{
1564
	if (!gpiochip->irq.need_valid_mask)
1565 1566
		return 0;

1567
	gpiochip->irq.valid_mask = gpiochip_allocate_mask(gpiochip);
1568
	if (!gpiochip->irq.valid_mask)
1569 1570 1571 1572 1573 1574 1575
		return -ENOMEM;

	return 0;
}

static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
{
1576 1577
	kfree(gpiochip->irq.valid_mask);
	gpiochip->irq.valid_mask = NULL;
1578 1579
}

1580 1581
bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
				unsigned int offset)
1582
{
1583 1584
	if (!gpiochip_line_is_valid(gpiochip, offset))
		return false;
1585
	/* No mask means all valid */
1586
	if (likely(!gpiochip->irq.valid_mask))
1587
		return true;
1588
	return test_bit(offset, gpiochip->irq.valid_mask);
1589
}
1590
EXPORT_SYMBOL_GPL(gpiochip_irqchip_irq_valid);
1591

1592
/**
1593
 * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
1594 1595
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
1596 1597 1598
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1599 1600
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
1601
 */
1602 1603
static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
					  struct irq_chip *irqchip,
1604
					  unsigned int parent_irq,
1605
					  irq_flow_handler_t parent_handler)
1606
{
1607 1608
	unsigned int offset;

1609
	if (!gpiochip->irq.domain) {
1610 1611
		chip_err(gpiochip, "called %s before setting up irqchip\n",
			 __func__);
1612 1613 1614
		return;
	}

1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
	if (parent_handler) {
		if (gpiochip->can_sleep) {
			chip_err(gpiochip,
				 "you cannot have chained interrupts on a "
				 "chip that may sleep\n");
			return;
		}
		/*
		 * The parent irqchip is already using the chip_data for this
		 * irqchip, so our callbacks simply use the handler_data.
		 */
1626 1627
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
1628

1629 1630
		gpiochip->irq.parents = &parent_irq;
		gpiochip->irq.num_parents = 1;
1631
	}
1632 1633

	/* Set the parent IRQ for all affected IRQs */
1634 1635 1636
	for (offset = 0; offset < gpiochip->ngpio; offset++) {
		if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
			continue;
1637
		irq_set_parent(irq_find_mapping(gpiochip->irq.domain, offset),
1638
			       parent_irq);
1639
	}
1640
}
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653

/**
 * gpiochip_set_chained_irqchip() - connects a chained irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
 */
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
				  struct irq_chip *irqchip,
1654
				  unsigned int parent_irq,
1655 1656
				  irq_flow_handler_t parent_handler)
{
1657 1658 1659 1660 1661
	if (gpiochip->irq.threaded) {
		chip_err(gpiochip, "tried to chain a threaded gpiochip\n");
		return;
	}

1662 1663 1664
	gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
				      parent_handler);
}
1665 1666
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);

1667 1668 1669 1670 1671 1672 1673 1674 1675
/**
 * gpiochip_set_nested_irqchip() - connects a nested irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip nested handler to
 * @irqchip: the irqchip to nest to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * nested irqchip
 */
void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
				 struct irq_chip *irqchip,
1676
				 unsigned int parent_irq)
1677 1678 1679 1680 1681 1682
{
	gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
				      NULL);
}
EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);

1683 1684 1685 1686 1687 1688 1689 1690 1691 1692
/**
 * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
 * @d: the irqdomain used by this irqchip
 * @irq: the global irq number used by this GPIO irqchip irq
 * @hwirq: the local IRQ/GPIO line offset on this gpiochip
 *
 * This function will set up the mapping for a certain IRQ line on a
 * gpiochip by assigning the gpiochip as chip data, and using the irqchip
 * stored inside the gpiochip.
 */
1693 1694
int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
		     irq_hw_number_t hwirq)
1695 1696
{
	struct gpio_chip *chip = d->host_data;
1697
	int err = 0;
1698

1699 1700 1701
	if (!gpiochip_irqchip_irq_valid(chip, hwirq))
		return -ENXIO;

1702
	irq_set_chip_data(irq, chip);
1703 1704 1705 1706
	/*
	 * This lock class tells lockdep that GPIO irqs are in a different
	 * category than their parents, so it won't report false recursion.
	 */
1707
	irq_set_lockdep_class(irq, chip->irq.lock_key, chip->irq.request_key);
1708
	irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
1709
	/* Chips that use nested thread handlers have them marked */
1710
	if (chip->irq.threaded)
1711
		irq_set_nested_thread(irq, 1);
1712
	irq_set_noprobe(irq);
R
Rob Herring 已提交
1713

1714 1715 1716 1717 1718 1719 1720 1721
	if (chip->irq.num_parents == 1)
		err = irq_set_parent(irq, chip->irq.parents[0]);
	else if (chip->irq.map)
		err = irq_set_parent(irq, chip->irq.map[hwirq]);

	if (err < 0)
		return err;

1722 1723 1724 1725
	/*
	 * No set-up of the hardware will happen if IRQ_TYPE_NONE
	 * is passed as default type.
	 */
1726 1727
	if (chip->irq.default_type != IRQ_TYPE_NONE)
		irq_set_irq_type(irq, chip->irq.default_type);
1728 1729 1730

	return 0;
}
1731
EXPORT_SYMBOL_GPL(gpiochip_irq_map);
1732

1733
void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
L
Linus Walleij 已提交
1734
{
1735 1736
	struct gpio_chip *chip = d->host_data;

1737
	if (chip->irq.threaded)
1738
		irq_set_nested_thread(irq, 0);
L
Linus Walleij 已提交
1739 1740 1741
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}
1742
EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
L
Linus Walleij 已提交
1743

1744 1745
static const struct irq_domain_ops gpiochip_domain_ops = {
	.map	= gpiochip_irq_map,
L
Linus Walleij 已提交
1746
	.unmap	= gpiochip_irq_unmap,
1747 1748 1749 1750 1751 1752 1753 1754
	/* Virtually all GPIO irqchips are twocell:ed */
	.xlate	= irq_domain_xlate_twocell,
};

static int gpiochip_irq_reqres(struct irq_data *d)
{
	struct gpio_chip *chip = irq_data_get_irq_chip_data(d);

1755
	if (!try_module_get(chip->gpiodev->owner))
1756 1757
		return -ENODEV;

1758
	if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1759 1760 1761
		chip_err(chip,
			"unable to lock HW IRQ %lu for IRQ\n",
			d->hwirq);
1762
		module_put(chip->gpiodev->owner);
1763 1764 1765 1766 1767 1768 1769 1770 1771
		return -EINVAL;
	}
	return 0;
}

static void gpiochip_irq_relres(struct irq_data *d)
{
	struct gpio_chip *chip = irq_data_get_irq_chip_data(d);

1772
	gpiochip_unlock_as_irq(chip, d->hwirq);
1773
	module_put(chip->gpiodev->owner);
1774 1775 1776 1777
}

static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
{
1778 1779
	if (!gpiochip_irqchip_irq_valid(chip, offset))
		return -ENXIO;
1780

1781
	return irq_create_mapping(chip->irq.domain, offset);
1782 1783
}

1784 1785 1786
/**
 * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip
 * @gpiochip: the GPIO chip to add the IRQ chip to
1787 1788
 * @lock_key: lockdep class for IRQ lock
 * @request_key: lockdep class for IRQ request
1789
 */
1790
static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
1791 1792
				struct lock_class_key *lock_key,
				struct lock_class_key *request_key)
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828
{
	struct irq_chip *irqchip = gpiochip->irq.chip;
	const struct irq_domain_ops *ops;
	struct device_node *np;
	unsigned int type;
	unsigned int i;

	if (!irqchip)
		return 0;

	if (gpiochip->irq.parent_handler && gpiochip->can_sleep) {
		chip_err(gpiochip, "you cannot have chained interrupts on a "
			 "chip that may sleep\n");
		return -EINVAL;
	}

	np = gpiochip->gpiodev->dev.of_node;
	type = gpiochip->irq.default_type;

	/*
	 * Specifying a default trigger is a terrible idea if DT or ACPI is
	 * used to configure the interrupts, as you may end up with
	 * conflicting triggers. Tell the user, and reset to NONE.
	 */
	if (WARN(np && type != IRQ_TYPE_NONE,
		 "%s: Ignoring %u default trigger\n", np->full_name, type))
		type = IRQ_TYPE_NONE;

	if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
		acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
				 "Ignoring %u default trigger\n", type);
		type = IRQ_TYPE_NONE;
	}

	gpiochip->to_irq = gpiochip_to_irq;
	gpiochip->irq.default_type = type;
1829
	gpiochip->irq.lock_key = lock_key;
1830
	gpiochip->irq.request_key = request_key;
1831 1832 1833 1834 1835 1836 1837

	if (gpiochip->irq.domain_ops)
		ops = gpiochip->irq.domain_ops;
	else
		ops = &gpiochip_domain_ops;

	gpiochip->irq.domain = irq_domain_add_simple(np, gpiochip->ngpio,
1838 1839
						     gpiochip->irq.first,
						     ops, gpiochip);
1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
	if (!gpiochip->irq.domain)
		return -EINVAL;

	/*
	 * It is possible for a driver to override this, but only if the
	 * alternative functions are both implemented.
	 */
	if (!irqchip->irq_request_resources &&
	    !irqchip->irq_release_resources) {
		irqchip->irq_request_resources = gpiochip_irq_reqres;
		irqchip->irq_release_resources = gpiochip_irq_relres;
	}

	if (gpiochip->irq.parent_handler) {
		void *data = gpiochip->irq.parent_handler_data ?: gpiochip;

		for (i = 0; i < gpiochip->irq.num_parents; i++) {
			/*
			 * The parent IRQ chip is already using the chip_data
			 * for this IRQ chip, so our callbacks simply use the
			 * handler_data.
			 */
			irq_set_chained_handler_and_data(gpiochip->irq.parents[i],
							 gpiochip->irq.parent_handler,
							 data);
		}
	}

	acpi_gpiochip_request_interrupts(gpiochip);

	return 0;
}

1873 1874 1875 1876 1877 1878 1879 1880
/**
 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
 * @gpiochip: the gpiochip to remove the irqchip from
 *
 * This is called only from gpiochip_remove()
 */
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
{
1881
	unsigned int offset;
L
Linus Walleij 已提交
1882

1883 1884
	acpi_gpiochip_free_interrupts(gpiochip);

1885
	if (gpiochip->irq.chip && gpiochip->irq.parent_handler) {
1886 1887 1888 1889 1890 1891
		struct gpio_irq_chip *irq = &gpiochip->irq;
		unsigned int i;

		for (i = 0; i < irq->num_parents; i++)
			irq_set_chained_handler_and_data(irq->parents[i],
							 NULL, NULL);
1892 1893
	}

L
Linus Walleij 已提交
1894
	/* Remove all IRQ mappings and delete the domain */
1895
	if (gpiochip->irq.domain) {
1896 1897
		unsigned int irq;

1898 1899 1900
		for (offset = 0; offset < gpiochip->ngpio; offset++) {
			if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
				continue;
1901 1902 1903

			irq = irq_find_mapping(gpiochip->irq.domain, offset);
			irq_dispose_mapping(irq);
1904
		}
1905 1906

		irq_domain_remove(gpiochip->irq.domain);
L
Linus Walleij 已提交
1907
	}
1908

1909 1910 1911 1912
	if (gpiochip->irq.chip) {
		gpiochip->irq.chip->irq_request_resources = NULL;
		gpiochip->irq.chip->irq_release_resources = NULL;
		gpiochip->irq.chip = NULL;
1913
	}
1914 1915

	gpiochip_irqchip_free_valid_mask(gpiochip);
1916 1917 1918
}

/**
1919
 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
1920 1921 1922 1923 1924
 * @gpiochip: the gpiochip to add the irqchip to
 * @irqchip: the irqchip to add to the gpiochip
 * @first_irq: if not dynamically assigned, the base (first) IRQ to
 * allocate gpiochip irqs from
 * @handler: the irq handler to use (often a predefined irq core function)
1925 1926
 * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
 * to have the core avoid setting up any default type in the hardware.
1927
 * @threaded: whether this irqchip uses a nested thread handler
1928 1929
 * @lock_key: lockdep class for IRQ lock
 * @request_key: lockdep class for IRQ request
1930 1931 1932 1933 1934
 *
 * This function closely associates a certain irqchip with a certain
 * gpiochip, providing an irq domain to translate the local IRQs to
 * global irqs in the gpiolib core, and making sure that the gpiochip
 * is passed as chip data to all related functions. Driver callbacks
L
Linus Walleij 已提交
1935
 * need to use gpiochip_get_data() to get their local state containers back
1936 1937 1938 1939 1940
 * from the gpiochip passed as chip data. An irqdomain will be stored
 * in the gpiochip that shall be used by the driver to handle IRQ number
 * translation. The gpiochip will need to be initialized and registered
 * before calling this function.
 *
L
Linus Walleij 已提交
1941 1942
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1943 1944
 * need to be open coded.
 */
1945 1946 1947 1948 1949
int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
			     struct irq_chip *irqchip,
			     unsigned int first_irq,
			     irq_flow_handler_t handler,
			     unsigned int type,
1950
			     bool threaded,
1951 1952
			     struct lock_class_key *lock_key,
			     struct lock_class_key *request_key)
1953 1954 1955 1956 1957 1958
{
	struct device_node *of_node;

	if (!gpiochip || !irqchip)
		return -EINVAL;

1959
	if (!gpiochip->parent) {
1960 1961 1962
		pr_err("missing gpiochip .dev parent pointer\n");
		return -EINVAL;
	}
1963
	gpiochip->irq.threaded = threaded;
1964
	of_node = gpiochip->parent->of_node;
1965 1966
#ifdef CONFIG_OF_GPIO
	/*
1967
	 * If the gpiochip has an assigned OF node this takes precedence
1968 1969
	 * FIXME: get rid of this and use gpiochip->parent->of_node
	 * everywhere
1970 1971 1972 1973
	 */
	if (gpiochip->of_node)
		of_node = gpiochip->of_node;
#endif
1974
	/*
1975
	 * Specifying a default trigger is a terrible idea if DT or ACPI is
1976 1977 1978 1979
	 * used to configure the interrupts, as you may end-up with
	 * conflicting triggers. Tell the user, and reset to NONE.
	 */
	if (WARN(of_node && type != IRQ_TYPE_NONE,
1980
		 "%pOF: Ignoring %d default trigger\n", of_node, type))
1981
		type = IRQ_TYPE_NONE;
1982 1983 1984 1985 1986
	if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
		acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
				 "Ignoring %d default trigger\n", type);
		type = IRQ_TYPE_NONE;
	}
1987

1988
	gpiochip->irq.chip = irqchip;
1989
	gpiochip->irq.handler = handler;
1990
	gpiochip->irq.default_type = type;
1991
	gpiochip->to_irq = gpiochip_to_irq;
1992
	gpiochip->irq.lock_key = lock_key;
1993
	gpiochip->irq.request_key = request_key;
1994
	gpiochip->irq.domain = irq_domain_add_simple(of_node,
1995 1996
					gpiochip->ngpio, first_irq,
					&gpiochip_domain_ops, gpiochip);
1997
	if (!gpiochip->irq.domain) {
1998
		gpiochip->irq.chip = NULL;
1999 2000
		return -EINVAL;
	}
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010

	/*
	 * It is possible for a driver to override this, but only if the
	 * alternative functions are both implemented.
	 */
	if (!irqchip->irq_request_resources &&
	    !irqchip->irq_release_resources) {
		irqchip->irq_request_resources = gpiochip_irq_reqres;
		irqchip->irq_release_resources = gpiochip_irq_relres;
	}
2011

2012 2013
	acpi_gpiochip_request_interrupts(gpiochip);

2014 2015
	return 0;
}
2016
EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
2017 2018 2019

#else /* CONFIG_GPIOLIB_IRQCHIP */

2020
static inline int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
2021 2022
				       struct lock_class_key *lock_key,
				       struct lock_class_key *request_key)
2023 2024 2025 2026
{
	return 0;
}

2027
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
2028 2029 2030 2031 2032 2033
static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
{
	return 0;
}
static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
{ }
2034 2035 2036

#endif /* CONFIG_GPIOLIB_IRQCHIP */

2037 2038 2039 2040 2041 2042 2043
/**
 * gpiochip_generic_request() - request the gpio function for a pin
 * @chip: the gpiochip owning the GPIO
 * @offset: the offset of the GPIO to request for GPIO function
 */
int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
{
2044
	return pinctrl_gpio_request(chip->gpiodev->base + offset);
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
}
EXPORT_SYMBOL_GPL(gpiochip_generic_request);

/**
 * gpiochip_generic_free() - free the gpio function from a pin
 * @chip: the gpiochip to request the gpio function for
 * @offset: the offset of the GPIO to free from GPIO function
 */
void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
{
2055
	pinctrl_gpio_free(chip->gpiodev->base + offset);
2056 2057 2058
}
EXPORT_SYMBOL_GPL(gpiochip_generic_free);

2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071
/**
 * gpiochip_generic_config() - apply configuration for a pin
 * @chip: the gpiochip owning the GPIO
 * @offset: the offset of the GPIO to apply the configuration
 * @config: the configuration to be applied
 */
int gpiochip_generic_config(struct gpio_chip *chip, unsigned offset,
			    unsigned long config)
{
	return pinctrl_gpio_set_config(chip->gpiodev->base + offset, config);
}
EXPORT_SYMBOL_GPL(gpiochip_generic_config);

2072
#ifdef CONFIG_PINCTRL
2073

2074 2075 2076
/**
 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
2077
 * @pctldev: the pin controller to map to
2078 2079
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_group: name of the pin group inside the pin controller
2080 2081 2082 2083 2084
 *
 * Calling this function directly from a DeviceTree-supported
 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2085 2086 2087 2088 2089 2090
 */
int gpiochip_add_pingroup_range(struct gpio_chip *chip,
			struct pinctrl_dev *pctldev,
			unsigned int gpio_offset, const char *pin_group)
{
	struct gpio_pin_range *pin_range;
2091
	struct gpio_device *gdev = chip->gpiodev;
2092 2093 2094 2095
	int ret;

	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
	if (!pin_range) {
2096
		chip_err(chip, "failed to allocate pin ranges\n");
2097 2098 2099 2100 2101 2102 2103
		return -ENOMEM;
	}

	/* Use local offset as range ID */
	pin_range->range.id = gpio_offset;
	pin_range->range.gc = chip;
	pin_range->range.name = chip->label;
2104
	pin_range->range.base = gdev->base + gpio_offset;
2105 2106 2107 2108 2109
	pin_range->pctldev = pctldev;

	ret = pinctrl_get_group_pins(pctldev, pin_group,
					&pin_range->range.pins,
					&pin_range->range.npins);
2110 2111
	if (ret < 0) {
		kfree(pin_range);
2112
		return ret;
2113
	}
2114 2115 2116

	pinctrl_add_gpio_range(pctldev, &pin_range->range);

2117 2118
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
2119 2120
		 pinctrl_dev_get_devname(pctldev), pin_group);

2121
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
2122 2123 2124 2125 2126

	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);

2127 2128 2129
/**
 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
T
Thierry Reding 已提交
2130
 * @pinctl_name: the dev_name() of the pin controller to map to
2131 2132
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_offset: the start offset in the pin controller number space
2133 2134
 * @npins: the number of pins from the offset of each pin space (GPIO and
 *	pin controller) to accumulate in this range
T
Thierry Reding 已提交
2135 2136 2137
 *
 * Returns:
 * 0 on success, or a negative error-code on failure.
2138 2139 2140 2141 2142
 *
 * Calling this function directly from a DeviceTree-supported
 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2143
 */
2144
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
2145
			   unsigned int gpio_offset, unsigned int pin_offset,
2146
			   unsigned int npins)
2147 2148
{
	struct gpio_pin_range *pin_range;
2149
	struct gpio_device *gdev = chip->gpiodev;
2150
	int ret;
2151

2152
	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2153
	if (!pin_range) {
2154
		chip_err(chip, "failed to allocate pin ranges\n");
2155
		return -ENOMEM;
2156 2157
	}

2158
	/* Use local offset as range ID */
2159
	pin_range->range.id = gpio_offset;
2160
	pin_range->range.gc = chip;
2161
	pin_range->range.name = chip->label;
2162
	pin_range->range.base = gdev->base + gpio_offset;
2163
	pin_range->range.pin_base = pin_offset;
2164
	pin_range->range.npins = npins;
L
Linus Walleij 已提交
2165
	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
2166
			&pin_range->range);
2167
	if (IS_ERR(pin_range->pctldev)) {
2168
		ret = PTR_ERR(pin_range->pctldev);
2169
		chip_err(chip, "could not create pin range\n");
2170
		kfree(pin_range);
2171
		return ret;
2172
	}
2173 2174
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
		 gpio_offset, gpio_offset + npins - 1,
2175 2176
		 pinctl_name,
		 pin_offset, pin_offset + npins - 1);
2177

2178
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
2179 2180

	return 0;
2181
}
2182
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2183

2184 2185 2186 2187
/**
 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
 * @chip: the chip to remove all the mappings for
 */
2188 2189 2190
void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
{
	struct gpio_pin_range *pin_range, *tmp;
2191
	struct gpio_device *gdev = chip->gpiodev;
2192

2193
	list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2194 2195 2196
		list_del(&pin_range->node);
		pinctrl_remove_gpio_range(pin_range->pctldev,
				&pin_range->range);
2197
		kfree(pin_range);
2198 2199
	}
}
2200 2201 2202
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);

#endif /* CONFIG_PINCTRL */
2203

2204 2205 2206 2207
/* These "optional" allocation calls help prevent drivers from stomping
 * on each other, and help provide better diagnostics in debugfs.
 * They're called even less than the "set direction" calls.
 */
2208
static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2209
{
2210
	struct gpio_chip	*chip = desc->gdev->chip;
2211
	int			status;
2212 2213
	unsigned long		flags;

2214 2215
	spin_lock_irqsave(&gpio_lock, flags);

2216
	/* NOTE:  gpio_request() can be called in early boot,
D
David Brownell 已提交
2217
	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2218 2219 2220 2221 2222
	 */

	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
		desc_set_label(desc, label ? : "?");
		status = 0;
2223
	} else {
2224
		status = -EBUSY;
M
Magnus Damm 已提交
2225
		goto done;
D
David Brownell 已提交
2226 2227 2228 2229 2230
	}

	if (chip->request) {
		/* chip->request may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2231
		status = chip->request(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2232 2233 2234 2235 2236
		spin_lock_irqsave(&gpio_lock, flags);

		if (status < 0) {
			desc_set_label(desc, NULL);
			clear_bit(FLAG_REQUESTED, &desc->flags);
2237
			goto done;
D
David Brownell 已提交
2238
		}
2239
	}
2240 2241 2242
	if (chip->get_direction) {
		/* chip->get_direction may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2243
		gpiod_get_direction(desc);
2244 2245
		spin_lock_irqsave(&gpio_lock, flags);
	}
2246 2247 2248 2249 2250
done:
	spin_unlock_irqrestore(&gpio_lock, flags);
	return status;
}

2251 2252 2253
/*
 * This descriptor validation needs to be inserted verbatim into each
 * function taking a descriptor, so we need to use a preprocessor
2254 2255
 * macro to avoid endless duplication. If the desc is NULL it is an
 * optional GPIO and calls should just bail out.
2256
 */
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
static int validate_desc(const struct gpio_desc *desc, const char *func)
{
	if (!desc)
		return 0;
	if (IS_ERR(desc)) {
		pr_warn("%s: invalid GPIO (errorpointer)\n", func);
		return PTR_ERR(desc);
	}
	if (!desc->gdev) {
		pr_warn("%s: invalid GPIO (no device)\n", func);
		return -EINVAL;
	}
	if (!desc->gdev->chip) {
		dev_warn(&desc->gdev->dev,
			 "%s: backing chip is gone\n", func);
		return 0;
	}
	return 1;
}

2277
#define VALIDATE_DESC(desc) do { \
2278 2279 2280 2281
	int __valid = validate_desc(desc, __func__); \
	if (__valid <= 0) \
		return __valid; \
	} while (0)
2282 2283

#define VALIDATE_DESC_VOID(desc) do { \
2284 2285
	int __valid = validate_desc(desc, __func__); \
	if (__valid <= 0) \
2286
		return; \
2287
	} while (0)
2288

2289
int gpiod_request(struct gpio_desc *desc, const char *label)
2290 2291
{
	int status = -EPROBE_DEFER;
2292
	struct gpio_device *gdev;
2293

2294 2295
	VALIDATE_DESC(desc);
	gdev = desc->gdev;
2296

2297
	if (try_module_get(gdev->owner)) {
2298
		status = gpiod_request_commit(desc, label);
2299
		if (status < 0)
2300
			module_put(gdev->owner);
2301 2302
		else
			get_device(&gdev->dev);
2303 2304
	}

2305
	if (status)
2306
		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2307

2308 2309
	return status;
}
2310

2311
static bool gpiod_free_commit(struct gpio_desc *desc)
2312
{
2313
	bool			ret = false;
2314
	unsigned long		flags;
D
David Brownell 已提交
2315
	struct gpio_chip	*chip;
2316

2317 2318
	might_sleep();

2319
	gpiod_unexport(desc);
D
David Brownell 已提交
2320

2321 2322
	spin_lock_irqsave(&gpio_lock, flags);

2323
	chip = desc->gdev->chip;
D
David Brownell 已提交
2324 2325 2326
	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
		if (chip->free) {
			spin_unlock_irqrestore(&gpio_lock, flags);
2327
			might_sleep_if(chip->can_sleep);
2328
			chip->free(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2329 2330
			spin_lock_irqsave(&gpio_lock, flags);
		}
2331
		desc_set_label(desc, NULL);
2332
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
D
David Brownell 已提交
2333
		clear_bit(FLAG_REQUESTED, &desc->flags);
2334
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2335
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
B
Benoit Parrot 已提交
2336
		clear_bit(FLAG_IS_HOGGED, &desc->flags);
2337 2338
		ret = true;
	}
2339 2340

	spin_unlock_irqrestore(&gpio_lock, flags);
2341 2342 2343
	return ret;
}

2344
void gpiod_free(struct gpio_desc *desc)
2345
{
2346
	if (desc && desc->gdev && gpiod_free_commit(desc)) {
2347
		module_put(desc->gdev->owner);
2348 2349
		put_device(&desc->gdev->dev);
	} else {
2350
		WARN_ON(extra_checks);
2351
	}
2352
}
2353

2354 2355 2356 2357 2358 2359
/**
 * gpiochip_is_requested - return string iff signal was requested
 * @chip: controller managing the signal
 * @offset: of signal within controller's 0..(ngpio - 1) range
 *
 * Returns NULL if the GPIO is not currently requested, else a string.
2360 2361
 * The string returned is the label passed to gpio_request(); if none has been
 * passed it is a meaningless, non-NULL constant.
2362 2363 2364 2365 2366 2367 2368
 *
 * This function is for use by GPIO controller drivers.  The label can
 * help with diagnostics, and knowing that the signal is used as a GPIO
 * can help avoid accidentally multiplexing it to another controller.
 */
const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
{
2369
	struct gpio_desc *desc;
2370

2371
	if (offset >= chip->ngpio)
2372
		return NULL;
2373

2374
	desc = &chip->gpiodev->descs[offset];
2375

2376
	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2377
		return NULL;
2378
	return desc->label;
2379 2380 2381
}
EXPORT_SYMBOL_GPL(gpiochip_is_requested);

2382 2383
/**
 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
T
Thierry Reding 已提交
2384 2385
 * @chip: GPIO chip
 * @hwnum: hardware number of the GPIO for which to request the descriptor
2386 2387 2388 2389 2390 2391 2392
 * @label: label for the GPIO
 *
 * Function allows GPIO chip drivers to request and use their own GPIO
 * descriptors via gpiolib API. Difference to gpiod_request() is that this
 * function will not increase reference count of the GPIO chip module. This
 * allows the GPIO chip module to be unloaded as needed (we assume that the
 * GPIO chip driver handles freeing the GPIOs it has requested).
T
Thierry Reding 已提交
2393 2394 2395 2396
 *
 * Returns:
 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
 * code on failure.
2397
 */
2398 2399
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
					    const char *label)
2400
{
2401 2402
	struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
	int err;
2403

2404 2405 2406 2407 2408
	if (IS_ERR(desc)) {
		chip_err(chip, "failed to get GPIO descriptor\n");
		return desc;
	}

2409
	err = gpiod_request_commit(desc, label);
2410 2411
	if (err < 0)
		return ERR_PTR(err);
2412

2413
	return desc;
2414
}
2415
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426

/**
 * gpiochip_free_own_desc - Free GPIO requested by the chip driver
 * @desc: GPIO descriptor to free
 *
 * Function frees the given GPIO requested previously with
 * gpiochip_request_own_desc().
 */
void gpiochip_free_own_desc(struct gpio_desc *desc)
{
	if (desc)
2427
		gpiod_free_commit(desc);
2428
}
2429
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2430

2431 2432
/*
 * Drivers MUST set GPIO direction before making get/set calls.  In
2433 2434 2435 2436 2437 2438 2439 2440
 * some cases this is done in early boot, before IRQs are enabled.
 *
 * As a rule these aren't called more than once (except for drivers
 * using the open-drain emulation idiom) so these are natural places
 * to accumulate extra debugging checks.  Note that we can't (yet)
 * rely on gpio_request() having been called beforehand.
 */

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
/**
 * gpiod_direction_input - set the GPIO direction to input
 * @desc:	GPIO to set to input
 *
 * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
 * be called safely on it.
 *
 * Return 0 in case of success, else an error code.
 */
int gpiod_direction_input(struct gpio_desc *desc)
2451 2452 2453 2454
{
	struct gpio_chip	*chip;
	int			status = -EINVAL;

2455 2456
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2457

2458
	if (!chip->get || !chip->direction_input) {
2459 2460
		gpiod_warn(desc,
			"%s: missing get() or direction_input() operations\n",
2461
			__func__);
2462 2463 2464
		return -EIO;
	}

2465
	status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2466 2467
	if (status == 0)
		clear_bit(FLAG_IS_OUT, &desc->flags);
2468

2469
	trace_gpio_direction(desc_to_gpio(desc), 1, status);
2470

2471 2472
	return status;
}
2473
EXPORT_SYMBOL_GPL(gpiod_direction_input);
2474

2475 2476 2477 2478 2479 2480 2481 2482
static int gpio_set_drive_single_ended(struct gpio_chip *gc, unsigned offset,
				       enum pin_config_param mode)
{
	unsigned long config = { PIN_CONF_PACKED(mode, 0) };

	return gc->set_config ? gc->set_config(gc, offset, config) : -ENOTSUPP;
}

2483
static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
2484
{
2485
	struct gpio_chip *gc = desc->gdev->chip;
2486
	int val = !!value;
2487
	int ret;
2488

2489
	if (!gc->set || !gc->direction_output) {
2490 2491 2492
		gpiod_warn(desc,
		       "%s: missing set() or direction_output() operations\n",
		       __func__);
2493 2494 2495
		return -EIO;
	}

2496
	ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2497
	if (!ret)
2498
		set_bit(FLAG_IS_OUT, &desc->flags);
2499
	trace_gpio_value(desc_to_gpio(desc), 0, val);
2500 2501
	trace_gpio_direction(desc_to_gpio(desc), 0, ret);
	return ret;
2502
}
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516

/**
 * gpiod_direction_output_raw - set the GPIO direction to output
 * @desc:	GPIO to set to output
 * @value:	initial output value of the GPIO
 *
 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
 * be called safely on it. The initial value of the output must be specified
 * as raw value on the physical line without regard for the ACTIVE_LOW status.
 *
 * Return 0 in case of success, else an error code.
 */
int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
{
2517
	VALIDATE_DESC(desc);
2518
	return gpiod_direction_output_raw_commit(desc, value);
2519 2520 2521 2522
}
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);

/**
2523
 * gpiod_direction_output - set the GPIO direction to output
2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
 * @desc:	GPIO to set to output
 * @value:	initial output value of the GPIO
 *
 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
 * be called safely on it. The initial value of the output must be specified
 * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
 * account.
 *
 * Return 0 in case of success, else an error code.
 */
int gpiod_direction_output(struct gpio_desc *desc, int value)
{
2536
	struct gpio_chip *gc;
2537 2538
	int ret;

2539
	VALIDATE_DESC(desc);
2540 2541
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2542 2543
	else
		value = !!value;
2544 2545 2546 2547 2548 2549 2550 2551 2552

	/* GPIOs used for IRQs shall not be set as output */
	if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
		gpiod_err(desc,
			  "%s: tried to set a GPIO tied to an IRQ as output\n",
			  __func__);
		return -EIO;
	}

2553
	gc = desc->gdev->chip;
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
		/* First see if we can enable open drain in hardware */
		ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
						  PIN_CONFIG_DRIVE_OPEN_DRAIN);
		if (!ret)
			goto set_output_value;
		/* Emulate open drain by not actively driving the line high */
		if (value)
			return gpiod_direction_input(desc);
	}
	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
		ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
						  PIN_CONFIG_DRIVE_OPEN_SOURCE);
		if (!ret)
			goto set_output_value;
		/* Emulate open source by not actively driving the line low */
		if (!value)
			return gpiod_direction_input(desc);
	} else {
		gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
					    PIN_CONFIG_DRIVE_PUSH_PULL);
	}

set_output_value:
2578
	return gpiod_direction_output_raw_commit(desc, value);
2579
}
2580
EXPORT_SYMBOL_GPL(gpiod_direction_output);
2581

2582
/**
T
Thierry Reding 已提交
2583 2584 2585
 * gpiod_set_debounce - sets @debounce time for a GPIO
 * @desc: descriptor of the GPIO for which to set debounce time
 * @debounce: debounce time in microseconds
2586
 *
T
Thierry Reding 已提交
2587 2588 2589
 * Returns:
 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
 * debounce time.
2590
 */
2591
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2592 2593
{
	struct gpio_chip	*chip;
2594
	unsigned long		config;
2595

2596 2597
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2598
	if (!chip->set || !chip->set_config) {
2599
		gpiod_dbg(desc,
2600
			  "%s: missing set() or set_config() operations\n",
2601
			  __func__);
2602
		return -ENOTSUPP;
2603 2604
	}

2605 2606
	config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
	return chip->set_config(chip, gpio_chip_hwgpio(desc), config);
2607
}
2608
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2609

2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624
/**
 * gpiod_set_transitory - Lose or retain GPIO state on suspend or reset
 * @desc: descriptor of the GPIO for which to configure persistence
 * @transitory: True to lose state on suspend or reset, false for persistence
 *
 * Returns:
 * 0 on success, otherwise a negative error code.
 */
int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
{
	struct gpio_chip *chip;
	unsigned long packed;
	int gpio;
	int rc;

2625
	VALIDATE_DESC(desc);
2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
	/*
	 * Handle FLAG_TRANSITORY first, enabling queries to gpiolib for
	 * persistence state.
	 */
	if (transitory)
		set_bit(FLAG_TRANSITORY, &desc->flags);
	else
		clear_bit(FLAG_TRANSITORY, &desc->flags);

	/* If the driver supports it, set the persistence state now */
	chip = desc->gdev->chip;
	if (!chip->set_config)
		return 0;

	packed = pinconf_to_config_packed(PIN_CONFIG_PERSIST_STATE,
					  !transitory);
	gpio = gpio_chip_hwgpio(desc);
	rc = chip->set_config(chip, gpio, packed);
	if (rc == -ENOTSUPP) {
		dev_dbg(&desc->gdev->dev, "Persistence not supported for GPIO %d\n",
				gpio);
		return 0;
	}

	return rc;
}
EXPORT_SYMBOL_GPL(gpiod_set_transitory);

2654 2655 2656 2657 2658 2659 2660
/**
 * gpiod_is_active_low - test whether a GPIO is active-low or not
 * @desc: the gpio descriptor to test
 *
 * Returns 1 if the GPIO is active-low, 0 otherwise.
 */
int gpiod_is_active_low(const struct gpio_desc *desc)
2661
{
2662
	VALIDATE_DESC(desc);
2663
	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2664
}
2665
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688

/* I/O calls are only valid after configuration completed; the relevant
 * "is this a valid GPIO" error checks should already have been done.
 *
 * "Get" operations are often inlinable as reading a pin value register,
 * and masking the relevant bit in that register.
 *
 * When "set" operations are inlinable, they involve writing that mask to
 * one register to set a low value, or a different register to set it high.
 * Otherwise locking is needed, so there may be little value to inlining.
 *
 *------------------------------------------------------------------------
 *
 * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
 * have requested the GPIO.  That can include implicit requesting by
 * a direction setting call.  Marking a gpio as requested locks its chip
 * in memory, guaranteeing that these table lookups need no more locking
 * and that gpiochip_remove() will fail.
 *
 * REVISIT when debugging, consider adding some instrumentation to ensure
 * that the GPIO was actually requested.
 */

2689
static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
2690 2691
{
	struct gpio_chip	*chip;
2692
	int offset;
2693
	int value;
2694

2695
	chip = desc->gdev->chip;
2696
	offset = gpio_chip_hwgpio(desc);
2697
	value = chip->get ? chip->get(chip, offset) : -EIO;
2698
	value = value < 0 ? value : !!value;
2699
	trace_gpio_value(desc_to_gpio(desc), 1, value);
2700
	return value;
2701
}
2702

2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
static int gpio_chip_get_multiple(struct gpio_chip *chip,
				  unsigned long *mask, unsigned long *bits)
{
	if (chip->get_multiple) {
		return chip->get_multiple(chip, mask, bits);
	} else if (chip->get) {
		int i, value;

		for_each_set_bit(i, mask, chip->ngpio) {
			value = chip->get(chip, i);
			if (value < 0)
				return value;
			__assign_bit(i, bits, value);
		}
		return 0;
	}
	return -EIO;
}

int gpiod_get_array_value_complex(bool raw, bool can_sleep,
				  unsigned int array_size,
				  struct gpio_desc **desc_array,
				  int *value_array)
{
	int i = 0;

	while (i < array_size) {
		struct gpio_chip *chip = desc_array[i]->gdev->chip;
		unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
		unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
		int first, j, ret;

		if (!can_sleep)
			WARN_ON(chip->can_sleep);

		/* collect all inputs belonging to the same chip */
		first = i;
		memset(mask, 0, sizeof(mask));
		do {
			const struct gpio_desc *desc = desc_array[i];
			int hwgpio = gpio_chip_hwgpio(desc);

			__set_bit(hwgpio, mask);
			i++;
		} while ((i < array_size) &&
			 (desc_array[i]->gdev->chip == chip));

		ret = gpio_chip_get_multiple(chip, mask, bits);
		if (ret)
			return ret;

		for (j = first; j < i; j++) {
			const struct gpio_desc *desc = desc_array[j];
			int hwgpio = gpio_chip_hwgpio(desc);
			int value = test_bit(hwgpio, bits);

			if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
				value = !value;
			value_array[j] = value;
			trace_gpio_value(desc_to_gpio(desc), 1, value);
		}
	}
	return 0;
}

2768
/**
2769 2770
 * gpiod_get_raw_value() - return a gpio's raw value
 * @desc: gpio whose value will be returned
2771
 *
2772
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2773
 * its ACTIVE_LOW status, or negative errno on failure.
2774 2775 2776
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2777
 */
2778
int gpiod_get_raw_value(const struct gpio_desc *desc)
2779
{
2780
	VALIDATE_DESC(desc);
2781
	/* Should be using gpio_get_value_cansleep() */
2782
	WARN_ON(desc->gdev->chip->can_sleep);
2783
	return gpiod_get_raw_value_commit(desc);
2784
}
2785
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2786

2787 2788 2789 2790 2791
/**
 * gpiod_get_value() - return a gpio's value
 * @desc: gpio whose value will be returned
 *
 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2792
 * account, or negative errno on failure.
2793 2794 2795 2796 2797
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_value(const struct gpio_desc *desc)
2798
{
2799
	int value;
2800 2801

	VALIDATE_DESC(desc);
2802
	/* Should be using gpio_get_value_cansleep() */
2803
	WARN_ON(desc->gdev->chip->can_sleep);
2804

2805
	value = gpiod_get_raw_value_commit(desc);
2806 2807 2808
	if (value < 0)
		return value;

2809 2810 2811 2812
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
2813
}
2814
EXPORT_SYMBOL_GPL(gpiod_get_value);
2815

2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860
/**
 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
 * else an error code.
 *
 * This function should be called from contexts where we cannot sleep,
 * and it will complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_raw_array_value(unsigned int array_size,
			      struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, false, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);

/**
 * gpiod_get_array_value() - read values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
 * into account.  Return 0 in case of success, else an error code.
 *
 * This function should be called from contexts where we cannot sleep,
 * and it will complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_array_value(unsigned int array_size,
			  struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(false, false, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_array_value);

2861
/*
2862
 *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
2863
 * @desc: gpio descriptor whose state need to be set.
2864
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2865
 */
2866
static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
2867 2868
{
	int err = 0;
2869
	struct gpio_chip *chip = desc->gdev->chip;
2870 2871
	int offset = gpio_chip_hwgpio(desc);

2872
	if (value) {
2873
		err = chip->direction_input(chip, offset);
2874
		if (!err)
2875
			clear_bit(FLAG_IS_OUT, &desc->flags);
2876
	} else {
2877
		err = chip->direction_output(chip, offset, 0);
2878
		if (!err)
2879
			set_bit(FLAG_IS_OUT, &desc->flags);
2880
	}
2881
	trace_gpio_direction(desc_to_gpio(desc), value, err);
2882
	if (err < 0)
2883 2884 2885
		gpiod_err(desc,
			  "%s: Error in set_value for open drain err %d\n",
			  __func__, err);
2886 2887
}

2888
/*
2889 2890
 *  _gpio_set_open_source_value() - Set the open source gpio's value.
 * @desc: gpio descriptor whose state need to be set.
2891
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2892
 */
2893
static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
2894 2895
{
	int err = 0;
2896
	struct gpio_chip *chip = desc->gdev->chip;
2897 2898
	int offset = gpio_chip_hwgpio(desc);

2899
	if (value) {
2900
		err = chip->direction_output(chip, offset, 1);
2901
		if (!err)
2902
			set_bit(FLAG_IS_OUT, &desc->flags);
2903
	} else {
2904
		err = chip->direction_input(chip, offset);
2905
		if (!err)
2906
			clear_bit(FLAG_IS_OUT, &desc->flags);
2907
	}
2908
	trace_gpio_direction(desc_to_gpio(desc), !value, err);
2909
	if (err < 0)
2910 2911 2912
		gpiod_err(desc,
			  "%s: Error in set_value for open source err %d\n",
			  __func__, err);
2913 2914
}

2915
static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
2916 2917 2918
{
	struct gpio_chip	*chip;

2919
	chip = desc->gdev->chip;
2920
	trace_gpio_value(desc_to_gpio(desc), 0, value);
2921
	chip->set(chip, gpio_chip_hwgpio(desc), value);
2922 2923
}

2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938
/*
 * set multiple outputs on the same chip;
 * use the chip's set_multiple function if available;
 * otherwise set the outputs sequentially;
 * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word
 *        defines which outputs are to be changed
 * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word
 *        defines the values the outputs specified by mask are to be set to
 */
static void gpio_chip_set_multiple(struct gpio_chip *chip,
				   unsigned long *mask, unsigned long *bits)
{
	if (chip->set_multiple) {
		chip->set_multiple(chip, mask, bits);
	} else {
2939 2940 2941 2942 2943
		unsigned int i;

		/* set outputs if the corresponding mask bit is set */
		for_each_set_bit(i, mask, chip->ngpio)
			chip->set(chip, i, test_bit(i, bits));
2944 2945 2946
	}
}

2947 2948 2949 2950
void gpiod_set_array_value_complex(bool raw, bool can_sleep,
				   unsigned int array_size,
				   struct gpio_desc **desc_array,
				   int *value_array)
2951 2952 2953 2954
{
	int i = 0;

	while (i < array_size) {
2955
		struct gpio_chip *chip = desc_array[i]->gdev->chip;
2956 2957 2958 2959
		unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
		unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
		int count = 0;

D
Daniel Lockyer 已提交
2960
		if (!can_sleep)
2961
			WARN_ON(chip->can_sleep);
D
Daniel Lockyer 已提交
2962

2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975
		memset(mask, 0, sizeof(mask));
		do {
			struct gpio_desc *desc = desc_array[i];
			int hwgpio = gpio_chip_hwgpio(desc);
			int value = value_array[i];

			if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
				value = !value;
			trace_gpio_value(desc_to_gpio(desc), 0, value);
			/*
			 * collect all normal outputs belonging to the same chip
			 * open drain and open source outputs are set individually
			 */
2976
			if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
2977
				gpio_set_open_drain_value_commit(desc, value);
2978
			} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
2979
				gpio_set_open_source_value_commit(desc, value);
2980 2981
			} else {
				__set_bit(hwgpio, mask);
D
Daniel Lockyer 已提交
2982
				if (value)
2983
					__set_bit(hwgpio, bits);
D
Daniel Lockyer 已提交
2984
				else
2985 2986 2987 2988
					__clear_bit(hwgpio, bits);
				count++;
			}
			i++;
2989 2990
		} while ((i < array_size) &&
			 (desc_array[i]->gdev->chip == chip));
2991
		/* push collected bits to outputs */
D
Daniel Lockyer 已提交
2992
		if (count != 0)
2993 2994 2995 2996
			gpio_chip_set_multiple(chip, mask, bits);
	}
}

2997
/**
2998 2999
 * gpiod_set_raw_value() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
3000 3001
 * @value: value to assign
 *
3002 3003 3004 3005 3006
 * Set the raw value of the GPIO, i.e. the value of its physical line without
 * regard for its ACTIVE_LOW status.
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
3007
 */
3008
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
3009
{
3010
	VALIDATE_DESC_VOID(desc);
3011
	/* Should be using gpiod_set_value_cansleep() */
3012
	WARN_ON(desc->gdev->chip->can_sleep);
3013
	gpiod_set_raw_value_commit(desc, value);
3014
}
3015
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
3016

3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037
/**
 * gpiod_set_value_nocheck() - set a GPIO line value without checking
 * @desc: the descriptor to set the value on
 * @value: value to set
 *
 * This sets the value of a GPIO line backing a descriptor, applying
 * different semantic quirks like active low and open drain/source
 * handling.
 */
static void gpiod_set_value_nocheck(struct gpio_desc *desc, int value)
{
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
		gpio_set_open_drain_value_commit(desc, value);
	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
		gpio_set_open_source_value_commit(desc, value);
	else
		gpiod_set_raw_value_commit(desc, value);
}

3038
/**
3039 3040 3041 3042
 * gpiod_set_value() - assign a gpio's value
 * @desc: gpio whose value will be assigned
 * @value: value to assign
 *
3043 3044
 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
 * OPEN_DRAIN and OPEN_SOURCE flags into account.
3045
 *
3046 3047
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
3048
 */
3049
void gpiod_set_value(struct gpio_desc *desc, int value)
3050
{
3051 3052
	VALIDATE_DESC_VOID(desc);
	WARN_ON(desc->gdev->chip->can_sleep);
3053
	gpiod_set_value_nocheck(desc, value);
3054
}
3055
EXPORT_SYMBOL_GPL(gpiod_set_value);
3056

3057
/**
3058
 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
3059 3060 3061 3062 3063 3064 3065 3066 3067 3068
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be assigned
 * @value_array: array of values to assign
 *
 * Set the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
 */
3069
void gpiod_set_raw_array_value(unsigned int array_size,
3070 3071 3072 3073
			 struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return;
3074 3075
	gpiod_set_array_value_complex(true, false, array_size, desc_array,
				      value_array);
3076
}
3077
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
3078 3079

/**
3080
 * gpiod_set_array_value() - assign values to an array of GPIOs
3081 3082 3083 3084 3085 3086 3087 3088 3089 3090
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be assigned
 * @value_array: array of values to assign
 *
 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
 * into account.
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
 */
3091 3092
void gpiod_set_array_value(unsigned int array_size,
			   struct gpio_desc **desc_array, int *value_array)
3093 3094 3095
{
	if (!desc_array)
		return;
3096 3097
	gpiod_set_array_value_complex(false, false, array_size, desc_array,
				      value_array);
3098
}
3099
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
3100

3101
/**
3102 3103
 * gpiod_cansleep() - report whether gpio value access may sleep
 * @desc: gpio to check
3104 3105
 *
 */
3106
int gpiod_cansleep(const struct gpio_desc *desc)
3107
{
3108 3109
	VALIDATE_DESC(desc);
	return desc->gdev->chip->can_sleep;
3110
}
3111
EXPORT_SYMBOL_GPL(gpiod_cansleep);
3112

D
David Brownell 已提交
3113
/**
3114 3115
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
D
David Brownell 已提交
3116
 *
3117 3118
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
D
David Brownell 已提交
3119
 */
3120
int gpiod_to_irq(const struct gpio_desc *desc)
D
David Brownell 已提交
3121
{
3122 3123
	struct gpio_chip *chip;
	int offset;
D
David Brownell 已提交
3124

3125 3126 3127 3128 3129
	/*
	 * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
	 * requires this function to not return zero on an invalid descriptor
	 * but rather a negative error number.
	 */
3130
	if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
3131 3132
		return -EINVAL;

3133
	chip = desc->gdev->chip;
3134
	offset = gpio_chip_hwgpio(desc);
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144
	if (chip->to_irq) {
		int retirq = chip->to_irq(chip, offset);

		/* Zero means NO_IRQ */
		if (!retirq)
			return -ENXIO;

		return retirq;
	}
	return -ENXIO;
D
David Brownell 已提交
3145
}
3146
EXPORT_SYMBOL_GPL(gpiod_to_irq);
D
David Brownell 已提交
3147

3148
/**
3149
 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
3150 3151
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
3152 3153
 *
 * This is used directly by GPIO drivers that want to lock down
3154
 * a certain GPIO line to be used for IRQs.
3155
 */
3156
int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
3157
{
3158 3159 3160 3161 3162 3163
	struct gpio_desc *desc;

	desc = gpiochip_get_desc(chip, offset);
	if (IS_ERR(desc))
		return PTR_ERR(desc);

3164 3165 3166 3167 3168
	/*
	 * If it's fast: flush the direction setting if something changed
	 * behind our back
	 */
	if (!chip->can_sleep && chip->get_direction) {
3169 3170 3171 3172 3173 3174 3175
		int dir = chip->get_direction(chip, offset);

		if (dir)
			clear_bit(FLAG_IS_OUT, &desc->flags);
		else
			set_bit(FLAG_IS_OUT, &desc->flags);
	}
3176

3177
	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
3178
		chip_err(chip,
3179 3180 3181 3182 3183
			  "%s: tried to flag a GPIO set as output for IRQ\n",
			  __func__);
		return -EIO;
	}

3184
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
3185 3186 3187 3188 3189 3190 3191 3192 3193

	/*
	 * If the consumer has not set up a label (such as when the
	 * IRQ is referenced from .to_irq()) we set up a label here
	 * so it is clear this is used as an interrupt.
	 */
	if (!desc->label)
		desc_set_label(desc, "interrupt");

3194
	return 0;
3195
}
3196
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
3197

3198
/**
3199
 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
3200 3201
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
3202 3203 3204
 *
 * This is used directly by GPIO drivers that want to indicate
 * that a certain GPIO is no longer used exclusively for IRQ.
3205
 */
3206
void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
3207
{
3208 3209 3210 3211
	struct gpio_desc *desc;

	desc = gpiochip_get_desc(chip, offset);
	if (IS_ERR(desc))
3212
		return;
3213

3214 3215 3216 3217 3218
	clear_bit(FLAG_USED_AS_IRQ, &desc->flags);

	/* If we only had this marking, erase it */
	if (desc->label && !strcmp(desc->label, "interrupt"))
		desc_set_label(desc, NULL);
3219
}
3220
EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
3221

3222 3223 3224 3225 3226 3227 3228 3229 3230
bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset)
{
	if (offset >= chip->ngpio)
		return false;

	return test_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);

3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248
bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset)
{
	if (offset >= chip->ngpio)
		return false;

	return test_bit(FLAG_OPEN_DRAIN, &chip->gpiodev->descs[offset].flags);
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);

bool gpiochip_line_is_open_source(struct gpio_chip *chip, unsigned int offset)
{
	if (offset >= chip->ngpio)
		return false;

	return test_bit(FLAG_OPEN_SOURCE, &chip->gpiodev->descs[offset].flags);
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);

3249 3250 3251 3252 3253
bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
{
	if (offset >= chip->ngpio)
		return false;

3254
	return !test_bit(FLAG_TRANSITORY, &chip->gpiodev->descs[offset].flags);
3255 3256 3257
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);

3258 3259 3260 3261 3262
/**
 * gpiod_get_raw_value_cansleep() - return a gpio's raw value
 * @desc: gpio whose value will be returned
 *
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
3263
 * its ACTIVE_LOW status, or negative errno on failure.
3264 3265
 *
 * This function is to be called from contexts that can sleep.
3266
 */
3267
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
3268 3269
{
	might_sleep_if(extra_checks);
3270
	VALIDATE_DESC(desc);
3271
	return gpiod_get_raw_value_commit(desc);
3272
}
3273
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
3274

3275 3276 3277 3278 3279
/**
 * gpiod_get_value_cansleep() - return a gpio's value
 * @desc: gpio whose value will be returned
 *
 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
3280
 * account, or negative errno on failure.
3281 3282 3283 3284
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
3285
{
3286
	int value;
3287 3288

	might_sleep_if(extra_checks);
3289
	VALIDATE_DESC(desc);
3290
	value = gpiod_get_raw_value_commit(desc);
3291 3292 3293
	if (value < 0)
		return value;

3294 3295 3296
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

3297
	return value;
3298
}
3299
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
3300

3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347
/**
 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
 * else an error code.
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
				       struct gpio_desc **desc_array,
				       int *value_array)
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, true, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);

/**
 * gpiod_get_array_value_cansleep() - read values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
 * into account.  Return 0 in case of success, else an error code.
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_array_value_cansleep(unsigned int array_size,
				   struct gpio_desc **desc_array,
				   int *value_array)
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(false, true, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep);

3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358
/**
 * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
 * @value: value to assign
 *
 * Set the raw value of the GPIO, i.e. the value of its physical line without
 * regard for its ACTIVE_LOW status.
 *
 * This function is to be called from contexts that can sleep.
 */
void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
3359
{
3360
	might_sleep_if(extra_checks);
3361
	VALIDATE_DESC_VOID(desc);
3362
	gpiod_set_raw_value_commit(desc, value);
3363
}
3364
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
3365

3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376
/**
 * gpiod_set_value_cansleep() - assign a gpio's value
 * @desc: gpio whose value will be assigned
 * @value: value to assign
 *
 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
 * account
 *
 * This function is to be called from contexts that can sleep.
 */
void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
3377 3378
{
	might_sleep_if(extra_checks);
3379
	VALIDATE_DESC_VOID(desc);
3380
	gpiod_set_value_nocheck(desc, value);
3381
}
3382
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
3383

3384
/**
3385
 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
3386 3387 3388 3389 3390 3391 3392 3393 3394
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be assigned
 * @value_array: array of values to assign
 *
 * Set the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.
 *
 * This function is to be called from contexts that can sleep.
 */
3395 3396 3397
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
					struct gpio_desc **desc_array,
					int *value_array)
3398 3399 3400 3401
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3402 3403
	gpiod_set_array_value_complex(true, true, array_size, desc_array,
				      value_array);
3404
}
3405
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
3406

3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423
/**
 * gpiod_add_lookup_tables() - register GPIO device consumers
 * @tables: list of tables of consumers to register
 * @n: number of tables in the list
 */
void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n)
{
	unsigned int i;

	mutex_lock(&gpio_lookup_lock);

	for (i = 0; i < n; i++)
		list_add_tail(&tables[i]->list, &gpio_lookup_list);

	mutex_unlock(&gpio_lookup_lock);
}

3424
/**
3425
 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
3426 3427 3428 3429 3430 3431 3432 3433 3434
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be assigned
 * @value_array: array of values to assign
 *
 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
 * into account.
 *
 * This function is to be called from contexts that can sleep.
 */
3435 3436 3437
void gpiod_set_array_value_cansleep(unsigned int array_size,
				    struct gpio_desc **desc_array,
				    int *value_array)
3438 3439 3440 3441
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3442 3443
	gpiod_set_array_value_complex(false, true, array_size, desc_array,
				      value_array);
3444
}
3445
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
3446

3447
/**
3448 3449
 * gpiod_add_lookup_table() - register GPIO device consumers
 * @table: table of consumers to register
3450
 */
3451
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
3452 3453 3454
{
	mutex_lock(&gpio_lookup_lock);

3455
	list_add_tail(&table->list, &gpio_lookup_list);
3456 3457 3458

	mutex_unlock(&gpio_lookup_lock);
}
3459
EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
3460

3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472
/**
 * gpiod_remove_lookup_table() - unregister GPIO device consumers
 * @table: table of consumers to unregister
 */
void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)
{
	mutex_lock(&gpio_lookup_lock);

	list_del(&table->list);

	mutex_unlock(&gpio_lookup_lock);
}
3473
EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
3474

3475
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
3476 3477
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
3478
	struct gpiod_lookup_table *table;
3479 3480 3481

	mutex_lock(&gpio_lookup_lock);

3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
	list_for_each_entry(table, &gpio_lookup_list, list) {
		if (table->dev_id && dev_id) {
			/*
			 * Valid strings on both ends, must be identical to have
			 * a match
			 */
			if (!strcmp(table->dev_id, dev_id))
				goto found;
		} else {
			/*
			 * One of the pointers is NULL, so both must be to have
			 * a match
			 */
			if (dev_id == table->dev_id)
				goto found;
		}
	}
	table = NULL;
3500

3501 3502 3503 3504
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
3505

3506 3507 3508 3509
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
				    unsigned int idx,
				    enum gpio_lookup_flags *flags)
{
3510
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
3511 3512
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
3513

3514 3515 3516
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
3517

3518 3519
	for (p = &table->table[0]; p->chip_label; p++) {
		struct gpio_chip *chip;
3520

3521
		/* idx must always match exactly */
3522 3523 3524
		if (p->idx != idx)
			continue;

3525 3526 3527
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
3528

3529
		chip = find_chip_by_name(p->chip_label);
3530

3531
		if (!chip) {
3532 3533 3534
			dev_err(dev, "cannot find GPIO chip %s\n",
				p->chip_label);
			return ERR_PTR(-ENODEV);
3535
		}
3536

3537
		if (chip->ngpio <= p->chip_hwnum) {
3538 3539 3540 3541
			dev_err(dev,
				"requested GPIO %d is out of range [0..%d] for chip %s\n",
				idx, chip->ngpio, chip->label);
			return ERR_PTR(-EINVAL);
3542 3543
		}

3544
		desc = gpiochip_get_desc(chip, p->chip_hwnum);
3545
		*flags = p->flags;
3546

3547
		return desc;
3548 3549 3550 3551 3552
	}

	return desc;
}

3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567
static int dt_gpio_count(struct device *dev, const char *con_id)
{
	int ret;
	char propname[32];
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
		if (con_id)
			snprintf(propname, sizeof(propname), "%s-%s",
				 con_id, gpio_suffixes[i]);
		else
			snprintf(propname, sizeof(propname), "%s",
				 gpio_suffixes[i]);

		ret = of_gpio_named_count(dev->of_node, propname);
3568
		if (ret > 0)
3569 3570
			break;
	}
3571
	return ret ? ret : -ENOENT;
3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616
}

static int platform_gpio_count(struct device *dev, const char *con_id)
{
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
	unsigned int count = 0;

	table = gpiod_find_lookup_table(dev);
	if (!table)
		return -ENOENT;

	for (p = &table->table[0]; p->chip_label; p++) {
		if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) ||
		    (!con_id && !p->con_id))
			count++;
	}
	if (!count)
		return -ENOENT;

	return count;
}

/**
 * gpiod_count - return the number of GPIOs associated with a device / function
 *		or -ENOENT if no GPIO has been assigned to the requested function
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
 * @con_id:	function within the GPIO consumer
 */
int gpiod_count(struct device *dev, const char *con_id)
{
	int count = -ENOENT;

	if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
		count = dt_gpio_count(dev, con_id);
	else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev))
		count = acpi_gpio_count(dev, con_id);

	if (count < 0)
		count = platform_gpio_count(dev, con_id);

	return count;
}
EXPORT_SYMBOL_GPL(gpiod_count);

3617
/**
3618
 * gpiod_get - obtain a GPIO for a given GPIO function
3619
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3620
 * @con_id:	function within the GPIO consumer
3621
 * @flags:	optional GPIO initialization flags
3622 3623
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
3624
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3625
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3626
 */
3627
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3628
					 enum gpiod_flags flags)
3629
{
3630
	return gpiod_get_index(dev, con_id, 0, flags);
3631
}
3632
EXPORT_SYMBOL_GPL(gpiod_get);
3633

3634 3635 3636 3637
/**
 * gpiod_get_optional - obtain an optional GPIO for a given GPIO function
 * @dev: GPIO consumer, can be NULL for system-global GPIOs
 * @con_id: function within the GPIO consumer
3638
 * @flags: optional GPIO initialization flags
3639 3640 3641 3642 3643
 *
 * This is equivalent to gpiod_get(), except that when no GPIO was assigned to
 * the requested function it will return NULL. This is convenient for drivers
 * that need to handle optional GPIOs.
 */
3644
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3645 3646
						  const char *con_id,
						  enum gpiod_flags flags)
3647
{
3648
	return gpiod_get_index_optional(dev, con_id, 0, flags);
3649
}
3650
EXPORT_SYMBOL_GPL(gpiod_get_optional);
3651

B
Benoit Parrot 已提交
3652 3653 3654 3655 3656

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
3657 3658
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
B
Benoit Parrot 已提交
3659 3660 3661 3662 3663 3664
 * @dflags:	gpiod_flags - optional GPIO initialization flags
 *
 * Return 0 on success, -ENOENT if no GPIO has been assigned to the
 * requested function and/or index, or another IS_ERR() code if an error
 * occurred while trying to acquire the GPIO.
 */
3665
int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
3666
		unsigned long lflags, enum gpiod_flags dflags)
B
Benoit Parrot 已提交
3667 3668 3669
{
	int status;

3670 3671
	if (lflags & GPIO_ACTIVE_LOW)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
3672

3673 3674
	if (lflags & GPIO_OPEN_DRAIN)
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686
	else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) {
		/*
		 * This enforces open drain mode from the consumer side.
		 * This is necessary for some busses like I2C, but the lookup
		 * should *REALLY* have specified them as open drain in the
		 * first place, so print a little warning here.
		 */
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
		gpiod_warn(desc,
			   "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n");
	}

3687 3688
	if (lflags & GPIO_OPEN_SOURCE)
		set_bit(FLAG_OPEN_SOURCE, &desc->flags);
3689 3690 3691 3692

	status = gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY));
	if (status < 0)
		return status;
3693

B
Benoit Parrot 已提交
3694 3695 3696 3697 3698 3699 3700 3701 3702
	/* No particular flag request, return here... */
	if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
		pr_debug("no flags found for %s\n", con_id);
		return 0;
	}

	/* Process flags */
	if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
		status = gpiod_direction_output(desc,
3703
				!!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
B
Benoit Parrot 已提交
3704 3705 3706 3707 3708 3709
	else
		status = gpiod_direction_input(desc);

	return status;
}

3710 3711
/**
 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
3712
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3713 3714
 * @con_id:	function within the GPIO consumer
 * @idx:	index of the GPIO to obtain in the consumer
3715
 * @flags:	optional GPIO initialization flags
3716 3717 3718 3719
 *
 * This variant of gpiod_get() allows to access GPIOs other than the first
 * defined one for functions that define several GPIOs.
 *
3720 3721
 * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
 * requested function and/or index, or another IS_ERR() code if an error
3722
 * occurred while trying to acquire the GPIO.
3723
 */
3724
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
3725
					       const char *con_id,
3726 3727
					       unsigned int idx,
					       enum gpiod_flags flags)
3728
{
3729
	struct gpio_desc *desc = NULL;
3730
	int status;
3731
	enum gpio_lookup_flags lookupflags = 0;
L
Linus Walleij 已提交
3732 3733
	/* Maybe we have a device name, maybe not */
	const char *devname = dev ? dev_name(dev) : "?";
3734 3735 3736

	dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);

3737 3738 3739 3740 3741 3742 3743
	if (dev) {
		/* Using device tree? */
		if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
			dev_dbg(dev, "using device tree for GPIO lookup\n");
			desc = of_find_gpio(dev, con_id, idx, &lookupflags);
		} else if (ACPI_COMPANION(dev)) {
			dev_dbg(dev, "using ACPI for GPIO lookup\n");
3744
			desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
3745
		}
3746 3747 3748 3749 3750 3751
	}

	/*
	 * Either we are not using DT or ACPI, or their lookup did not return
	 * a result. In that case, use platform lookup as a fallback.
	 */
3752
	if (!desc || desc == ERR_PTR(-ENOENT)) {
3753
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3754
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
3755 3756 3757
	}

	if (IS_ERR(desc)) {
3758
		dev_dbg(dev, "No GPIO consumer %s found\n", con_id);
3759 3760 3761
		return desc;
	}

L
Linus Walleij 已提交
3762 3763 3764 3765 3766
	/*
	 * If a connection label was passed use that, else attempt to use
	 * the device name as label
	 */
	status = gpiod_request(desc, con_id ? con_id : devname);
3767 3768 3769
	if (status < 0)
		return ERR_PTR(status);

3770
	status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
3771 3772 3773 3774 3775 3776
	if (status < 0) {
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
		gpiod_put(desc);
		return ERR_PTR(status);
	}

3777 3778
	return desc;
}
3779
EXPORT_SYMBOL_GPL(gpiod_get_index);
3780

3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795
/**
 * gpiod_get_from_of_node() - obtain a GPIO from an OF node
 * @node:	handle of the OF node
 * @propname:	name of the DT property representing the GPIO
 * @index:	index of the GPIO to obtain for the consumer
 * @dflags:	GPIO initialization flags
 * @label:	label to attach to the requested GPIO
 *
 * Returns:
 * On successful request the GPIO pin is configured in accordance with
 * provided @dflags. If the node does not have the requested GPIO
 * property, NULL is returned.
 *
 * In case of error an ERR_PTR() is returned.
 */
3796 3797 3798 3799
struct gpio_desc *gpiod_get_from_of_node(struct device_node *node,
					 const char *propname, int index,
					 enum gpiod_flags dflags,
					 const char *label)
3800
{
3801
	struct gpio_desc *desc;
3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849
	unsigned long lflags = 0;
	enum of_gpio_flags flags;
	bool active_low = false;
	bool single_ended = false;
	bool open_drain = false;
	bool transitory = false;
	int ret;

	desc = of_get_named_gpiod_flags(node, propname,
					index, &flags);

	if (!desc || IS_ERR(desc)) {
		/* If it is not there, just return NULL */
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
		return desc;
	}

	active_low = flags & OF_GPIO_ACTIVE_LOW;
	single_ended = flags & OF_GPIO_SINGLE_ENDED;
	open_drain = flags & OF_GPIO_OPEN_DRAIN;
	transitory = flags & OF_GPIO_TRANSITORY;

	ret = gpiod_request(desc, label);
	if (ret)
		return ERR_PTR(ret);

	if (active_low)
		lflags |= GPIO_ACTIVE_LOW;

	if (single_ended) {
		if (open_drain)
			lflags |= GPIO_OPEN_DRAIN;
		else
			lflags |= GPIO_OPEN_SOURCE;
	}

	if (transitory)
		lflags |= GPIO_TRANSITORY;

	ret = gpiod_configure_flags(desc, propname, lflags, dflags);
	if (ret < 0) {
		gpiod_put(desc);
		return ERR_PTR(ret);
	}

	return desc;
}
3850
EXPORT_SYMBOL(gpiod_get_from_of_node);
3851

3852 3853 3854 3855
/**
 * fwnode_get_named_gpiod - obtain a GPIO from firmware node
 * @fwnode:	handle of the firmware node
 * @propname:	name of the firmware property representing the GPIO
3856
 * @index:	index of the GPIO to obtain for the consumer
3857
 * @dflags:	GPIO initialization flags
T
Thierry Reding 已提交
3858
 * @label:	label to attach to the requested GPIO
3859 3860
 *
 * This function can be used for drivers that get their configuration
3861
 * from opaque firmware.
3862
 *
3863
 * The function properly finds the corresponding GPIO using whatever is the
3864 3865 3866
 * underlying firmware interface and then makes sure that the GPIO
 * descriptor is requested before it is returned to the caller.
 *
T
Thierry Reding 已提交
3867
 * Returns:
3868
 * On successful request the GPIO pin is configured in accordance with
3869 3870
 * provided @dflags.
 *
3871 3872 3873
 * In case of error an ERR_PTR() is returned.
 */
struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
3874
					 const char *propname, int index,
3875 3876
					 enum gpiod_flags dflags,
					 const char *label)
3877 3878
{
	struct gpio_desc *desc = ERR_PTR(-ENODEV);
3879
	unsigned long lflags = 0;
3880 3881 3882 3883 3884 3885
	int ret;

	if (!fwnode)
		return ERR_PTR(-EINVAL);

	if (is_of_node(fwnode)) {
3886 3887 3888 3889 3890
		desc = gpiod_get_from_of_node(to_of_node(fwnode),
					      propname, index,
					      dflags,
					      label);
		return desc;
3891 3892 3893
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

3894
		desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
3895 3896
		if (IS_ERR(desc))
			return desc;
3897

3898
		acpi_gpio_update_gpiod_flags(&dflags, &info);
3899

3900 3901 3902
		if (info.polarity == GPIO_ACTIVE_LOW)
			lflags |= GPIO_ACTIVE_LOW;
	}
3903

3904
	/* Currently only ACPI takes this path */
3905
	ret = gpiod_request(desc, label);
3906 3907 3908
	if (ret)
		return ERR_PTR(ret);

3909 3910 3911 3912
	ret = gpiod_configure_flags(desc, propname, lflags, dflags);
	if (ret < 0) {
		gpiod_put(desc);
		return ERR_PTR(ret);
3913 3914
	}

3915 3916 3917 3918
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

3919 3920 3921 3922 3923 3924
/**
 * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
 *                            function
 * @dev: GPIO consumer, can be NULL for system-global GPIOs
 * @con_id: function within the GPIO consumer
 * @index: index of the GPIO to obtain in the consumer
3925
 * @flags: optional GPIO initialization flags
3926 3927 3928 3929 3930
 *
 * This is equivalent to gpiod_get_index(), except that when no GPIO with the
 * specified index was assigned to the requested function it will return NULL.
 * This is convenient for drivers that need to handle optional GPIOs.
 */
3931
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3932
							const char *con_id,
3933 3934
							unsigned int index,
							enum gpiod_flags flags)
3935 3936 3937
{
	struct gpio_desc *desc;

3938
	desc = gpiod_get_index(dev, con_id, index, flags);
3939 3940 3941 3942 3943 3944 3945
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
3946
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3947

B
Benoit Parrot 已提交
3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968
/**
 * gpiod_hog - Hog the specified GPIO desc given the provided flags
 * @desc:	gpio whose value will be assigned
 * @name:	gpio line name
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
 * @dflags:	gpiod_flags - optional GPIO initialization flags
 */
int gpiod_hog(struct gpio_desc *desc, const char *name,
	      unsigned long lflags, enum gpiod_flags dflags)
{
	struct gpio_chip *chip;
	struct gpio_desc *local_desc;
	int hwnum;
	int status;

	chip = gpiod_to_chip(desc);
	hwnum = gpio_chip_hwgpio(desc);

	local_desc = gpiochip_request_own_desc(chip, hwnum, name);
	if (IS_ERR(local_desc)) {
3969 3970 3971 3972
		status = PTR_ERR(local_desc);
		pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
		return status;
B
Benoit Parrot 已提交
3973 3974
	}

3975
	status = gpiod_configure_flags(desc, name, lflags, dflags);
B
Benoit Parrot 已提交
3976
	if (status < 0) {
3977 3978
		pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
B
Benoit Parrot 已提交
3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005
		gpiochip_free_own_desc(desc);
		return status;
	}

	/* Mark GPIO as hogged so it can be identified and removed later */
	set_bit(FLAG_IS_HOGGED, &desc->flags);

	pr_info("GPIO line %d (%s) hogged as %s%s\n",
		desc_to_gpio(desc), name,
		(dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
		(dflags&GPIOD_FLAGS_BIT_DIR_OUT) ?
		  (dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":"");

	return 0;
}

/**
 * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog
 * @chip:	gpio chip to act on
 *
 * This is only used by of_gpiochip_remove to free hogged gpios
 */
static void gpiochip_free_hogs(struct gpio_chip *chip)
{
	int id;

	for (id = 0; id < chip->ngpio; id++) {
4006 4007
		if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
B
Benoit Parrot 已提交
4008 4009 4010
	}
}

4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076
/**
 * gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
 * @con_id:	function within the GPIO consumer
 * @flags:	optional GPIO initialization flags
 *
 * This function acquires all the GPIOs defined under a given function.
 *
 * Return a struct gpio_descs containing an array of descriptors, -ENOENT if
 * no GPIO has been assigned to the requested function, or another IS_ERR()
 * code if an error occurred while trying to acquire the GPIOs.
 */
struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
						const char *con_id,
						enum gpiod_flags flags)
{
	struct gpio_desc *desc;
	struct gpio_descs *descs;
	int count;

	count = gpiod_count(dev, con_id);
	if (count < 0)
		return ERR_PTR(count);

	descs = kzalloc(sizeof(*descs) + sizeof(descs->desc[0]) * count,
			GFP_KERNEL);
	if (!descs)
		return ERR_PTR(-ENOMEM);

	for (descs->ndescs = 0; descs->ndescs < count; ) {
		desc = gpiod_get_index(dev, con_id, descs->ndescs, flags);
		if (IS_ERR(desc)) {
			gpiod_put_array(descs);
			return ERR_CAST(desc);
		}
		descs->desc[descs->ndescs] = desc;
		descs->ndescs++;
	}
	return descs;
}
EXPORT_SYMBOL_GPL(gpiod_get_array);

/**
 * gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO
 *                            function
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
 * @con_id:	function within the GPIO consumer
 * @flags:	optional GPIO initialization flags
 *
 * This is equivalent to gpiod_get_array(), except that when no GPIO was
 * assigned to the requested function it will return NULL.
 */
struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
							const char *con_id,
							enum gpiod_flags flags)
{
	struct gpio_descs *descs;

	descs = gpiod_get_array(dev, con_id, flags);
	if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT))
		return NULL;

	return descs;
}
EXPORT_SYMBOL_GPL(gpiod_get_array_optional);

4077 4078 4079 4080 4081 4082 4083 4084 4085
/**
 * gpiod_put - dispose of a GPIO descriptor
 * @desc:	GPIO descriptor to dispose of
 *
 * No descriptor can be used after gpiod_put() has been called on it.
 */
void gpiod_put(struct gpio_desc *desc)
{
	gpiod_free(desc);
4086
}
4087
EXPORT_SYMBOL_GPL(gpiod_put);
4088

4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103
/**
 * gpiod_put_array - dispose of multiple GPIO descriptors
 * @descs:	struct gpio_descs containing an array of descriptors
 */
void gpiod_put_array(struct gpio_descs *descs)
{
	unsigned int i;

	for (i = 0; i < descs->ndescs; i++)
		gpiod_put(descs->desc[i]);

	kfree(descs);
}
EXPORT_SYMBOL_GPL(gpiod_put_array);

4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118
static int __init gpiolib_dev_init(void)
{
	int ret;

	/* Register GPIO sysfs bus */
	ret  = bus_register(&gpio_bus_type);
	if (ret < 0) {
		pr_err("gpiolib: could not register GPIO bus type\n");
		return ret;
	}

	ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, "gpiochip");
	if (ret < 0) {
		pr_err("gpiolib: failed to allocate char dev region\n");
		bus_unregister(&gpio_bus_type);
4119 4120 4121
	} else {
		gpiolib_initialized = true;
		gpiochip_setup_devs();
4122 4123 4124 4125 4126
	}
	return ret;
}
core_initcall(gpiolib_dev_init);

4127 4128
#ifdef CONFIG_DEBUG_FS

4129
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
4130 4131
{
	unsigned		i;
4132 4133 4134
	struct gpio_chip	*chip = gdev->chip;
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
4135
	int			is_out;
4136
	int			is_irq;
4137

4138
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
4139 4140 4141 4142 4143
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
4144
			continue;
4145
		}
4146

4147
		gpiod_get_direction(gdesc);
4148
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
4149
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
4150 4151
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
4152 4153 4154
			is_out ? "out" : "in ",
			chip->get
				? (chip->get(chip, i) ? "hi" : "lo")
4155 4156
				: "?  ",
			is_irq ? "IRQ" : "   ");
4157 4158 4159 4160
		seq_printf(s, "\n");
	}
}

4161
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
4162
{
4163
	unsigned long flags;
4164
	struct gpio_device *gdev = NULL;
4165
	loff_t index = *pos;
4166

4167
	s->private = "";
4168

4169
	spin_lock_irqsave(&gpio_lock, flags);
4170
	list_for_each_entry(gdev, &gpio_devices, list)
4171 4172
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
4173
			return gdev;
4174
		}
4175
	spin_unlock_irqrestore(&gpio_lock, flags);
4176

4177
	return NULL;
4178 4179 4180 4181
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
4182
	unsigned long flags;
4183
	struct gpio_device *gdev = v;
4184 4185
	void *ret = NULL;

4186
	spin_lock_irqsave(&gpio_lock, flags);
4187
	if (list_is_last(&gdev->list, &gpio_devices))
4188 4189
		ret = NULL;
	else
4190
		ret = list_entry(gdev->list.next, struct gpio_device, list);
4191
	spin_unlock_irqrestore(&gpio_lock, flags);
4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204

	s->private = "\n";
	++*pos;

	return ret;
}

static void gpiolib_seq_stop(struct seq_file *s, void *v)
{
}

static int gpiolib_seq_show(struct seq_file *s, void *v)
{
4205 4206 4207 4208 4209 4210 4211 4212 4213
	struct gpio_device *gdev = v;
	struct gpio_chip *chip = gdev->chip;
	struct device *parent;

	if (!chip) {
		seq_printf(s, "%s%s: (dangling chip)", (char *)s->private,
			   dev_name(&gdev->dev));
		return 0;
	}
4214

4215 4216
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
4217
		   gdev->base, gdev->base + gdev->ngpio - 1);
4218 4219 4220 4221 4222
	parent = chip->parent;
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
4223 4224 4225 4226 4227 4228 4229 4230 4231
	if (chip->label)
		seq_printf(s, ", %s", chip->label);
	if (chip->can_sleep)
		seq_printf(s, ", can sleep");
	seq_printf(s, ":\n");

	if (chip->dbg_show)
		chip->dbg_show(s, chip);
	else
4232
		gpiolib_dbg_show(s, gdev);
4233

4234 4235 4236
	return 0;
}

4237 4238 4239 4240 4241 4242 4243
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

4244 4245
static int gpiolib_open(struct inode *inode, struct file *file)
{
4246
	return seq_open(file, &gpiolib_seq_ops);
4247 4248
}

4249
static const struct file_operations gpiolib_operations = {
4250
	.owner		= THIS_MODULE,
4251 4252 4253
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
4254
	.release	= seq_release,
4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266
};

static int __init gpiolib_debugfs_init(void)
{
	/* /sys/kernel/debug/gpio */
	(void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
				NULL, NULL, &gpiolib_operations);
	return 0;
}
subsys_initcall(gpiolib_debugfs_init);

#endif	/* DEBUG_FS */