gpiolib.c 95.4 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 2153
	struct gpio_chip *gc = desc->gdev->chip;
	int ret;
2154

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

2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
	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 */
		if (value)
			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 */
		if (!value)
			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);
	}
2192

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

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

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

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

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

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

2269
	return chip->set_debounce(chip, gpio_chip_hwgpio(desc), debounce);
2270
}
2271
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2272

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

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

2308
static int _gpiod_get_raw_value(const struct gpio_desc *desc)
2309 2310
{
	struct gpio_chip	*chip;
2311
	int offset;
2312
	int value;
2313

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

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

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

	VALIDATE_DESC(desc);
2356
	/* Should be using gpio_get_value_cansleep() */
2357
	WARN_ON(desc->gdev->chip->can_sleep);
2358 2359

	value = _gpiod_get_raw_value(desc);
2360 2361 2362
	if (value < 0)
		return value;

2363 2364 2365 2366
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
2367
}
2368
EXPORT_SYMBOL_GPL(gpiod_get_value);
2369

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

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

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

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

2424
static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
2425 2426 2427
{
	struct gpio_chip	*chip;

2428
	chip = desc->gdev->chip;
2429 2430 2431 2432 2433
	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);
2434
	else
2435 2436 2437
		chip->set(chip, gpio_chip_hwgpio(desc), value);
}

2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461
/*
 * 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 已提交
2462
			if (__test_and_clear_bit(i, mask))
2463 2464 2465 2466 2467
				chip->set(chip, i, test_bit(i, bits));
		}
	}
}

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

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

D
Daniel Lockyer 已提交
2481
		if (!can_sleep)
2482
			WARN_ON(chip->can_sleep);
D
Daniel Lockyer 已提交
2483

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

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

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

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

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

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

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

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

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

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

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

2684
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2685
	return 0;
2686
}
2687
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
2688

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

2702
	clear_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
2703
}
2704
EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
2705

2706 2707 2708 2709 2710 2711 2712 2713 2714
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);

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

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

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

	might_sleep_if(extra_checks);
2764
	VALIDATE_DESC(desc);
2765
	value = _gpiod_get_raw_value(desc);
2766 2767 2768
	if (value < 0)
		return value;

2769 2770 2771
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

2772
	return value;
2773
}
2774
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2775

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

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

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

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

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

2868
	list_add_tail(&table->list, &gpio_lookup_list);
2869 2870 2871 2872

	mutex_unlock(&gpio_lookup_lock);
}

2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885
/**
 * 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);
}

2886 2887
static struct gpio_desc *acpi_find_gpio(struct device *dev,
					const char *con_id,
2888
					unsigned int idx,
2889 2890
					enum gpiod_flags flags,
					enum gpio_lookup_flags *lookupflags)
2891
{
2892
	struct acpi_device *adev = ACPI_COMPANION(dev);
2893 2894
	struct acpi_gpio_info info;
	struct gpio_desc *desc;
2895 2896
	char propname[32];
	int i;
2897

2898
	/* Try first from _DSD */
2899
	for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
2900 2901
		if (con_id && strcmp(con_id, "gpios")) {
			snprintf(propname, sizeof(propname), "%s-%s",
2902
				 con_id, gpio_suffixes[i]);
2903 2904
		} else {
			snprintf(propname, sizeof(propname), "%s",
2905
				 gpio_suffixes[i]);
2906 2907 2908 2909 2910 2911 2912 2913 2914
		}

		desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
		if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
			break;
	}

	/* Then from plain _CRS GPIOs */
	if (IS_ERR(desc)) {
2915 2916 2917
		if (!acpi_can_fallback_to_crs(adev, con_id))
			return ERR_PTR(-ENOENT);

2918 2919 2920
		desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
		if (IS_ERR(desc))
			return desc;
2921 2922 2923 2924 2925 2926

		if ((flags == GPIOD_OUT_LOW || flags == GPIOD_OUT_HIGH) &&
		    info.gpioint) {
			dev_dbg(dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");
			return ERR_PTR(-ENOENT);
		}
2927
	}
2928

2929
	if (info.polarity == GPIO_ACTIVE_LOW)
2930
		*lookupflags |= GPIO_ACTIVE_LOW;
2931 2932

	return desc;
2933 2934
}

2935
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2936 2937
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
2938
	struct gpiod_lookup_table *table;
2939 2940 2941

	mutex_lock(&gpio_lookup_lock);

2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959
	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;
2960

2961 2962 2963 2964
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
2965

2966 2967 2968 2969
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
				    unsigned int idx,
				    enum gpio_lookup_flags *flags)
{
2970
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
2971 2972
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
2973

2974 2975 2976
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
2977

2978 2979
	for (p = &table->table[0]; p->chip_label; p++) {
		struct gpio_chip *chip;
2980

2981
		/* idx must always match exactly */
2982 2983 2984
		if (p->idx != idx)
			continue;

2985 2986 2987
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
2988

2989
		chip = find_chip_by_name(p->chip_label);
2990

2991
		if (!chip) {
2992 2993 2994
			dev_err(dev, "cannot find GPIO chip %s\n",
				p->chip_label);
			return ERR_PTR(-ENODEV);
2995
		}
2996

2997
		if (chip->ngpio <= p->chip_hwnum) {
2998 2999 3000 3001
			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);
3002 3003
		}

3004
		desc = gpiochip_get_desc(chip, p->chip_hwnum);
3005
		*flags = p->flags;
3006

3007
		return desc;
3008 3009 3010 3011 3012
	}

	return desc;
}

3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076
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);

3077
/**
3078
 * gpiod_get - obtain a GPIO for a given GPIO function
3079
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3080
 * @con_id:	function within the GPIO consumer
3081
 * @flags:	optional GPIO initialization flags
3082 3083
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
3084
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3085
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3086
 */
3087
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3088
					 enum gpiod_flags flags)
3089
{
3090
	return gpiod_get_index(dev, con_id, 0, flags);
3091
}
3092
EXPORT_SYMBOL_GPL(gpiod_get);
3093

3094 3095 3096 3097
/**
 * 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
3098
 * @flags: optional GPIO initialization flags
3099 3100 3101 3102 3103
 *
 * 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.
 */
3104
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3105 3106
						  const char *con_id,
						  enum gpiod_flags flags)
3107
{
3108
	return gpiod_get_index_optional(dev, con_id, 0, flags);
3109
}
3110
EXPORT_SYMBOL_GPL(gpiod_get_optional);
3111

B
Benoit Parrot 已提交
3112 3113 3114 3115 3116

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
3117 3118
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
B
Benoit Parrot 已提交
3119 3120 3121 3122 3123 3124 3125
 * @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,
3126
		unsigned long lflags, enum gpiod_flags dflags)
B
Benoit Parrot 已提交
3127 3128 3129
{
	int status;

3130 3131 3132 3133 3134 3135 3136
	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 已提交
3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152
	/* 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,
					      dflags & GPIOD_FLAGS_BIT_DIR_VAL);
	else
		status = gpiod_direction_input(desc);

	return status;
}

3153 3154
/**
 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
3155
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3156 3157
 * @con_id:	function within the GPIO consumer
 * @idx:	index of the GPIO to obtain in the consumer
3158
 * @flags:	optional GPIO initialization flags
3159 3160 3161 3162
 *
 * This variant of gpiod_get() allows to access GPIOs other than the first
 * defined one for functions that define several GPIOs.
 *
3163 3164
 * 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
3165
 * occurred while trying to acquire the GPIO.
3166
 */
3167
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
3168
					       const char *con_id,
3169 3170
					       unsigned int idx,
					       enum gpiod_flags flags)
3171
{
3172
	struct gpio_desc *desc = NULL;
3173
	int status;
3174
	enum gpio_lookup_flags lookupflags = 0;
3175 3176 3177

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

3178 3179 3180 3181 3182 3183 3184
	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");
3185
			desc = acpi_find_gpio(dev, con_id, idx, flags, &lookupflags);
3186
		}
3187 3188 3189 3190 3191 3192
	}

	/*
	 * 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.
	 */
3193
	if (!desc || desc == ERR_PTR(-ENOENT)) {
3194
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3195
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
3196 3197 3198
	}

	if (IS_ERR(desc)) {
3199
		dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
3200 3201 3202 3203 3204 3205 3206
		return desc;
	}

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

3207
	status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
3208 3209 3210 3211 3212 3213
	if (status < 0) {
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
		gpiod_put(desc);
		return ERR_PTR(status);
	}

3214 3215
	return desc;
}
3216
EXPORT_SYMBOL_GPL(gpiod_get_index);
3217

3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236
/**
 * 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;
3237
	bool single_ended = false;
3238 3239 3240 3241 3242 3243 3244 3245
	int ret;

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

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

3246
		desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname, 0,
3247
						&flags);
3248
		if (!IS_ERR(desc)) {
3249
			active_low = flags & OF_GPIO_ACTIVE_LOW;
3250 3251
			single_ended = flags & OF_GPIO_SINGLE_ENDED;
		}
3252 3253 3254
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

3255
		desc = acpi_node_get_gpiod(fwnode, propname, 0, &info);
3256
		if (!IS_ERR(desc))
3257
			active_low = info.polarity == GPIO_ACTIVE_LOW;
3258 3259 3260 3261 3262
	}

	if (IS_ERR(desc))
		return desc;

3263 3264 3265 3266
	ret = gpiod_request(desc, NULL);
	if (ret)
		return ERR_PTR(ret);

3267 3268 3269
	if (active_low)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);

3270 3271 3272 3273 3274 3275 3276
	if (single_ended) {
		if (active_low)
			set_bit(FLAG_OPEN_DRAIN, &desc->flags);
		else
			set_bit(FLAG_OPEN_SOURCE, &desc->flags);
	}

3277 3278 3279 3280
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

3281 3282 3283 3284 3285 3286
/**
 * 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
3287
 * @flags: optional GPIO initialization flags
3288 3289 3290 3291 3292
 *
 * 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.
 */
3293
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3294
							const char *con_id,
3295 3296
							unsigned int index,
							enum gpiod_flags flags)
3297 3298 3299
{
	struct gpio_desc *desc;

3300
	desc = gpiod_get_index(dev, con_id, index, flags);
3301 3302 3303 3304 3305 3306 3307
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
3308
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3309

B
Benoit Parrot 已提交
3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330
/**
 * 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)) {
3331 3332 3333 3334
		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 已提交
3335 3336
	}

3337
	status = gpiod_configure_flags(desc, name, lflags, dflags);
B
Benoit Parrot 已提交
3338
	if (status < 0) {
3339 3340
		pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
B
Benoit Parrot 已提交
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
		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++) {
3368 3369
		if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
B
Benoit Parrot 已提交
3370 3371 3372
	}
}

3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438
/**
 * 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);

3439 3440 3441 3442 3443 3444 3445 3446 3447
/**
 * 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);
3448
}
3449
EXPORT_SYMBOL_GPL(gpiod_put);
3450

3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465
/**
 * 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);

3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480
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);
3481 3482 3483
	} else {
		gpiolib_initialized = true;
		gpiochip_setup_devs();
3484 3485 3486 3487 3488
	}
	return ret;
}
core_initcall(gpiolib_dev_init);

3489 3490
#ifdef CONFIG_DEBUG_FS

3491
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
3492 3493
{
	unsigned		i;
3494 3495 3496
	struct gpio_chip	*chip = gdev->chip;
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
3497
	int			is_out;
3498
	int			is_irq;
3499

3500
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
3501 3502 3503 3504 3505
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
3506
			continue;
3507
		}
3508

3509
		gpiod_get_direction(gdesc);
3510
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
3511
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
3512 3513
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
3514 3515 3516
			is_out ? "out" : "in ",
			chip->get
				? (chip->get(chip, i) ? "hi" : "lo")
3517 3518
				: "?  ",
			is_irq ? "IRQ" : "   ");
3519 3520 3521 3522
		seq_printf(s, "\n");
	}
}

3523
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
3524
{
3525
	unsigned long flags;
3526
	struct gpio_device *gdev = NULL;
3527
	loff_t index = *pos;
3528

3529
	s->private = "";
3530

3531
	spin_lock_irqsave(&gpio_lock, flags);
3532
	list_for_each_entry(gdev, &gpio_devices, list)
3533 3534
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
3535
			return gdev;
3536
		}
3537
	spin_unlock_irqrestore(&gpio_lock, flags);
3538

3539
	return NULL;
3540 3541 3542 3543
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
3544
	unsigned long flags;
3545
	struct gpio_device *gdev = v;
3546 3547
	void *ret = NULL;

3548
	spin_lock_irqsave(&gpio_lock, flags);
3549
	if (list_is_last(&gdev->list, &gpio_devices))
3550 3551
		ret = NULL;
	else
3552
		ret = list_entry(gdev->list.next, struct gpio_device, list);
3553
	spin_unlock_irqrestore(&gpio_lock, flags);
3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566

	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)
{
3567 3568 3569 3570 3571 3572 3573 3574 3575
	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;
	}
3576

3577 3578
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
3579
		   gdev->base, gdev->base + gdev->ngpio - 1);
3580 3581 3582 3583 3584
	parent = chip->parent;
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
3585 3586 3587 3588 3589 3590 3591 3592 3593
	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
3594
		gpiolib_dbg_show(s, gdev);
3595

3596 3597 3598
	return 0;
}

3599 3600 3601 3602 3603 3604 3605
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

3606 3607
static int gpiolib_open(struct inode *inode, struct file *file)
{
3608
	return seq_open(file, &gpiolib_seq_ops);
3609 3610
}

3611
static const struct file_operations gpiolib_operations = {
3612
	.owner		= THIS_MODULE,
3613 3614 3615
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
3616
	.release	= seq_release,
3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628
};

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