gpiolib.c 82.9 KB
Newer Older
1 2
#include <linux/kernel.h>
#include <linux/module.h>
3
#include <linux/interrupt.h>
4 5
#include <linux/irq.h>
#include <linux/spinlock.h>
6
#include <linux/list.h>
David Brownell's avatar
David Brownell committed
7 8 9 10 11
#include <linux/device.h>
#include <linux/err.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/gpio.h>
12
#include <linux/of_gpio.h>
13
#include <linux/idr.h>
14
#include <linux/slab.h>
15
#include <linux/acpi.h>
16
#include <linux/gpio/driver.h>
17
#include <linux/gpio/machine.h>
18
#include <linux/pinctrl/consumer.h>
19
#include <linux/idr.h>
20 21 22
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
23
#include <linux/compat.h>
24
#include <uapi/linux/gpio.h>
25

26 27
#include "gpiolib.h"

28 29
#define CREATE_TRACE_POINTS
#include <trace/events/gpio.h>
30

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


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

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

59 60 61 62
/* 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.
 */
63
DEFINE_SPINLOCK(gpio_lock);
64

65 66
static DEFINE_MUTEX(gpio_lookup_lock);
static LIST_HEAD(gpio_lookup_list);
67
LIST_HEAD(gpio_devices);
68 69 70 71

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

72
static bool gpiolib_initialized;
73

74 75 76 77 78
static inline void desc_set_label(struct gpio_desc *d, const char *label)
{
	d->label = label;
}

79 80 81
/**
 * Convert a GPIO number to its descriptor
 */
82
struct gpio_desc *gpio_to_desc(unsigned gpio)
83
{
84
	struct gpio_device *gdev;
85 86 87 88
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

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

	spin_unlock_irqrestore(&gpio_lock, flags);

99 100 101
	if (!gpio_is_valid(gpio))
		WARN(1, "invalid GPIO %d\n", gpio);

102
	return NULL;
103
}
104
EXPORT_SYMBOL_GPL(gpio_to_desc);
105

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

	if (hwnum >= gdev->ngpio)
115
		return ERR_PTR(-EINVAL);
116

117
	return &gdev->descs[hwnum];
118
}
119 120 121 122 123 124

/**
 * Convert a GPIO descriptor to the integer namespace.
 * This should disappear in the future but is needed since we still
 * use GPIO numbers for error messages and sysfs nodes
 */
125
int desc_to_gpio(const struct gpio_desc *desc)
126
{
127
	return desc->gdev->base + (desc - &desc->gdev->descs[0]);
128
}
129
EXPORT_SYMBOL_GPL(desc_to_gpio);
130 131


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

144 145 146
/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
static int gpiochip_find_base(int ngpio)
{
147
	struct gpio_device *gdev;
148
	int base = ARCH_NR_GPIOS - ngpio;
149

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

159
	if (gpio_is_valid(base)) {
160
		pr_debug("%s: found new base at %d\n", __func__, base);
161 162 163 164
		return base;
	} else {
		pr_err("%s: cannot find free range\n", __func__);
		return -ENOSPC;
Anton Vorontsov's avatar
Anton Vorontsov committed
165 166 167
	}
}

168 169 170 171 172 173 174 175
/**
 * gpiod_get_direction - return the current direction of a GPIO
 * @desc:	GPIO to get the direction of
 *
 * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
 *
 * This function may sleep if gpiod_cansleep() is true.
 */
176
int gpiod_get_direction(struct gpio_desc *desc)
177 178
{
	struct gpio_chip	*chip;
179
	unsigned		offset;
180 181
	int			status = -EINVAL;

182 183
	chip = gpiod_to_chip(desc);
	offset = gpio_chip_hwgpio(desc);
184 185 186 187

	if (!chip->get_direction)
		return status;

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

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

213
	if (list_empty(&gpio_devices)) {
214
		/* initial entry in list */
215
		list_add_tail(&gdev->list, &gpio_devices);
216
		return 0;
217 218
	}

219 220 221 222 223
	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;
224 225
	}

226 227 228 229
	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);
230
		return 0;
231 232
	}

233 234 235 236
	list_for_each_entry_safe(prev, next, &gpio_devices, list) {
		/* at the end of the list */
		if (&next->list == &gpio_devices)
			break;
237

238 239 240 241 242 243 244 245 246 247
		/* 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;
248 249
}

250 251 252 253 254
/**
 * Convert a GPIO name to its descriptor
 */
static struct gpio_desc *gpio_name_to_desc(const char * const name)
{
255
	struct gpio_device *gdev;
256 257 258 259
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);

260
	list_for_each_entry(gdev, &gpio_devices, list) {
261 262
		int i;

263 264
		for (i = 0; i != gdev->ngpio; ++i) {
			struct gpio_desc *desc = &gdev->descs[i];
265

266
			if (!desc->name || !name)
267 268
				continue;

269
			if (!strcmp(desc->name, name)) {
270
				spin_unlock_irqrestore(&gpio_lock, flags);
271
				return desc;
272 273 274 275 276 277 278 279 280
			}
		}
	}

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

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

	/* Then add all names to the GPIO descriptors */
	for (i = 0; i != gc->ngpio; ++i)
308
		gdev->descs[i].name = gc->names[i];
309 310 311 312

	return 0;
}

313 314 315 316 317 318 319
/**
 * gpio_ioctl() - ioctl handler for the GPIO chardev
 */
static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct gpio_device *gdev = filp->private_data;
	struct gpio_chip *chip = gdev->chip;
320
	void __user *ip = (void __user *)arg;
321 322 323 324 325

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

326
	/* Fill in the struct and pass to userspace */
327
	if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
328 329
		struct gpiochip_info chipinfo;

330 331 332
		strncpy(chipinfo.name, dev_name(&gdev->dev),
			sizeof(chipinfo.name));
		chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
333 334 335
		strncpy(chipinfo.label, gdev->label,
			sizeof(chipinfo.label));
		chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
336
		chipinfo.lines = gdev->ngpio;
337 338 339
		if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
			return -EFAULT;
		return 0;
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
	} else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
		struct gpioline_info lineinfo;
		struct gpio_desc *desc;

		if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
			return -EFAULT;
		if (lineinfo.line_offset > gdev->ngpio)
			return -EINVAL;

		desc = &gdev->descs[lineinfo.line_offset];
		if (desc->name) {
			strncpy(lineinfo.name, desc->name,
				sizeof(lineinfo.name));
			lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
		} else {
			lineinfo.name[0] = '\0';
		}
		if (desc->label) {
358 359 360
			strncpy(lineinfo.consumer, desc->label,
				sizeof(lineinfo.consumer));
			lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
361
		} else {
362
			lineinfo.consumer[0] = '\0';
363 364 365 366 367 368 369
		}

		/*
		 * Userspace only need to know that the kernel is using
		 * this GPIO so it can't use it.
		 */
		lineinfo.flags = 0;
370 371 372 373 374
		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))
375
			lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
376
		if (test_bit(FLAG_IS_OUT, &desc->flags))
377
			lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
378
		if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
379
			lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
380
		if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
381
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
382
		if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
383 384 385 386 387
			lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;

		if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
			return -EFAULT;
		return 0;
388 389 390 391
	}
	return -EINVAL;
}

392 393 394 395 396 397 398 399
#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

400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
/**
 * gpio_chrdev_open() - open the chardev for ioctl operations
 * @inode: inode for this chardev
 * @filp: file struct for storing private data
 * Returns 0 on success
 */
static int gpio_chrdev_open(struct inode *inode, struct file *filp)
{
	struct gpio_device *gdev = container_of(inode->i_cdev,
					      struct gpio_device, chrdev);

	/* Fail on open if the backing gpiochip is gone */
	if (!gdev || !gdev->chip)
		return -ENODEV;
	get_device(&gdev->dev);
	filp->private_data = gdev;
	return 0;
}

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

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


static const struct file_operations gpio_fileops = {
	.release = gpio_chrdev_release,
	.open = gpio_chrdev_open,
	.owner = THIS_MODULE,
	.llseek = noop_llseek,
	.unlocked_ioctl = gpio_ioctl,
443 444 445
#ifdef CONFIG_COMPAT
	.compat_ioctl = gpio_ioctl_compat,
#endif
446 447
};

448 449 450 451
static void gpiodevice_release(struct device *dev)
{
	struct gpio_device *gdev = dev_get_drvdata(dev);

452
	cdev_del(&gdev->chrdev);
453 454
	list_del(&gdev->list);
	ida_simple_remove(&gpio_ida, gdev->id);
455 456
	kfree(gdev->label);
	kfree(gdev->descs);
457
	kfree(gdev);
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 499 500 501 502 503 504 505 506 507 508 509 510 511
static int gpiochip_setup_dev(struct gpio_device *gdev)
{
	int status;

	cdev_init(&gdev->chrdev, &gpio_fileops);
	gdev->chrdev.owner = THIS_MODULE;
	gdev->chrdev.kobj.parent = &gdev->dev.kobj;
	gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
	status = cdev_add(&gdev->chrdev, gdev->dev.devt, 1);
	if (status < 0)
		chip_warn(gdev->chip, "failed to add char device %d:%d\n",
			  MAJOR(gpio_devt), gdev->id);
	else
		chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
			 MAJOR(gpio_devt), gdev->id);
	status = device_add(&gdev->dev);
	if (status)
		goto err_remove_chardev;

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

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

	return 0;

err_remove_device:
	device_del(&gdev->dev);
err_remove_chardev:
	cdev_del(&gdev->chrdev);
	return status;
}

static void gpiochip_setup_devs(void)
{
	struct gpio_device *gdev;
	int err;

	list_for_each_entry(gdev, &gpio_devices, list) {
		err = gpiochip_setup_dev(gdev);
		if (err)
			pr_err("%s: Failed to initialize gpio device (%d)\n",
			       dev_name(&gdev->dev), err);
	}
}

512
/**
513
 * gpiochip_add_data() - register a gpio_chip
514
 * @chip: the chip to register, with chip->base initialized
515
 * Context: potentially before irqs will work
516 517 518 519
 *
 * Returns a negative errno if the chip can't be registered, such as
 * because the chip->base is invalid or already associated with a
 * different chip.  Otherwise it returns zero as a success code.
520
 *
521
 * When gpiochip_add_data() is called very early during boot, so that GPIOs
522
 * can be freely used, the chip->parent device must be registered before
David Brownell's avatar
David Brownell committed
523 524 525
 * the gpio framework's arch_initcall().  Otherwise sysfs initialization
 * for GPIOs will fail rudely.
 *
526 527 528
 * gpiochip_add_data() must only be called after gpiolib initialization,
 * ie after core_initcall().
 *
529 530
 * If chip->base is negative, this requests dynamic assignment of
 * a range of valid GPIOs.
531
 */
532
int gpiochip_add_data(struct gpio_chip *chip, void *data)
533 534 535
{
	unsigned long	flags;
	int		status = 0;
536
	unsigned	i;
537
	int		base = chip->base;
538
	struct gpio_device *gdev;
539

540 541 542 543
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
544
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
545
	if (!gdev)
546
		return -ENOMEM;
547
	gdev->dev.bus = &gpio_bus_type;
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
	gdev->chip = chip;
	chip->gpiodev = gdev;
	if (chip->parent) {
		gdev->dev.parent = chip->parent;
		gdev->dev.of_node = chip->parent->of_node;
	} else {
#ifdef CONFIG_OF_GPIO
	/* If the gpiochip has an assigned OF node this takes precedence */
		if (chip->of_node)
			gdev->dev.of_node = chip->of_node;
#endif
	}
	gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
	if (gdev->id < 0) {
		status = gdev->id;
		goto err_free_gdev;
	}
	dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
	device_initialize(&gdev->dev);
	dev_set_drvdata(&gdev->dev, gdev);
	if (chip->parent && chip->parent->driver)
		gdev->owner = chip->parent->driver->owner;
	else if (chip->owner)
		/* TODO: remove chip->owner */
		gdev->owner = chip->owner;
	else
		gdev->owner = THIS_MODULE;
575

576
	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
577
	if (!gdev->descs) {
578 579 580 581
		status = -ENOMEM;
		goto err_free_gdev;
	}

582 583
	if (chip->ngpio == 0) {
		chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
584
		status = -EINVAL;
585
		goto err_free_descs;
586
	}
587 588

	if (chip->label)
589
		gdev->label = kstrdup(chip->label, GFP_KERNEL);
590
	else
591
		gdev->label = kstrdup("unknown", GFP_KERNEL);
592 593
	if (!gdev->label) {
		status = -ENOMEM;
594
		goto err_free_descs;
595 596
	}

597
	gdev->ngpio = chip->ngpio;
598
	gdev->data = data;
599

600 601
	spin_lock_irqsave(&gpio_lock, flags);

602 603 604 605 606 607 608
	/*
	 * 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.
	 */
609 610 611 612
	if (base < 0) {
		base = gpiochip_find_base(chip->ngpio);
		if (base < 0) {
			status = base;
613
			spin_unlock_irqrestore(&gpio_lock, flags);
614
			goto err_free_label;
615
		}
616 617 618 619 620 621
		/*
		 * 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.
		 */
622 623
		chip->base = base;
	}
624
	gdev->base = base;
625

626
	status = gpiodev_add_to_list(gdev);
627 628
	if (status) {
		spin_unlock_irqrestore(&gpio_lock, flags);
629
		goto err_free_label;
630
	}
631

632 633
	spin_unlock_irqrestore(&gpio_lock, flags);

634
	for (i = 0; i < chip->ngpio; i++) {
635
		struct gpio_desc *desc = &gdev->descs[i];
636

637
		desc->gdev = gdev;
638 639 640 641 642 643 644
		/*
		 * REVISIT: most hardware initializes GPIOs as inputs
		 * (often with pullups enabled) so power usage is
		 * minimized. Linux code should set the gpio direction
		 * first thing; but until it does, and in case
		 * chip->get_direction is not set, we may expose the
		 * wrong direction in sysfs.
645
		 */
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662

		if (chip->get_direction) {
			/*
			 * If we have .get_direction, set up the initial
			 * direction flag from the hardware.
			 */
			int dir = chip->get_direction(chip, i);

			if (!dir)
				set_bit(FLAG_IS_OUT, &desc->flags);
		} else if (!chip->direction_input) {
			/*
			 * If the chip lacks the .direction_input callback
			 * we logically assume all lines are outputs.
			 */
			set_bit(FLAG_IS_OUT, &desc->flags);
		}
663
	}
664

665
#ifdef CONFIG_PINCTRL
666
	INIT_LIST_HEAD(&gdev->pin_ranges);
667 668
#endif

669 670 671 672
	status = gpiochip_set_desc_names(chip);
	if (status)
		goto err_remove_from_list;

673 674 675 676
	status = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

677
	acpi_gpiochip_add(chip);
678

679 680 681 682 683
	/*
	 * 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.
684 685
	 * We can do this only if gpiolib has been initialized.
	 * Otherwise, defer until later.
686
	 */
687 688 689 690 691
	if (gpiolib_initialized) {
		status = gpiochip_setup_dev(gdev);
		if (status)
			goto err_remove_chip;
	}
692
	return 0;
693

694 695
err_remove_chip:
	acpi_gpiochip_remove(chip);
696
	gpiochip_free_hogs(chip);
697
	of_gpiochip_remove(chip);
698
err_remove_from_list:
699
	spin_lock_irqsave(&gpio_lock, flags);
700
	list_del(&gdev->list);
701
	spin_unlock_irqrestore(&gpio_lock, flags);
702 703 704 705
err_free_label:
	kfree(gdev->label);
err_free_descs:
	kfree(gdev->descs);
706 707
err_free_gdev:
	ida_simple_remove(&gpio_ida, gdev->id);
708
	/* failures here can mean systems won't boot... */
709
	pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
710 711 712
	       gdev->base, gdev->base + gdev->ngpio - 1,
	       chip->label ? : "generic");
	kfree(gdev);
713 714
	return status;
}
715
EXPORT_SYMBOL_GPL(gpiochip_add_data);
716

717 718 719 720 721 722 723 724 725
/**
 * gpiochip_get_data() - get per-subdriver data for the chip
 */
void *gpiochip_get_data(struct gpio_chip *chip)
{
	return chip->gpiodev->data;
}
EXPORT_SYMBOL_GPL(gpiochip_get_data);

726 727 728 729 730 731
/**
 * gpiochip_remove() - unregister a gpio_chip
 * @chip: the chip to unregister
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
732
void gpiochip_remove(struct gpio_chip *chip)
733
{
734
	struct gpio_device *gdev = chip->gpiodev;
Johan Hovold's avatar
Johan Hovold committed
735
	struct gpio_desc *desc;
736
	unsigned long	flags;
737
	unsigned	i;
Johan Hovold's avatar
Johan Hovold committed
738
	bool		requested = false;
739

740
	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
741
	gpiochip_sysfs_unregister(gdev);
742 743
	/* Numb the device, cancelling all outstanding operations */
	gdev->chip = NULL;
744
	gpiochip_irqchip_remove(chip);
745
	acpi_gpiochip_remove(chip);
746
	gpiochip_remove_pin_ranges(chip);
747
	gpiochip_free_hogs(chip);
748
	of_gpiochip_remove(chip);
749 750 751 752 753
	/*
	 * We accept no more calls into the driver from this point, so
	 * NULL the driver data pointer
	 */
	gdev->data = NULL;
754

755
	spin_lock_irqsave(&gpio_lock, flags);
756
	for (i = 0; i < gdev->ngpio; i++) {
757
		desc = &gdev->descs[i];
Johan Hovold's avatar
Johan Hovold committed
758 759
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
760 761
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
762

Johan Hovold's avatar
Johan Hovold committed
763
	if (requested)
764
		dev_crit(&gdev->dev,
765
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
Johan Hovold's avatar
Johan Hovold committed
766

767 768 769 770 771 772 773
	/*
	 * The gpiochip side puts its use of the device to rest here:
	 * if there are no userspace clients, the chardev and device will
	 * be removed, else it will be dangling until the last user is
	 * gone.
	 */
	put_device(&gdev->dev);
774 775 776
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
static void devm_gpio_chip_release(struct device *dev, void *res)
{
	struct gpio_chip *chip = *(struct gpio_chip **)res;

	gpiochip_remove(chip);
}

static int devm_gpio_chip_match(struct device *dev, void *res, void *data)

{
	struct gpio_chip **r = res;

	if (!r || !*r) {
		WARN_ON(!r || !*r);
		return 0;
	}

	return *r == data;
}

/**
 * devm_gpiochip_add_data() - Resource manager piochip_add_data()
 * @dev: the device pointer on which irq_chip belongs to.
 * @chip: the chip to register, with chip->base initialized
 * Context: potentially before irqs will work
 *
 * Returns a negative errno if the chip can't be registered, such as
 * because the chip->base is invalid or already associated with a
 * different chip.  Otherwise it returns zero as a success code.
 *
 * The gpio chip automatically be released when the device is unbound.
 */
int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
			   void *data)
{
	struct gpio_chip **ptr;
	int ret;

	ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
			     GFP_KERNEL);
	if (!ptr)
		return -ENOMEM;

	ret = gpiochip_add_data(chip, data);
	if (ret < 0) {
		devres_free(ptr);
		return ret;
	}

	*ptr = chip;
	devres_add(dev, ptr);

	return 0;
}
EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);

/**
 * devm_gpiochip_remove() - Resource manager of gpiochip_remove()
 * @dev: device for which which resource was allocated
 * @chip: the chip to remove
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
void devm_gpiochip_remove(struct device *dev, struct gpio_chip *chip)
{
	int ret;

	ret = devres_release(dev, devm_gpio_chip_release,
			     devm_gpio_chip_match, chip);
	if (!ret)
		WARN_ON(ret);
}
EXPORT_SYMBOL_GPL(devm_gpiochip_remove);

851 852 853 854 855 856 857 858 859 860 861
/**
 * gpiochip_find() - iterator for locating a specific gpio_chip
 * @data: data to pass to match function
 * @callback: Callback function to check gpio_chip
 *
 * Similar to bus_find_device.  It returns a reference to a gpio_chip as
 * determined by a user supplied @match callback.  The callback should return
 * 0 if the device doesn't match and non-zero if it does.  If the callback is
 * non-zero, this function will return to the caller and not iterate over any
 * more gpio_chips.
 */
862
struct gpio_chip *gpiochip_find(void *data,
863
				int (*match)(struct gpio_chip *chip,
864
					     void *data))
865
{
866
	struct gpio_device *gdev;
867
	struct gpio_chip *chip;
868 869 870
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
871
	list_for_each_entry(gdev, &gpio_devices, list)
872
		if (gdev->chip && match(gdev->chip, data))
873
			break;
874 875

	/* No match? */
876
	if (&gdev->list == &gpio_devices)
877
		chip = NULL;
878 879 880
	else
		chip = gdev->chip;

881 882 883 884
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
Jean Delvare's avatar
Jean Delvare committed
885
EXPORT_SYMBOL_GPL(gpiochip_find);
886

887 888 889 890 891 892 893 894 895 896 897 898
static int gpiochip_match_name(struct gpio_chip *chip, void *data)
{
	const char *name = data;

	return !strcmp(chip->label, name);
}

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

899 900 901 902 903 904 905
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

/**
906 907 908
 * gpiochip_set_chained_irqchip() - sets a chained irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
909 910 911
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
912 913
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
914 915 916 917 918 919
 */
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
				  struct irq_chip *irqchip,
				  int parent_irq,
				  irq_flow_handler_t parent_handler)
{
920 921 922 923 924
	unsigned int offset;

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

928 929 930 931 932 933 934 935 936 937 938
	if (parent_handler) {
		if (gpiochip->can_sleep) {
			chip_err(gpiochip,
				 "you cannot have chained interrupts on a "
				 "chip that may sleep\n");
			return;
		}
		/*
		 * The parent irqchip is already using the chip_data for this
		 * irqchip, so our callbacks simply use the handler_data.
		 */
939 940
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
941 942

		gpiochip->irq_parent = parent_irq;
943
	}
944 945 946 947 948

	/* Set the parent IRQ for all affected IRQs */
	for (offset = 0; offset < gpiochip->ngpio; offset++)
		irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
			       parent_irq);
949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
}
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);

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

	irq_set_chip_data(irq, chip);
968 969 970 971 972
	/*
	 * This lock class tells lockdep that GPIO irqs are in a different
	 * category than their parents, so it won't report false recursion.
	 */
	irq_set_lockdep_class(irq, chip->lock_key);
973
	irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
974
	/* Chips that can sleep need nested thread handlers */
975
	if (chip->can_sleep && !chip->irq_not_threaded)
976
		irq_set_nested_thread(irq, 1);
977
	irq_set_noprobe(irq);
978

979 980 981 982 983 984
	/*
	 * No set-up of the hardware will happen if IRQ_TYPE_NONE
	 * is passed as default type.
	 */
	if (chip->irq_default_type != IRQ_TYPE_NONE)
		irq_set_irq_type(irq, chip->irq_default_type);
985 986 987 988

	return 0;
}

Linus Walleij's avatar
Linus Walleij committed
989 990
static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
{
991 992 993 994
	struct gpio_chip *chip = d->host_data;

	if (chip->can_sleep)
		irq_set_nested_thread(irq, 0);
Linus Walleij's avatar
Linus Walleij committed
995 996 997 998
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}

999 1000
static const struct irq_domain_ops gpiochip_domain_ops = {
	.map	= gpiochip_irq_map,
Linus Walleij's avatar
Linus Walleij committed
1001
	.unmap	= gpiochip_irq_unmap,
1002 1003 1004 1005 1006 1007 1008 1009
	/* Virtually all GPIO irqchips are twocell:ed */
	.xlate	= irq_domain_xlate_twocell,
};

static int gpiochip_irq_reqres(struct irq_data *d)
{
	struct gpio_chip *chip = irq_data_get_irq_chip_data(d);

1010
	if (!try_module_get(chip->gpiodev->owner))
1011 1012
		return -ENODEV;

1013
	if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1014 1015 1016
		chip_err(chip,
			"unable to lock HW IRQ %lu for IRQ\n",
			d->hwirq);
1017
		module_put(chip->gpiodev->owner);
1018 1019 1020 1021 1022 1023 1024 1025 1026
		return -EINVAL;
	}
	return 0;
}

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

1027
	gpiochip_unlock_as_irq(chip, d->hwirq);
1028
	module_put(chip->gpiodev->owner);
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
}

static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
{
	return irq_find_mapping(chip->irqdomain, offset);
}

/**
 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
 * @gpiochip: the gpiochip to remove the irqchip from
 *
 * This is called only from gpiochip_remove()
 */
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
{
Linus Walleij's avatar
Linus Walleij committed
1044 1045
	unsigned int offset;

1046 1047
	acpi_gpiochip_free_interrupts(gpiochip);

1048 1049 1050 1051 1052
	if (gpiochip->irq_parent) {
		irq_set_chained_handler(gpiochip->irq_parent, NULL);
		irq_set_handler_data(gpiochip->irq_parent, NULL);
	}

Linus Walleij's avatar
Linus Walleij committed
1053 1054 1055
	/* Remove all IRQ mappings and delete the domain */
	if (gpiochip->irqdomain) {
		for (offset = 0; offset < gpiochip->ngpio; offset++)
1056 1057
			irq_dispose_mapping(
				irq_find_mapping(gpiochip->irqdomain, offset));
1058
		irq_domain_remove(gpiochip->irqdomain);
Linus Walleij's avatar
Linus Walleij committed
1059
	}
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074

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

/**
 * gpiochip_irqchip_add() - adds an irqchip to a gpiochip
 * @gpiochip: the gpiochip to add the irqchip to
 * @irqchip: the irqchip to add to the gpiochip
 * @first_irq: if not dynamically assigned, the base (first) IRQ to
 * allocate gpiochip irqs from
 * @handler: the irq handler to use (often a predefined irq core function)
1075 1076
 * @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.
1077
 * @lock_key: lockdep class
1078 1079 1080 1081 1082
 *
 * 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
Linus Walleij's avatar
Linus Walleij committed
1083
 * need to use gpiochip_get_data() to get their local state containers back
1084 1085 1086 1087 1088
 * 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.
 *
Linus Walleij's avatar
Linus Walleij committed
1089 1090
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1091 1092
 * need to be open coded.
 */