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

31 32
#include "gpiolib.h"

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

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


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

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

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

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

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

81
static bool gpiolib_initialized;
82

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

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

	spin_lock_irqsave(&gpio_lock, flags);

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

	spin_unlock_irqrestore(&gpio_lock, flags);

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

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

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

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

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

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


158 159 160 161 162
/**
 * 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)
163
{
164 165 166
	if (!desc || !desc->gdev || !desc->gdev->chip)
		return NULL;
	return desc->gdev->chip;
167
}
168
EXPORT_SYMBOL_GPL(gpiod_to_chip);
169

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

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

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

194 195 196 197 198 199 200 201
/**
 * 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.
 */
202
int gpiod_get_direction(struct gpio_desc *desc)
203 204
{
	struct gpio_chip	*chip;
205
	unsigned		offset;
206 207
	int			status = -EINVAL;

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

	if (!chip->get_direction)
		return status;

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

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

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

245 246 247 248 249
	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;
250 251
	}

252 253 254 255
	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);
256
		return 0;
257 258
	}

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

264 265 266 267 268 269 270 271 272 273
		/* 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;
274 275
}

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

	spin_lock_irqsave(&gpio_lock, flags);

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

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

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

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

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

307 308 309 310
/*
 * Takes the names from gc->names and checks if they are all unique. If they
 * are, they are assigned to their gpio descriptors.
 *
311
 * Warning if one of the names is already used for a different GPIO.
312 313 314
 */
static int gpiochip_set_desc_names(struct gpio_chip *gc)
{
315
	struct gpio_device *gdev = gc->gpiodev;
316 317 318 319 320 321 322 323 324 325
	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]);
326
		if (gpio)
327
			dev_warn(&gdev->dev,
328
				 "Detected name collision for GPIO name '%s'\n",
329
				 gc->names[i]);
330 331 332 333
	}

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

	return 0;
}

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
/*
 * 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;
};

357 358 359 360 361 362 363
#define GPIOHANDLE_REQUEST_VALID_FLAGS \
	(GPIOHANDLE_REQUEST_INPUT | \
	GPIOHANDLE_REQUEST_OUTPUT | \
	GPIOHANDLE_REQUEST_ACTIVE_LOW | \
	GPIOHANDLE_REQUEST_OPEN_DRAIN | \
	GPIOHANDLE_REQUEST_OPEN_SOURCE)

364 365 366 367 368 369
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;
370
	int vals[GPIOHANDLES_MAX];
371 372 373
	int i;

	if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
374 375 376 377 378 379 380 381
		/* TODO: check if descriptors are really input */
		int ret = gpiod_get_array_value_complex(false,
							true,
							lh->numdescs,
							lh->descs,
							vals);
		if (ret)
			return ret;
382

383
		memset(&ghd, 0, sizeof(ghd));
384 385
		for (i = 0; i < lh->numdescs; i++)
			ghd.values[i] = vals[i];
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

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

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

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

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

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

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

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

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

static int linehandle_create(struct gpio_device *gdev, void __user *ip)
{
	struct gpiohandle_request handlereq;
	struct linehandle_state *lh;
447
	struct file *file;
448
	int fd, i, ret;
449
	u32 lflags;
450 451 452 453 454 455

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

456 457 458 459 460 461
	lflags = handlereq.flags;

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

462 463 464 465 466 467
	/* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */
	if (!(lflags & GPIOHANDLE_REQUEST_OUTPUT) &&
	    ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
	     (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
		return -EINVAL;

468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
	lh = kzalloc(sizeof(*lh), GFP_KERNEL);
	if (!lh)
		return -ENOMEM;
	lh->gdev = gdev;
	get_device(&gdev->dev);

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

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

490 491 492 493 494
		if (offset >= gdev->ngpio) {
			ret = -EINVAL;
			goto out_free_descs;
		}

495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
		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);
	}
526 527
	/* Let i point at the last handle */
	i--;
528 529
	lh->numdescs = handlereq.lines;

530
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
531 532 533 534 535
	if (fd < 0) {
		ret = fd;
		goto out_free_descs;
	}

536 537 538 539 540 541 542 543 544
	file = anon_inode_getfile("gpio-linehandle",
				  &linehandle_fileops,
				  lh,
				  O_RDONLY | O_CLOEXEC);
	if (IS_ERR(file)) {
		ret = PTR_ERR(file);
		goto out_put_unused_fd;
	}

545
	handlereq.fd = fd;
546
	if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
547 548 549 550 551 552 553
		/*
		 * fput() will trigger the release() callback, so do not go onto
		 * the regular error cleanup path here.
		 */
		fput(file);
		put_unused_fd(fd);
		return -EFAULT;
554
	}
555

556 557
	fd_install(fd, file);

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

	return 0;

563 564
out_put_unused_fd:
	put_unused_fd(fd);
565 566 567 568 569 570 571 572 573 574
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;
}

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

602 603 604 605
#define GPIOEVENT_REQUEST_VALID_FLAGS \
	(GPIOEVENT_REQUEST_RISING_EDGE | \
	GPIOEVENT_REQUEST_FALLING_EDGE)

606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
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;

693 694
		memset(&ghd, 0, sizeof(ghd));

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

728
static irqreturn_t lineevent_irq_thread(int irq, void *p)
729 730 731
{
	struct lineevent_state *le = p;
	struct gpioevent_data ge;
732
	int ret, level;
733 734

	ge.timestamp = ktime_get_real_ns();
735
	level = gpiod_get_value_cansleep(le->desc);
736

737 738
	if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
	    && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
739 740 741 742 743 744
		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;
745
	} else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE && level) {
746 747
		/* Emit low-to-high event */
		ge.id = GPIOEVENT_EVENT_RISING_EDGE;
748
	} else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE && !level) {
749 750
		/* Emit high-to-low event */
		ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
751 752
	} else {
		return IRQ_NONE;
753 754 755 756 757 758 759 760 761 762 763 764 765 766
	}

	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;
767
	struct file *file;
768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
	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;

799 800 801 802 803
	if (offset >= gdev->ngpio) {
		ret = -EINVAL;
		goto out_free_label;
	}

804 805 806 807 808 809 810
	/* Return an error if a unknown flag is set */
	if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) ||
	    (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS)) {
		ret = -EINVAL;
		goto out_free_label;
	}

811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
	/* 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;

862
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
863 864 865 866 867
	if (fd < 0) {
		ret = fd;
		goto out_free_irq;
	}

868 869 870 871 872 873 874 875 876
	file = anon_inode_getfile("gpio-event",
				  &lineevent_fileops,
				  le,
				  O_RDONLY | O_CLOEXEC);
	if (IS_ERR(file)) {
		ret = PTR_ERR(file);
		goto out_put_unused_fd;
	}

877
	eventreq.fd = fd;
878
	if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
879 880 881 882 883 884 885
		/*
		 * fput() will trigger the release() callback, so do not go onto
		 * the regular error cleanup path here.
		 */
		fput(file);
		put_unused_fd(fd);
		return -EFAULT;
886
	}
887

888 889
	fd_install(fd, file);

890 891
	return 0;

892 893
out_put_unused_fd:
	put_unused_fd(fd);
894 895 896 897 898 899 900 901 902 903 904 905
out_free_irq:
	free_irq(le->irq, le);
out_free_desc:
	gpiod_free(le->desc);
out_free_label:
	kfree(le->label);
out_free_le:
	kfree(le);
	put_device(&gdev->dev);
	return ret;
}

T
Thierry Reding 已提交
906
/*
907 908 909 910 911 912
 * 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;
913
	void __user *ip = (void __user *)arg;
914 915 916 917 918

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

919
	/* Fill in the struct and pass to userspace */
920
	if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
921 922
		struct gpiochip_info chipinfo;

923 924
		memset(&chipinfo, 0, sizeof(chipinfo));

925 926 927
		strncpy(chipinfo.name, dev_name(&gdev->dev),
			sizeof(chipinfo.name));
		chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
928 929 930
		strncpy(chipinfo.label, gdev->label,
			sizeof(chipinfo.label));
		chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
931
		chipinfo.lines = gdev->ngpio;
932 933 934
		if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
			return -EFAULT;
		return 0;
935 936 937 938 939 940
	} 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;
941
		if (lineinfo.line_offset >= gdev->ngpio)
942 943 944 945 946 947 948 949 950 951 952
			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) {
953 954 955
			strncpy(lineinfo.consumer, desc->label,
				sizeof(lineinfo.consumer));
			lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
956
		} else {
957
			lineinfo.consumer[0] = '\0';
958 959 960 961 962 963 964
		}

		/*
		 * Userspace only need to know that the kernel is using
		 * this GPIO so it can't use it.
		 */
		lineinfo.flags = 0;
965 966 967 968 969
		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))
970
			lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
971
		if (test_bit(FLAG_IS_OUT, &desc->flags))
972
			lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
973
		if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
974
			lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
975
		if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
976
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
977
		if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
978 979 980 981 982
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;

		if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
			return -EFAULT;
		return 0;
983 984
	} else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
		return linehandle_create(gdev, ip);
985 986
	} else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
		return lineevent_create(gdev, ip);
987 988 989 990
	}
	return -EINVAL;
}

991 992 993 994 995 996 997 998
#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

999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
/**
 * 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 */
1011
	if (!gdev->chip)
1012 1013 1014
		return -ENODEV;
	get_device(&gdev->dev);
	filp->private_data = gdev;
1015 1016

	return nonseekable_open(inode, filp);
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
}

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

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


static const struct file_operations gpio_fileops = {
	.release = gpio_chrdev_release,
	.open = gpio_chrdev_open,
	.owner = THIS_MODULE,
1039
	.llseek = no_llseek,
1040
	.unlocked_ioctl = gpio_ioctl,
1041 1042 1043
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
1044 1045
};

1046 1047 1048 1049 1050 1051
static void gpiodevice_release(struct device *dev)
{
	struct gpio_device *gdev = dev_get_drvdata(dev);

	list_del(&gdev->list);
	ida_simple_remove(&gpio_ida, gdev->id);
1052 1053
	kfree(gdev->label);
	kfree(gdev->descs);
1054
	kfree(gdev);
1055 1056
}

1057 1058 1059 1060 1061 1062 1063
static int gpiochip_setup_dev(struct gpio_device *gdev)
{
	int status;

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

	status = cdev_device_add(&gdev->chrdev, &gdev->dev);
1066
	if (status)
1067 1068 1069 1070
		return status;

	chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
		 MAJOR(gpio_devt), gdev->id);
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084

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

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

	return 0;

err_remove_device:
1085
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
	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);
	}
}

1102 1103
int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
			       struct lock_class_key *key)
1104 1105 1106
{
	unsigned long	flags;
	int		status = 0;
1107
	unsigned	i;
1108
	int		base = chip->base;
1109
	struct gpio_device *gdev;
1110

1111 1112 1113 1114
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
1115
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1116
	if (!gdev)
1117
		return -ENOMEM;
1118
	gdev->dev.bus = &gpio_bus_type;
1119 1120 1121 1122 1123
	gdev->chip = chip;
	chip->gpiodev = gdev;
	if (chip->parent) {
		gdev->dev.parent = chip->parent;
		gdev->dev.of_node = chip->parent->of_node;
1124 1125
	}

1126 1127
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
1128 1129
	if (chip->of_node)
		gdev->dev.of_node = chip->of_node;
1130
#endif
1131

1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
	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;
1147

1148
	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1149
	if (!gdev->descs) {
1150 1151 1152 1153
		status = -ENOMEM;
		goto err_free_gdev;
	}

1154 1155
	if (chip->ngpio == 0) {
		chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1156
		status = -EINVAL;
1157
		goto err_free_descs;
1158
	}
1159 1160

	if (chip->label)
1161
		gdev->label = kstrdup(chip->label, GFP_KERNEL);
1162
	else
1163
		gdev->label = kstrdup("unknown", GFP_KERNEL);
1164 1165
	if (!gdev->label) {
		status = -ENOMEM;
1166
		goto err_free_descs;
1167 1168
	}

1169
	gdev->ngpio = chip->ngpio;
1170
	gdev->data = data;
1171

1172 1173
	spin_lock_irqsave(&gpio_lock, flags);

1174 1175 1176 1177 1178 1179 1180
	/*
	 * 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.
	 */
1181 1182 1183 1184
	if (base < 0) {
		base = gpiochip_find_base(chip->ngpio);
		if (base < 0) {
			status = base;
1185
			spin_unlock_irqrestore(&gpio_lock, flags);
1186
			goto err_free_label;
1187
		}
1188 1189 1190 1191 1192 1193
		/*
		 * 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.
		 */
1194 1195
		chip->base = base;
	}
1196
	gdev->base = base;
1197

1198
	status = gpiodev_add_to_list(gdev);
1199 1200
	if (status) {
		spin_unlock_irqrestore(&gpio_lock, flags);
1201
		goto err_free_label;
1202
	}
1203

1204 1205
	spin_unlock_irqrestore(&gpio_lock, flags);

1206
	for (i = 0; i < chip->ngpio; i++) {
1207
		struct gpio_desc *desc = &gdev->descs[i];
1208

1209
		desc->gdev = gdev;
1210 1211 1212 1213 1214 1215 1216
		/*
		 * 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.
1217
		 */
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234

		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);
		}
1235
	}
1236

1237
#ifdef CONFIG_PINCTRL
1238
	INIT_LIST_HEAD(&gdev->pin_ranges);
1239 1240
#endif

1241 1242 1243 1244
	status = gpiochip_set_desc_names(chip);
	if (status)
		goto err_remove_from_list;

1245 1246 1247 1248
	status = gpiochip_irqchip_init_valid_mask(chip);
	if (status)
		goto err_remove_from_list;

1249
	status = gpiochip_add_irqchip(chip, key);
1250 1251 1252
	if (status)
		goto err_remove_chip;

1253 1254 1255 1256
	status = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

1257
	acpi_gpiochip_add(chip);
1258

1259 1260 1261 1262 1263
	/*
	 * 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.
1264 1265
	 * We can do this only if gpiolib has been initialized.
	 * Otherwise, defer until later.
1266
	 */
1267 1268 1269 1270 1271
	if (gpiolib_initialized) {
		status = gpiochip_setup_dev(gdev);
		if (status)
			goto err_remove_chip;
	}
1272
	return 0;
1273

1274 1275
err_remove_chip:
	acpi_gpiochip_remove(chip);
1276
	gpiochip_free_hogs(chip);
1277
	of_gpiochip_remove(chip);
1278
	gpiochip_irqchip_free_valid_mask(chip);
1279
err_remove_from_list:
1280
	spin_lock_irqsave(&gpio_lock, flags);
1281
	list_del(&gdev->list);
1282
	spin_unlock_irqrestore(&gpio_lock, flags);
1283 1284 1285 1286
err_free_label:
	kfree(gdev->label);
err_free_descs:
	kfree(gdev->descs);
1287 1288
err_free_gdev:
	ida_simple_remove(&gpio_ida, gdev->id);
1289
	/* failures here can mean systems won't boot... */
1290
	pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1291 1292 1293
	       gdev->base, gdev->base + gdev->ngpio - 1,
	       chip->label ? : "generic");
	kfree(gdev);
1294 1295
	return status;
}
1296
EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
1297

1298 1299
/**
 * gpiochip_get_data() - get per-subdriver data for the chip
T
Thierry Reding 已提交
1300 1301 1302 1303
 * @chip: GPIO chip
 *
 * Returns:
 * The per-subdriver data for the chip.
1304 1305 1306 1307 1308 1309 1310
 */
void *gpiochip_get_data(struct gpio_chip *chip)
{
	return chip->gpiodev->data;
}
EXPORT_SYMBOL_GPL(gpiochip_get_data);

1311 1312 1313 1314 1315 1316
/**
 * gpiochip_remove() - unregister a gpio_chip
 * @chip: the chip to unregister
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
1317
void gpiochip_remove(struct gpio_chip *chip)
1318
{
1319
	struct gpio_device *gdev = chip->gpiodev;
J
Johan Hovold 已提交
1320
	struct gpio_desc *desc;
1321
	unsigned long	flags;
1322
	unsigned	i;
J
Johan Hovold 已提交
1323
	bool		requested = false;
1324

1325
	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1326
	gpiochip_sysfs_unregister(gdev);
1327
	gpiochip_free_hogs(chip);
1328 1329
	/* Numb the device, cancelling all outstanding operations */
	gdev->chip = NULL;
1330
	gpiochip_irqchip_remove(chip);
1331
	acpi_gpiochip_remove(chip);
1332
	gpiochip_remove_pin_ranges(chip);
1333
	of_gpiochip_remove(chip);
1334 1335 1336 1337 1338
	/*
	 * We accept no more calls into the driver from this point, so
	 * NULL the driver data pointer
	 */
	gdev->data = NULL;
1339

1340
	spin_lock_irqsave(&gpio_lock, flags);
1341
	for (i = 0; i < gdev->ngpio; i++) {
1342
		desc = &gdev->descs[i];
J
Johan Hovold 已提交
1343 1344
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
1345 1346
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
1347

J
Johan Hovold 已提交
1348
	if (requested)
1349
		dev_crit(&gdev->dev,
1350
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
J
Johan Hovold 已提交
1351

1352 1353 1354 1355 1356 1357
	/*
	 * 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.
	 */
1358
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1359
	put_device(&gdev->dev);
1360 1361 1362
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
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
T
Thierry Reding 已提交
1387
 * @data: driver-private data associated with this chip
1388
 *
T
Thierry Reding 已提交
1389
 * Context: potentially before irqs will work
1390 1391
 *
 * The gpio chip automatically be released when the device is unbound.
T
Thierry Reding 已提交
1392 1393 1394 1395 1396
 *
 * 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.
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
 */
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);
1435
	WARN_ON(ret);
1436 1437 1438
}
EXPORT_SYMBOL_GPL(devm_gpiochip_remove);

1439 1440 1441
/**
 * gpiochip_find() - iterator for locating a specific gpio_chip
 * @data: data to pass to match function
T
Thierry Reding 已提交
1442
 * @match: Callback function to check gpio_chip
1443 1444 1445 1446 1447 1448 1449
 *
 * 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.
 */
1450
struct gpio_chip *gpiochip_find(void *data,
1451
				int (*match)(struct gpio_chip *chip,
1452
					     void *data))
1453
{
1454
	struct gpio_device *gdev;
1455
	struct gpio_chip *chip = NULL;
1456 1457 1458
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
1459
	list_for_each_entry(gdev, &gpio_devices, list)
1460 1461
		if (gdev->chip && match(gdev->chip, data)) {
			chip = gdev->chip;
1462
			break;
1463
		}
1464

1465 1466 1467 1468
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
J
Jean Delvare 已提交
1469
EXPORT_SYMBOL_GPL(gpiochip_find);
1470

1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
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);
}

1483 1484 1485 1486 1487 1488
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

1489 1490
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
{
1491
	if (!gpiochip->irq.need_valid_mask)
1492 1493
		return 0;

1494
	gpiochip->irq.valid_mask = kcalloc(BITS_TO_LONGS(gpiochip->ngpio),
1495
					   sizeof(long), GFP_KERNEL);
1496
	if (!gpiochip->irq.valid_mask)
1497 1498 1499
		return -ENOMEM;

	/* Assume by default all GPIOs are valid */
1500
	bitmap_fill(gpiochip->irq.valid_mask, gpiochip->ngpio);
1501 1502 1503 1504 1505 1506

	return 0;
}

static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
{
1507 1508
	kfree(gpiochip->irq.valid_mask);
	gpiochip->irq.valid_mask = NULL;
1509 1510 1511 1512 1513 1514
}

static bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
				       unsigned int offset)
{
	/* No mask means all valid */
1515
	if (likely(!gpiochip->irq.valid_mask))
1516
		return true;
1517
	return test_bit(offset, gpiochip->irq.valid_mask);
1518 1519
}

1520
/**
1521
 * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
1522 1523
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
1524 1525 1526
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1527 1528
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
1529
 */
1530 1531
static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
					  struct irq_chip *irqchip,
1532
					  unsigned int parent_irq,
1533
					  irq_flow_handler_t parent_handler)
1534
{
1535 1536
	unsigned int offset;

1537
	if (!gpiochip->irq.domain) {
1538 1539
		chip_err(gpiochip, "called %s before setting up irqchip\n",
			 __func__);
1540 1541 1542
		return;
	}

1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
	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.
		 */
1554 1555
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
1556

1557 1558
		gpiochip->irq.parents = &parent_irq;
		gpiochip->irq.num_parents = 1;
1559
	}
1560 1561

	/* Set the parent IRQ for all affected IRQs */
1562 1563 1564
	for (offset = 0; offset < gpiochip->ngpio; offset++) {
		if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
			continue;
1565
		irq_set_parent(irq_find_mapping(gpiochip->irq.domain, offset),
1566
			       parent_irq);
1567
	}
1568
}
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581

/**
 * gpiochip_set_chained_irqchip() - connects a chained irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
 */
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
				  struct irq_chip *irqchip,
1582
				  unsigned int parent_irq,
1583 1584
				  irq_flow_handler_t parent_handler)
{
1585 1586 1587 1588 1589
	if (gpiochip->irq.threaded) {
		chip_err(gpiochip, "tried to chain a threaded gpiochip\n");
		return;
	}

1590 1591 1592
	gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
				      parent_handler);
}
1593 1594
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);

1595 1596 1597 1598 1599 1600 1601 1602 1603
/**
 * gpiochip_set_nested_irqchip() - connects a nested irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip nested handler to
 * @irqchip: the irqchip to nest to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * nested irqchip
 */
void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
				 struct irq_chip *irqchip,
1604
				 unsigned int parent_irq)
1605 1606 1607 1608 1609 1610
{
	gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
				      NULL);
}
EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);

1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
/**
 * 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.
 */
1621 1622
int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
		     irq_hw_number_t hwirq)
1623 1624
{
	struct gpio_chip *chip = d->host_data;
1625
	int err = 0;
1626

1627 1628 1629
	if (!gpiochip_irqchip_irq_valid(chip, hwirq))
		return -ENXIO;

1630
	irq_set_chip_data(irq, chip);
1631 1632 1633 1634
	/*
	 * This lock class tells lockdep that GPIO irqs are in a different
	 * category than their parents, so it won't report false recursion.
	 */
1635
	irq_set_lockdep_class(irq, chip->irq.lock_key);
1636
	irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
1637
	/* Chips that use nested thread handlers have them marked */
1638
	if (chip->irq.threaded)
1639
		irq_set_nested_thread(irq, 1);
1640
	irq_set_noprobe(irq);
R
Rob Herring 已提交
1641

1642 1643 1644 1645 1646 1647 1648 1649
	if (chip->irq.num_parents == 1)
		err = irq_set_parent(irq, chip->irq.parents[0]);
	else if (chip->irq.map)
		err = irq_set_parent(irq, chip->irq.map[hwirq]);

	if (err < 0)
		return err;

1650 1651 1652 1653
	/*
	 * No set-up of the hardware will happen if IRQ_TYPE_NONE
	 * is passed as default type.
	 */
1654 1655
	if (chip->irq.default_type != IRQ_TYPE_NONE)
		irq_set_irq_type(irq, chip->irq.default_type);
1656 1657 1658

	return 0;
}
1659
EXPORT_SYMBOL_GPL(gpiochip_irq_map);
1660

1661
void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
L
Linus Walleij 已提交
1662
{
1663 1664
	struct gpio_chip *chip = d->host_data;

1665
	if (chip->irq.threaded)
1666
		irq_set_nested_thread(irq, 0);
L
Linus Walleij 已提交
1667 1668 1669
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}
1670
EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
L
Linus Walleij 已提交
1671

1672 1673
static const struct irq_domain_ops gpiochip_domain_ops = {
	.map	= gpiochip_irq_map,
L
Linus Walleij 已提交
1674
	.unmap	= gpiochip_irq_unmap,
1675 1676 1677 1678 1679 1680 1681 1682
	/* 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);

1683
	if (!try_module_get(chip->gpiodev->owner))
1684 1685
		return -ENODEV;

1686
	if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1687 1688 1689
		chip_err(chip,
			"unable to lock HW IRQ %lu for IRQ\n",
			d->hwirq);
1690
		module_put(chip->gpiodev->owner);
1691 1692 1693 1694 1695 1696 1697 1698 1699
		return -EINVAL;
	}
	return 0;
}

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

1700
	gpiochip_unlock_as_irq(chip, d->hwirq);
1701
	module_put(chip->gpiodev->owner);
1702 1703 1704 1705
}

static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
{
1706 1707
	if (!gpiochip_irqchip_irq_valid(chip, offset))
		return -ENXIO;
1708

1709
	return irq_create_mapping(chip->irq.domain, offset);
1710 1711
}

1712 1713 1714
/**
 * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip
 * @gpiochip: the GPIO chip to add the IRQ chip to
1715
 * @lock_key: lockdep class
1716
 */
1717 1718
static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
				struct lock_class_key *lock_key)
1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
{
	struct irq_chip *irqchip = gpiochip->irq.chip;
	const struct irq_domain_ops *ops;
	struct device_node *np;
	unsigned int type;
	unsigned int i;

	if (!irqchip)
		return 0;

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

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

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

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

	gpiochip->to_irq = gpiochip_to_irq;
	gpiochip->irq.default_type = type;
1755
	gpiochip->irq.lock_key = lock_key;
1756 1757 1758 1759 1760 1761 1762

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

	gpiochip->irq.domain = irq_domain_add_simple(np, gpiochip->ngpio,
1763 1764
						     gpiochip->irq.first,
						     ops, gpiochip);
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
	if (!gpiochip->irq.domain)
		return -EINVAL;

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

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

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

	acpi_gpiochip_request_interrupts(gpiochip);

	return 0;
}

1798 1799 1800 1801 1802 1803 1804 1805
/**
 * 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)
{
1806
	unsigned int offset;
L
Linus Walleij 已提交
1807

1808 1809
	acpi_gpiochip_free_interrupts(gpiochip);

1810
	if (gpiochip->irq.chip && gpiochip->irq.parent_handler) {
1811 1812 1813 1814 1815 1816
		struct gpio_irq_chip *irq = &gpiochip->irq;
		unsigned int i;

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

L
Linus Walleij 已提交
1819
	/* Remove all IRQ mappings and delete the domain */
1820
	if (gpiochip->irq.domain) {
1821 1822
		unsigned int irq;

1823 1824 1825
		for (offset = 0; offset < gpiochip->ngpio; offset++) {
			if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
				continue;
1826 1827 1828

			irq = irq_find_mapping(gpiochip->irq.domain, offset);
			irq_dispose_mapping(irq);
1829
		}
1830 1831

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

1834 1835 1836 1837
	if (gpiochip->irq.chip) {
		gpiochip->irq.chip->irq_request_resources = NULL;
		gpiochip->irq.chip->irq_release_resources = NULL;
		gpiochip->irq.chip = NULL;
1838
	}
1839 1840

	gpiochip_irqchip_free_valid_mask(gpiochip);
1841 1842 1843
}

/**
1844
 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
1845 1846 1847 1848 1849
 * @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)
1850 1851
 * @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.
1852
 * @threaded: whether this irqchip uses a nested thread handler
1853
 * @lock_key: lockdep class
1854 1855 1856 1857 1858
 *
 * 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 已提交
1859
 * need to use gpiochip_get_data() to get their local state containers back
1860 1861 1862 1863 1864
 * 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 已提交
1865 1866
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1867 1868
 * need to be open coded.
 */
1869 1870 1871 1872 1873
int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
			     struct irq_chip *irqchip,
			     unsigned int first_irq,
			     irq_flow_handler_t handler,
			     unsigned int type,
1874
			     bool threaded,
1875
			     struct lock_class_key *lock_key)
1876 1877 1878 1879 1880 1881
{
	struct device_node *of_node;

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

1882
	if (!gpiochip->parent) {
1883 1884 1885
		pr_err("missing gpiochip .dev parent pointer\n");
		return -EINVAL;
	}
1886
	gpiochip->irq.threaded = threaded;
1887
	of_node = gpiochip->parent->of_node;
1888 1889
#ifdef CONFIG_OF_GPIO
	/*
1890
	 * If the gpiochip has an assigned OF node this takes precedence
1891 1892
	 * FIXME: get rid of this and use gpiochip->parent->of_node
	 * everywhere
1893 1894 1895 1896
	 */
	if (gpiochip->of_node)
		of_node = gpiochip->of_node;
#endif
1897
	/*
1898
	 * Specifying a default trigger is a terrible idea if DT or ACPI is
1899 1900 1901 1902
	 * used to configure the interrupts, as you may end-up with
	 * conflicting triggers. Tell the user, and reset to NONE.
	 */
	if (WARN(of_node && type != IRQ_TYPE_NONE,
1903
		 "%pOF: Ignoring %d default trigger\n", of_node, type))
1904
		type = IRQ_TYPE_NONE;
1905 1906 1907 1908 1909
	if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
		acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
				 "Ignoring %d default trigger\n", type);
		type = IRQ_TYPE_NONE;
	}
1910

1911
	gpiochip->irq.chip = irqchip;
1912
	gpiochip->irq.handler = handler;
1913
	gpiochip->irq.default_type = type;
1914
	gpiochip->to_irq = gpiochip_to_irq;
1915
	gpiochip->irq.lock_key = lock_key;
1916
	gpiochip->irq.domain = irq_domain_add_simple(of_node,
1917 1918
					gpiochip->ngpio, first_irq,
					&gpiochip_domain_ops, gpiochip);
1919
	if (!gpiochip->irq.domain) {
1920
		gpiochip->irq.chip = NULL;
1921 1922
		return -EINVAL;
	}
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932

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

1934 1935
	acpi_gpiochip_request_interrupts(gpiochip);

1936 1937
	return 0;
}
1938
EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
1939 1940 1941

#else /* CONFIG_GPIOLIB_IRQCHIP */

1942
static inline int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
L
Linus Walleij 已提交
1943
				       struct lock_class_key *key)
1944 1945 1946 1947
{
	return 0;
}

1948
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1949 1950 1951 1952 1953 1954
static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
{
	return 0;
}
static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
{ }
1955 1956 1957

#endif /* CONFIG_GPIOLIB_IRQCHIP */

1958 1959 1960 1961 1962 1963 1964
/**
 * 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)
{
1965
	return pinctrl_gpio_request(chip->gpiodev->base + offset);
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975
}
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)
{
1976
	pinctrl_gpio_free(chip->gpiodev->base + offset);
1977 1978 1979
}
EXPORT_SYMBOL_GPL(gpiochip_generic_free);

1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
/**
 * gpiochip_generic_config() - apply configuration for a pin
 * @chip: the gpiochip owning the GPIO
 * @offset: the offset of the GPIO to apply the configuration
 * @config: the configuration to be applied
 */
int gpiochip_generic_config(struct gpio_chip *chip, unsigned offset,
			    unsigned long config)
{
	return pinctrl_gpio_set_config(chip->gpiodev->base + offset, config);
}
EXPORT_SYMBOL_GPL(gpiochip_generic_config);

1993
#ifdef CONFIG_PINCTRL
1994

1995 1996 1997
/**
 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
1998
 * @pctldev: the pin controller to map to
1999 2000 2001 2002 2003 2004 2005 2006
 * @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;
2007
	struct gpio_device *gdev = chip->gpiodev;
2008 2009 2010 2011
	int ret;

	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
	if (!pin_range) {
2012
		chip_err(chip, "failed to allocate pin ranges\n");
2013 2014 2015 2016 2017 2018 2019
		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;
2020
	pin_range->range.base = gdev->base + gpio_offset;
2021 2022 2023 2024 2025
	pin_range->pctldev = pctldev;

	ret = pinctrl_get_group_pins(pctldev, pin_group,
					&pin_range->range.pins,
					&pin_range->range.npins);
2026 2027
	if (ret < 0) {
		kfree(pin_range);
2028
		return ret;
2029
	}
2030 2031 2032

	pinctrl_add_gpio_range(pctldev, &pin_range->range);

2033 2034
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
2035 2036
		 pinctrl_dev_get_devname(pctldev), pin_group);

2037
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
2038 2039 2040 2041 2042

	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);

2043 2044 2045
/**
 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
T
Thierry Reding 已提交
2046
 * @pinctl_name: the dev_name() of the pin controller to map to
2047 2048
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_offset: the start offset in the pin controller number space
2049 2050
 * @npins: the number of pins from the offset of each pin space (GPIO and
 *	pin controller) to accumulate in this range
T
Thierry Reding 已提交
2051 2052 2053
 *
 * Returns:
 * 0 on success, or a negative error-code on failure.
2054
 */
2055
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
2056
			   unsigned int gpio_offset, unsigned int pin_offset,
2057
			   unsigned int npins)
2058 2059
{
	struct gpio_pin_range *pin_range;
2060
	struct gpio_device *gdev = chip->gpiodev;
2061
	int ret;
2062

2063
	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2064
	if (!pin_range) {
2065
		chip_err(chip, "failed to allocate pin ranges\n");
2066
		return -ENOMEM;
2067 2068
	}

2069
	/* Use local offset as range ID */
2070
	pin_range->range.id = gpio_offset;
2071
	pin_range->range.gc = chip;
2072
	pin_range->range.name = chip->label;
2073
	pin_range->range.base = gdev->base + gpio_offset;
2074
	pin_range->range.pin_base = pin_offset;
2075
	pin_range->range.npins = npins;
L
Linus Walleij 已提交
2076
	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
2077
			&pin_range->range);
2078
	if (IS_ERR(pin_range->pctldev)) {
2079
		ret = PTR_ERR(pin_range->pctldev);
2080
		chip_err(chip, "could not create pin range\n");
2081
		kfree(pin_range);
2082
		return ret;
2083
	}
2084 2085
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
		 gpio_offset, gpio_offset + npins - 1,
2086 2087
		 pinctl_name,
		 pin_offset, pin_offset + npins - 1);
2088

2089
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
2090 2091

	return 0;
2092
}
2093
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2094

2095 2096 2097 2098
/**
 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
 * @chip: the chip to remove all the mappings for
 */
2099 2100 2101
void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
{
	struct gpio_pin_range *pin_range, *tmp;
2102
	struct gpio_device *gdev = chip->gpiodev;
2103

2104
	list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2105 2106 2107
		list_del(&pin_range->node);
		pinctrl_remove_gpio_range(pin_range->pctldev,
				&pin_range->range);
2108
		kfree(pin_range);
2109 2110
	}
}
2111 2112 2113
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);

#endif /* CONFIG_PINCTRL */
2114

2115 2116 2117 2118
/* 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.
 */
2119
static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2120
{
2121
	struct gpio_chip	*chip = desc->gdev->chip;
2122
	int			status;
2123 2124
	unsigned long		flags;

2125 2126
	spin_lock_irqsave(&gpio_lock, flags);

2127
	/* NOTE:  gpio_request() can be called in early boot,
D
David Brownell 已提交
2128
	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2129 2130 2131 2132 2133
	 */

	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
		desc_set_label(desc, label ? : "?");
		status = 0;
2134
	} else {
2135
		status = -EBUSY;
M
Magnus Damm 已提交
2136
		goto done;
D
David Brownell 已提交
2137 2138 2139 2140 2141
	}

	if (chip->request) {
		/* chip->request may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2142
		status = chip->request(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2143 2144 2145 2146 2147
		spin_lock_irqsave(&gpio_lock, flags);

		if (status < 0) {
			desc_set_label(desc, NULL);
			clear_bit(FLAG_REQUESTED, &desc->flags);
2148
			goto done;
D
David Brownell 已提交
2149
		}
2150
	}
2151 2152 2153
	if (chip->get_direction) {
		/* chip->get_direction may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2154
		gpiod_get_direction(desc);
2155 2156
		spin_lock_irqsave(&gpio_lock, flags);
	}
2157 2158 2159 2160 2161
done:
	spin_unlock_irqrestore(&gpio_lock, flags);
	return status;
}

2162 2163 2164
/*
 * This descriptor validation needs to be inserted verbatim into each
 * function taking a descriptor, so we need to use a preprocessor
2165 2166
 * macro to avoid endless duplication. If the desc is NULL it is an
 * optional GPIO and calls should just bail out.
2167 2168
 */
#define VALIDATE_DESC(desc) do { \
2169 2170
	if (!desc) \
		return 0; \
2171 2172 2173 2174
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return PTR_ERR(desc); \
	} \
2175
	if (!desc->gdev) { \
2176
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2177 2178 2179 2180 2181 2182 2183 2184 2185
		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 { \
2186 2187
	if (!desc) \
		return; \
2188 2189 2190 2191
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return; \
	} \
2192
	if (!desc->gdev) { \
2193
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2194 2195 2196 2197 2198 2199 2200 2201 2202
		return; \
	} \
	if (!desc->gdev->chip) { \
		dev_warn(&desc->gdev->dev, \
			 "%s: backing chip is gone\n", __func__); \
		return; \
	} } while (0)


2203
int gpiod_request(struct gpio_desc *desc, const char *label)
2204 2205
{
	int status = -EPROBE_DEFER;
2206
	struct gpio_device *gdev;
2207

2208 2209
	VALIDATE_DESC(desc);
	gdev = desc->gdev;
2210

2211
	if (try_module_get(gdev->owner)) {
2212
		status = gpiod_request_commit(desc, label);
2213
		if (status < 0)
2214
			module_put(gdev->owner);
2215 2216
		else
			get_device(&gdev->dev);
2217 2218
	}

2219
	if (status)
2220
		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2221

2222 2223
	return status;
}
2224

2225
static bool gpiod_free_commit(struct gpio_desc *desc)
2226
{
2227
	bool			ret = false;
2228
	unsigned long		flags;
D
David Brownell 已提交
2229
	struct gpio_chip	*chip;
2230

2231 2232
	might_sleep();

2233
	gpiod_unexport(desc);
D
David Brownell 已提交
2234

2235 2236
	spin_lock_irqsave(&gpio_lock, flags);

2237
	chip = desc->gdev->chip;
D
David Brownell 已提交
2238 2239 2240
	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
		if (chip->free) {
			spin_unlock_irqrestore(&gpio_lock, flags);
2241
			might_sleep_if(chip->can_sleep);
2242
			chip->free(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2243 2244
			spin_lock_irqsave(&gpio_lock, flags);
		}
2245
		desc_set_label(desc, NULL);
2246
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
D
David Brownell 已提交
2247
		clear_bit(FLAG_REQUESTED, &desc->flags);
2248
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2249
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
B
Benoit Parrot 已提交
2250
		clear_bit(FLAG_IS_HOGGED, &desc->flags);
2251 2252
		ret = true;
	}
2253 2254

	spin_unlock_irqrestore(&gpio_lock, flags);
2255 2256 2257
	return ret;
}

2258
void gpiod_free(struct gpio_desc *desc)
2259
{
2260
	if (desc && desc->gdev && gpiod_free_commit(desc)) {
2261
		module_put(desc->gdev->owner);
2262 2263
		put_device(&desc->gdev->dev);
	} else {
2264
		WARN_ON(extra_checks);
2265
	}
2266
}
2267

2268 2269 2270 2271 2272 2273
/**
 * 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.
2274 2275
 * The string returned is the label passed to gpio_request(); if none has been
 * passed it is a meaningless, non-NULL constant.
2276 2277 2278 2279 2280 2281 2282
 *
 * 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)
{
2283
	struct gpio_desc *desc;
2284

2285
	if (offset >= chip->ngpio)
2286
		return NULL;
2287

2288
	desc = &chip->gpiodev->descs[offset];
2289

2290
	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2291
		return NULL;
2292
	return desc->label;
2293 2294 2295
}
EXPORT_SYMBOL_GPL(gpiochip_is_requested);

2296 2297
/**
 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
T
Thierry Reding 已提交
2298 2299
 * @chip: GPIO chip
 * @hwnum: hardware number of the GPIO for which to request the descriptor
2300 2301 2302 2303 2304 2305 2306
 * @label: label for the GPIO
 *
 * Function allows GPIO chip drivers to request and use their own GPIO
 * descriptors via gpiolib API. Difference to gpiod_request() is that this
 * function will not increase reference count of the GPIO chip module. This
 * allows the GPIO chip module to be unloaded as needed (we assume that the
 * GPIO chip driver handles freeing the GPIOs it has requested).
T
Thierry Reding 已提交
2307 2308 2309 2310
 *
 * Returns:
 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
 * code on failure.
2311
 */
2312 2313
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
					    const char *label)
2314
{
2315 2316
	struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
	int err;
2317

2318 2319 2320 2321 2322
	if (IS_ERR(desc)) {
		chip_err(chip, "failed to get GPIO descriptor\n");
		return desc;
	}

2323
	err = gpiod_request_commit(desc, label);
2324 2325
	if (err < 0)
		return ERR_PTR(err);
2326

2327
	return desc;
2328
}
2329
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340

/**
 * 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)
2341
		gpiod_free_commit(desc);
2342
}
2343
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2344

2345 2346
/*
 * Drivers MUST set GPIO direction before making get/set calls.  In
2347 2348 2349 2350 2351 2352 2353 2354
 * 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.
 */

2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
/**
 * 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)
2365 2366 2367 2368
{
	struct gpio_chip	*chip;
	int			status = -EINVAL;

2369 2370
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2371

2372
	if (!chip->get || !chip->direction_input) {
2373 2374
		gpiod_warn(desc,
			"%s: missing get() or direction_input() operations\n",
2375
			__func__);
2376 2377 2378
		return -EIO;
	}

2379
	status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2380 2381
	if (status == 0)
		clear_bit(FLAG_IS_OUT, &desc->flags);
2382

2383
	trace_gpio_direction(desc_to_gpio(desc), 1, status);
2384

2385 2386
	return status;
}
2387
EXPORT_SYMBOL_GPL(gpiod_direction_input);
2388

2389 2390 2391 2392 2393 2394 2395 2396
static int gpio_set_drive_single_ended(struct gpio_chip *gc, unsigned offset,
				       enum pin_config_param mode)
{
	unsigned long config = { PIN_CONF_PACKED(mode, 0) };

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

2397
static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
2398
{
2399
	struct gpio_chip *gc = desc->gdev->chip;
2400
	int val = !!value;
2401
	int ret;
2402

2403
	if (!gc->set || !gc->direction_output) {
2404 2405 2406
		gpiod_warn(desc,
		       "%s: missing set() or direction_output() operations\n",
		       __func__);
2407 2408 2409
		return -EIO;
	}

2410
	ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2411
	if (!ret)
2412
		set_bit(FLAG_IS_OUT, &desc->flags);
2413
	trace_gpio_value(desc_to_gpio(desc), 0, val);
2414 2415
	trace_gpio_direction(desc_to_gpio(desc), 0, ret);
	return ret;
2416
}
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430

/**
 * 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)
{
2431
	VALIDATE_DESC(desc);
2432
	return gpiod_direction_output_raw_commit(desc, value);
2433 2434 2435 2436
}
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);

/**
2437
 * gpiod_direction_output - set the GPIO direction to output
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
 * @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)
{
2450 2451 2452
	struct gpio_chip *gc = desc->gdev->chip;
	int ret;

2453
	VALIDATE_DESC(desc);
2454 2455
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2456 2457
	else
		value = !!value;
2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490

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

	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
		/* First see if we can enable open drain in hardware */
		ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
						  PIN_CONFIG_DRIVE_OPEN_DRAIN);
		if (!ret)
			goto set_output_value;
		/* Emulate open drain by not actively driving the line high */
		if (value)
			return gpiod_direction_input(desc);
	}
	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
		ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
						  PIN_CONFIG_DRIVE_OPEN_SOURCE);
		if (!ret)
			goto set_output_value;
		/* Emulate open source by not actively driving the line low */
		if (!value)
			return gpiod_direction_input(desc);
	} else {
		gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
					    PIN_CONFIG_DRIVE_PUSH_PULL);
	}

set_output_value:
2491
	return gpiod_direction_output_raw_commit(desc, value);
2492
}
2493
EXPORT_SYMBOL_GPL(gpiod_direction_output);
2494

2495
/**
T
Thierry Reding 已提交
2496 2497 2498
 * gpiod_set_debounce - sets @debounce time for a GPIO
 * @desc: descriptor of the GPIO for which to set debounce time
 * @debounce: debounce time in microseconds
2499
 *
T
Thierry Reding 已提交
2500 2501 2502
 * Returns:
 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
 * debounce time.
2503
 */
2504
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2505 2506
{
	struct gpio_chip	*chip;
2507
	unsigned long		config;
2508

2509 2510
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2511
	if (!chip->set || !chip->set_config) {
2512
		gpiod_dbg(desc,
2513
			  "%s: missing set() or set_config() operations\n",
2514
			  __func__);
2515
		return -ENOTSUPP;
2516 2517
	}

2518 2519
	config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
	return chip->set_config(chip, gpio_chip_hwgpio(desc), config);
2520
}
2521
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2522

2523 2524 2525 2526 2527 2528 2529
/**
 * 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)
2530
{
2531
	VALIDATE_DESC(desc);
2532
	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2533
}
2534
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557

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

2558
static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
2559 2560
{
	struct gpio_chip	*chip;
2561
	int offset;
2562
	int value;
2563

2564
	chip = desc->gdev->chip;
2565
	offset = gpio_chip_hwgpio(desc);
2566
	value = chip->get ? chip->get(chip, offset) : -EIO;
2567
	value = value < 0 ? value : !!value;
2568
	trace_gpio_value(desc_to_gpio(desc), 1, value);
2569
	return value;
2570
}
2571

2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
static int gpio_chip_get_multiple(struct gpio_chip *chip,
				  unsigned long *mask, unsigned long *bits)
{
	if (chip->get_multiple) {
		return chip->get_multiple(chip, mask, bits);
	} else if (chip->get) {
		int i, value;

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

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

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

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

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

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

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

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

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

2637
/**
2638 2639
 * gpiod_get_raw_value() - return a gpio's raw value
 * @desc: gpio whose value will be returned
2640
 *
2641
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2642
 * its ACTIVE_LOW status, or negative errno on failure.
2643 2644 2645
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2646
 */
2647
int gpiod_get_raw_value(const struct gpio_desc *desc)
2648
{
2649
	VALIDATE_DESC(desc);
2650
	/* Should be using gpio_get_value_cansleep() */
2651
	WARN_ON(desc->gdev->chip->can_sleep);
2652
	return gpiod_get_raw_value_commit(desc);
2653
}
2654
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2655

2656 2657 2658 2659 2660
/**
 * 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
2661
 * account, or negative errno on failure.
2662 2663 2664 2665 2666
 *
 * 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)
2667
{
2668
	int value;
2669 2670

	VALIDATE_DESC(desc);
2671
	/* Should be using gpio_get_value_cansleep() */
2672
	WARN_ON(desc->gdev->chip->can_sleep);
2673

2674
	value = gpiod_get_raw_value_commit(desc);
2675 2676 2677
	if (value < 0)
		return value;

2678 2679 2680 2681
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
2682
}
2683
EXPORT_SYMBOL_GPL(gpiod_get_value);
2684

2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729
/**
 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
 * else an error code.
 *
 * This function should be called from contexts where we cannot sleep,
 * and it will complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_raw_array_value(unsigned int array_size,
			      struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, false, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);

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

2730
/*
2731
 *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
2732
 * @desc: gpio descriptor whose state need to be set.
2733
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2734
 */
2735
static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
2736 2737
{
	int err = 0;
2738
	struct gpio_chip *chip = desc->gdev->chip;
2739 2740
	int offset = gpio_chip_hwgpio(desc);

2741
	if (value) {
2742
		err = chip->direction_input(chip, offset);
2743
		if (!err)
2744
			clear_bit(FLAG_IS_OUT, &desc->flags);
2745
	} else {
2746
		err = chip->direction_output(chip, offset, 0);
2747
		if (!err)
2748
			set_bit(FLAG_IS_OUT, &desc->flags);
2749
	}
2750
	trace_gpio_direction(desc_to_gpio(desc), value, err);
2751
	if (err < 0)
2752 2753 2754
		gpiod_err(desc,
			  "%s: Error in set_value for open drain err %d\n",
			  __func__, err);
2755 2756
}

2757
/*
2758 2759
 *  _gpio_set_open_source_value() - Set the open source gpio's value.
 * @desc: gpio descriptor whose state need to be set.
2760
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2761
 */
2762
static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
2763 2764
{
	int err = 0;
2765
	struct gpio_chip *chip = desc->gdev->chip;
2766 2767
	int offset = gpio_chip_hwgpio(desc);

2768
	if (value) {
2769
		err = chip->direction_output(chip, offset, 1);
2770
		if (!err)
2771
			set_bit(FLAG_IS_OUT, &desc->flags);
2772
	} else {
2773
		err = chip->direction_input(chip, offset);
2774
		if (!err)
2775
			clear_bit(FLAG_IS_OUT, &desc->flags);
2776
	}
2777
	trace_gpio_direction(desc_to_gpio(desc), !value, err);
2778
	if (err < 0)
2779 2780 2781
		gpiod_err(desc,
			  "%s: Error in set_value for open source err %d\n",
			  __func__, err);
2782 2783
}

2784
static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
2785 2786 2787
{
	struct gpio_chip	*chip;

2788
	chip = desc->gdev->chip;
2789
	trace_gpio_value(desc_to_gpio(desc), 0, value);
2790
	chip->set(chip, gpio_chip_hwgpio(desc), value);
2791 2792
}

2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807
/*
 * 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 {
2808 2809 2810 2811 2812
		unsigned int i;

		/* set outputs if the corresponding mask bit is set */
		for_each_set_bit(i, mask, chip->ngpio)
			chip->set(chip, i, test_bit(i, bits));
2813 2814 2815
	}
}

2816 2817 2818 2819
void gpiod_set_array_value_complex(bool raw, bool can_sleep,
				   unsigned int array_size,
				   struct gpio_desc **desc_array,
				   int *value_array)
2820 2821 2822 2823
{
	int i = 0;

	while (i < array_size) {
2824
		struct gpio_chip *chip = desc_array[i]->gdev->chip;
2825 2826 2827 2828
		unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
		unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
		int count = 0;

D
Daniel Lockyer 已提交
2829
		if (!can_sleep)
2830
			WARN_ON(chip->can_sleep);
D
Daniel Lockyer 已提交
2831

2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
		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
			 */
2845
			if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
2846
				gpio_set_open_drain_value_commit(desc, value);
2847
			} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
2848
				gpio_set_open_source_value_commit(desc, value);
2849 2850
			} else {
				__set_bit(hwgpio, mask);
D
Daniel Lockyer 已提交
2851
				if (value)
2852
					__set_bit(hwgpio, bits);
D
Daniel Lockyer 已提交
2853
				else
2854 2855 2856 2857
					__clear_bit(hwgpio, bits);
				count++;
			}
			i++;
2858 2859
		} while ((i < array_size) &&
			 (desc_array[i]->gdev->chip == chip));
2860
		/* push collected bits to outputs */
D
Daniel Lockyer 已提交
2861
		if (count != 0)
2862 2863 2864 2865
			gpio_chip_set_multiple(chip, mask, bits);
	}
}

2866
/**
2867 2868
 * gpiod_set_raw_value() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
2869 2870
 * @value: value to assign
 *
2871 2872 2873 2874 2875
 * 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.
2876
 */
2877
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2878
{
2879
	VALIDATE_DESC_VOID(desc);
2880
	/* Should be using gpiod_set_value_cansleep() */
2881
	WARN_ON(desc->gdev->chip->can_sleep);
2882
	gpiod_set_raw_value_commit(desc, value);
2883
}
2884
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2885 2886

/**
2887 2888 2889 2890
 * gpiod_set_value() - assign a gpio's value
 * @desc: gpio whose value will be assigned
 * @value: value to assign
 *
2891 2892
 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
 * OPEN_DRAIN and OPEN_SOURCE flags into account.
2893
 *
2894 2895
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2896
 */
2897
void gpiod_set_value(struct gpio_desc *desc, int value)
2898
{
2899
	VALIDATE_DESC_VOID(desc);
2900
	/* Should be using gpiod_set_value_cansleep() */
2901
	WARN_ON(desc->gdev->chip->can_sleep);
2902 2903
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2904 2905 2906 2907 2908 2909
	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
		gpio_set_open_drain_value_commit(desc, value);
	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
		gpio_set_open_source_value_commit(desc, value);
	else
		gpiod_set_raw_value_commit(desc, value);
2910
}
2911
EXPORT_SYMBOL_GPL(gpiod_set_value);
2912

2913
/**
2914
 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
2915 2916 2917 2918 2919 2920 2921 2922 2923 2924
 * @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.
 */
2925
void gpiod_set_raw_array_value(unsigned int array_size,
2926 2927 2928 2929
			 struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return;
2930 2931
	gpiod_set_array_value_complex(true, false, array_size, desc_array,
				      value_array);
2932
}
2933
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
2934 2935

/**
2936
 * gpiod_set_array_value() - assign values to an array of GPIOs
2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
 * @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.
 */
2947 2948
void gpiod_set_array_value(unsigned int array_size,
			   struct gpio_desc **desc_array, int *value_array)
2949 2950 2951
{
	if (!desc_array)
		return;
2952 2953
	gpiod_set_array_value_complex(false, false, array_size, desc_array,
				      value_array);
2954
}
2955
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
2956

2957
/**
2958 2959
 * gpiod_cansleep() - report whether gpio value access may sleep
 * @desc: gpio to check
2960 2961
 *
 */
2962
int gpiod_cansleep(const struct gpio_desc *desc)
2963
{
2964 2965
	VALIDATE_DESC(desc);
	return desc->gdev->chip->can_sleep;
2966
}
2967
EXPORT_SYMBOL_GPL(gpiod_cansleep);
2968

D
David Brownell 已提交
2969
/**
2970 2971
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
D
David Brownell 已提交
2972
 *
2973 2974
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
D
David Brownell 已提交
2975
 */
2976
int gpiod_to_irq(const struct gpio_desc *desc)
D
David Brownell 已提交
2977
{
2978 2979
	struct gpio_chip *chip;
	int offset;
D
David Brownell 已提交
2980

2981 2982 2983 2984 2985
	/*
	 * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
	 * requires this function to not return zero on an invalid descriptor
	 * but rather a negative error number.
	 */
2986
	if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
2987 2988
		return -EINVAL;

2989
	chip = desc->gdev->chip;
2990
	offset = gpio_chip_hwgpio(desc);
2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
	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 已提交
3001
}
3002
EXPORT_SYMBOL_GPL(gpiod_to_irq);
D
David Brownell 已提交
3003

3004
/**
3005
 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
3006 3007
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
3008 3009
 *
 * This is used directly by GPIO drivers that want to lock down
3010
 * a certain GPIO line to be used for IRQs.
3011
 */
3012
int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
3013
{
3014 3015 3016 3017 3018 3019
	struct gpio_desc *desc;

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

3020 3021 3022 3023 3024
	/*
	 * If it's fast: flush the direction setting if something changed
	 * behind our back
	 */
	if (!chip->can_sleep && chip->get_direction) {
3025 3026 3027 3028 3029 3030 3031
		int dir = chip->get_direction(chip, offset);

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

3033
	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
3034
		chip_err(chip,
3035 3036 3037 3038 3039
			  "%s: tried to flag a GPIO set as output for IRQ\n",
			  __func__);
		return -EIO;
	}

3040
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
3041 3042 3043 3044 3045 3046 3047 3048 3049

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

3050
	return 0;
3051
}
3052
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
3053

3054
/**
3055
 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
3056 3057
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
3058 3059 3060
 *
 * This is used directly by GPIO drivers that want to indicate
 * that a certain GPIO is no longer used exclusively for IRQ.
3061
 */
3062
void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
3063
{
3064 3065 3066 3067
	struct gpio_desc *desc;

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

3070 3071 3072 3073 3074
	clear_bit(FLAG_USED_AS_IRQ, &desc->flags);

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

3078 3079 3080 3081 3082 3083 3084 3085 3086
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);

3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104
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);

3105 3106 3107 3108 3109
bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
{
	if (offset >= chip->ngpio)
		return false;

A
Andrew Jeffery 已提交
3110
	return !test_bit(FLAG_SLEEP_MAY_LOSE_VALUE,
3111 3112 3113 3114
			 &chip->gpiodev->descs[offset].flags);
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);

3115 3116 3117 3118 3119
/**
 * 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
3120
 * its ACTIVE_LOW status, or negative errno on failure.
3121 3122
 *
 * This function is to be called from contexts that can sleep.
3123
 */
3124
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
3125 3126
{
	might_sleep_if(extra_checks);
3127
	VALIDATE_DESC(desc);
3128
	return gpiod_get_raw_value_commit(desc);
3129
}
3130
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
3131

3132 3133 3134 3135 3136
/**
 * 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
3137
 * account, or negative errno on failure.
3138 3139 3140 3141
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
3142
{
3143
	int value;
3144 3145

	might_sleep_if(extra_checks);
3146
	VALIDATE_DESC(desc);
3147
	value = gpiod_get_raw_value_commit(desc);
3148 3149 3150
	if (value < 0)
		return value;

3151 3152 3153
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

3154
	return value;
3155
}
3156
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
3157

3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204
/**
 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
 * else an error code.
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
				       struct gpio_desc **desc_array,
				       int *value_array)
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, true, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);

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

3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215
/**
 * 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)
3216
{
3217
	might_sleep_if(extra_checks);
3218
	VALIDATE_DESC_VOID(desc);
3219
	gpiod_set_raw_value_commit(desc, value);
3220
}
3221
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
3222

3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233
/**
 * 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)
3234 3235
{
	might_sleep_if(extra_checks);
3236
	VALIDATE_DESC_VOID(desc);
3237 3238
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
3239
	gpiod_set_raw_value_commit(desc, value);
3240
}
3241
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
3242

3243
/**
3244
 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
3245 3246 3247 3248 3249 3250 3251 3252 3253
 * @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.
 */
3254 3255 3256
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
					struct gpio_desc **desc_array,
					int *value_array)
3257 3258 3259 3260
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3261 3262
	gpiod_set_array_value_complex(true, true, array_size, desc_array,
				      value_array);
3263
}
3264
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
3265

3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282
/**
 * gpiod_add_lookup_tables() - register GPIO device consumers
 * @tables: list of tables of consumers to register
 * @n: number of tables in the list
 */
void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n)
{
	unsigned int i;

	mutex_lock(&gpio_lookup_lock);

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

	mutex_unlock(&gpio_lookup_lock);
}

3283
/**
3284
 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
3285 3286 3287 3288 3289 3290 3291 3292 3293
 * @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.
 */
3294 3295 3296
void gpiod_set_array_value_cansleep(unsigned int array_size,
				    struct gpio_desc **desc_array,
				    int *value_array)
3297 3298 3299 3300
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3301 3302
	gpiod_set_array_value_complex(false, true, array_size, desc_array,
				      value_array);
3303
}
3304
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
3305

3306
/**
3307 3308
 * gpiod_add_lookup_table() - register GPIO device consumers
 * @table: table of consumers to register
3309
 */
3310
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
3311 3312 3313
{
	mutex_lock(&gpio_lookup_lock);

3314
	list_add_tail(&table->list, &gpio_lookup_list);
3315 3316 3317

	mutex_unlock(&gpio_lookup_lock);
}
3318
EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
3319

3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331
/**
 * 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);
}
3332
EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
3333

3334
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
3335 3336
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
3337
	struct gpiod_lookup_table *table;
3338 3339 3340

	mutex_lock(&gpio_lookup_lock);

3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358
	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;
3359

3360 3361 3362 3363
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
3364

3365 3366 3367 3368
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
				    unsigned int idx,
				    enum gpio_lookup_flags *flags)
{
3369
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
3370 3371
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
3372

3373 3374 3375
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
3376

3377 3378
	for (p = &table->table[0]; p->chip_label; p++) {
		struct gpio_chip *chip;
3379

3380
		/* idx must always match exactly */
3381 3382 3383
		if (p->idx != idx)
			continue;

3384 3385 3386
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
3387

3388
		chip = find_chip_by_name(p->chip_label);
3389

3390
		if (!chip) {
3391 3392 3393
			dev_err(dev, "cannot find GPIO chip %s\n",
				p->chip_label);
			return ERR_PTR(-ENODEV);
3394
		}
3395

3396
		if (chip->ngpio <= p->chip_hwnum) {
3397 3398 3399 3400
			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);
3401 3402
		}

3403
		desc = gpiochip_get_desc(chip, p->chip_hwnum);
3404
		*flags = p->flags;
3405

3406
		return desc;
3407 3408 3409 3410 3411
	}

	return desc;
}

3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426
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);
3427
		if (ret > 0)
3428 3429
			break;
	}
3430
	return ret ? ret : -ENOENT;
3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475
}

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

3476
/**
3477
 * gpiod_get - obtain a GPIO for a given GPIO function
3478
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3479
 * @con_id:	function within the GPIO consumer
3480
 * @flags:	optional GPIO initialization flags
3481 3482
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
3483
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3484
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3485
 */
3486
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3487
					 enum gpiod_flags flags)
3488
{
3489
	return gpiod_get_index(dev, con_id, 0, flags);
3490
}
3491
EXPORT_SYMBOL_GPL(gpiod_get);
3492

3493 3494 3495 3496
/**
 * 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
3497
 * @flags: optional GPIO initialization flags
3498 3499 3500 3501 3502
 *
 * 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.
 */
3503
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3504 3505
						  const char *con_id,
						  enum gpiod_flags flags)
3506
{
3507
	return gpiod_get_index_optional(dev, con_id, 0, flags);
3508
}
3509
EXPORT_SYMBOL_GPL(gpiod_get_optional);
3510

B
Benoit Parrot 已提交
3511 3512 3513 3514 3515

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
3516 3517
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
B
Benoit Parrot 已提交
3518 3519 3520 3521 3522 3523
 * @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.
 */
3524
int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
3525
		unsigned long lflags, enum gpiod_flags dflags)
B
Benoit Parrot 已提交
3526 3527 3528
{
	int status;

3529 3530
	if (lflags & GPIO_ACTIVE_LOW)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
3531

3532 3533
	if (lflags & GPIO_OPEN_DRAIN)
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545
	else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) {
		/*
		 * This enforces open drain mode from the consumer side.
		 * This is necessary for some busses like I2C, but the lookup
		 * should *REALLY* have specified them as open drain in the
		 * first place, so print a little warning here.
		 */
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
		gpiod_warn(desc,
			   "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n");
	}

3546 3547
	if (lflags & GPIO_OPEN_SOURCE)
		set_bit(FLAG_OPEN_SOURCE, &desc->flags);
A
Andrew Jeffery 已提交
3548 3549
	if (lflags & GPIO_SLEEP_MAY_LOSE_VALUE)
		set_bit(FLAG_SLEEP_MAY_LOSE_VALUE, &desc->flags);
3550

B
Benoit Parrot 已提交
3551 3552 3553 3554 3555 3556 3557 3558 3559
	/* 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,
3560
				!!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
B
Benoit Parrot 已提交
3561 3562 3563 3564 3565 3566
	else
		status = gpiod_direction_input(desc);

	return status;
}

3567 3568
/**
 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
3569
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3570 3571
 * @con_id:	function within the GPIO consumer
 * @idx:	index of the GPIO to obtain in the consumer
3572
 * @flags:	optional GPIO initialization flags
3573 3574 3575 3576
 *
 * This variant of gpiod_get() allows to access GPIOs other than the first
 * defined one for functions that define several GPIOs.
 *
3577 3578
 * 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
3579
 * occurred while trying to acquire the GPIO.
3580
 */
3581
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
3582
					       const char *con_id,
3583 3584
					       unsigned int idx,
					       enum gpiod_flags flags)
3585
{
3586
	struct gpio_desc *desc = NULL;
3587
	int status;
3588
	enum gpio_lookup_flags lookupflags = 0;
3589 3590 3591

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

3592 3593 3594 3595 3596 3597 3598
	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");
3599
			desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
3600
		}
3601 3602 3603 3604 3605 3606
	}

	/*
	 * 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.
	 */
3607
	if (!desc || desc == ERR_PTR(-ENOENT)) {
3608
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3609
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
3610 3611 3612
	}

	if (IS_ERR(desc)) {
3613
		dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
3614 3615 3616 3617 3618 3619 3620
		return desc;
	}

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

3621
	status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
3622 3623 3624 3625 3626 3627
	if (status < 0) {
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
		gpiod_put(desc);
		return ERR_PTR(status);
	}

3628 3629
	return desc;
}
3630
EXPORT_SYMBOL_GPL(gpiod_get_index);
3631

3632 3633 3634 3635
/**
 * 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
3636
 * @index:	index of the GPIO to obtain in the consumer
3637
 * @dflags:	GPIO initialization flags
T
Thierry Reding 已提交
3638
 * @label:	label to attach to the requested GPIO
3639 3640 3641 3642 3643 3644 3645 3646
 *
 * 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.
 *
T
Thierry Reding 已提交
3647
 * Returns:
3648
 * On successful request the GPIO pin is configured in accordance with
3649 3650
 * provided @dflags.
 *
3651 3652 3653
 * In case of error an ERR_PTR() is returned.
 */
struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
3654
					 const char *propname, int index,
3655 3656
					 enum gpiod_flags dflags,
					 const char *label)
3657 3658
{
	struct gpio_desc *desc = ERR_PTR(-ENODEV);
3659
	unsigned long lflags = 0;
3660
	bool active_low = false;
3661
	bool single_ended = false;
3662
	bool open_drain = false;
3663 3664 3665 3666 3667 3668 3669 3670
	int ret;

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

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

3671 3672
		desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname,
						index, &flags);
3673
		if (!IS_ERR(desc)) {
3674
			active_low = flags & OF_GPIO_ACTIVE_LOW;
3675
			single_ended = flags & OF_GPIO_SINGLE_ENDED;
3676
			open_drain = flags & OF_GPIO_OPEN_DRAIN;
3677
		}
3678 3679 3680
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

3681
		desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
3682
		if (!IS_ERR(desc)) {
3683
			active_low = info.polarity == GPIO_ACTIVE_LOW;
3684 3685 3686 3687
			ret = acpi_gpio_update_gpiod_flags(&dflags, info.flags);
			if (ret)
				pr_debug("Override GPIO initialization flags\n");
		}
3688 3689 3690 3691 3692
	}

	if (IS_ERR(desc))
		return desc;

3693
	ret = gpiod_request(desc, label);
3694 3695 3696
	if (ret)
		return ERR_PTR(ret);

3697
	if (active_low)
3698
		lflags |= GPIO_ACTIVE_LOW;
3699

3700
	if (single_ended) {
3701
		if (open_drain)
3702
			lflags |= GPIO_OPEN_DRAIN;
3703
		else
3704 3705 3706 3707 3708 3709 3710
			lflags |= GPIO_OPEN_SOURCE;
	}

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

3713 3714 3715 3716
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

3717 3718 3719 3720 3721 3722
/**
 * 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
3723
 * @flags: optional GPIO initialization flags
3724 3725 3726 3727 3728
 *
 * 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.
 */
3729
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3730
							const char *con_id,
3731 3732
							unsigned int index,
							enum gpiod_flags flags)
3733 3734 3735
{
	struct gpio_desc *desc;

3736
	desc = gpiod_get_index(dev, con_id, index, flags);
3737 3738 3739 3740 3741 3742 3743
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
3744
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3745

B
Benoit Parrot 已提交
3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766
/**
 * gpiod_hog - Hog the specified GPIO desc given the provided flags
 * @desc:	gpio whose value will be assigned
 * @name:	gpio line name
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
 * @dflags:	gpiod_flags - optional GPIO initialization flags
 */
int gpiod_hog(struct gpio_desc *desc, const char *name,
	      unsigned long lflags, enum gpiod_flags dflags)
{
	struct gpio_chip *chip;
	struct gpio_desc *local_desc;
	int hwnum;
	int status;

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

	local_desc = gpiochip_request_own_desc(chip, hwnum, name);
	if (IS_ERR(local_desc)) {
3767 3768 3769 3770
		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 已提交
3771 3772
	}

3773
	status = gpiod_configure_flags(desc, name, lflags, dflags);
B
Benoit Parrot 已提交
3774
	if (status < 0) {
3775 3776
		pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
B
Benoit Parrot 已提交
3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803
		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++) {
3804 3805
		if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
B
Benoit Parrot 已提交
3806 3807 3808
	}
}

3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874
/**
 * 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);

3875 3876 3877 3878 3879 3880 3881 3882 3883
/**
 * 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);
3884
}
3885
EXPORT_SYMBOL_GPL(gpiod_put);
3886

3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901
/**
 * 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);

3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916
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);
3917 3918 3919
	} else {
		gpiolib_initialized = true;
		gpiochip_setup_devs();
3920 3921 3922 3923 3924
	}
	return ret;
}
core_initcall(gpiolib_dev_init);

3925 3926
#ifdef CONFIG_DEBUG_FS

3927
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
3928 3929
{
	unsigned		i;
3930 3931 3932
	struct gpio_chip	*chip = gdev->chip;
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
3933
	int			is_out;
3934
	int			is_irq;
3935

3936
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
3937 3938 3939 3940 3941
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
3942
			continue;
3943
		}
3944

3945
		gpiod_get_direction(gdesc);
3946
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
3947
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
3948 3949
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
3950 3951 3952
			is_out ? "out" : "in ",
			chip->get
				? (chip->get(chip, i) ? "hi" : "lo")
3953 3954
				: "?  ",
			is_irq ? "IRQ" : "   ");
3955 3956 3957 3958
		seq_printf(s, "\n");
	}
}

3959
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
3960
{
3961
	unsigned long flags;
3962
	struct gpio_device *gdev = NULL;
3963
	loff_t index = *pos;
3964

3965
	s->private = "";
3966

3967
	spin_lock_irqsave(&gpio_lock, flags);
3968
	list_for_each_entry(gdev, &gpio_devices, list)
3969 3970
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
3971
			return gdev;
3972
		}
3973
	spin_unlock_irqrestore(&gpio_lock, flags);
3974

3975
	return NULL;
3976 3977 3978 3979
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
3980
	unsigned long flags;
3981
	struct gpio_device *gdev = v;
3982 3983
	void *ret = NULL;

3984
	spin_lock_irqsave(&gpio_lock, flags);
3985
	if (list_is_last(&gdev->list, &gpio_devices))
3986 3987
		ret = NULL;
	else
3988
		ret = list_entry(gdev->list.next, struct gpio_device, list);
3989
	spin_unlock_irqrestore(&gpio_lock, flags);
3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002

	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)
{
4003 4004 4005 4006 4007 4008 4009 4010 4011
	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;
	}
4012

4013 4014
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
4015
		   gdev->base, gdev->base + gdev->ngpio - 1);
4016 4017 4018 4019 4020
	parent = chip->parent;
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
4021 4022 4023 4024 4025 4026 4027 4028 4029
	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
4030
		gpiolib_dbg_show(s, gdev);
4031

4032 4033 4034
	return 0;
}

4035 4036 4037 4038 4039 4040 4041
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

4042 4043
static int gpiolib_open(struct inode *inode, struct file *file)
{
4044
	return seq_open(file, &gpiolib_seq_ops);
4045 4046
}

4047
static const struct file_operations gpiolib_operations = {
4048
	.owner		= THIS_MODULE,
4049 4050 4051
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
4052
	.release	= seq_release,
4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064
};

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