1#include <linux/kernel.h>
   2#include <linux/module.h>
   3#include <linux/interrupt.h>
   4#include <linux/irq.h>
   5#include <linux/spinlock.h>
 
   6#include <linux/device.h>
   7#include <linux/err.h>
   8#include <linux/debugfs.h>
   9#include <linux/seq_file.h>
  10#include <linux/gpio.h>
  11#include <linux/of_gpio.h>
  12#include <linux/idr.h>
  13#include <linux/slab.h>
 
 
 
 
  14
  15#define CREATE_TRACE_POINTS
  16#include <trace/events/gpio.h>
  17
  18/* Optional implementation infrastructure for GPIO interfaces.
  19 *
  20 * Platforms may want to use this if they tend to use very many GPIOs
  21 * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
  22 *
  23 * When kernel footprint or instruction count is an issue, simpler
  24 * implementations may be preferred.  The GPIO programming interface
  25 * allows for inlining speed-critical get/set operations for common
  26 * cases, so that access to SOC-integrated GPIOs can sometimes cost
  27 * only an instruction or two per bit.
  28 */
  29
  30
  31/* When debugging, extend minimal trust to callers and platform code.
  32 * Also emit diagnostic messages that may help initial bringup, when
  33 * board setup or driver bugs are most common.
  34 *
  35 * Otherwise, minimize overhead in what may be bitbanging codepaths.
  36 */
  37#ifdef	DEBUG
  38#define	extra_checks	1
  39#else
  40#define	extra_checks	0
  41#endif
  42
  43/* gpio_lock prevents conflicts during gpio_desc[] table updates.
  44 * While any GPIO is requested, its gpio_chip is not removable;
  45 * each GPIO's "requested" flag serves as a lock and refcount.
  46 */
  47static DEFINE_SPINLOCK(gpio_lock);
  48
  49struct gpio_desc {
  50	struct gpio_chip	*chip;
  51	unsigned long		flags;
  52/* flag symbols are bit numbers */
  53#define FLAG_REQUESTED	0
  54#define FLAG_IS_OUT	1
  55#define FLAG_RESERVED	2
  56#define FLAG_EXPORT	3	/* protected by sysfs_lock */
  57#define FLAG_SYSFS	4	/* exported via /sys/class/gpio/control */
  58#define FLAG_TRIG_FALL	5	/* trigger on falling edge */
  59#define FLAG_TRIG_RISE	6	/* trigger on rising edge */
  60#define FLAG_ACTIVE_LOW	7	/* sysfs value has active low */
 
 
  61
  62#define ID_SHIFT	16	/* add new flags before this one */
  63
  64#define GPIO_FLAGS_MASK		((1 << ID_SHIFT) - 1)
  65#define GPIO_TRIGGER_MASK	(BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
  66
  67#ifdef CONFIG_DEBUG_FS
  68	const char		*label;
  69#endif
  70};
  71static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
  72
 
 
 
 
 
 
  73#ifdef CONFIG_GPIO_SYSFS
  74static DEFINE_IDR(dirent_idr);
  75#endif
  76
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  77static inline void desc_set_label(struct gpio_desc *d, const char *label)
  78{
  79#ifdef CONFIG_DEBUG_FS
  80	d->label = label;
  81#endif
  82}
  83
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  84/* Warn when drivers omit gpio_request() calls -- legal but ill-advised
  85 * when setting direction, and otherwise illegal.  Until board setup code
  86 * and drivers use explicit requests everywhere (which won't happen when
  87 * those calls have no teeth) we can't avoid autorequesting.  This nag
  88 * message should motivate switching to explicit requests... so should
  89 * the weaker cleanup after faults, compared to gpio_request().
  90 *
  91 * NOTE: the autorequest mechanism is going away; at this point it's
  92 * only "legal" in the sense that (old) code using it won't break yet,
  93 * but instead only triggers a WARN() stack dump.
  94 */
  95static int gpio_ensure_requested(struct gpio_desc *desc, unsigned offset)
  96{
  97	const struct gpio_chip *chip = desc->chip;
  98	const int gpio = chip->base + offset;
  99
 100	if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
 101			"autorequest GPIO-%d\n", gpio)) {
 102		if (!try_module_get(chip->owner)) {
 103			pr_err("GPIO-%d: module can't be gotten \n", gpio);
 
 104			clear_bit(FLAG_REQUESTED, &desc->flags);
 105			/* lose */
 106			return -EIO;
 107		}
 108		desc_set_label(desc, "[auto]");
 109		/* caller must chip->request() w/o spinlock */
 110		if (chip->request)
 111			return 1;
 112	}
 113	return 0;
 114}
 115
 116/* caller holds gpio_lock *OR* gpio is marked as requested */
 117static inline struct gpio_chip *gpio_to_chip(unsigned gpio)
 
 
 
 118{
 119	return gpio_desc[gpio].chip;
 120}
 
 121
 122/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
 123static int gpiochip_find_base(int ngpio)
 124{
 125	int i;
 126	int spare = 0;
 127	int base = -ENOSPC;
 128
 129	for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) {
 130		struct gpio_desc *desc = &gpio_desc[i];
 131		struct gpio_chip *chip = desc->chip;
 132
 133		if (!chip && !test_bit(FLAG_RESERVED, &desc->flags)) {
 134			spare++;
 135			if (spare == ngpio) {
 136				base = i;
 137				break;
 138			}
 139		} else {
 140			spare = 0;
 141			if (chip)
 142				i -= chip->ngpio - 1;
 143		}
 144	}
 145
 146	if (gpio_is_valid(base))
 147		pr_debug("%s: found new base at %d\n", __func__, base);
 148	return base;
 
 
 
 
 149}
 150
 151/**
 152 * gpiochip_reserve() - reserve range of gpios to use with platform code only
 153 * @start: starting gpio number
 154 * @ngpio: number of gpios to reserve
 155 * Context: platform init, potentially before irqs or kmalloc will work
 156 *
 157 * Returns a negative errno if any gpio within the range is already reserved
 158 * or registered, else returns zero as a success code.  Use this function
 159 * to mark a range of gpios as unavailable for dynamic gpio number allocation,
 160 * for example because its driver support is not yet loaded.
 161 */
 162int __init gpiochip_reserve(int start, int ngpio)
 163{
 164	int ret = 0;
 165	unsigned long flags;
 166	int i;
 167
 168	if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio - 1))
 169		return -EINVAL;
 170
 171	spin_lock_irqsave(&gpio_lock, flags);
 172
 173	for (i = start; i < start + ngpio; i++) {
 174		struct gpio_desc *desc = &gpio_desc[i];
 175
 176		if (desc->chip || test_bit(FLAG_RESERVED, &desc->flags)) {
 177			ret = -EBUSY;
 178			goto err;
 179		}
 180
 181		set_bit(FLAG_RESERVED, &desc->flags);
 
 
 
 
 
 
 182	}
 183
 184	pr_debug("%s: reserved gpios from %d to %d\n",
 185		 __func__, start, start + ngpio - 1);
 186err:
 187	spin_unlock_irqrestore(&gpio_lock, flags);
 188
 189	return ret;
 190}
 
 191
 192#ifdef CONFIG_GPIO_SYSFS
 193
 194/* lock protects against unexport_gpio() being called while
 195 * sysfs files are active.
 196 */
 197static DEFINE_MUTEX(sysfs_lock);
 198
 199/*
 200 * /sys/class/gpio/gpioN... only for GPIOs that are exported
 201 *   /direction
 202 *      * MAY BE OMITTED if kernel won't allow direction changes
 203 *      * is read/write as "in" or "out"
 204 *      * may also be written as "high" or "low", initializing
 205 *        output value as specified ("out" implies "low")
 206 *   /value
 207 *      * always readable, subject to hardware behavior
 208 *      * may be writable, as zero/nonzero
 209 *   /edge
 210 *      * configures behavior of poll(2) on /value
 211 *      * available only if pin can generate IRQs on input
 212 *      * is read/write as "none", "falling", "rising", or "both"
 213 *   /active_low
 214 *      * configures polarity of /value
 215 *      * is read/write as zero/nonzero
 216 *      * also affects existing and subsequent "falling" and "rising"
 217 *        /edge configuration
 218 */
 219
 220static ssize_t gpio_direction_show(struct device *dev,
 221		struct device_attribute *attr, char *buf)
 222{
 223	const struct gpio_desc	*desc = dev_get_drvdata(dev);
 224	ssize_t			status;
 225
 226	mutex_lock(&sysfs_lock);
 227
 228	if (!test_bit(FLAG_EXPORT, &desc->flags))
 229		status = -EIO;
 230	else
 
 231		status = sprintf(buf, "%s\n",
 232			test_bit(FLAG_IS_OUT, &desc->flags)
 233				? "out" : "in");
 
 234
 235	mutex_unlock(&sysfs_lock);
 236	return status;
 237}
 238
 239static ssize_t gpio_direction_store(struct device *dev,
 240		struct device_attribute *attr, const char *buf, size_t size)
 241{
 242	const struct gpio_desc	*desc = dev_get_drvdata(dev);
 243	unsigned		gpio = desc - gpio_desc;
 244	ssize_t			status;
 245
 246	mutex_lock(&sysfs_lock);
 247
 248	if (!test_bit(FLAG_EXPORT, &desc->flags))
 249		status = -EIO;
 250	else if (sysfs_streq(buf, "high"))
 251		status = gpio_direction_output(gpio, 1);
 252	else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
 253		status = gpio_direction_output(gpio, 0);
 254	else if (sysfs_streq(buf, "in"))
 255		status = gpio_direction_input(gpio);
 256	else
 257		status = -EINVAL;
 258
 259	mutex_unlock(&sysfs_lock);
 260	return status ? : size;
 261}
 262
 263static /* const */ DEVICE_ATTR(direction, 0644,
 264		gpio_direction_show, gpio_direction_store);
 265
 266static ssize_t gpio_value_show(struct device *dev,
 267		struct device_attribute *attr, char *buf)
 268{
 269	const struct gpio_desc	*desc = dev_get_drvdata(dev);
 270	unsigned		gpio = desc - gpio_desc;
 271	ssize_t			status;
 272
 273	mutex_lock(&sysfs_lock);
 274
 275	if (!test_bit(FLAG_EXPORT, &desc->flags)) {
 276		status = -EIO;
 277	} else {
 278		int value;
 279
 280		value = !!gpio_get_value_cansleep(gpio);
 281		if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
 282			value = !value;
 283
 284		status = sprintf(buf, "%d\n", value);
 285	}
 286
 287	mutex_unlock(&sysfs_lock);
 288	return status;
 289}
 290
 291static ssize_t gpio_value_store(struct device *dev,
 292		struct device_attribute *attr, const char *buf, size_t size)
 293{
 294	const struct gpio_desc	*desc = dev_get_drvdata(dev);
 295	unsigned		gpio = desc - gpio_desc;
 296	ssize_t			status;
 297
 298	mutex_lock(&sysfs_lock);
 299
 300	if (!test_bit(FLAG_EXPORT, &desc->flags))
 301		status = -EIO;
 302	else if (!test_bit(FLAG_IS_OUT, &desc->flags))
 303		status = -EPERM;
 304	else {
 305		long		value;
 306
 307		status = strict_strtol(buf, 0, &value);
 308		if (status == 0) {
 309			if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
 310				value = !value;
 311			gpio_set_value_cansleep(gpio, value != 0);
 312			status = size;
 313		}
 314	}
 315
 316	mutex_unlock(&sysfs_lock);
 317	return status;
 318}
 319
 320static const DEVICE_ATTR(value, 0644,
 321		gpio_value_show, gpio_value_store);
 322
 323static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
 324{
 325	struct sysfs_dirent	*value_sd = priv;
 326
 327	sysfs_notify_dirent(value_sd);
 328	return IRQ_HANDLED;
 329}
 330
 331static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
 332		unsigned long gpio_flags)
 333{
 334	struct sysfs_dirent	*value_sd;
 335	unsigned long		irq_flags;
 336	int			ret, irq, id;
 337
 338	if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
 339		return 0;
 340
 341	irq = gpio_to_irq(desc - gpio_desc);
 342	if (irq < 0)
 343		return -EIO;
 344
 345	id = desc->flags >> ID_SHIFT;
 346	value_sd = idr_find(&dirent_idr, id);
 347	if (value_sd)
 348		free_irq(irq, value_sd);
 349
 350	desc->flags &= ~GPIO_TRIGGER_MASK;
 351
 352	if (!gpio_flags) {
 
 353		ret = 0;
 354		goto free_id;
 355	}
 356
 357	irq_flags = IRQF_SHARED;
 358	if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
 359		irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 360			IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
 361	if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
 362		irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 363			IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
 364
 365	if (!value_sd) {
 366		value_sd = sysfs_get_dirent(dev->kobj.sd, NULL, "value");
 367		if (!value_sd) {
 368			ret = -ENODEV;
 369			goto err_out;
 370		}
 371
 372		do {
 373			ret = -ENOMEM;
 374			if (idr_pre_get(&dirent_idr, GFP_KERNEL))
 375				ret = idr_get_new_above(&dirent_idr, value_sd,
 376							1, &id);
 377		} while (ret == -EAGAIN);
 378
 379		if (ret)
 380			goto free_sd;
 
 381
 382		desc->flags &= GPIO_FLAGS_MASK;
 383		desc->flags |= (unsigned long)id << ID_SHIFT;
 384
 385		if (desc->flags >> ID_SHIFT != id) {
 386			ret = -ERANGE;
 387			goto free_id;
 388		}
 389	}
 390
 391	ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
 392				"gpiolib", value_sd);
 393	if (ret < 0)
 394		goto free_id;
 395
 
 
 
 
 
 
 396	desc->flags |= gpio_flags;
 397	return 0;
 398
 399free_id:
 400	idr_remove(&dirent_idr, id);
 401	desc->flags &= GPIO_FLAGS_MASK;
 402free_sd:
 403	if (value_sd)
 404		sysfs_put(value_sd);
 405err_out:
 406	return ret;
 407}
 408
 409static const struct {
 410	const char *name;
 411	unsigned long flags;
 412} trigger_types[] = {
 413	{ "none",    0 },
 414	{ "falling", BIT(FLAG_TRIG_FALL) },
 415	{ "rising",  BIT(FLAG_TRIG_RISE) },
 416	{ "both",    BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
 417};
 418
 419static ssize_t gpio_edge_show(struct device *dev,
 420		struct device_attribute *attr, char *buf)
 421{
 422	const struct gpio_desc	*desc = dev_get_drvdata(dev);
 423	ssize_t			status;
 424
 425	mutex_lock(&sysfs_lock);
 426
 427	if (!test_bit(FLAG_EXPORT, &desc->flags))
 428		status = -EIO;
 429	else {
 430		int i;
 431
 432		status = 0;
 433		for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
 434			if ((desc->flags & GPIO_TRIGGER_MASK)
 435					== trigger_types[i].flags) {
 436				status = sprintf(buf, "%s\n",
 437						 trigger_types[i].name);
 438				break;
 439			}
 440	}
 441
 442	mutex_unlock(&sysfs_lock);
 443	return status;
 444}
 445
 446static ssize_t gpio_edge_store(struct device *dev,
 447		struct device_attribute *attr, const char *buf, size_t size)
 448{
 449	struct gpio_desc	*desc = dev_get_drvdata(dev);
 450	ssize_t			status;
 451	int			i;
 452
 453	for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
 454		if (sysfs_streq(trigger_types[i].name, buf))
 455			goto found;
 456	return -EINVAL;
 457
 458found:
 459	mutex_lock(&sysfs_lock);
 460
 461	if (!test_bit(FLAG_EXPORT, &desc->flags))
 462		status = -EIO;
 463	else {
 464		status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
 465		if (!status)
 466			status = size;
 467	}
 468
 469	mutex_unlock(&sysfs_lock);
 470
 471	return status;
 472}
 473
 474static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
 475
 476static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
 477				int value)
 478{
 479	int			status = 0;
 480
 481	if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
 482		return 0;
 483
 484	if (value)
 485		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 486	else
 487		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
 488
 489	/* reconfigure poll(2) support if enabled on one edge only */
 490	if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
 491				!!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
 492		unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
 493
 494		gpio_setup_irq(desc, dev, 0);
 495		status = gpio_setup_irq(desc, dev, trigger_flags);
 496	}
 497
 498	return status;
 499}
 500
 501static ssize_t gpio_active_low_show(struct device *dev,
 502		struct device_attribute *attr, char *buf)
 503{
 504	const struct gpio_desc	*desc = dev_get_drvdata(dev);
 505	ssize_t			status;
 506
 507	mutex_lock(&sysfs_lock);
 508
 509	if (!test_bit(FLAG_EXPORT, &desc->flags))
 510		status = -EIO;
 511	else
 512		status = sprintf(buf, "%d\n",
 513				!!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
 514
 515	mutex_unlock(&sysfs_lock);
 516
 517	return status;
 518}
 519
 520static ssize_t gpio_active_low_store(struct device *dev,
 521		struct device_attribute *attr, const char *buf, size_t size)
 522{
 523	struct gpio_desc	*desc = dev_get_drvdata(dev);
 524	ssize_t			status;
 525
 526	mutex_lock(&sysfs_lock);
 527
 528	if (!test_bit(FLAG_EXPORT, &desc->flags)) {
 529		status = -EIO;
 530	} else {
 531		long		value;
 532
 533		status = strict_strtol(buf, 0, &value);
 534		if (status == 0)
 535			status = sysfs_set_active_low(desc, dev, value != 0);
 536	}
 537
 538	mutex_unlock(&sysfs_lock);
 539
 540	return status ? : size;
 541}
 542
 543static const DEVICE_ATTR(active_low, 0644,
 544		gpio_active_low_show, gpio_active_low_store);
 545
 546static const struct attribute *gpio_attrs[] = {
 547	&dev_attr_value.attr,
 548	&dev_attr_active_low.attr,
 549	NULL,
 550};
 551
 552static const struct attribute_group gpio_attr_group = {
 553	.attrs = (struct attribute **) gpio_attrs,
 554};
 555
 556/*
 557 * /sys/class/gpio/gpiochipN/
 558 *   /base ... matching gpio_chip.base (N)
 559 *   /label ... matching gpio_chip.label
 560 *   /ngpio ... matching gpio_chip.ngpio
 561 */
 562
 563static ssize_t chip_base_show(struct device *dev,
 564			       struct device_attribute *attr, char *buf)
 565{
 566	const struct gpio_chip	*chip = dev_get_drvdata(dev);
 567
 568	return sprintf(buf, "%d\n", chip->base);
 569}
 570static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
 571
 572static ssize_t chip_label_show(struct device *dev,
 573			       struct device_attribute *attr, char *buf)
 574{
 575	const struct gpio_chip	*chip = dev_get_drvdata(dev);
 576
 577	return sprintf(buf, "%s\n", chip->label ? : "");
 578}
 579static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
 580
 581static ssize_t chip_ngpio_show(struct device *dev,
 582			       struct device_attribute *attr, char *buf)
 583{
 584	const struct gpio_chip	*chip = dev_get_drvdata(dev);
 585
 586	return sprintf(buf, "%u\n", chip->ngpio);
 587}
 588static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
 589
 590static const struct attribute *gpiochip_attrs[] = {
 591	&dev_attr_base.attr,
 592	&dev_attr_label.attr,
 593	&dev_attr_ngpio.attr,
 594	NULL,
 595};
 596
 597static const struct attribute_group gpiochip_attr_group = {
 598	.attrs = (struct attribute **) gpiochip_attrs,
 599};
 600
 601/*
 602 * /sys/class/gpio/export ... write-only
 603 *	integer N ... number of GPIO to export (full access)
 604 * /sys/class/gpio/unexport ... write-only
 605 *	integer N ... number of GPIO to unexport
 606 */
 607static ssize_t export_store(struct class *class,
 608				struct class_attribute *attr,
 609				const char *buf, size_t len)
 610{
 611	long	gpio;
 612	int	status;
 
 613
 614	status = strict_strtol(buf, 0, &gpio);
 615	if (status < 0)
 616		goto done;
 617
 
 
 
 
 
 
 
 618	/* No extra locking here; FLAG_SYSFS just signifies that the
 619	 * request and export were done by on behalf of userspace, so
 620	 * they may be undone on its behalf too.
 621	 */
 622
 623	status = gpio_request(gpio, "sysfs");
 624	if (status < 0)
 
 
 625		goto done;
 626
 627	status = gpio_export(gpio, true);
 628	if (status < 0)
 629		gpio_free(gpio);
 630	else
 631		set_bit(FLAG_SYSFS, &gpio_desc[gpio].flags);
 632
 633done:
 634	if (status)
 635		pr_debug("%s: status %d\n", __func__, status);
 636	return status ? : len;
 637}
 638
 639static ssize_t unexport_store(struct class *class,
 640				struct class_attribute *attr,
 641				const char *buf, size_t len)
 642{
 643	long	gpio;
 644	int	status;
 
 645
 646	status = strict_strtol(buf, 0, &gpio);
 647	if (status < 0)
 648		goto done;
 649
 650	status = -EINVAL;
 651
 652	/* reject bogus commands (gpio_unexport ignores them) */
 653	if (!gpio_is_valid(gpio))
 654		goto done;
 
 
 
 
 655
 656	/* No extra locking here; FLAG_SYSFS just signifies that the
 657	 * request and export were done by on behalf of userspace, so
 658	 * they may be undone on its behalf too.
 659	 */
 660	if (test_and_clear_bit(FLAG_SYSFS, &gpio_desc[gpio].flags)) {
 661		status = 0;
 662		gpio_free(gpio);
 663	}
 664done:
 665	if (status)
 666		pr_debug("%s: status %d\n", __func__, status);
 667	return status ? : len;
 668}
 669
 670static struct class_attribute gpio_class_attrs[] = {
 671	__ATTR(export, 0200, NULL, export_store),
 672	__ATTR(unexport, 0200, NULL, unexport_store),
 673	__ATTR_NULL,
 674};
 675
 676static struct class gpio_class = {
 677	.name =		"gpio",
 678	.owner =	THIS_MODULE,
 679
 680	.class_attrs =	gpio_class_attrs,
 681};
 682
 683
 684/**
 685 * gpio_export - export a GPIO through sysfs
 686 * @gpio: gpio to make available, already requested
 687 * @direction_may_change: true if userspace may change gpio direction
 688 * Context: arch_initcall or later
 689 *
 690 * When drivers want to make a GPIO accessible to userspace after they
 691 * have requested it -- perhaps while debugging, or as part of their
 692 * public interface -- they may use this routine.  If the GPIO can
 693 * change direction (some can't) and the caller allows it, userspace
 694 * will see "direction" sysfs attribute which may be used to change
 695 * the gpio's direction.  A "value" attribute will always be provided.
 696 *
 697 * Returns zero on success, else an error.
 698 */
 699int gpio_export(unsigned gpio, bool direction_may_change)
 700{
 701	unsigned long		flags;
 702	struct gpio_desc	*desc;
 703	int			status = -EINVAL;
 704	const char		*ioname = NULL;
 
 
 705
 706	/* can't export until sysfs is available ... */
 707	if (!gpio_class.p) {
 708		pr_debug("%s: called too early!\n", __func__);
 709		return -ENOENT;
 710	}
 711
 712	if (!gpio_is_valid(gpio))
 713		goto done;
 
 
 714
 715	mutex_lock(&sysfs_lock);
 716
 717	spin_lock_irqsave(&gpio_lock, flags);
 718	desc = &gpio_desc[gpio];
 719	if (test_bit(FLAG_REQUESTED, &desc->flags)
 720			&& !test_bit(FLAG_EXPORT, &desc->flags)) {
 721		status = 0;
 722		if (!desc->chip->direction_input
 723				|| !desc->chip->direction_output)
 724			direction_may_change = false;
 
 
 725	}
 
 
 
 726	spin_unlock_irqrestore(&gpio_lock, flags);
 727
 728	if (desc->chip->names && desc->chip->names[gpio - desc->chip->base])
 729		ioname = desc->chip->names[gpio - desc->chip->base];
 
 
 
 
 
 
 
 
 
 730
 731	if (status == 0) {
 732		struct device	*dev;
 
 733
 734		dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
 735				desc, ioname ? ioname : "gpio%u", gpio);
 736		if (!IS_ERR(dev)) {
 737			status = sysfs_create_group(&dev->kobj,
 738						&gpio_attr_group);
 739
 740			if (!status && direction_may_change)
 741				status = device_create_file(dev,
 742						&dev_attr_direction);
 743
 744			if (!status && gpio_to_irq(gpio) >= 0
 745					&& (direction_may_change
 746						|| !test_bit(FLAG_IS_OUT,
 747							&desc->flags)))
 748				status = device_create_file(dev,
 749						&dev_attr_edge);
 750
 751			if (status != 0)
 752				device_unregister(dev);
 753		} else
 754			status = PTR_ERR(dev);
 755		if (status == 0)
 756			set_bit(FLAG_EXPORT, &desc->flags);
 757	}
 758
 
 759	mutex_unlock(&sysfs_lock);
 
 760
 761done:
 762	if (status)
 763		pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
 764
 
 765	return status;
 766}
 767EXPORT_SYMBOL_GPL(gpio_export);
 768
 769static int match_export(struct device *dev, void *data)
 770{
 771	return dev_get_drvdata(dev) == data;
 772}
 773
 774/**
 775 * gpio_export_link - create a sysfs link to an exported GPIO node
 776 * @dev: device under which to create symlink
 777 * @name: name of the symlink
 778 * @gpio: gpio to create symlink to, already exported
 779 *
 780 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 781 * node. Caller is responsible for unlinking.
 782 *
 783 * Returns zero on success, else an error.
 784 */
 785int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
 
 786{
 787	struct gpio_desc	*desc;
 788	int			status = -EINVAL;
 789
 790	if (!gpio_is_valid(gpio))
 791		goto done;
 
 
 792
 793	mutex_lock(&sysfs_lock);
 794
 795	desc = &gpio_desc[gpio];
 796
 797	if (test_bit(FLAG_EXPORT, &desc->flags)) {
 798		struct device *tdev;
 799
 800		tdev = class_find_device(&gpio_class, NULL, desc, match_export);
 801		if (tdev != NULL) {
 802			status = sysfs_create_link(&dev->kobj, &tdev->kobj,
 803						name);
 804		} else {
 805			status = -ENODEV;
 806		}
 807	}
 808
 809	mutex_unlock(&sysfs_lock);
 810
 811done:
 812	if (status)
 813		pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
 814
 815	return status;
 816}
 817EXPORT_SYMBOL_GPL(gpio_export_link);
 818
 819
 820/**
 821 * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
 822 * @gpio: gpio to change
 823 * @value: non-zero to use active low, i.e. inverted values
 824 *
 825 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
 826 * The GPIO does not have to be exported yet.  If poll(2) support has
 827 * been enabled for either rising or falling edge, it will be
 828 * reconfigured to follow the new polarity.
 829 *
 830 * Returns zero on success, else an error.
 831 */
 832int gpio_sysfs_set_active_low(unsigned gpio, int value)
 833{
 834	struct gpio_desc	*desc;
 835	struct device		*dev = NULL;
 836	int			status = -EINVAL;
 837
 838	if (!gpio_is_valid(gpio))
 839		goto done;
 
 
 840
 841	mutex_lock(&sysfs_lock);
 842
 843	desc = &gpio_desc[gpio];
 844
 845	if (test_bit(FLAG_EXPORT, &desc->flags)) {
 846		dev = class_find_device(&gpio_class, NULL, desc, match_export);
 847		if (dev == NULL) {
 848			status = -ENODEV;
 849			goto unlock;
 850		}
 851	}
 852
 853	status = sysfs_set_active_low(desc, dev, value);
 854
 855unlock:
 856	mutex_unlock(&sysfs_lock);
 857
 858done:
 859	if (status)
 860		pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
 861
 862	return status;
 863}
 864EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
 865
 866/**
 867 * gpio_unexport - reverse effect of gpio_export()
 868 * @gpio: gpio to make unavailable
 869 *
 870 * This is implicit on gpio_free().
 871 */
 872void gpio_unexport(unsigned gpio)
 873{
 874	struct gpio_desc	*desc;
 875	int			status = 0;
 
 876
 877	if (!gpio_is_valid(gpio)) {
 878		status = -EINVAL;
 879		goto done;
 880	}
 881
 882	mutex_lock(&sysfs_lock);
 883
 884	desc = &gpio_desc[gpio];
 885
 886	if (test_bit(FLAG_EXPORT, &desc->flags)) {
 887		struct device	*dev = NULL;
 888
 889		dev = class_find_device(&gpio_class, NULL, desc, match_export);
 890		if (dev) {
 891			gpio_setup_irq(desc, dev, 0);
 892			clear_bit(FLAG_EXPORT, &desc->flags);
 893			put_device(dev);
 894			device_unregister(dev);
 895		} else
 896			status = -ENODEV;
 897	}
 898
 899	mutex_unlock(&sysfs_lock);
 900done:
 
 
 
 
 
 901	if (status)
 902		pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
 903}
 904EXPORT_SYMBOL_GPL(gpio_unexport);
 905
 906static int gpiochip_export(struct gpio_chip *chip)
 907{
 908	int		status;
 909	struct device	*dev;
 910
 911	/* Many systems register gpio chips for SOC support very early,
 912	 * before driver model support is available.  In those cases we
 913	 * export this later, in gpiolib_sysfs_init() ... here we just
 914	 * verify that _some_ field of gpio_class got initialized.
 915	 */
 916	if (!gpio_class.p)
 917		return 0;
 918
 919	/* use chip->base for the ID; it's already known to be unique */
 920	mutex_lock(&sysfs_lock);
 921	dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
 922				"gpiochip%d", chip->base);
 923	if (!IS_ERR(dev)) {
 924		status = sysfs_create_group(&dev->kobj,
 925				&gpiochip_attr_group);
 926	} else
 927		status = PTR_ERR(dev);
 928	chip->exported = (status == 0);
 929	mutex_unlock(&sysfs_lock);
 930
 931	if (status) {
 932		unsigned long	flags;
 933		unsigned	gpio;
 934
 935		spin_lock_irqsave(&gpio_lock, flags);
 936		gpio = chip->base;
 937		while (gpio_desc[gpio].chip == chip)
 938			gpio_desc[gpio++].chip = NULL;
 939		spin_unlock_irqrestore(&gpio_lock, flags);
 940
 941		pr_debug("%s: chip %s status %d\n", __func__,
 942				chip->label, status);
 943	}
 944
 945	return status;
 946}
 947
 948static void gpiochip_unexport(struct gpio_chip *chip)
 949{
 950	int			status;
 951	struct device		*dev;
 952
 953	mutex_lock(&sysfs_lock);
 954	dev = class_find_device(&gpio_class, NULL, chip, match_export);
 955	if (dev) {
 956		put_device(dev);
 957		device_unregister(dev);
 958		chip->exported = 0;
 959		status = 0;
 960	} else
 961		status = -ENODEV;
 962	mutex_unlock(&sysfs_lock);
 963
 964	if (status)
 965		pr_debug("%s: chip %s status %d\n", __func__,
 966				chip->label, status);
 967}
 968
 969static int __init gpiolib_sysfs_init(void)
 970{
 971	int		status;
 972	unsigned long	flags;
 973	unsigned	gpio;
 974
 975	status = class_register(&gpio_class);
 976	if (status < 0)
 977		return status;
 978
 979	/* Scan and register the gpio_chips which registered very
 980	 * early (e.g. before the class_register above was called).
 981	 *
 982	 * We run before arch_initcall() so chip->dev nodes can have
 983	 * registered, and so arch_initcall() can always gpio_export().
 984	 */
 985	spin_lock_irqsave(&gpio_lock, flags);
 986	for (gpio = 0; gpio < ARCH_NR_GPIOS; gpio++) {
 987		struct gpio_chip	*chip;
 988
 989		chip = gpio_desc[gpio].chip;
 990		if (!chip || chip->exported)
 991			continue;
 992
 993		spin_unlock_irqrestore(&gpio_lock, flags);
 994		status = gpiochip_export(chip);
 995		spin_lock_irqsave(&gpio_lock, flags);
 996	}
 997	spin_unlock_irqrestore(&gpio_lock, flags);
 998
 999
1000	return status;
1001}
1002postcore_initcall(gpiolib_sysfs_init);
1003
1004#else
1005static inline int gpiochip_export(struct gpio_chip *chip)
1006{
1007	return 0;
1008}
1009
1010static inline void gpiochip_unexport(struct gpio_chip *chip)
1011{
1012}
1013
1014#endif /* CONFIG_GPIO_SYSFS */
1015
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1016/**
1017 * gpiochip_add() - register a gpio_chip
1018 * @chip: the chip to register, with chip->base initialized
1019 * Context: potentially before irqs or kmalloc will work
1020 *
1021 * Returns a negative errno if the chip can't be registered, such as
1022 * because the chip->base is invalid or already associated with a
1023 * different chip.  Otherwise it returns zero as a success code.
1024 *
1025 * When gpiochip_add() is called very early during boot, so that GPIOs
1026 * can be freely used, the chip->dev device must be registered before
1027 * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1028 * for GPIOs will fail rudely.
1029 *
1030 * If chip->base is negative, this requests dynamic assignment of
1031 * a range of valid GPIOs.
1032 */
1033int gpiochip_add(struct gpio_chip *chip)
1034{
1035	unsigned long	flags;
1036	int		status = 0;
1037	unsigned	id;
1038	int		base = chip->base;
1039
1040	if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1041			&& base >= 0) {
1042		status = -EINVAL;
1043		goto fail;
1044	}
1045
1046	spin_lock_irqsave(&gpio_lock, flags);
1047
1048	if (base < 0) {
1049		base = gpiochip_find_base(chip->ngpio);
1050		if (base < 0) {
1051			status = base;
1052			goto unlock;
1053		}
1054		chip->base = base;
1055	}
1056
1057	/* these GPIO numbers must not be managed by another gpio_chip */
1058	for (id = base; id < base + chip->ngpio; id++) {
1059		if (gpio_desc[id].chip != NULL) {
1060			status = -EBUSY;
1061			break;
1062		}
1063	}
1064	if (status == 0) {
1065		for (id = base; id < base + chip->ngpio; id++) {
1066			gpio_desc[id].chip = chip;
 
 
 
1067
1068			/* REVISIT:  most hardware initializes GPIOs as
1069			 * inputs (often with pullups enabled) so power
1070			 * usage is minimized.  Linux code should set the
1071			 * gpio direction first thing; but until it does,
 
1072			 * we may expose the wrong direction in sysfs.
1073			 */
1074			gpio_desc[id].flags = !chip->direction_input
1075				? (1 << FLAG_IS_OUT)
1076				: 0;
1077		}
1078	}
1079
1080	of_gpiochip_add(chip);
1081
1082unlock:
1083	spin_unlock_irqrestore(&gpio_lock, flags);
1084
 
 
 
 
 
 
 
1085	if (status)
1086		goto fail;
1087
1088	status = gpiochip_export(chip);
1089	if (status)
1090		goto fail;
1091
 
 
 
 
1092	return 0;
 
 
 
1093fail:
1094	/* failures here can mean systems won't boot... */
1095	pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
1096		chip->base, chip->base + chip->ngpio - 1,
1097		chip->label ? : "generic");
1098	return status;
1099}
1100EXPORT_SYMBOL_GPL(gpiochip_add);
1101
 
 
 
1102/**
1103 * gpiochip_remove() - unregister a gpio_chip
1104 * @chip: the chip to unregister
1105 *
1106 * A gpio_chip with any GPIOs still requested may not be removed.
1107 */
1108int gpiochip_remove(struct gpio_chip *chip)
1109{
1110	unsigned long	flags;
1111	int		status = 0;
1112	unsigned	id;
1113
 
 
1114	spin_lock_irqsave(&gpio_lock, flags);
1115
 
 
1116	of_gpiochip_remove(chip);
1117
1118	for (id = chip->base; id < chip->base + chip->ngpio; id++) {
1119		if (test_bit(FLAG_REQUESTED, &gpio_desc[id].flags)) {
1120			status = -EBUSY;
1121			break;
1122		}
1123	}
1124	if (status == 0) {
1125		for (id = chip->base; id < chip->base + chip->ngpio; id++)
1126			gpio_desc[id].chip = NULL;
 
 
1127	}
1128
1129	spin_unlock_irqrestore(&gpio_lock, flags);
1130
1131	if (status == 0)
1132		gpiochip_unexport(chip);
1133
1134	return status;
1135}
1136EXPORT_SYMBOL_GPL(gpiochip_remove);
1137
1138/**
1139 * gpiochip_find() - iterator for locating a specific gpio_chip
1140 * @data: data to pass to match function
1141 * @callback: Callback function to check gpio_chip
1142 *
1143 * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1144 * determined by a user supplied @match callback.  The callback should return
1145 * 0 if the device doesn't match and non-zero if it does.  If the callback is
1146 * non-zero, this function will return to the caller and not iterate over any
1147 * more gpio_chips.
1148 */
1149struct gpio_chip *gpiochip_find(void *data,
1150				int (*match)(struct gpio_chip *chip, void *data))
 
1151{
1152	struct gpio_chip *chip = NULL;
1153	unsigned long flags;
1154	int i;
1155
1156	spin_lock_irqsave(&gpio_lock, flags);
1157	for (i = 0; i < ARCH_NR_GPIOS; i++) {
1158		if (!gpio_desc[i].chip)
1159			continue;
1160
1161		if (match(gpio_desc[i].chip, data)) {
1162			chip = gpio_desc[i].chip;
1163			break;
1164		}
1165	}
 
 
1166	spin_unlock_irqrestore(&gpio_lock, flags);
1167
1168	return chip;
1169}
1170EXPORT_SYMBOL_GPL(gpiochip_find);
1171
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1172/* These "optional" allocation calls help prevent drivers from stomping
1173 * on each other, and help provide better diagnostics in debugfs.
1174 * They're called even less than the "set direction" calls.
1175 */
1176int gpio_request(unsigned gpio, const char *label)
1177{
1178	struct gpio_desc	*desc;
1179	struct gpio_chip	*chip;
1180	int			status = -EINVAL;
1181	unsigned long		flags;
1182
1183	spin_lock_irqsave(&gpio_lock, flags);
1184
1185	if (!gpio_is_valid(gpio))
1186		goto done;
1187	desc = &gpio_desc[gpio];
1188	chip = desc->chip;
1189	if (chip == NULL)
1190		goto done;
1191
1192	if (!try_module_get(chip->owner))
1193		goto done;
1194
1195	/* NOTE:  gpio_request() can be called in early boot,
1196	 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1197	 */
1198
1199	if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1200		desc_set_label(desc, label ? : "?");
1201		status = 0;
1202	} else {
1203		status = -EBUSY;
1204		module_put(chip->owner);
1205		goto done;
1206	}
1207
1208	if (chip->request) {
1209		/* chip->request may sleep */
1210		spin_unlock_irqrestore(&gpio_lock, flags);
1211		status = chip->request(chip, gpio - chip->base);
1212		spin_lock_irqsave(&gpio_lock, flags);
1213
1214		if (status < 0) {
1215			desc_set_label(desc, NULL);
1216			module_put(chip->owner);
1217			clear_bit(FLAG_REQUESTED, &desc->flags);
 
1218		}
1219	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1220
1221done:
1222	if (status)
1223		pr_debug("gpio_request: gpio-%d (%s) status %d\n",
1224			gpio, label ? : "?", status);
1225	spin_unlock_irqrestore(&gpio_lock, flags);
1226	return status;
1227}
 
 
 
 
 
1228EXPORT_SYMBOL_GPL(gpio_request);
1229
1230void gpio_free(unsigned gpio)
1231{
 
1232	unsigned long		flags;
1233	struct gpio_desc	*desc;
1234	struct gpio_chip	*chip;
1235
1236	might_sleep();
1237
1238	if (!gpio_is_valid(gpio)) {
1239		WARN_ON(extra_checks);
1240		return;
1241	}
1242
1243	gpio_unexport(gpio);
1244
1245	spin_lock_irqsave(&gpio_lock, flags);
1246
1247	desc = &gpio_desc[gpio];
1248	chip = desc->chip;
1249	if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1250		if (chip->free) {
1251			spin_unlock_irqrestore(&gpio_lock, flags);
1252			might_sleep_if(chip->can_sleep);
1253			chip->free(chip, gpio - chip->base);
1254			spin_lock_irqsave(&gpio_lock, flags);
1255		}
1256		desc_set_label(desc, NULL);
1257		module_put(desc->chip->owner);
1258		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1259		clear_bit(FLAG_REQUESTED, &desc->flags);
1260	} else
1261		WARN_ON(extra_checks);
 
 
1262
1263	spin_unlock_irqrestore(&gpio_lock, flags);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1264}
1265EXPORT_SYMBOL_GPL(gpio_free);
1266
1267/**
1268 * gpio_request_one - request a single GPIO with initial configuration
1269 * @gpio:	the GPIO number
1270 * @flags:	GPIO configuration as specified by GPIOF_*
1271 * @label:	a literal description string of this GPIO
1272 */
1273int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1274{
 
1275	int err;
1276
1277	err = gpio_request(gpio, label);
 
 
1278	if (err)
1279		return err;
1280
 
 
 
 
 
 
1281	if (flags & GPIOF_DIR_IN)
1282		err = gpio_direction_input(gpio);
1283	else
1284		err = gpio_direction_output(gpio,
1285				(flags & GPIOF_INIT_HIGH) ? 1 : 0);
1286
1287	if (err)
1288		gpio_free(gpio);
 
 
 
 
 
 
1289
 
 
 
 
1290	return err;
1291}
1292EXPORT_SYMBOL_GPL(gpio_request_one);
1293
1294/**
1295 * gpio_request_array - request multiple GPIOs in a single call
1296 * @array:	array of the 'struct gpio'
1297 * @num:	how many GPIOs in the array
1298 */
1299int gpio_request_array(const struct gpio *array, size_t num)
1300{
1301	int i, err;
1302
1303	for (i = 0; i < num; i++, array++) {
1304		err = gpio_request_one(array->gpio, array->flags, array->label);
1305		if (err)
1306			goto err_free;
1307	}
1308	return 0;
1309
1310err_free:
1311	while (i--)
1312		gpio_free((--array)->gpio);
1313	return err;
1314}
1315EXPORT_SYMBOL_GPL(gpio_request_array);
1316
1317/**
1318 * gpio_free_array - release multiple GPIOs in a single call
1319 * @array:	array of the 'struct gpio'
1320 * @num:	how many GPIOs in the array
1321 */
1322void gpio_free_array(const struct gpio *array, size_t num)
1323{
1324	while (num--)
1325		gpio_free((array++)->gpio);
1326}
1327EXPORT_SYMBOL_GPL(gpio_free_array);
1328
1329/**
1330 * gpiochip_is_requested - return string iff signal was requested
1331 * @chip: controller managing the signal
1332 * @offset: of signal within controller's 0..(ngpio - 1) range
1333 *
1334 * Returns NULL if the GPIO is not currently requested, else a string.
1335 * If debugfs support is enabled, the string returned is the label passed
1336 * to gpio_request(); otherwise it is a meaningless constant.
1337 *
1338 * This function is for use by GPIO controller drivers.  The label can
1339 * help with diagnostics, and knowing that the signal is used as a GPIO
1340 * can help avoid accidentally multiplexing it to another controller.
1341 */
1342const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1343{
1344	unsigned gpio = chip->base + offset;
1345
1346	if (!gpio_is_valid(gpio) || gpio_desc[gpio].chip != chip)
1347		return NULL;
1348	if (test_bit(FLAG_REQUESTED, &gpio_desc[gpio].flags) == 0)
 
 
 
1349		return NULL;
1350#ifdef CONFIG_DEBUG_FS
1351	return gpio_desc[gpio].label;
1352#else
1353	return "?";
1354#endif
1355}
1356EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1357
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1358
1359/* Drivers MUST set GPIO direction before making get/set calls.  In
1360 * some cases this is done in early boot, before IRQs are enabled.
1361 *
1362 * As a rule these aren't called more than once (except for drivers
1363 * using the open-drain emulation idiom) so these are natural places
1364 * to accumulate extra debugging checks.  Note that we can't (yet)
1365 * rely on gpio_request() having been called beforehand.
1366 */
1367
1368int gpio_direction_input(unsigned gpio)
 
 
 
 
 
 
 
 
 
1369{
1370	unsigned long		flags;
1371	struct gpio_chip	*chip;
1372	struct gpio_desc	*desc = &gpio_desc[gpio];
1373	int			status = -EINVAL;
 
1374
1375	spin_lock_irqsave(&gpio_lock, flags);
 
 
 
1376
1377	if (!gpio_is_valid(gpio))
1378		goto fail;
1379	chip = desc->chip;
1380	if (!chip || !chip->get || !chip->direction_input)
1381		goto fail;
1382	gpio -= chip->base;
1383	if (gpio >= chip->ngpio)
1384		goto fail;
1385	status = gpio_ensure_requested(desc, gpio);
 
 
 
 
1386	if (status < 0)
1387		goto fail;
1388
1389	/* now we know the gpio is valid and chip won't vanish */
1390
1391	spin_unlock_irqrestore(&gpio_lock, flags);
1392
1393	might_sleep_if(chip->can_sleep);
1394
 
1395	if (status) {
1396		status = chip->request(chip, gpio);
1397		if (status < 0) {
1398			pr_debug("GPIO-%d: chip request fail, %d\n",
1399				chip->base + gpio, status);
1400			/* and it's not available to anyone else ...
1401			 * gpio_request() is the fully clean solution.
1402			 */
1403			goto lose;
1404		}
1405	}
1406
1407	status = chip->direction_input(chip, gpio);
1408	if (status == 0)
1409		clear_bit(FLAG_IS_OUT, &desc->flags);
1410
1411	trace_gpio_direction(chip->base + gpio, 1, status);
1412lose:
1413	return status;
1414fail:
1415	spin_unlock_irqrestore(&gpio_lock, flags);
1416	if (status)
1417		pr_debug("%s: gpio-%d status %d\n",
1418			__func__, gpio, status);
1419	return status;
1420}
1421EXPORT_SYMBOL_GPL(gpio_direction_input);
1422
1423int gpio_direction_output(unsigned gpio, int value)
1424{
1425	unsigned long		flags;
1426	struct gpio_chip	*chip;
1427	struct gpio_desc	*desc = &gpio_desc[gpio];
1428	int			status = -EINVAL;
 
1429
1430	spin_lock_irqsave(&gpio_lock, flags);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1431
1432	if (!gpio_is_valid(gpio))
1433		goto fail;
1434	chip = desc->chip;
1435	if (!chip || !chip->set || !chip->direction_output)
1436		goto fail;
1437	gpio -= chip->base;
1438	if (gpio >= chip->ngpio)
1439		goto fail;
1440	status = gpio_ensure_requested(desc, gpio);
 
 
 
 
1441	if (status < 0)
1442		goto fail;
1443
1444	/* now we know the gpio is valid and chip won't vanish */
1445
1446	spin_unlock_irqrestore(&gpio_lock, flags);
1447
1448	might_sleep_if(chip->can_sleep);
1449
 
1450	if (status) {
1451		status = chip->request(chip, gpio);
1452		if (status < 0) {
1453			pr_debug("GPIO-%d: chip request fail, %d\n",
1454				chip->base + gpio, status);
1455			/* and it's not available to anyone else ...
1456			 * gpio_request() is the fully clean solution.
1457			 */
1458			goto lose;
1459		}
1460	}
1461
1462	status = chip->direction_output(chip, gpio, value);
1463	if (status == 0)
1464		set_bit(FLAG_IS_OUT, &desc->flags);
1465	trace_gpio_value(chip->base + gpio, 0, value);
1466	trace_gpio_direction(chip->base + gpio, 0, status);
1467lose:
1468	return status;
1469fail:
1470	spin_unlock_irqrestore(&gpio_lock, flags);
1471	if (status)
1472		pr_debug("%s: gpio-%d status %d\n",
1473			__func__, gpio, status);
1474	return status;
1475}
1476EXPORT_SYMBOL_GPL(gpio_direction_output);
1477
1478/**
1479 * gpio_set_debounce - sets @debounce time for a @gpio
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1480 * @gpio: the gpio to set debounce time
1481 * @debounce: debounce time is microseconds
 
 
 
1482 */
1483int gpio_set_debounce(unsigned gpio, unsigned debounce)
1484{
1485	unsigned long		flags;
1486	struct gpio_chip	*chip;
1487	struct gpio_desc	*desc = &gpio_desc[gpio];
1488	int			status = -EINVAL;
 
1489
1490	spin_lock_irqsave(&gpio_lock, flags);
 
 
 
1491
1492	if (!gpio_is_valid(gpio))
1493		goto fail;
1494	chip = desc->chip;
1495	if (!chip || !chip->set || !chip->set_debounce)
1496		goto fail;
1497	gpio -= chip->base;
1498	if (gpio >= chip->ngpio)
1499		goto fail;
1500	status = gpio_ensure_requested(desc, gpio);
 
 
 
 
1501	if (status < 0)
1502		goto fail;
1503
1504	/* now we know the gpio is valid and chip won't vanish */
1505
1506	spin_unlock_irqrestore(&gpio_lock, flags);
1507
1508	might_sleep_if(chip->can_sleep);
1509
1510	return chip->set_debounce(chip, gpio, debounce);
 
1511
1512fail:
1513	spin_unlock_irqrestore(&gpio_lock, flags);
1514	if (status)
1515		pr_debug("%s: gpio-%d status %d\n",
1516			__func__, gpio, status);
1517
1518	return status;
1519}
1520EXPORT_SYMBOL_GPL(gpio_set_debounce);
 
 
 
 
 
 
 
 
 
 
 
 
1521
1522/* I/O calls are only valid after configuration completed; the relevant
1523 * "is this a valid GPIO" error checks should already have been done.
1524 *
1525 * "Get" operations are often inlinable as reading a pin value register,
1526 * and masking the relevant bit in that register.
1527 *
1528 * When "set" operations are inlinable, they involve writing that mask to
1529 * one register to set a low value, or a different register to set it high.
1530 * Otherwise locking is needed, so there may be little value to inlining.
1531 *
1532 *------------------------------------------------------------------------
1533 *
1534 * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1535 * have requested the GPIO.  That can include implicit requesting by
1536 * a direction setting call.  Marking a gpio as requested locks its chip
1537 * in memory, guaranteeing that these table lookups need no more locking
1538 * and that gpiochip_remove() will fail.
1539 *
1540 * REVISIT when debugging, consider adding some instrumentation to ensure
1541 * that the GPIO was actually requested.
1542 */
1543
 
 
 
 
 
 
 
 
 
 
 
 
 
1544/**
1545 * __gpio_get_value() - return a gpio's value
1546 * @gpio: gpio whose value will be returned
1547 * Context: any
1548 *
1549 * This is used directly or indirectly to implement gpio_get_value().
1550 * It returns the zero or nonzero value provided by the associated
1551 * gpio_chip.get() method; or zero if no such method is provided.
 
1552 */
1553int __gpio_get_value(unsigned gpio)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1554{
1555	struct gpio_chip	*chip;
1556	int value;
 
 
 
 
 
 
 
 
1557
1558	chip = gpio_to_chip(gpio);
1559	WARN_ON(chip->can_sleep);
1560	value = chip->get ? chip->get(chip, gpio - chip->base) : 0;
1561	trace_gpio_value(gpio, 1, value);
1562	return value;
1563}
1564EXPORT_SYMBOL_GPL(__gpio_get_value);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1565
1566/**
1567 * __gpio_set_value() - assign a gpio's value
1568 * @gpio: gpio whose value will be assigned
1569 * @value: value to assign
1570 * Context: any
1571 *
1572 * This is used directly or indirectly to implement gpio_set_value().
1573 * It invokes the associated gpio_chip.set() method.
 
 
 
1574 */
1575void __gpio_set_value(unsigned gpio, int value)
1576{
1577	struct gpio_chip	*chip;
 
 
 
 
 
 
 
 
1578
1579	chip = gpio_to_chip(gpio);
1580	WARN_ON(chip->can_sleep);
1581	trace_gpio_value(gpio, 0, value);
1582	chip->set(chip, gpio - chip->base, value);
 
 
 
 
 
 
1583}
1584EXPORT_SYMBOL_GPL(__gpio_set_value);
1585
1586/**
1587 * __gpio_cansleep() - report whether gpio value access will sleep
1588 * @gpio: gpio in question
1589 * Context: any
1590 *
1591 * This is used directly or indirectly to implement gpio_cansleep().  It
1592 * returns nonzero if access reading or writing the GPIO value can sleep.
1593 */
1594int __gpio_cansleep(unsigned gpio)
1595{
1596	struct gpio_chip	*chip;
 
1597
1598	/* only call this on GPIOs that are valid! */
1599	chip = gpio_to_chip(gpio);
1600
1601	return chip->can_sleep;
 
1602}
1603EXPORT_SYMBOL_GPL(__gpio_cansleep);
1604
1605/**
1606 * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1607 * @gpio: gpio whose IRQ will be returned (already requested)
1608 * Context: any
1609 *
1610 * This is used directly or indirectly to implement gpio_to_irq().
1611 * It returns the number of the IRQ signaled by this (input) GPIO,
1612 * or a negative errno.
1613 */
1614int __gpio_to_irq(unsigned gpio)
1615{
1616	struct gpio_chip	*chip;
 
 
 
 
 
 
 
 
1617
1618	chip = gpio_to_chip(gpio);
1619	return chip->to_irq ? chip->to_irq(chip, gpio - chip->base) : -ENXIO;
1620}
1621EXPORT_SYMBOL_GPL(__gpio_to_irq);
1622
 
 
 
 
 
1623
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1624
1625/* There's no value in making it easy to inline GPIO calls that may sleep.
1626 * Common examples include ones connected to I2C or SPI chips.
 
 
 
 
 
 
1627 */
 
 
 
 
 
 
 
 
1628
1629int gpio_get_value_cansleep(unsigned gpio)
 
 
 
 
 
 
 
 
 
1630{
1631	struct gpio_chip	*chip;
1632	int value;
1633
1634	might_sleep_if(extra_checks);
1635	chip = gpio_to_chip(gpio);
1636	value = chip->get ? chip->get(chip, gpio - chip->base) : 0;
1637	trace_gpio_value(gpio, 1, value);
 
 
 
 
1638	return value;
1639}
1640EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
1641
1642void gpio_set_value_cansleep(unsigned gpio, int value)
 
 
 
 
 
 
 
 
 
 
1643{
1644	struct gpio_chip	*chip;
 
 
 
 
 
1645
 
 
 
 
 
 
 
 
 
 
 
 
1646	might_sleep_if(extra_checks);
1647	chip = gpio_to_chip(gpio);
1648	trace_gpio_value(gpio, 0, value);
1649	chip->set(chip, gpio - chip->base, value);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1650}
1651EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
1652
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1653
1654#ifdef CONFIG_DEBUG_FS
1655
1656static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
1657{
1658	unsigned		i;
1659	unsigned		gpio = chip->base;
1660	struct gpio_desc	*gdesc = &gpio_desc[gpio];
1661	int			is_out;
 
1662
1663	for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
1664		if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
1665			continue;
1666
 
1667		is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
1668		seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
 
1669			gpio, gdesc->label,
1670			is_out ? "out" : "in ",
1671			chip->get
1672				? (chip->get(chip, i) ? "hi" : "lo")
1673				: "?  ");
 
1674		seq_printf(s, "\n");
1675	}
1676}
1677
1678static int gpiolib_show(struct seq_file *s, void *unused)
1679{
1680	struct gpio_chip	*chip = NULL;
1681	unsigned		gpio;
1682	int			started = 0;
1683
1684	/* REVISIT this isn't locked against gpio_chip removal ... */
1685
1686	for (gpio = 0; gpio_is_valid(gpio); gpio++) {
1687		struct device *dev;
 
 
 
 
 
1688
1689		if (chip == gpio_desc[gpio].chip)
1690			continue;
1691		chip = gpio_desc[gpio].chip;
1692		if (!chip)
1693			continue;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1694
1695		seq_printf(s, "%sGPIOs %d-%d",
1696				started ? "\n" : "",
1697				chip->base, chip->base + chip->ngpio - 1);
1698		dev = chip->dev;
1699		if (dev)
1700			seq_printf(s, ", %s/%s",
1701				dev->bus ? dev->bus->name : "no-bus",
1702				dev_name(dev));
1703		if (chip->label)
1704			seq_printf(s, ", %s", chip->label);
1705		if (chip->can_sleep)
1706			seq_printf(s, ", can sleep");
1707		seq_printf(s, ":\n");
1708
1709		started = 1;
1710		if (chip->dbg_show)
1711			chip->dbg_show(s, chip);
1712		else
1713			gpiolib_dbg_show(s, chip);
1714	}
1715	return 0;
1716}
1717
 
 
 
 
 
 
 
1718static int gpiolib_open(struct inode *inode, struct file *file)
1719{
1720	return single_open(file, gpiolib_show, NULL);
1721}
1722
1723static const struct file_operations gpiolib_operations = {
 
1724	.open		= gpiolib_open,
1725	.read		= seq_read,
1726	.llseek		= seq_lseek,
1727	.release	= single_release,
1728};
1729
1730static int __init gpiolib_debugfs_init(void)
1731{
1732	/* /sys/kernel/debug/gpio */
1733	(void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
1734				NULL, NULL, &gpiolib_operations);
1735	return 0;
1736}
1737subsys_initcall(gpiolib_debugfs_init);
1738
1739#endif	/* DEBUG_FS */