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

29 30
#include "gpiolib.h"

31 32
#define CREATE_TRACE_POINTS
#include <trace/events/gpio.h>
33

34
/* Implementation infrastructure for GPIO interfaces.
35
 *
36 37 38
 * 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.
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
 */


/* 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

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

62 63 64 65
/* 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.
 */
66
DEFINE_SPINLOCK(gpio_lock);
67

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

static void gpiochip_free_hogs(struct gpio_chip *chip);
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
74 75
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
76

77
static bool gpiolib_initialized;
78

79 80 81 82 83
static inline void desc_set_label(struct gpio_desc *d, const char *label)
{
	d->label = label;
}

84 85 86
/**
 * Convert a GPIO number to its descriptor
 */
87
struct gpio_desc *gpio_to_desc(unsigned gpio)
88
{
89
	struct gpio_device *gdev;
90 91 92 93
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

94
	list_for_each_entry(gdev, &gpio_devices, list) {
95 96
		if (gdev->base <= gpio &&
		    gdev->base + gdev->ngpio > gpio) {
97
			spin_unlock_irqrestore(&gpio_lock, flags);
98
			return &gdev->descs[gpio - gdev->base];
99 100 101 102 103
		}
	}

	spin_unlock_irqrestore(&gpio_lock, flags);

104 105 106
	if (!gpio_is_valid(gpio))
		WARN(1, "invalid GPIO %d\n", gpio);

107
	return NULL;
108
}
109
EXPORT_SYMBOL_GPL(gpio_to_desc);
110

111
/**
112
 * Get the GPIO descriptor corresponding to the given hw number for this chip.
113
 */
114 115
struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
				    u16 hwnum)
116
{
117 118 119
	struct gpio_device *gdev = chip->gpiodev;

	if (hwnum >= gdev->ngpio)
120
		return ERR_PTR(-EINVAL);
121

122
	return &gdev->descs[hwnum];
123
}
124 125 126 127 128 129

/**
 * Convert a GPIO descriptor to the integer namespace.
 * This should disappear in the future but is needed since we still
 * use GPIO numbers for error messages and sysfs nodes
 */
130
int desc_to_gpio(const struct gpio_desc *desc)
131
{
132
	return desc->gdev->base + (desc - &desc->gdev->descs[0]);
133
}
134
EXPORT_SYMBOL_GPL(desc_to_gpio);
135 136


137 138 139 140 141
/**
 * 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)
142
{
143 144 145
	if (!desc || !desc->gdev || !desc->gdev->chip)
		return NULL;
	return desc->gdev->chip;
146
}
147
EXPORT_SYMBOL_GPL(gpiod_to_chip);
148

149 150 151
/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
static int gpiochip_find_base(int ngpio)
{
152
	struct gpio_device *gdev;
153
	int base = ARCH_NR_GPIOS - ngpio;
154

155
	list_for_each_entry_reverse(gdev, &gpio_devices, list) {
156
		/* found a free space? */
157
		if (gdev->base + gdev->ngpio <= base)
158 159 160
			break;
		else
			/* nope, check the space right before the chip */
161
			base = gdev->base - ngpio;
162 163
	}

164
	if (gpio_is_valid(base)) {
165
		pr_debug("%s: found new base at %d\n", __func__, base);
166 167 168 169
		return base;
	} else {
		pr_err("%s: cannot find free range\n", __func__);
		return -ENOSPC;
A
Anton Vorontsov 已提交
170 171 172
	}
}

173 174 175 176 177 178 179 180
/**
 * gpiod_get_direction - return the current direction of a GPIO
 * @desc:	GPIO to get the direction of
 *
 * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
 *
 * This function may sleep if gpiod_cansleep() is true.
 */
181
int gpiod_get_direction(struct gpio_desc *desc)
182 183
{
	struct gpio_chip	*chip;
184
	unsigned		offset;
185 186
	int			status = -EINVAL;

187 188
	chip = gpiod_to_chip(desc);
	offset = gpio_chip_hwgpio(desc);
189 190 191 192

	if (!chip->get_direction)
		return status;

193
	status = chip->get_direction(chip, offset);
194 195 196
	if (status > 0) {
		/* GPIOF_DIR_IN, or other positive */
		status = 1;
197
		clear_bit(FLAG_IS_OUT, &desc->flags);
198 199 200
	}
	if (status == 0) {
		/* GPIOF_DIR_OUT */
201
		set_bit(FLAG_IS_OUT, &desc->flags);
202 203 204
	}
	return status;
}
205
EXPORT_SYMBOL_GPL(gpiod_get_direction);
206

207 208
/*
 * Add a new chip to the global chips list, keeping the list of chips sorted
209
 * by range(means [base, base + ngpio - 1]) order.
210 211 212 213
 *
 * Return -EBUSY if the new chip overlaps with some other chip's integer
 * space.
 */
214
static int gpiodev_add_to_list(struct gpio_device *gdev)
215
{
216
	struct gpio_device *prev, *next;
217

218
	if (list_empty(&gpio_devices)) {
219
		/* initial entry in list */
220
		list_add_tail(&gdev->list, &gpio_devices);
S
Sudip Mukherjee 已提交
221
		return 0;
222 223
	}

224 225 226 227 228
	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;
229 230
	}

231 232 233 234
	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);
235
		return 0;
236 237
	}

238 239 240 241
	list_for_each_entry_safe(prev, next, &gpio_devices, list) {
		/* at the end of the list */
		if (&next->list == &gpio_devices)
			break;
242

243 244 245 246 247 248 249 250 251 252
		/* 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;
253 254
}

255 256 257 258 259
/**
 * Convert a GPIO name to its descriptor
 */
static struct gpio_desc *gpio_name_to_desc(const char * const name)
{
260
	struct gpio_device *gdev;
261 262 263 264
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

265
	list_for_each_entry(gdev, &gpio_devices, list) {
266 267
		int i;

268 269
		for (i = 0; i != gdev->ngpio; ++i) {
			struct gpio_desc *desc = &gdev->descs[i];
270

271
			if (!desc->name || !name)
272 273
				continue;

274
			if (!strcmp(desc->name, name)) {
275
				spin_unlock_irqrestore(&gpio_lock, flags);
276
				return desc;
277 278 279 280 281 282 283 284 285
			}
		}
	}

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

286 287 288 289
/*
 * Takes the names from gc->names and checks if they are all unique. If they
 * are, they are assigned to their gpio descriptors.
 *
290
 * Warning if one of the names is already used for a different GPIO.
291 292 293
 */
static int gpiochip_set_desc_names(struct gpio_chip *gc)
{
294
	struct gpio_device *gdev = gc->gpiodev;
295 296 297 298 299 300 301 302 303 304
	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]);
305
		if (gpio)
306
			dev_warn(&gdev->dev,
307
				 "Detected name collision for GPIO name '%s'\n",
308
				 gc->names[i]);
309 310 311 312
	}

	/* Then add all names to the GPIO descriptors */
	for (i = 0; i != gc->ngpio; ++i)
313
		gdev->descs[i].name = gc->names[i];
314 315 316 317

	return 0;
}

318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 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 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 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
/*
 * 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;
};

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;
	int i;

	if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
		int val;

		/* TODO: check if descriptors are really input */
		for (i = 0; i < lh->numdescs; i++) {
			val = gpiod_get_value_cansleep(lh->descs[i]);
			if (val < 0)
				return val;
			ghd.values[i] = val;
		}

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

		return 0;
	} else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
		int vals[GPIOHANDLES_MAX];

		/* 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;
	int fd, i, ret;

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

	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];
		u32 lflags = handlereq.flags;
		struct gpio_desc *desc;

		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);

		/*
		 * 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);
	}
478 479
	/* Let i point at the last handle */
	i--;
480 481 482 483 484 485 486 487 488 489 490 491
	lh->numdescs = handlereq.lines;

	fd = anon_inode_getfd("gpio-linehandle",
			      &linehandle_fileops,
			      lh,
			      O_RDONLY | O_CLOEXEC);
	if (fd < 0) {
		ret = fd;
		goto out_free_descs;
	}

	handlereq.fd = fd;
492 493 494 495
	if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
		ret = -EFAULT;
		goto out_free_descs;
	}
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511

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

	return 0;

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;
}

512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
/*
 * 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
 */
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;
};

static unsigned int lineevent_poll(struct file *filep,
				   struct poll_table_struct *wait)
{
	struct lineevent_state *le = filep->private_data;
	unsigned int events = 0;

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

	if (!kfifo_is_empty(&le->events))
		events = POLLIN | POLLRDNORM;

	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;

		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
};

659
static irqreturn_t lineevent_irq_thread(int irq, void *p)
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
{
	struct lineevent_state *le = p;
	struct gpioevent_data ge;
	int ret;

	ge.timestamp = ktime_get_real_ns();

	if (le->eflags & GPIOEVENT_REQUEST_BOTH_EDGES) {
		int level = gpiod_get_value_cansleep(le->desc);

		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;
	} else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) {
		/* Emit low-to-high event */
		ge.id = GPIOEVENT_EVENT_RISING_EDGE;
	} else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
		/* Emit high-to-low event */
		ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
682 683
	} else {
		return IRQ_NONE;
684 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 762 763 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
	}

	ret = kfifo_put(&le->events, ge);
	if (ret != 0)
		wake_up_poll(&le->wait, POLLIN);

	return IRQ_HANDLED;
}

static int lineevent_create(struct gpio_device *gdev, void __user *ip)
{
	struct gpioevent_request eventreq;
	struct lineevent_state *le;
	struct gpio_desc *desc;
	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;

	/* 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,
			NULL,
			lineevent_irq_thread,
			irqflags,
			le->label,
			le);
	if (ret)
		goto out_free_desc;

	fd = anon_inode_getfd("gpio-event",
			      &lineevent_fileops,
			      le,
			      O_RDONLY | O_CLOEXEC);
	if (fd < 0) {
		ret = fd;
		goto out_free_irq;
	}

	eventreq.fd = fd;
790 791 792 793
	if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
		ret = -EFAULT;
		goto out_free_irq;
	}
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808

	return 0;

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;
}

809 810 811 812 813 814 815
/**
 * 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;
816
	void __user *ip = (void __user *)arg;
817 818 819 820 821

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

822
	/* Fill in the struct and pass to userspace */
823
	if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
824 825
		struct gpiochip_info chipinfo;

826 827 828
		strncpy(chipinfo.name, dev_name(&gdev->dev),
			sizeof(chipinfo.name));
		chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
829 830 831
		strncpy(chipinfo.label, gdev->label,
			sizeof(chipinfo.label));
		chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
832
		chipinfo.lines = gdev->ngpio;
833 834 835
		if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
			return -EFAULT;
		return 0;
836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
	} 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;
		if (lineinfo.line_offset > gdev->ngpio)
			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) {
854 855 856
			strncpy(lineinfo.consumer, desc->label,
				sizeof(lineinfo.consumer));
			lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
857
		} else {
858
			lineinfo.consumer[0] = '\0';
859 860 861 862 863 864 865
		}

		/*
		 * Userspace only need to know that the kernel is using
		 * this GPIO so it can't use it.
		 */
		lineinfo.flags = 0;
866 867 868 869 870
		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))
871
			lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
872
		if (test_bit(FLAG_IS_OUT, &desc->flags))
873
			lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
874
		if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
875
			lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
876
		if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
877
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
878
		if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
879 880 881 882 883
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;

		if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
			return -EFAULT;
		return 0;
884 885
	} else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
		return linehandle_create(gdev, ip);
886 887
	} else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
		return lineevent_create(gdev, ip);
888 889 890 891
	}
	return -EINVAL;
}

892 893 894 895 896 897 898 899
#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

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 939 940 941 942
/**
 * 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 */
	if (!gdev || !gdev->chip)
		return -ENODEV;
	get_device(&gdev->dev);
	filp->private_data = gdev;
	return 0;
}

/**
 * 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);

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


static const struct file_operations gpio_fileops = {
	.release = gpio_chrdev_release,
	.open = gpio_chrdev_open,
	.owner = THIS_MODULE,
	.llseek = noop_llseek,
	.unlocked_ioctl = gpio_ioctl,
943 944 945
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
946 947
};

948 949 950 951 952 953
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);
954 955
	kfree(gdev->label);
	kfree(gdev->descs);
956
	kfree(gdev);
957 958
}

959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
static int gpiochip_setup_dev(struct gpio_device *gdev)
{
	int status;

	cdev_init(&gdev->chrdev, &gpio_fileops);
	gdev->chrdev.owner = THIS_MODULE;
	gdev->chrdev.kobj.parent = &gdev->dev.kobj;
	gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
	status = cdev_add(&gdev->chrdev, gdev->dev.devt, 1);
	if (status < 0)
		chip_warn(gdev->chip, "failed to add char device %d:%d\n",
			  MAJOR(gpio_devt), gdev->id);
	else
		chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
			 MAJOR(gpio_devt), gdev->id);
	status = device_add(&gdev->dev);
	if (status)
		goto err_remove_chardev;

	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:
	device_del(&gdev->dev);
err_remove_chardev:
	cdev_del(&gdev->chrdev);
	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);
	}
}

1010
/**
1011
 * gpiochip_add_data() - register a gpio_chip
1012
 * @chip: the chip to register, with chip->base initialized
1013
 * Context: potentially before irqs will work
1014 1015 1016 1017
 *
 * 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.
1018
 *
1019
 * When gpiochip_add_data() is called very early during boot, so that GPIOs
1020
 * can be freely used, the chip->parent device must be registered before
D
David Brownell 已提交
1021 1022 1023
 * the gpio framework's arch_initcall().  Otherwise sysfs initialization
 * for GPIOs will fail rudely.
 *
1024 1025 1026
 * gpiochip_add_data() must only be called after gpiolib initialization,
 * ie after core_initcall().
 *
1027 1028
 * If chip->base is negative, this requests dynamic assignment of
 * a range of valid GPIOs.
1029
 */
1030
int gpiochip_add_data(struct gpio_chip *chip, void *data)
1031 1032 1033
{
	unsigned long	flags;
	int		status = 0;
1034
	unsigned	i;
1035
	int		base = chip->base;
1036
	struct gpio_device *gdev;
1037

1038 1039 1040 1041
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
1042
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1043
	if (!gdev)
1044
		return -ENOMEM;
1045
	gdev->dev.bus = &gpio_bus_type;
1046 1047 1048 1049 1050
	gdev->chip = chip;
	chip->gpiodev = gdev;
	if (chip->parent) {
		gdev->dev.parent = chip->parent;
		gdev->dev.of_node = chip->parent->of_node;
1051 1052
	}

1053 1054
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
1055 1056
	if (chip->of_node)
		gdev->dev.of_node = chip->of_node;
1057
#endif
1058

1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
	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;
1074

1075
	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1076
	if (!gdev->descs) {
1077 1078 1079 1080
		status = -ENOMEM;
		goto err_free_gdev;
	}

1081 1082
	if (chip->ngpio == 0) {
		chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1083
		status = -EINVAL;
1084
		goto err_free_descs;
1085
	}
1086 1087

	if (chip->label)
1088
		gdev->label = kstrdup(chip->label, GFP_KERNEL);
1089
	else
1090
		gdev->label = kstrdup("unknown", GFP_KERNEL);
1091 1092
	if (!gdev->label) {
		status = -ENOMEM;
1093
		goto err_free_descs;
1094 1095
	}

1096
	gdev->ngpio = chip->ngpio;
1097
	gdev->data = data;
1098

1099 1100
	spin_lock_irqsave(&gpio_lock, flags);

1101 1102 1103 1104 1105 1106 1107
	/*
	 * 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.
	 */
1108 1109 1110 1111
	if (base < 0) {
		base = gpiochip_find_base(chip->ngpio);
		if (base < 0) {
			status = base;
1112
			spin_unlock_irqrestore(&gpio_lock, flags);
1113
			goto err_free_label;
1114
		}
1115 1116 1117 1118 1119 1120
		/*
		 * 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.
		 */
1121 1122
		chip->base = base;
	}
1123
	gdev->base = base;
1124

1125
	status = gpiodev_add_to_list(gdev);
1126 1127
	if (status) {
		spin_unlock_irqrestore(&gpio_lock, flags);
1128
		goto err_free_label;
1129
	}
1130

1131 1132
	spin_unlock_irqrestore(&gpio_lock, flags);

1133
	for (i = 0; i < chip->ngpio; i++) {
1134
		struct gpio_desc *desc = &gdev->descs[i];
1135

1136
		desc->gdev = gdev;
1137 1138 1139 1140 1141 1142 1143
		/*
		 * 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.
1144
		 */
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161

		if (chip->get_direction) {
			/*
			 * If we have .get_direction, set up the initial
			 * direction flag from the hardware.
			 */
			int dir = chip->get_direction(chip, i);

			if (!dir)
				set_bit(FLAG_IS_OUT, &desc->flags);
		} else if (!chip->direction_input) {
			/*
			 * If the chip lacks the .direction_input callback
			 * we logically assume all lines are outputs.
			 */
			set_bit(FLAG_IS_OUT, &desc->flags);
		}
1162
	}
1163

1164
#ifdef CONFIG_PINCTRL
1165
	INIT_LIST_HEAD(&gdev->pin_ranges);
1166 1167
#endif

1168 1169 1170 1171
	status = gpiochip_set_desc_names(chip);
	if (status)
		goto err_remove_from_list;

1172 1173 1174 1175
	status = gpiochip_irqchip_init_valid_mask(chip);
	if (status)
		goto err_remove_from_list;

1176 1177 1178 1179
	status = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

1180
	acpi_gpiochip_add(chip);
1181

1182 1183 1184 1185 1186
	/*
	 * 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.
1187 1188
	 * We can do this only if gpiolib has been initialized.
	 * Otherwise, defer until later.
1189
	 */
1190 1191 1192 1193 1194
	if (gpiolib_initialized) {
		status = gpiochip_setup_dev(gdev);
		if (status)
			goto err_remove_chip;
	}
1195
	return 0;
1196

1197 1198
err_remove_chip:
	acpi_gpiochip_remove(chip);
1199
	gpiochip_free_hogs(chip);
1200
	of_gpiochip_remove(chip);
1201
	gpiochip_irqchip_free_valid_mask(chip);
1202
err_remove_from_list:
1203
	spin_lock_irqsave(&gpio_lock, flags);
1204
	list_del(&gdev->list);
1205
	spin_unlock_irqrestore(&gpio_lock, flags);
1206 1207 1208 1209
err_free_label:
	kfree(gdev->label);
err_free_descs:
	kfree(gdev->descs);
1210 1211
err_free_gdev:
	ida_simple_remove(&gpio_ida, gdev->id);
1212
	/* failures here can mean systems won't boot... */
1213
	pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1214 1215 1216
	       gdev->base, gdev->base + gdev->ngpio - 1,
	       chip->label ? : "generic");
	kfree(gdev);
1217 1218
	return status;
}
1219
EXPORT_SYMBOL_GPL(gpiochip_add_data);
1220

1221 1222 1223 1224 1225 1226 1227 1228 1229
/**
 * gpiochip_get_data() - get per-subdriver data for the chip
 */
void *gpiochip_get_data(struct gpio_chip *chip)
{
	return chip->gpiodev->data;
}
EXPORT_SYMBOL_GPL(gpiochip_get_data);

1230 1231 1232 1233 1234 1235
/**
 * gpiochip_remove() - unregister a gpio_chip
 * @chip: the chip to unregister
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
1236
void gpiochip_remove(struct gpio_chip *chip)
1237
{
1238
	struct gpio_device *gdev = chip->gpiodev;
J
Johan Hovold 已提交
1239
	struct gpio_desc *desc;
1240
	unsigned long	flags;
1241
	unsigned	i;
J
Johan Hovold 已提交
1242
	bool		requested = false;
1243

1244
	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1245
	gpiochip_sysfs_unregister(gdev);
1246 1247
	/* Numb the device, cancelling all outstanding operations */
	gdev->chip = NULL;
1248
	gpiochip_irqchip_remove(chip);
1249
	acpi_gpiochip_remove(chip);
1250
	gpiochip_remove_pin_ranges(chip);
B
Benoit Parrot 已提交
1251
	gpiochip_free_hogs(chip);
1252
	of_gpiochip_remove(chip);
1253 1254 1255 1256 1257
	/*
	 * We accept no more calls into the driver from this point, so
	 * NULL the driver data pointer
	 */
	gdev->data = NULL;
1258

1259
	spin_lock_irqsave(&gpio_lock, flags);
1260
	for (i = 0; i < gdev->ngpio; i++) {
1261
		desc = &gdev->descs[i];
J
Johan Hovold 已提交
1262 1263
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
1264 1265
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
1266

J
Johan Hovold 已提交
1267
	if (requested)
1268
		dev_crit(&gdev->dev,
1269
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
J
Johan Hovold 已提交
1270

1271 1272 1273 1274 1275 1276
	/*
	 * 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.
	 */
1277 1278
	cdev_del(&gdev->chrdev);
	device_del(&gdev->dev);
1279
	put_device(&gdev->dev);
1280 1281 1282
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
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;
}

/**
 * devm_gpiochip_add_data() - Resource manager piochip_add_data()
 * @dev: the device pointer on which irq_chip belongs to.
 * @chip: the chip to register, with chip->base initialized
 * Context: potentially before irqs will work
 *
 * 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.
 *
 * The gpio chip automatically be released when the device is unbound.
 */
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);
	if (!ret)
		WARN_ON(ret);
}
EXPORT_SYMBOL_GPL(devm_gpiochip_remove);

1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
/**
 * gpiochip_find() - iterator for locating a specific gpio_chip
 * @data: data to pass to match function
 * @callback: Callback function to check gpio_chip
 *
 * 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.
 */
1368
struct gpio_chip *gpiochip_find(void *data,
1369
				int (*match)(struct gpio_chip *chip,
1370
					     void *data))
1371
{
1372
	struct gpio_device *gdev;
1373
	struct gpio_chip *chip = NULL;
1374 1375 1376
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
1377
	list_for_each_entry(gdev, &gpio_devices, list)
1378 1379
		if (gdev->chip && match(gdev->chip, data)) {
			chip = gdev->chip;
1380
			break;
1381
		}
1382

1383 1384 1385 1386
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
J
Jean Delvare 已提交
1387
EXPORT_SYMBOL_GPL(gpiochip_find);
1388

1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
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);
}

1401 1402 1403 1404 1405 1406
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
{
	int i;

	if (!gpiochip->irq_need_valid_mask)
		return 0;

	gpiochip->irq_valid_mask = kcalloc(BITS_TO_LONGS(gpiochip->ngpio),
					   sizeof(long), GFP_KERNEL);
	if (!gpiochip->irq_valid_mask)
		return -ENOMEM;

	/* Assume by default all GPIOs are valid */
	for (i = 0; i < gpiochip->ngpio; i++)
		set_bit(i, gpiochip->irq_valid_mask);

	return 0;
}

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

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

1441
/**
1442 1443 1444
 * gpiochip_set_chained_irqchip() - sets a chained irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
1445 1446 1447
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1448 1449
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
1450 1451 1452 1453 1454 1455
 */
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
				  struct irq_chip *irqchip,
				  int parent_irq,
				  irq_flow_handler_t parent_handler)
{
1456 1457 1458 1459 1460
	unsigned int offset;

	if (!gpiochip->irqdomain) {
		chip_err(gpiochip, "called %s before setting up irqchip\n",
			 __func__);
1461 1462 1463
		return;
	}

1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
	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.
		 */
1475 1476
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
1477 1478

		gpiochip->irq_parent = parent_irq;
1479
	}
1480 1481

	/* Set the parent IRQ for all affected IRQs */
1482 1483 1484
	for (offset = 0; offset < gpiochip->ngpio; offset++) {
		if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
			continue;
1485 1486
		irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
			       parent_irq);
1487
	}
1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
}
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);

/**
 * 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.
 */
static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
			    irq_hw_number_t hwirq)
{
	struct gpio_chip *chip = d->host_data;

	irq_set_chip_data(irq, chip);
1507 1508 1509 1510 1511
	/*
	 * This lock class tells lockdep that GPIO irqs are in a different
	 * category than their parents, so it won't report false recursion.
	 */
	irq_set_lockdep_class(irq, chip->lock_key);
1512
	irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
1513
	/* Chips that can sleep need nested thread handlers */
1514
	if (chip->can_sleep && !chip->irq_not_threaded)
1515
		irq_set_nested_thread(irq, 1);
1516
	irq_set_noprobe(irq);
R
Rob Herring 已提交
1517

1518 1519 1520 1521 1522 1523
	/*
	 * No set-up of the hardware will happen if IRQ_TYPE_NONE
	 * is passed as default type.
	 */
	if (chip->irq_default_type != IRQ_TYPE_NONE)
		irq_set_irq_type(irq, chip->irq_default_type);
1524 1525 1526 1527

	return 0;
}

L
Linus Walleij 已提交
1528 1529
static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
{
1530 1531 1532 1533
	struct gpio_chip *chip = d->host_data;

	if (chip->can_sleep)
		irq_set_nested_thread(irq, 0);
L
Linus Walleij 已提交
1534 1535 1536 1537
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}

1538 1539
static const struct irq_domain_ops gpiochip_domain_ops = {
	.map	= gpiochip_irq_map,
L
Linus Walleij 已提交
1540
	.unmap	= gpiochip_irq_unmap,
1541 1542 1543 1544 1545 1546 1547 1548
	/* 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);

1549
	if (!try_module_get(chip->gpiodev->owner))
1550 1551
		return -ENODEV;

1552
	if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1553 1554 1555
		chip_err(chip,
			"unable to lock HW IRQ %lu for IRQ\n",
			d->hwirq);
1556
		module_put(chip->gpiodev->owner);
1557 1558 1559 1560 1561 1562 1563 1564 1565
		return -EINVAL;
	}
	return 0;
}

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

1566
	gpiochip_unlock_as_irq(chip, d->hwirq);
1567
	module_put(chip->gpiodev->owner);
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
}

static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
{
	return irq_find_mapping(chip->irqdomain, offset);
}

/**
 * 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)
{
L
Linus Walleij 已提交
1583 1584
	unsigned int offset;

1585 1586
	acpi_gpiochip_free_interrupts(gpiochip);

1587 1588 1589 1590 1591
	if (gpiochip->irq_parent) {
		irq_set_chained_handler(gpiochip->irq_parent, NULL);
		irq_set_handler_data(gpiochip->irq_parent, NULL);
	}

L
Linus Walleij 已提交
1592 1593
	/* Remove all IRQ mappings and delete the domain */
	if (gpiochip->irqdomain) {
1594 1595 1596
		for (offset = 0; offset < gpiochip->ngpio; offset++) {
			if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
				continue;
1597 1598
			irq_dispose_mapping(
				irq_find_mapping(gpiochip->irqdomain, offset));
1599
		}
1600
		irq_domain_remove(gpiochip->irqdomain);
L
Linus Walleij 已提交
1601
	}
1602 1603 1604 1605 1606 1607

	if (gpiochip->irqchip) {
		gpiochip->irqchip->irq_request_resources = NULL;
		gpiochip->irqchip->irq_release_resources = NULL;
		gpiochip->irqchip = NULL;
	}
1608 1609

	gpiochip_irqchip_free_valid_mask(gpiochip);
1610 1611 1612 1613 1614 1615 1616 1617 1618
}

/**
 * gpiochip_irqchip_add() - adds an irqchip to a gpiochip
 * @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)
1619 1620
 * @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.
1621
 * @lock_key: lockdep class
1622 1623 1624 1625 1626
 *
 * 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 已提交
1627
 * need to use gpiochip_get_data() to get their local state containers back
1628 1629 1630 1631 1632
 * 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 已提交
1633 1634
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1635 1636
 * need to be open coded.
 */
1637 1638 1639 1640 1641 1642
int _gpiochip_irqchip_add(struct gpio_chip *gpiochip,
			  struct irq_chip *irqchip,
			  unsigned int first_irq,
			  irq_flow_handler_t handler,
			  unsigned int type,
			  struct lock_class_key *lock_key)
1643 1644
{
	struct device_node *of_node;
1645
	bool irq_base_set = false;
1646
	unsigned int offset;
L
Linus Walleij 已提交
1647
	unsigned irq_base = 0;
1648 1649 1650 1651

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

1652
	if (!gpiochip->parent) {
1653 1654 1655
		pr_err("missing gpiochip .dev parent pointer\n");
		return -EINVAL;
	}
1656
	of_node = gpiochip->parent->of_node;
1657 1658
#ifdef CONFIG_OF_GPIO
	/*
1659
	 * If the gpiochip has an assigned OF node this takes precedence
1660 1661
	 * FIXME: get rid of this and use gpiochip->parent->of_node
	 * everywhere
1662 1663 1664 1665
	 */
	if (gpiochip->of_node)
		of_node = gpiochip->of_node;
#endif
1666
	/*
1667
	 * Specifying a default trigger is a terrible idea if DT or ACPI is
1668 1669 1670 1671 1672 1673
	 * 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,
		 "%s: Ignoring %d default trigger\n", of_node->full_name, type))
		type = IRQ_TYPE_NONE;
1674 1675 1676 1677 1678
	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;
	}
1679

1680 1681 1682 1683
	gpiochip->irqchip = irqchip;
	gpiochip->irq_handler = handler;
	gpiochip->irq_default_type = type;
	gpiochip->to_irq = gpiochip_to_irq;
1684
	gpiochip->lock_key = lock_key;
1685 1686 1687 1688 1689 1690 1691
	gpiochip->irqdomain = irq_domain_add_simple(of_node,
					gpiochip->ngpio, first_irq,
					&gpiochip_domain_ops, gpiochip);
	if (!gpiochip->irqdomain) {
		gpiochip->irqchip = NULL;
		return -EINVAL;
	}
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701

	/*
	 * 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;
	}
1702 1703 1704 1705 1706 1707

	/*
	 * Prepare the mapping since the irqchip shall be orthogonal to
	 * any gpiochip calls. If the first_irq was zero, this is
	 * necessary to allocate descriptors for all IRQs.
	 */
L
Linus Walleij 已提交
1708
	for (offset = 0; offset < gpiochip->ngpio; offset++) {
1709 1710
		if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
			continue;
L
Linus Walleij 已提交
1711
		irq_base = irq_create_mapping(gpiochip->irqdomain, offset);
1712
		if (!irq_base_set) {
L
Linus Walleij 已提交
1713 1714 1715 1716 1717
			/*
			 * Store the base into the gpiochip to be used when
			 * unmapping the irqs.
			 */
			gpiochip->irq_base = irq_base;
1718 1719
			irq_base_set = true;
		}
L
Linus Walleij 已提交
1720
	}
1721

1722 1723
	acpi_gpiochip_request_interrupts(gpiochip);

1724 1725
	return 0;
}
1726
EXPORT_SYMBOL_GPL(_gpiochip_irqchip_add);
1727 1728 1729 1730

#else /* CONFIG_GPIOLIB_IRQCHIP */

static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1731 1732 1733 1734 1735 1736
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)
{ }
1737 1738 1739

#endif /* CONFIG_GPIOLIB_IRQCHIP */

1740 1741 1742 1743 1744 1745 1746
/**
 * 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)
{
1747
	return pinctrl_request_gpio(chip->gpiodev->base + offset);
1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
}
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)
{
1758
	pinctrl_free_gpio(chip->gpiodev->base + offset);
1759 1760 1761
}
EXPORT_SYMBOL_GPL(gpiochip_generic_free);

1762
#ifdef CONFIG_PINCTRL
1763

1764 1765 1766
/**
 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
1767
 * @pctldev: the pin controller to map to
1768 1769 1770 1771 1772 1773 1774 1775
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_group: name of the pin group inside the pin controller
 */
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;
1776
	struct gpio_device *gdev = chip->gpiodev;
1777 1778 1779 1780
	int ret;

	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
	if (!pin_range) {
1781
		chip_err(chip, "failed to allocate pin ranges\n");
1782 1783 1784 1785 1786 1787 1788
		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;
1789
	pin_range->range.base = gdev->base + gpio_offset;
1790 1791 1792 1793 1794
	pin_range->pctldev = pctldev;

	ret = pinctrl_get_group_pins(pctldev, pin_group,
					&pin_range->range.pins,
					&pin_range->range.npins);
1795 1796
	if (ret < 0) {
		kfree(pin_range);
1797
		return ret;
1798
	}
1799 1800 1801

	pinctrl_add_gpio_range(pctldev, &pin_range->range);

1802 1803
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
1804 1805
		 pinctrl_dev_get_devname(pctldev), pin_group);

1806
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
1807 1808 1809 1810 1811

	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);

1812 1813 1814 1815
/**
 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
 * @pinctrl_name: the dev_name() of the pin controller to map to
1816 1817
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_offset: the start offset in the pin controller number space
1818 1819 1820
 * @npins: the number of pins from the offset of each pin space (GPIO and
 *	pin controller) to accumulate in this range
 */
1821
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1822
			   unsigned int gpio_offset, unsigned int pin_offset,
1823
			   unsigned int npins)
1824 1825
{
	struct gpio_pin_range *pin_range;
1826
	struct gpio_device *gdev = chip->gpiodev;
1827
	int ret;
1828

1829
	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1830
	if (!pin_range) {
1831
		chip_err(chip, "failed to allocate pin ranges\n");
1832
		return -ENOMEM;
1833 1834
	}

1835
	/* Use local offset as range ID */
1836
	pin_range->range.id = gpio_offset;
1837
	pin_range->range.gc = chip;
1838
	pin_range->range.name = chip->label;
1839
	pin_range->range.base = gdev->base + gpio_offset;
1840
	pin_range->range.pin_base = pin_offset;
1841
	pin_range->range.npins = npins;
L
Linus Walleij 已提交
1842
	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1843
			&pin_range->range);
1844
	if (IS_ERR(pin_range->pctldev)) {
1845
		ret = PTR_ERR(pin_range->pctldev);
1846
		chip_err(chip, "could not create pin range\n");
1847
		kfree(pin_range);
1848
		return ret;
1849
	}
1850 1851
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
		 gpio_offset, gpio_offset + npins - 1,
1852 1853
		 pinctl_name,
		 pin_offset, pin_offset + npins - 1);
1854

1855
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
1856 1857

	return 0;
1858
}
1859
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1860

1861 1862 1863 1864
/**
 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
 * @chip: the chip to remove all the mappings for
 */
1865 1866 1867
void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
{
	struct gpio_pin_range *pin_range, *tmp;
1868
	struct gpio_device *gdev = chip->gpiodev;
1869

1870
	list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
1871 1872 1873
		list_del(&pin_range->node);
		pinctrl_remove_gpio_range(pin_range->pctldev,
				&pin_range->range);
1874
		kfree(pin_range);
1875 1876
	}
}
1877 1878 1879
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);

#endif /* CONFIG_PINCTRL */
1880

1881 1882 1883 1884
/* 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.
 */
1885
static int __gpiod_request(struct gpio_desc *desc, const char *label)
1886
{
1887
	struct gpio_chip	*chip = desc->gdev->chip;
1888
	int			status;
1889 1890
	unsigned long		flags;

1891 1892
	spin_lock_irqsave(&gpio_lock, flags);

1893
	/* NOTE:  gpio_request() can be called in early boot,
D
David Brownell 已提交
1894
	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1895 1896 1897 1898 1899
	 */

	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
		desc_set_label(desc, label ? : "?");
		status = 0;
1900
	} else {
1901
		status = -EBUSY;
M
Magnus Damm 已提交
1902
		goto done;
D
David Brownell 已提交
1903 1904 1905 1906 1907
	}

	if (chip->request) {
		/* chip->request may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
1908
		status = chip->request(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
1909 1910 1911 1912 1913
		spin_lock_irqsave(&gpio_lock, flags);

		if (status < 0) {
			desc_set_label(desc, NULL);
			clear_bit(FLAG_REQUESTED, &desc->flags);
1914
			goto done;
D
David Brownell 已提交
1915
		}
1916
	}
1917 1918 1919
	if (chip->get_direction) {
		/* chip->get_direction may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
1920
		gpiod_get_direction(desc);
1921 1922
		spin_lock_irqsave(&gpio_lock, flags);
	}
1923 1924 1925 1926 1927
done:
	spin_unlock_irqrestore(&gpio_lock, flags);
	return status;
}

1928 1929 1930
/*
 * This descriptor validation needs to be inserted verbatim into each
 * function taking a descriptor, so we need to use a preprocessor
1931 1932
 * macro to avoid endless duplication. If the desc is NULL it is an
 * optional GPIO and calls should just bail out.
1933 1934
 */
#define VALIDATE_DESC(desc) do { \
1935 1936
	if (!desc) \
		return 0; \
1937 1938 1939 1940
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return PTR_ERR(desc); \
	} \
1941
	if (!desc->gdev) { \
1942
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
1943 1944 1945 1946 1947 1948 1949 1950 1951
		return -EINVAL; \
	} \
	if ( !desc->gdev->chip ) { \
		dev_warn(&desc->gdev->dev, \
			 "%s: backing chip is gone\n", __func__); \
		return 0; \
	} } while (0)

#define VALIDATE_DESC_VOID(desc) do { \
1952 1953
	if (!desc) \
		return; \
1954 1955 1956 1957
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return; \
	} \
1958
	if (!desc->gdev) { \
1959
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
1960 1961 1962 1963 1964 1965 1966 1967 1968
		return; \
	} \
	if (!desc->gdev->chip) { \
		dev_warn(&desc->gdev->dev, \
			 "%s: backing chip is gone\n", __func__); \
		return; \
	} } while (0)


1969
int gpiod_request(struct gpio_desc *desc, const char *label)
1970 1971
{
	int status = -EPROBE_DEFER;
1972
	struct gpio_device *gdev;
1973

1974 1975
	VALIDATE_DESC(desc);
	gdev = desc->gdev;
1976

1977
	if (try_module_get(gdev->owner)) {
1978 1979
		status = __gpiod_request(desc, label);
		if (status < 0)
1980
			module_put(gdev->owner);
1981 1982
		else
			get_device(&gdev->dev);
1983 1984
	}

1985
	if (status)
1986
		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1987

1988 1989
	return status;
}
1990

1991
static bool __gpiod_free(struct gpio_desc *desc)
1992
{
1993
	bool			ret = false;
1994
	unsigned long		flags;
D
David Brownell 已提交
1995
	struct gpio_chip	*chip;
1996

1997 1998
	might_sleep();

1999
	gpiod_unexport(desc);
D
David Brownell 已提交
2000

2001 2002
	spin_lock_irqsave(&gpio_lock, flags);

2003
	chip = desc->gdev->chip;
D
David Brownell 已提交
2004 2005 2006
	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
		if (chip->free) {
			spin_unlock_irqrestore(&gpio_lock, flags);
2007
			might_sleep_if(chip->can_sleep);
2008
			chip->free(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2009 2010
			spin_lock_irqsave(&gpio_lock, flags);
		}
2011
		desc_set_label(desc, NULL);
2012
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
D
David Brownell 已提交
2013
		clear_bit(FLAG_REQUESTED, &desc->flags);
2014
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2015
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
B
Benoit Parrot 已提交
2016
		clear_bit(FLAG_IS_HOGGED, &desc->flags);
2017 2018
		ret = true;
	}
2019 2020

	spin_unlock_irqrestore(&gpio_lock, flags);
2021 2022 2023
	return ret;
}

2024
void gpiod_free(struct gpio_desc *desc)
2025
{
2026
	if (desc && desc->gdev && __gpiod_free(desc)) {
2027
		module_put(desc->gdev->owner);
2028 2029
		put_device(&desc->gdev->dev);
	} else {
2030
		WARN_ON(extra_checks);
2031
	}
2032
}
2033

2034 2035 2036 2037 2038 2039
/**
 * 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.
2040 2041
 * The string returned is the label passed to gpio_request(); if none has been
 * passed it is a meaningless, non-NULL constant.
2042 2043 2044 2045 2046 2047 2048
 *
 * 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)
{
2049
	struct gpio_desc *desc;
2050

2051
	if (offset >= chip->ngpio)
2052
		return NULL;
2053

2054
	desc = &chip->gpiodev->descs[offset];
2055

2056
	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2057
		return NULL;
2058
	return desc->label;
2059 2060 2061
}
EXPORT_SYMBOL_GPL(gpiochip_is_requested);

2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
/**
 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
 * @desc: GPIO descriptor to request
 * @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).
 */
2073 2074
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
					    const char *label)
2075
{
2076 2077
	struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
	int err;
2078

2079 2080 2081 2082 2083 2084 2085 2086
	if (IS_ERR(desc)) {
		chip_err(chip, "failed to get GPIO descriptor\n");
		return desc;
	}

	err = __gpiod_request(desc, label);
	if (err < 0)
		return ERR_PTR(err);
2087

2088
	return desc;
2089
}
2090
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103

/**
 * 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)
		__gpiod_free(desc);
}
2104
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2105

2106 2107
/*
 * Drivers MUST set GPIO direction before making get/set calls.  In
2108 2109 2110 2111 2112 2113 2114 2115
 * 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.
 */

2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
/**
 * 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)
2126 2127 2128 2129
{
	struct gpio_chip	*chip;
	int			status = -EINVAL;

2130 2131
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2132

2133
	if (!chip->get || !chip->direction_input) {
2134 2135
		gpiod_warn(desc,
			"%s: missing get() or direction_input() operations\n",
2136
			__func__);
2137 2138 2139
		return -EIO;
	}

2140
	status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2141 2142
	if (status == 0)
		clear_bit(FLAG_IS_OUT, &desc->flags);
2143

2144
	trace_gpio_direction(desc_to_gpio(desc), 1, status);
2145

2146 2147
	return status;
}
2148
EXPORT_SYMBOL_GPL(gpiod_direction_input);
2149

2150
static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2151
{
2152
	struct gpio_chip *gc = desc->gdev->chip;
2153
	int val = !!value;
2154
	int ret;
2155

2156 2157 2158 2159 2160 2161 2162 2163
	/* 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;
	}

2164 2165 2166 2167 2168 2169 2170 2171 2172
	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
		/* First see if we can enable open drain in hardware */
		if (gc->set_single_ended) {
			ret = gc->set_single_ended(gc, gpio_chip_hwgpio(desc),
						   LINE_MODE_OPEN_DRAIN);
			if (!ret)
				goto set_output_value;
		}
		/* Emulate open drain by not actively driving the line high */
2173
		if (val)
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
			return gpiod_direction_input(desc);
	}
	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
		if (gc->set_single_ended) {
			ret = gc->set_single_ended(gc, gpio_chip_hwgpio(desc),
						   LINE_MODE_OPEN_SOURCE);
			if (!ret)
				goto set_output_value;
		}
		/* Emulate open source by not actively driving the line low */
2184
		if (!val)
2185 2186 2187 2188 2189 2190 2191 2192
			return gpiod_direction_input(desc);
	} else {
		/* Make sure to disable open drain/source hardware, if any */
		if (gc->set_single_ended)
			gc->set_single_ended(gc,
					     gpio_chip_hwgpio(desc),
					     LINE_MODE_PUSH_PULL);
	}
2193

2194 2195
set_output_value:
	if (!gc->set || !gc->direction_output) {
2196 2197 2198
		gpiod_warn(desc,
		       "%s: missing set() or direction_output() operations\n",
		       __func__);
2199 2200 2201
		return -EIO;
	}

2202
	ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2203
	if (!ret)
2204
		set_bit(FLAG_IS_OUT, &desc->flags);
2205
	trace_gpio_value(desc_to_gpio(desc), 0, val);
2206 2207
	trace_gpio_direction(desc_to_gpio(desc), 0, ret);
	return ret;
2208
}
2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222

/**
 * 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)
{
2223
	VALIDATE_DESC(desc);
2224 2225 2226 2227 2228
	return _gpiod_direction_output_raw(desc, value);
}
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);

/**
2229
 * gpiod_direction_output - set the GPIO direction to output
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241
 * @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)
{
2242
	VALIDATE_DESC(desc);
2243 2244
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2245 2246
	else
		value = !!value;
2247 2248
	return _gpiod_direction_output_raw(desc, value);
}
2249
EXPORT_SYMBOL_GPL(gpiod_direction_output);
2250

2251
/**
2252
 * gpiod_set_debounce - sets @debounce time for a @gpio
2253 2254
 * @gpio: the gpio to set debounce time
 * @debounce: debounce time is microseconds
2255 2256 2257
 *
 * returns -ENOTSUPP if the controller does not support setting
 * debounce.
2258
 */
2259
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2260 2261 2262
{
	struct gpio_chip	*chip;

2263 2264
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2265
	if (!chip->set || !chip->set_debounce) {
2266 2267 2268
		gpiod_dbg(desc,
			  "%s: missing set() or set_debounce() operations\n",
			  __func__);
2269
		return -ENOTSUPP;
2270 2271
	}

2272
	return chip->set_debounce(chip, gpio_chip_hwgpio(desc), debounce);
2273
}
2274
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2275

2276 2277 2278 2279 2280 2281 2282
/**
 * 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)
2283
{
2284
	VALIDATE_DESC(desc);
2285
	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2286
}
2287
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310

/* 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.
 */

2311
static int _gpiod_get_raw_value(const struct gpio_desc *desc)
2312 2313
{
	struct gpio_chip	*chip;
2314
	int offset;
2315
	int value;
2316

2317
	chip = desc->gdev->chip;
2318
	offset = gpio_chip_hwgpio(desc);
2319
	value = chip->get ? chip->get(chip, offset) : -EIO;
2320
	value = value < 0 ? value : !!value;
2321
	trace_gpio_value(desc_to_gpio(desc), 1, value);
2322
	return value;
2323
}
2324

2325
/**
2326 2327
 * gpiod_get_raw_value() - return a gpio's raw value
 * @desc: gpio whose value will be returned
2328
 *
2329
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2330
 * its ACTIVE_LOW status, or negative errno on failure.
2331 2332 2333
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2334
 */
2335
int gpiod_get_raw_value(const struct gpio_desc *desc)
2336
{
2337
	VALIDATE_DESC(desc);
2338
	/* Should be using gpio_get_value_cansleep() */
2339
	WARN_ON(desc->gdev->chip->can_sleep);
2340
	return _gpiod_get_raw_value(desc);
2341
}
2342
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2343

2344 2345 2346 2347 2348
/**
 * 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
2349
 * account, or negative errno on failure.
2350 2351 2352 2353 2354
 *
 * 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)
2355
{
2356
	int value;
2357 2358

	VALIDATE_DESC(desc);
2359
	/* Should be using gpio_get_value_cansleep() */
2360
	WARN_ON(desc->gdev->chip->can_sleep);
2361 2362

	value = _gpiod_get_raw_value(desc);
2363 2364 2365
	if (value < 0)
		return value;

2366 2367 2368 2369
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
2370
}
2371
EXPORT_SYMBOL_GPL(gpiod_get_value);
2372

2373 2374
/*
 *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
2375
 * @desc: gpio descriptor whose state need to be set.
2376
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2377
 */
2378
static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
2379 2380
{
	int err = 0;
2381
	struct gpio_chip *chip = desc->gdev->chip;
2382 2383
	int offset = gpio_chip_hwgpio(desc);

2384
	if (value) {
2385
		err = chip->direction_input(chip, offset);
2386
		if (!err)
2387
			clear_bit(FLAG_IS_OUT, &desc->flags);
2388
	} else {
2389
		err = chip->direction_output(chip, offset, 0);
2390
		if (!err)
2391
			set_bit(FLAG_IS_OUT, &desc->flags);
2392
	}
2393
	trace_gpio_direction(desc_to_gpio(desc), value, err);
2394
	if (err < 0)
2395 2396 2397
		gpiod_err(desc,
			  "%s: Error in set_value for open drain err %d\n",
			  __func__, err);
2398 2399
}

2400
/*
2401 2402
 *  _gpio_set_open_source_value() - Set the open source gpio's value.
 * @desc: gpio descriptor whose state need to be set.
2403
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2404
 */
2405
static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
2406 2407
{
	int err = 0;
2408
	struct gpio_chip *chip = desc->gdev->chip;
2409 2410
	int offset = gpio_chip_hwgpio(desc);

2411
	if (value) {
2412
		err = chip->direction_output(chip, offset, 1);
2413
		if (!err)
2414
			set_bit(FLAG_IS_OUT, &desc->flags);
2415
	} else {
2416
		err = chip->direction_input(chip, offset);
2417
		if (!err)
2418
			clear_bit(FLAG_IS_OUT, &desc->flags);
2419
	}
2420
	trace_gpio_direction(desc_to_gpio(desc), !value, err);
2421
	if (err < 0)
2422 2423 2424
		gpiod_err(desc,
			  "%s: Error in set_value for open source err %d\n",
			  __func__, err);
2425 2426
}

2427
static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
2428 2429 2430
{
	struct gpio_chip	*chip;

2431
	chip = desc->gdev->chip;
2432 2433 2434 2435 2436
	trace_gpio_value(desc_to_gpio(desc), 0, value);
	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
		_gpio_set_open_drain_value(desc, value);
	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
		_gpio_set_open_source_value(desc, value);
2437
	else
2438 2439 2440
		chip->set(chip, gpio_chip_hwgpio(desc), value);
}

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
/*
 * 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 {
		int i;
		for (i = 0; i < chip->ngpio; i++) {
			if (mask[BIT_WORD(i)] == 0) {
				/* no more set bits in this mask word;
				 * skip ahead to the next word */
				i = (BIT_WORD(i) + 1) * BITS_PER_LONG - 1;
				continue;
			}
			/* set outputs if the corresponding mask bit is set */
D
Daniel Lockyer 已提交
2465
			if (__test_and_clear_bit(i, mask))
2466 2467 2468 2469 2470
				chip->set(chip, i, test_bit(i, bits));
		}
	}
}

2471 2472 2473 2474
void gpiod_set_array_value_complex(bool raw, bool can_sleep,
				   unsigned int array_size,
				   struct gpio_desc **desc_array,
				   int *value_array)
2475 2476 2477 2478
{
	int i = 0;

	while (i < array_size) {
2479
		struct gpio_chip *chip = desc_array[i]->gdev->chip;
2480 2481 2482 2483
		unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
		unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
		int count = 0;

D
Daniel Lockyer 已提交
2484
		if (!can_sleep)
2485
			WARN_ON(chip->can_sleep);
D
Daniel Lockyer 已提交
2486

2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500
		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
			 */
			if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
D
Daniel Lockyer 已提交
2501
				_gpio_set_open_drain_value(desc, value);
2502 2503 2504 2505
			} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
				_gpio_set_open_source_value(desc, value);
			} else {
				__set_bit(hwgpio, mask);
D
Daniel Lockyer 已提交
2506
				if (value)
2507
					__set_bit(hwgpio, bits);
D
Daniel Lockyer 已提交
2508
				else
2509 2510 2511 2512
					__clear_bit(hwgpio, bits);
				count++;
			}
			i++;
2513 2514
		} while ((i < array_size) &&
			 (desc_array[i]->gdev->chip == chip));
2515
		/* push collected bits to outputs */
D
Daniel Lockyer 已提交
2516
		if (count != 0)
2517 2518 2519 2520
			gpio_chip_set_multiple(chip, mask, bits);
	}
}

2521
/**
2522 2523
 * gpiod_set_raw_value() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
2524 2525
 * @value: value to assign
 *
2526 2527 2528 2529 2530
 * 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.
2531
 */
2532
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2533
{
2534
	VALIDATE_DESC_VOID(desc);
2535
	/* Should be using gpiod_set_value_cansleep() */
2536
	WARN_ON(desc->gdev->chip->can_sleep);
2537
	_gpiod_set_raw_value(desc, value);
2538
}
2539
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2540 2541

/**
2542 2543 2544 2545 2546 2547
 * gpiod_set_value() - 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
2548
 *
2549 2550
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2551
 */
2552
void gpiod_set_value(struct gpio_desc *desc, int value)
2553
{
2554
	VALIDATE_DESC_VOID(desc);
2555
	/* Should be using gpiod_set_value_cansleep() */
2556
	WARN_ON(desc->gdev->chip->can_sleep);
2557 2558 2559
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
	_gpiod_set_raw_value(desc, value);
2560
}
2561
EXPORT_SYMBOL_GPL(gpiod_set_value);
2562

2563
/**
2564
 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
 * @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.
 */
2575
void gpiod_set_raw_array_value(unsigned int array_size,
2576 2577 2578 2579
			 struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return;
2580 2581
	gpiod_set_array_value_complex(true, false, array_size, desc_array,
				      value_array);
2582
}
2583
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
2584 2585

/**
2586
 * gpiod_set_array_value() - assign values to an array of GPIOs
2587 2588 2589 2590 2591 2592 2593 2594 2595 2596
 * @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.
 */
2597 2598
void gpiod_set_array_value(unsigned int array_size,
			   struct gpio_desc **desc_array, int *value_array)
2599 2600 2601
{
	if (!desc_array)
		return;
2602 2603
	gpiod_set_array_value_complex(false, false, array_size, desc_array,
				      value_array);
2604
}
2605
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
2606

2607
/**
2608 2609
 * gpiod_cansleep() - report whether gpio value access may sleep
 * @desc: gpio to check
2610 2611
 *
 */
2612
int gpiod_cansleep(const struct gpio_desc *desc)
2613
{
2614 2615
	VALIDATE_DESC(desc);
	return desc->gdev->chip->can_sleep;
2616
}
2617
EXPORT_SYMBOL_GPL(gpiod_cansleep);
2618

D
David Brownell 已提交
2619
/**
2620 2621
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
D
David Brownell 已提交
2622
 *
2623 2624
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
D
David Brownell 已提交
2625
 */
2626
int gpiod_to_irq(const struct gpio_desc *desc)
D
David Brownell 已提交
2627
{
2628 2629
	struct gpio_chip *chip;
	int offset;
D
David Brownell 已提交
2630

2631 2632 2633 2634 2635
	/*
	 * 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.
	 */
2636
	if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
2637 2638
		return -EINVAL;

2639
	chip = desc->gdev->chip;
2640
	offset = gpio_chip_hwgpio(desc);
2641 2642 2643 2644 2645 2646 2647 2648 2649 2650
	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 已提交
2651
}
2652
EXPORT_SYMBOL_GPL(gpiod_to_irq);
D
David Brownell 已提交
2653

2654
/**
2655
 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
2656 2657
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2658 2659
 *
 * This is used directly by GPIO drivers that want to lock down
2660
 * a certain GPIO line to be used for IRQs.
2661
 */
2662
int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2663
{
2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678
	struct gpio_desc *desc;

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

	/* Flush direction if something changed behind our back */
	if (chip->get_direction) {
		int dir = chip->get_direction(chip, offset);

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

2680
	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2681
		chip_err(chip,
2682 2683 2684 2685 2686
			  "%s: tried to flag a GPIO set as output for IRQ\n",
			  __func__);
		return -EIO;
	}

2687
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2688
	return 0;
2689
}
2690
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
2691

2692
/**
2693
 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
2694 2695
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2696 2697 2698
 *
 * This is used directly by GPIO drivers that want to indicate
 * that a certain GPIO is no longer used exclusively for IRQ.
2699
 */
2700
void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2701
{
2702
	if (offset >= chip->ngpio)
2703
		return;
2704

2705
	clear_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
2706
}
2707
EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
2708

2709 2710 2711 2712 2713 2714 2715 2716 2717
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);

2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735
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);

2736 2737 2738 2739 2740
/**
 * 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
2741
 * its ACTIVE_LOW status, or negative errno on failure.
2742 2743
 *
 * This function is to be called from contexts that can sleep.
2744
 */
2745
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2746 2747
{
	might_sleep_if(extra_checks);
2748
	VALIDATE_DESC(desc);
2749
	return _gpiod_get_raw_value(desc);
2750
}
2751
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2752

2753 2754 2755 2756 2757
/**
 * 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
2758
 * account, or negative errno on failure.
2759 2760 2761 2762
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2763
{
2764
	int value;
2765 2766

	might_sleep_if(extra_checks);
2767
	VALIDATE_DESC(desc);
2768
	value = _gpiod_get_raw_value(desc);
2769 2770 2771
	if (value < 0)
		return value;

2772 2773 2774
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

2775
	return value;
2776
}
2777
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2778

2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789
/**
 * 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)
2790
{
2791
	might_sleep_if(extra_checks);
2792
	VALIDATE_DESC_VOID(desc);
2793
	_gpiod_set_raw_value(desc, value);
2794
}
2795
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2796

2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807
/**
 * 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)
2808 2809
{
	might_sleep_if(extra_checks);
2810
	VALIDATE_DESC_VOID(desc);
2811 2812 2813
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
	_gpiod_set_raw_value(desc, value);
2814
}
2815
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2816

2817
/**
2818
 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
2819 2820 2821 2822 2823 2824 2825 2826 2827
 * @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.
 */
2828 2829 2830
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
					struct gpio_desc **desc_array,
					int *value_array)
2831 2832 2833 2834
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
2835 2836
	gpiod_set_array_value_complex(true, true, array_size, desc_array,
				      value_array);
2837
}
2838
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
2839 2840

/**
2841
 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
2842 2843 2844 2845 2846 2847 2848 2849 2850
 * @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.
 */
2851 2852 2853
void gpiod_set_array_value_cansleep(unsigned int array_size,
				    struct gpio_desc **desc_array,
				    int *value_array)
2854 2855 2856 2857
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
2858 2859
	gpiod_set_array_value_complex(false, true, array_size, desc_array,
				      value_array);
2860
}
2861
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
2862

2863
/**
2864 2865
 * gpiod_add_lookup_table() - register GPIO device consumers
 * @table: table of consumers to register
2866
 */
2867
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2868 2869 2870
{
	mutex_lock(&gpio_lookup_lock);

2871
	list_add_tail(&table->list, &gpio_lookup_list);
2872 2873 2874 2875

	mutex_unlock(&gpio_lookup_lock);
}

2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888
/**
 * 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);
}

2889
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2890 2891
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
2892
	struct gpiod_lookup_table *table;
2893 2894 2895

	mutex_lock(&gpio_lookup_lock);

2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913
	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;
2914

2915 2916 2917 2918
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
2919

2920 2921 2922 2923
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
				    unsigned int idx,
				    enum gpio_lookup_flags *flags)
{
2924
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
2925 2926
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
2927

2928 2929 2930
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
2931

2932 2933
	for (p = &table->table[0]; p->chip_label; p++) {
		struct gpio_chip *chip;
2934

2935
		/* idx must always match exactly */
2936 2937 2938
		if (p->idx != idx)
			continue;

2939 2940 2941
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
2942

2943
		chip = find_chip_by_name(p->chip_label);
2944

2945
		if (!chip) {
2946 2947 2948
			dev_err(dev, "cannot find GPIO chip %s\n",
				p->chip_label);
			return ERR_PTR(-ENODEV);
2949
		}
2950

2951
		if (chip->ngpio <= p->chip_hwnum) {
2952 2953 2954 2955
			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);
2956 2957
		}

2958
		desc = gpiochip_get_desc(chip, p->chip_hwnum);
2959
		*flags = p->flags;
2960

2961
		return desc;
2962 2963 2964 2965 2966
	}

	return desc;
}

2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030
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);
		if (ret >= 0)
			break;
	}
	return ret;
}

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);

3031
/**
3032
 * gpiod_get - obtain a GPIO for a given GPIO function
3033
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3034
 * @con_id:	function within the GPIO consumer
3035
 * @flags:	optional GPIO initialization flags
3036 3037
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
3038
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3039
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3040
 */
3041
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3042
					 enum gpiod_flags flags)
3043
{
3044
	return gpiod_get_index(dev, con_id, 0, flags);
3045
}
3046
EXPORT_SYMBOL_GPL(gpiod_get);
3047

3048 3049 3050 3051
/**
 * 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
3052
 * @flags: optional GPIO initialization flags
3053 3054 3055 3056 3057
 *
 * 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.
 */
3058
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3059 3060
						  const char *con_id,
						  enum gpiod_flags flags)
3061
{
3062
	return gpiod_get_index_optional(dev, con_id, 0, flags);
3063
}
3064
EXPORT_SYMBOL_GPL(gpiod_get_optional);
3065

B
Benoit Parrot 已提交
3066 3067 3068 3069 3070

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
3071 3072
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
B
Benoit Parrot 已提交
3073 3074 3075 3076 3077 3078 3079
 * @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.
 */
static int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
3080
		unsigned long lflags, enum gpiod_flags dflags)
B
Benoit Parrot 已提交
3081 3082 3083
{
	int status;

3084 3085 3086 3087 3088 3089 3090
	if (lflags & GPIO_ACTIVE_LOW)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
	if (lflags & GPIO_OPEN_DRAIN)
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
	if (lflags & GPIO_OPEN_SOURCE)
		set_bit(FLAG_OPEN_SOURCE, &desc->flags);

B
Benoit Parrot 已提交
3091 3092 3093 3094 3095 3096 3097 3098 3099
	/* 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,
3100
				!!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
B
Benoit Parrot 已提交
3101 3102 3103 3104 3105 3106
	else
		status = gpiod_direction_input(desc);

	return status;
}

3107 3108
/**
 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
3109
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3110 3111
 * @con_id:	function within the GPIO consumer
 * @idx:	index of the GPIO to obtain in the consumer
3112
 * @flags:	optional GPIO initialization flags
3113 3114 3115 3116
 *
 * This variant of gpiod_get() allows to access GPIOs other than the first
 * defined one for functions that define several GPIOs.
 *
3117 3118
 * 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
3119
 * occurred while trying to acquire the GPIO.
3120
 */
3121
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
3122
					       const char *con_id,
3123 3124
					       unsigned int idx,
					       enum gpiod_flags flags)
3125
{
3126
	struct gpio_desc *desc = NULL;
3127
	int status;
3128
	enum gpio_lookup_flags lookupflags = 0;
3129 3130 3131

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

3132 3133 3134 3135 3136 3137 3138
	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");
3139
			desc = acpi_find_gpio(dev, con_id, idx, flags, &lookupflags);
3140
		}
3141 3142 3143 3144 3145 3146
	}

	/*
	 * 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.
	 */
3147
	if (!desc || desc == ERR_PTR(-ENOENT)) {
3148
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3149
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
3150 3151 3152
	}

	if (IS_ERR(desc)) {
3153
		dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
3154 3155 3156 3157 3158 3159 3160
		return desc;
	}

	status = gpiod_request(desc, con_id);
	if (status < 0)
		return ERR_PTR(status);

3161
	status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
3162 3163 3164 3165 3166 3167
	if (status < 0) {
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
		gpiod_put(desc);
		return ERR_PTR(status);
	}

3168 3169
	return desc;
}
3170
EXPORT_SYMBOL_GPL(gpiod_get_index);
3171

3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
/**
 * 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
 *
 * This function can be used for drivers that get their configuration
 * from firmware.
 *
 * Function properly finds the corresponding GPIO using whatever is the
 * underlying firmware interface and then makes sure that the GPIO
 * descriptor is requested before it is returned to the caller.
 *
 * In case of error an ERR_PTR() is returned.
 */
struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
					 const char *propname)
{
	struct gpio_desc *desc = ERR_PTR(-ENODEV);
	bool active_low = false;
3191
	bool single_ended = false;
3192 3193 3194 3195 3196 3197 3198 3199
	int ret;

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

	if (is_of_node(fwnode)) {
		enum of_gpio_flags flags;

3200
		desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname, 0,
3201
						&flags);
3202
		if (!IS_ERR(desc)) {
3203
			active_low = flags & OF_GPIO_ACTIVE_LOW;
3204 3205
			single_ended = flags & OF_GPIO_SINGLE_ENDED;
		}
3206 3207 3208
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

3209
		desc = acpi_node_get_gpiod(fwnode, propname, 0, &info);
3210
		if (!IS_ERR(desc))
3211
			active_low = info.polarity == GPIO_ACTIVE_LOW;
3212 3213 3214 3215 3216
	}

	if (IS_ERR(desc))
		return desc;

3217 3218 3219 3220
	ret = gpiod_request(desc, NULL);
	if (ret)
		return ERR_PTR(ret);

3221 3222 3223
	if (active_low)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);

3224 3225 3226 3227 3228 3229 3230
	if (single_ended) {
		if (active_low)
			set_bit(FLAG_OPEN_DRAIN, &desc->flags);
		else
			set_bit(FLAG_OPEN_SOURCE, &desc->flags);
	}

3231 3232 3233 3234
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

3235 3236 3237 3238 3239 3240
/**
 * 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
3241
 * @flags: optional GPIO initialization flags
3242 3243 3244 3245 3246
 *
 * 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.
 */
3247
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3248
							const char *con_id,
3249 3250
							unsigned int index,
							enum gpiod_flags flags)
3251 3252 3253
{
	struct gpio_desc *desc;

3254
	desc = gpiod_get_index(dev, con_id, index, flags);
3255 3256 3257 3258 3259 3260 3261
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
3262
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3263

B
Benoit Parrot 已提交
3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284
/**
 * 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)) {
3285 3286 3287 3288
		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 已提交
3289 3290
	}

3291
	status = gpiod_configure_flags(desc, name, lflags, dflags);
B
Benoit Parrot 已提交
3292
	if (status < 0) {
3293 3294
		pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
B
Benoit Parrot 已提交
3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321
		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++) {
3322 3323
		if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
B
Benoit Parrot 已提交
3324 3325 3326
	}
}

3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392
/**
 * 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);

3393 3394 3395 3396 3397 3398 3399 3400 3401
/**
 * 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);
3402
}
3403
EXPORT_SYMBOL_GPL(gpiod_put);
3404

3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419
/**
 * 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);

3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434
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);
3435 3436 3437
	} else {
		gpiolib_initialized = true;
		gpiochip_setup_devs();
3438 3439 3440 3441 3442
	}
	return ret;
}
core_initcall(gpiolib_dev_init);

3443 3444
#ifdef CONFIG_DEBUG_FS

3445
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
3446 3447
{
	unsigned		i;
3448 3449 3450
	struct gpio_chip	*chip = gdev->chip;
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
3451
	int			is_out;
3452
	int			is_irq;
3453

3454
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
3455 3456 3457 3458 3459
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
3460
			continue;
3461
		}
3462

3463
		gpiod_get_direction(gdesc);
3464
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
3465
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
3466 3467
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
3468 3469 3470
			is_out ? "out" : "in ",
			chip->get
				? (chip->get(chip, i) ? "hi" : "lo")
3471 3472
				: "?  ",
			is_irq ? "IRQ" : "   ");
3473 3474 3475 3476
		seq_printf(s, "\n");
	}
}

3477
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
3478
{
3479
	unsigned long flags;
3480
	struct gpio_device *gdev = NULL;
3481
	loff_t index = *pos;
3482

3483
	s->private = "";
3484

3485
	spin_lock_irqsave(&gpio_lock, flags);
3486
	list_for_each_entry(gdev, &gpio_devices, list)
3487 3488
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
3489
			return gdev;
3490
		}
3491
	spin_unlock_irqrestore(&gpio_lock, flags);
3492

3493
	return NULL;
3494 3495 3496 3497
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
3498
	unsigned long flags;
3499
	struct gpio_device *gdev = v;
3500 3501
	void *ret = NULL;

3502
	spin_lock_irqsave(&gpio_lock, flags);
3503
	if (list_is_last(&gdev->list, &gpio_devices))
3504 3505
		ret = NULL;
	else
3506
		ret = list_entry(gdev->list.next, struct gpio_device, list);
3507
	spin_unlock_irqrestore(&gpio_lock, flags);
3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520

	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)
{
3521 3522 3523 3524 3525 3526 3527 3528 3529
	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;
	}
3530

3531 3532
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
3533
		   gdev->base, gdev->base + gdev->ngpio - 1);
3534 3535 3536 3537 3538
	parent = chip->parent;
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
3539 3540 3541 3542 3543 3544 3545 3546 3547
	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
3548
		gpiolib_dbg_show(s, gdev);
3549

3550 3551 3552
	return 0;
}

3553 3554 3555 3556 3557 3558 3559
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

3560 3561
static int gpiolib_open(struct inode *inode, struct file *file)
{
3562
	return seq_open(file, &gpiolib_seq_ops);
3563 3564
}

3565
static const struct file_operations gpiolib_operations = {
3566
	.owner		= THIS_MODULE,
3567 3568 3569
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
3570
	.release	= seq_release,
3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582
};

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 */