gpiolib.c 144.0 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2
#include <linux/bitmap.h>
3 4
#include <linux/kernel.h>
#include <linux/module.h>
5
#include <linux/interrupt.h>
6 7
#include <linux/irq.h>
#include <linux/spinlock.h>
8
#include <linux/list.h>
D
David Brownell 已提交
9 10 11 12 13
#include <linux/device.h>
#include <linux/err.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/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
#include "gpiolib.h"
L
Linus Walleij 已提交
32
#include "gpiolib-of.h"
33
#include "gpiolib-acpi.h"
34

35 36
#define CREATE_TRACE_POINTS
#include <trace/events/gpio.h>
37

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


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

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

L
Laura Abbott 已提交
66 67 68 69 70
/*
 * Number of GPIOs to use for the fast path in set array
 */
#define FASTPATH_NGPIO CONFIG_GPIOLIB_FASTPATH_LIMIT

71 72 73 74
/* 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.
 */
75
DEFINE_SPINLOCK(gpio_lock);
76

77 78
static DEFINE_MUTEX(gpio_lookup_lock);
static LIST_HEAD(gpio_lookup_list);
79
LIST_HEAD(gpio_devices);
80

81 82 83
static DEFINE_MUTEX(gpio_machine_hogs_mutex);
static LIST_HEAD(gpio_machine_hogs);

84 85
static void gpiochip_free_hogs(struct gpio_chip *gc);
static int gpiochip_add_irqchip(struct gpio_chip *gc,
86 87
				struct lock_class_key *lock_key,
				struct lock_class_key *request_key);
88 89 90 91
static void gpiochip_irqchip_remove(struct gpio_chip *gc);
static int gpiochip_irqchip_init_hw(struct gpio_chip *gc);
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc);
static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gc);
92

93
static bool gpiolib_initialized;
94

95 96 97 98 99
static inline void desc_set_label(struct gpio_desc *d, const char *label)
{
	d->label = label;
}

100
/**
T
Thierry Reding 已提交
101 102 103 104 105 106
 * 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.
107
 */
108
struct gpio_desc *gpio_to_desc(unsigned gpio)
109
{
110
	struct gpio_device *gdev;
111 112 113 114
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

115
	list_for_each_entry(gdev, &gpio_devices, list) {
116 117
		if (gdev->base <= gpio &&
		    gdev->base + gdev->ngpio > gpio) {
118
			spin_unlock_irqrestore(&gpio_lock, flags);
119
			return &gdev->descs[gpio - gdev->base];
120 121 122 123 124
		}
	}

	spin_unlock_irqrestore(&gpio_lock, flags);

125 126 127
	if (!gpio_is_valid(gpio))
		WARN(1, "invalid GPIO %d\n", gpio);

128
	return NULL;
129
}
130
EXPORT_SYMBOL_GPL(gpio_to_desc);
131

132
/**
T
Thierry Reding 已提交
133 134
 * gpiochip_get_desc - get the GPIO descriptor corresponding to the given
 *                     hardware number for this chip
135
 * @gc: GPIO chip
T
Thierry Reding 已提交
136 137 138
 * @hwnum: hardware number of the GPIO for this chip
 *
 * Returns:
139
 * A pointer to the GPIO descriptor or ``ERR_PTR(-EINVAL)`` if no GPIO exists
T
Thierry Reding 已提交
140
 * in the given chip for the specified hardware number.
141
 */
142
struct gpio_desc *gpiochip_get_desc(struct gpio_chip *gc,
143
				    unsigned int hwnum)
144
{
145
	struct gpio_device *gdev = gc->gpiodev;
146 147

	if (hwnum >= gdev->ngpio)
148
		return ERR_PTR(-EINVAL);
149

150
	return &gdev->descs[hwnum];
151
}
M
Marco Felsch 已提交
152
EXPORT_SYMBOL_GPL(gpiochip_get_desc);
153 154

/**
T
Thierry Reding 已提交
155 156 157
 * desc_to_gpio - convert a GPIO descriptor to the integer namespace
 * @desc: GPIO descriptor
 *
158
 * This should disappear in the future but is needed since we still
T
Thierry Reding 已提交
159 160 161 162
 * use GPIO numbers for error messages and sysfs nodes.
 *
 * Returns:
 * The global GPIO number for the GPIO specified by its descriptor.
163
 */
164
int desc_to_gpio(const struct gpio_desc *desc)
165
{
166
	return desc->gdev->base + (desc - &desc->gdev->descs[0]);
167
}
168
EXPORT_SYMBOL_GPL(desc_to_gpio);
169 170


171 172 173 174 175
/**
 * 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)
176
{
177
	if (!desc || !desc->gdev)
178 179
		return NULL;
	return desc->gdev->chip;
180
}
181
EXPORT_SYMBOL_GPL(gpiod_to_chip);
182

183 184 185
/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
static int gpiochip_find_base(int ngpio)
{
186
	struct gpio_device *gdev;
187
	int base = ARCH_NR_GPIOS - ngpio;
188

189
	list_for_each_entry_reverse(gdev, &gpio_devices, list) {
190
		/* found a free space? */
191
		if (gdev->base + gdev->ngpio <= base)
192 193 194
			break;
		else
			/* nope, check the space right before the chip */
195
			base = gdev->base - ngpio;
196 197
	}

198
	if (gpio_is_valid(base)) {
199
		pr_debug("%s: found new base at %d\n", __func__, base);
200 201 202 203
		return base;
	} else {
		pr_err("%s: cannot find free range\n", __func__);
		return -ENOSPC;
A
Anton Vorontsov 已提交
204 205 206
	}
}

207 208 209 210
/**
 * gpiod_get_direction - return the current direction of a GPIO
 * @desc:	GPIO to get the direction of
 *
211
 * Returns 0 for output, 1 for input, or an error code in case of error.
212 213 214
 *
 * This function may sleep if gpiod_cansleep() is true.
 */
215
int gpiod_get_direction(struct gpio_desc *desc)
216
{
217
	struct gpio_chip *gc;
218
	unsigned offset;
219
	int ret;
220

221
	gc = gpiod_to_chip(desc);
222
	offset = gpio_chip_hwgpio(desc);
223

224 225 226 227 228 229 230 231
	/*
	 * Open drain emulation using input mode may incorrectly report
	 * input here, fix that up.
	 */
	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) &&
	    test_bit(FLAG_IS_OUT, &desc->flags))
		return 0;

232
	if (!gc->get_direction)
233
		return -ENOTSUPP;
234

235
	ret = gc->get_direction(gc, offset);
236 237 238 239 240
	if (ret < 0)
		return ret;

	/* GPIOF_DIR_IN or other positive, otherwise GPIOF_DIR_OUT */
	if (ret > 0)
241
		ret = 1;
242 243 244

	assign_bit(FLAG_IS_OUT, &desc->flags, !ret);

245
	return ret;
246
}
247
EXPORT_SYMBOL_GPL(gpiod_get_direction);
248

249 250
/*
 * Add a new chip to the global chips list, keeping the list of chips sorted
251
 * by range(means [base, base + ngpio - 1]) order.
252 253 254 255
 *
 * Return -EBUSY if the new chip overlaps with some other chip's integer
 * space.
 */
256
static int gpiodev_add_to_list(struct gpio_device *gdev)
257
{
258
	struct gpio_device *prev, *next;
259

260
	if (list_empty(&gpio_devices)) {
261
		/* initial entry in list */
262
		list_add_tail(&gdev->list, &gpio_devices);
S
Sudip Mukherjee 已提交
263
		return 0;
264 265
	}

266 267 268 269 270
	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;
271 272
	}

273 274 275 276
	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);
277
		return 0;
278 279
	}

280 281 282 283
	list_for_each_entry_safe(prev, next, &gpio_devices, list) {
		/* at the end of the list */
		if (&next->list == &gpio_devices)
			break;
284

285 286 287 288 289 290 291 292 293 294
		/* 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;
295 296
}

T
Thierry Reding 已提交
297
/*
298 299 300 301
 * Convert a GPIO name to its descriptor
 */
static struct gpio_desc *gpio_name_to_desc(const char * const name)
{
302
	struct gpio_device *gdev;
303 304
	unsigned long flags;

305 306 307
	if (!name)
		return NULL;

308 309
	spin_lock_irqsave(&gpio_lock, flags);

310
	list_for_each_entry(gdev, &gpio_devices, list) {
311 312
		int i;

313 314
		for (i = 0; i != gdev->ngpio; ++i) {
			struct gpio_desc *desc = &gdev->descs[i];
315

316
			if (!desc->name)
317 318
				continue;

319
			if (!strcmp(desc->name, name)) {
320
				spin_unlock_irqrestore(&gpio_lock, flags);
321
				return desc;
322 323 324 325 326 327 328 329 330
			}
		}
	}

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

331 332 333 334
/*
 * Takes the names from gc->names and checks if they are all unique. If they
 * are, they are assigned to their gpio descriptors.
 *
335
 * Warning if one of the names is already used for a different GPIO.
336 337 338
 */
static int gpiochip_set_desc_names(struct gpio_chip *gc)
{
339
	struct gpio_device *gdev = gc->gpiodev;
340 341 342 343 344 345 346 347 348 349
	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]);
350
		if (gpio)
351
			dev_warn(&gdev->dev,
352
				 "Detected name collision for GPIO name '%s'\n",
353
				 gc->names[i]);
354 355 356 357
	}

	/* Then add all names to the GPIO descriptors */
	for (i = 0; i != gc->ngpio; ++i)
358
		gdev->descs[i].name = gc->names[i];
359 360 361 362

	return 0;
}

363
static unsigned long *gpiochip_allocate_mask(struct gpio_chip *gc)
364 365 366
{
	unsigned long *p;

367
	p = bitmap_alloc(gc->ngpio, GFP_KERNEL);
368 369 370 371
	if (!p)
		return NULL;

	/* Assume by default all GPIOs are valid */
372
	bitmap_fill(p, gc->ngpio);
373 374 375 376

	return p;
}

L
Linus Walleij 已提交
377
static int gpiochip_alloc_valid_mask(struct gpio_chip *gc)
378
{
379
	if (!(of_gpio_need_valid_mask(gc) || gc->init_valid_mask))
380 381
		return 0;

L
Linus Walleij 已提交
382 383
	gc->valid_mask = gpiochip_allocate_mask(gc);
	if (!gc->valid_mask)
384 385 386 387 388
		return -ENOMEM;

	return 0;
}

389
static int gpiochip_init_valid_mask(struct gpio_chip *gc)
390
{
391 392 393 394
	if (gc->init_valid_mask)
		return gc->init_valid_mask(gc,
					   gc->valid_mask,
					   gc->ngpio);
395 396 397 398

	return 0;
}

399
static void gpiochip_free_valid_mask(struct gpio_chip *gc)
400
{
401 402
	bitmap_free(gc->valid_mask);
	gc->valid_mask = NULL;
403 404
}

405 406 407 408 409 410 411 412
static int gpiochip_add_pin_ranges(struct gpio_chip *gc)
{
	if (gc->add_pin_ranges)
		return gc->add_pin_ranges(gc);

	return 0;
}

413
bool gpiochip_line_is_valid(const struct gpio_chip *gc,
414 415 416
				unsigned int offset)
{
	/* No mask means all valid */
417
	if (likely(!gc->valid_mask))
418
		return true;
419
	return test_bit(offset, gc->valid_mask);
420 421 422
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_valid);

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
/*
 * 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;
};

441 442 443 444
#define GPIOHANDLE_REQUEST_VALID_FLAGS \
	(GPIOHANDLE_REQUEST_INPUT | \
	GPIOHANDLE_REQUEST_OUTPUT | \
	GPIOHANDLE_REQUEST_ACTIVE_LOW | \
445 446
	GPIOHANDLE_REQUEST_BIAS_PULL_UP | \
	GPIOHANDLE_REQUEST_BIAS_PULL_DOWN | \
447
	GPIOHANDLE_REQUEST_BIAS_DISABLE | \
448 449 450
	GPIOHANDLE_REQUEST_OPEN_DRAIN | \
	GPIOHANDLE_REQUEST_OPEN_SOURCE)

451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
static int linehandle_validate_flags(u32 flags)
{
	/* Return an error if an unknown flag is set */
	if (flags & ~GPIOHANDLE_REQUEST_VALID_FLAGS)
		return -EINVAL;

	/*
	 * Do not allow both INPUT & OUTPUT flags to be set as they are
	 * contradictory.
	 */
	if ((flags & GPIOHANDLE_REQUEST_INPUT) &&
	    (flags & GPIOHANDLE_REQUEST_OUTPUT))
		return -EINVAL;

	/*
	 * Do not allow OPEN_SOURCE & OPEN_DRAIN flags in a single request. If
	 * the hardware actually supports enabling both at the same time the
	 * electrical result would be disastrous.
	 */
	if ((flags & GPIOHANDLE_REQUEST_OPEN_DRAIN) &&
	    (flags & GPIOHANDLE_REQUEST_OPEN_SOURCE))
		return -EINVAL;

	/* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */
	if (!(flags & GPIOHANDLE_REQUEST_OUTPUT) &&
	    ((flags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
	     (flags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
		return -EINVAL;

	/* Bias flags only allowed for input or output mode. */
	if (!((flags & GPIOHANDLE_REQUEST_INPUT) ||
	      (flags & GPIOHANDLE_REQUEST_OUTPUT)) &&
	    ((flags & GPIOHANDLE_REQUEST_BIAS_DISABLE) ||
	     (flags & GPIOHANDLE_REQUEST_BIAS_PULL_UP) ||
	     (flags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN)))
		return -EINVAL;

	/* Only one bias flag can be set. */
	if (((flags & GPIOHANDLE_REQUEST_BIAS_DISABLE) &&
	     (flags & (GPIOHANDLE_REQUEST_BIAS_PULL_DOWN |
			GPIOHANDLE_REQUEST_BIAS_PULL_UP))) ||
	    ((flags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN) &&
	     (flags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)))
		return -EINVAL;

	return 0;
}

499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
static long linehandle_set_config(struct linehandle_state *lh,
				  void __user *ip)
{
	struct gpiohandle_config gcnf;
	struct gpio_desc *desc;
	int i, ret;
	u32 lflags;
	unsigned long *flagsp;

	if (copy_from_user(&gcnf, ip, sizeof(gcnf)))
		return -EFAULT;

	lflags = gcnf.flags;
	ret = linehandle_validate_flags(lflags);
	if (ret)
		return ret;

	for (i = 0; i < lh->numdescs; i++) {
		desc = lh->descs[i];
		flagsp = &desc->flags;

520
		assign_bit(FLAG_ACTIVE_LOW, flagsp,
521 522
			lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW);

523
		assign_bit(FLAG_OPEN_DRAIN, flagsp,
524 525
			lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN);

526
		assign_bit(FLAG_OPEN_SOURCE, flagsp,
527 528
			lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE);

529
		assign_bit(FLAG_PULL_UP, flagsp,
530 531
			lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP);

532
		assign_bit(FLAG_PULL_DOWN, flagsp,
533 534
			lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN);

535
		assign_bit(FLAG_BIAS_DISABLE, flagsp,
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
			lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE);

		/*
		 * 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 = !!gcnf.default_values[i];

			ret = gpiod_direction_output(desc, val);
			if (ret)
				return ret;
		} else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
			ret = gpiod_direction_input(desc);
			if (ret)
				return ret;
		}
553 554 555

		atomic_notifier_call_chain(&desc->gdev->notifier,
					   GPIOLINE_CHANGED_CONFIG, desc);
556 557 558 559
	}
	return 0;
}

560 561 562 563 564 565
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;
566
	DECLARE_BITMAP(vals, GPIOHANDLES_MAX);
567 568 569
	int i;

	if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
570
		/* NOTE: It's ok to read values of output lines. */
571 572 573 574
		int ret = gpiod_get_array_value_complex(false,
							true,
							lh->numdescs,
							lh->descs,
575
							NULL,
576 577 578
							vals);
		if (ret)
			return ret;
579

580
		memset(&ghd, 0, sizeof(ghd));
581
		for (i = 0; i < lh->numdescs; i++)
582
			ghd.values[i] = test_bit(i, vals);
583 584 585 586 587 588

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

		return 0;
	} else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
589 590 591 592 593 594 595
		/*
		 * All line descriptors were created at once with the same
		 * flags so just check if the first one is really output.
		 */
		if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags))
			return -EPERM;

596 597 598 599 600
		if (copy_from_user(&ghd, ip, sizeof(ghd)))
			return -EFAULT;

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

		/* Reuse the array setting function */
L
Laura Abbott 已提交
604
		return gpiod_set_array_value_complex(false,
605 606 607
					      true,
					      lh->numdescs,
					      lh->descs,
608
					      NULL,
609
					      vals);
610 611
	} else if (cmd == GPIOHANDLE_SET_CONFIG_IOCTL) {
		return linehandle_set_config(lh, ip);
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
	}
	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;
652
	struct file *file;
653
	int fd, i, count = 0, ret;
654
	u32 lflags;
655 656 657 658 659 660

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

661 662
	lflags = handlereq.flags;

663 664 665
	ret = linehandle_validate_flags(lflags);
	if (ret)
		return ret;
666

667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
	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];
687
		struct gpio_desc *desc = gpiochip_get_desc(gdev->chip, offset);
688

689 690
		if (IS_ERR(desc)) {
			ret = PTR_ERR(desc);
691 692 693
			goto out_free_descs;
		}

694 695 696 697
		ret = gpiod_request(desc, lh->label);
		if (ret)
			goto out_free_descs;
		lh->descs[i] = desc;
698
		count = i + 1;
699 700 701 702 703 704 705

		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);
706 707
		if (lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE)
			set_bit(FLAG_BIAS_DISABLE, &desc->flags);
708 709 710 711
		if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN)
			set_bit(FLAG_PULL_DOWN, &desc->flags);
		if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)
			set_bit(FLAG_PULL_UP, &desc->flags);
712

713 714 715 716
		ret = gpiod_set_transitory(desc, false);
		if (ret < 0)
			goto out_free_descs;

717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
		/*
		 * 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);
	}
735 736
	/* Let i point at the last handle */
	i--;
737 738
	lh->numdescs = handlereq.lines;

739
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
740 741 742 743 744
	if (fd < 0) {
		ret = fd;
		goto out_free_descs;
	}

745 746 747 748 749 750 751 752 753
	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;
	}

754
	handlereq.fd = fd;
755
	if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
756 757 758 759 760 761 762
		/*
		 * 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;
763
	}
764

765 766
	fd_install(fd, file);

767 768 769 770 771
	dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
		lh->numdescs);

	return 0;

772 773
out_put_unused_fd:
	put_unused_fd(fd);
774
out_free_descs:
775
	for (i = 0; i < count; i++)
776 777 778 779 780 781 782 783
		gpiod_free(lh->descs[i]);
	kfree(lh->label);
out_free_lh:
	kfree(lh);
	put_device(&gdev->dev);
	return ret;
}

784 785 786 787 788 789 790 791 792 793 794 795 796
/*
 * 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
797 798 799
 * @timestamp: cache for the timestamp storing it between hardirq
 * and IRQ thread, used to bring the timestamp close to the actual
 * event
800 801 802 803 804 805 806 807 808
 */
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);
809
	u64 timestamp;
810 811
};

812 813 814 815
#define GPIOEVENT_REQUEST_VALID_FLAGS \
	(GPIOEVENT_REQUEST_RISING_EDGE | \
	GPIOEVENT_REQUEST_FALLING_EDGE)

816
static __poll_t lineevent_poll(struct file *filep,
817 818 819
				   struct poll_table_struct *wait)
{
	struct lineevent_state *le = filep->private_data;
820
	__poll_t events = 0;
821 822 823

	poll_wait(filep, &le->wait, wait);

824
	if (!kfifo_is_empty_spinlocked_noirqsave(&le->events, &le->wait.lock))
825
		events = EPOLLIN | EPOLLRDNORM;
826 827 828 829 830 831 832 833 834 835 836

	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;
837
	struct gpioevent_data ge;
838
	ssize_t bytes_read = 0;
839 840
	int ret;

841
	if (count < sizeof(ge))
842 843 844
		return -EINVAL;

	do {
845
		spin_lock(&le->wait.lock);
846
		if (kfifo_is_empty(&le->events)) {
847 848 849 850 851 852 853
			if (bytes_read) {
				spin_unlock(&le->wait.lock);
				return bytes_read;
			}

			if (filep->f_flags & O_NONBLOCK) {
				spin_unlock(&le->wait.lock);
854
				return -EAGAIN;
855
			}
856

857
			ret = wait_event_interruptible_locked(le->wait,
858
					!kfifo_is_empty(&le->events));
859 860
			if (ret) {
				spin_unlock(&le->wait.lock);
861
				return ret;
862
			}
863 864
		}

865
		ret = kfifo_out(&le->events, &ge, 1);
866 867 868 869 870 871 872 873 874 875
		spin_unlock(&le->wait.lock);
		if (ret != 1) {
			/*
			 * This should never happen - we were holding the lock
			 * from the moment we learned the fifo is no longer
			 * empty until now.
			 */
			ret = -EIO;
			break;
		}
876

877
		if (copy_to_user(buf + bytes_read, &ge, sizeof(ge)))
878
			return -EFAULT;
879 880
		bytes_read += sizeof(ge);
	} while (count >= bytes_read + sizeof(ge));
881

882
	return bytes_read;
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
}

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;

912 913
		memset(&ghd, 0, sizeof(ghd));

914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
		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
};

947
static irqreturn_t lineevent_irq_thread(int irq, void *p)
948 949 950
{
	struct lineevent_state *le = p;
	struct gpioevent_data ge;
951
	int ret;
952

953 954 955
	/* Do not leak kernel stack to userspace */
	memset(&ge, 0, sizeof(ge));

956 957 958 959 960
	/*
	 * We may be running from a nested threaded interrupt in which case
	 * we didn't get the timestamp from lineevent_irq_handler().
	 */
	if (!le->timestamp)
961
		ge.timestamp = ktime_get_ns();
962 963
	else
		ge.timestamp = le->timestamp;
964

965 966
	if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
	    && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
967
		int level = gpiod_get_value_cansleep(le->desc);
968 969 970 971 972 973
		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;
974
	} else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) {
975 976
		/* Emit low-to-high event */
		ge.id = GPIOEVENT_EVENT_RISING_EDGE;
977
	} else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
978 979
		/* Emit high-to-low event */
		ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
980 981
	} else {
		return IRQ_NONE;
982 983
	}

984 985
	ret = kfifo_in_spinlocked_noirqsave(&le->events, &ge,
					    1, &le->wait.lock);
986
	if (ret)
987
		wake_up_poll(&le->wait, EPOLLIN);
988 989
	else
		pr_debug_ratelimited("event FIFO is full - event dropped\n");
990 991 992 993

	return IRQ_HANDLED;
}

994 995 996 997 998 999 1000 1001
static irqreturn_t lineevent_irq_handler(int irq, void *p)
{
	struct lineevent_state *le = p;

	/*
	 * Just store the timestamp in hardirq context so we get it as
	 * close in time as possible to the actual event.
	 */
1002
	le->timestamp = ktime_get_ns();
1003 1004 1005 1006

	return IRQ_WAKE_THREAD;
}

1007 1008 1009 1010 1011
static int lineevent_create(struct gpio_device *gdev, void __user *ip)
{
	struct gpioevent_request eventreq;
	struct lineevent_state *le;
	struct gpio_desc *desc;
1012
	struct file *file;
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
	u32 offset;
	u32 lflags;
	u32 eflags;
	int fd;
	int ret;
	int irqflags = 0;

	if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
		return -EFAULT;

1023 1024 1025 1026
	offset = eventreq.lineoffset;
	lflags = eventreq.handleflags;
	eflags = eventreq.eventflags;

1027 1028 1029
	desc = gpiochip_get_desc(gdev->chip, offset);
	if (IS_ERR(desc))
		return PTR_ERR(desc);
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041

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

	/* This is just wrong: we don't look for events on output lines */
	if ((lflags & GPIOHANDLE_REQUEST_OUTPUT) ||
	    (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
	    (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE))
		return -EINVAL;

1042 1043 1044 1045 1046 1047 1048 1049
	/* Only one bias flag can be set. */
	if (((lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE) &&
	     (lflags & (GPIOHANDLE_REQUEST_BIAS_PULL_DOWN |
			GPIOHANDLE_REQUEST_BIAS_PULL_UP))) ||
	    ((lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN) &&
	     (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)))
		return -EINVAL;

1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
	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;
		}
	}

	ret = gpiod_request(desc, le->label);
	if (ret)
1069
		goto out_free_label;
1070 1071 1072 1073 1074
	le->desc = desc;
	le->eflags = eflags;

	if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
1075 1076
	if (lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE)
		set_bit(FLAG_BIAS_DISABLE, &desc->flags);
1077 1078 1079 1080
	if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN)
		set_bit(FLAG_PULL_DOWN, &desc->flags);
	if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)
		set_bit(FLAG_PULL_UP, &desc->flags);
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092

	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)
1093 1094
		irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
			IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1095
	if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
1096 1097
		irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
			IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
1098 1099 1100 1101 1102 1103 1104
	irqflags |= IRQF_ONESHOT;

	INIT_KFIFO(le->events);
	init_waitqueue_head(&le->wait);

	/* Request a thread to read the events */
	ret = request_threaded_irq(le->irq,
1105
			lineevent_irq_handler,
1106 1107 1108 1109 1110 1111 1112
			lineevent_irq_thread,
			irqflags,
			le->label,
			le);
	if (ret)
		goto out_free_desc;

1113
	fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
1114 1115 1116 1117 1118
	if (fd < 0) {
		ret = fd;
		goto out_free_irq;
	}

1119 1120 1121 1122 1123 1124 1125 1126 1127
	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;
	}

1128
	eventreq.fd = fd;
1129
	if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
1130 1131 1132 1133 1134 1135 1136
		/*
		 * 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;
1137
	}
1138

1139 1140
	fd_install(fd, file);

1141 1142
	return 0;

1143 1144
out_put_unused_fd:
	put_unused_fd(fd);
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
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;
}

1157 1158 1159
static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
				  struct gpioline_info *info)
{
1160
	struct gpio_chip *gc = desc->gdev->chip;
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

	if (desc->name) {
		strncpy(info->name, desc->name, sizeof(info->name));
		info->name[sizeof(info->name) - 1] = '\0';
	} else {
		info->name[0] = '\0';
	}

	if (desc->label) {
		strncpy(info->consumer, desc->label, sizeof(info->consumer));
		info->consumer[sizeof(info->consumer) - 1] = '\0';
	} else {
		info->consumer[0] = '\0';
	}

	/*
	 * Userspace only need to know that the kernel is using this GPIO so
	 * it can't use it.
	 */
	info->flags = 0;
	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) ||
1189
	    !pinctrl_gpio_can_use_line(gc->base + info->line_offset))
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
		info->flags |= GPIOLINE_FLAG_KERNEL;
	if (test_bit(FLAG_IS_OUT, &desc->flags))
		info->flags |= GPIOLINE_FLAG_IS_OUT;
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		info->flags |= GPIOLINE_FLAG_ACTIVE_LOW;
	if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
		info->flags |= (GPIOLINE_FLAG_OPEN_DRAIN |
				GPIOLINE_FLAG_IS_OUT);
	if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
		info->flags |= (GPIOLINE_FLAG_OPEN_SOURCE |
				GPIOLINE_FLAG_IS_OUT);
	if (test_bit(FLAG_BIAS_DISABLE, &desc->flags))
		info->flags |= GPIOLINE_FLAG_BIAS_DISABLE;
	if (test_bit(FLAG_PULL_DOWN, &desc->flags))
		info->flags |= GPIOLINE_FLAG_BIAS_PULL_DOWN;
	if (test_bit(FLAG_PULL_UP, &desc->flags))
		info->flags |= GPIOLINE_FLAG_BIAS_PULL_UP;

	spin_unlock_irqrestore(&gpio_lock, flags);
}

1211 1212 1213 1214 1215 1216 1217 1218
struct gpio_chardev_data {
	struct gpio_device *gdev;
	wait_queue_head_t wait;
	DECLARE_KFIFO(events, struct gpioline_info_changed, 32);
	struct notifier_block lineinfo_changed_nb;
	unsigned long *watched_lines;
};

T
Thierry Reding 已提交
1219
/*
1220 1221 1222 1223
 * gpio_ioctl() - ioctl handler for the GPIO chardev
 */
static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
1224 1225
	struct gpio_chardev_data *priv = filp->private_data;
	struct gpio_device *gdev = priv->gdev;
1226
	struct gpio_chip *gc = gdev->chip;
1227
	void __user *ip = (void __user *)arg;
1228 1229
	struct gpio_desc *desc;
	__u32 offset;
1230 1231

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

1235
	/* Fill in the struct and pass to userspace */
1236
	if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
1237 1238
		struct gpiochip_info chipinfo;

1239 1240
		memset(&chipinfo, 0, sizeof(chipinfo));

1241 1242 1243
		strncpy(chipinfo.name, dev_name(&gdev->dev),
			sizeof(chipinfo.name));
		chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
1244 1245 1246
		strncpy(chipinfo.label, gdev->label,
			sizeof(chipinfo.label));
		chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
1247
		chipinfo.lines = gdev->ngpio;
1248 1249 1250
		if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
			return -EFAULT;
		return 0;
1251 1252
	} else if (cmd == GPIO_GET_LINEINFO_IOCTL ||
		   cmd == GPIO_GET_LINEINFO_WATCH_IOCTL) {
1253 1254 1255 1256 1257
		struct gpioline_info lineinfo;

		if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
			return -EFAULT;

1258
		desc = gpiochip_get_desc(gc, lineinfo.line_offset);
1259 1260 1261
		if (IS_ERR(desc))
			return PTR_ERR(desc);

1262
		gpio_desc_to_lineinfo(desc, &lineinfo);
1263 1264 1265

		if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
			return -EFAULT;
1266 1267

		if (cmd == GPIO_GET_LINEINFO_WATCH_IOCTL)
1268
			set_bit(gpio_chip_hwgpio(desc), priv->watched_lines);
1269

1270
		return 0;
1271 1272
	} else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
		return linehandle_create(gdev, ip);
1273 1274
	} else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
		return lineevent_create(gdev, ip);
1275 1276 1277 1278
	} else if (cmd == GPIO_GET_LINEINFO_UNWATCH_IOCTL) {
		if (copy_from_user(&offset, ip, sizeof(offset)))
			return -EFAULT;

1279
		desc = gpiochip_get_desc(gc, offset);
1280 1281 1282
		if (IS_ERR(desc))
			return PTR_ERR(desc);

1283
		clear_bit(gpio_chip_hwgpio(desc), priv->watched_lines);
1284
		return 0;
1285 1286 1287 1288
	}
	return -EINVAL;
}

1289 1290 1291 1292 1293 1294 1295 1296
#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

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
static struct gpio_chardev_data *
to_gpio_chardev_data(struct notifier_block *nb)
{
	return container_of(nb, struct gpio_chardev_data, lineinfo_changed_nb);
}

static int lineinfo_changed_notify(struct notifier_block *nb,
				   unsigned long action, void *data)
{
	struct gpio_chardev_data *priv = to_gpio_chardev_data(nb);
	struct gpioline_info_changed chg;
	struct gpio_desc *desc = data;
	int ret;

1311
	if (!test_bit(gpio_chip_hwgpio(desc), priv->watched_lines))
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
		return NOTIFY_DONE;

	memset(&chg, 0, sizeof(chg));
	chg.info.line_offset = gpio_chip_hwgpio(desc);
	chg.event_type = action;
	chg.timestamp = ktime_get_ns();
	gpio_desc_to_lineinfo(desc, &chg.info);

	ret = kfifo_in_spinlocked(&priv->events, &chg, 1, &priv->wait.lock);
	if (ret)
		wake_up_poll(&priv->wait, EPOLLIN);
	else
		pr_debug_ratelimited("lineinfo event FIFO is full - event dropped\n");

	return NOTIFY_OK;
}

static __poll_t lineinfo_watch_poll(struct file *filep,
				    struct poll_table_struct *pollt)
{
	struct gpio_chardev_data *priv = filep->private_data;
	__poll_t events = 0;

	poll_wait(filep, &priv->wait, pollt);

	if (!kfifo_is_empty_spinlocked_noirqsave(&priv->events,
						 &priv->wait.lock))
		events = EPOLLIN | EPOLLRDNORM;

	return events;
}

static ssize_t lineinfo_watch_read(struct file *filep, char __user *buf,
				   size_t count, loff_t *off)
{
	struct gpio_chardev_data *priv = filep->private_data;
	struct gpioline_info_changed event;
	ssize_t bytes_read = 0;
	int ret;

	if (count < sizeof(event))
		return -EINVAL;

	do {
		spin_lock(&priv->wait.lock);
		if (kfifo_is_empty(&priv->events)) {
			if (bytes_read) {
				spin_unlock(&priv->wait.lock);
				return bytes_read;
			}

			if (filep->f_flags & O_NONBLOCK) {
				spin_unlock(&priv->wait.lock);
				return -EAGAIN;
			}

			ret = wait_event_interruptible_locked(priv->wait,
					!kfifo_is_empty(&priv->events));
			if (ret) {
				spin_unlock(&priv->wait.lock);
				return ret;
			}
		}

		ret = kfifo_out(&priv->events, &event, 1);
		spin_unlock(&priv->wait.lock);
		if (ret != 1) {
			ret = -EIO;
			break;
			/* We should never get here. See lineevent_read(). */
		}

		if (copy_to_user(buf + bytes_read, &event, sizeof(event)))
			return -EFAULT;
		bytes_read += sizeof(event);
	} while (count >= bytes_read + sizeof(event));

	return bytes_read;
}

1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
/**
 * 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);
1402 1403
	struct gpio_chardev_data *priv;
	int ret = -ENOMEM;
1404 1405

	/* Fail on open if the backing gpiochip is gone */
1406
	if (!gdev->chip)
1407
		return -ENODEV;
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->watched_lines = bitmap_zalloc(gdev->chip->ngpio, GFP_KERNEL);
	if (!priv->watched_lines)
		goto out_free_priv;

	init_waitqueue_head(&priv->wait);
	INIT_KFIFO(priv->events);
	priv->gdev = gdev;

	priv->lineinfo_changed_nb.notifier_call = lineinfo_changed_notify;
	ret = atomic_notifier_chain_register(&gdev->notifier,
					     &priv->lineinfo_changed_nb);
	if (ret)
		goto out_free_bitmap;

1427
	get_device(&gdev->dev);
1428
	filp->private_data = priv;
1429

1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
	ret = nonseekable_open(inode, filp);
	if (ret)
		goto out_unregister_notifier;

	return ret;

out_unregister_notifier:
	atomic_notifier_chain_unregister(&gdev->notifier,
					 &priv->lineinfo_changed_nb);
out_free_bitmap:
	bitmap_free(priv->watched_lines);
out_free_priv:
	kfree(priv);
	return ret;
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
}

/**
 * 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)
{
1454 1455
	struct gpio_chardev_data *priv = filp->private_data;
	struct gpio_device *gdev = priv->gdev;
1456

1457 1458 1459
	bitmap_free(priv->watched_lines);
	atomic_notifier_chain_unregister(&gdev->notifier,
					 &priv->lineinfo_changed_nb);
1460
	put_device(&gdev->dev);
1461 1462
	kfree(priv);

1463 1464 1465 1466 1467 1468
	return 0;
}

static const struct file_operations gpio_fileops = {
	.release = gpio_chrdev_release,
	.open = gpio_chrdev_open,
1469 1470
	.poll = lineinfo_watch_poll,
	.read = lineinfo_watch_read,
1471
	.owner = THIS_MODULE,
1472
	.llseek = no_llseek,
1473
	.unlocked_ioctl = gpio_ioctl,
1474 1475 1476
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
1477 1478
};

1479 1480 1481 1482 1483 1484
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);
1485
	kfree_const(gdev->label);
1486
	kfree(gdev->descs);
1487
	kfree(gdev);
1488 1489
}

1490 1491
static int gpiochip_setup_dev(struct gpio_device *gdev)
{
1492
	int ret;
1493 1494 1495 1496

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

1498 1499 1500
	ret = cdev_device_add(&gdev->chrdev, &gdev->dev);
	if (ret)
		return ret;
1501 1502 1503

	chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
		 MAJOR(gpio_devt), gdev->id);
1504

1505 1506
	ret = gpiochip_sysfs_register(gdev);
	if (ret)
1507 1508 1509 1510
		goto err_remove_device;

	/* From this point, the .release() function cleans up gpio_device */
	gdev->dev.release = gpiodevice_release;
1511 1512
	dev_dbg(&gdev->dev, "registered GPIOs %d to %d on %s\n", gdev->base,
		gdev->base + gdev->ngpio - 1, gdev->chip->label ? : "generic");
1513 1514 1515 1516

	return 0;

err_remove_device:
1517
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1518
	return ret;
1519 1520
}

1521
static void gpiochip_machine_hog(struct gpio_chip *gc, struct gpiod_hog *hog)
1522 1523 1524 1525
{
	struct gpio_desc *desc;
	int rv;

1526
	desc = gpiochip_get_desc(gc, hog->chip_hwnum);
1527
	if (IS_ERR(desc)) {
1528 1529
		chip_err(gc, "%s: unable to get GPIO desc: %ld\n", __func__,
			 PTR_ERR(desc));
1530 1531 1532
		return;
	}

1533
	if (test_bit(FLAG_IS_HOGGED, &desc->flags))
1534 1535 1536 1537
		return;

	rv = gpiod_hog(desc, hog->line_name, hog->lflags, hog->dflags);
	if (rv)
1538 1539
		gpiod_err(desc, "%s: unable to hog GPIO line (%s:%u): %d\n",
			  __func__, gc->label, hog->chip_hwnum, rv);
1540 1541
}

1542
static void machine_gpiochip_add(struct gpio_chip *gc)
1543 1544 1545 1546 1547 1548
{
	struct gpiod_hog *hog;

	mutex_lock(&gpio_machine_hogs_mutex);

	list_for_each_entry(hog, &gpio_machine_hogs, list) {
1549 1550
		if (!strcmp(gc->label, hog->chip_label))
			gpiochip_machine_hog(gc, hog);
1551 1552 1553 1554 1555
	}

	mutex_unlock(&gpio_machine_hogs_mutex);
}

1556 1557 1558
static void gpiochip_setup_devs(void)
{
	struct gpio_device *gdev;
1559
	int ret;
1560 1561

	list_for_each_entry(gdev, &gpio_devices, list) {
1562 1563
		ret = gpiochip_setup_dev(gdev);
		if (ret)
1564 1565
			dev_err(&gdev->dev,
				"Failed to initialize gpio device (%d)\n", ret);
1566 1567 1568
	}
}

1569
int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
1570 1571
			       struct lock_class_key *lock_key,
			       struct lock_class_key *request_key)
1572 1573
{
	unsigned long	flags;
1574
	int		ret = 0;
1575
	unsigned	i;
1576
	int		base = gc->base;
1577
	struct gpio_device *gdev;
1578

1579 1580 1581 1582
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
1583
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1584
	if (!gdev)
1585
		return -ENOMEM;
1586
	gdev->dev.bus = &gpio_bus_type;
1587 1588 1589 1590 1591
	gdev->chip = gc;
	gc->gpiodev = gdev;
	if (gc->parent) {
		gdev->dev.parent = gc->parent;
		gdev->dev.of_node = gc->parent->of_node;
1592 1593
	}

1594 1595
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
1596 1597
	if (gc->of_node)
		gdev->dev.of_node = gc->of_node;
B
Biju Das 已提交
1598
	else
1599
		gc->of_node = gdev->dev.of_node;
1600
#endif
1601

1602 1603
	gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
	if (gdev->id < 0) {
1604
		ret = gdev->id;
1605 1606
		goto err_free_gdev;
	}
1607
	dev_set_name(&gdev->dev, GPIOCHIP_NAME "%d", gdev->id);
1608 1609
	device_initialize(&gdev->dev);
	dev_set_drvdata(&gdev->dev, gdev);
1610 1611 1612
	if (gc->parent && gc->parent->driver)
		gdev->owner = gc->parent->driver->owner;
	else if (gc->owner)
1613
		/* TODO: remove chip->owner */
1614
		gdev->owner = gc->owner;
1615 1616
	else
		gdev->owner = THIS_MODULE;
1617

1618
	gdev->descs = kcalloc(gc->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1619
	if (!gdev->descs) {
1620
		ret = -ENOMEM;
1621
		goto err_free_ida;
1622 1623
	}

1624 1625
	if (gc->ngpio == 0) {
		chip_err(gc, "tried to insert a GPIO chip with zero lines\n");
1626
		ret = -EINVAL;
1627
		goto err_free_descs;
1628
	}
1629

1630 1631 1632
	if (gc->ngpio > FASTPATH_NGPIO)
		chip_warn(gc, "line cnt %u is greater than fast path cnt %u\n",
			  gc->ngpio, FASTPATH_NGPIO);
L
Laura Abbott 已提交
1633

1634
	gdev->label = kstrdup_const(gc->label ?: "unknown", GFP_KERNEL);
1635
	if (!gdev->label) {
1636
		ret = -ENOMEM;
1637
		goto err_free_descs;
1638 1639
	}

1640
	gdev->ngpio = gc->ngpio;
1641
	gdev->data = data;
1642

1643 1644
	spin_lock_irqsave(&gpio_lock, flags);

1645 1646 1647 1648 1649 1650 1651
	/*
	 * 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.
	 */
1652
	if (base < 0) {
1653
		base = gpiochip_find_base(gc->ngpio);
1654
		if (base < 0) {
1655
			ret = base;
1656
			spin_unlock_irqrestore(&gpio_lock, flags);
1657
			goto err_free_label;
1658
		}
1659 1660 1661 1662 1663 1664
		/*
		 * 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.
		 */
1665
		gc->base = base;
1666
	}
1667
	gdev->base = base;
1668

1669 1670
	ret = gpiodev_add_to_list(gdev);
	if (ret) {
1671
		spin_unlock_irqrestore(&gpio_lock, flags);
1672
		goto err_free_label;
1673
	}
1674

1675
	for (i = 0; i < gc->ngpio; i++)
1676
		gdev->descs[i].gdev = gdev;
1677

1678 1679
	spin_unlock_irqrestore(&gpio_lock, flags);

1680 1681
	ATOMIC_INIT_NOTIFIER_HEAD(&gdev->notifier);

1682
#ifdef CONFIG_PINCTRL
1683
	INIT_LIST_HEAD(&gdev->pin_ranges);
1684 1685
#endif

1686
	ret = gpiochip_set_desc_names(gc);
1687
	if (ret)
1688 1689
		goto err_remove_from_list;

1690
	ret = gpiochip_alloc_valid_mask(gc);
1691
	if (ret)
1692
		goto err_remove_from_list;
1693

1694
	ret = of_gpiochip_add(gc);
1695
	if (ret)
1696
		goto err_free_gpiochip_mask;
1697

1698
	ret = gpiochip_init_valid_mask(gc);
1699
	if (ret)
1700
		goto err_remove_of_chip;
1701

1702
	for (i = 0; i < gc->ngpio; i++) {
1703 1704
		struct gpio_desc *desc = &gdev->descs[i];

1705
		if (gc->get_direction && gpiochip_line_is_valid(gc, i)) {
1706
			assign_bit(FLAG_IS_OUT,
1707
				   &desc->flags, !gc->get_direction(gc, i));
1708
		} else {
1709
			assign_bit(FLAG_IS_OUT,
1710
				   &desc->flags, !gc->direction_input);
1711
		}
1712 1713
	}

1714
	ret = gpiochip_add_pin_ranges(gc);
1715 1716 1717
	if (ret)
		goto err_remove_of_chip;

1718
	acpi_gpiochip_add(gc);
1719

1720
	machine_gpiochip_add(gc);
1721

1722
	ret = gpiochip_irqchip_init_valid_mask(gc);
1723 1724 1725
	if (ret)
		goto err_remove_acpi_chip;

1726
	ret = gpiochip_irqchip_init_hw(gc);
L
Linus Walleij 已提交
1727
	if (ret)
1728 1729
		goto err_remove_acpi_chip;

1730
	ret = gpiochip_add_irqchip(gc, lock_key, request_key);
L
Linus Walleij 已提交
1731
	if (ret)
1732 1733
		goto err_remove_irqchip_mask;

1734 1735 1736 1737 1738
	/*
	 * 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.
1739 1740
	 * We can do this only if gpiolib has been initialized.
	 * Otherwise, defer until later.
1741
	 */
1742
	if (gpiolib_initialized) {
1743 1744
		ret = gpiochip_setup_dev(gdev);
		if (ret)
1745
			goto err_remove_irqchip;
1746
	}
1747
	return 0;
1748

1749
err_remove_irqchip:
1750
	gpiochip_irqchip_remove(gc);
1751
err_remove_irqchip_mask:
1752
	gpiochip_irqchip_free_valid_mask(gc);
1753
err_remove_acpi_chip:
1754
	acpi_gpiochip_remove(gc);
1755
err_remove_of_chip:
1756 1757
	gpiochip_free_hogs(gc);
	of_gpiochip_remove(gc);
1758
err_free_gpiochip_mask:
1759 1760
	gpiochip_remove_pin_ranges(gc);
	gpiochip_free_valid_mask(gc);
1761
err_remove_from_list:
1762
	spin_lock_irqsave(&gpio_lock, flags);
1763
	list_del(&gdev->list);
1764
	spin_unlock_irqrestore(&gpio_lock, flags);
1765
err_free_label:
1766
	kfree_const(gdev->label);
1767 1768
err_free_descs:
	kfree(gdev->descs);
1769
err_free_ida:
1770
	ida_simple_remove(&gpio_ida, gdev->id);
1771
err_free_gdev:
1772
	/* failures here can mean systems won't boot... */
1773
	pr_err("%s: GPIOs %d..%d (%s) failed to register, %d\n", __func__,
1774
	       gdev->base, gdev->base + gdev->ngpio - 1,
1775
	       gc->label ? : "generic", ret);
1776
	kfree(gdev);
1777
	return ret;
1778
}
1779
EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
1780

1781 1782
/**
 * gpiochip_get_data() - get per-subdriver data for the chip
1783
 * @gc: GPIO chip
T
Thierry Reding 已提交
1784 1785 1786
 *
 * Returns:
 * The per-subdriver data for the chip.
1787
 */
1788
void *gpiochip_get_data(struct gpio_chip *gc)
1789
{
1790
	return gc->gpiodev->data;
1791 1792 1793
}
EXPORT_SYMBOL_GPL(gpiochip_get_data);

1794 1795
/**
 * gpiochip_remove() - unregister a gpio_chip
1796
 * @gc: the chip to unregister
1797 1798 1799
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
1800
void gpiochip_remove(struct gpio_chip *gc)
1801
{
1802
	struct gpio_device *gdev = gc->gpiodev;
1803
	unsigned long	flags;
1804
	unsigned int	i;
1805

1806
	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1807
	gpiochip_sysfs_unregister(gdev);
1808
	gpiochip_free_hogs(gc);
1809 1810
	/* Numb the device, cancelling all outstanding operations */
	gdev->chip = NULL;
1811 1812 1813 1814 1815
	gpiochip_irqchip_remove(gc);
	acpi_gpiochip_remove(gc);
	of_gpiochip_remove(gc);
	gpiochip_remove_pin_ranges(gc);
	gpiochip_free_valid_mask(gc);
1816 1817 1818 1819 1820
	/*
	 * We accept no more calls into the driver from this point, so
	 * NULL the driver data pointer
	 */
	gdev->data = NULL;
1821

1822
	spin_lock_irqsave(&gpio_lock, flags);
1823
	for (i = 0; i < gdev->ngpio; i++) {
1824
		if (gpiochip_is_requested(gc, i))
1825
			break;
1826 1827
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
1828

1829
	if (i != gdev->ngpio)
1830
		dev_crit(&gdev->dev,
1831
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
J
Johan Hovold 已提交
1832

1833 1834 1835 1836 1837 1838
	/*
	 * 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.
	 */
1839
	cdev_device_del(&gdev->chrdev, &gdev->dev);
1840
	put_device(&gdev->dev);
1841 1842 1843
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

1844 1845 1846
/**
 * gpiochip_find() - iterator for locating a specific gpio_chip
 * @data: data to pass to match function
T
Thierry Reding 已提交
1847
 * @match: Callback function to check gpio_chip
1848 1849 1850 1851 1852 1853 1854
 *
 * 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.
 */
1855
struct gpio_chip *gpiochip_find(void *data,
1856
				int (*match)(struct gpio_chip *gc,
1857
					     void *data))
1858
{
1859
	struct gpio_device *gdev;
1860
	struct gpio_chip *gc = NULL;
1861 1862 1863
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
1864
	list_for_each_entry(gdev, &gpio_devices, list)
1865
		if (gdev->chip && match(gdev->chip, data)) {
1866
			gc = gdev->chip;
1867
			break;
1868
		}
1869

1870 1871
	spin_unlock_irqrestore(&gpio_lock, flags);

1872
	return gc;
1873
}
J
Jean Delvare 已提交
1874
EXPORT_SYMBOL_GPL(gpiochip_find);
1875

1876
static int gpiochip_match_name(struct gpio_chip *gc, void *data)
1877 1878 1879
{
	const char *name = data;

1880
	return !strcmp(gc->label, name);
1881 1882 1883 1884 1885 1886 1887
}

static struct gpio_chip *find_chip_by_name(const char *name)
{
	return gpiochip_find((void *)name, gpiochip_match_name);
}

1888 1889 1890 1891 1892 1893
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
static int gpiochip_irqchip_init_hw(struct gpio_chip *gc)
{
	struct gpio_irq_chip *girq = &gc->irq;

	if (!girq->init_hw)
		return 0;

	return girq->init_hw(gc);
}

1904
static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc)
1905
{
1906 1907 1908
	struct gpio_irq_chip *girq = &gc->irq;

	if (!girq->init_valid_mask)
1909 1910
		return 0;

1911 1912
	girq->valid_mask = gpiochip_allocate_mask(gc);
	if (!girq->valid_mask)
1913 1914
		return -ENOMEM;

1915 1916
	girq->init_valid_mask(gc, girq->valid_mask, gc->ngpio);

1917 1918 1919
	return 0;
}

1920
static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gc)
1921
{
1922 1923
	bitmap_free(gc->irq.valid_mask);
	gc->irq.valid_mask = NULL;
1924 1925
}

1926
bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gc,
1927
				unsigned int offset)
1928
{
1929
	if (!gpiochip_line_is_valid(gc, offset))
1930
		return false;
1931
	/* No mask means all valid */
1932
	if (likely(!gc->irq.valid_mask))
1933
		return true;
1934
	return test_bit(offset, gc->irq.valid_mask);
1935
}
1936
EXPORT_SYMBOL_GPL(gpiochip_irqchip_irq_valid);
1937

1938
/**
1939
 * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
1940
 * @gc: the gpiochip to set the irqchip chain to
1941
 * @parent_irq: the irq number corresponding to the parent IRQ for this
1942
 * cascaded irqchip
1943
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1944 1945
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
1946
 */
1947
static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gc,
1948
					  unsigned int parent_irq,
1949
					  irq_flow_handler_t parent_handler)
1950
{
1951 1952 1953 1954 1955
	struct gpio_irq_chip *girq = &gc->irq;
	struct device *dev = &gc->gpiodev->dev;

	if (!girq->domain) {
		chip_err(gc, "called %s before setting up irqchip\n",
1956
			 __func__);
1957 1958 1959
		return;
	}

1960
	if (parent_handler) {
1961 1962
		if (gc->can_sleep) {
			chip_err(gc,
1963
				 "you cannot have chained interrupts on a chip that may sleep\n");
1964 1965
			return;
		}
1966 1967 1968 1969 1970 1971 1972 1973 1974
		girq->parents = devm_kcalloc(dev, 1,
					     sizeof(*girq->parents),
					     GFP_KERNEL);
		if (!girq->parents) {
			chip_err(gc, "out of memory allocating parent IRQ\n");
			return;
		}
		girq->parents[0] = parent_irq;
		girq->num_parents = 1;
1975 1976 1977 1978
		/*
		 * The parent irqchip is already using the chip_data for this
		 * irqchip, so our callbacks simply use the handler_data.
		 */
1979
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
1980
						 gc);
1981
	}
1982
}
1983 1984 1985

/**
 * gpiochip_set_nested_irqchip() - connects a nested irqchip to a gpiochip
1986
 * @gc: the gpiochip to set the irqchip nested handler to
1987 1988 1989 1990
 * @irqchip: the irqchip to nest to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * nested irqchip
 */
1991
void gpiochip_set_nested_irqchip(struct gpio_chip *gc,
1992
				 struct irq_chip *irqchip,
1993
				 unsigned int parent_irq)
1994
{
1995
	gpiochip_set_cascaded_irqchip(gc, parent_irq, NULL);
1996 1997 1998
}
EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);

1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY

/**
 * gpiochip_set_hierarchical_irqchip() - connects a hierarchical irqchip
 * to a gpiochip
 * @gc: the gpiochip to set the irqchip hierarchical handler to
 * @irqchip: the irqchip to handle this level of the hierarchy, the interrupt
 * will then percolate up to the parent
 */
static void gpiochip_set_hierarchical_irqchip(struct gpio_chip *gc,
					      struct irq_chip *irqchip)
{
	/* DT will deal with mapping each IRQ as we go along */
	if (is_of_node(gc->irq.fwnode))
		return;

	/*
	 * This is for legacy and boardfile "irqchip" fwnodes: allocate
	 * irqs upfront instead of dynamically since we don't have the
	 * dynamic type of allocation that hardware description languages
	 * provide. Once all GPIO drivers using board files are gone from
	 * the kernel we can delete this code, but for a transitional period
	 * it is necessary to keep this around.
	 */
	if (is_fwnode_irqchip(gc->irq.fwnode)) {
		int i;
		int ret;

		for (i = 0; i < gc->ngpio; i++) {
			struct irq_fwspec fwspec;
			unsigned int parent_hwirq;
			unsigned int parent_type;
			struct gpio_irq_chip *girq = &gc->irq;

			/*
			 * We call the child to parent translation function
			 * only to check if the child IRQ is valid or not.
			 * Just pick the rising edge type here as that is what
			 * we likely need to support.
			 */
			ret = girq->child_to_parent_hwirq(gc, i,
							  IRQ_TYPE_EDGE_RISING,
							  &parent_hwirq,
							  &parent_type);
			if (ret) {
				chip_err(gc, "skip set-up on hwirq %d\n",
					 i);
				continue;
			}

			fwspec.fwnode = gc->irq.fwnode;
			/* This is the hwirq for the GPIO line side of things */
			fwspec.param[0] = girq->child_offset_to_irq(gc, i);
			/* Just pick something */
			fwspec.param[1] = IRQ_TYPE_EDGE_RISING;
			fwspec.param_count = 2;
			ret = __irq_domain_alloc_irqs(gc->irq.domain,
						      /* just pick something */
						      -1,
						      1,
						      NUMA_NO_NODE,
						      &fwspec,
						      false,
						      NULL);
			if (ret < 0) {
				chip_err(gc,
					 "can not allocate irq for GPIO line %d parent hwirq %d in hierarchy domain: %d\n",
					 i, parent_hwirq,
					 ret);
			}
		}
	}

	chip_err(gc, "%s unknown fwnode type proceed anyway\n", __func__);

	return;
}

static int gpiochip_hierarchy_irq_domain_translate(struct irq_domain *d,
						   struct irq_fwspec *fwspec,
						   unsigned long *hwirq,
						   unsigned int *type)
{
	/* We support standard DT translation */
	if (is_of_node(fwspec->fwnode) && fwspec->param_count == 2) {
		return irq_domain_translate_twocell(d, fwspec, hwirq, type);
	}

	/* This is for board files and others not using DT */
	if (is_fwnode_irqchip(fwspec->fwnode)) {
		int ret;

		ret = irq_domain_translate_twocell(d, fwspec, hwirq, type);
		if (ret)
			return ret;
		WARN_ON(*type == IRQ_TYPE_NONE);
		return 0;
	}
	return -EINVAL;
}

static int gpiochip_hierarchy_irq_domain_alloc(struct irq_domain *d,
					       unsigned int irq,
					       unsigned int nr_irqs,
					       void *data)
{
	struct gpio_chip *gc = d->host_data;
	irq_hw_number_t hwirq;
	unsigned int type = IRQ_TYPE_NONE;
	struct irq_fwspec *fwspec = data;
2109
	void *parent_arg;
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124
	unsigned int parent_hwirq;
	unsigned int parent_type;
	struct gpio_irq_chip *girq = &gc->irq;
	int ret;

	/*
	 * The nr_irqs parameter is always one except for PCI multi-MSI
	 * so this should not happen.
	 */
	WARN_ON(nr_irqs != 1);

	ret = gc->irq.child_irq_domain_ops.translate(d, fwspec, &hwirq, &type);
	if (ret)
		return ret;

2125
	chip_dbg(gc, "allocate IRQ %d, hwirq %lu\n", irq,  hwirq);
2126 2127 2128 2129 2130 2131 2132

	ret = girq->child_to_parent_hwirq(gc, hwirq, type,
					  &parent_hwirq, &parent_type);
	if (ret) {
		chip_err(gc, "can't look up hwirq %lu\n", hwirq);
		return ret;
	}
2133
	chip_dbg(gc, "found parent hwirq %u\n", parent_hwirq);
2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148

	/*
	 * We set handle_bad_irq because the .set_type() should
	 * always be invoked and set the right type of handler.
	 */
	irq_domain_set_info(d,
			    irq,
			    hwirq,
			    gc->irq.chip,
			    gc,
			    girq->handler,
			    NULL, NULL);
	irq_set_probe(irq);

	/* This parent only handles asserted level IRQs */
2149 2150 2151 2152
	parent_arg = girq->populate_parent_alloc_arg(gc, parent_hwirq, parent_type);
	if (!parent_arg)
		return -ENOMEM;

2153
	chip_dbg(gc, "alloc_irqs_parent for %d parent hwirq %d\n",
2154
		  irq, parent_hwirq);
2155
	irq_set_lockdep_class(irq, gc->irq.lock_key, gc->irq.request_key);
2156
	ret = irq_domain_alloc_irqs_parent(d, irq, 1, parent_arg);
2157 2158 2159 2160 2161 2162
	/*
	 * If the parent irqdomain is msi, the interrupts have already
	 * been allocated, so the EEXIST is good.
	 */
	if (irq_domain_is_msi(d->parent) && (ret == -EEXIST))
		ret = 0;
2163 2164 2165 2166 2167
	if (ret)
		chip_err(gc,
			 "failed to allocate parent hwirq %d for hwirq %lu\n",
			 parent_hwirq, hwirq);

2168
	kfree(parent_arg);
2169 2170 2171
	return ret;
}

2172
static unsigned int gpiochip_child_offset_to_irq_noop(struct gpio_chip *gc,
2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204
						      unsigned int offset)
{
	return offset;
}

static void gpiochip_hierarchy_setup_domain_ops(struct irq_domain_ops *ops)
{
	ops->activate = gpiochip_irq_domain_activate;
	ops->deactivate = gpiochip_irq_domain_deactivate;
	ops->alloc = gpiochip_hierarchy_irq_domain_alloc;
	ops->free = irq_domain_free_irqs_common;

	/*
	 * We only allow overriding the translate() function for
	 * hierarchical chips, and this should only be done if the user
	 * really need something other than 1:1 translation.
	 */
	if (!ops->translate)
		ops->translate = gpiochip_hierarchy_irq_domain_translate;
}

static int gpiochip_hierarchy_add_domain(struct gpio_chip *gc)
{
	if (!gc->irq.child_to_parent_hwirq ||
	    !gc->irq.fwnode) {
		chip_err(gc, "missing irqdomain vital data\n");
		return -EINVAL;
	}

	if (!gc->irq.child_offset_to_irq)
		gc->irq.child_offset_to_irq = gpiochip_child_offset_to_irq_noop;

2205 2206
	if (!gc->irq.populate_parent_alloc_arg)
		gc->irq.populate_parent_alloc_arg =
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
			gpiochip_populate_parent_fwspec_twocell;

	gpiochip_hierarchy_setup_domain_ops(&gc->irq.child_irq_domain_ops);

	gc->irq.domain = irq_domain_create_hierarchy(
		gc->irq.parent_domain,
		0,
		gc->ngpio,
		gc->irq.fwnode,
		&gc->irq.child_irq_domain_ops,
		gc);

	if (!gc->irq.domain)
		return -ENOMEM;

	gpiochip_set_hierarchical_irqchip(gc, gc->irq.chip);

	return 0;
}

static bool gpiochip_hierarchy_is_hierarchical(struct gpio_chip *gc)
{
	return !!gc->irq.parent_domain;
}

2232
void *gpiochip_populate_parent_fwspec_twocell(struct gpio_chip *gc,
2233 2234 2235
					     unsigned int parent_hwirq,
					     unsigned int parent_type)
{
2236 2237 2238 2239 2240 2241
	struct irq_fwspec *fwspec;

	fwspec = kmalloc(sizeof(*fwspec), GFP_KERNEL);
	if (!fwspec)
		return NULL;

2242
	fwspec->fwnode = gc->irq.parent_domain->fwnode;
2243 2244 2245
	fwspec->param_count = 2;
	fwspec->param[0] = parent_hwirq;
	fwspec->param[1] = parent_type;
2246 2247

	return fwspec;
2248 2249 2250
}
EXPORT_SYMBOL_GPL(gpiochip_populate_parent_fwspec_twocell);

2251
void *gpiochip_populate_parent_fwspec_fourcell(struct gpio_chip *gc,
2252 2253 2254
					      unsigned int parent_hwirq,
					      unsigned int parent_type)
{
2255 2256 2257 2258 2259 2260
	struct irq_fwspec *fwspec;

	fwspec = kmalloc(sizeof(*fwspec), GFP_KERNEL);
	if (!fwspec)
		return NULL;

2261
	fwspec->fwnode = gc->irq.parent_domain->fwnode;
2262 2263 2264 2265 2266
	fwspec->param_count = 4;
	fwspec->param[0] = 0;
	fwspec->param[1] = parent_hwirq;
	fwspec->param[2] = 0;
	fwspec->param[3] = parent_type;
2267 2268

	return fwspec;
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
}
EXPORT_SYMBOL_GPL(gpiochip_populate_parent_fwspec_fourcell);

#else

static int gpiochip_hierarchy_add_domain(struct gpio_chip *gc)
{
	return -EINVAL;
}

static bool gpiochip_hierarchy_is_hierarchical(struct gpio_chip *gc)
{
	return false;
}

#endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */

2286 2287 2288 2289 2290 2291 2292 2293 2294 2295
/**
 * 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.
 */
2296 2297
int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
		     irq_hw_number_t hwirq)
2298
{
2299
	struct gpio_chip *gc = d->host_data;
2300
	int ret = 0;
2301

2302
	if (!gpiochip_irqchip_irq_valid(gc, hwirq))
2303 2304
		return -ENXIO;

2305
	irq_set_chip_data(irq, gc);
2306 2307 2308 2309
	/*
	 * This lock class tells lockdep that GPIO irqs are in a different
	 * category than their parents, so it won't report false recursion.
	 */
2310 2311
	irq_set_lockdep_class(irq, gc->irq.lock_key, gc->irq.request_key);
	irq_set_chip_and_handler(irq, gc->irq.chip, gc->irq.handler);
2312
	/* Chips that use nested thread handlers have them marked */
2313
	if (gc->irq.threaded)
2314
		irq_set_nested_thread(irq, 1);
2315
	irq_set_noprobe(irq);
R
Rob Herring 已提交
2316

2317 2318 2319 2320
	if (gc->irq.num_parents == 1)
		ret = irq_set_parent(irq, gc->irq.parents[0]);
	else if (gc->irq.map)
		ret = irq_set_parent(irq, gc->irq.map[hwirq]);
2321

2322 2323
	if (ret < 0)
		return ret;
2324

2325 2326 2327 2328
	/*
	 * No set-up of the hardware will happen if IRQ_TYPE_NONE
	 * is passed as default type.
	 */
2329 2330
	if (gc->irq.default_type != IRQ_TYPE_NONE)
		irq_set_irq_type(irq, gc->irq.default_type);
2331 2332 2333

	return 0;
}
2334
EXPORT_SYMBOL_GPL(gpiochip_irq_map);
2335

2336
void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
L
Linus Walleij 已提交
2337
{
2338
	struct gpio_chip *gc = d->host_data;
2339

2340
	if (gc->irq.threaded)
2341
		irq_set_nested_thread(irq, 0);
L
Linus Walleij 已提交
2342 2343 2344
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}
2345
EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
L
Linus Walleij 已提交
2346

2347 2348
static const struct irq_domain_ops gpiochip_domain_ops = {
	.map	= gpiochip_irq_map,
L
Linus Walleij 已提交
2349
	.unmap	= gpiochip_irq_unmap,
2350 2351 2352 2353
	/* Virtually all GPIO irqchips are twocell:ed */
	.xlate	= irq_domain_xlate_twocell,
};

2354 2355 2356 2357 2358
/*
 * TODO: move these activate/deactivate in under the hierarchicial
 * irqchip implementation as static once SPMI and SSBI (all external
 * users) are phased over.
 */
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371
/**
 * gpiochip_irq_domain_activate() - Lock a GPIO to be used as an IRQ
 * @domain: The IRQ domain used by this IRQ chip
 * @data: Outermost irq_data associated with the IRQ
 * @reserve: If set, only reserve an interrupt vector instead of assigning one
 *
 * This function is a wrapper that calls gpiochip_lock_as_irq() and is to be
 * used as the activate function for the &struct irq_domain_ops. The host_data
 * for the IRQ domain must be the &struct gpio_chip.
 */
int gpiochip_irq_domain_activate(struct irq_domain *domain,
				 struct irq_data *data, bool reserve)
{
2372
	struct gpio_chip *gc = domain->host_data;
2373

2374
	return gpiochip_lock_as_irq(gc, data->hwirq);
2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389
}
EXPORT_SYMBOL_GPL(gpiochip_irq_domain_activate);

/**
 * gpiochip_irq_domain_deactivate() - Unlock a GPIO used as an IRQ
 * @domain: The IRQ domain used by this IRQ chip
 * @data: Outermost irq_data associated with the IRQ
 *
 * This function is a wrapper that will call gpiochip_unlock_as_irq() and is to
 * be used as the deactivate function for the &struct irq_domain_ops. The
 * host_data for the IRQ domain must be the &struct gpio_chip.
 */
void gpiochip_irq_domain_deactivate(struct irq_domain *domain,
				    struct irq_data *data)
{
2390
	struct gpio_chip *gc = domain->host_data;
2391

2392
	return gpiochip_unlock_as_irq(gc, data->hwirq);
2393 2394 2395
}
EXPORT_SYMBOL_GPL(gpiochip_irq_domain_deactivate);

2396
static int gpiochip_to_irq(struct gpio_chip *gc, unsigned offset)
2397
{
2398
	struct irq_domain *domain = gc->irq.domain;
2399

2400
	if (!gpiochip_irqchip_irq_valid(gc, offset))
2401
		return -ENXIO;
2402

2403 2404 2405 2406 2407 2408
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
	if (irq_domain_is_hierarchy(domain)) {
		struct irq_fwspec spec;

		spec.fwnode = domain->fwnode;
		spec.param_count = 2;
2409
		spec.param[0] = gc->irq.child_offset_to_irq(gc, offset);
2410 2411 2412 2413 2414 2415 2416
		spec.param[1] = IRQ_TYPE_NONE;

		return irq_create_fwspec_mapping(&spec);
	}
#endif

	return irq_create_mapping(domain, offset);
2417 2418 2419 2420
}

static int gpiochip_irq_reqres(struct irq_data *d)
{
2421
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
2422

2423
	return gpiochip_reqres_irq(gc, d->hwirq);
2424 2425 2426 2427
}

static void gpiochip_irq_relres(struct irq_data *d)
{
2428
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
2429

2430
	gpiochip_relres_irq(gc, d->hwirq);
2431 2432
}

2433
static void gpiochip_irq_enable(struct irq_data *d)
2434
{
2435
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
2436

2437 2438 2439
	gpiochip_enable_irq(gc, d->hwirq);
	if (gc->irq.irq_enable)
		gc->irq.irq_enable(d);
2440
	else
2441
		gc->irq.chip->irq_unmask(d);
2442 2443 2444 2445
}

static void gpiochip_irq_disable(struct irq_data *d)
{
2446
	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
2447

2448 2449 2450 2451 2452 2453 2454
	/*
	 * Since we override .irq_disable() we need to mimic the
	 * behaviour of __irq_disable() in irq/chip.c.
	 * First call .irq_disable() if it exists, else mimic the
	 * behaviour of mask_irq() which calls .irq_mask() if
	 * it exists.
	 */
2455 2456
	if (gc->irq.irq_disable)
		gc->irq.irq_disable(d);
2457
	else if (gc->irq.chip->irq_mask)
2458 2459
		gc->irq.chip->irq_mask(d);
	gpiochip_disable_irq(gc, d->hwirq);
2460 2461
}

2462
static void gpiochip_set_irq_hooks(struct gpio_chip *gc)
2463
{
2464
	struct irq_chip *irqchip = gc->irq.chip;
2465 2466 2467 2468 2469 2470

	if (!irqchip->irq_request_resources &&
	    !irqchip->irq_release_resources) {
		irqchip->irq_request_resources = gpiochip_irq_reqres;
		irqchip->irq_release_resources = gpiochip_irq_relres;
	}
2471
	if (WARN_ON(gc->irq.irq_enable))
2472
		return;
2473 2474 2475 2476 2477 2478
	/* Check if the irqchip already has this hook... */
	if (irqchip->irq_enable == gpiochip_irq_enable) {
		/*
		 * ...and if so, give a gentle warning that this is bad
		 * practice.
		 */
2479
		chip_info(gc,
2480 2481 2482
			  "detected irqchip that is shared with multiple gpiochips: please fix the driver.\n");
		return;
	}
2483 2484
	gc->irq.irq_enable = irqchip->irq_enable;
	gc->irq.irq_disable = irqchip->irq_disable;
2485 2486
	irqchip->irq_enable = gpiochip_irq_enable;
	irqchip->irq_disable = gpiochip_irq_disable;
2487 2488
}

2489 2490
/**
 * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip
2491
 * @gc: the GPIO chip to add the IRQ chip to
2492 2493
 * @lock_key: lockdep class for IRQ lock
 * @request_key: lockdep class for IRQ request
2494
 */
2495
static int gpiochip_add_irqchip(struct gpio_chip *gc,
2496 2497
				struct lock_class_key *lock_key,
				struct lock_class_key *request_key)
2498
{
2499
	struct irq_chip *irqchip = gc->irq.chip;
2500
	const struct irq_domain_ops *ops = NULL;
2501 2502 2503 2504 2505 2506 2507
	struct device_node *np;
	unsigned int type;
	unsigned int i;

	if (!irqchip)
		return 0;

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

2513 2514
	np = gc->gpiodev->dev.of_node;
	type = gc->irq.default_type;
2515 2516 2517 2518 2519 2520 2521 2522 2523 2524

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

2525 2526
	if (has_acpi_companion(gc->parent) && type != IRQ_TYPE_NONE) {
		acpi_handle_warn(ACPI_HANDLE(gc->parent),
2527 2528 2529 2530
				 "Ignoring %u default trigger\n", type);
		type = IRQ_TYPE_NONE;
	}

2531 2532 2533 2534
	gc->to_irq = gpiochip_to_irq;
	gc->irq.default_type = type;
	gc->irq.lock_key = lock_key;
	gc->irq.request_key = request_key;
2535

2536
	/* If a parent irqdomain is provided, let's build a hierarchy */
2537 2538
	if (gpiochip_hierarchy_is_hierarchical(gc)) {
		int ret = gpiochip_hierarchy_add_domain(gc);
2539 2540 2541 2542
		if (ret)
			return ret;
	} else {
		/* Some drivers provide custom irqdomain ops */
2543 2544
		if (gc->irq.domain_ops)
			ops = gc->irq.domain_ops;
2545 2546 2547

		if (!ops)
			ops = &gpiochip_domain_ops;
2548 2549 2550 2551 2552
		gc->irq.domain = irq_domain_add_simple(np,
			gc->ngpio,
			gc->irq.first,
			ops, gc);
		if (!gc->irq.domain)
2553 2554
			return -EINVAL;
	}
2555

2556 2557
	if (gc->irq.parent_handler) {
		void *data = gc->irq.parent_handler_data ?: gc;
2558

2559
		for (i = 0; i < gc->irq.num_parents; i++) {
2560 2561 2562 2563 2564
			/*
			 * The parent IRQ chip is already using the chip_data
			 * for this IRQ chip, so our callbacks simply use the
			 * handler_data.
			 */
2565 2566
			irq_set_chained_handler_and_data(gc->irq.parents[i],
							 gc->irq.parent_handler,
2567 2568 2569 2570
							 data);
		}
	}

2571
	gpiochip_set_irq_hooks(gc);
2572

2573
	acpi_gpiochip_request_interrupts(gc);
2574 2575 2576 2577

	return 0;
}

2578 2579
/**
 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
2580
 * @gc: the gpiochip to remove the irqchip from
2581 2582 2583
 *
 * This is called only from gpiochip_remove()
 */
2584
static void gpiochip_irqchip_remove(struct gpio_chip *gc)
2585
{
2586
	struct irq_chip *irqchip = gc->irq.chip;
2587
	unsigned int offset;
L
Linus Walleij 已提交
2588

2589
	acpi_gpiochip_free_interrupts(gc);
2590

2591 2592
	if (irqchip && gc->irq.parent_handler) {
		struct gpio_irq_chip *irq = &gc->irq;
2593 2594 2595 2596 2597
		unsigned int i;

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

L
Linus Walleij 已提交
2600
	/* Remove all IRQ mappings and delete the domain */
2601
	if (gc->irq.domain) {
2602 2603
		unsigned int irq;

2604 2605
		for (offset = 0; offset < gc->ngpio; offset++) {
			if (!gpiochip_irqchip_irq_valid(gc, offset))
2606
				continue;
2607

2608
			irq = irq_find_mapping(gc->irq.domain, offset);
2609
			irq_dispose_mapping(irq);
2610
		}
2611

2612
		irq_domain_remove(gc->irq.domain);
L
Linus Walleij 已提交
2613
	}
2614

2615 2616 2617 2618 2619 2620
	if (irqchip) {
		if (irqchip->irq_request_resources == gpiochip_irq_reqres) {
			irqchip->irq_request_resources = NULL;
			irqchip->irq_release_resources = NULL;
		}
		if (irqchip->irq_enable == gpiochip_irq_enable) {
2621 2622
			irqchip->irq_enable = gc->irq.irq_enable;
			irqchip->irq_disable = gc->irq.irq_disable;
2623
		}
2624
	}
2625 2626 2627
	gc->irq.irq_enable = NULL;
	gc->irq.irq_disable = NULL;
	gc->irq.chip = NULL;
2628

2629
	gpiochip_irqchip_free_valid_mask(gc);
2630 2631 2632
}

/**
2633
 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
2634
 * @gc: the gpiochip to add the irqchip to
2635 2636 2637 2638
 * @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)
2639 2640
 * @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.
2641
 * @threaded: whether this irqchip uses a nested thread handler
2642 2643
 * @lock_key: lockdep class for IRQ lock
 * @request_key: lockdep class for IRQ request
2644 2645 2646 2647 2648
 *
 * 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 已提交
2649
 * need to use gpiochip_get_data() to get their local state containers back
2650 2651 2652 2653 2654
 * 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 已提交
2655 2656
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
2657 2658
 * need to be open coded.
 */
2659
int gpiochip_irqchip_add_key(struct gpio_chip *gc,
2660 2661 2662 2663
			     struct irq_chip *irqchip,
			     unsigned int first_irq,
			     irq_flow_handler_t handler,
			     unsigned int type,
2664
			     bool threaded,
2665 2666
			     struct lock_class_key *lock_key,
			     struct lock_class_key *request_key)
2667 2668 2669
{
	struct device_node *of_node;

2670
	if (!gc || !irqchip)
2671 2672
		return -EINVAL;

2673
	if (!gc->parent) {
2674
		chip_err(gc, "missing gpiochip .dev parent pointer\n");
2675 2676
		return -EINVAL;
	}
2677 2678
	gc->irq.threaded = threaded;
	of_node = gc->parent->of_node;
2679 2680
#ifdef CONFIG_OF_GPIO
	/*
2681
	 * If the gpiochip has an assigned OF node this takes precedence
2682
	 * FIXME: get rid of this and use gc->parent->of_node
2683
	 * everywhere
2684
	 */
2685 2686
	if (gc->of_node)
		of_node = gc->of_node;
2687
#endif
2688
	/*
2689
	 * Specifying a default trigger is a terrible idea if DT or ACPI is
2690 2691 2692 2693
	 * 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,
2694
		 "%pOF: Ignoring %d default trigger\n", of_node, type))
2695
		type = IRQ_TYPE_NONE;
2696 2697
	if (has_acpi_companion(gc->parent) && type != IRQ_TYPE_NONE) {
		acpi_handle_warn(ACPI_HANDLE(gc->parent),
2698 2699 2700
				 "Ignoring %d default trigger\n", type);
		type = IRQ_TYPE_NONE;
	}
2701

2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712
	gc->irq.chip = irqchip;
	gc->irq.handler = handler;
	gc->irq.default_type = type;
	gc->to_irq = gpiochip_to_irq;
	gc->irq.lock_key = lock_key;
	gc->irq.request_key = request_key;
	gc->irq.domain = irq_domain_add_simple(of_node,
					gc->ngpio, first_irq,
					&gpiochip_domain_ops, gc);
	if (!gc->irq.domain) {
		gc->irq.chip = NULL;
2713 2714
		return -EINVAL;
	}
2715

2716
	gpiochip_set_irq_hooks(gc);
2717

2718
	acpi_gpiochip_request_interrupts(gc);
2719

2720 2721
	return 0;
}
2722
EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
2723 2724 2725

#else /* CONFIG_GPIOLIB_IRQCHIP */

2726
static inline int gpiochip_add_irqchip(struct gpio_chip *gc,
2727 2728
				       struct lock_class_key *lock_key,
				       struct lock_class_key *request_key)
2729 2730 2731
{
	return 0;
}
2732
static void gpiochip_irqchip_remove(struct gpio_chip *gc) {}
2733

2734
static inline int gpiochip_irqchip_init_hw(struct gpio_chip *gc)
2735 2736 2737 2738
{
	return 0;
}

2739
static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc)
2740 2741 2742
{
	return 0;
}
2743
static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gc)
2744
{ }
2745 2746 2747

#endif /* CONFIG_GPIOLIB_IRQCHIP */

2748 2749
/**
 * gpiochip_generic_request() - request the gpio function for a pin
2750
 * @gc: the gpiochip owning the GPIO
2751 2752
 * @offset: the offset of the GPIO to request for GPIO function
 */
2753
int gpiochip_generic_request(struct gpio_chip *gc, unsigned offset)
2754
{
2755
#ifdef CONFIG_PINCTRL
2756
	if (list_empty(&gc->gpiodev->pin_ranges))
2757 2758
		return 0;
#endif
2759

2760
	return pinctrl_gpio_request(gc->gpiodev->base + offset);
2761 2762 2763 2764 2765
}
EXPORT_SYMBOL_GPL(gpiochip_generic_request);

/**
 * gpiochip_generic_free() - free the gpio function from a pin
2766
 * @gc: the gpiochip to request the gpio function for
2767 2768
 * @offset: the offset of the GPIO to free from GPIO function
 */
2769
void gpiochip_generic_free(struct gpio_chip *gc, unsigned offset)
2770
{
2771
	pinctrl_gpio_free(gc->gpiodev->base + offset);
2772 2773 2774
}
EXPORT_SYMBOL_GPL(gpiochip_generic_free);

2775 2776
/**
 * gpiochip_generic_config() - apply configuration for a pin
2777
 * @gc: the gpiochip owning the GPIO
2778 2779 2780
 * @offset: the offset of the GPIO to apply the configuration
 * @config: the configuration to be applied
 */
2781
int gpiochip_generic_config(struct gpio_chip *gc, unsigned offset,
2782 2783
			    unsigned long config)
{
2784
	return pinctrl_gpio_set_config(gc->gpiodev->base + offset, config);
2785 2786 2787
}
EXPORT_SYMBOL_GPL(gpiochip_generic_config);

2788
#ifdef CONFIG_PINCTRL
2789

2790 2791
/**
 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
2792
 * @gc: the gpiochip to add the range for
2793
 * @pctldev: the pin controller to map to
2794 2795
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_group: name of the pin group inside the pin controller
2796 2797 2798 2799 2800
 *
 * Calling this function directly from a DeviceTree-supported
 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2801
 */
2802
int gpiochip_add_pingroup_range(struct gpio_chip *gc,
2803 2804 2805 2806
			struct pinctrl_dev *pctldev,
			unsigned int gpio_offset, const char *pin_group)
{
	struct gpio_pin_range *pin_range;
2807
	struct gpio_device *gdev = gc->gpiodev;
2808 2809 2810 2811
	int ret;

	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
	if (!pin_range) {
2812
		chip_err(gc, "failed to allocate pin ranges\n");
2813 2814 2815 2816 2817
		return -ENOMEM;
	}

	/* Use local offset as range ID */
	pin_range->range.id = gpio_offset;
2818 2819
	pin_range->range.gc = gc;
	pin_range->range.name = gc->label;
2820
	pin_range->range.base = gdev->base + gpio_offset;
2821 2822 2823 2824 2825
	pin_range->pctldev = pctldev;

	ret = pinctrl_get_group_pins(pctldev, pin_group,
					&pin_range->range.pins,
					&pin_range->range.npins);
2826 2827
	if (ret < 0) {
		kfree(pin_range);
2828
		return ret;
2829
	}
2830 2831 2832

	pinctrl_add_gpio_range(pctldev, &pin_range->range);

2833
	chip_dbg(gc, "created GPIO range %d->%d ==> %s PINGRP %s\n",
2834
		 gpio_offset, gpio_offset + pin_range->range.npins - 1,
2835 2836
		 pinctrl_dev_get_devname(pctldev), pin_group);

2837
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
2838 2839 2840 2841 2842

	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);

2843 2844
/**
 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
2845
 * @gc: the gpiochip to add the range for
T
Thierry Reding 已提交
2846
 * @pinctl_name: the dev_name() of the pin controller to map to
2847 2848
 * @gpio_offset: the start offset in the current gpio_chip number space
 * @pin_offset: the start offset in the pin controller number space
2849 2850
 * @npins: the number of pins from the offset of each pin space (GPIO and
 *	pin controller) to accumulate in this range
T
Thierry Reding 已提交
2851 2852 2853
 *
 * Returns:
 * 0 on success, or a negative error-code on failure.
2854 2855 2856 2857 2858
 *
 * Calling this function directly from a DeviceTree-supported
 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2859
 */
2860
int gpiochip_add_pin_range(struct gpio_chip *gc, const char *pinctl_name,
2861
			   unsigned int gpio_offset, unsigned int pin_offset,
2862
			   unsigned int npins)
2863 2864
{
	struct gpio_pin_range *pin_range;
2865
	struct gpio_device *gdev = gc->gpiodev;
2866
	int ret;
2867

2868
	pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2869
	if (!pin_range) {
2870
		chip_err(gc, "failed to allocate pin ranges\n");
2871
		return -ENOMEM;
2872 2873
	}

2874
	/* Use local offset as range ID */
2875
	pin_range->range.id = gpio_offset;
2876 2877
	pin_range->range.gc = gc;
	pin_range->range.name = gc->label;
2878
	pin_range->range.base = gdev->base + gpio_offset;
2879
	pin_range->range.pin_base = pin_offset;
2880
	pin_range->range.npins = npins;
L
Linus Walleij 已提交
2881
	pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
2882
			&pin_range->range);
2883
	if (IS_ERR(pin_range->pctldev)) {
2884
		ret = PTR_ERR(pin_range->pctldev);
2885
		chip_err(gc, "could not create pin range\n");
2886
		kfree(pin_range);
2887
		return ret;
2888
	}
2889
	chip_dbg(gc, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
2890
		 gpio_offset, gpio_offset + npins - 1,
2891 2892
		 pinctl_name,
		 pin_offset, pin_offset + npins - 1);
2893

2894
	list_add_tail(&pin_range->node, &gdev->pin_ranges);
2895 2896

	return 0;
2897
}
2898
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2899

2900 2901
/**
 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
2902
 * @gc: the chip to remove all the mappings for
2903
 */
2904
void gpiochip_remove_pin_ranges(struct gpio_chip *gc)
2905 2906
{
	struct gpio_pin_range *pin_range, *tmp;
2907
	struct gpio_device *gdev = gc->gpiodev;
2908

2909
	list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2910 2911 2912
		list_del(&pin_range->node);
		pinctrl_remove_gpio_range(pin_range->pctldev,
				&pin_range->range);
2913
		kfree(pin_range);
2914 2915
	}
}
2916 2917 2918
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);

#endif /* CONFIG_PINCTRL */
2919

2920 2921 2922 2923
/* 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.
 */
2924
static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2925
{
2926
	struct gpio_chip	*gc = desc->gdev->chip;
2927
	int			ret;
2928
	unsigned long		flags;
2929
	unsigned		offset;
2930

2931 2932 2933 2934 2935 2936
	if (label) {
		label = kstrdup_const(label, GFP_KERNEL);
		if (!label)
			return -ENOMEM;
	}

2937 2938
	spin_lock_irqsave(&gpio_lock, flags);

2939
	/* NOTE:  gpio_request() can be called in early boot,
D
David Brownell 已提交
2940
	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2941 2942 2943 2944
	 */

	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
		desc_set_label(desc, label ? : "?");
2945
		ret = 0;
2946
	} else {
2947
		kfree_const(label);
2948
		ret = -EBUSY;
M
Magnus Damm 已提交
2949
		goto done;
D
David Brownell 已提交
2950 2951
	}

2952 2953
	if (gc->request) {
		/* gc->request may sleep */
D
David Brownell 已提交
2954
		spin_unlock_irqrestore(&gpio_lock, flags);
2955
		offset = gpio_chip_hwgpio(desc);
2956 2957
		if (gpiochip_line_is_valid(gc, offset))
			ret = gc->request(gc, offset);
2958
		else
2959
			ret = -EINVAL;
D
David Brownell 已提交
2960 2961
		spin_lock_irqsave(&gpio_lock, flags);

2962
		if (ret < 0) {
D
David Brownell 已提交
2963
			desc_set_label(desc, NULL);
2964
			kfree_const(label);
D
David Brownell 已提交
2965
			clear_bit(FLAG_REQUESTED, &desc->flags);
2966
			goto done;
D
David Brownell 已提交
2967
		}
2968
	}
2969 2970
	if (gc->get_direction) {
		/* gc->get_direction may sleep */
2971
		spin_unlock_irqrestore(&gpio_lock, flags);
2972
		gpiod_get_direction(desc);
2973 2974
		spin_lock_irqsave(&gpio_lock, flags);
	}
2975 2976
done:
	spin_unlock_irqrestore(&gpio_lock, flags);
2977 2978
	atomic_notifier_call_chain(&desc->gdev->notifier,
				   GPIOLINE_CHANGED_REQUESTED, desc);
2979
	return ret;
2980 2981
}

2982 2983 2984
/*
 * This descriptor validation needs to be inserted verbatim into each
 * function taking a descriptor, so we need to use a preprocessor
2985 2986
 * macro to avoid endless duplication. If the desc is NULL it is an
 * optional GPIO and calls should just bail out.
2987
 */
2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007
static int validate_desc(const struct gpio_desc *desc, const char *func)
{
	if (!desc)
		return 0;
	if (IS_ERR(desc)) {
		pr_warn("%s: invalid GPIO (errorpointer)\n", func);
		return PTR_ERR(desc);
	}
	if (!desc->gdev) {
		pr_warn("%s: invalid GPIO (no device)\n", func);
		return -EINVAL;
	}
	if (!desc->gdev->chip) {
		dev_warn(&desc->gdev->dev,
			 "%s: backing chip is gone\n", func);
		return 0;
	}
	return 1;
}

3008
#define VALIDATE_DESC(desc) do { \
3009 3010 3011 3012
	int __valid = validate_desc(desc, __func__); \
	if (__valid <= 0) \
		return __valid; \
	} while (0)
3013 3014

#define VALIDATE_DESC_VOID(desc) do { \
3015 3016
	int __valid = validate_desc(desc, __func__); \
	if (__valid <= 0) \
3017
		return; \
3018
	} while (0)
3019

3020
int gpiod_request(struct gpio_desc *desc, const char *label)
3021
{
3022
	int ret = -EPROBE_DEFER;
3023
	struct gpio_device *gdev;
3024

3025 3026
	VALIDATE_DESC(desc);
	gdev = desc->gdev;
3027

3028
	if (try_module_get(gdev->owner)) {
3029 3030
		ret = gpiod_request_commit(desc, label);
		if (ret < 0)
3031
			module_put(gdev->owner);
3032 3033
		else
			get_device(&gdev->dev);
3034 3035
	}

3036 3037
	if (ret)
		gpiod_dbg(desc, "%s: status %d\n", __func__, ret);
3038

3039
	return ret;
3040
}
3041

3042
static bool gpiod_free_commit(struct gpio_desc *desc)
3043
{
3044
	bool			ret = false;
3045
	unsigned long		flags;
3046
	struct gpio_chip	*gc;
3047

3048 3049
	might_sleep();

3050
	gpiod_unexport(desc);
D
David Brownell 已提交
3051

3052 3053
	spin_lock_irqsave(&gpio_lock, flags);

3054 3055 3056
	gc = desc->gdev->chip;
	if (gc && test_bit(FLAG_REQUESTED, &desc->flags)) {
		if (gc->free) {
D
David Brownell 已提交
3057
			spin_unlock_irqrestore(&gpio_lock, flags);
3058 3059
			might_sleep_if(gc->can_sleep);
			gc->free(gc, gpio_chip_hwgpio(desc));
D
David Brownell 已提交
3060 3061
			spin_lock_irqsave(&gpio_lock, flags);
		}
3062
		kfree_const(desc->label);
3063
		desc_set_label(desc, NULL);
3064
		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
D
David Brownell 已提交
3065
		clear_bit(FLAG_REQUESTED, &desc->flags);
3066
		clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
3067
		clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
3068 3069
		clear_bit(FLAG_PULL_UP, &desc->flags);
		clear_bit(FLAG_PULL_DOWN, &desc->flags);
3070
		clear_bit(FLAG_BIAS_DISABLE, &desc->flags);
B
Benoit Parrot 已提交
3071
		clear_bit(FLAG_IS_HOGGED, &desc->flags);
3072 3073 3074
#ifdef CONFIG_OF_DYNAMIC
		desc->hog = NULL;
#endif
3075 3076
		ret = true;
	}
3077 3078

	spin_unlock_irqrestore(&gpio_lock, flags);
3079 3080 3081
	atomic_notifier_call_chain(&desc->gdev->notifier,
				   GPIOLINE_CHANGED_RELEASED, desc);

3082 3083 3084
	return ret;
}

3085
void gpiod_free(struct gpio_desc *desc)
3086
{
3087
	if (desc && desc->gdev && gpiod_free_commit(desc)) {
3088
		module_put(desc->gdev->owner);
3089 3090
		put_device(&desc->gdev->dev);
	} else {
3091
		WARN_ON(extra_checks);
3092
	}
3093
}
3094

3095 3096
/**
 * gpiochip_is_requested - return string iff signal was requested
3097
 * @gc: controller managing the signal
3098 3099 3100
 * @offset: of signal within controller's 0..(ngpio - 1) range
 *
 * Returns NULL if the GPIO is not currently requested, else a string.
3101 3102
 * The string returned is the label passed to gpio_request(); if none has been
 * passed it is a meaningless, non-NULL constant.
3103 3104 3105 3106 3107
 *
 * 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.
 */
3108
const char *gpiochip_is_requested(struct gpio_chip *gc, unsigned offset)
3109
{
3110
	struct gpio_desc *desc;
3111

3112
	if (offset >= gc->ngpio)
3113
		return NULL;
3114

3115
	desc = gpiochip_get_desc(gc, offset);
3116 3117
	if (IS_ERR(desc))
		return NULL;
3118

3119
	if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
3120
		return NULL;
3121
	return desc->label;
3122 3123 3124
}
EXPORT_SYMBOL_GPL(gpiochip_is_requested);

3125 3126
/**
 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
3127
 * @gc: GPIO chip
T
Thierry Reding 已提交
3128
 * @hwnum: hardware number of the GPIO for which to request the descriptor
3129
 * @label: label for the GPIO
3130 3131 3132 3133 3134
 * @lflags: lookup flags for this GPIO or 0 if default, this can be used to
 * specify things like line inversion semantics with the machine flags
 * such as GPIO_OUT_LOW
 * @dflags: descriptor request flags for this GPIO or 0 if default, this
 * can be used to specify consumer semantics such as open drain
3135 3136 3137 3138 3139 3140
 *
 * 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 已提交
3141 3142 3143 3144
 *
 * Returns:
 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
 * code on failure.
3145
 */
3146
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *gc,
3147
					    unsigned int hwnum,
3148
					    const char *label,
3149 3150
					    enum gpio_lookup_flags lflags,
					    enum gpiod_flags dflags)
3151
{
3152
	struct gpio_desc *desc = gpiochip_get_desc(gc, hwnum);
3153
	int ret;
3154

3155
	if (IS_ERR(desc)) {
3156
		chip_err(gc, "failed to get GPIO descriptor\n");
3157 3158 3159
		return desc;
	}

3160 3161 3162
	ret = gpiod_request_commit(desc, label);
	if (ret < 0)
		return ERR_PTR(ret);
3163

3164 3165
	ret = gpiod_configure_flags(desc, label, lflags, dflags);
	if (ret) {
3166
		chip_err(gc, "setup of own GPIO %s failed\n", label);
3167
		gpiod_free_commit(desc);
3168
		return ERR_PTR(ret);
3169 3170
	}

3171
	return desc;
3172
}
3173
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184

/**
 * 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)
3185
		gpiod_free_commit(desc);
3186
}
3187
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
3188

3189 3190
/*
 * Drivers MUST set GPIO direction before making get/set calls.  In
3191 3192 3193 3194 3195 3196 3197 3198
 * 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.
 */

3199
static int gpio_do_set_config(struct gpio_chip *gc, unsigned int offset,
3200
			      unsigned long config)
3201
{
3202 3203
	if (!gc->set_config)
		return -ENOTSUPP;
3204

3205
	return gc->set_config(gc, offset, config);
3206 3207
}

3208
static int gpio_set_config(struct gpio_desc *desc, enum pin_config_param mode)
3209
{
3210
	struct gpio_chip *gc = desc->gdev->chip;
3211
	unsigned long config;
3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223
	unsigned arg;

	switch (mode) {
	case PIN_CONFIG_BIAS_PULL_DOWN:
	case PIN_CONFIG_BIAS_PULL_UP:
		arg = 1;
		break;

	default:
		arg = 0;
	}

3224
	config = PIN_CONF_PACKED(mode, arg);
3225
	return gpio_do_set_config(gc, gpio_chip_hwgpio(desc), config);
3226 3227
}

3228
static int gpio_set_bias(struct gpio_desc *desc)
3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240
{
	int bias = 0;
	int ret = 0;

	if (test_bit(FLAG_BIAS_DISABLE, &desc->flags))
		bias = PIN_CONFIG_BIAS_DISABLE;
	else if (test_bit(FLAG_PULL_UP, &desc->flags))
		bias = PIN_CONFIG_BIAS_PULL_UP;
	else if (test_bit(FLAG_PULL_DOWN, &desc->flags))
		bias = PIN_CONFIG_BIAS_PULL_DOWN;

	if (bias) {
3241
		ret = gpio_set_config(desc, bias);
3242 3243 3244 3245 3246 3247
		if (ret != -ENOTSUPP)
			return ret;
	}
	return 0;
}

3248 3249 3250 3251 3252 3253 3254 3255 3256 3257
/**
 * 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)
3258
{
3259
	struct gpio_chip	*gc;
3260
	int			ret = 0;
3261

3262
	VALIDATE_DESC(desc);
3263
	gc = desc->gdev->chip;
3264

3265 3266 3267 3268 3269
	/*
	 * It is legal to have no .get() and .direction_input() specified if
	 * the chip is output-only, but you can't specify .direction_input()
	 * and not support the .get() operation, that doesn't make sense.
	 */
3270
	if (!gc->get && gc->direction_input) {
3271
		gpiod_warn(desc,
3272 3273
			   "%s: missing get() but have direction_input()\n",
			   __func__);
3274 3275 3276
		return -EIO;
	}

3277 3278 3279 3280 3281 3282
	/*
	 * If we have a .direction_input() callback, things are simple,
	 * just call it. Else we are some input-only chip so try to check the
	 * direction (if .get_direction() is supported) else we silently
	 * assume we are in input mode after this.
	 */
3283 3284 3285 3286
	if (gc->direction_input) {
		ret = gc->direction_input(gc, gpio_chip_hwgpio(desc));
	} else if (gc->get_direction &&
		  (gc->get_direction(gc, gpio_chip_hwgpio(desc)) != 1)) {
3287
		gpiod_warn(desc,
3288 3289
			   "%s: missing direction_input() operation and line is output\n",
			   __func__);
3290 3291
		return -EIO;
	}
3292
	if (ret == 0) {
3293
		clear_bit(FLAG_IS_OUT, &desc->flags);
3294
		ret = gpio_set_bias(desc);
3295
	}
3296

3297
	trace_gpio_direction(desc_to_gpio(desc), 1, ret);
3298

3299
	return ret;
3300
}
3301
EXPORT_SYMBOL_GPL(gpiod_direction_input);
3302

3303
static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
3304
{
3305
	struct gpio_chip *gc = desc->gdev->chip;
3306
	int val = !!value;
3307
	int ret = 0;
3308

3309 3310 3311 3312 3313
	/*
	 * It's OK not to specify .direction_output() if the gpiochip is
	 * output-only, but if there is then not even a .set() operation it
	 * is pretty tricky to drive the output line.
	 */
3314
	if (!gc->set && !gc->direction_output) {
3315
		gpiod_warn(desc,
3316 3317
			   "%s: missing set() and direction_output() operations\n",
			   __func__);
3318 3319 3320
		return -EIO;
	}

3321 3322 3323
	if (gc->direction_output) {
		ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
	} else {
3324
		/* Check that we are in output mode if we can */
3325 3326 3327 3328 3329 3330 3331
		if (gc->get_direction &&
		    gc->get_direction(gc, gpio_chip_hwgpio(desc))) {
			gpiod_warn(desc,
				"%s: missing direction_output() operation\n",
				__func__);
			return -EIO;
		}
3332 3333 3334 3335
		/*
		 * If we can't actively set the direction, we are some
		 * output-only chip, so just drive the output as desired.
		 */
3336 3337 3338
		gc->set(gc, gpio_chip_hwgpio(desc), val);
	}

3339
	if (!ret)
3340
		set_bit(FLAG_IS_OUT, &desc->flags);
3341
	trace_gpio_value(desc_to_gpio(desc), 0, val);
3342 3343
	trace_gpio_direction(desc_to_gpio(desc), 0, ret);
	return ret;
3344
}
3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358

/**
 * 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)
{
3359
	VALIDATE_DESC(desc);
3360
	return gpiod_direction_output_raw_commit(desc, value);
3361 3362 3363 3364
}
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);

/**
3365
 * gpiod_direction_output - set the GPIO direction to output
3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377
 * @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)
{
3378 3379
	int ret;

3380
	VALIDATE_DESC(desc);
3381 3382
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
3383 3384
	else
		value = !!value;
3385

3386 3387 3388
	/* GPIOs used for enabled IRQs shall not be set as output */
	if (test_bit(FLAG_USED_AS_IRQ, &desc->flags) &&
	    test_bit(FLAG_IRQ_IS_ENABLED, &desc->flags)) {
3389 3390 3391 3392 3393 3394 3395 3396
		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 */
3397
		ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_DRAIN);
3398 3399 3400
		if (!ret)
			goto set_output_value;
		/* Emulate open drain by not actively driving the line high */
3401 3402 3403 3404
		if (value) {
			ret = gpiod_direction_input(desc);
			goto set_output_flag;
		}
3405 3406
	}
	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
3407
		ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_SOURCE);
3408 3409 3410
		if (!ret)
			goto set_output_value;
		/* Emulate open source by not actively driving the line low */
3411 3412 3413 3414
		if (!value) {
			ret = gpiod_direction_input(desc);
			goto set_output_flag;
		}
3415
	} else {
3416
		gpio_set_config(desc, PIN_CONFIG_DRIVE_PUSH_PULL);
3417 3418 3419
	}

set_output_value:
3420
	ret = gpio_set_bias(desc);
3421 3422
	if (ret)
		return ret;
3423
	return gpiod_direction_output_raw_commit(desc, value);
3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434

set_output_flag:
	/*
	 * When emulating open-source or open-drain functionalities by not
	 * actively driving the line (setting mode to input) we still need to
	 * set the IS_OUT flag or otherwise we won't be able to set the line
	 * value anymore.
	 */
	if (ret == 0)
		set_bit(FLAG_IS_OUT, &desc->flags);
	return ret;
3435
}
3436
EXPORT_SYMBOL_GPL(gpiod_direction_output);
3437

3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448
/**
 * gpiod_set_config - sets @config for a GPIO
 * @desc: descriptor of the GPIO for which to set the configuration
 * @config: Same packed config format as generic pinconf
 *
 * Returns:
 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
 * configuration.
 */
int gpiod_set_config(struct gpio_desc *desc, unsigned long config)
{
3449
	struct gpio_chip *gc;
3450 3451

	VALIDATE_DESC(desc);
3452
	gc = desc->gdev->chip;
3453

3454
	return gpio_do_set_config(gc, gpio_chip_hwgpio(desc), config);
3455 3456 3457
}
EXPORT_SYMBOL_GPL(gpiod_set_config);

3458
/**
T
Thierry Reding 已提交
3459 3460 3461
 * 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
3462
 *
T
Thierry Reding 已提交
3463 3464 3465
 * Returns:
 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
 * debounce time.
3466
 */
3467
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
3468
{
3469
	unsigned long config;
3470

3471
	config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
3472
	return gpiod_set_config(desc, config);
3473
}
3474
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
3475

3476 3477 3478 3479 3480 3481 3482 3483 3484 3485
/**
 * gpiod_set_transitory - Lose or retain GPIO state on suspend or reset
 * @desc: descriptor of the GPIO for which to configure persistence
 * @transitory: True to lose state on suspend or reset, false for persistence
 *
 * Returns:
 * 0 on success, otherwise a negative error code.
 */
int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
{
3486
	struct gpio_chip *gc;
3487 3488 3489 3490
	unsigned long packed;
	int gpio;
	int rc;

3491
	VALIDATE_DESC(desc);
3492 3493 3494 3495
	/*
	 * Handle FLAG_TRANSITORY first, enabling queries to gpiolib for
	 * persistence state.
	 */
3496
	assign_bit(FLAG_TRANSITORY, &desc->flags, transitory);
3497 3498

	/* If the driver supports it, set the persistence state now */
3499 3500
	gc = desc->gdev->chip;
	if (!gc->set_config)
3501 3502 3503 3504 3505
		return 0;

	packed = pinconf_to_config_packed(PIN_CONFIG_PERSIST_STATE,
					  !transitory);
	gpio = gpio_chip_hwgpio(desc);
3506
	rc = gpio_do_set_config(gc, gpio, packed);
3507 3508 3509 3510 3511 3512 3513 3514 3515 3516
	if (rc == -ENOTSUPP) {
		dev_dbg(&desc->gdev->dev, "Persistence not supported for GPIO %d\n",
				gpio);
		return 0;
	}

	return rc;
}
EXPORT_SYMBOL_GPL(gpiod_set_transitory);

3517 3518 3519 3520 3521 3522 3523
/**
 * 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)
3524
{
3525
	VALIDATE_DESC(desc);
3526
	return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
3527
}
3528
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
3529

3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540
/**
 * gpiod_toggle_active_low - toggle whether a GPIO is active-low or not
 * @desc: the gpio descriptor to change
 */
void gpiod_toggle_active_low(struct gpio_desc *desc)
{
	VALIDATE_DESC_VOID(desc);
	change_bit(FLAG_ACTIVE_LOW, &desc->flags);
}
EXPORT_SYMBOL_GPL(gpiod_toggle_active_low);

3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562
/* 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.
 */

3563
static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
3564
{
3565
	struct gpio_chip	*gc;
3566
	int offset;
3567
	int value;
3568

3569
	gc = desc->gdev->chip;
3570
	offset = gpio_chip_hwgpio(desc);
3571
	value = gc->get ? gc->get(gc, offset) : -EIO;
3572
	value = value < 0 ? value : !!value;
3573
	trace_gpio_value(desc_to_gpio(desc), 1, value);
3574
	return value;
3575
}
3576

3577
static int gpio_chip_get_multiple(struct gpio_chip *gc,
3578 3579
				  unsigned long *mask, unsigned long *bits)
{
3580 3581 3582
	if (gc->get_multiple) {
		return gc->get_multiple(gc, mask, bits);
	} else if (gc->get) {
3583 3584
		int i, value;

3585 3586
		for_each_set_bit(i, mask, gc->ngpio) {
			value = gc->get(gc, i);
3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598
			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,
3599
				  struct gpio_array *array_info,
3600
				  unsigned long *value_bitmap)
3601
{
3602
	int ret, i = 0;
3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614

	/*
	 * Validate array_info against desc_array and its size.
	 * It should immediately follow desc_array if both
	 * have been obtained from the same gpiod_get_array() call.
	 */
	if (array_info && array_info->desc == desc_array &&
	    array_size <= array_info->size &&
	    (void *)array_info == desc_array + array_info->size) {
		if (!can_sleep)
			WARN_ON(array_info->chip->can_sleep);

3615
		ret = gpio_chip_get_multiple(array_info->chip,
3616 3617
					     array_info->get_mask,
					     value_bitmap);
3618 3619
		if (ret)
			return ret;
3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631

		if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
			bitmap_xor(value_bitmap, value_bitmap,
				   array_info->invert_mask, array_size);

		if (bitmap_full(array_info->get_mask, array_size))
			return 0;

		i = find_first_zero_bit(array_info->get_mask, array_size);
	} else {
		array_info = NULL;
	}
3632 3633

	while (i < array_size) {
3634
		struct gpio_chip *gc = desc_array[i]->gdev->chip;
L
Laura Abbott 已提交
3635 3636
		unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
		unsigned long *mask, *bits;
3637 3638
		int first, j, ret;

3639
		if (likely(gc->ngpio <= FASTPATH_NGPIO)) {
L
Laura Abbott 已提交
3640 3641
			mask = fastpath;
		} else {
3642
			mask = kmalloc_array(2 * BITS_TO_LONGS(gc->ngpio),
L
Laura Abbott 已提交
3643 3644 3645 3646 3647 3648
					   sizeof(*mask),
					   can_sleep ? GFP_KERNEL : GFP_ATOMIC);
			if (!mask)
				return -ENOMEM;
		}

3649 3650
		bits = mask + BITS_TO_LONGS(gc->ngpio);
		bitmap_zero(mask, gc->ngpio);
L
Laura Abbott 已提交
3651

3652
		if (!can_sleep)
3653
			WARN_ON(gc->can_sleep);
3654 3655 3656 3657 3658 3659 3660 3661 3662

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

			__set_bit(hwgpio, mask);
			i++;
3663 3664

			if (array_info)
3665 3666
				i = find_next_zero_bit(array_info->get_mask,
						       array_size, i);
3667
		} while ((i < array_size) &&
3668
			 (desc_array[i]->gdev->chip == gc));
3669

3670
		ret = gpio_chip_get_multiple(gc, mask, bits);
L
Laura Abbott 已提交
3671 3672 3673
		if (ret) {
			if (mask != fastpath)
				kfree(mask);
3674
			return ret;
L
Laura Abbott 已提交
3675
		}
3676

3677
		for (j = first; j < i; ) {
3678 3679 3680 3681 3682 3683
			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;
3684
			__assign_bit(j, value_bitmap, value);
3685
			trace_gpio_value(desc_to_gpio(desc), 1, value);
3686
			j++;
3687 3688

			if (array_info)
3689 3690
				j = find_next_zero_bit(array_info->get_mask, i,
						       j);
3691
		}
L
Laura Abbott 已提交
3692 3693 3694

		if (mask != fastpath)
			kfree(mask);
3695 3696 3697 3698
	}
	return 0;
}

3699
/**
3700 3701
 * gpiod_get_raw_value() - return a gpio's raw value
 * @desc: gpio whose value will be returned
3702
 *
3703
 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
3704
 * its ACTIVE_LOW status, or negative errno on failure.
3705
 *
3706
 * This function can be called from contexts where we cannot sleep, and will
3707
 * complain if the GPIO chip functions potentially sleep.
3708
 */
3709
int gpiod_get_raw_value(const struct gpio_desc *desc)
3710
{
3711
	VALIDATE_DESC(desc);
3712
	/* Should be using gpiod_get_raw_value_cansleep() */
3713
	WARN_ON(desc->gdev->chip->can_sleep);
3714
	return gpiod_get_raw_value_commit(desc);
3715
}
3716
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
3717

3718 3719 3720 3721 3722
/**
 * 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
3723
 * account, or negative errno on failure.
3724
 *
3725
 * This function can be called from contexts where we cannot sleep, and will
3726 3727 3728
 * complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_value(const struct gpio_desc *desc)
3729
{
3730
	int value;
3731 3732

	VALIDATE_DESC(desc);
3733
	/* Should be using gpiod_get_value_cansleep() */
3734
	WARN_ON(desc->gdev->chip->can_sleep);
3735

3736
	value = gpiod_get_raw_value_commit(desc);
3737 3738 3739
	if (value < 0)
		return value;

3740 3741 3742 3743
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

	return value;
3744
}
3745
EXPORT_SYMBOL_GPL(gpiod_get_value);
3746

3747 3748
/**
 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
3749
 * @array_size: number of elements in the descriptor array / value bitmap
3750
 * @desc_array: array of GPIO descriptors whose values will be read
3751
 * @array_info: information on applicability of fast bitmap processing path
3752
 * @value_bitmap: bitmap to store the read values
3753 3754 3755 3756 3757
 *
 * 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.
 *
3758
 * This function can be called from contexts where we cannot sleep,
3759 3760 3761
 * and it will complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_raw_array_value(unsigned int array_size,
3762
			      struct gpio_desc **desc_array,
3763
			      struct gpio_array *array_info,
3764
			      unsigned long *value_bitmap)
3765 3766 3767 3768
{
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, false, array_size,
3769 3770
					     desc_array, array_info,
					     value_bitmap);
3771 3772 3773 3774 3775
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);

/**
 * gpiod_get_array_value() - read values from an array of GPIOs
3776
 * @array_size: number of elements in the descriptor array / value bitmap
3777
 * @desc_array: array of GPIO descriptors whose values will be read
3778
 * @array_info: information on applicability of fast bitmap processing path
3779
 * @value_bitmap: bitmap to store the read values
3780 3781 3782 3783
 *
 * 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.
 *
3784
 * This function can be called from contexts where we cannot sleep,
3785 3786 3787
 * and it will complain if the GPIO chip functions potentially sleep.
 */
int gpiod_get_array_value(unsigned int array_size,
3788
			  struct gpio_desc **desc_array,
3789
			  struct gpio_array *array_info,
3790
			  unsigned long *value_bitmap)
3791 3792 3793 3794
{
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(false, false, array_size,
3795 3796
					     desc_array, array_info,
					     value_bitmap);
3797 3798 3799
}
EXPORT_SYMBOL_GPL(gpiod_get_array_value);

3800
/*
3801
 *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
3802
 * @desc: gpio descriptor whose state need to be set.
3803
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
3804
 */
3805
static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
3806
{
3807
	int ret = 0;
3808
	struct gpio_chip *gc = desc->gdev->chip;
3809 3810
	int offset = gpio_chip_hwgpio(desc);

3811
	if (value) {
3812
		ret = gc->direction_input(gc, offset);
3813
	} else {
3814
		ret = gc->direction_output(gc, offset, 0);
3815
		if (!ret)
3816
			set_bit(FLAG_IS_OUT, &desc->flags);
3817
	}
3818 3819
	trace_gpio_direction(desc_to_gpio(desc), value, ret);
	if (ret < 0)
3820 3821
		gpiod_err(desc,
			  "%s: Error in set_value for open drain err %d\n",
3822
			  __func__, ret);
3823 3824
}

3825
/*
3826 3827
 *  _gpio_set_open_source_value() - Set the open source gpio's value.
 * @desc: gpio descriptor whose state need to be set.
3828
 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
3829
 */
3830
static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
3831
{
3832
	int ret = 0;
3833
	struct gpio_chip *gc = desc->gdev->chip;
3834 3835
	int offset = gpio_chip_hwgpio(desc);

3836
	if (value) {
3837
		ret = gc->direction_output(gc, offset, 1);
3838
		if (!ret)
3839
			set_bit(FLAG_IS_OUT, &desc->flags);
3840
	} else {
3841
		ret = gc->direction_input(gc, offset);
3842
	}
3843 3844
	trace_gpio_direction(desc_to_gpio(desc), !value, ret);
	if (ret < 0)
3845 3846
		gpiod_err(desc,
			  "%s: Error in set_value for open source err %d\n",
3847
			  __func__, ret);
3848 3849
}

3850
static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
3851
{
3852
	struct gpio_chip	*gc;
3853

3854
	gc = desc->gdev->chip;
3855
	trace_gpio_value(desc_to_gpio(desc), 0, value);
3856
	gc->set(gc, gpio_chip_hwgpio(desc), value);
3857 3858
}

3859 3860 3861 3862
/*
 * set multiple outputs on the same chip;
 * use the chip's set_multiple function if available;
 * otherwise set the outputs sequentially;
3863
 * @chip: the GPIO chip we operate on
3864 3865 3866 3867 3868
 * @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
 */
3869
static void gpio_chip_set_multiple(struct gpio_chip *gc,
3870 3871
				   unsigned long *mask, unsigned long *bits)
{
3872 3873
	if (gc->set_multiple) {
		gc->set_multiple(gc, mask, bits);
3874
	} else {
3875 3876 3877
		unsigned int i;

		/* set outputs if the corresponding mask bit is set */
3878 3879
		for_each_set_bit(i, mask, gc->ngpio)
			gc->set(gc, i, test_bit(i, bits));
3880 3881 3882
	}
}

L
Laura Abbott 已提交
3883
int gpiod_set_array_value_complex(bool raw, bool can_sleep,
3884 3885 3886 3887
				  unsigned int array_size,
				  struct gpio_desc **desc_array,
				  struct gpio_array *array_info,
				  unsigned long *value_bitmap)
3888 3889 3890
{
	int i = 0;

3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916
	/*
	 * Validate array_info against desc_array and its size.
	 * It should immediately follow desc_array if both
	 * have been obtained from the same gpiod_get_array() call.
	 */
	if (array_info && array_info->desc == desc_array &&
	    array_size <= array_info->size &&
	    (void *)array_info == desc_array + array_info->size) {
		if (!can_sleep)
			WARN_ON(array_info->chip->can_sleep);

		if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
			bitmap_xor(value_bitmap, value_bitmap,
				   array_info->invert_mask, array_size);

		gpio_chip_set_multiple(array_info->chip, array_info->set_mask,
				       value_bitmap);

		if (bitmap_full(array_info->set_mask, array_size))
			return 0;

		i = find_first_zero_bit(array_info->set_mask, array_size);
	} else {
		array_info = NULL;
	}

3917
	while (i < array_size) {
3918
		struct gpio_chip *gc = desc_array[i]->gdev->chip;
L
Laura Abbott 已提交
3919 3920
		unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
		unsigned long *mask, *bits;
3921 3922
		int count = 0;

3923
		if (likely(gc->ngpio <= FASTPATH_NGPIO)) {
L
Laura Abbott 已提交
3924 3925
			mask = fastpath;
		} else {
3926
			mask = kmalloc_array(2 * BITS_TO_LONGS(gc->ngpio),
L
Laura Abbott 已提交
3927 3928 3929 3930 3931 3932
					   sizeof(*mask),
					   can_sleep ? GFP_KERNEL : GFP_ATOMIC);
			if (!mask)
				return -ENOMEM;
		}

3933 3934
		bits = mask + BITS_TO_LONGS(gc->ngpio);
		bitmap_zero(mask, gc->ngpio);
L
Laura Abbott 已提交
3935

D
Daniel Lockyer 已提交
3936
		if (!can_sleep)
3937
			WARN_ON(gc->can_sleep);
D
Daniel Lockyer 已提交
3938

3939 3940 3941
		do {
			struct gpio_desc *desc = desc_array[i];
			int hwgpio = gpio_chip_hwgpio(desc);
3942
			int value = test_bit(i, value_bitmap);
3943

3944 3945 3946 3947 3948 3949 3950 3951
			/*
			 * Pins applicable for fast input but not for
			 * fast output processing may have been already
			 * inverted inside the fast path, skip them.
			 */
			if (!raw && !(array_info &&
			    test_bit(i, array_info->invert_mask)) &&
			    test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3952 3953 3954 3955 3956 3957
				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
			 */
3958
			if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
3959
				gpio_set_open_drain_value_commit(desc, value);
3960
			} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
3961
				gpio_set_open_source_value_commit(desc, value);
3962 3963
			} else {
				__set_bit(hwgpio, mask);
3964
				__assign_bit(hwgpio, bits, value);
3965 3966 3967
				count++;
			}
			i++;
3968 3969

			if (array_info)
3970 3971
				i = find_next_zero_bit(array_info->set_mask,
						       array_size, i);
3972
		} while ((i < array_size) &&
3973
			 (desc_array[i]->gdev->chip == gc));
3974
		/* push collected bits to outputs */
D
Daniel Lockyer 已提交
3975
		if (count != 0)
3976
			gpio_chip_set_multiple(gc, mask, bits);
L
Laura Abbott 已提交
3977 3978 3979

		if (mask != fastpath)
			kfree(mask);
3980
	}
L
Laura Abbott 已提交
3981
	return 0;
3982 3983
}

3984
/**
3985 3986
 * gpiod_set_raw_value() - assign a gpio's raw value
 * @desc: gpio whose value will be assigned
3987 3988
 * @value: value to assign
 *
3989 3990 3991
 * Set the raw value of the GPIO, i.e. the value of its physical line without
 * regard for its ACTIVE_LOW status.
 *
3992
 * This function can be called from contexts where we cannot sleep, and will
3993
 * complain if the GPIO chip functions potentially sleep.
3994
 */
3995
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
3996
{
3997
	VALIDATE_DESC_VOID(desc);
3998
	/* Should be using gpiod_set_raw_value_cansleep() */
3999
	WARN_ON(desc->gdev->chip->can_sleep);
4000
	gpiod_set_raw_value_commit(desc, value);
4001
}
4002
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
4003

4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024
/**
 * gpiod_set_value_nocheck() - set a GPIO line value without checking
 * @desc: the descriptor to set the value on
 * @value: value to set
 *
 * This sets the value of a GPIO line backing a descriptor, applying
 * different semantic quirks like active low and open drain/source
 * handling.
 */
static void gpiod_set_value_nocheck(struct gpio_desc *desc, int value)
{
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;
	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);
}

4025
/**
4026 4027 4028 4029
 * gpiod_set_value() - assign a gpio's value
 * @desc: gpio whose value will be assigned
 * @value: value to assign
 *
4030 4031
 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
 * OPEN_DRAIN and OPEN_SOURCE flags into account.
4032
 *
4033
 * This function can be called from contexts where we cannot sleep, and will
4034
 * complain if the GPIO chip functions potentially sleep.
4035
 */
4036
void gpiod_set_value(struct gpio_desc *desc, int value)
4037
{
4038
	VALIDATE_DESC_VOID(desc);
4039
	/* Should be using gpiod_set_value_cansleep() */
4040
	WARN_ON(desc->gdev->chip->can_sleep);
4041
	gpiod_set_value_nocheck(desc, value);
4042
}
4043
EXPORT_SYMBOL_GPL(gpiod_set_value);
4044

4045
/**
4046
 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
4047
 * @array_size: number of elements in the descriptor array / value bitmap
4048
 * @desc_array: array of GPIO descriptors whose values will be assigned
4049
 * @array_info: information on applicability of fast bitmap processing path
4050
 * @value_bitmap: bitmap of values to assign
4051 4052 4053 4054
 *
 * Set the raw values of the GPIOs, i.e. the values of the physical lines
 * without regard for their ACTIVE_LOW status.
 *
4055
 * This function can be called from contexts where we cannot sleep, and will
4056 4057
 * complain if the GPIO chip functions potentially sleep.
 */
L
Laura Abbott 已提交
4058
int gpiod_set_raw_array_value(unsigned int array_size,
4059 4060 4061
			      struct gpio_desc **desc_array,
			      struct gpio_array *array_info,
			      unsigned long *value_bitmap)
4062 4063
{
	if (!desc_array)
L
Laura Abbott 已提交
4064 4065
		return -EINVAL;
	return gpiod_set_array_value_complex(true, false, array_size,
4066
					desc_array, array_info, value_bitmap);
4067
}
4068
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
4069 4070

/**
4071
 * gpiod_set_array_value() - assign values to an array of GPIOs
4072
 * @array_size: number of elements in the descriptor array / value bitmap
4073
 * @desc_array: array of GPIO descriptors whose values will be assigned
4074
 * @array_info: information on applicability of fast bitmap processing path
4075
 * @value_bitmap: bitmap of values to assign
4076 4077 4078 4079
 *
 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
 * into account.
 *
4080
 * This function can be called from contexts where we cannot sleep, and will
4081 4082
 * complain if the GPIO chip functions potentially sleep.
 */
4083 4084 4085 4086
int gpiod_set_array_value(unsigned int array_size,
			  struct gpio_desc **desc_array,
			  struct gpio_array *array_info,
			  unsigned long *value_bitmap)
4087 4088
{
	if (!desc_array)
4089 4090 4091 4092
		return -EINVAL;
	return gpiod_set_array_value_complex(false, false, array_size,
					     desc_array, array_info,
					     value_bitmap);
4093
}
4094
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
4095

4096
/**
4097 4098
 * gpiod_cansleep() - report whether gpio value access may sleep
 * @desc: gpio to check
4099 4100
 *
 */
4101
int gpiod_cansleep(const struct gpio_desc *desc)
4102
{
4103 4104
	VALIDATE_DESC(desc);
	return desc->gdev->chip->can_sleep;
4105
}
4106
EXPORT_SYMBOL_GPL(gpiod_cansleep);
4107

4108 4109 4110 4111 4112
/**
 * gpiod_set_consumer_name() - set the consumer name for the descriptor
 * @desc: gpio to set the consumer name on
 * @name: the new consumer name
 */
4113
int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name)
4114
{
4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125
	VALIDATE_DESC(desc);
	if (name) {
		name = kstrdup_const(name, GFP_KERNEL);
		if (!name)
			return -ENOMEM;
	}

	kfree_const(desc->label);
	desc_set_label(desc, name);

	return 0;
4126 4127 4128
}
EXPORT_SYMBOL_GPL(gpiod_set_consumer_name);

D
David Brownell 已提交
4129
/**
4130 4131
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
D
David Brownell 已提交
4132
 *
4133 4134
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
D
David Brownell 已提交
4135
 */
4136
int gpiod_to_irq(const struct gpio_desc *desc)
D
David Brownell 已提交
4137
{
4138
	struct gpio_chip *gc;
4139
	int offset;
D
David Brownell 已提交
4140

4141 4142 4143 4144 4145
	/*
	 * 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.
	 */
4146
	if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
4147 4148
		return -EINVAL;

4149
	gc = desc->gdev->chip;
4150
	offset = gpio_chip_hwgpio(desc);
4151 4152
	if (gc->to_irq) {
		int retirq = gc->to_irq(gc, offset);
4153 4154 4155 4156 4157 4158 4159 4160

		/* Zero means NO_IRQ */
		if (!retirq)
			return -ENXIO;

		return retirq;
	}
	return -ENXIO;
D
David Brownell 已提交
4161
}
4162
EXPORT_SYMBOL_GPL(gpiod_to_irq);
D
David Brownell 已提交
4163

4164
/**
4165
 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
4166
 * @gc: the chip the GPIO to lock belongs to
4167
 * @offset: the offset of the GPIO to lock as IRQ
4168 4169
 *
 * This is used directly by GPIO drivers that want to lock down
4170
 * a certain GPIO line to be used for IRQs.
4171
 */
4172
int gpiochip_lock_as_irq(struct gpio_chip *gc, unsigned int offset)
4173
{
4174 4175
	struct gpio_desc *desc;

4176
	desc = gpiochip_get_desc(gc, offset);
4177 4178 4179
	if (IS_ERR(desc))
		return PTR_ERR(desc);

4180 4181 4182 4183
	/*
	 * If it's fast: flush the direction setting if something changed
	 * behind our back
	 */
4184
	if (!gc->can_sleep && gc->get_direction) {
4185
		int dir = gpiod_get_direction(desc);
4186

4187
		if (dir < 0) {
4188
			chip_err(gc, "%s: cannot get GPIO direction\n",
4189 4190 4191
				 __func__);
			return dir;
		}
4192
	}
4193

4194
	if (test_bit(FLAG_IS_OUT, &desc->flags)) {
4195
		chip_err(gc,
4196 4197
			 "%s: tried to flag a GPIO set as output for IRQ\n",
			 __func__);
4198 4199 4200
		return -EIO;
	}

4201
	set_bit(FLAG_USED_AS_IRQ, &desc->flags);
4202
	set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
4203 4204 4205 4206 4207 4208 4209 4210 4211

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

4212
	return 0;
4213
}
4214
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
4215

4216
/**
4217
 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
4218
 * @gc: the chip the GPIO to lock belongs to
4219
 * @offset: the offset of the GPIO to lock as IRQ
4220 4221 4222
 *
 * This is used directly by GPIO drivers that want to indicate
 * that a certain GPIO is no longer used exclusively for IRQ.
4223
 */
4224
void gpiochip_unlock_as_irq(struct gpio_chip *gc, unsigned int offset)
4225
{
4226 4227
	struct gpio_desc *desc;

4228
	desc = gpiochip_get_desc(gc, offset);
4229
	if (IS_ERR(desc))
4230
		return;
4231

4232
	clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
4233
	clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
4234 4235 4236 4237

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

4241
void gpiochip_disable_irq(struct gpio_chip *gc, unsigned int offset)
4242
{
4243
	struct gpio_desc *desc = gpiochip_get_desc(gc, offset);
4244 4245 4246 4247 4248 4249 4250

	if (!IS_ERR(desc) &&
	    !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags)))
		clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
}
EXPORT_SYMBOL_GPL(gpiochip_disable_irq);

4251
void gpiochip_enable_irq(struct gpio_chip *gc, unsigned int offset)
4252
{
4253
	struct gpio_desc *desc = gpiochip_get_desc(gc, offset);
4254 4255 4256 4257 4258 4259 4260 4261 4262

	if (!IS_ERR(desc) &&
	    !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) {
		WARN_ON(test_bit(FLAG_IS_OUT, &desc->flags));
		set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
	}
}
EXPORT_SYMBOL_GPL(gpiochip_enable_irq);

4263
bool gpiochip_line_is_irq(struct gpio_chip *gc, unsigned int offset)
4264
{
4265
	if (offset >= gc->ngpio)
4266 4267
		return false;

4268
	return test_bit(FLAG_USED_AS_IRQ, &gc->gpiodev->descs[offset].flags);
4269 4270 4271
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);

4272
int gpiochip_reqres_irq(struct gpio_chip *gc, unsigned int offset)
4273 4274 4275
{
	int ret;

4276
	if (!try_module_get(gc->gpiodev->owner))
4277 4278
		return -ENODEV;

4279
	ret = gpiochip_lock_as_irq(gc, offset);
4280
	if (ret) {
4281 4282
		chip_err(gc, "unable to lock HW IRQ %u for IRQ\n", offset);
		module_put(gc->gpiodev->owner);
4283 4284 4285 4286 4287 4288
		return ret;
	}
	return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_reqres_irq);

4289
void gpiochip_relres_irq(struct gpio_chip *gc, unsigned int offset)
4290
{
4291 4292
	gpiochip_unlock_as_irq(gc, offset);
	module_put(gc->gpiodev->owner);
4293 4294 4295
}
EXPORT_SYMBOL_GPL(gpiochip_relres_irq);

4296
bool gpiochip_line_is_open_drain(struct gpio_chip *gc, unsigned int offset)
4297
{
4298
	if (offset >= gc->ngpio)
4299 4300
		return false;

4301
	return test_bit(FLAG_OPEN_DRAIN, &gc->gpiodev->descs[offset].flags);
4302 4303 4304
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);

4305
bool gpiochip_line_is_open_source(struct gpio_chip *gc, unsigned int offset)
4306
{
4307
	if (offset >= gc->ngpio)
4308 4309
		return false;

4310
	return test_bit(FLAG_OPEN_SOURCE, &gc->gpiodev->descs[offset].flags);
4311 4312 4313
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);

4314
bool gpiochip_line_is_persistent(struct gpio_chip *gc, unsigned int offset)
4315
{
4316
	if (offset >= gc->ngpio)
4317 4318
		return false;

4319
	return !test_bit(FLAG_TRANSITORY, &gc->gpiodev->descs[offset].flags);
4320 4321 4322
}
EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);

4323 4324 4325 4326 4327
/**
 * 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
4328
 * its ACTIVE_LOW status, or negative errno on failure.
4329 4330
 *
 * This function is to be called from contexts that can sleep.
4331
 */
4332
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
4333 4334
{
	might_sleep_if(extra_checks);
4335
	VALIDATE_DESC(desc);
4336
	return gpiod_get_raw_value_commit(desc);
4337
}
4338
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
4339

4340 4341 4342 4343 4344
/**
 * 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
4345
 * account, or negative errno on failure.
4346 4347 4348 4349
 *
 * This function is to be called from contexts that can sleep.
 */
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
4350
{
4351
	int value;
4352 4353

	might_sleep_if(extra_checks);
4354
	VALIDATE_DESC(desc);
4355
	value = gpiod_get_raw_value_commit(desc);
4356 4357 4358
	if (value < 0)
		return value;

4359 4360 4361
	if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
		value = !value;

4362
	return value;
4363
}
4364
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
4365

4366 4367
/**
 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
4368
 * @array_size: number of elements in the descriptor array / value bitmap
4369
 * @desc_array: array of GPIO descriptors whose values will be read
4370
 * @array_info: information on applicability of fast bitmap processing path
4371
 * @value_bitmap: bitmap to store the read values
4372 4373 4374 4375 4376 4377 4378 4379 4380
 *
 * 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,
4381
				       struct gpio_array *array_info,
4382
				       unsigned long *value_bitmap)
4383 4384 4385 4386 4387
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(true, true, array_size,
4388 4389
					     desc_array, array_info,
					     value_bitmap);
4390 4391 4392 4393 4394
}
EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);

/**
 * gpiod_get_array_value_cansleep() - read values from an array of GPIOs
4395
 * @array_size: number of elements in the descriptor array / value bitmap
4396
 * @desc_array: array of GPIO descriptors whose values will be read
4397
 * @array_info: information on applicability of fast bitmap processing path
4398
 * @value_bitmap: bitmap to store the read values
4399 4400 4401 4402 4403 4404 4405 4406
 *
 * 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,
4407
				   struct gpio_array *array_info,
4408
				   unsigned long *value_bitmap)
4409 4410 4411 4412 4413
{
	might_sleep_if(extra_checks);
	if (!desc_array)
		return -EINVAL;
	return gpiod_get_array_value_complex(false, true, array_size,
4414 4415
					     desc_array, array_info,
					     value_bitmap);
4416 4417 4418
}
EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep);

4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429
/**
 * 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)
4430
{
4431
	might_sleep_if(extra_checks);
4432
	VALIDATE_DESC_VOID(desc);
4433
	gpiod_set_raw_value_commit(desc, value);
4434
}
4435
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
4436

4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
/**
 * 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)
4448 4449
{
	might_sleep_if(extra_checks);
4450
	VALIDATE_DESC_VOID(desc);
4451
	gpiod_set_value_nocheck(desc, value);
4452
}
4453
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
4454

4455
/**
4456
 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
4457
 * @array_size: number of elements in the descriptor array / value bitmap
4458
 * @desc_array: array of GPIO descriptors whose values will be assigned
4459
 * @array_info: information on applicability of fast bitmap processing path
4460
 * @value_bitmap: bitmap of values to assign
4461 4462 4463 4464 4465 4466
 *
 * 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.
 */
L
Laura Abbott 已提交
4467
int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
4468 4469 4470
				       struct gpio_desc **desc_array,
				       struct gpio_array *array_info,
				       unsigned long *value_bitmap)
4471 4472 4473
{
	might_sleep_if(extra_checks);
	if (!desc_array)
L
Laura Abbott 已提交
4474 4475
		return -EINVAL;
	return gpiod_set_array_value_complex(true, true, array_size, desc_array,
4476
				      array_info, value_bitmap);
4477
}
4478
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
4479

4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496
/**
 * 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);
}

4497
/**
4498
 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
4499
 * @array_size: number of elements in the descriptor array / value bitmap
4500
 * @desc_array: array of GPIO descriptors whose values will be assigned
4501
 * @array_info: information on applicability of fast bitmap processing path
4502
 * @value_bitmap: bitmap of values to assign
4503 4504 4505 4506 4507 4508
 *
 * 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.
 */
4509 4510 4511 4512
int gpiod_set_array_value_cansleep(unsigned int array_size,
				   struct gpio_desc **desc_array,
				   struct gpio_array *array_info,
				   unsigned long *value_bitmap)
4513 4514 4515
{
	might_sleep_if(extra_checks);
	if (!desc_array)
4516 4517 4518 4519
		return -EINVAL;
	return gpiod_set_array_value_complex(false, true, array_size,
					     desc_array, array_info,
					     value_bitmap);
4520
}
4521
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
4522

4523
/**
4524 4525
 * gpiod_add_lookup_table() - register GPIO device consumers
 * @table: table of consumers to register
4526
 */
4527
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
4528 4529 4530
{
	mutex_lock(&gpio_lookup_lock);

4531
	list_add_tail(&table->list, &gpio_lookup_list);
4532 4533 4534

	mutex_unlock(&gpio_lookup_lock);
}
4535
EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
4536

4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548
/**
 * 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);
}
4549
EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
4550

4551 4552 4553 4554 4555 4556
/**
 * gpiod_add_hogs() - register a set of GPIO hogs from machine code
 * @hogs: table of gpio hog entries with a zeroed sentinel at the end
 */
void gpiod_add_hogs(struct gpiod_hog *hogs)
{
4557
	struct gpio_chip *gc;
4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568
	struct gpiod_hog *hog;

	mutex_lock(&gpio_machine_hogs_mutex);

	for (hog = &hogs[0]; hog->chip_label; hog++) {
		list_add_tail(&hog->list, &gpio_machine_hogs);

		/*
		 * The chip may have been registered earlier, so check if it
		 * exists and, if so, try to hog the line now.
		 */
4569 4570 4571
		gc = find_chip_by_name(hog->chip_label);
		if (gc)
			gpiochip_machine_hog(gc, hog);
4572 4573 4574 4575 4576 4577
	}

	mutex_unlock(&gpio_machine_hogs_mutex);
}
EXPORT_SYMBOL_GPL(gpiod_add_hogs);

4578
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
4579 4580
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
4581
	struct gpiod_lookup_table *table;
4582 4583 4584

	mutex_lock(&gpio_lookup_lock);

4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602
	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;
4603

4604 4605 4606 4607
found:
	mutex_unlock(&gpio_lookup_lock);
	return table;
}
4608

4609
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
4610
				    unsigned int idx, unsigned long *flags)
4611
{
4612
	struct gpio_desc *desc = ERR_PTR(-ENOENT);
4613 4614
	struct gpiod_lookup_table *table;
	struct gpiod_lookup *p;
4615

4616 4617 4618
	table = gpiod_find_lookup_table(dev);
	if (!table)
		return desc;
4619

4620
	for (p = &table->table[0]; p->chip_label; p++) {
4621
		struct gpio_chip *gc;
4622

4623
		/* idx must always match exactly */
4624 4625 4626
		if (p->idx != idx)
			continue;

4627 4628 4629
		/* If the lookup entry has a con_id, require exact match */
		if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
			continue;
4630

4631
		gc = find_chip_by_name(p->chip_label);
4632

4633
		if (!gc) {
4634 4635 4636 4637 4638 4639 4640 4641 4642 4643
			/*
			 * As the lookup table indicates a chip with
			 * p->chip_label should exist, assume it may
			 * still appear later and let the interested
			 * consumer be probed again or let the Deferred
			 * Probe infrastructure handle the error.
			 */
			dev_warn(dev, "cannot find GPIO chip %s, deferring\n",
				 p->chip_label);
			return ERR_PTR(-EPROBE_DEFER);
4644
		}
4645

4646
		if (gc->ngpio <= p->chip_hwnum) {
4647
			dev_err(dev,
4648
				"requested GPIO %u (%u) is out of range [0..%u] for chip %s\n",
4649 4650
				idx, p->chip_hwnum, gc->ngpio - 1,
				gc->label);
4651
			return ERR_PTR(-EINVAL);
4652 4653
		}

4654
		desc = gpiochip_get_desc(gc, p->chip_hwnum);
4655
		*flags = p->flags;
4656

4657
		return desc;
4658 4659 4660 4661 4662
	}

	return desc;
}

4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683
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;
}

4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731
/**
 * fwnode_gpiod_get_index - obtain a GPIO from firmware node
 * @fwnode:	handle of the firmware node
 * @con_id:	function within the GPIO consumer
 * @index:	index of the GPIO to obtain for the consumer
 * @flags:	GPIO initialization flags
 * @label:	label to attach to the requested GPIO
 *
 * This function can be used for drivers that get their configuration
 * from opaque firmware.
 *
 * The 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.
 *
 * Returns:
 * On successful request the GPIO pin is configured in accordance with
 * provided @flags.
 *
 * In case of error an ERR_PTR() is returned.
 */
struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
					 const char *con_id, int index,
					 enum gpiod_flags flags,
					 const char *label)
{
	struct gpio_desc *desc;
	char prop_name[32]; /* 32 is max size of property name */
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
		if (con_id)
			snprintf(prop_name, sizeof(prop_name), "%s-%s",
					    con_id, gpio_suffixes[i]);
		else
			snprintf(prop_name, sizeof(prop_name), "%s",
					    gpio_suffixes[i]);

		desc = fwnode_get_named_gpiod(fwnode, prop_name, index, flags,
					      label);
		if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT))
			break;
	}

	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_gpiod_get_index);

4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742
/**
 * 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)
L
Linus Walleij 已提交
4743
		count = of_gpio_get_count(dev, con_id);
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753
	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);

4754
/**
4755
 * gpiod_get - obtain a GPIO for a given GPIO function
4756
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
4757
 * @con_id:	function within the GPIO consumer
4758
 * @flags:	optional GPIO initialization flags
4759 4760
 *
 * Return the GPIO descriptor corresponding to the function con_id of device
4761
 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
4762
 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
4763
 */
4764
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
4765
					 enum gpiod_flags flags)
4766
{
4767
	return gpiod_get_index(dev, con_id, 0, flags);
4768
}
4769
EXPORT_SYMBOL_GPL(gpiod_get);
4770

4771 4772 4773 4774
/**
 * 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
4775
 * @flags: optional GPIO initialization flags
4776 4777 4778 4779 4780
 *
 * 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.
 */
4781
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
4782 4783
						  const char *con_id,
						  enum gpiod_flags flags)
4784
{
4785
	return gpiod_get_index_optional(dev, con_id, 0, flags);
4786
}
4787
EXPORT_SYMBOL_GPL(gpiod_get_optional);
4788

B
Benoit Parrot 已提交
4789 4790 4791 4792 4793

/**
 * gpiod_configure_flags - helper function to configure a given GPIO
 * @desc:	gpio whose value will be assigned
 * @con_id:	function within the GPIO consumer
4794 4795
 * @lflags:	bitmask of gpio_lookup_flags GPIO_* values - returned from
 *		of_find_gpio() or of_get_gpio_hog()
B
Benoit Parrot 已提交
4796 4797 4798 4799 4800 4801
 * @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.
 */
4802
int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
4803
		unsigned long lflags, enum gpiod_flags dflags)
B
Benoit Parrot 已提交
4804
{
4805
	int ret;
B
Benoit Parrot 已提交
4806

4807 4808
	if (lflags & GPIO_ACTIVE_LOW)
		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
4809

4810 4811
	if (lflags & GPIO_OPEN_DRAIN)
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823
	else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) {
		/*
		 * This enforces open drain mode from the consumer side.
		 * This is necessary for some busses like I2C, but the lookup
		 * should *REALLY* have specified them as open drain in the
		 * first place, so print a little warning here.
		 */
		set_bit(FLAG_OPEN_DRAIN, &desc->flags);
		gpiod_warn(desc,
			   "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n");
	}

4824 4825
	if (lflags & GPIO_OPEN_SOURCE)
		set_bit(FLAG_OPEN_SOURCE, &desc->flags);
4826

4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837
	if ((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DOWN)) {
		gpiod_err(desc,
			  "both pull-up and pull-down enabled, invalid configuration\n");
		return -EINVAL;
	}

	if (lflags & GPIO_PULL_UP)
		set_bit(FLAG_PULL_UP, &desc->flags);
	else if (lflags & GPIO_PULL_DOWN)
		set_bit(FLAG_PULL_DOWN, &desc->flags);

4838 4839 4840
	ret = gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY));
	if (ret < 0)
		return ret;
4841

B
Benoit Parrot 已提交
4842 4843
	/* No particular flag request, return here... */
	if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
4844
		gpiod_dbg(desc, "no flags found for %s\n", con_id);
B
Benoit Parrot 已提交
4845 4846 4847 4848 4849
		return 0;
	}

	/* Process flags */
	if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
4850
		ret = gpiod_direction_output(desc,
4851
				!!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
B
Benoit Parrot 已提交
4852
	else
4853
		ret = gpiod_direction_input(desc);
B
Benoit Parrot 已提交
4854

4855
	return ret;
B
Benoit Parrot 已提交
4856 4857
}

4858 4859
/**
 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
4860
 * @dev:	GPIO consumer, can be NULL for system-global GPIOs
4861 4862
 * @con_id:	function within the GPIO consumer
 * @idx:	index of the GPIO to obtain in the consumer
4863
 * @flags:	optional GPIO initialization flags
4864 4865 4866 4867
 *
 * This variant of gpiod_get() allows to access GPIOs other than the first
 * defined one for functions that define several GPIOs.
 *
4868 4869
 * 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
4870
 * occurred while trying to acquire the GPIO.
4871
 */
4872
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
4873
					       const char *con_id,
4874 4875
					       unsigned int idx,
					       enum gpiod_flags flags)
4876
{
4877
	unsigned long lookupflags = GPIO_LOOKUP_FLAGS_DEFAULT;
4878
	struct gpio_desc *desc = NULL;
4879
	int ret;
L
Linus Walleij 已提交
4880 4881
	/* Maybe we have a device name, maybe not */
	const char *devname = dev ? dev_name(dev) : "?";
4882 4883 4884

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

4885 4886 4887 4888 4889 4890 4891
	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");
4892
			desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
4893
		}
4894 4895 4896 4897 4898 4899
	}

	/*
	 * 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.
	 */
4900
	if (!desc || desc == ERR_PTR(-ENOENT)) {
4901
		dev_dbg(dev, "using lookup tables for GPIO lookup\n");
4902
		desc = gpiod_find(dev, con_id, idx, &lookupflags);
4903 4904 4905
	}

	if (IS_ERR(desc)) {
4906
		dev_dbg(dev, "No GPIO consumer %s found\n", con_id);
4907 4908 4909
		return desc;
	}

L
Linus Walleij 已提交
4910 4911 4912 4913
	/*
	 * If a connection label was passed use that, else attempt to use
	 * the device name as label
	 */
4914 4915 4916
	ret = gpiod_request(desc, con_id ? con_id : devname);
	if (ret < 0) {
		if (ret == -EBUSY && flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE) {
4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928
			/*
			 * This happens when there are several consumers for
			 * the same GPIO line: we just return here without
			 * further initialization. It is a bit if a hack.
			 * This is necessary to support fixed regulators.
			 *
			 * FIXME: Make this more sane and safe.
			 */
			dev_info(dev, "nonexclusive access to GPIO for %s\n",
				 con_id ? con_id : devname);
			return desc;
		} else {
4929
			return ERR_PTR(ret);
4930 4931
		}
	}
4932

4933
	ret = gpiod_configure_flags(desc, con_id, lookupflags, flags);
4934
	if (ret < 0) {
4935
		dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
4936 4937 4938 4939 4940 4941
		gpiod_put(desc);
		return ERR_PTR(ret);
	}

	return desc;
}
4942
EXPORT_SYMBOL_GPL(gpiod_get_index);
4943

4944 4945 4946 4947
/**
 * 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
4948
 * @index:	index of the GPIO to obtain for the consumer
4949
 * @dflags:	GPIO initialization flags
T
Thierry Reding 已提交
4950
 * @label:	label to attach to the requested GPIO
4951 4952
 *
 * This function can be used for drivers that get their configuration
4953
 * from opaque firmware.
4954
 *
4955
 * The function properly finds the corresponding GPIO using whatever is the
4956 4957 4958
 * underlying firmware interface and then makes sure that the GPIO
 * descriptor is requested before it is returned to the caller.
 *
T
Thierry Reding 已提交
4959
 * Returns:
4960
 * On successful request the GPIO pin is configured in accordance with
4961 4962
 * provided @dflags.
 *
4963 4964 4965
 * In case of error an ERR_PTR() is returned.
 */
struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
4966
					 const char *propname, int index,
4967 4968
					 enum gpiod_flags dflags,
					 const char *label)
4969
{
4970
	unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
4971 4972 4973 4974 4975 4976 4977
	struct gpio_desc *desc = ERR_PTR(-ENODEV);
	int ret;

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

	if (is_of_node(fwnode)) {
4978 4979 4980 4981 4982
		desc = gpiod_get_from_of_node(to_of_node(fwnode),
					      propname, index,
					      dflags,
					      label);
		return desc;
4983 4984 4985
	} else if (is_acpi_node(fwnode)) {
		struct acpi_gpio_info info;

4986
		desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
4987 4988
		if (IS_ERR(desc))
			return desc;
4989

4990
		acpi_gpio_update_gpiod_flags(&dflags, &info);
4991
		acpi_gpio_update_gpiod_lookup_flags(&lflags, &info);
4992
	}
4993

4994
	/* Currently only ACPI takes this path */
4995
	ret = gpiod_request(desc, label);
4996 4997 4998
	if (ret)
		return ERR_PTR(ret);

4999 5000 5001 5002
	ret = gpiod_configure_flags(desc, propname, lflags, dflags);
	if (ret < 0) {
		gpiod_put(desc);
		return ERR_PTR(ret);
5003 5004
	}

5005 5006 5007 5008
	return desc;
}
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);

5009 5010 5011 5012 5013 5014
/**
 * 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
5015
 * @flags: optional GPIO initialization flags
5016 5017 5018 5019 5020
 *
 * 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.
 */
5021
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
5022
							const char *con_id,
5023 5024
							unsigned int index,
							enum gpiod_flags flags)
5025 5026 5027
{
	struct gpio_desc *desc;

5028
	desc = gpiod_get_index(dev, con_id, index, flags);
5029 5030 5031 5032 5033 5034 5035
	if (IS_ERR(desc)) {
		if (PTR_ERR(desc) == -ENOENT)
			return NULL;
	}

	return desc;
}
5036
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
5037

B
Benoit Parrot 已提交
5038 5039 5040 5041
/**
 * gpiod_hog - Hog the specified GPIO desc given the provided flags
 * @desc:	gpio whose value will be assigned
 * @name:	gpio line name
5042 5043
 * @lflags:	bitmask of gpio_lookup_flags GPIO_* values - returned from
 *		of_find_gpio() or of_get_gpio_hog()
B
Benoit Parrot 已提交
5044 5045 5046 5047 5048
 * @dflags:	gpiod_flags - optional GPIO initialization flags
 */
int gpiod_hog(struct gpio_desc *desc, const char *name,
	      unsigned long lflags, enum gpiod_flags dflags)
{
5049
	struct gpio_chip *gc;
B
Benoit Parrot 已提交
5050 5051
	struct gpio_desc *local_desc;
	int hwnum;
5052
	int ret;
B
Benoit Parrot 已提交
5053

5054
	gc = gpiod_to_chip(desc);
B
Benoit Parrot 已提交
5055 5056
	hwnum = gpio_chip_hwgpio(desc);

5057
	local_desc = gpiochip_request_own_desc(gc, hwnum, name,
5058
					       lflags, dflags);
B
Benoit Parrot 已提交
5059
	if (IS_ERR(local_desc)) {
5060
		ret = PTR_ERR(local_desc);
5061
		pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
5062
		       name, gc->label, hwnum, ret);
5063
		return ret;
B
Benoit Parrot 已提交
5064 5065 5066 5067 5068
	}

	/* Mark GPIO as hogged so it can be identified and removed later */
	set_bit(FLAG_IS_HOGGED, &desc->flags);

5069
	gpiod_info(desc, "hogged as %s%s\n",
5070 5071 5072
		(dflags & GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
		(dflags & GPIOD_FLAGS_BIT_DIR_OUT) ?
		  (dflags & GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low" : "");
B
Benoit Parrot 已提交
5073 5074 5075 5076 5077 5078

	return 0;
}

/**
 * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog
5079
 * @gc:	gpio chip to act on
B
Benoit Parrot 已提交
5080
 */
5081
static void gpiochip_free_hogs(struct gpio_chip *gc)
B
Benoit Parrot 已提交
5082 5083 5084
{
	int id;

5085 5086 5087
	for (id = 0; id < gc->ngpio; id++) {
		if (test_bit(FLAG_IS_HOGGED, &gc->gpiodev->descs[id].flags))
			gpiochip_free_own_desc(&gc->gpiodev->descs[id]);
B
Benoit Parrot 已提交
5088 5089 5090
	}
}

5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108
/**
 * 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;
5109
	struct gpio_array *array_info = NULL;
5110
	struct gpio_chip *gc;
5111
	int count, bitmap_size;
5112 5113 5114 5115 5116

	count = gpiod_count(dev, con_id);
	if (count < 0)
		return ERR_PTR(count);

5117
	descs = kzalloc(struct_size(descs, desc, count), GFP_KERNEL);
5118 5119 5120 5121 5122 5123 5124 5125 5126
	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);
		}
5127

5128
		descs->desc[descs->ndescs] = desc;
5129

5130
		gc = gpiod_to_chip(desc);
5131
		/*
5132 5133
		 * If pin hardware number of array member 0 is also 0, select
		 * its chip as a candidate for fast bitmap processing path.
5134
		 */
5135
		if (descs->ndescs == 0 && gpio_chip_hwgpio(desc) == 0) {
5136 5137
			struct gpio_descs *array;

5138 5139
			bitmap_size = BITS_TO_LONGS(gc->ngpio > count ?
						    gc->ngpio : count);
5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161

			array = kzalloc(struct_size(descs, desc, count) +
					struct_size(array_info, invert_mask,
					3 * bitmap_size), GFP_KERNEL);
			if (!array) {
				gpiod_put_array(descs);
				return ERR_PTR(-ENOMEM);
			}

			memcpy(array, descs,
			       struct_size(descs, desc, descs->ndescs + 1));
			kfree(descs);

			descs = array;
			array_info = (void *)(descs->desc + count);
			array_info->get_mask = array_info->invert_mask +
						  bitmap_size;
			array_info->set_mask = array_info->get_mask +
						  bitmap_size;

			array_info->desc = descs->desc;
			array_info->size = count;
5162
			array_info->chip = gc;
5163 5164 5165 5166 5167 5168
			bitmap_set(array_info->get_mask, descs->ndescs,
				   count - descs->ndescs);
			bitmap_set(array_info->set_mask, descs->ndescs,
				   count - descs->ndescs);
			descs->info = array_info;
		}
5169
		/* Unmark array members which don't belong to the 'fast' chip */
5170
		if (array_info && array_info->chip != gc) {
5171 5172
			__clear_bit(descs->ndescs, array_info->get_mask);
			__clear_bit(descs->ndescs, array_info->set_mask);
5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192
		}
		/*
		 * Detect array members which belong to the 'fast' chip
		 * but their pins are not in hardware order.
		 */
		else if (array_info &&
			   gpio_chip_hwgpio(desc) != descs->ndescs) {
			/*
			 * Don't use fast path if all array members processed so
			 * far belong to the same chip as this one but its pin
			 * hardware number is different from its array index.
			 */
			if (bitmap_full(array_info->get_mask, descs->ndescs)) {
				array_info = NULL;
			} else {
				__clear_bit(descs->ndescs,
					    array_info->get_mask);
				__clear_bit(descs->ndescs,
					    array_info->set_mask);
			}
5193 5194
		} else if (array_info) {
			/* Exclude open drain or open source from fast output */
5195 5196
			if (gpiochip_line_is_open_drain(gc, descs->ndescs) ||
			    gpiochip_line_is_open_source(gc, descs->ndescs))
5197 5198 5199 5200 5201 5202 5203 5204
				__clear_bit(descs->ndescs,
					    array_info->set_mask);
			/* Identify 'fast' pins which require invertion */
			if (gpiod_is_active_low(desc))
				__set_bit(descs->ndescs,
					  array_info->invert_mask);
		}

5205 5206
		descs->ndescs++;
	}
5207 5208 5209 5210 5211 5212
	if (array_info)
		dev_dbg(dev,
			"GPIO array info: chip=%s, size=%d, get_mask=%lx, set_mask=%lx, invert_mask=%lx\n",
			array_info->chip->label, array_info->size,
			*array_info->get_mask, *array_info->set_mask,
			*array_info->invert_mask);
5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233
	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);
5234
	if (PTR_ERR(descs) == -ENOENT)
5235 5236 5237 5238 5239 5240
		return NULL;

	return descs;
}
EXPORT_SYMBOL_GPL(gpiod_get_array_optional);

5241 5242 5243 5244 5245 5246 5247 5248
/**
 * 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)
{
5249 5250
	if (desc)
		gpiod_free(desc);
5251
}
5252
EXPORT_SYMBOL_GPL(gpiod_put);
5253

5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268
/**
 * 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);

5269 5270 5271 5272 5273
static int __init gpiolib_dev_init(void)
{
	int ret;

	/* Register GPIO sysfs bus */
5274
	ret = bus_register(&gpio_bus_type);
5275 5276 5277 5278 5279
	if (ret < 0) {
		pr_err("gpiolib: could not register GPIO bus type\n");
		return ret;
	}

5280
	ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, GPIOCHIP_NAME);
5281 5282 5283
	if (ret < 0) {
		pr_err("gpiolib: failed to allocate char dev region\n");
		bus_unregister(&gpio_bus_type);
5284
		return ret;
5285
	}
5286 5287 5288 5289 5290 5291 5292

	gpiolib_initialized = true;
	gpiochip_setup_devs();

	if (IS_ENABLED(CONFIG_OF_DYNAMIC))
		WARN_ON(of_reconfig_notifier_register(&gpio_of_notifier));

5293 5294 5295 5296
	return ret;
}
core_initcall(gpiolib_dev_init);

5297 5298
#ifdef CONFIG_DEBUG_FS

5299
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
5300 5301
{
	unsigned		i;
5302
	struct gpio_chip	*gc = gdev->chip;
5303 5304
	unsigned		gpio = gdev->base;
	struct gpio_desc	*gdesc = &gdev->descs[0];
5305 5306 5307
	bool			is_out;
	bool			is_irq;
	bool			active_low;
5308

5309
	for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
5310 5311 5312 5313 5314
		if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
			if (gdesc->name) {
				seq_printf(s, " gpio-%-3d (%-20.20s)\n",
					   gpio, gdesc->name);
			}
5315
			continue;
5316
		}
5317

5318
		gpiod_get_direction(gdesc);
5319
		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
5320
		is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
5321 5322
		active_low = test_bit(FLAG_ACTIVE_LOW, &gdesc->flags);
		seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s%s",
5323
			gpio, gdesc->name ? gdesc->name : "", gdesc->label,
5324
			is_out ? "out" : "in ",
5325
			gc->get ? (gc->get(gc, i) ? "hi" : "lo") : "?  ",
5326 5327
			is_irq ? "IRQ " : "",
			active_low ? "ACTIVE LOW" : "");
5328 5329 5330 5331
		seq_printf(s, "\n");
	}
}

5332
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
5333
{
5334
	unsigned long flags;
5335
	struct gpio_device *gdev = NULL;
5336
	loff_t index = *pos;
5337

5338
	s->private = "";
5339

5340
	spin_lock_irqsave(&gpio_lock, flags);
5341
	list_for_each_entry(gdev, &gpio_devices, list)
5342 5343
		if (index-- == 0) {
			spin_unlock_irqrestore(&gpio_lock, flags);
5344
			return gdev;
5345
		}
5346
	spin_unlock_irqrestore(&gpio_lock, flags);
5347

5348
	return NULL;
5349 5350 5351 5352
}

static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
5353
	unsigned long flags;
5354
	struct gpio_device *gdev = v;
5355 5356
	void *ret = NULL;

5357
	spin_lock_irqsave(&gpio_lock, flags);
5358
	if (list_is_last(&gdev->list, &gpio_devices))
5359 5360
		ret = NULL;
	else
5361
		ret = list_entry(gdev->list.next, struct gpio_device, list);
5362
	spin_unlock_irqrestore(&gpio_lock, flags);
5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375

	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)
{
5376
	struct gpio_device *gdev = v;
5377
	struct gpio_chip *gc = gdev->chip;
5378 5379
	struct device *parent;

5380
	if (!gc) {
5381 5382 5383 5384
		seq_printf(s, "%s%s: (dangling chip)", (char *)s->private,
			   dev_name(&gdev->dev));
		return 0;
	}
5385

5386 5387
	seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
		   dev_name(&gdev->dev),
5388
		   gdev->base, gdev->base + gdev->ngpio - 1);
5389
	parent = gc->parent;
5390 5391 5392 5393
	if (parent)
		seq_printf(s, ", parent: %s/%s",
			   parent->bus ? parent->bus->name : "no-bus",
			   dev_name(parent));
5394 5395 5396
	if (gc->label)
		seq_printf(s, ", %s", gc->label);
	if (gc->can_sleep)
5397 5398 5399
		seq_printf(s, ", can sleep");
	seq_printf(s, ":\n");

5400 5401
	if (gc->dbg_show)
		gc->dbg_show(s, gc);
5402
	else
5403
		gpiolib_dbg_show(s, gdev);
5404

5405 5406 5407
	return 0;
}

5408 5409 5410 5411 5412 5413 5414
static const struct seq_operations gpiolib_seq_ops = {
	.start = gpiolib_seq_start,
	.next = gpiolib_seq_next,
	.stop = gpiolib_seq_stop,
	.show = gpiolib_seq_show,
};

5415 5416
static int gpiolib_open(struct inode *inode, struct file *file)
{
5417
	return seq_open(file, &gpiolib_seq_ops);
5418 5419
}

5420
static const struct file_operations gpiolib_operations = {
5421
	.owner		= THIS_MODULE,
5422 5423 5424
	.open		= gpiolib_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
5425
	.release	= seq_release,
5426 5427 5428 5429 5430
};

static int __init gpiolib_debugfs_init(void)
{
	/* /sys/kernel/debug/gpio */
5431 5432
	debugfs_create_file("gpio", S_IFREG | S_IRUGO, NULL, NULL,
			    &gpiolib_operations);
5433 5434 5435 5436 5437
	return 0;
}
subsys_initcall(gpiolib_debugfs_init);

#endif	/* DEBUG_FS */