gpiolib.c 82.5 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 23
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <uapi/linux/gpio.h>
24

25 26
#include "gpiolib.h"

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

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


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

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

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

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

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

71
static bool gpiolib_initialized;
72

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

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

	spin_lock_irqsave(&gpio_lock, flags);

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

	spin_unlock_irqrestore(&gpio_lock, flags);

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

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

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

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

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

/**
 * 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
 */
124
int desc_to_gpio(const struct gpio_desc *desc)
125
{
126
	return desc->gdev->base + (desc - &desc->gdev->descs[0]);
127
}
128
EXPORT_SYMBOL_GPL(desc_to_gpio);
129 130


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

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

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

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

167 168 169 170 171 172 173 174
/**
 * 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.
 */
175
int gpiod_get_direction(struct gpio_desc *desc)
176 177
{
	struct gpio_chip	*chip;
178
	unsigned		offset;
179 180
	int			status = -EINVAL;

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

	if (!chip->get_direction)
		return status;

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

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

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

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

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

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

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

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

	spin_lock_irqsave(&gpio_lock, flags);

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

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

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

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

	spin_unlock_irqrestore(&gpio_lock, flags);

	return NULL;
}

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

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

	return 0;
}

312 313 314 315 316 317 318 319 320 321 322 323 324
/**
 * 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;
	int __user *ip = (int __user *)arg;

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

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

329 330 331
		strncpy(chipinfo.name, dev_name(&gdev->dev),
			sizeof(chipinfo.name));
		chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
332 333 334
		strncpy(chipinfo.label, gdev->label,
			sizeof(chipinfo.label));
		chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
335
		chipinfo.lines = gdev->ngpio;
336 337 338
		if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
			return -EFAULT;
		return 0;
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
	} 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) {
357 358 359
			strncpy(lineinfo.consumer, desc->label,
				sizeof(lineinfo.consumer));
			lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
360
		} else {
361
			lineinfo.consumer[0] = '\0';
362 363 364 365 366 367 368
		}

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

		if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
			return -EFAULT;
		return 0;
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
	}
	return -EINVAL;
}

/**
 * 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,
	.compat_ioctl = gpio_ioctl,
};

437 438 439 440
static void gpiodevice_release(struct device *dev)
{
	struct gpio_device *gdev = dev_get_drvdata(dev);

441
	cdev_del(&gdev->chrdev);
442 443
	list_del(&gdev->list);
	ida_simple_remove(&gpio_ida, gdev->id);
444 445
	kfree(gdev->label);
	kfree(gdev->descs);
446
	kfree(gdev);
447 448
}

449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 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
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);
	}
}

501
/**
502
 * gpiochip_add_data() - register a gpio_chip
503
 * @chip: the chip to register, with chip->base initialized
504
 * Context: potentially before irqs will work
505 506 507 508
 *
 * 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.
509
 *
510
 * When gpiochip_add_data() is called very early during boot, so that GPIOs
511
 * can be freely used, the chip->parent device must be registered before
David Brownell's avatar
David Brownell committed
512 513 514
 * the gpio framework's arch_initcall().  Otherwise sysfs initialization
 * for GPIOs will fail rudely.
 *
515 516 517
 * gpiochip_add_data() must only be called after gpiolib initialization,
 * ie after core_initcall().
 *
518 519
 * If chip->base is negative, this requests dynamic assignment of
 * a range of valid GPIOs.
520
 */
521
int gpiochip_add_data(struct gpio_chip *chip, void *data)
522 523 524
{
	unsigned long	flags;
	int		status = 0;
525
	unsigned	i;
526
	int		base = chip->base;
527
	struct gpio_device *gdev;
528

529 530 531 532
	/*
	 * First: allocate and populate the internal stat container, and
	 * set up the struct device.
	 */
533
	gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
534
	if (!gdev)
535
		return -ENOMEM;
536
	gdev->dev.bus = &gpio_bus_type;
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
	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;
564

565
	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
566
	if (!gdev->descs) {
567 568 569 570
		status = -ENOMEM;
		goto err_free_gdev;
	}

571 572
	if (chip->ngpio == 0) {
		chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
573
		status = -EINVAL;
574
		goto err_free_descs;
575
	}
576 577

	if (chip->label)
578
		gdev->label = kstrdup(chip->label, GFP_KERNEL);
579
	else
580
		gdev->label = kstrdup("unknown", GFP_KERNEL);
581 582
	if (!gdev->label) {
		status = -ENOMEM;
583
		goto err_free_descs;
584 585
	}

586
	gdev->ngpio = chip->ngpio;
587
	gdev->data = data;
588

589 590
	spin_lock_irqsave(&gpio_lock, flags);

591 592 593 594 595 596 597
	/*
	 * 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.
	 */
598 599 600 601
	if (base < 0) {
		base = gpiochip_find_base(chip->ngpio);
		if (base < 0) {
			status = base;
602
			spin_unlock_irqrestore(&gpio_lock, flags);
603
			goto err_free_label;
604
		}
605 606 607 608 609 610
		/*
		 * 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.
		 */
611 612
		chip->base = base;
	}
613
	gdev->base = base;
614

615
	status = gpiodev_add_to_list(gdev);
616 617
	if (status) {
		spin_unlock_irqrestore(&gpio_lock, flags);
618
		goto err_free_label;
619
	}
620

621
	for (i = 0; i < chip->ngpio; i++) {
622
		struct gpio_desc *desc = &gdev->descs[i];
623

624
		desc->gdev = gdev;
625 626 627 628 629 630 631
		/*
		 * 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.
632
		 */
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649

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

652 653
	spin_unlock_irqrestore(&gpio_lock, flags);

654
#ifdef CONFIG_PINCTRL
655
	INIT_LIST_HEAD(&gdev->pin_ranges);
656 657
#endif

658 659 660 661
	status = gpiochip_set_desc_names(chip);
	if (status)
		goto err_remove_from_list;

662 663 664 665
	status = of_gpiochip_add(chip);
	if (status)
		goto err_remove_chip;

666
	acpi_gpiochip_add(chip);
667

668 669 670 671 672
	/*
	 * 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.
673 674
	 * We can do this only if gpiolib has been initialized.
	 * Otherwise, defer until later.
675
	 */
676 677 678 679 680
	if (gpiolib_initialized) {
		status = gpiochip_setup_dev(gdev);
		if (status)
			goto err_remove_chip;
	}
681
	return 0;
682

683 684
err_remove_chip:
	acpi_gpiochip_remove(chip);
685
	gpiochip_free_hogs(chip);
686
	of_gpiochip_remove(chip);
687
err_remove_from_list:
688
	spin_lock_irqsave(&gpio_lock, flags);
689
	list_del(&gdev->list);
690
	spin_unlock_irqrestore(&gpio_lock, flags);
691 692 693 694
err_free_label:
	kfree(gdev->label);
err_free_descs:
	kfree(gdev->descs);
695 696
err_free_gdev:
	ida_simple_remove(&gpio_ida, gdev->id);
697
	/* failures here can mean systems won't boot... */
698
	pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
699 700 701
	       gdev->base, gdev->base + gdev->ngpio - 1,
	       chip->label ? : "generic");
	kfree(gdev);
702 703
	return status;
}
704
EXPORT_SYMBOL_GPL(gpiochip_add_data);
705

706 707 708 709 710 711 712 713 714
/**
 * 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);

715 716 717 718 719 720
/**
 * gpiochip_remove() - unregister a gpio_chip
 * @chip: the chip to unregister
 *
 * A gpio_chip with any GPIOs still requested may not be removed.
 */
721
void gpiochip_remove(struct gpio_chip *chip)
722
{
723
	struct gpio_device *gdev = chip->gpiodev;
Johan Hovold's avatar
Johan Hovold committed
724
	struct gpio_desc *desc;
725
	unsigned long	flags;
726
	unsigned	i;
Johan Hovold's avatar
Johan Hovold committed
727
	bool		requested = false;
728

729
	/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
730
	gpiochip_sysfs_unregister(gdev);
731 732
	/* Numb the device, cancelling all outstanding operations */
	gdev->chip = NULL;
733
	gpiochip_irqchip_remove(chip);
734
	acpi_gpiochip_remove(chip);
735
	gpiochip_remove_pin_ranges(chip);
736
	gpiochip_free_hogs(chip);
737
	of_gpiochip_remove(chip);
738 739 740 741 742
	/*
	 * We accept no more calls into the driver from this point, so
	 * NULL the driver data pointer
	 */
	gdev->data = NULL;
743

744
	spin_lock_irqsave(&gpio_lock, flags);
745
	for (i = 0; i < gdev->ngpio; i++) {
746
		desc = &gdev->descs[i];
Johan Hovold's avatar
Johan Hovold committed
747 748
		if (test_bit(FLAG_REQUESTED, &desc->flags))
			requested = true;
749 750
	}
	spin_unlock_irqrestore(&gpio_lock, flags);
751

Johan Hovold's avatar
Johan Hovold committed
752
	if (requested)
753
		dev_crit(&gdev->dev,
754
			 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
Johan Hovold's avatar
Johan Hovold committed
755

756 757 758 759 760 761 762
	/*
	 * 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);
763 764 765
}
EXPORT_SYMBOL_GPL(gpiochip_remove);

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

840 841 842 843 844 845 846 847 848 849 850
/**
 * 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.
 */
851
struct gpio_chip *gpiochip_find(void *data,
852
				int (*match)(struct gpio_chip *chip,
853
					     void *data))
854
{
855
	struct gpio_device *gdev;
856
	struct gpio_chip *chip;
857 858 859
	unsigned long flags;

	spin_lock_irqsave(&gpio_lock, flags);
860 861
	list_for_each_entry(gdev, &gpio_devices, list)
		if (match(gdev->chip, data))
862
			break;
863 864

	/* No match? */
865
	if (&gdev->list == &gpio_devices)
866
		chip = NULL;
867 868 869
	else
		chip = gdev->chip;

870 871 872 873
	spin_unlock_irqrestore(&gpio_lock, flags);

	return chip;
}
Jean Delvare's avatar
Jean Delvare committed
874
EXPORT_SYMBOL_GPL(gpiochip_find);
875

876 877 878 879 880 881 882 883 884 885 886 887
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);
}

888 889 890 891 892 893 894
#ifdef CONFIG_GPIOLIB_IRQCHIP

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

/**
895 896 897
 * 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
898 899 900
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
901 902
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
903 904 905 906 907 908
 */
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
				  struct irq_chip *irqchip,
				  int parent_irq,
				  irq_flow_handler_t parent_handler)
{
909 910 911 912 913
	unsigned int offset;

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

917 918 919 920 921 922 923 924 925 926 927
	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.
		 */
928 929
		irq_set_chained_handler_and_data(parent_irq, parent_handler,
						 gpiochip);
930 931

		gpiochip->irq_parent = parent_irq;
932
	}
933 934 935 936 937

	/* 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);
938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956
}
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);
957 958 959 960 961
	/*
	 * 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);
962
	irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
963
	/* Chips that can sleep need nested thread handlers */
964
	if (chip->can_sleep && !chip->irq_not_threaded)
965
		irq_set_nested_thread(irq, 1);
966
	irq_set_noprobe(irq);
967

968 969 970 971 972 973
	/*
	 * 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);
974 975 976 977

	return 0;
}

Linus Walleij's avatar
Linus Walleij committed
978 979
static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
{
980 981 982 983
	struct gpio_chip *chip = d->host_data;

	if (chip->can_sleep)
		irq_set_nested_thread(irq, 0);
Linus Walleij's avatar
Linus Walleij committed
984 985 986 987
	irq_set_chip_and_handler(irq, NULL, NULL);
	irq_set_chip_data(irq, NULL);
}

988 989
static const struct irq_domain_ops gpiochip_domain_ops = {
	.map	= gpiochip_irq_map,
Linus Walleij's avatar
Linus Walleij committed
990
	.unmap	= gpiochip_irq_unmap,
991 992 993 994 995 996 997 998
	/* 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);

999
	if (!try_module_get(chip->gpiodev->owner))
1000 1001
		return -ENODEV;

1002
	if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1003 1004 1005
		chip_err(chip,
			"unable to lock HW IRQ %lu for IRQ\n",
			d->hwirq);
1006
		module_put(chip->gpiodev->owner);
1007 1008 1009 1010 1011 1012 1013 1014 1015
		return -EINVAL;
	}
	return 0;
}

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

1016
	gpiochip_unlock_as_irq(chip, d->hwirq);
1017
	module_put(chip->gpiodev->owner);
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
}

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
1033 1034
	unsigned int offset;

1035 1036
	acpi_gpiochip_free_interrupts(gpiochip);

1037 1038 1039 1040 1041
	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
1042 1043 1044
	/* Remove all IRQ mappings and delete the domain */
	if (gpiochip->irqdomain) {
		for (offset = 0; offset < gpiochip->ngpio; offset++)
1045 1046
			irq_dispose_mapping(
				irq_find_mapping(gpiochip->irqdomain, offset));
1047
		irq_domain_remove(gpiochip->irqdomain);
Linus Walleij's avatar
Linus Walleij committed
1048
	}
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063

	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)
1064 1065
 * @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.
1066
 * @lock_key: lockdep class
1067 1068 1069 1070 1071
 *
 * 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
1072
 * need to use gpiochip_get_data() to get their local state containers back
1073 1074 1075 1076 1077
 * 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
1078 1079
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
1080 1081
 * need to be open coded.
 */
1082 1083 1084 1085 1086 1087
int _gpiochip_irqchip_add(struct gpio_chip *gpiochip,
			  struct irq_chip *irqchip,
			  unsigned int first_irq,
			  irq_flow_handler_t handler,
			  unsigned int type,
			  struct lock_class_key *lock_key)
1088 1089 1090
{
	struct device_node *of_node;
	unsigned int offset;
Linus Walleij's avatar
Linus Walleij committed
1091
	unsigned irq_base = 0;
1092 1093 1094 1095

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

1096
	if (!gpiochip->parent) {
1097 1098 1099
		pr_err("missing gpiochip .dev parent pointer\n");
		return -EINVAL;
	}