gpiolib.c 94.8 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
#include <linux/idr.h>
20 21 22
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
23
#include <linux/compat.h>
24
#include <linux/anon_inodes.h>
25 26 27
#include <linux/kfifo.h>
#include <linux/poll.h>
#include <linux/timekeeping.h>
28
#include <uapi/linux/gpio.h>
29

30 31
#include "gpiolib.h"

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

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


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

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

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

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

static void gpiochip_free_hogs(struct gpio_chip *chip);
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);

76
static bool gpiolib_initialized;
77

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

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

	spin_lock_irqsave(&gpio_lock, flags);

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

	spin_unlock_irqrestore(&gpio_lock, flags);

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

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

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

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

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

/**
 * 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
 */
129
int desc_to_gpio(const struct gpio_desc *desc)
130
{
131
	return desc->gdev->base + (desc - &desc->gdev->descs[0]);
132
}
133
EXPORT_SYMBOL_GPL(desc_to_gpio);
134 135


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

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

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

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

172 173 174 175 176 177 178 179
/**
 * 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.
 */
180
int gpiod_get_direction(struct gpio_desc *desc)
181 182
{
	struct gpio_chip	*chip;
183
	unsigned		offset;
184 185
	int			status = -EINVAL;

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

	if (!chip->get_direction)
		return status;

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

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

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

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

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

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

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

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

	spin_lock_irqsave(&gpio_lock, flags);

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

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

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

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

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

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

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

	return 0;
}

317 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
/*
 * 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);
	}
477 478
	/* Let i point at the last handle */
	i--;
479 480 481 482 483 484 485 486 487 488 489 490
	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;
491 492 493 494
	if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
		ret = -EFAULT;
		goto out_free_descs;
	}
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510

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

511 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
/*
 * 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
};

658
static irqreturn_t lineevent_irq_thread(int irq, void *p)
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
{
	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;
681 682
	} else {
		return IRQ_NONE;
683 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
	}

	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;
789 790 791 792
	if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
		ret = -EFAULT;
		goto out_free_irq;
	}
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807

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

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

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

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

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

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

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

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

899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
/**
 * 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,
942 943 944
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
945 946
};

947 948 949 950
static void gpiodevice_release(struct device *dev)
{
	struct gpio_device *gdev = dev_get_drvdata(dev);

951
	cdev_del(&gdev->chrdev);
952 953
	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 1010
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;
	get_device(&gdev->dev);
	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);
	}
}

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

1039 1040 1041 1042
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
1043
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1044
	if (!gdev)
1045
		return -ENOMEM;
1046
	gdev->dev.bus = &gpio_bus_type;
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
	gdev->chip = chip;
	chip->gpiodev = gdev;
	if (chip->parent) {
		gdev->dev.parent = chip->parent;
		gdev->dev.of_node = chip->parent->of_node;
	} else {
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
		if (chip->of_node)
			gdev->dev.of_node = chip->of_node;
#endif
	}
	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 = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

1176
	acpi_gpiochip_add(chip);
1177

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

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

1216 1217 1218 1219 1220 1221 1222 1223 1224
/**
 * 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);

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

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

1254
	spin_lock_irqsave(&gpio_lock, flags);
1255
	for (i = 0; i < gdev->ngpio; i++) {
1256
		desc = &gdev->descs[i];
J
Johan Hovold 已提交
1257 1258
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
1259 1260
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
1261

J
Johan Hovold 已提交
1262
	if (requested)
1263
		dev_crit(&gdev->dev,
1264
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
J
Johan Hovold 已提交
1265

1266 1267 1268 1269 1270 1271 1272
	/*
	 * 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.
	 */
	put_device(&gdev->dev);
1273 1274 1275
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

1276 1277 1278 1279 1280 1281 1282 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
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);

1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
/**
 * 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.
 */
1361
struct gpio_chip *gpiochip_find(void *data,
1362
				int (*match)(struct gpio_chip *chip,
1363
					     void *data))
1364
{
1365
	struct gpio_device *gdev;
1366
	struct gpio_chip *chip;
1367 1368 1369
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
1370 1371
	list_for_each_entry(gdev, &gpio_devices, list)
		if (match(gdev->chip, data))
1372
			break;
1373 1374

	/* No match? */
1375
	if (&gdev->list == &gpio_devices)
1376
		chip = NULL;
1377 1378 1379
	else
		chip = gdev->chip;

1380 1381 1382 1383
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
J
Jean Delvare 已提交
1384
EXPORT_SYMBOL_GPL(gpiochip_find);
1385

1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
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);
}

1398 1399 1400 1401 1402 1403 1404
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

/**
1405 1406 1407
 * 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
1408 1409 1410
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1411 1412
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
1413 1414 1415 1416 1417 1418
 */
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
				  struct irq_chip *irqchip,
				  int parent_irq,
				  irq_flow_handler_t parent_handler)
{
1419 1420 1421 1422 1423
	unsigned int offset;

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

1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
	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.
		 */
1438 1439
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
1440 1441

		gpiochip->irq_parent = parent_irq;
1442
	}
1443 1444 1445 1446 1447

	/* Set the parent IRQ for all affected IRQs */
	for (offset = 0; offset < gpiochip->ngpio; offset++)
		irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
			       parent_irq);
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
}
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);
1467 1468 1469 1470 1471
	/*
	 * 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);
1472
	irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
1473
	/* Chips that can sleep need nested thread handlers */
1474
	if (chip->can_sleep && !chip->irq_not_threaded)
1475
		irq_set_nested_thread(irq, 1);
1476
	irq_set_noprobe(irq);
R
Rob Herring 已提交
1477

1478 1479 1480 1481 1482 1483
	/*
	 * 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);
1484 1485 1486 1487

	return 0;
}

L
Linus Walleij 已提交
1488 1489
static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
{
1490 1491 1492 1493
	struct gpio_chip *chip = d->host_data;

	if (chip->can_sleep)
		irq_set_nested_thread(irq, 0);
L
Linus Walleij 已提交
1494 1495 1496 1497
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}

1498 1499
static const struct irq_domain_ops gpiochip_domain_ops = {
	.map	= gpiochip_irq_map,
L
Linus Walleij 已提交
1500
	.unmap	= gpiochip_irq_unmap,
1501 1502 1503 1504 1505 1506 1507 1508
	/* 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);

1509
	if (!try_module_get(chip->gpiodev->owner))
1510 1511
		return -ENODEV;

1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
	/*
	 * If it is possible to switch this GPIO to an input
	 * this is a good time to do it.
	 */
	if (chip->direction_input) {
		struct gpio_desc *desc;
		int ret;

		desc = gpiochip_get_desc(chip, d->hwirq);
		if (IS_ERR(desc))
			return PTR_ERR(desc);

	        ret = chip->direction_input(chip, d->hwirq);
		if (ret)
			return ret;

		clear_bit(FLAG_IS_OUT, &desc->flags);
	}

1531
	if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1532 1533 1534
		chip_err(chip,
			"unable to lock HW IRQ %lu for IRQ\n",
			d->hwirq);
1535
		module_put(chip->gpiodev->owner);
1536 1537 1538 1539 1540 1541 1542 1543 1544
		return -EINVAL;
	}
	return 0;
}

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

1545
	gpiochip_unlock_as_irq(chip, d->hwirq);
1546
	module_put(chip->gpiodev->owner);
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
}

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 已提交
1562 1563
	unsigned int offset;

1564 1565
	acpi_gpiochip_free_interrupts(gpiochip);

1566 1567 1568 1569 1570
	if (gpiochip->irq_parent) {
		irq_set_chained_handler(gpiochip->irq_parent, NULL);
		irq_set_handler_data(gpiochip->irq_parent, NULL);
	}

L
Linus Walleij 已提交
1571 1572 1573
	/* Remove all IRQ mappings and delete the domain */
	if (gpiochip->irqdomain) {
		for (offset = 0; offset < gpiochip->ngpio; offset++)
1574 1575
			irq_dispose_mapping(
				irq_find_mapping(gpiochip->irqdomain, offset));
1576
		irq_domain_remove(gpiochip->irqdomain);
L
Linus Walleij 已提交
1577
	}
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592

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

/**
 * 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)
1593 1594
 * @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.
1595
 * @lock_key: lockdep class
1596 1597 1598 1599 1600
 *
 * 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 已提交
1601
 * need to use gpiochip_get_data() to get their local state containers back
1602 1603 1604 1605 1606
 * 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 已提交
1607 1608
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1609 1610
 * need to be open coded.
 */
1611 1612 1613 1614 1615 1616
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)
1617 1618 1619
{
	struct device_node *of_node;
	unsigned int offset;
L
Linus Walleij 已提交
1620
	unsigned irq_base = 0;
1621 1622 1623 1624

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

1625
	if (!gpiochip->parent) {
1626 1627 1628
		pr_err("missing gpiochip .dev parent pointer\n");
		return -EINVAL;
	}
1629
	of_node = gpiochip->parent->of_node;
1630 1631
#ifdef CONFIG_OF_GPIO
	/*
1632
	 * If the gpiochip has an assigned OF node this takes precedence
1633 1634
	 * FIXME: get rid of this and use gpiochip->parent->of_node
	 * everywhere
1635 1636 1637 1638 1639 1640 1641 1642
	 */
	if (gpiochip->of_node)
		of_node = gpiochip->of_node;
#endif
	gpiochip->irqchip = irqchip;
	gpiochip->irq_handler = handler;
	gpiochip->irq_default_type = type;
	gpiochip->to_irq = gpiochip_to_irq;
1643
	gpiochip->lock_key = lock_key;
1644 1645 1646 1647 1648 1649 1650
	gpiochip->irqdomain = irq_domain_add_simple(of_node,
					gpiochip->ngpio, first_irq,
					&gpiochip_domain_ops, gpiochip);
	if (!gpiochip->irqdomain) {
		gpiochip->irqchip = NULL;
		return -EINVAL;
	}
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660

	/*
	 * 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;
	}
1661 1662 1663 1664 1665 1666

	/*
	 * 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 已提交
1667 1668 1669 1670 1671 1672 1673 1674 1675
	for (offset = 0; offset < gpiochip->ngpio; offset++) {
		irq_base = irq_create_mapping(gpiochip->irqdomain, offset);
		if (offset == 0)
			/*
			 * Store the base into the gpiochip to be used when
			 * unmapping the irqs.
			 */
			gpiochip->irq_base = irq_base;
	}
1676

1677 1678
	acpi_gpiochip_request_interrupts(gpiochip);

1679 1680
	return 0;
}
1681
EXPORT_SYMBOL_GPL(_gpiochip_irqchip_add);
1682 1683 1684 1685 1686 1687 1688

#else /* CONFIG_GPIOLIB_IRQCHIP */

static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}

#endif /* CONFIG_GPIOLIB_IRQCHIP */

1689 1690 1691 1692 1693 1694 1695
/**
 * 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)
{
1696
	return pinctrl_request_gpio(chip->gpiodev->base + offset);
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
}
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)
{
1707
	pinctrl_free_gpio(chip->gpiodev->base + offset);
1708 1709 1710
}
EXPORT_SYMBOL_GPL(gpiochip_generic_free);

1711
#ifdef CONFIG_PINCTRL
1712

1713 1714 1715
/**
 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
1716
 * @pctldev: the pin controller to map to
1717 1718 1719 1720 1721 1722 1723 1724
 * @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;
1725
	struct gpio_device *gdev = chip->gpiodev;
1726 1727 1728 1729
	int ret;

	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
	if (!pin_range) {
1730
		chip_err(chip, "failed to allocate pin ranges\n");
1731 1732 1733 1734 1735 1736 1737
		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;
1738
	pin_range->range.base = gdev->base + gpio_offset;
1739 1740 1741 1742 1743
	pin_range->pctldev = pctldev;

	ret = pinctrl_get_group_pins(pctldev, pin_group,
					&pin_range->range.pins,
					&pin_range->range.npins);
1744 1745
	if (ret < 0) {
		kfree(pin_range);
1746
		return ret;
1747
	}
1748 1749 1750

	pinctrl_add_gpio_range(pctldev, &pin_range->range);

1751 1752
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
1753 1754
		 pinctrl_dev_get_devname(pctldev), pin_group);

1755
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
1756 1757 1758 1759 1760

	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);

1761 1762 1763 1764
/**
 * 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
1765 1766
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_offset: the start offset in the pin controller number space
1767 1768 1769
 * @npins: the number of pins from the offset of each pin space (GPIO and
 *	pin controller) to accumulate in this range
 */
1770
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1771
			   unsigned int gpio_offset, unsigned int pin_offset,
1772
			   unsigned int npins)
1773 1774
{
	struct gpio_pin_range *pin_range;
1775
	struct gpio_device *gdev = chip->gpiodev;
1776
	int ret;
1777

1778
	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1779
	if (!pin_range) {
1780
		chip_err(chip, "failed to allocate pin ranges\n");
1781
		return -ENOMEM;
1782 1783
	}

1784
	/* Use local offset as range ID */
1785
	pin_range->range.id = gpio_offset;
1786
	pin_range->range.gc = chip;
1787
	pin_range->range.name = chip->label;
1788
	pin_range->range.base = gdev->base + gpio_offset;
1789
	pin_range->range.pin_base = pin_offset;
1790
	pin_range->range.npins = npins;
L
Linus Walleij 已提交
1791
	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1792
			&pin_range->range);
1793
	if (IS_ERR(pin_range->pctldev)) {
1794
		ret = PTR_ERR(pin_range->pctldev);
1795
		chip_err(chip, "could not create pin range\n");
1796
		kfree(pin_range);
1797
		return ret;
1798
	}
1799 1800
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
		 gpio_offset, gpio_offset + npins - 1,
1801 1802
		 pinctl_name,
		 pin_offset, pin_offset + npins - 1);
1803

1804
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
1805 1806

	return 0;
1807
}
1808
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1809

1810 1811 1812 1813
/**
 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
 * @chip: the chip to remove all the mappings for
 */
1814 1815 1816
void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
{
	struct gpio_pin_range *pin_range, *tmp;
1817
	struct gpio_device *gdev = chip->gpiodev;
1818

1819
	list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
1820 1821 1822
		list_del(&pin_range->node);
		pinctrl_remove_gpio_range(pin_range->pctldev,
				&pin_range->range);
1823
		kfree(pin_range);
1824 1825
	}
}
1826 1827 1828
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);

#endif /* CONFIG_PINCTRL */
1829

1830 1831 1832 1833
/* 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.
 */
1834
static int __gpiod_request(struct gpio_desc *desc, const char *label)
1835
{
1836
	struct gpio_chip	*chip = desc->gdev->chip;
1837
	int			status;
1838 1839
	unsigned long		flags;

1840 1841
	spin_lock_irqsave(&gpio_lock, flags);

1842
	/* NOTE:  gpio_request() can be called in early boot,
D
David Brownell 已提交
1843
	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1844 1845 1846 1847 1848
	 */

	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
		desc_set_label(desc, label ? : "?");
		status = 0;
1849
	} else {
1850
		status = -EBUSY;
M
Magnus Damm 已提交
1851
		goto done;
D
David Brownell 已提交
1852 1853 1854 1855 1856
	}

	if (chip->request) {
		/* chip->request may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
1857
		status = chip->request(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
1858 1859 1860 1861 1862
		spin_lock_irqsave(&gpio_lock, flags);

		if (status < 0) {
			desc_set_label(desc, NULL);
			clear_bit(FLAG_REQUESTED, &desc->flags);
1863
			goto done;
D
David Brownell 已提交
1864
		}
1865
	}
1866 1867 1868
	if (chip->get_direction) {
		/* chip->get_direction may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
1869
		gpiod_get_direction(desc);
1870 1871
		spin_lock_irqsave(&gpio_lock, flags);
	}
1872
done:
1873 1874 1875 1876 1877 1878 1879 1880
	if (status < 0) {
		/* Clear flags that might have been set by the caller before
		 * requesting the GPIO.
		 */
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
	}
1881 1882 1883 1884
	spin_unlock_irqrestore(&gpio_lock, flags);
	return status;
}

1885 1886 1887
/*
 * This descriptor validation needs to be inserted verbatim into each
 * function taking a descriptor, so we need to use a preprocessor
1888 1889
 * macro to avoid endless duplication. If the desc is NULL it is an
 * optional GPIO and calls should just bail out.
1890 1891
 */
#define VALIDATE_DESC(desc) do { \
1892 1893 1894
	if (!desc) \
		return 0; \
	if (!desc->gdev) { \
1895 1896 1897 1898 1899 1900 1901 1902 1903 1904
		pr_warn("%s: invalid GPIO\n", __func__); \
		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 { \
1905 1906 1907
	if (!desc) \
		return; \
	if (!desc->gdev) { \
1908 1909 1910 1911 1912 1913 1914 1915 1916 1917
		pr_warn("%s: invalid GPIO\n", __func__); \
		return; \
	} \
	if (!desc->gdev->chip) { \
		dev_warn(&desc->gdev->dev, \
			 "%s: backing chip is gone\n", __func__); \
		return; \
	} } while (0)


1918
int gpiod_request(struct gpio_desc *desc, const char *label)
1919 1920
{
	int status = -EPROBE_DEFER;
1921
	struct gpio_device *gdev;
1922

1923 1924
	VALIDATE_DESC(desc);
	gdev = desc->gdev;
1925

1926
	if (try_module_get(gdev->owner)) {
1927 1928
		status = __gpiod_request(desc, label);
		if (status < 0)
1929
			module_put(gdev->owner);
1930 1931
		else
			get_device(&gdev->dev);
1932 1933
	}

1934
	if (status)
1935
		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1936

1937 1938
	return status;
}
1939

1940
static bool __gpiod_free(struct gpio_desc *desc)
1941
{
1942
	bool			ret = false;
1943
	unsigned long		flags;
D
David Brownell 已提交
1944
	struct gpio_chip	*chip;
1945

1946 1947
	might_sleep();

1948
	gpiod_unexport(desc);
D
David Brownell 已提交
1949

1950 1951
	spin_lock_irqsave(&gpio_lock, flags);

1952
	chip = desc->gdev->chip;
D
David Brownell 已提交
1953 1954 1955
	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
		if (chip->free) {
			spin_unlock_irqrestore(&gpio_lock, flags);
1956
			might_sleep_if(chip->can_sleep);
1957
			chip->free(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
1958 1959
			spin_lock_irqsave(&gpio_lock, flags);
		}
1960
		desc_set_label(desc, NULL);
1961
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
D
David Brownell 已提交
1962
		clear_bit(FLAG_REQUESTED, &desc->flags);
1963
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1964
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
B
Benoit Parrot 已提交
1965
		clear_bit(FLAG_IS_HOGGED, &desc->flags);
1966 1967
		ret = true;
	}
1968 1969

	spin_unlock_irqrestore(&gpio_lock, flags);
1970 1971 1972
	return ret;
}

1973
void gpiod_free(struct gpio_desc *desc)
1974
{
1975
	if (desc && desc->gdev && __gpiod_free(desc)) {
1976
		module_put(desc->gdev->owner);
1977 1978
		put_device(&desc->gdev->dev);
	} else {
1979
		WARN_ON(extra_checks);
1980
	}
1981
}
1982

1983 1984 1985 1986 1987 1988
/**
 * 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.
1989 1990
 * The string returned is the label passed to gpio_request(); if none has been
 * passed it is a meaningless, non-NULL constant.
1991 1992 1993 1994 1995 1996 1997
 *
 * 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)
{
1998
	struct gpio_desc *desc;
1999

2000
	if (offset >= chip->ngpio)
2001
		return NULL;
2002

2003
	desc = &chip->gpiodev->descs[offset];
2004

2005
	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2006
		return NULL;
2007
	return desc->label;
2008 2009 2010
}
EXPORT_SYMBOL_GPL(gpiochip_is_requested);

2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
/**
 * 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).
 */
2022 2023
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
					    const char *label)
2024
{
2025 2026
	struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
	int err;
2027

2028 2029 2030 2031 2032 2033 2034 2035
	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);
2036

2037
	return desc;
2038
}
2039
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052

/**
 * 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);
}
2053
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2054

2055 2056
/*
 * Drivers MUST set GPIO direction before making get/set calls.  In
2057 2058 2059 2060 2061 2062 2063 2064
 * 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.
 */

2065 2066 2067 2068 2069 2070 2071 2072 2073 2074
/**
 * 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)
2075 2076 2077 2078
{
	struct gpio_chip	*chip;
	int			status = -EINVAL;

2079 2080
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2081

2082
	if (!chip->get || !chip->direction_input) {
2083 2084
		gpiod_warn(desc,
			"%s: missing get() or direction_input() operations\n",
2085
			__func__);
2086 2087 2088
		return -EIO;
	}

2089
	status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2090 2091
	if (status == 0)
		clear_bit(FLAG_IS_OUT, &desc->flags);
2092

2093
	trace_gpio_direction(desc_to_gpio(desc), 1, status);
2094

2095 2096
	return status;
}
2097
EXPORT_SYMBOL_GPL(gpiod_direction_input);
2098

2099
static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2100
{
2101 2102
	struct gpio_chip *gc = desc->gdev->chip;
	int ret;
2103

2104 2105 2106 2107 2108 2109 2110 2111
	/* 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;
	}

2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
	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);
	}
2141

2142 2143
set_output_value:
	if (!gc->set || !gc->direction_output) {
2144 2145 2146
		gpiod_warn(desc,
		       "%s: missing set() or direction_output() operations\n",
		       __func__);
2147 2148 2149
		return -EIO;
	}

2150 2151
	ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), value);
	if (!ret)
2152
		set_bit(FLAG_IS_OUT, &desc->flags);
2153
	trace_gpio_value(desc_to_gpio(desc), 0, value);
2154 2155
	trace_gpio_direction(desc_to_gpio(desc), 0, ret);
	return ret;
2156
}
2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170

/**
 * 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)
{
2171
	VALIDATE_DESC(desc);
2172 2173 2174 2175 2176
	return _gpiod_direction_output_raw(desc, value);
}
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);

/**
2177
 * gpiod_direction_output - set the GPIO direction to output
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189
 * @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)
{
2190
	VALIDATE_DESC(desc);
2191 2192 2193 2194
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
	return _gpiod_direction_output_raw(desc, value);
}
2195
EXPORT_SYMBOL_GPL(gpiod_direction_output);
2196

2197
/**
2198
 * gpiod_set_debounce - sets @debounce time for a @gpio
2199 2200
 * @gpio: the gpio to set debounce time
 * @debounce: debounce time is microseconds
2201 2202 2203
 *
 * returns -ENOTSUPP if the controller does not support setting
 * debounce.
2204
 */
2205
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2206 2207 2208
{
	struct gpio_chip	*chip;

2209 2210
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2211
	if (!chip->set || !chip->set_debounce) {
2212 2213 2214
		gpiod_dbg(desc,
			  "%s: missing set() or set_debounce() operations\n",
			  __func__);
2215
		return -ENOTSUPP;
2216 2217
	}

2218
	return chip->set_debounce(chip, gpio_chip_hwgpio(desc), debounce);
2219
}
2220
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2221

2222 2223 2224 2225 2226 2227 2228
/**
 * 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)
2229
{
2230
	VALIDATE_DESC(desc);
2231
	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2232
}
2233
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256

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

2257
static int _gpiod_get_raw_value(const struct gpio_desc *desc)
2258 2259
{
	struct gpio_chip	*chip;
2260
	int offset;
2261
	int value;
2262

2263
	chip = desc->gdev->chip;
2264
	offset = gpio_chip_hwgpio(desc);
2265
	value = chip->get ? chip->get(chip, offset) : -EIO;
2266
	value = value < 0 ? value : !!value;
2267
	trace_gpio_value(desc_to_gpio(desc), 1, value);
2268
	return value;
2269
}
2270

2271
/**
2272 2273
 * gpiod_get_raw_value() - return a gpio's raw value
 * @desc: gpio whose value will be returned
2274
 *
2275
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2276
 * its ACTIVE_LOW status, or negative errno on failure.
2277 2278 2279
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2280
 */
2281
int gpiod_get_raw_value(const struct gpio_desc *desc)
2282
{
2283
	VALIDATE_DESC(desc);
2284
	/* Should be using gpio_get_value_cansleep() */
2285
	WARN_ON(desc->gdev->chip->can_sleep);
2286
	return _gpiod_get_raw_value(desc);
2287
}
2288
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2289

2290 2291 2292 2293 2294
/**
 * 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
2295
 * account, or negative errno on failure.
2296 2297 2298 2299 2300
 *
 * 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)
2301
{
2302
	int value;
2303 2304

	VALIDATE_DESC(desc);
2305
	/* Should be using gpio_get_value_cansleep() */
2306
	WARN_ON(desc->gdev->chip->can_sleep);
2307 2308

	value = _gpiod_get_raw_value(desc);
2309 2310 2311
	if (value < 0)
		return value;

2312 2313 2314 2315
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
2316
}
2317
EXPORT_SYMBOL_GPL(gpiod_get_value);
2318

2319 2320
/*
 *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
2321
 * @desc: gpio descriptor whose state need to be set.
2322
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2323
 */
2324
static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
2325 2326
{
	int err = 0;
2327
	struct gpio_chip *chip = desc->gdev->chip;
2328 2329
	int offset = gpio_chip_hwgpio(desc);

2330
	if (value) {
2331
		err = chip->direction_input(chip, offset);
2332
		if (!err)
2333
			clear_bit(FLAG_IS_OUT, &desc->flags);
2334
	} else {
2335
		err = chip->direction_output(chip, offset, 0);
2336
		if (!err)
2337
			set_bit(FLAG_IS_OUT, &desc->flags);
2338
	}
2339
	trace_gpio_direction(desc_to_gpio(desc), value, err);
2340
	if (err < 0)
2341 2342 2343
		gpiod_err(desc,
			  "%s: Error in set_value for open drain err %d\n",
			  __func__, err);
2344 2345
}

2346
/*
2347 2348
 *  _gpio_set_open_source_value() - Set the open source gpio's value.
 * @desc: gpio descriptor whose state need to be set.
2349
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2350
 */
2351
static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
2352 2353
{
	int err = 0;
2354
	struct gpio_chip *chip = desc->gdev->chip;
2355 2356
	int offset = gpio_chip_hwgpio(desc);

2357
	if (value) {
2358
		err = chip->direction_output(chip, offset, 1);
2359
		if (!err)
2360
			set_bit(FLAG_IS_OUT, &desc->flags);
2361
	} else {
2362
		err = chip->direction_input(chip, offset);
2363
		if (!err)
2364
			clear_bit(FLAG_IS_OUT, &desc->flags);
2365
	}
2366
	trace_gpio_direction(desc_to_gpio(desc), !value, err);
2367
	if (err < 0)
2368 2369 2370
		gpiod_err(desc,
			  "%s: Error in set_value for open source err %d\n",
			  __func__, err);
2371 2372
}

2373
static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
2374 2375 2376
{
	struct gpio_chip	*chip;

2377
	chip = desc->gdev->chip;
2378 2379 2380 2381 2382
	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);
2383
	else
2384 2385 2386
		chip->set(chip, gpio_chip_hwgpio(desc), value);
}

2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
/*
 * 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 已提交
2411
			if (__test_and_clear_bit(i, mask))
2412 2413 2414 2415 2416
				chip->set(chip, i, test_bit(i, bits));
		}
	}
}

2417 2418 2419 2420
void gpiod_set_array_value_complex(bool raw, bool can_sleep,
				   unsigned int array_size,
				   struct gpio_desc **desc_array,
				   int *value_array)
2421 2422 2423 2424
{
	int i = 0;

	while (i < array_size) {
2425
		struct gpio_chip *chip = desc_array[i]->gdev->chip;
2426 2427 2428 2429
		unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
		unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
		int count = 0;

D
Daniel Lockyer 已提交
2430
		if (!can_sleep)
2431
			WARN_ON(chip->can_sleep);
D
Daniel Lockyer 已提交
2432

2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
		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 已提交
2447
				_gpio_set_open_drain_value(desc, value);
2448 2449 2450 2451
			} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
				_gpio_set_open_source_value(desc, value);
			} else {
				__set_bit(hwgpio, mask);
D
Daniel Lockyer 已提交
2452
				if (value)
2453
					__set_bit(hwgpio, bits);
D
Daniel Lockyer 已提交
2454
				else
2455 2456 2457 2458
					__clear_bit(hwgpio, bits);
				count++;
			}
			i++;
2459 2460
		} while ((i < array_size) &&
			 (desc_array[i]->gdev->chip == chip));
2461
		/* push collected bits to outputs */
D
Daniel Lockyer 已提交
2462
		if (count != 0)
2463 2464 2465 2466
			gpio_chip_set_multiple(chip, mask, bits);
	}
}

2467
/**
2468 2469
 * gpiod_set_raw_value() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
2470 2471
 * @value: value to assign
 *
2472 2473 2474 2475 2476
 * 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.
2477
 */
2478
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2479
{
2480
	VALIDATE_DESC_VOID(desc);
2481
	/* Should be using gpiod_set_value_cansleep() */
2482
	WARN_ON(desc->gdev->chip->can_sleep);
2483
	_gpiod_set_raw_value(desc, value);
2484
}
2485
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2486 2487

/**
2488 2489 2490 2491 2492 2493
 * 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
2494
 *
2495 2496
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2497
 */
2498
void gpiod_set_value(struct gpio_desc *desc, int value)
2499
{
2500
	VALIDATE_DESC_VOID(desc);
2501
	/* Should be using gpiod_set_value_cansleep() */
2502
	WARN_ON(desc->gdev->chip->can_sleep);
2503 2504 2505
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
	_gpiod_set_raw_value(desc, value);
2506
}
2507
EXPORT_SYMBOL_GPL(gpiod_set_value);
2508

2509
/**
2510
 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
 * @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.
 */
2521
void gpiod_set_raw_array_value(unsigned int array_size,
2522 2523 2524 2525
			 struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return;
2526 2527
	gpiod_set_array_value_complex(true, false, array_size, desc_array,
				      value_array);
2528
}
2529
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
2530 2531

/**
2532
 * gpiod_set_array_value() - assign values to an array of GPIOs
2533 2534 2535 2536 2537 2538 2539 2540 2541 2542
 * @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.
 */
2543 2544
void gpiod_set_array_value(unsigned int array_size,
			   struct gpio_desc **desc_array, int *value_array)
2545 2546 2547
{
	if (!desc_array)
		return;
2548 2549
	gpiod_set_array_value_complex(false, false, array_size, desc_array,
				      value_array);
2550
}
2551
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
2552

2553
/**
2554 2555
 * gpiod_cansleep() - report whether gpio value access may sleep
 * @desc: gpio to check
2556 2557
 *
 */
2558
int gpiod_cansleep(const struct gpio_desc *desc)
2559
{
2560 2561
	VALIDATE_DESC(desc);
	return desc->gdev->chip->can_sleep;
2562
}
2563
EXPORT_SYMBOL_GPL(gpiod_cansleep);
2564

D
David Brownell 已提交
2565
/**
2566 2567
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
D
David Brownell 已提交
2568
 *
2569 2570
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
D
David Brownell 已提交
2571
 */
2572
int gpiod_to_irq(const struct gpio_desc *desc)
D
David Brownell 已提交
2573
{
2574 2575
	struct gpio_chip *chip;
	int offset;
D
David Brownell 已提交
2576

2577 2578
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2579
	offset = gpio_chip_hwgpio(desc);
2580 2581 2582 2583 2584 2585 2586 2587 2588 2589
	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 已提交
2590
}
2591
EXPORT_SYMBOL_GPL(gpiod_to_irq);
D
David Brownell 已提交
2592

2593
/**
2594
 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
2595 2596
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2597 2598
 *
 * This is used directly by GPIO drivers that want to lock down
2599
 * a certain GPIO line to be used for IRQs.
2600
 */
2601
int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2602
{
2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
	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);
	}
2618

2619
	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2620
		chip_err(chip,
2621 2622 2623 2624 2625
			  "%s: tried to flag a GPIO set as output for IRQ\n",
			  __func__);
		return -EIO;
	}

2626
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2627
	return 0;
2628
}
2629
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
2630

2631
/**
2632
 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
2633 2634
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2635 2636 2637
 *
 * This is used directly by GPIO drivers that want to indicate
 * that a certain GPIO is no longer used exclusively for IRQ.
2638
 */
2639
void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2640
{
2641
	if (offset >= chip->ngpio)
2642
		return;
2643

2644
	clear_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
2645
}
2646
EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
2647

2648 2649 2650 2651 2652 2653 2654 2655 2656
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);

2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674
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);

2675 2676 2677 2678 2679
/**
 * 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
2680
 * its ACTIVE_LOW status, or negative errno on failure.
2681 2682
 *
 * This function is to be called from contexts that can sleep.
2683
 */
2684
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2685 2686
{
	might_sleep_if(extra_checks);
2687
	VALIDATE_DESC(desc);
2688
	return _gpiod_get_raw_value(desc);
2689
}
2690
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2691

2692 2693 2694 2695 2696
/**
 * 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
2697
 * account, or negative errno on failure.
2698 2699 2700 2701
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2702
{
2703
	int value;
2704 2705

	might_sleep_if(extra_checks);
2706
	VALIDATE_DESC(desc);
2707
	value = _gpiod_get_raw_value(desc);
2708 2709 2710
	if (value < 0)
		return value;

2711 2712 2713
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

2714
	return value;
2715
}
2716
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2717

2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
/**
 * 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)
2729
{
2730
	might_sleep_if(extra_checks);
2731
	VALIDATE_DESC_VOID(desc);
2732
	_gpiod_set_raw_value(desc, value);
2733
}
2734
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2735

2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746
/**
 * 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)
2747 2748
{
	might_sleep_if(extra_checks);
2749
	VALIDATE_DESC_VOID(desc);
2750 2751 2752
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
	_gpiod_set_raw_value(desc, value);
2753
}
2754
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2755

2756
/**
2757
 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
2758 2759 2760 2761 2762 2763 2764 2765 2766
 * @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.
 */
2767 2768 2769
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
					struct gpio_desc **desc_array,
					int *value_array)
2770 2771 2772 2773
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
2774 2775
	gpiod_set_array_value_complex(true, true, array_size, desc_array,
				      value_array);
2776
}
2777
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
2778 2779

/**
2780
 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
2781 2782 2783 2784 2785 2786 2787 2788 2789
 * @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.
 */
2790 2791 2792
void gpiod_set_array_value_cansleep(unsigned int array_size,
				    struct gpio_desc **desc_array,
				    int *value_array)
2793 2794 2795 2796
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
2797 2798
	gpiod_set_array_value_complex(false, true, array_size, desc_array,
				      value_array);
2799
}
2800
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
2801

2802
/**
2803 2804
 * gpiod_add_lookup_table() - register GPIO device consumers
 * @table: table of consumers to register
2805
 */
2806
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2807 2808 2809
{
	mutex_lock(&gpio_lookup_lock);

2810
	list_add_tail(&table->list, &gpio_lookup_list);
2811 2812 2813 2814

	mutex_unlock(&gpio_lookup_lock);
}

2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827
/**
 * 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);
}

2828
static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2829 2830
				      unsigned int idx,
				      enum gpio_lookup_flags *flags)
2831 2832 2833 2834
{
	char prop_name[32]; /* 32 is max size of property name */
	enum of_gpio_flags of_flags;
	struct gpio_desc *desc;
2835
	unsigned int i;
2836

2837
	for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
2838
		if (con_id)
2839
			snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
2840
				 gpio_suffixes[i]);
2841
		else
2842
			snprintf(prop_name, sizeof(prop_name), "%s",
2843
				 gpio_suffixes[i]);
2844

2845 2846
		desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
						&of_flags);
2847
		if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
2848 2849
			break;
	}
2850 2851 2852 2853 2854

	if (IS_ERR(desc))
		return desc;

	if (of_flags & OF_GPIO_ACTIVE_LOW)
2855
		*flags |= GPIO_ACTIVE_LOW;
2856

2857 2858 2859 2860 2861 2862 2863
	if (of_flags & OF_GPIO_SINGLE_ENDED) {
		if (of_flags & OF_GPIO_ACTIVE_LOW)
			*flags |= GPIO_OPEN_DRAIN;
		else
			*flags |= GPIO_OPEN_SOURCE;
	}

2864 2865
	return desc;
}
2866

2867 2868
static struct gpio_desc *acpi_find_gpio(struct device *dev,
					const char *con_id,
2869
					unsigned int idx,
2870 2871
					enum gpiod_flags flags,
					enum gpio_lookup_flags *lookupflags)
2872
{
2873
	struct acpi_device *adev = ACPI_COMPANION(dev);
2874 2875
	struct acpi_gpio_info info;
	struct gpio_desc *desc;
2876 2877
	char propname[32];
	int i;
2878

2879
	/* Try first from _DSD */
2880
	for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
2881 2882
		if (con_id && strcmp(con_id, "gpios")) {
			snprintf(propname, sizeof(propname), "%s-%s",
2883
				 con_id, gpio_suffixes[i]);
2884 2885
		} else {
			snprintf(propname, sizeof(propname), "%s",
2886
				 gpio_suffixes[i]);
2887 2888 2889 2890 2891 2892 2893 2894 2895
		}

		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)) {
2896 2897 2898
		if (!acpi_can_fallback_to_crs(adev, con_id))
			return ERR_PTR(-ENOENT);

2899 2900 2901
		desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
		if (IS_ERR(desc))
			return desc;
2902 2903 2904 2905 2906 2907

		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);
		}
2908
	}
2909

2910
	if (info.polarity == GPIO_ACTIVE_LOW)
2911
		*lookupflags |= GPIO_ACTIVE_LOW;
2912 2913

	return desc;
2914 2915
}

2916
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2917 2918
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
2919
	struct gpiod_lookup_table *table;
2920 2921 2922

	mutex_lock(&gpio_lookup_lock);

2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940
	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;
2941

2942 2943 2944 2945
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
2946

2947 2948 2949 2950
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
				    unsigned int idx,
				    enum gpio_lookup_flags *flags)
{
2951
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
2952 2953
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
2954

2955 2956 2957
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
2958

2959 2960
	for (p = &table->table[0]; p->chip_label; p++) {
		struct gpio_chip *chip;
2961

2962
		/* idx must always match exactly */
2963 2964 2965
		if (p->idx != idx)
			continue;

2966 2967 2968
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
2969

2970
		chip = find_chip_by_name(p->chip_label);
2971

2972
		if (!chip) {
2973 2974 2975
			dev_err(dev, "cannot find GPIO chip %s\n",
				p->chip_label);
			return ERR_PTR(-ENODEV);
2976
		}
2977

2978
		if (chip->ngpio <= p->chip_hwnum) {
2979 2980 2981 2982
			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);
2983 2984
		}

2985
		desc = gpiochip_get_desc(chip, p->chip_hwnum);
2986
		*flags = p->flags;
2987

2988
		return desc;
2989 2990 2991 2992 2993
	}

	return desc;
}

2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 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
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);

3058
/**
3059
 * gpiod_get - obtain a GPIO for a given GPIO function
3060
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3061
 * @con_id:	function within the GPIO consumer
3062
 * @flags:	optional GPIO initialization flags
3063 3064
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
3065
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3066
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3067
 */
3068
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3069
					 enum gpiod_flags flags)
3070
{
3071
	return gpiod_get_index(dev, con_id, 0, flags);
3072
}
3073
EXPORT_SYMBOL_GPL(gpiod_get);
3074

3075 3076 3077 3078
/**
 * 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
3079
 * @flags: optional GPIO initialization flags
3080 3081 3082 3083 3084
 *
 * 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.
 */
3085
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3086 3087
						  const char *con_id,
						  enum gpiod_flags flags)
3088
{
3089
	return gpiod_get_index_optional(dev, con_id, 0, flags);
3090
}
3091
EXPORT_SYMBOL_GPL(gpiod_get_optional);
3092

3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109
/**
 * gpiod_parse_flags - helper function to parse GPIO lookup flags
 * @desc:	gpio to be setup
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
 *
 * Set the GPIO descriptor flags based on the given GPIO lookup flags.
 */
static void gpiod_parse_flags(struct gpio_desc *desc, unsigned long lflags)
{
	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 已提交
3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
 * @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,
3122
				 enum gpiod_flags dflags)
B
Benoit Parrot 已提交
3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
{
	int status;

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

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

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

3167 3168 3169 3170 3171 3172 3173
	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");
3174
			desc = acpi_find_gpio(dev, con_id, idx, flags, &lookupflags);
3175
		}
3176 3177 3178 3179 3180 3181
	}

	/*
	 * 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.
	 */
3182
	if (!desc || desc == ERR_PTR(-ENOENT)) {
3183
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3184
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
3185 3186 3187
	}

	if (IS_ERR(desc)) {
3188
		dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
3189 3190 3191
		return desc;
	}

3192 3193
	gpiod_parse_flags(desc, lookupflags);

3194 3195 3196 3197
	status = gpiod_request(desc, con_id);
	if (status < 0)
		return ERR_PTR(status);

3198
	status = gpiod_configure_flags(desc, con_id, flags);
3199 3200 3201 3202 3203 3204
	if (status < 0) {
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
		gpiod_put(desc);
		return ERR_PTR(status);
	}

3205 3206
	return desc;
}
3207
EXPORT_SYMBOL_GPL(gpiod_get_index);
3208

3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227
/**
 * 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;
3228
	bool single_ended = false;
3229 3230 3231 3232 3233 3234 3235 3236
	int ret;

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

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

3237
		desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname, 0,
3238
						&flags);
3239
		if (!IS_ERR(desc)) {
3240
			active_low = flags & OF_GPIO_ACTIVE_LOW;
3241 3242
			single_ended = flags & OF_GPIO_SINGLE_ENDED;
		}
3243 3244 3245
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

3246
		desc = acpi_node_get_gpiod(fwnode, propname, 0, &info);
3247
		if (!IS_ERR(desc))
3248
			active_low = info.polarity == GPIO_ACTIVE_LOW;
3249 3250 3251 3252 3253 3254 3255 3256
	}

	if (IS_ERR(desc))
		return desc;

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

3257 3258 3259 3260 3261 3262 3263
	if (single_ended) {
		if (active_low)
			set_bit(FLAG_OPEN_DRAIN, &desc->flags);
		else
			set_bit(FLAG_OPEN_SOURCE, &desc->flags);
	}

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

3268 3269 3270 3271
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

3272 3273 3274 3275 3276 3277
/**
 * 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
3278
 * @flags: optional GPIO initialization flags
3279 3280 3281 3282 3283
 *
 * 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.
 */
3284
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3285
							const char *con_id,
3286 3287
							unsigned int index,
							enum gpiod_flags flags)
3288 3289 3290
{
	struct gpio_desc *desc;

3291
	desc = gpiod_get_index(dev, con_id, index, flags);
3292 3293 3294 3295 3296 3297 3298
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
3299
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3300

B
Benoit Parrot 已提交
3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319
/**
 * 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);

3320 3321
	gpiod_parse_flags(desc, lflags);

B
Benoit Parrot 已提交
3322 3323
	local_desc = gpiochip_request_own_desc(chip, hwnum, name);
	if (IS_ERR(local_desc)) {
3324 3325 3326 3327
		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 已提交
3328 3329
	}

3330
	status = gpiod_configure_flags(desc, name, dflags);
B
Benoit Parrot 已提交
3331
	if (status < 0) {
3332 3333
		pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
B
Benoit Parrot 已提交
3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360
		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++) {
3361 3362
		if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
B
Benoit Parrot 已提交
3363 3364 3365
	}
}

3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 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
/**
 * 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);

3432 3433 3434 3435 3436 3437 3438 3439 3440
/**
 * 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);
3441
}
3442
EXPORT_SYMBOL_GPL(gpiod_put);
3443

3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458
/**
 * 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);

3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473
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);
3474 3475 3476
	} else {
		gpiolib_initialized = true;
		gpiochip_setup_devs();
3477 3478 3479 3480 3481
	}
	return ret;
}
core_initcall(gpiolib_dev_init);

3482 3483
#ifdef CONFIG_DEBUG_FS

3484
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
3485 3486
{
	unsigned		i;
3487 3488 3489
	struct gpio_chip	*chip = gdev->chip;
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
3490
	int			is_out;
3491
	int			is_irq;
3492

3493
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
3494 3495 3496 3497 3498
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
3499
			continue;
3500
		}
3501

3502
		gpiod_get_direction(gdesc);
3503
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
3504
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
3505 3506
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
3507 3508 3509
			is_out ? "out" : "in ",
			chip->get
				? (chip->get(chip, i) ? "hi" : "lo")
3510 3511
				: "?  ",
			is_irq ? "IRQ" : "   ");
3512 3513 3514 3515
		seq_printf(s, "\n");
	}
}

3516
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
3517
{
3518
	unsigned long flags;
3519
	struct gpio_device *gdev = NULL;
3520
	loff_t index = *pos;
3521

3522
	s->private = "";
3523

3524
	spin_lock_irqsave(&gpio_lock, flags);
3525
	list_for_each_entry(gdev, &gpio_devices, list)
3526 3527
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
3528
			return gdev;
3529
		}
3530
	spin_unlock_irqrestore(&gpio_lock, flags);
3531

3532
	return NULL;
3533 3534 3535 3536
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
3537
	unsigned long flags;
3538
	struct gpio_device *gdev = v;
3539 3540
	void *ret = NULL;

3541
	spin_lock_irqsave(&gpio_lock, flags);
3542
	if (list_is_last(&gdev->list, &gpio_devices))
3543 3544
		ret = NULL;
	else
3545
		ret = list_entry(gdev->list.next, struct gpio_device, list);
3546
	spin_unlock_irqrestore(&gpio_lock, flags);
3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559

	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)
{
3560 3561 3562 3563 3564 3565 3566 3567 3568
	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;
	}
3569

3570 3571
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
3572
		   gdev->base, gdev->base + gdev->ngpio - 1);
3573 3574 3575 3576 3577
	parent = chip->parent;
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
3578 3579 3580 3581 3582 3583 3584 3585 3586
	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
3587
		gpiolib_dbg_show(s, gdev);
3588

3589 3590 3591
	return 0;
}

3592 3593 3594 3595 3596 3597 3598
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

3599 3600
static int gpiolib_open(struct inode *inode, struct file *file)
{
3601
	return seq_open(file, &gpiolib_seq_ops);
3602 3603
}

3604
static const struct file_operations gpiolib_operations = {
3605
	.owner		= THIS_MODULE,
3606 3607 3608
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
3609
	.release	= seq_release,
3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621
};

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