gpiolib.c 100.3 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 75

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

79
static bool gpiolib_initialized;
80

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

86
/**
T
Thierry Reding 已提交
87 88 89 90 91 92
 * 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.
93
 */
94
struct gpio_desc *gpio_to_desc(unsigned gpio)
95
{
96
	struct gpio_device *gdev;
97 98 99 100
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

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

	spin_unlock_irqrestore(&gpio_lock, flags);

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

114
	return NULL;
115
}
116
EXPORT_SYMBOL_GPL(gpio_to_desc);
117

118
/**
T
Thierry Reding 已提交
119 120 121 122 123 124 125 126
 * 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.
127
 */
128 129
struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
				    u16 hwnum)
130
{
131 132 133
	struct gpio_device *gdev = chip->gpiodev;

	if (hwnum >= gdev->ngpio)
134
		return ERR_PTR(-EINVAL);
135

136
	return &gdev->descs[hwnum];
137
}
138 139

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


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

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

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

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

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

206 207
	chip = gpiod_to_chip(desc);
	offset = gpio_chip_hwgpio(desc);
208 209 210 211

	if (!chip->get_direction)
		return status;

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

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

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

243 244 245 246 247
	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;
248 249
	}

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

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

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

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

	spin_lock_irqsave(&gpio_lock, flags);

284
	list_for_each_entry(gdev, &gpio_devices, list) {
285 286
		int i;

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

290
			if (!desc->name || !name)
291 292
				continue;

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

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

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

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

	return 0;
}

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

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

362 363 364 365 366 367 368 369 370 371 372
static long linehandle_ioctl(struct file *filep, unsigned int cmd,
			     unsigned long arg)
{
	struct linehandle_state *lh = filep->private_data;
	void __user *ip = (void __user *)arg;
	struct gpiohandle_data ghd;
	int i;

	if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
		int val;

373 374
		memset(&ghd, 0, sizeof(ghd));

375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
		/* TODO: check if descriptors are really input */
		for (i = 0; i < lh->numdescs; i++) {
			val = gpiod_get_value_cansleep(lh->descs[i]);
			if (val < 0)
				return val;
			ghd.values[i] = val;
		}

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

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

		/* TODO: check if descriptors are really output */
		if (copy_from_user(&ghd, ip, sizeof(ghd)))
			return -EFAULT;

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

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

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

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

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

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

static int linehandle_create(struct gpio_device *gdev, void __user *ip)
{
	struct gpiohandle_request handlereq;
	struct linehandle_state *lh;
445
	struct file *file;
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
	int fd, i, ret;

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

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

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

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

476 477 478 479 480
		if (offset >= gdev->ngpio) {
			ret = -EINVAL;
			goto out_free_descs;
		}

481 482 483 484 485 486
		/* Return an error if a unknown flag is set */
		if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) {
			ret = -EINVAL;
			goto out_free_descs;
		}

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
		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);
	}
518 519
	/* Let i point at the last handle */
	i--;
520 521
	lh->numdescs = handlereq.lines;

522
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
523 524 525 526 527
	if (fd < 0) {
		ret = fd;
		goto out_free_descs;
	}

528 529 530 531 532 533 534 535 536
	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;
	}

537
	handlereq.fd = fd;
538
	if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
539 540 541 542 543 544 545
		/*
		 * 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;
546
	}
547

548 549
	fd_install(fd, file);

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

	return 0;

555 556
out_put_unused_fd:
	put_unused_fd(fd);
557 558 559 560 561 562 563 564 565 566
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;
}

567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
/*
 * 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;
};

594 595 596 597
#define GPIOEVENT_REQUEST_VALID_FLAGS \
	(GPIOEVENT_REQUEST_RISING_EDGE | \
	GPIOEVENT_REQUEST_FALLING_EDGE)

598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 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
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;

685 686
		memset(&ghd, 0, sizeof(ghd));

687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
		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
};

720
static irqreturn_t lineevent_irq_thread(int irq, void *p)
721 722 723
{
	struct lineevent_state *le = p;
	struct gpioevent_data ge;
724
	int ret, level;
725 726

	ge.timestamp = ktime_get_real_ns();
727
	level = gpiod_get_value_cansleep(le->desc);
728

729 730
	if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
	    && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
731 732 733 734 735 736
		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;
737
	} else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE && level) {
738 739
		/* Emit low-to-high event */
		ge.id = GPIOEVENT_EVENT_RISING_EDGE;
740
	} else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE && !level) {
741 742
		/* Emit high-to-low event */
		ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
743 744
	} else {
		return IRQ_NONE;
745 746 747 748 749 750 751 752 753 754 755 756 757 758
	}

	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;
759
	struct file *file;
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
	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;

791 792 793 794 795
	if (offset >= gdev->ngpio) {
		ret = -EINVAL;
		goto out_free_label;
	}

796 797 798 799 800 801 802
	/* 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;
	}

803 804 805 806 807 808 809 810 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
	/* 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;

854
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
855 856 857 858 859
	if (fd < 0) {
		ret = fd;
		goto out_free_irq;
	}

860 861 862 863 864 865 866 867 868
	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;
	}

869
	eventreq.fd = fd;
870
	if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
871 872 873 874 875 876 877
		/*
		 * 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;
878
	}
879

880 881
	fd_install(fd, file);

882 883
	return 0;

884 885
out_put_unused_fd:
	put_unused_fd(fd);
886 887 888 889 890 891 892 893 894 895 896 897
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 已提交
898
/*
899 900 901 902 903 904
 * 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;
905
	void __user *ip = (void __user *)arg;
906 907 908 909 910

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

911
	/* Fill in the struct and pass to userspace */
912
	if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
913 914
		struct gpiochip_info chipinfo;

915 916
		memset(&chipinfo, 0, sizeof(chipinfo));

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

		/*
		 * Userspace only need to know that the kernel is using
		 * this GPIO so it can't use it.
		 */
		lineinfo.flags = 0;
957 958 959 960 961
		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))
962
			lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
963
		if (test_bit(FLAG_IS_OUT, &desc->flags))
964
			lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
965
		if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
966
			lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
967
		if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
968
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
969
		if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
970 971 972 973 974
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;

		if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
			return -EFAULT;
		return 0;
975 976
	} else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
		return linehandle_create(gdev, ip);
977 978
	} else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
		return lineevent_create(gdev, ip);
979 980 981 982
	}
	return -EINVAL;
}

983 984 985 986 987 988 989 990
#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

991 992 993 994 995 996 997 998 999 1000 1001 1002
/**
 * 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 */
1003
	if (!gdev->chip)
1004 1005 1006
		return -ENODEV;
	get_device(&gdev->dev);
	filp->private_data = gdev;
1007 1008

	return nonseekable_open(inode, filp);
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
}

/**
 * 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,
1031
	.llseek = no_llseek,
1032
	.unlocked_ioctl = gpio_ioctl,
1033 1034 1035
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
1036 1037
};

1038 1039 1040 1041 1042 1043
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);
1044 1045
	kfree(gdev->label);
	kfree(gdev->descs);
1046
	kfree(gdev);
1047 1048
}

1049 1050 1051 1052 1053 1054 1055
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);
1056 1057

	status = cdev_device_add(&gdev->chrdev, &gdev->dev);
1058
	if (status)
1059 1060 1061 1062
		return status;

	chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
		 MAJOR(gpio_devt), gdev->id);
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076

	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:
1077
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
	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);
	}
}

1094
/**
1095
 * gpiochip_add_data() - register a gpio_chip
1096
 * @chip: the chip to register, with chip->base initialized
T
Thierry Reding 已提交
1097
 * @data: driver-private data associated with this chip
1098
 *
T
Thierry Reding 已提交
1099
 * Context: potentially before irqs will work
1100
 *
1101
 * When gpiochip_add_data() is called very early during boot, so that GPIOs
1102
 * can be freely used, the chip->parent device must be registered before
D
David Brownell 已提交
1103 1104 1105
 * the gpio framework's arch_initcall().  Otherwise sysfs initialization
 * for GPIOs will fail rudely.
 *
1106 1107 1108
 * gpiochip_add_data() must only be called after gpiolib initialization,
 * ie after core_initcall().
 *
1109 1110
 * If chip->base is negative, this requests dynamic assignment of
 * a range of valid GPIOs.
T
Thierry Reding 已提交
1111 1112 1113 1114 1115
 *
 * 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.
1116
 */
1117
int gpiochip_add_data(struct gpio_chip *chip, void *data)
1118 1119 1120
{
	unsigned long	flags;
	int		status = 0;
1121
	unsigned	i;
1122
	int		base = chip->base;
1123
	struct gpio_device *gdev;
1124

1125 1126 1127 1128
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
1129
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1130
	if (!gdev)
1131
		return -ENOMEM;
1132
	gdev->dev.bus = &gpio_bus_type;
1133 1134 1135 1136 1137
	gdev->chip = chip;
	chip->gpiodev = gdev;
	if (chip->parent) {
		gdev->dev.parent = chip->parent;
		gdev->dev.of_node = chip->parent->of_node;
1138 1139
	}

1140 1141
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
1142 1143
	if (chip->of_node)
		gdev->dev.of_node = chip->of_node;
1144
#endif
1145

1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
	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;
1161

1162
	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1163
	if (!gdev->descs) {
1164 1165 1166 1167
		status = -ENOMEM;
		goto err_free_gdev;
	}

1168 1169
	if (chip->ngpio == 0) {
		chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1170
		status = -EINVAL;
1171
		goto err_free_descs;
1172
	}
1173 1174

	if (chip->label)
1175
		gdev->label = kstrdup(chip->label, GFP_KERNEL);
1176
	else
1177
		gdev->label = kstrdup("unknown", GFP_KERNEL);
1178 1179
	if (!gdev->label) {
		status = -ENOMEM;
1180
		goto err_free_descs;
1181 1182
	}

1183
	gdev->ngpio = chip->ngpio;
1184
	gdev->data = data;
1185

1186 1187
	spin_lock_irqsave(&gpio_lock, flags);

1188 1189 1190 1191 1192 1193 1194
	/*
	 * 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.
	 */
1195 1196 1197 1198
	if (base < 0) {
		base = gpiochip_find_base(chip->ngpio);
		if (base < 0) {
			status = base;
1199
			spin_unlock_irqrestore(&gpio_lock, flags);
1200
			goto err_free_label;
1201
		}
1202 1203 1204 1205 1206 1207
		/*
		 * 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.
		 */
1208 1209
		chip->base = base;
	}
1210
	gdev->base = base;
1211

1212
	status = gpiodev_add_to_list(gdev);
1213 1214
	if (status) {
		spin_unlock_irqrestore(&gpio_lock, flags);
1215
		goto err_free_label;
1216
	}
1217

1218 1219
	spin_unlock_irqrestore(&gpio_lock, flags);

1220
	for (i = 0; i < chip->ngpio; i++) {
1221
		struct gpio_desc *desc = &gdev->descs[i];
1222

1223
		desc->gdev = gdev;
1224 1225 1226 1227 1228 1229 1230
		/*
		 * 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.
1231
		 */
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248

		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);
		}
1249
	}
1250

1251
#ifdef CONFIG_PINCTRL
1252
	INIT_LIST_HEAD(&gdev->pin_ranges);
1253 1254
#endif

1255 1256 1257 1258
	status = gpiochip_set_desc_names(chip);
	if (status)
		goto err_remove_from_list;

1259 1260 1261 1262
	status = gpiochip_irqchip_init_valid_mask(chip);
	if (status)
		goto err_remove_from_list;

1263 1264 1265 1266
	status = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

1267
	acpi_gpiochip_add(chip);
1268

1269 1270 1271 1272 1273
	/*
	 * 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.
1274 1275
	 * We can do this only if gpiolib has been initialized.
	 * Otherwise, defer until later.
1276
	 */
1277 1278 1279 1280 1281
	if (gpiolib_initialized) {
		status = gpiochip_setup_dev(gdev);
		if (status)
			goto err_remove_chip;
	}
1282
	return 0;
1283

1284 1285
err_remove_chip:
	acpi_gpiochip_remove(chip);
1286
	gpiochip_free_hogs(chip);
1287
	of_gpiochip_remove(chip);
1288
	gpiochip_irqchip_free_valid_mask(chip);
1289
err_remove_from_list:
1290
	spin_lock_irqsave(&gpio_lock, flags);
1291
	list_del(&gdev->list);
1292
	spin_unlock_irqrestore(&gpio_lock, flags);
1293 1294 1295 1296
err_free_label:
	kfree(gdev->label);
err_free_descs:
	kfree(gdev->descs);
1297 1298
err_free_gdev:
	ida_simple_remove(&gpio_ida, gdev->id);
1299
	/* failures here can mean systems won't boot... */
1300
	pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1301 1302 1303
	       gdev->base, gdev->base + gdev->ngpio - 1,
	       chip->label ? : "generic");
	kfree(gdev);
1304 1305
	return status;
}
1306
EXPORT_SYMBOL_GPL(gpiochip_add_data);
1307

1308 1309
/**
 * gpiochip_get_data() - get per-subdriver data for the chip
T
Thierry Reding 已提交
1310 1311 1312 1313
 * @chip: GPIO chip
 *
 * Returns:
 * The per-subdriver data for the chip.
1314 1315 1316 1317 1318 1319 1320
 */
void *gpiochip_get_data(struct gpio_chip *chip)
{
	return chip->gpiodev->data;
}
EXPORT_SYMBOL_GPL(gpiochip_get_data);

1321 1322 1323 1324 1325 1326
/**
 * gpiochip_remove() - unregister a gpio_chip
 * @chip: the chip to unregister
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
1327
void gpiochip_remove(struct gpio_chip *chip)
1328
{
1329
	struct gpio_device *gdev = chip->gpiodev;
J
Johan Hovold 已提交
1330
	struct gpio_desc *desc;
1331
	unsigned long	flags;
1332
	unsigned	i;
J
Johan Hovold 已提交
1333
	bool		requested = false;
1334

1335
	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1336
	gpiochip_sysfs_unregister(gdev);
1337
	gpiochip_free_hogs(chip);
1338 1339
	/* Numb the device, cancelling all outstanding operations */
	gdev->chip = NULL;
1340
	gpiochip_irqchip_remove(chip);
1341
	acpi_gpiochip_remove(chip);
1342
	gpiochip_remove_pin_ranges(chip);
1343
	of_gpiochip_remove(chip);
1344 1345 1346 1347 1348
	/*
	 * We accept no more calls into the driver from this point, so
	 * NULL the driver data pointer
	 */
	gdev->data = NULL;
1349

1350
	spin_lock_irqsave(&gpio_lock, flags);
1351
	for (i = 0; i < gdev->ngpio; i++) {
1352
		desc = &gdev->descs[i];
J
Johan Hovold 已提交
1353 1354
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
1355 1356
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
1357

J
Johan Hovold 已提交
1358
	if (requested)
1359
		dev_crit(&gdev->dev,
1360
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
J
Johan Hovold 已提交
1361

1362 1363 1364 1365 1366 1367
	/*
	 * 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.
	 */
1368
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1369
	put_device(&gdev->dev);
1370 1371 1372
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

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

1449 1450 1451
/**
 * gpiochip_find() - iterator for locating a specific gpio_chip
 * @data: data to pass to match function
T
Thierry Reding 已提交
1452
 * @match: Callback function to check gpio_chip
1453 1454 1455 1456 1457 1458 1459
 *
 * 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.
 */
1460
struct gpio_chip *gpiochip_find(void *data,
1461
				int (*match)(struct gpio_chip *chip,
1462
					     void *data))
1463
{
1464
	struct gpio_device *gdev;
1465
	struct gpio_chip *chip = NULL;
1466 1467 1468
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
1469
	list_for_each_entry(gdev, &gpio_devices, list)
1470 1471
		if (gdev->chip && match(gdev->chip, data)) {
			chip = gdev->chip;
1472
			break;
1473
		}
1474

1475 1476 1477 1478
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
J
Jean Delvare 已提交
1479
EXPORT_SYMBOL_GPL(gpiochip_find);
1480

1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
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);
}

1493 1494 1495 1496 1497 1498
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
{
	if (!gpiochip->irq_need_valid_mask)
		return 0;

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

	/* Assume by default all GPIOs are valid */
1510
	bitmap_fill(gpiochip->irq_valid_mask, gpiochip->ngpio);
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529

	return 0;
}

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

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

1530
/**
1531
 * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
1532 1533
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
1534 1535 1536
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1537 1538
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
1539
 */
1540 1541
static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
					  struct irq_chip *irqchip,
1542
					  unsigned int parent_irq,
1543
					  irq_flow_handler_t parent_handler)
1544
{
1545 1546 1547 1548 1549
	unsigned int offset;

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

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
	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.
		 */
1564 1565
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
1566

1567
		gpiochip->irq_chained_parent = parent_irq;
1568
	}
1569 1570

	/* Set the parent IRQ for all affected IRQs */
1571 1572 1573
	for (offset = 0; offset < gpiochip->ngpio; offset++) {
		if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
			continue;
1574 1575
		irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
			       parent_irq);
1576
	}
1577
}
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590

/**
 * 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,
1591
				  unsigned int parent_irq,
1592 1593 1594 1595 1596
				  irq_flow_handler_t parent_handler)
{
	gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
				      parent_handler);
}
1597 1598
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);

1599 1600 1601 1602 1603 1604 1605 1606 1607
/**
 * 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,
1608
				 unsigned int parent_irq)
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
{
	if (!gpiochip->irq_nested) {
		chip_err(gpiochip, "tried to nest a chained gpiochip\n");
		return;
	}
	gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
				      NULL);
}
EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);

1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
/**
 * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
 * @d: the irqdomain used by this irqchip
 * @irq: the global irq number used by this GPIO irqchip irq
 * @hwirq: the local IRQ/GPIO line offset on this gpiochip
 *
 * This function will set up the mapping for a certain IRQ line on a
 * gpiochip by assigning the gpiochip as chip data, and using the irqchip
 * stored inside the gpiochip.
 */
static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
			    irq_hw_number_t hwirq)
{
	struct gpio_chip *chip = d->host_data;

1634 1635 1636
	if (!gpiochip_irqchip_irq_valid(chip, hwirq))
		return -ENXIO;

1637
	irq_set_chip_data(irq, chip);
1638 1639 1640 1641 1642
	/*
	 * This lock class tells lockdep that GPIO irqs are in a different
	 * category than their parents, so it won't report false recursion.
	 */
	irq_set_lockdep_class(irq, chip->lock_key);
1643
	irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
1644 1645
	/* Chips that use nested thread handlers have them marked */
	if (chip->irq_nested)
1646
		irq_set_nested_thread(irq, 1);
1647
	irq_set_noprobe(irq);
R
Rob Herring 已提交
1648

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

	return 0;
}

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

1663
	if (chip->irq_nested)
1664
		irq_set_nested_thread(irq, 0);
L
Linus Walleij 已提交
1665 1666 1667 1668
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}

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

1680
	if (!try_module_get(chip->gpiodev->owner))
1681 1682
		return -ENODEV;

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

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

1697
	gpiochip_unlock_as_irq(chip, d->hwirq);
1698
	module_put(chip->gpiodev->owner);
1699 1700 1701 1702
}

static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
{
1703 1704 1705
	if (!gpiochip_irqchip_irq_valid(chip, offset))
		return -ENXIO;
	return irq_create_mapping(chip->irqdomain, offset);
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
}

/**
 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
 * @gpiochip: the gpiochip to remove the irqchip from
 *
 * This is called only from gpiochip_remove()
 */
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
{
L
Linus Walleij 已提交
1716 1717
	unsigned int offset;

1718 1719
	acpi_gpiochip_free_interrupts(gpiochip);

1720 1721 1722
	if (gpiochip->irq_chained_parent) {
		irq_set_chained_handler(gpiochip->irq_chained_parent, NULL);
		irq_set_handler_data(gpiochip->irq_chained_parent, NULL);
1723 1724
	}

L
Linus Walleij 已提交
1725 1726
	/* Remove all IRQ mappings and delete the domain */
	if (gpiochip->irqdomain) {
1727 1728 1729
		for (offset = 0; offset < gpiochip->ngpio; offset++) {
			if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
				continue;
1730 1731
			irq_dispose_mapping(
				irq_find_mapping(gpiochip->irqdomain, offset));
1732
		}
1733
		irq_domain_remove(gpiochip->irqdomain);
L
Linus Walleij 已提交
1734
	}
1735 1736 1737 1738 1739 1740

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

	gpiochip_irqchip_free_valid_mask(gpiochip);
1743 1744 1745
}

/**
1746
 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
1747 1748 1749 1750 1751
 * @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)
1752 1753
 * @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.
1754 1755
 * @nested: whether this is a nested irqchip calling handle_nested_irq()
 * in its IRQ handler
1756
 * @lock_key: lockdep class
1757 1758 1759 1760 1761
 *
 * 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 已提交
1762
 * need to use gpiochip_get_data() to get their local state containers back
1763 1764 1765 1766 1767
 * 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 已提交
1768 1769
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1770 1771
 * need to be open coded.
 */
1772 1773 1774 1775 1776 1777 1778
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,
			     bool nested,
			     struct lock_class_key *lock_key)
1779 1780 1781 1782 1783 1784
{
	struct device_node *of_node;

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

1785
	if (!gpiochip->parent) {
1786 1787 1788
		pr_err("missing gpiochip .dev parent pointer\n");
		return -EINVAL;
	}
1789
	gpiochip->irq_nested = nested;
1790
	of_node = gpiochip->parent->of_node;
1791 1792
#ifdef CONFIG_OF_GPIO
	/*
1793
	 * If the gpiochip has an assigned OF node this takes precedence
1794 1795
	 * FIXME: get rid of this and use gpiochip->parent->of_node
	 * everywhere
1796 1797 1798 1799
	 */
	if (gpiochip->of_node)
		of_node = gpiochip->of_node;
#endif
1800
	/*
1801
	 * Specifying a default trigger is a terrible idea if DT or ACPI is
1802 1803 1804 1805
	 * 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,
1806
		 "%pOF: Ignoring %d default trigger\n", of_node, type))
1807
		type = IRQ_TYPE_NONE;
1808 1809 1810 1811 1812
	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;
	}
1813

1814 1815 1816 1817
	gpiochip->irqchip = irqchip;
	gpiochip->irq_handler = handler;
	gpiochip->irq_default_type = type;
	gpiochip->to_irq = gpiochip_to_irq;
1818
	gpiochip->lock_key = lock_key;
1819 1820 1821 1822 1823 1824 1825
	gpiochip->irqdomain = irq_domain_add_simple(of_node,
					gpiochip->ngpio, first_irq,
					&gpiochip_domain_ops, gpiochip);
	if (!gpiochip->irqdomain) {
		gpiochip->irqchip = NULL;
		return -EINVAL;
	}
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835

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

1837 1838
	acpi_gpiochip_request_interrupts(gpiochip);

1839 1840
	return 0;
}
1841
EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
1842 1843 1844 1845

#else /* CONFIG_GPIOLIB_IRQCHIP */

static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1846 1847 1848 1849 1850 1851
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)
{ }
1852 1853 1854

#endif /* CONFIG_GPIOLIB_IRQCHIP */

1855 1856 1857 1858 1859 1860 1861
/**
 * 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)
{
1862
	return pinctrl_request_gpio(chip->gpiodev->base + offset);
1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
}
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)
{
1873
	pinctrl_free_gpio(chip->gpiodev->base + offset);
1874 1875 1876
}
EXPORT_SYMBOL_GPL(gpiochip_generic_free);

1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889
/**
 * 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);

1890
#ifdef CONFIG_PINCTRL
1891

1892 1893 1894
/**
 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
1895
 * @pctldev: the pin controller to map to
1896 1897 1898 1899 1900 1901 1902 1903
 * @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;
1904
	struct gpio_device *gdev = chip->gpiodev;
1905 1906 1907 1908
	int ret;

	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
	if (!pin_range) {
1909
		chip_err(chip, "failed to allocate pin ranges\n");
1910 1911 1912 1913 1914 1915 1916
		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;
1917
	pin_range->range.base = gdev->base + gpio_offset;
1918 1919 1920 1921 1922
	pin_range->pctldev = pctldev;

	ret = pinctrl_get_group_pins(pctldev, pin_group,
					&pin_range->range.pins,
					&pin_range->range.npins);
1923 1924
	if (ret < 0) {
		kfree(pin_range);
1925
		return ret;
1926
	}
1927 1928 1929

	pinctrl_add_gpio_range(pctldev, &pin_range->range);

1930 1931
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
1932 1933
		 pinctrl_dev_get_devname(pctldev), pin_group);

1934
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
1935 1936 1937 1938 1939

	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);

1940 1941 1942
/**
 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
T
Thierry Reding 已提交
1943
 * @pinctl_name: the dev_name() of the pin controller to map to
1944 1945
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_offset: the start offset in the pin controller number space
1946 1947
 * @npins: the number of pins from the offset of each pin space (GPIO and
 *	pin controller) to accumulate in this range
T
Thierry Reding 已提交
1948 1949 1950
 *
 * Returns:
 * 0 on success, or a negative error-code on failure.
1951
 */
1952
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1953
			   unsigned int gpio_offset, unsigned int pin_offset,
1954
			   unsigned int npins)
1955 1956
{
	struct gpio_pin_range *pin_range;
1957
	struct gpio_device *gdev = chip->gpiodev;
1958
	int ret;
1959

1960
	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1961
	if (!pin_range) {
1962
		chip_err(chip, "failed to allocate pin ranges\n");
1963
		return -ENOMEM;
1964 1965
	}

1966
	/* Use local offset as range ID */
1967
	pin_range->range.id = gpio_offset;
1968
	pin_range->range.gc = chip;
1969
	pin_range->range.name = chip->label;
1970
	pin_range->range.base = gdev->base + gpio_offset;
1971
	pin_range->range.pin_base = pin_offset;
1972
	pin_range->range.npins = npins;
L
Linus Walleij 已提交
1973
	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1974
			&pin_range->range);
1975
	if (IS_ERR(pin_range->pctldev)) {
1976
		ret = PTR_ERR(pin_range->pctldev);
1977
		chip_err(chip, "could not create pin range\n");
1978
		kfree(pin_range);
1979
		return ret;
1980
	}
1981 1982
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
		 gpio_offset, gpio_offset + npins - 1,
1983 1984
		 pinctl_name,
		 pin_offset, pin_offset + npins - 1);
1985

1986
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
1987 1988

	return 0;
1989
}
1990
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1991

1992 1993 1994 1995
/**
 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
 * @chip: the chip to remove all the mappings for
 */
1996 1997 1998
void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
{
	struct gpio_pin_range *pin_range, *tmp;
1999
	struct gpio_device *gdev = chip->gpiodev;
2000

2001
	list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2002 2003 2004
		list_del(&pin_range->node);
		pinctrl_remove_gpio_range(pin_range->pctldev,
				&pin_range->range);
2005
		kfree(pin_range);
2006 2007
	}
}
2008 2009 2010
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);

#endif /* CONFIG_PINCTRL */
2011

2012 2013 2014 2015
/* 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.
 */
2016
static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2017
{
2018
	struct gpio_chip	*chip = desc->gdev->chip;
2019
	int			status;
2020 2021
	unsigned long		flags;

2022 2023
	spin_lock_irqsave(&gpio_lock, flags);

2024
	/* NOTE:  gpio_request() can be called in early boot,
D
David Brownell 已提交
2025
	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2026 2027 2028 2029 2030
	 */

	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
		desc_set_label(desc, label ? : "?");
		status = 0;
2031
	} else {
2032
		status = -EBUSY;
M
Magnus Damm 已提交
2033
		goto done;
D
David Brownell 已提交
2034 2035 2036 2037 2038
	}

	if (chip->request) {
		/* chip->request may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2039
		status = chip->request(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2040 2041 2042 2043 2044
		spin_lock_irqsave(&gpio_lock, flags);

		if (status < 0) {
			desc_set_label(desc, NULL);
			clear_bit(FLAG_REQUESTED, &desc->flags);
2045
			goto done;
D
David Brownell 已提交
2046
		}
2047
	}
2048 2049 2050
	if (chip->get_direction) {
		/* chip->get_direction may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2051
		gpiod_get_direction(desc);
2052 2053
		spin_lock_irqsave(&gpio_lock, flags);
	}
2054 2055 2056 2057 2058
done:
	spin_unlock_irqrestore(&gpio_lock, flags);
	return status;
}

2059 2060 2061
/*
 * This descriptor validation needs to be inserted verbatim into each
 * function taking a descriptor, so we need to use a preprocessor
2062 2063
 * macro to avoid endless duplication. If the desc is NULL it is an
 * optional GPIO and calls should just bail out.
2064 2065
 */
#define VALIDATE_DESC(desc) do { \
2066 2067
	if (!desc) \
		return 0; \
2068 2069 2070 2071
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return PTR_ERR(desc); \
	} \
2072
	if (!desc->gdev) { \
2073
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2074 2075 2076 2077 2078 2079 2080 2081 2082
		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 { \
2083 2084
	if (!desc) \
		return; \
2085 2086 2087 2088
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return; \
	} \
2089
	if (!desc->gdev) { \
2090
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2091 2092 2093 2094 2095 2096 2097 2098 2099
		return; \
	} \
	if (!desc->gdev->chip) { \
		dev_warn(&desc->gdev->dev, \
			 "%s: backing chip is gone\n", __func__); \
		return; \
	} } while (0)


2100
int gpiod_request(struct gpio_desc *desc, const char *label)
2101 2102
{
	int status = -EPROBE_DEFER;
2103
	struct gpio_device *gdev;
2104

2105 2106
	VALIDATE_DESC(desc);
	gdev = desc->gdev;
2107

2108
	if (try_module_get(gdev->owner)) {
2109
		status = gpiod_request_commit(desc, label);
2110
		if (status < 0)
2111
			module_put(gdev->owner);
2112 2113
		else
			get_device(&gdev->dev);
2114 2115
	}

2116
	if (status)
2117
		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2118

2119 2120
	return status;
}
2121

2122
static bool gpiod_free_commit(struct gpio_desc *desc)
2123
{
2124
	bool			ret = false;
2125
	unsigned long		flags;
D
David Brownell 已提交
2126
	struct gpio_chip	*chip;
2127

2128 2129
	might_sleep();

2130
	gpiod_unexport(desc);
D
David Brownell 已提交
2131

2132 2133
	spin_lock_irqsave(&gpio_lock, flags);

2134
	chip = desc->gdev->chip;
D
David Brownell 已提交
2135 2136 2137
	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
		if (chip->free) {
			spin_unlock_irqrestore(&gpio_lock, flags);
2138
			might_sleep_if(chip->can_sleep);
2139
			chip->free(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2140 2141
			spin_lock_irqsave(&gpio_lock, flags);
		}
2142
		desc_set_label(desc, NULL);
2143
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
D
David Brownell 已提交
2144
		clear_bit(FLAG_REQUESTED, &desc->flags);
2145
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2146
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
B
Benoit Parrot 已提交
2147
		clear_bit(FLAG_IS_HOGGED, &desc->flags);
2148 2149
		ret = true;
	}
2150 2151

	spin_unlock_irqrestore(&gpio_lock, flags);
2152 2153 2154
	return ret;
}

2155
void gpiod_free(struct gpio_desc *desc)
2156
{
2157
	if (desc && desc->gdev && gpiod_free_commit(desc)) {
2158
		module_put(desc->gdev->owner);
2159 2160
		put_device(&desc->gdev->dev);
	} else {
2161
		WARN_ON(extra_checks);
2162
	}
2163
}
2164

2165 2166 2167 2168 2169 2170
/**
 * 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.
2171 2172
 * The string returned is the label passed to gpio_request(); if none has been
 * passed it is a meaningless, non-NULL constant.
2173 2174 2175 2176 2177 2178 2179
 *
 * 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)
{
2180
	struct gpio_desc *desc;
2181

2182
	if (offset >= chip->ngpio)
2183
		return NULL;
2184

2185
	desc = &chip->gpiodev->descs[offset];
2186

2187
	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2188
		return NULL;
2189
	return desc->label;
2190 2191 2192
}
EXPORT_SYMBOL_GPL(gpiochip_is_requested);

2193 2194
/**
 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
T
Thierry Reding 已提交
2195 2196
 * @chip: GPIO chip
 * @hwnum: hardware number of the GPIO for which to request the descriptor
2197 2198 2199 2200 2201 2202 2203
 * @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 已提交
2204 2205 2206 2207
 *
 * Returns:
 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
 * code on failure.
2208
 */
2209 2210
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
					    const char *label)
2211
{
2212 2213
	struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
	int err;
2214

2215 2216 2217 2218 2219
	if (IS_ERR(desc)) {
		chip_err(chip, "failed to get GPIO descriptor\n");
		return desc;
	}

2220
	err = gpiod_request_commit(desc, label);
2221 2222
	if (err < 0)
		return ERR_PTR(err);
2223

2224
	return desc;
2225
}
2226
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237

/**
 * 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)
2238
		gpiod_free_commit(desc);
2239
}
2240
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2241

2242 2243
/*
 * Drivers MUST set GPIO direction before making get/set calls.  In
2244 2245 2246 2247 2248 2249 2250 2251
 * 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.
 */

2252 2253 2254 2255 2256 2257 2258 2259 2260 2261
/**
 * 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)
2262 2263 2264 2265
{
	struct gpio_chip	*chip;
	int			status = -EINVAL;

2266 2267
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2268

2269
	if (!chip->get || !chip->direction_input) {
2270 2271
		gpiod_warn(desc,
			"%s: missing get() or direction_input() operations\n",
2272
			__func__);
2273 2274 2275
		return -EIO;
	}

2276
	status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2277 2278
	if (status == 0)
		clear_bit(FLAG_IS_OUT, &desc->flags);
2279

2280
	trace_gpio_direction(desc_to_gpio(desc), 1, status);
2281

2282 2283
	return status;
}
2284
EXPORT_SYMBOL_GPL(gpiod_direction_input);
2285

2286 2287 2288 2289 2290 2291 2292 2293
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;
}

2294
static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
2295
{
2296
	struct gpio_chip *gc = desc->gdev->chip;
2297
	int val = !!value;
2298
	int ret;
2299

2300
	if (!gc->set || !gc->direction_output) {
2301 2302 2303
		gpiod_warn(desc,
		       "%s: missing set() or direction_output() operations\n",
		       __func__);
2304 2305 2306
		return -EIO;
	}

2307
	ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2308
	if (!ret)
2309
		set_bit(FLAG_IS_OUT, &desc->flags);
2310
	trace_gpio_value(desc_to_gpio(desc), 0, val);
2311 2312
	trace_gpio_direction(desc_to_gpio(desc), 0, ret);
	return ret;
2313
}
2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327

/**
 * 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)
{
2328
	VALIDATE_DESC(desc);
2329
	return gpiod_direction_output_raw_commit(desc, value);
2330 2331 2332 2333
}
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);

/**
2334
 * gpiod_direction_output - set the GPIO direction to output
2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
 * @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)
{
2347 2348 2349
	struct gpio_chip *gc = desc->gdev->chip;
	int ret;

2350
	VALIDATE_DESC(desc);
2351 2352
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2353 2354
	else
		value = !!value;
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387

	/* 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:
2388
	return gpiod_direction_output_raw_commit(desc, value);
2389
}
2390
EXPORT_SYMBOL_GPL(gpiod_direction_output);
2391

2392
/**
T
Thierry Reding 已提交
2393 2394 2395
 * 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
2396
 *
T
Thierry Reding 已提交
2397 2398 2399
 * Returns:
 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
 * debounce time.
2400
 */
2401
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2402 2403
{
	struct gpio_chip	*chip;
2404
	unsigned long		config;
2405

2406 2407
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2408
	if (!chip->set || !chip->set_config) {
2409
		gpiod_dbg(desc,
2410
			  "%s: missing set() or set_config() operations\n",
2411
			  __func__);
2412
		return -ENOTSUPP;
2413 2414
	}

2415 2416
	config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
	return chip->set_config(chip, gpio_chip_hwgpio(desc), config);
2417
}
2418
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2419

2420 2421 2422 2423 2424 2425 2426
/**
 * 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)
2427
{
2428
	VALIDATE_DESC(desc);
2429
	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2430
}
2431
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454

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

2455
static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
2456 2457
{
	struct gpio_chip	*chip;
2458
	int offset;
2459
	int value;
2460

2461
	chip = desc->gdev->chip;
2462
	offset = gpio_chip_hwgpio(desc);
2463
	value = chip->get ? chip->get(chip, offset) : -EIO;
2464
	value = value < 0 ? value : !!value;
2465
	trace_gpio_value(desc_to_gpio(desc), 1, value);
2466
	return value;
2467
}
2468

2469
/**
2470 2471
 * gpiod_get_raw_value() - return a gpio's raw value
 * @desc: gpio whose value will be returned
2472
 *
2473
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2474
 * its ACTIVE_LOW status, or negative errno on failure.
2475 2476 2477
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2478
 */
2479
int gpiod_get_raw_value(const struct gpio_desc *desc)
2480
{
2481
	VALIDATE_DESC(desc);
2482
	/* Should be using gpio_get_value_cansleep() */
2483
	WARN_ON(desc->gdev->chip->can_sleep);
2484
	return gpiod_get_raw_value_commit(desc);
2485
}
2486
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2487

2488 2489 2490 2491 2492
/**
 * 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
2493
 * account, or negative errno on failure.
2494 2495 2496 2497 2498
 *
 * 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)
2499
{
2500
	int value;
2501 2502

	VALIDATE_DESC(desc);
2503
	/* Should be using gpio_get_value_cansleep() */
2504
	WARN_ON(desc->gdev->chip->can_sleep);
2505

2506
	value = gpiod_get_raw_value_commit(desc);
2507 2508 2509
	if (value < 0)
		return value;

2510 2511 2512 2513
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
2514
}
2515
EXPORT_SYMBOL_GPL(gpiod_get_value);
2516

2517
/*
2518
 *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
2519
 * @desc: gpio descriptor whose state need to be set.
2520
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2521
 */
2522
static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
2523 2524
{
	int err = 0;
2525
	struct gpio_chip *chip = desc->gdev->chip;
2526 2527
	int offset = gpio_chip_hwgpio(desc);

2528
	if (value) {
2529
		err = chip->direction_input(chip, offset);
2530
		if (!err)
2531
			clear_bit(FLAG_IS_OUT, &desc->flags);
2532
	} else {
2533
		err = chip->direction_output(chip, offset, 0);
2534
		if (!err)
2535
			set_bit(FLAG_IS_OUT, &desc->flags);
2536
	}
2537
	trace_gpio_direction(desc_to_gpio(desc), value, err);
2538
	if (err < 0)
2539 2540 2541
		gpiod_err(desc,
			  "%s: Error in set_value for open drain err %d\n",
			  __func__, err);
2542 2543
}

2544
/*
2545 2546
 *  _gpio_set_open_source_value() - Set the open source gpio's value.
 * @desc: gpio descriptor whose state need to be set.
2547
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2548
 */
2549
static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
2550 2551
{
	int err = 0;
2552
	struct gpio_chip *chip = desc->gdev->chip;
2553 2554
	int offset = gpio_chip_hwgpio(desc);

2555
	if (value) {
2556
		err = chip->direction_output(chip, offset, 1);
2557
		if (!err)
2558
			set_bit(FLAG_IS_OUT, &desc->flags);
2559
	} else {
2560
		err = chip->direction_input(chip, offset);
2561
		if (!err)
2562
			clear_bit(FLAG_IS_OUT, &desc->flags);
2563
	}
2564
	trace_gpio_direction(desc_to_gpio(desc), !value, err);
2565
	if (err < 0)
2566 2567 2568
		gpiod_err(desc,
			  "%s: Error in set_value for open source err %d\n",
			  __func__, err);
2569 2570
}

2571
static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
2572 2573 2574
{
	struct gpio_chip	*chip;

2575
	chip = desc->gdev->chip;
2576
	trace_gpio_value(desc_to_gpio(desc), 0, value);
2577
	chip->set(chip, gpio_chip_hwgpio(desc), value);
2578 2579
}

2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594
/*
 * 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 {
2595 2596 2597 2598 2599
		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));
2600 2601 2602
	}
}

2603 2604 2605 2606
void gpiod_set_array_value_complex(bool raw, bool can_sleep,
				   unsigned int array_size,
				   struct gpio_desc **desc_array,
				   int *value_array)
2607 2608 2609 2610
{
	int i = 0;

	while (i < array_size) {
2611
		struct gpio_chip *chip = desc_array[i]->gdev->chip;
2612 2613 2614 2615
		unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
		unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
		int count = 0;

D
Daniel Lockyer 已提交
2616
		if (!can_sleep)
2617
			WARN_ON(chip->can_sleep);
D
Daniel Lockyer 已提交
2618

2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
		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
			 */
2632
			if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
2633
				gpio_set_open_drain_value_commit(desc, value);
2634
			} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
2635
				gpio_set_open_source_value_commit(desc, value);
2636 2637
			} else {
				__set_bit(hwgpio, mask);
D
Daniel Lockyer 已提交
2638
				if (value)
2639
					__set_bit(hwgpio, bits);
D
Daniel Lockyer 已提交
2640
				else
2641 2642 2643 2644
					__clear_bit(hwgpio, bits);
				count++;
			}
			i++;
2645 2646
		} while ((i < array_size) &&
			 (desc_array[i]->gdev->chip == chip));
2647
		/* push collected bits to outputs */
D
Daniel Lockyer 已提交
2648
		if (count != 0)
2649 2650 2651 2652
			gpio_chip_set_multiple(chip, mask, bits);
	}
}

2653
/**
2654 2655
 * gpiod_set_raw_value() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
2656 2657
 * @value: value to assign
 *
2658 2659 2660 2661 2662
 * 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.
2663
 */
2664
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2665
{
2666
	VALIDATE_DESC_VOID(desc);
2667
	/* Should be using gpiod_set_value_cansleep() */
2668
	WARN_ON(desc->gdev->chip->can_sleep);
2669
	gpiod_set_raw_value_commit(desc, value);
2670
}
2671
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2672 2673

/**
2674 2675 2676 2677
 * gpiod_set_value() - assign a gpio's value
 * @desc: gpio whose value will be assigned
 * @value: value to assign
 *
2678 2679
 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
 * OPEN_DRAIN and OPEN_SOURCE flags into account.
2680
 *
2681 2682
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2683
 */
2684
void gpiod_set_value(struct gpio_desc *desc, int value)
2685
{
2686
	VALIDATE_DESC_VOID(desc);
2687
	/* Should be using gpiod_set_value_cansleep() */
2688
	WARN_ON(desc->gdev->chip->can_sleep);
2689 2690
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2691 2692 2693 2694 2695 2696
	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);
2697
}
2698
EXPORT_SYMBOL_GPL(gpiod_set_value);
2699

2700
/**
2701
 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
2702 2703 2704 2705 2706 2707 2708 2709 2710 2711
 * @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.
 */
2712
void gpiod_set_raw_array_value(unsigned int array_size,
2713 2714 2715 2716
			 struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return;
2717 2718
	gpiod_set_array_value_complex(true, false, array_size, desc_array,
				      value_array);
2719
}
2720
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
2721 2722

/**
2723
 * gpiod_set_array_value() - assign values to an array of GPIOs
2724 2725 2726 2727 2728 2729 2730 2731 2732 2733
 * @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.
 */
2734 2735
void gpiod_set_array_value(unsigned int array_size,
			   struct gpio_desc **desc_array, int *value_array)
2736 2737 2738
{
	if (!desc_array)
		return;
2739 2740
	gpiod_set_array_value_complex(false, false, array_size, desc_array,
				      value_array);
2741
}
2742
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
2743

2744
/**
2745 2746
 * gpiod_cansleep() - report whether gpio value access may sleep
 * @desc: gpio to check
2747 2748
 *
 */
2749
int gpiod_cansleep(const struct gpio_desc *desc)
2750
{
2751 2752
	VALIDATE_DESC(desc);
	return desc->gdev->chip->can_sleep;
2753
}
2754
EXPORT_SYMBOL_GPL(gpiod_cansleep);
2755

D
David Brownell 已提交
2756
/**
2757 2758
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
D
David Brownell 已提交
2759
 *
2760 2761
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
D
David Brownell 已提交
2762
 */
2763
int gpiod_to_irq(const struct gpio_desc *desc)
D
David Brownell 已提交
2764
{
2765 2766
	struct gpio_chip *chip;
	int offset;
D
David Brownell 已提交
2767

2768 2769 2770 2771 2772
	/*
	 * 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.
	 */
2773
	if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
2774 2775
		return -EINVAL;

2776
	chip = desc->gdev->chip;
2777
	offset = gpio_chip_hwgpio(desc);
2778 2779 2780 2781 2782 2783 2784 2785 2786 2787
	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 已提交
2788
}
2789
EXPORT_SYMBOL_GPL(gpiod_to_irq);
D
David Brownell 已提交
2790

2791
/**
2792
 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
2793 2794
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2795 2796
 *
 * This is used directly by GPIO drivers that want to lock down
2797
 * a certain GPIO line to be used for IRQs.
2798
 */
2799
int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2800
{
2801 2802 2803 2804 2805 2806
	struct gpio_desc *desc;

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

2807 2808 2809 2810 2811
	/*
	 * If it's fast: flush the direction setting if something changed
	 * behind our back
	 */
	if (!chip->can_sleep && chip->get_direction) {
2812 2813 2814 2815 2816 2817 2818
		int dir = chip->get_direction(chip, offset);

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

2820
	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2821
		chip_err(chip,
2822 2823 2824 2825 2826
			  "%s: tried to flag a GPIO set as output for IRQ\n",
			  __func__);
		return -EIO;
	}

2827
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2828 2829 2830 2831 2832 2833 2834 2835 2836

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

2837
	return 0;
2838
}
2839
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
2840

2841
/**
2842
 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
2843 2844
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2845 2846 2847
 *
 * This is used directly by GPIO drivers that want to indicate
 * that a certain GPIO is no longer used exclusively for IRQ.
2848
 */
2849
void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2850
{
2851 2852 2853 2854
	struct gpio_desc *desc;

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

2857 2858 2859 2860 2861
	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);
2862
}
2863
EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
2864

2865 2866 2867 2868 2869 2870 2871 2872 2873
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);

2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891
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);

2892 2893 2894 2895 2896 2897 2898 2899 2900 2901
bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
{
	if (offset >= chip->ngpio)
		return false;

	return !test_bit(FLAG_SLEEP_MAY_LOOSE_VALUE,
			 &chip->gpiodev->descs[offset].flags);
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);

2902 2903 2904 2905 2906
/**
 * 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
2907
 * its ACTIVE_LOW status, or negative errno on failure.
2908 2909
 *
 * This function is to be called from contexts that can sleep.
2910
 */
2911
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2912 2913
{
	might_sleep_if(extra_checks);
2914
	VALIDATE_DESC(desc);
2915
	return gpiod_get_raw_value_commit(desc);
2916
}
2917
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2918

2919 2920 2921 2922 2923
/**
 * 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
2924
 * account, or negative errno on failure.
2925 2926 2927 2928
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2929
{
2930
	int value;
2931 2932

	might_sleep_if(extra_checks);
2933
	VALIDATE_DESC(desc);
2934
	value = gpiod_get_raw_value_commit(desc);
2935 2936 2937
	if (value < 0)
		return value;

2938 2939 2940
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

2941
	return value;
2942
}
2943
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2944

2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955
/**
 * 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)
2956
{
2957
	might_sleep_if(extra_checks);
2958
	VALIDATE_DESC_VOID(desc);
2959
	gpiod_set_raw_value_commit(desc, value);
2960
}
2961
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2962

2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973
/**
 * 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)
2974 2975
{
	might_sleep_if(extra_checks);
2976
	VALIDATE_DESC_VOID(desc);
2977 2978
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2979
	gpiod_set_raw_value_commit(desc, value);
2980
}
2981
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2982

2983
/**
2984
 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
2985 2986 2987 2988 2989 2990 2991 2992 2993
 * @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.
 */
2994 2995 2996
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
					struct gpio_desc **desc_array,
					int *value_array)
2997 2998 2999 3000
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3001 3002
	gpiod_set_array_value_complex(true, true, array_size, desc_array,
				      value_array);
3003
}
3004
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
3005

3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022
/**
 * 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);
}

3023
/**
3024
 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
3025 3026 3027 3028 3029 3030 3031 3032 3033
 * @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.
 */
3034 3035 3036
void gpiod_set_array_value_cansleep(unsigned int array_size,
				    struct gpio_desc **desc_array,
				    int *value_array)
3037 3038 3039 3040
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3041 3042
	gpiod_set_array_value_complex(false, true, array_size, desc_array,
				      value_array);
3043
}
3044
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
3045

3046
/**
3047 3048
 * gpiod_add_lookup_table() - register GPIO device consumers
 * @table: table of consumers to register
3049
 */
3050
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
3051 3052 3053
{
	mutex_lock(&gpio_lookup_lock);

3054
	list_add_tail(&table->list, &gpio_lookup_list);
3055 3056 3057

	mutex_unlock(&gpio_lookup_lock);
}
3058
EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
3059

3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071
/**
 * 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);
}
3072
EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
3073

3074
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
3075 3076
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
3077
	struct gpiod_lookup_table *table;
3078 3079 3080

	mutex_lock(&gpio_lookup_lock);

3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098
	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;
3099

3100 3101 3102 3103
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
3104

3105 3106 3107 3108
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
				    unsigned int idx,
				    enum gpio_lookup_flags *flags)
{
3109
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
3110 3111
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
3112

3113 3114 3115
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
3116

3117 3118
	for (p = &table->table[0]; p->chip_label; p++) {
		struct gpio_chip *chip;
3119

3120
		/* idx must always match exactly */
3121 3122 3123
		if (p->idx != idx)
			continue;

3124 3125 3126
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
3127

3128
		chip = find_chip_by_name(p->chip_label);
3129

3130
		if (!chip) {
3131 3132 3133
			dev_err(dev, "cannot find GPIO chip %s\n",
				p->chip_label);
			return ERR_PTR(-ENODEV);
3134
		}
3135

3136
		if (chip->ngpio <= p->chip_hwnum) {
3137 3138 3139 3140
			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);
3141 3142
		}

3143
		desc = gpiochip_get_desc(chip, p->chip_hwnum);
3144
		*flags = p->flags;
3145

3146
		return desc;
3147 3148 3149 3150 3151
	}

	return desc;
}

3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166
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);
3167
		if (ret > 0)
3168 3169
			break;
	}
3170
	return ret ? ret : -ENOENT;
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 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215
}

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

3216
/**
3217
 * gpiod_get - obtain a GPIO for a given GPIO function
3218
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3219
 * @con_id:	function within the GPIO consumer
3220
 * @flags:	optional GPIO initialization flags
3221 3222
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
3223
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3224
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3225
 */
3226
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3227
					 enum gpiod_flags flags)
3228
{
3229
	return gpiod_get_index(dev, con_id, 0, flags);
3230
}
3231
EXPORT_SYMBOL_GPL(gpiod_get);
3232

3233 3234 3235 3236
/**
 * 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
3237
 * @flags: optional GPIO initialization flags
3238 3239 3240 3241 3242
 *
 * 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.
 */
3243
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3244 3245
						  const char *con_id,
						  enum gpiod_flags flags)
3246
{
3247
	return gpiod_get_index_optional(dev, con_id, 0, flags);
3248
}
3249
EXPORT_SYMBOL_GPL(gpiod_get_optional);
3250

B
Benoit Parrot 已提交
3251 3252 3253 3254 3255

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
3256 3257
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
B
Benoit Parrot 已提交
3258 3259 3260 3261 3262 3263
 * @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.
 */
3264
int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
3265
		unsigned long lflags, enum gpiod_flags dflags)
B
Benoit Parrot 已提交
3266 3267 3268
{
	int status;

3269 3270 3271 3272 3273 3274
	if (lflags & GPIO_ACTIVE_LOW)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
	if (lflags & GPIO_OPEN_DRAIN)
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
	if (lflags & GPIO_OPEN_SOURCE)
		set_bit(FLAG_OPEN_SOURCE, &desc->flags);
3275 3276
	if (lflags & GPIO_SLEEP_MAY_LOOSE_VALUE)
		set_bit(FLAG_SLEEP_MAY_LOOSE_VALUE, &desc->flags);
3277

B
Benoit Parrot 已提交
3278 3279 3280 3281 3282 3283 3284 3285 3286
	/* 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,
3287
				!!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
B
Benoit Parrot 已提交
3288 3289 3290 3291 3292 3293
	else
		status = gpiod_direction_input(desc);

	return status;
}

3294 3295
/**
 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
3296
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3297 3298
 * @con_id:	function within the GPIO consumer
 * @idx:	index of the GPIO to obtain in the consumer
3299
 * @flags:	optional GPIO initialization flags
3300 3301 3302 3303
 *
 * This variant of gpiod_get() allows to access GPIOs other than the first
 * defined one for functions that define several GPIOs.
 *
3304 3305
 * 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
3306
 * occurred while trying to acquire the GPIO.
3307
 */
3308
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
3309
					       const char *con_id,
3310 3311
					       unsigned int idx,
					       enum gpiod_flags flags)
3312
{
3313
	struct gpio_desc *desc = NULL;
3314
	int status;
3315
	enum gpio_lookup_flags lookupflags = 0;
3316 3317 3318

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

3319 3320 3321 3322 3323 3324 3325
	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");
3326
			desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
3327
		}
3328 3329 3330 3331 3332 3333
	}

	/*
	 * 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.
	 */
3334
	if (!desc || desc == ERR_PTR(-ENOENT)) {
3335
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3336
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
3337 3338 3339
	}

	if (IS_ERR(desc)) {
3340
		dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
3341 3342 3343 3344 3345 3346 3347
		return desc;
	}

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

3348
	status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
3349 3350 3351 3352 3353 3354
	if (status < 0) {
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
		gpiod_put(desc);
		return ERR_PTR(status);
	}

3355 3356
	return desc;
}
3357
EXPORT_SYMBOL_GPL(gpiod_get_index);
3358

3359 3360 3361 3362
/**
 * 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
3363
 * @index:	index of the GPIO to obtain in the consumer
3364
 * @dflags:	GPIO initialization flags
T
Thierry Reding 已提交
3365
 * @label:	label to attach to the requested GPIO
3366 3367 3368 3369 3370 3371 3372 3373
 *
 * 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 已提交
3374
 * Returns:
3375
 * On successful request the GPIO pin is configured in accordance with
3376 3377
 * provided @dflags.
 *
3378 3379 3380
 * In case of error an ERR_PTR() is returned.
 */
struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
3381
					 const char *propname, int index,
3382 3383
					 enum gpiod_flags dflags,
					 const char *label)
3384 3385
{
	struct gpio_desc *desc = ERR_PTR(-ENODEV);
3386
	unsigned long lflags = 0;
3387
	bool active_low = false;
3388
	bool single_ended = false;
3389
	bool open_drain = false;
3390 3391 3392 3393 3394 3395 3396 3397
	int ret;

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

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

3398 3399
		desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname,
						index, &flags);
3400
		if (!IS_ERR(desc)) {
3401
			active_low = flags & OF_GPIO_ACTIVE_LOW;
3402
			single_ended = flags & OF_GPIO_SINGLE_ENDED;
3403
			open_drain = flags & OF_GPIO_OPEN_DRAIN;
3404
		}
3405 3406 3407
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

3408
		desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
3409
		if (!IS_ERR(desc)) {
3410
			active_low = info.polarity == GPIO_ACTIVE_LOW;
3411 3412 3413 3414
			ret = acpi_gpio_update_gpiod_flags(&dflags, info.flags);
			if (ret)
				pr_debug("Override GPIO initialization flags\n");
		}
3415 3416 3417 3418 3419
	}

	if (IS_ERR(desc))
		return desc;

3420
	ret = gpiod_request(desc, label);
3421 3422 3423
	if (ret)
		return ERR_PTR(ret);

3424
	if (active_low)
3425
		lflags |= GPIO_ACTIVE_LOW;
3426

3427
	if (single_ended) {
3428
		if (open_drain)
3429
			lflags |= GPIO_OPEN_DRAIN;
3430
		else
3431 3432 3433 3434 3435 3436 3437
			lflags |= GPIO_OPEN_SOURCE;
	}

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

3440 3441 3442 3443
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

3444 3445 3446 3447 3448 3449
/**
 * 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
3450
 * @flags: optional GPIO initialization flags
3451 3452 3453 3454 3455
 *
 * 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.
 */
3456
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3457
							const char *con_id,
3458 3459
							unsigned int index,
							enum gpiod_flags flags)
3460 3461 3462
{
	struct gpio_desc *desc;

3463
	desc = gpiod_get_index(dev, con_id, index, flags);
3464 3465 3466 3467 3468 3469 3470
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
3471
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3472

B
Benoit Parrot 已提交
3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493
/**
 * 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)) {
3494 3495 3496 3497
		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 已提交
3498 3499
	}

3500
	status = gpiod_configure_flags(desc, name, lflags, dflags);
B
Benoit Parrot 已提交
3501
	if (status < 0) {
3502 3503
		pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
B
Benoit Parrot 已提交
3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530
		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++) {
3531 3532
		if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
B
Benoit Parrot 已提交
3533 3534 3535
	}
}

3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601
/**
 * 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);

3602 3603 3604 3605 3606 3607 3608 3609 3610
/**
 * 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);
3611
}
3612
EXPORT_SYMBOL_GPL(gpiod_put);
3613

3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628
/**
 * 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);

3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643
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);
3644 3645 3646
	} else {
		gpiolib_initialized = true;
		gpiochip_setup_devs();
3647 3648 3649 3650 3651
	}
	return ret;
}
core_initcall(gpiolib_dev_init);

3652 3653
#ifdef CONFIG_DEBUG_FS

3654
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
3655 3656
{
	unsigned		i;
3657 3658 3659
	struct gpio_chip	*chip = gdev->chip;
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
3660
	int			is_out;
3661
	int			is_irq;
3662

3663
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
3664 3665 3666 3667 3668
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
3669
			continue;
3670
		}
3671

3672
		gpiod_get_direction(gdesc);
3673
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
3674
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
3675 3676
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
3677 3678 3679
			is_out ? "out" : "in ",
			chip->get
				? (chip->get(chip, i) ? "hi" : "lo")
3680 3681
				: "?  ",
			is_irq ? "IRQ" : "   ");
3682 3683 3684 3685
		seq_printf(s, "\n");
	}
}

3686
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
3687
{
3688
	unsigned long flags;
3689
	struct gpio_device *gdev = NULL;
3690
	loff_t index = *pos;
3691

3692
	s->private = "";
3693

3694
	spin_lock_irqsave(&gpio_lock, flags);
3695
	list_for_each_entry(gdev, &gpio_devices, list)
3696 3697
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
3698
			return gdev;
3699
		}
3700
	spin_unlock_irqrestore(&gpio_lock, flags);
3701

3702
	return NULL;
3703 3704 3705 3706
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
3707
	unsigned long flags;
3708
	struct gpio_device *gdev = v;
3709 3710
	void *ret = NULL;

3711
	spin_lock_irqsave(&gpio_lock, flags);
3712
	if (list_is_last(&gdev->list, &gpio_devices))
3713 3714
		ret = NULL;
	else
3715
		ret = list_entry(gdev->list.next, struct gpio_device, list);
3716
	spin_unlock_irqrestore(&gpio_lock, flags);
3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729

	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)
{
3730 3731 3732 3733 3734 3735 3736 3737 3738
	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;
	}
3739

3740 3741
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
3742
		   gdev->base, gdev->base + gdev->ngpio - 1);
3743 3744 3745 3746 3747
	parent = chip->parent;
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
3748 3749 3750 3751 3752 3753 3754 3755 3756
	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
3757
		gpiolib_dbg_show(s, gdev);
3758

3759 3760 3761
	return 0;
}

3762 3763 3764 3765 3766 3767 3768
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

3769 3770
static int gpiolib_open(struct inode *inode, struct file *file)
{
3771
	return seq_open(file, &gpiolib_seq_ops);
3772 3773
}

3774
static const struct file_operations gpiolib_operations = {
3775
	.owner		= THIS_MODULE,
3776 3777 3778
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
3779
	.release	= seq_release,
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791
};

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