gpiolib.c 105.5 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
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;
368
	int vals[GPIOHANDLES_MAX];
369 370 371
	int i;

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

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

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

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

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

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

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

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

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

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

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

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

454 455 456 457 458 459
	lflags = handlereq.flags;

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

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

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

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

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

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

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 518 519 520 521 522 523
		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);
	}
524 525
	/* Let i point at the last handle */
	i--;
526 527
	lh->numdescs = handlereq.lines;

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

534 535 536 537 538 539 540 541 542
	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;
	}

543
	handlereq.fd = fd;
544
	if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
545 546 547 548 549 550 551
		/*
		 * 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;
552
	}
553

554 555
	fd_install(fd, file);

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

	return 0;

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

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
/*
 * 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;
};

600 601 602 603
#define GPIOEVENT_REQUEST_VALID_FLAGS \
	(GPIOEVENT_REQUEST_RISING_EDGE | \
	GPIOEVENT_REQUEST_FALLING_EDGE)

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 685 686 687 688 689 690
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;

691 692
		memset(&ghd, 0, sizeof(ghd));

693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
		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
};

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

	ge.timestamp = ktime_get_real_ns();
733
	level = gpiod_get_value_cansleep(le->desc);
734

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

	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;
765
	struct file *file;
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 791 792 793 794 795 796
	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;

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

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

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 854 855 856 857 858 859
	/* 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;

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

866 867 868 869 870 871 872 873 874
	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;
	}

875
	eventreq.fd = fd;
876
	if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
877 878 879 880 881 882 883
		/*
		 * 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;
884
	}
885

886 887
	fd_install(fd, file);

888 889
	return 0;

890 891
out_put_unused_fd:
	put_unused_fd(fd);
892 893 894 895 896 897 898 899 900 901 902 903
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 已提交
904
/*
905 906 907 908 909 910
 * 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;
911
	void __user *ip = (void __user *)arg;
912 913 914 915 916

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

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

921 922
		memset(&chipinfo, 0, sizeof(chipinfo));

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

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

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

989 990 991 992 993 994 995 996
#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

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

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

/**
 * 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,
1037
	.llseek = no_llseek,
1038
	.unlocked_ioctl = gpio_ioctl,
1039 1040 1041
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
1042 1043
};

1044 1045 1046 1047 1048 1049
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);
1050 1051
	kfree(gdev->label);
	kfree(gdev->descs);
1052
	kfree(gdev);
1053 1054
}

1055 1056 1057 1058 1059 1060 1061
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);
1062 1063

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

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

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

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

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

1146 1147
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
1148 1149
	if (chip->of_node)
		gdev->dev.of_node = chip->of_node;
1150
#endif
1151

1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
	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;
1167

1168
	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1169
	if (!gdev->descs) {
1170 1171 1172 1173
		status = -ENOMEM;
		goto err_free_gdev;
	}

1174 1175
	if (chip->ngpio == 0) {
		chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1176
		status = -EINVAL;
1177
		goto err_free_descs;
1178
	}
1179 1180

	if (chip->label)
1181
		gdev->label = kstrdup(chip->label, GFP_KERNEL);
1182
	else
1183
		gdev->label = kstrdup("unknown", GFP_KERNEL);
1184 1185
	if (!gdev->label) {
		status = -ENOMEM;
1186
		goto err_free_descs;
1187 1188
	}

1189
	gdev->ngpio = chip->ngpio;
1190
	gdev->data = data;
1191

1192 1193
	spin_lock_irqsave(&gpio_lock, flags);

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

1218
	status = gpiodev_add_to_list(gdev);
1219 1220
	if (status) {
		spin_unlock_irqrestore(&gpio_lock, flags);
1221
		goto err_free_label;
1222
	}
1223

1224 1225
	spin_unlock_irqrestore(&gpio_lock, flags);

1226
	for (i = 0; i < chip->ngpio; i++) {
1227
		struct gpio_desc *desc = &gdev->descs[i];
1228

1229
		desc->gdev = gdev;
1230 1231 1232 1233 1234 1235 1236
		/*
		 * 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.
1237
		 */
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254

		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);
		}
1255
	}
1256

1257
#ifdef CONFIG_PINCTRL
1258
	INIT_LIST_HEAD(&gdev->pin_ranges);
1259 1260
#endif

1261 1262 1263 1264
	status = gpiochip_set_desc_names(chip);
	if (status)
		goto err_remove_from_list;

1265 1266 1267 1268
	status = gpiochip_irqchip_init_valid_mask(chip);
	if (status)
		goto err_remove_from_list;

1269 1270 1271 1272
	status = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

1273
	acpi_gpiochip_add(chip);
1274

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

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

1314 1315
/**
 * gpiochip_get_data() - get per-subdriver data for the chip
T
Thierry Reding 已提交
1316 1317 1318 1319
 * @chip: GPIO chip
 *
 * Returns:
 * The per-subdriver data for the chip.
1320 1321 1322 1323 1324 1325 1326
 */
void *gpiochip_get_data(struct gpio_chip *chip)
{
	return chip->gpiodev->data;
}
EXPORT_SYMBOL_GPL(gpiochip_get_data);

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

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

1356
	spin_lock_irqsave(&gpio_lock, flags);
1357
	for (i = 0; i < gdev->ngpio; i++) {
1358
		desc = &gdev->descs[i];
J
Johan Hovold 已提交
1359 1360
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
1361 1362
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
1363

J
Johan Hovold 已提交
1364
	if (requested)
1365
		dev_crit(&gdev->dev,
1366
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
J
Johan Hovold 已提交
1367

1368 1369 1370 1371 1372 1373
	/*
	 * 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.
	 */
1374
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1375
	put_device(&gdev->dev);
1376 1377 1378
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
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 已提交
1403
 * @data: driver-private data associated with this chip
1404
 *
T
Thierry Reding 已提交
1405
 * Context: potentially before irqs will work
1406 1407
 *
 * The gpio chip automatically be released when the device is unbound.
T
Thierry Reding 已提交
1408 1409 1410 1411 1412
 *
 * 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.
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 1445 1446 1447 1448 1449 1450
 */
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);
1451
	WARN_ON(ret);
1452 1453 1454
}
EXPORT_SYMBOL_GPL(devm_gpiochip_remove);

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

	spin_lock_irqsave(&gpio_lock, flags);
1475
	list_for_each_entry(gdev, &gpio_devices, list)
1476 1477
		if (gdev->chip && match(gdev->chip, data)) {
			chip = gdev->chip;
1478
			break;
1479
		}
1480

1481 1482 1483 1484
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
J
Jean Delvare 已提交
1485
EXPORT_SYMBOL_GPL(gpiochip_find);
1486

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
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);
}

1499 1500 1501 1502 1503 1504
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
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 */
1516
	bitmap_fill(gpiochip->irq_valid_mask, gpiochip->ngpio);
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535

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

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

1553
	if (!gpiochip->irq.domain) {
1554 1555
		chip_err(gpiochip, "called %s before setting up irqchip\n",
			 __func__);
1556 1557 1558
		return;
	}

1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
	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.
		 */
1570 1571
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
1572

1573 1574
		gpiochip->irq.parents = &parent_irq;
		gpiochip->irq.num_parents = 1;
1575
	}
1576 1577

	/* Set the parent IRQ for all affected IRQs */
1578 1579 1580
	for (offset = 0; offset < gpiochip->ngpio; offset++) {
		if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
			continue;
1581
		irq_set_parent(irq_find_mapping(gpiochip->irq.domain, offset),
1582
			       parent_irq);
1583
	}
1584
}
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597

/**
 * 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,
1598
				  unsigned int parent_irq,
1599 1600 1601 1602 1603
				  irq_flow_handler_t parent_handler)
{
	gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
				      parent_handler);
}
1604 1605
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);

1606 1607 1608 1609 1610 1611 1612 1613 1614
/**
 * 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,
1615
				 unsigned int parent_irq)
1616
{
1617
	if (!gpiochip->irq.nested) {
1618 1619 1620 1621 1622 1623 1624 1625
		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);

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
/**
 * 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;

1641 1642 1643
	if (!gpiochip_irqchip_irq_valid(chip, hwirq))
		return -ENXIO;

1644
	irq_set_chip_data(irq, chip);
1645 1646 1647 1648 1649
	/*
	 * 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);
1650
	irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
1651
	/* Chips that use nested thread handlers have them marked */
1652
	if (chip->irq.nested)
1653
		irq_set_nested_thread(irq, 1);
1654
	irq_set_noprobe(irq);
R
Rob Herring 已提交
1655

1656 1657 1658 1659
	/*
	 * No set-up of the hardware will happen if IRQ_TYPE_NONE
	 * is passed as default type.
	 */
1660 1661
	if (chip->irq.default_type != IRQ_TYPE_NONE)
		irq_set_irq_type(irq, chip->irq.default_type);
1662 1663 1664 1665

	return 0;
}

L
Linus Walleij 已提交
1666 1667
static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
{
1668 1669
	struct gpio_chip *chip = d->host_data;

1670
	if (chip->irq.nested)
1671
		irq_set_nested_thread(irq, 0);
L
Linus Walleij 已提交
1672 1673 1674 1675
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}

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

1687
	if (!try_module_get(chip->gpiodev->owner))
1688 1689
		return -ENODEV;

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

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

1704
	gpiochip_unlock_as_irq(chip, d->hwirq);
1705
	module_put(chip->gpiodev->owner);
1706 1707 1708 1709
}

static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
{
1710 1711
	if (!gpiochip_irqchip_irq_valid(chip, offset))
		return -ENXIO;
1712
	return irq_create_mapping(chip->irq.domain, offset);
1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
}

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

1725 1726
	acpi_gpiochip_free_interrupts(gpiochip);

1727 1728 1729 1730 1731 1732 1733
	if (gpiochip->irq.num_parents > 0) {
		struct gpio_irq_chip *irq = &gpiochip->irq;
		unsigned int i;

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

L
Linus Walleij 已提交
1736
	/* Remove all IRQ mappings and delete the domain */
1737
	if (gpiochip->irq.domain) {
1738 1739
		unsigned int irq;

1740 1741 1742
		for (offset = 0; offset < gpiochip->ngpio; offset++) {
			if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
				continue;
1743 1744 1745

			irq = irq_find_mapping(gpiochip->irq.domain, offset);
			irq_dispose_mapping(irq);
1746
		}
1747 1748

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

1751 1752 1753 1754
	if (gpiochip->irq.chip) {
		gpiochip->irq.chip->irq_request_resources = NULL;
		gpiochip->irq.chip->irq_release_resources = NULL;
		gpiochip->irq.chip = NULL;
1755
	}
1756 1757

	gpiochip_irqchip_free_valid_mask(gpiochip);
1758 1759 1760
}

/**
1761
 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
1762 1763 1764 1765 1766
 * @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)
1767 1768
 * @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.
1769 1770
 * @nested: whether this is a nested irqchip calling handle_nested_irq()
 * in its IRQ handler
1771
 * @lock_key: lockdep class
1772 1773 1774 1775 1776
 *
 * 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 已提交
1777
 * need to use gpiochip_get_data() to get their local state containers back
1778 1779 1780 1781 1782
 * 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 已提交
1783 1784
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1785 1786
 * need to be open coded.
 */
1787 1788 1789 1790 1791 1792 1793
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)
1794 1795 1796 1797 1798 1799
{
	struct device_node *of_node;

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

1800
	if (!gpiochip->parent) {
1801 1802 1803
		pr_err("missing gpiochip .dev parent pointer\n");
		return -EINVAL;
	}
1804
	gpiochip->irq.nested = nested;
1805
	of_node = gpiochip->parent->of_node;
1806 1807
#ifdef CONFIG_OF_GPIO
	/*
1808
	 * If the gpiochip has an assigned OF node this takes precedence
1809 1810
	 * FIXME: get rid of this and use gpiochip->parent->of_node
	 * everywhere
1811 1812 1813 1814
	 */
	if (gpiochip->of_node)
		of_node = gpiochip->of_node;
#endif
1815
	/*
1816
	 * Specifying a default trigger is a terrible idea if DT or ACPI is
1817 1818 1819 1820
	 * 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,
1821
		 "%pOF: Ignoring %d default trigger\n", of_node, type))
1822
		type = IRQ_TYPE_NONE;
1823 1824 1825 1826 1827
	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;
	}
1828

1829
	gpiochip->irq.chip = irqchip;
1830
	gpiochip->irq.handler = handler;
1831
	gpiochip->irq.default_type = type;
1832
	gpiochip->to_irq = gpiochip_to_irq;
1833
	gpiochip->lock_key = lock_key;
1834
	gpiochip->irq.domain = irq_domain_add_simple(of_node,
1835 1836
					gpiochip->ngpio, first_irq,
					&gpiochip_domain_ops, gpiochip);
1837
	if (!gpiochip->irq.domain) {
1838
		gpiochip->irq.chip = NULL;
1839 1840
		return -EINVAL;
	}
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850

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

1852 1853
	acpi_gpiochip_request_interrupts(gpiochip);

1854 1855
	return 0;
}
1856
EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
1857 1858 1859 1860

#else /* CONFIG_GPIOLIB_IRQCHIP */

static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1861 1862 1863 1864 1865 1866
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)
{ }
1867 1868 1869

#endif /* CONFIG_GPIOLIB_IRQCHIP */

1870 1871 1872 1873 1874 1875 1876
/**
 * 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)
{
1877
	return pinctrl_request_gpio(chip->gpiodev->base + offset);
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887
}
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)
{
1888
	pinctrl_free_gpio(chip->gpiodev->base + offset);
1889 1890 1891
}
EXPORT_SYMBOL_GPL(gpiochip_generic_free);

1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904
/**
 * 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);

1905
#ifdef CONFIG_PINCTRL
1906

1907 1908 1909
/**
 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
1910
 * @pctldev: the pin controller to map to
1911 1912 1913 1914 1915 1916 1917 1918
 * @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;
1919
	struct gpio_device *gdev = chip->gpiodev;
1920 1921 1922 1923
	int ret;

	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
	if (!pin_range) {
1924
		chip_err(chip, "failed to allocate pin ranges\n");
1925 1926 1927 1928 1929 1930 1931
		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;
1932
	pin_range->range.base = gdev->base + gpio_offset;
1933 1934 1935 1936 1937
	pin_range->pctldev = pctldev;

	ret = pinctrl_get_group_pins(pctldev, pin_group,
					&pin_range->range.pins,
					&pin_range->range.npins);
1938 1939
	if (ret < 0) {
		kfree(pin_range);
1940
		return ret;
1941
	}
1942 1943 1944

	pinctrl_add_gpio_range(pctldev, &pin_range->range);

1945 1946
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
1947 1948
		 pinctrl_dev_get_devname(pctldev), pin_group);

1949
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
1950 1951 1952 1953 1954

	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);

1955 1956 1957
/**
 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
 * @chip: the gpiochip to add the range for
T
Thierry Reding 已提交
1958
 * @pinctl_name: the dev_name() of the pin controller to map to
1959 1960
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_offset: the start offset in the pin controller number space
1961 1962
 * @npins: the number of pins from the offset of each pin space (GPIO and
 *	pin controller) to accumulate in this range
T
Thierry Reding 已提交
1963 1964 1965
 *
 * Returns:
 * 0 on success, or a negative error-code on failure.
1966
 */
1967
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1968
			   unsigned int gpio_offset, unsigned int pin_offset,
1969
			   unsigned int npins)
1970 1971
{
	struct gpio_pin_range *pin_range;
1972
	struct gpio_device *gdev = chip->gpiodev;
1973
	int ret;
1974

1975
	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1976
	if (!pin_range) {
1977
		chip_err(chip, "failed to allocate pin ranges\n");
1978
		return -ENOMEM;
1979 1980
	}

1981
	/* Use local offset as range ID */
1982
	pin_range->range.id = gpio_offset;
1983
	pin_range->range.gc = chip;
1984
	pin_range->range.name = chip->label;
1985
	pin_range->range.base = gdev->base + gpio_offset;
1986
	pin_range->range.pin_base = pin_offset;
1987
	pin_range->range.npins = npins;
L
Linus Walleij 已提交
1988
	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1989
			&pin_range->range);
1990
	if (IS_ERR(pin_range->pctldev)) {
1991
		ret = PTR_ERR(pin_range->pctldev);
1992
		chip_err(chip, "could not create pin range\n");
1993
		kfree(pin_range);
1994
		return ret;
1995
	}
1996 1997
	chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
		 gpio_offset, gpio_offset + npins - 1,
1998 1999
		 pinctl_name,
		 pin_offset, pin_offset + npins - 1);
2000

2001
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
2002 2003

	return 0;
2004
}
2005
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2006

2007 2008 2009 2010
/**
 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
 * @chip: the chip to remove all the mappings for
 */
2011 2012 2013
void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
{
	struct gpio_pin_range *pin_range, *tmp;
2014
	struct gpio_device *gdev = chip->gpiodev;
2015

2016
	list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2017 2018 2019
		list_del(&pin_range->node);
		pinctrl_remove_gpio_range(pin_range->pctldev,
				&pin_range->range);
2020
		kfree(pin_range);
2021 2022
	}
}
2023 2024 2025
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);

#endif /* CONFIG_PINCTRL */
2026

2027 2028 2029 2030
/* 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.
 */
2031
static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2032
{
2033
	struct gpio_chip	*chip = desc->gdev->chip;
2034
	int			status;
2035 2036
	unsigned long		flags;

2037 2038
	spin_lock_irqsave(&gpio_lock, flags);

2039
	/* NOTE:  gpio_request() can be called in early boot,
D
David Brownell 已提交
2040
	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2041 2042 2043 2044 2045
	 */

	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
		desc_set_label(desc, label ? : "?");
		status = 0;
2046
	} else {
2047
		status = -EBUSY;
M
Magnus Damm 已提交
2048
		goto done;
D
David Brownell 已提交
2049 2050 2051 2052 2053
	}

	if (chip->request) {
		/* chip->request may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2054
		status = chip->request(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2055 2056 2057 2058 2059
		spin_lock_irqsave(&gpio_lock, flags);

		if (status < 0) {
			desc_set_label(desc, NULL);
			clear_bit(FLAG_REQUESTED, &desc->flags);
2060
			goto done;
D
David Brownell 已提交
2061
		}
2062
	}
2063 2064 2065
	if (chip->get_direction) {
		/* chip->get_direction may sleep */
		spin_unlock_irqrestore(&gpio_lock, flags);
2066
		gpiod_get_direction(desc);
2067 2068
		spin_lock_irqsave(&gpio_lock, flags);
	}
2069 2070 2071 2072 2073
done:
	spin_unlock_irqrestore(&gpio_lock, flags);
	return status;
}

2074 2075 2076
/*
 * This descriptor validation needs to be inserted verbatim into each
 * function taking a descriptor, so we need to use a preprocessor
2077 2078
 * macro to avoid endless duplication. If the desc is NULL it is an
 * optional GPIO and calls should just bail out.
2079 2080
 */
#define VALIDATE_DESC(desc) do { \
2081 2082
	if (!desc) \
		return 0; \
2083 2084 2085 2086
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return PTR_ERR(desc); \
	} \
2087
	if (!desc->gdev) { \
2088
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2089 2090 2091 2092 2093 2094 2095 2096 2097
		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 { \
2098 2099
	if (!desc) \
		return; \
2100 2101 2102 2103
	if (IS_ERR(desc)) {						\
		pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
		return; \
	} \
2104
	if (!desc->gdev) { \
2105
		pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2106 2107 2108 2109 2110 2111 2112 2113 2114
		return; \
	} \
	if (!desc->gdev->chip) { \
		dev_warn(&desc->gdev->dev, \
			 "%s: backing chip is gone\n", __func__); \
		return; \
	} } while (0)


2115
int gpiod_request(struct gpio_desc *desc, const char *label)
2116 2117
{
	int status = -EPROBE_DEFER;
2118
	struct gpio_device *gdev;
2119

2120 2121
	VALIDATE_DESC(desc);
	gdev = desc->gdev;
2122

2123
	if (try_module_get(gdev->owner)) {
2124
		status = gpiod_request_commit(desc, label);
2125
		if (status < 0)
2126
			module_put(gdev->owner);
2127 2128
		else
			get_device(&gdev->dev);
2129 2130
	}

2131
	if (status)
2132
		gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2133

2134 2135
	return status;
}
2136

2137
static bool gpiod_free_commit(struct gpio_desc *desc)
2138
{
2139
	bool			ret = false;
2140
	unsigned long		flags;
D
David Brownell 已提交
2141
	struct gpio_chip	*chip;
2142

2143 2144
	might_sleep();

2145
	gpiod_unexport(desc);
D
David Brownell 已提交
2146

2147 2148
	spin_lock_irqsave(&gpio_lock, flags);

2149
	chip = desc->gdev->chip;
D
David Brownell 已提交
2150 2151 2152
	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
		if (chip->free) {
			spin_unlock_irqrestore(&gpio_lock, flags);
2153
			might_sleep_if(chip->can_sleep);
2154
			chip->free(chip, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
2155 2156
			spin_lock_irqsave(&gpio_lock, flags);
		}
2157
		desc_set_label(desc, NULL);
2158
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
D
David Brownell 已提交
2159
		clear_bit(FLAG_REQUESTED, &desc->flags);
2160
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2161
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
B
Benoit Parrot 已提交
2162
		clear_bit(FLAG_IS_HOGGED, &desc->flags);
2163 2164
		ret = true;
	}
2165 2166

	spin_unlock_irqrestore(&gpio_lock, flags);
2167 2168 2169
	return ret;
}

2170
void gpiod_free(struct gpio_desc *desc)
2171
{
2172
	if (desc && desc->gdev && gpiod_free_commit(desc)) {
2173
		module_put(desc->gdev->owner);
2174 2175
		put_device(&desc->gdev->dev);
	} else {
2176
		WARN_ON(extra_checks);
2177
	}
2178
}
2179

2180 2181 2182 2183 2184 2185
/**
 * 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.
2186 2187
 * The string returned is the label passed to gpio_request(); if none has been
 * passed it is a meaningless, non-NULL constant.
2188 2189 2190 2191 2192 2193 2194
 *
 * 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)
{
2195
	struct gpio_desc *desc;
2196

2197
	if (offset >= chip->ngpio)
2198
		return NULL;
2199

2200
	desc = &chip->gpiodev->descs[offset];
2201

2202
	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2203
		return NULL;
2204
	return desc->label;
2205 2206 2207
}
EXPORT_SYMBOL_GPL(gpiochip_is_requested);

2208 2209
/**
 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
T
Thierry Reding 已提交
2210 2211
 * @chip: GPIO chip
 * @hwnum: hardware number of the GPIO for which to request the descriptor
2212 2213 2214 2215 2216 2217 2218
 * @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 已提交
2219 2220 2221 2222
 *
 * Returns:
 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
 * code on failure.
2223
 */
2224 2225
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
					    const char *label)
2226
{
2227 2228
	struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
	int err;
2229

2230 2231 2232 2233 2234
	if (IS_ERR(desc)) {
		chip_err(chip, "failed to get GPIO descriptor\n");
		return desc;
	}

2235
	err = gpiod_request_commit(desc, label);
2236 2237
	if (err < 0)
		return ERR_PTR(err);
2238

2239
	return desc;
2240
}
2241
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252

/**
 * 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)
2253
		gpiod_free_commit(desc);
2254
}
2255
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2256

2257 2258
/*
 * Drivers MUST set GPIO direction before making get/set calls.  In
2259 2260 2261 2262 2263 2264 2265 2266
 * 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.
 */

2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
/**
 * 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)
2277 2278 2279 2280
{
	struct gpio_chip	*chip;
	int			status = -EINVAL;

2281 2282
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2283

2284
	if (!chip->get || !chip->direction_input) {
2285 2286
		gpiod_warn(desc,
			"%s: missing get() or direction_input() operations\n",
2287
			__func__);
2288 2289 2290
		return -EIO;
	}

2291
	status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2292 2293
	if (status == 0)
		clear_bit(FLAG_IS_OUT, &desc->flags);
2294

2295
	trace_gpio_direction(desc_to_gpio(desc), 1, status);
2296

2297 2298
	return status;
}
2299
EXPORT_SYMBOL_GPL(gpiod_direction_input);
2300

2301 2302 2303 2304 2305 2306 2307 2308
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;
}

2309
static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
2310
{
2311
	struct gpio_chip *gc = desc->gdev->chip;
2312
	int val = !!value;
2313
	int ret;
2314

2315
	if (!gc->set || !gc->direction_output) {
2316 2317 2318
		gpiod_warn(desc,
		       "%s: missing set() or direction_output() operations\n",
		       __func__);
2319 2320 2321
		return -EIO;
	}

2322
	ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2323
	if (!ret)
2324
		set_bit(FLAG_IS_OUT, &desc->flags);
2325
	trace_gpio_value(desc_to_gpio(desc), 0, val);
2326 2327
	trace_gpio_direction(desc_to_gpio(desc), 0, ret);
	return ret;
2328
}
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342

/**
 * 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)
{
2343
	VALIDATE_DESC(desc);
2344
	return gpiod_direction_output_raw_commit(desc, value);
2345 2346 2347 2348
}
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);

/**
2349
 * gpiod_direction_output - set the GPIO direction to output
2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361
 * @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)
{
2362 2363 2364
	struct gpio_chip *gc = desc->gdev->chip;
	int ret;

2365
	VALIDATE_DESC(desc);
2366 2367
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2368 2369
	else
		value = !!value;
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402

	/* 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:
2403
	return gpiod_direction_output_raw_commit(desc, value);
2404
}
2405
EXPORT_SYMBOL_GPL(gpiod_direction_output);
2406

2407
/**
T
Thierry Reding 已提交
2408 2409 2410
 * 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
2411
 *
T
Thierry Reding 已提交
2412 2413 2414
 * Returns:
 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
 * debounce time.
2415
 */
2416
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2417 2418
{
	struct gpio_chip	*chip;
2419
	unsigned long		config;
2420

2421 2422
	VALIDATE_DESC(desc);
	chip = desc->gdev->chip;
2423
	if (!chip->set || !chip->set_config) {
2424
		gpiod_dbg(desc,
2425
			  "%s: missing set() or set_config() operations\n",
2426
			  __func__);
2427
		return -ENOTSUPP;
2428 2429
	}

2430 2431
	config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
	return chip->set_config(chip, gpio_chip_hwgpio(desc), config);
2432
}
2433
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2434

2435 2436 2437 2438 2439 2440 2441
/**
 * 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)
2442
{
2443
	VALIDATE_DESC(desc);
2444
	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2445
}
2446
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469

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

2470
static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
2471 2472
{
	struct gpio_chip	*chip;
2473
	int offset;
2474
	int value;
2475

2476
	chip = desc->gdev->chip;
2477
	offset = gpio_chip_hwgpio(desc);
2478
	value = chip->get ? chip->get(chip, offset) : -EIO;
2479
	value = value < 0 ? value : !!value;
2480
	trace_gpio_value(desc_to_gpio(desc), 1, value);
2481
	return value;
2482
}
2483

2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548
static int gpio_chip_get_multiple(struct gpio_chip *chip,
				  unsigned long *mask, unsigned long *bits)
{
	if (chip->get_multiple) {
		return chip->get_multiple(chip, mask, bits);
	} else if (chip->get) {
		int i, value;

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

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

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

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

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

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

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

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

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

2549
/**
2550 2551
 * gpiod_get_raw_value() - return a gpio's raw value
 * @desc: gpio whose value will be returned
2552
 *
2553
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2554
 * its ACTIVE_LOW status, or negative errno on failure.
2555 2556 2557
 *
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2558
 */
2559
int gpiod_get_raw_value(const struct gpio_desc *desc)
2560
{
2561
	VALIDATE_DESC(desc);
2562
	/* Should be using gpio_get_value_cansleep() */
2563
	WARN_ON(desc->gdev->chip->can_sleep);
2564
	return gpiod_get_raw_value_commit(desc);
2565
}
2566
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2567

2568 2569 2570 2571 2572
/**
 * 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
2573
 * account, or negative errno on failure.
2574 2575 2576 2577 2578
 *
 * 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)
2579
{
2580
	int value;
2581 2582

	VALIDATE_DESC(desc);
2583
	/* Should be using gpio_get_value_cansleep() */
2584
	WARN_ON(desc->gdev->chip->can_sleep);
2585

2586
	value = gpiod_get_raw_value_commit(desc);
2587 2588 2589
	if (value < 0)
		return value;

2590 2591 2592 2593
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
2594
}
2595
EXPORT_SYMBOL_GPL(gpiod_get_value);
2596

2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641
/**
 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
 * else an error code.
 *
 * This function should be called from contexts where we cannot sleep,
 * and it will complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_raw_array_value(unsigned int array_size,
			      struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, false, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);

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

2642
/*
2643
 *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
2644
 * @desc: gpio descriptor whose state need to be set.
2645
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2646
 */
2647
static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
2648 2649
{
	int err = 0;
2650
	struct gpio_chip *chip = desc->gdev->chip;
2651 2652
	int offset = gpio_chip_hwgpio(desc);

2653
	if (value) {
2654
		err = chip->direction_input(chip, offset);
2655
		if (!err)
2656
			clear_bit(FLAG_IS_OUT, &desc->flags);
2657
	} else {
2658
		err = chip->direction_output(chip, offset, 0);
2659
		if (!err)
2660
			set_bit(FLAG_IS_OUT, &desc->flags);
2661
	}
2662
	trace_gpio_direction(desc_to_gpio(desc), value, err);
2663
	if (err < 0)
2664 2665 2666
		gpiod_err(desc,
			  "%s: Error in set_value for open drain err %d\n",
			  __func__, err);
2667 2668
}

2669
/*
2670 2671
 *  _gpio_set_open_source_value() - Set the open source gpio's value.
 * @desc: gpio descriptor whose state need to be set.
2672
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2673
 */
2674
static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
2675 2676
{
	int err = 0;
2677
	struct gpio_chip *chip = desc->gdev->chip;
2678 2679
	int offset = gpio_chip_hwgpio(desc);

2680
	if (value) {
2681
		err = chip->direction_output(chip, offset, 1);
2682
		if (!err)
2683
			set_bit(FLAG_IS_OUT, &desc->flags);
2684
	} else {
2685
		err = chip->direction_input(chip, offset);
2686
		if (!err)
2687
			clear_bit(FLAG_IS_OUT, &desc->flags);
2688
	}
2689
	trace_gpio_direction(desc_to_gpio(desc), !value, err);
2690
	if (err < 0)
2691 2692 2693
		gpiod_err(desc,
			  "%s: Error in set_value for open source err %d\n",
			  __func__, err);
2694 2695
}

2696
static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
2697 2698 2699
{
	struct gpio_chip	*chip;

2700
	chip = desc->gdev->chip;
2701
	trace_gpio_value(desc_to_gpio(desc), 0, value);
2702
	chip->set(chip, gpio_chip_hwgpio(desc), value);
2703 2704
}

2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719
/*
 * 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 {
2720 2721 2722 2723 2724
		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));
2725 2726 2727
	}
}

2728 2729 2730 2731
void gpiod_set_array_value_complex(bool raw, bool can_sleep,
				   unsigned int array_size,
				   struct gpio_desc **desc_array,
				   int *value_array)
2732 2733 2734 2735
{
	int i = 0;

	while (i < array_size) {
2736
		struct gpio_chip *chip = desc_array[i]->gdev->chip;
2737 2738 2739 2740
		unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
		unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
		int count = 0;

D
Daniel Lockyer 已提交
2741
		if (!can_sleep)
2742
			WARN_ON(chip->can_sleep);
D
Daniel Lockyer 已提交
2743

2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756
		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
			 */
2757
			if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
2758
				gpio_set_open_drain_value_commit(desc, value);
2759
			} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
2760
				gpio_set_open_source_value_commit(desc, value);
2761 2762
			} else {
				__set_bit(hwgpio, mask);
D
Daniel Lockyer 已提交
2763
				if (value)
2764
					__set_bit(hwgpio, bits);
D
Daniel Lockyer 已提交
2765
				else
2766 2767 2768 2769
					__clear_bit(hwgpio, bits);
				count++;
			}
			i++;
2770 2771
		} while ((i < array_size) &&
			 (desc_array[i]->gdev->chip == chip));
2772
		/* push collected bits to outputs */
D
Daniel Lockyer 已提交
2773
		if (count != 0)
2774 2775 2776 2777
			gpio_chip_set_multiple(chip, mask, bits);
	}
}

2778
/**
2779 2780
 * gpiod_set_raw_value() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
2781 2782
 * @value: value to assign
 *
2783 2784 2785 2786 2787
 * 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.
2788
 */
2789
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2790
{
2791
	VALIDATE_DESC_VOID(desc);
2792
	/* Should be using gpiod_set_value_cansleep() */
2793
	WARN_ON(desc->gdev->chip->can_sleep);
2794
	gpiod_set_raw_value_commit(desc, value);
2795
}
2796
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2797 2798

/**
2799 2800 2801 2802
 * gpiod_set_value() - assign a gpio's value
 * @desc: gpio whose value will be assigned
 * @value: value to assign
 *
2803 2804
 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
 * OPEN_DRAIN and OPEN_SOURCE flags into account.
2805
 *
2806 2807
 * This function should be called from contexts where we cannot sleep, and will
 * complain if the GPIO chip functions potentially sleep.
2808
 */
2809
void gpiod_set_value(struct gpio_desc *desc, int value)
2810
{
2811
	VALIDATE_DESC_VOID(desc);
2812
	/* Should be using gpiod_set_value_cansleep() */
2813
	WARN_ON(desc->gdev->chip->can_sleep);
2814 2815
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
2816 2817 2818 2819 2820 2821
	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);
2822
}
2823
EXPORT_SYMBOL_GPL(gpiod_set_value);
2824

2825
/**
2826
 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
 * @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.
 */
2837
void gpiod_set_raw_array_value(unsigned int array_size,
2838 2839 2840 2841
			 struct gpio_desc **desc_array, int *value_array)
{
	if (!desc_array)
		return;
2842 2843
	gpiod_set_array_value_complex(true, false, array_size, desc_array,
				      value_array);
2844
}
2845
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
2846 2847

/**
2848
 * gpiod_set_array_value() - assign values to an array of GPIOs
2849 2850 2851 2852 2853 2854 2855 2856 2857 2858
 * @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.
 */
2859 2860
void gpiod_set_array_value(unsigned int array_size,
			   struct gpio_desc **desc_array, int *value_array)
2861 2862 2863
{
	if (!desc_array)
		return;
2864 2865
	gpiod_set_array_value_complex(false, false, array_size, desc_array,
				      value_array);
2866
}
2867
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
2868

2869
/**
2870 2871
 * gpiod_cansleep() - report whether gpio value access may sleep
 * @desc: gpio to check
2872 2873
 *
 */
2874
int gpiod_cansleep(const struct gpio_desc *desc)
2875
{
2876 2877
	VALIDATE_DESC(desc);
	return desc->gdev->chip->can_sleep;
2878
}
2879
EXPORT_SYMBOL_GPL(gpiod_cansleep);
2880

D
David Brownell 已提交
2881
/**
2882 2883
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
D
David Brownell 已提交
2884
 *
2885 2886
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
D
David Brownell 已提交
2887
 */
2888
int gpiod_to_irq(const struct gpio_desc *desc)
D
David Brownell 已提交
2889
{
2890 2891
	struct gpio_chip *chip;
	int offset;
D
David Brownell 已提交
2892

2893 2894 2895 2896 2897
	/*
	 * 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.
	 */
2898
	if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
2899 2900
		return -EINVAL;

2901
	chip = desc->gdev->chip;
2902
	offset = gpio_chip_hwgpio(desc);
2903 2904 2905 2906 2907 2908 2909 2910 2911 2912
	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 已提交
2913
}
2914
EXPORT_SYMBOL_GPL(gpiod_to_irq);
D
David Brownell 已提交
2915

2916
/**
2917
 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
2918 2919
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2920 2921
 *
 * This is used directly by GPIO drivers that want to lock down
2922
 * a certain GPIO line to be used for IRQs.
2923
 */
2924
int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2925
{
2926 2927 2928 2929 2930 2931
	struct gpio_desc *desc;

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

2932 2933 2934 2935 2936
	/*
	 * If it's fast: flush the direction setting if something changed
	 * behind our back
	 */
	if (!chip->can_sleep && chip->get_direction) {
2937 2938 2939 2940 2941 2942 2943
		int dir = chip->get_direction(chip, offset);

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

2945
	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2946
		chip_err(chip,
2947 2948 2949 2950 2951
			  "%s: tried to flag a GPIO set as output for IRQ\n",
			  __func__);
		return -EIO;
	}

2952
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2953 2954 2955 2956 2957 2958 2959 2960 2961

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

2962
	return 0;
2963
}
2964
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
2965

2966
/**
2967
 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
2968 2969
 * @chip: the chip the GPIO to lock belongs to
 * @offset: the offset of the GPIO to lock as IRQ
2970 2971 2972
 *
 * This is used directly by GPIO drivers that want to indicate
 * that a certain GPIO is no longer used exclusively for IRQ.
2973
 */
2974
void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2975
{
2976 2977 2978 2979
	struct gpio_desc *desc;

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

2982 2983 2984 2985 2986
	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);
2987
}
2988
EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
2989

2990 2991 2992 2993 2994 2995 2996 2997 2998
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);

2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016
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);

3017 3018 3019 3020 3021
bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
{
	if (offset >= chip->ngpio)
		return false;

A
Andrew Jeffery 已提交
3022
	return !test_bit(FLAG_SLEEP_MAY_LOSE_VALUE,
3023 3024 3025 3026
			 &chip->gpiodev->descs[offset].flags);
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);

3027 3028 3029 3030 3031
/**
 * 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
3032
 * its ACTIVE_LOW status, or negative errno on failure.
3033 3034
 *
 * This function is to be called from contexts that can sleep.
3035
 */
3036
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
3037 3038
{
	might_sleep_if(extra_checks);
3039
	VALIDATE_DESC(desc);
3040
	return gpiod_get_raw_value_commit(desc);
3041
}
3042
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
3043

3044 3045 3046 3047 3048
/**
 * 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
3049
 * account, or negative errno on failure.
3050 3051 3052 3053
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
3054
{
3055
	int value;
3056 3057

	might_sleep_if(extra_checks);
3058
	VALIDATE_DESC(desc);
3059
	value = gpiod_get_raw_value_commit(desc);
3060 3061 3062
	if (value < 0)
		return value;

3063 3064 3065
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

3066
	return value;
3067
}
3068
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
3069

3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116
/**
 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
 * @array_size: number of elements in the descriptor / value arrays
 * @desc_array: array of GPIO descriptors whose values will be read
 * @value_array: array to store the read values
 *
 * Read the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
 * else an error code.
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
				       struct gpio_desc **desc_array,
				       int *value_array)
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, true, array_size,
					     desc_array, value_array);
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);

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

3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127
/**
 * 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)
3128
{
3129
	might_sleep_if(extra_checks);
3130
	VALIDATE_DESC_VOID(desc);
3131
	gpiod_set_raw_value_commit(desc, value);
3132
}
3133
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
3134

3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145
/**
 * 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)
3146 3147
{
	might_sleep_if(extra_checks);
3148
	VALIDATE_DESC_VOID(desc);
3149 3150
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
3151
	gpiod_set_raw_value_commit(desc, value);
3152
}
3153
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
3154

3155
/**
3156
 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
3157 3158 3159 3160 3161 3162 3163 3164 3165
 * @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.
 */
3166 3167 3168
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
					struct gpio_desc **desc_array,
					int *value_array)
3169 3170 3171 3172
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3173 3174
	gpiod_set_array_value_complex(true, true, array_size, desc_array,
				      value_array);
3175
}
3176
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
3177

3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194
/**
 * 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);
}

3195
/**
3196
 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
3197 3198 3199 3200 3201 3202 3203 3204 3205
 * @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.
 */
3206 3207 3208
void gpiod_set_array_value_cansleep(unsigned int array_size,
				    struct gpio_desc **desc_array,
				    int *value_array)
3209 3210 3211 3212
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return;
3213 3214
	gpiod_set_array_value_complex(false, true, array_size, desc_array,
				      value_array);
3215
}
3216
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
3217

3218
/**
3219 3220
 * gpiod_add_lookup_table() - register GPIO device consumers
 * @table: table of consumers to register
3221
 */
3222
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
3223 3224 3225
{
	mutex_lock(&gpio_lookup_lock);

3226
	list_add_tail(&table->list, &gpio_lookup_list);
3227 3228 3229

	mutex_unlock(&gpio_lookup_lock);
}
3230
EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
3231

3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
/**
 * 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);
}
3244
EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
3245

3246
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
3247 3248
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
3249
	struct gpiod_lookup_table *table;
3250 3251 3252

	mutex_lock(&gpio_lookup_lock);

3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270
	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;
3271

3272 3273 3274 3275
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
3276

3277 3278 3279 3280
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
				    unsigned int idx,
				    enum gpio_lookup_flags *flags)
{
3281
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
3282 3283
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
3284

3285 3286 3287
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
3288

3289 3290
	for (p = &table->table[0]; p->chip_label; p++) {
		struct gpio_chip *chip;
3291

3292
		/* idx must always match exactly */
3293 3294 3295
		if (p->idx != idx)
			continue;

3296 3297 3298
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
3299

3300
		chip = find_chip_by_name(p->chip_label);
3301

3302
		if (!chip) {
3303 3304 3305
			dev_err(dev, "cannot find GPIO chip %s\n",
				p->chip_label);
			return ERR_PTR(-ENODEV);
3306
		}
3307

3308
		if (chip->ngpio <= p->chip_hwnum) {
3309 3310 3311 3312
			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);
3313 3314
		}

3315
		desc = gpiochip_get_desc(chip, p->chip_hwnum);
3316
		*flags = p->flags;
3317

3318
		return desc;
3319 3320 3321 3322 3323
	}

	return desc;
}

3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
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);
3339
		if (ret > 0)
3340 3341
			break;
	}
3342
	return ret ? ret : -ENOENT;
3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
}

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

3388
/**
3389
 * gpiod_get - obtain a GPIO for a given GPIO function
3390
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3391
 * @con_id:	function within the GPIO consumer
3392
 * @flags:	optional GPIO initialization flags
3393 3394
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
3395
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3396
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3397
 */
3398
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3399
					 enum gpiod_flags flags)
3400
{
3401
	return gpiod_get_index(dev, con_id, 0, flags);
3402
}
3403
EXPORT_SYMBOL_GPL(gpiod_get);
3404

3405 3406 3407 3408
/**
 * 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
3409
 * @flags: optional GPIO initialization flags
3410 3411 3412 3413 3414
 *
 * 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.
 */
3415
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
3416 3417
						  const char *con_id,
						  enum gpiod_flags flags)
3418
{
3419
	return gpiod_get_index_optional(dev, con_id, 0, flags);
3420
}
3421
EXPORT_SYMBOL_GPL(gpiod_get_optional);
3422

B
Benoit Parrot 已提交
3423 3424 3425 3426 3427

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
3428 3429
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
 *		of_get_gpio_hog()
B
Benoit Parrot 已提交
3430 3431 3432 3433 3434 3435
 * @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.
 */
3436
int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
3437
		unsigned long lflags, enum gpiod_flags dflags)
B
Benoit Parrot 已提交
3438 3439 3440
{
	int status;

3441 3442 3443 3444 3445 3446
	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);
A
Andrew Jeffery 已提交
3447 3448
	if (lflags & GPIO_SLEEP_MAY_LOSE_VALUE)
		set_bit(FLAG_SLEEP_MAY_LOSE_VALUE, &desc->flags);
3449

B
Benoit Parrot 已提交
3450 3451 3452 3453 3454 3455 3456 3457 3458
	/* 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,
3459
				!!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
B
Benoit Parrot 已提交
3460 3461 3462 3463 3464 3465
	else
		status = gpiod_direction_input(desc);

	return status;
}

3466 3467
/**
 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
3468
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
3469 3470
 * @con_id:	function within the GPIO consumer
 * @idx:	index of the GPIO to obtain in the consumer
3471
 * @flags:	optional GPIO initialization flags
3472 3473 3474 3475
 *
 * This variant of gpiod_get() allows to access GPIOs other than the first
 * defined one for functions that define several GPIOs.
 *
3476 3477
 * 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
3478
 * occurred while trying to acquire the GPIO.
3479
 */
3480
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
3481
					       const char *con_id,
3482 3483
					       unsigned int idx,
					       enum gpiod_flags flags)
3484
{
3485
	struct gpio_desc *desc = NULL;
3486
	int status;
3487
	enum gpio_lookup_flags lookupflags = 0;
3488 3489 3490

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

3491 3492 3493 3494 3495 3496 3497
	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");
3498
			desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
3499
		}
3500 3501 3502 3503 3504 3505
	}

	/*
	 * 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.
	 */
3506
	if (!desc || desc == ERR_PTR(-ENOENT)) {
3507
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
3508
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
3509 3510 3511
	}

	if (IS_ERR(desc)) {
3512
		dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
3513 3514 3515 3516 3517 3518 3519
		return desc;
	}

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

3520
	status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
3521 3522 3523 3524 3525 3526
	if (status < 0) {
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
		gpiod_put(desc);
		return ERR_PTR(status);
	}

3527 3528
	return desc;
}
3529
EXPORT_SYMBOL_GPL(gpiod_get_index);
3530

3531 3532 3533 3534
/**
 * 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
3535
 * @index:	index of the GPIO to obtain in the consumer
3536
 * @dflags:	GPIO initialization flags
T
Thierry Reding 已提交
3537
 * @label:	label to attach to the requested GPIO
3538 3539 3540 3541 3542 3543 3544 3545
 *
 * 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 已提交
3546
 * Returns:
3547
 * On successful request the GPIO pin is configured in accordance with
3548 3549
 * provided @dflags.
 *
3550 3551 3552
 * In case of error an ERR_PTR() is returned.
 */
struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
3553
					 const char *propname, int index,
3554 3555
					 enum gpiod_flags dflags,
					 const char *label)
3556 3557
{
	struct gpio_desc *desc = ERR_PTR(-ENODEV);
3558
	unsigned long lflags = 0;
3559
	bool active_low = false;
3560
	bool single_ended = false;
3561
	bool open_drain = false;
3562 3563 3564 3565 3566 3567 3568 3569
	int ret;

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

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

3570 3571
		desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname,
						index, &flags);
3572
		if (!IS_ERR(desc)) {
3573
			active_low = flags & OF_GPIO_ACTIVE_LOW;
3574
			single_ended = flags & OF_GPIO_SINGLE_ENDED;
3575
			open_drain = flags & OF_GPIO_OPEN_DRAIN;
3576
		}
3577 3578 3579
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

3580
		desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
3581
		if (!IS_ERR(desc)) {
3582
			active_low = info.polarity == GPIO_ACTIVE_LOW;
3583 3584 3585 3586
			ret = acpi_gpio_update_gpiod_flags(&dflags, info.flags);
			if (ret)
				pr_debug("Override GPIO initialization flags\n");
		}
3587 3588 3589 3590 3591
	}

	if (IS_ERR(desc))
		return desc;

3592
	ret = gpiod_request(desc, label);
3593 3594 3595
	if (ret)
		return ERR_PTR(ret);

3596
	if (active_low)
3597
		lflags |= GPIO_ACTIVE_LOW;
3598

3599
	if (single_ended) {
3600
		if (open_drain)
3601
			lflags |= GPIO_OPEN_DRAIN;
3602
		else
3603 3604 3605 3606 3607 3608 3609
			lflags |= GPIO_OPEN_SOURCE;
	}

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

3612 3613 3614 3615
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

3616 3617 3618 3619 3620 3621
/**
 * 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
3622
 * @flags: optional GPIO initialization flags
3623 3624 3625 3626 3627
 *
 * 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.
 */
3628
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
3629
							const char *con_id,
3630 3631
							unsigned int index,
							enum gpiod_flags flags)
3632 3633 3634
{
	struct gpio_desc *desc;

3635
	desc = gpiod_get_index(dev, con_id, index, flags);
3636 3637 3638 3639 3640 3641 3642
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
3643
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
3644

B
Benoit Parrot 已提交
3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665
/**
 * 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)) {
3666 3667 3668 3669
		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 已提交
3670 3671
	}

3672
	status = gpiod_configure_flags(desc, name, lflags, dflags);
B
Benoit Parrot 已提交
3673
	if (status < 0) {
3674 3675
		pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
		       name, chip->label, hwnum, status);
B
Benoit Parrot 已提交
3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
		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++) {
3703 3704
		if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
B
Benoit Parrot 已提交
3705 3706 3707
	}
}

3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773
/**
 * 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);

3774 3775 3776 3777 3778 3779 3780 3781 3782
/**
 * 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);
3783
}
3784
EXPORT_SYMBOL_GPL(gpiod_put);
3785

3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800
/**
 * 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);

3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815
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);
3816 3817 3818
	} else {
		gpiolib_initialized = true;
		gpiochip_setup_devs();
3819 3820 3821 3822 3823
	}
	return ret;
}
core_initcall(gpiolib_dev_init);

3824 3825
#ifdef CONFIG_DEBUG_FS

3826
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
3827 3828
{
	unsigned		i;
3829 3830 3831
	struct gpio_chip	*chip = gdev->chip;
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
3832
	int			is_out;
3833
	int			is_irq;
3834

3835
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
3836 3837 3838 3839 3840
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
3841
			continue;
3842
		}
3843

3844
		gpiod_get_direction(gdesc);
3845
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
3846
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
3847 3848
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
3849 3850 3851
			is_out ? "out" : "in ",
			chip->get
				? (chip->get(chip, i) ? "hi" : "lo")
3852 3853
				: "?  ",
			is_irq ? "IRQ" : "   ");
3854 3855 3856 3857
		seq_printf(s, "\n");
	}
}

3858
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
3859
{
3860
	unsigned long flags;
3861
	struct gpio_device *gdev = NULL;
3862
	loff_t index = *pos;
3863

3864
	s->private = "";
3865

3866
	spin_lock_irqsave(&gpio_lock, flags);
3867
	list_for_each_entry(gdev, &gpio_devices, list)
3868 3869
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
3870
			return gdev;
3871
		}
3872
	spin_unlock_irqrestore(&gpio_lock, flags);
3873

3874
	return NULL;
3875 3876 3877 3878
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
3879
	unsigned long flags;
3880
	struct gpio_device *gdev = v;
3881 3882
	void *ret = NULL;

3883
	spin_lock_irqsave(&gpio_lock, flags);
3884
	if (list_is_last(&gdev->list, &gpio_devices))
3885 3886
		ret = NULL;
	else
3887
		ret = list_entry(gdev->list.next, struct gpio_device, list);
3888
	spin_unlock_irqrestore(&gpio_lock, flags);
3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901

	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)
{
3902 3903 3904 3905 3906 3907 3908 3909 3910
	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;
	}
3911

3912 3913
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
3914
		   gdev->base, gdev->base + gdev->ngpio - 1);
3915 3916 3917 3918 3919
	parent = chip->parent;
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
3920 3921 3922 3923 3924 3925 3926 3927 3928
	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
3929
		gpiolib_dbg_show(s, gdev);
3930

3931 3932 3933
	return 0;
}

3934 3935 3936 3937 3938 3939 3940
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

3941 3942
static int gpiolib_open(struct inode *inode, struct file *file)
{
3943
	return seq_open(file, &gpiolib_seq_ops);
3944 3945
}

3946
static const struct file_operations gpiolib_operations = {
3947
	.owner		= THIS_MODULE,
3948 3949 3950
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
3951
	.release	= seq_release,
3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963
};

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