blob: 42fb2fd24c0c03cd20b21dab5038fde07d3be30c [file] [log] [blame]
David Brownelld2876d02008-02-04 22:28:20 -08001#include <linux/kernel.h>
2#include <linux/module.h>
3#include <linux/irq.h>
4#include <linux/spinlock.h>
David Brownelld8f388d2008-07-25 01:46:07 -07005#include <linux/device.h>
6#include <linux/err.h>
7#include <linux/debugfs.h>
8#include <linux/seq_file.h>
9#include <linux/gpio.h>
David Brownelld2876d02008-02-04 22:28:20 -080010
11
12/* Optional implementation infrastructure for GPIO interfaces.
13 *
14 * Platforms may want to use this if they tend to use very many GPIOs
15 * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
16 *
17 * When kernel footprint or instruction count is an issue, simpler
18 * implementations may be preferred. The GPIO programming interface
19 * allows for inlining speed-critical get/set operations for common
20 * cases, so that access to SOC-integrated GPIOs can sometimes cost
21 * only an instruction or two per bit.
22 */
23
24
25/* When debugging, extend minimal trust to callers and platform code.
26 * Also emit diagnostic messages that may help initial bringup, when
27 * board setup or driver bugs are most common.
28 *
29 * Otherwise, minimize overhead in what may be bitbanging codepaths.
30 */
31#ifdef DEBUG
32#define extra_checks 1
33#else
34#define extra_checks 0
35#endif
36
37/* gpio_lock prevents conflicts during gpio_desc[] table updates.
38 * While any GPIO is requested, its gpio_chip is not removable;
39 * each GPIO's "requested" flag serves as a lock and refcount.
40 */
41static DEFINE_SPINLOCK(gpio_lock);
42
43struct gpio_desc {
44 struct gpio_chip *chip;
45 unsigned long flags;
46/* flag symbols are bit numbers */
47#define FLAG_REQUESTED 0
48#define FLAG_IS_OUT 1
Anton Vorontsov169b6a72008-04-28 02:14:47 -070049#define FLAG_RESERVED 2
David Brownelld8f388d2008-07-25 01:46:07 -070050#define FLAG_EXPORT 3 /* protected by sysfs_lock */
51#define FLAG_SYSFS 4 /* exported via /sys/class/gpio/control */
David Brownelld2876d02008-02-04 22:28:20 -080052
53#ifdef CONFIG_DEBUG_FS
54 const char *label;
55#endif
56};
57static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
58
59static inline void desc_set_label(struct gpio_desc *d, const char *label)
60{
61#ifdef CONFIG_DEBUG_FS
62 d->label = label;
63#endif
64}
65
66/* Warn when drivers omit gpio_request() calls -- legal but ill-advised
67 * when setting direction, and otherwise illegal. Until board setup code
68 * and drivers use explicit requests everywhere (which won't happen when
69 * those calls have no teeth) we can't avoid autorequesting. This nag
David Brownell35e8bb52008-10-15 22:03:16 -070070 * message should motivate switching to explicit requests... so should
71 * the weaker cleanup after faults, compared to gpio_request().
David Brownelld2876d02008-02-04 22:28:20 -080072 */
David Brownell35e8bb52008-10-15 22:03:16 -070073static int gpio_ensure_requested(struct gpio_desc *desc, unsigned offset)
David Brownelld2876d02008-02-04 22:28:20 -080074{
75 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
David Brownell35e8bb52008-10-15 22:03:16 -070076 struct gpio_chip *chip = desc->chip;
77 int gpio = chip->base + offset;
78
79 if (!try_module_get(chip->owner)) {
80 pr_err("GPIO-%d: module can't be gotten \n", gpio);
81 clear_bit(FLAG_REQUESTED, &desc->flags);
82 /* lose */
83 return -EIO;
84 }
85 pr_warning("GPIO-%d autorequested\n", gpio);
David Brownelld2876d02008-02-04 22:28:20 -080086 desc_set_label(desc, "[auto]");
David Brownell35e8bb52008-10-15 22:03:16 -070087 /* caller must chip->request() w/o spinlock */
88 if (chip->request)
89 return 1;
David Brownelld2876d02008-02-04 22:28:20 -080090 }
David Brownell35e8bb52008-10-15 22:03:16 -070091 return 0;
David Brownelld2876d02008-02-04 22:28:20 -080092}
93
94/* caller holds gpio_lock *OR* gpio is marked as requested */
95static inline struct gpio_chip *gpio_to_chip(unsigned gpio)
96{
97 return gpio_desc[gpio].chip;
98}
99
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700100/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
101static int gpiochip_find_base(int ngpio)
102{
103 int i;
104 int spare = 0;
105 int base = -ENOSPC;
106
107 for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) {
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700108 struct gpio_desc *desc = &gpio_desc[i];
109 struct gpio_chip *chip = desc->chip;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700110
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700111 if (!chip && !test_bit(FLAG_RESERVED, &desc->flags)) {
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700112 spare++;
113 if (spare == ngpio) {
114 base = i;
115 break;
116 }
117 } else {
118 spare = 0;
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700119 if (chip)
120 i -= chip->ngpio - 1;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700121 }
122 }
123
124 if (gpio_is_valid(base))
125 pr_debug("%s: found new base at %d\n", __func__, base);
126 return base;
127}
128
David Brownelld2876d02008-02-04 22:28:20 -0800129/**
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700130 * gpiochip_reserve() - reserve range of gpios to use with platform code only
131 * @start: starting gpio number
132 * @ngpio: number of gpios to reserve
133 * Context: platform init, potentially before irqs or kmalloc will work
134 *
135 * Returns a negative errno if any gpio within the range is already reserved
136 * or registered, else returns zero as a success code. Use this function
137 * to mark a range of gpios as unavailable for dynamic gpio number allocation,
138 * for example because its driver support is not yet loaded.
139 */
140int __init gpiochip_reserve(int start, int ngpio)
141{
142 int ret = 0;
143 unsigned long flags;
144 int i;
145
Trent Piephobff5fda2008-05-23 13:04:44 -0700146 if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio - 1))
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700147 return -EINVAL;
148
149 spin_lock_irqsave(&gpio_lock, flags);
150
151 for (i = start; i < start + ngpio; i++) {
152 struct gpio_desc *desc = &gpio_desc[i];
153
154 if (desc->chip || test_bit(FLAG_RESERVED, &desc->flags)) {
155 ret = -EBUSY;
156 goto err;
157 }
158
159 set_bit(FLAG_RESERVED, &desc->flags);
160 }
161
162 pr_debug("%s: reserved gpios from %d to %d\n",
163 __func__, start, start + ngpio - 1);
164err:
165 spin_unlock_irqrestore(&gpio_lock, flags);
166
167 return ret;
168}
169
David Brownelld8f388d2008-07-25 01:46:07 -0700170#ifdef CONFIG_GPIO_SYSFS
171
172/* lock protects against unexport_gpio() being called while
173 * sysfs files are active.
174 */
175static DEFINE_MUTEX(sysfs_lock);
176
177/*
178 * /sys/class/gpio/gpioN... only for GPIOs that are exported
179 * /direction
180 * * MAY BE OMITTED if kernel won't allow direction changes
181 * * is read/write as "in" or "out"
182 * * may also be written as "high" or "low", initializing
183 * output value as specified ("out" implies "low")
184 * /value
185 * * always readable, subject to hardware behavior
186 * * may be writable, as zero/nonzero
187 *
188 * REVISIT there will likely be an attribute for configuring async
189 * notifications, e.g. to specify polling interval or IRQ trigger type
190 * that would for example trigger a poll() on the "value".
191 */
192
193static ssize_t gpio_direction_show(struct device *dev,
194 struct device_attribute *attr, char *buf)
195{
196 const struct gpio_desc *desc = dev_get_drvdata(dev);
197 ssize_t status;
198
199 mutex_lock(&sysfs_lock);
200
201 if (!test_bit(FLAG_EXPORT, &desc->flags))
202 status = -EIO;
203 else
204 status = sprintf(buf, "%s\n",
205 test_bit(FLAG_IS_OUT, &desc->flags)
206 ? "out" : "in");
207
208 mutex_unlock(&sysfs_lock);
209 return status;
210}
211
212static ssize_t gpio_direction_store(struct device *dev,
213 struct device_attribute *attr, const char *buf, size_t size)
214{
215 const struct gpio_desc *desc = dev_get_drvdata(dev);
216 unsigned gpio = desc - gpio_desc;
217 ssize_t status;
218
219 mutex_lock(&sysfs_lock);
220
221 if (!test_bit(FLAG_EXPORT, &desc->flags))
222 status = -EIO;
223 else if (sysfs_streq(buf, "high"))
224 status = gpio_direction_output(gpio, 1);
225 else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
226 status = gpio_direction_output(gpio, 0);
227 else if (sysfs_streq(buf, "in"))
228 status = gpio_direction_input(gpio);
229 else
230 status = -EINVAL;
231
232 mutex_unlock(&sysfs_lock);
233 return status ? : size;
234}
235
236static const DEVICE_ATTR(direction, 0644,
237 gpio_direction_show, gpio_direction_store);
238
239static ssize_t gpio_value_show(struct device *dev,
240 struct device_attribute *attr, char *buf)
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
Steven A. Falcoe3274e92008-10-18 20:27:48 -0700251 status = sprintf(buf, "%d\n", !!gpio_get_value_cansleep(gpio));
David Brownelld8f388d2008-07-25 01:46:07 -0700252
253 mutex_unlock(&sysfs_lock);
254 return status;
255}
256
257static ssize_t gpio_value_store(struct device *dev,
258 struct device_attribute *attr, const char *buf, size_t size)
259{
260 const struct gpio_desc *desc = dev_get_drvdata(dev);
261 unsigned gpio = desc - gpio_desc;
262 ssize_t status;
263
264 mutex_lock(&sysfs_lock);
265
266 if (!test_bit(FLAG_EXPORT, &desc->flags))
267 status = -EIO;
268 else if (!test_bit(FLAG_IS_OUT, &desc->flags))
269 status = -EPERM;
270 else {
271 long value;
272
273 status = strict_strtol(buf, 0, &value);
274 if (status == 0) {
275 gpio_set_value_cansleep(gpio, value != 0);
276 status = size;
277 }
278 }
279
280 mutex_unlock(&sysfs_lock);
281 return status;
282}
283
284static /*const*/ DEVICE_ATTR(value, 0644,
285 gpio_value_show, gpio_value_store);
286
287static const struct attribute *gpio_attrs[] = {
288 &dev_attr_direction.attr,
289 &dev_attr_value.attr,
290 NULL,
291};
292
293static const struct attribute_group gpio_attr_group = {
294 .attrs = (struct attribute **) gpio_attrs,
295};
296
297/*
298 * /sys/class/gpio/gpiochipN/
299 * /base ... matching gpio_chip.base (N)
300 * /label ... matching gpio_chip.label
301 * /ngpio ... matching gpio_chip.ngpio
302 */
303
304static ssize_t chip_base_show(struct device *dev,
305 struct device_attribute *attr, char *buf)
306{
307 const struct gpio_chip *chip = dev_get_drvdata(dev);
308
309 return sprintf(buf, "%d\n", chip->base);
310}
311static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
312
313static ssize_t chip_label_show(struct device *dev,
314 struct device_attribute *attr, char *buf)
315{
316 const struct gpio_chip *chip = dev_get_drvdata(dev);
317
318 return sprintf(buf, "%s\n", chip->label ? : "");
319}
320static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
321
322static ssize_t chip_ngpio_show(struct device *dev,
323 struct device_attribute *attr, char *buf)
324{
325 const struct gpio_chip *chip = dev_get_drvdata(dev);
326
327 return sprintf(buf, "%u\n", chip->ngpio);
328}
329static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
330
331static const struct attribute *gpiochip_attrs[] = {
332 &dev_attr_base.attr,
333 &dev_attr_label.attr,
334 &dev_attr_ngpio.attr,
335 NULL,
336};
337
338static const struct attribute_group gpiochip_attr_group = {
339 .attrs = (struct attribute **) gpiochip_attrs,
340};
341
342/*
343 * /sys/class/gpio/export ... write-only
344 * integer N ... number of GPIO to export (full access)
345 * /sys/class/gpio/unexport ... write-only
346 * integer N ... number of GPIO to unexport
347 */
348static ssize_t export_store(struct class *class, const char *buf, size_t len)
349{
350 long gpio;
351 int status;
352
353 status = strict_strtol(buf, 0, &gpio);
354 if (status < 0)
355 goto done;
356
357 /* No extra locking here; FLAG_SYSFS just signifies that the
358 * request and export were done by on behalf of userspace, so
359 * they may be undone on its behalf too.
360 */
361
362 status = gpio_request(gpio, "sysfs");
363 if (status < 0)
364 goto done;
365
366 status = gpio_export(gpio, true);
367 if (status < 0)
368 gpio_free(gpio);
369 else
370 set_bit(FLAG_SYSFS, &gpio_desc[gpio].flags);
371
372done:
373 if (status)
374 pr_debug("%s: status %d\n", __func__, status);
375 return status ? : len;
376}
377
378static ssize_t unexport_store(struct class *class, const char *buf, size_t len)
379{
380 long gpio;
381 int status;
382
383 status = strict_strtol(buf, 0, &gpio);
384 if (status < 0)
385 goto done;
386
387 status = -EINVAL;
388
389 /* reject bogus commands (gpio_unexport ignores them) */
390 if (!gpio_is_valid(gpio))
391 goto done;
392
393 /* No extra locking here; FLAG_SYSFS just signifies that the
394 * request and export were done by on behalf of userspace, so
395 * they may be undone on its behalf too.
396 */
397 if (test_and_clear_bit(FLAG_SYSFS, &gpio_desc[gpio].flags)) {
398 status = 0;
399 gpio_free(gpio);
400 }
401done:
402 if (status)
403 pr_debug("%s: status %d\n", __func__, status);
404 return status ? : len;
405}
406
407static struct class_attribute gpio_class_attrs[] = {
408 __ATTR(export, 0200, NULL, export_store),
409 __ATTR(unexport, 0200, NULL, unexport_store),
410 __ATTR_NULL,
411};
412
413static struct class gpio_class = {
414 .name = "gpio",
415 .owner = THIS_MODULE,
416
417 .class_attrs = gpio_class_attrs,
418};
419
420
421/**
422 * gpio_export - export a GPIO through sysfs
423 * @gpio: gpio to make available, already requested
424 * @direction_may_change: true if userspace may change gpio direction
425 * Context: arch_initcall or later
426 *
427 * When drivers want to make a GPIO accessible to userspace after they
428 * have requested it -- perhaps while debugging, or as part of their
429 * public interface -- they may use this routine. If the GPIO can
430 * change direction (some can't) and the caller allows it, userspace
431 * will see "direction" sysfs attribute which may be used to change
432 * the gpio's direction. A "value" attribute will always be provided.
433 *
434 * Returns zero on success, else an error.
435 */
436int gpio_export(unsigned gpio, bool direction_may_change)
437{
438 unsigned long flags;
439 struct gpio_desc *desc;
440 int status = -EINVAL;
441
442 /* can't export until sysfs is available ... */
443 if (!gpio_class.p) {
444 pr_debug("%s: called too early!\n", __func__);
445 return -ENOENT;
446 }
447
448 if (!gpio_is_valid(gpio))
449 goto done;
450
451 mutex_lock(&sysfs_lock);
452
453 spin_lock_irqsave(&gpio_lock, flags);
454 desc = &gpio_desc[gpio];
455 if (test_bit(FLAG_REQUESTED, &desc->flags)
456 && !test_bit(FLAG_EXPORT, &desc->flags)) {
457 status = 0;
458 if (!desc->chip->direction_input
459 || !desc->chip->direction_output)
460 direction_may_change = false;
461 }
462 spin_unlock_irqrestore(&gpio_lock, flags);
463
464 if (status == 0) {
465 struct device *dev;
466
467 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
468 desc, "gpio%d", gpio);
469 if (dev) {
470 if (direction_may_change)
471 status = sysfs_create_group(&dev->kobj,
472 &gpio_attr_group);
473 else
474 status = device_create_file(dev,
475 &dev_attr_value);
476 if (status != 0)
477 device_unregister(dev);
478 } else
479 status = -ENODEV;
480 if (status == 0)
481 set_bit(FLAG_EXPORT, &desc->flags);
482 }
483
484 mutex_unlock(&sysfs_lock);
485
486done:
487 if (status)
488 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
489
490 return status;
491}
492EXPORT_SYMBOL_GPL(gpio_export);
493
494static int match_export(struct device *dev, void *data)
495{
496 return dev_get_drvdata(dev) == data;
497}
498
499/**
500 * gpio_unexport - reverse effect of gpio_export()
501 * @gpio: gpio to make unavailable
502 *
503 * This is implicit on gpio_free().
504 */
505void gpio_unexport(unsigned gpio)
506{
507 struct gpio_desc *desc;
508 int status = -EINVAL;
509
510 if (!gpio_is_valid(gpio))
511 goto done;
512
513 mutex_lock(&sysfs_lock);
514
515 desc = &gpio_desc[gpio];
516 if (test_bit(FLAG_EXPORT, &desc->flags)) {
517 struct device *dev = NULL;
518
519 dev = class_find_device(&gpio_class, NULL, desc, match_export);
520 if (dev) {
521 clear_bit(FLAG_EXPORT, &desc->flags);
522 put_device(dev);
523 device_unregister(dev);
524 status = 0;
525 } else
526 status = -ENODEV;
527 }
528
529 mutex_unlock(&sysfs_lock);
530done:
531 if (status)
532 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
533}
534EXPORT_SYMBOL_GPL(gpio_unexport);
535
536static int gpiochip_export(struct gpio_chip *chip)
537{
538 int status;
539 struct device *dev;
540
541 /* Many systems register gpio chips for SOC support very early,
542 * before driver model support is available. In those cases we
543 * export this later, in gpiolib_sysfs_init() ... here we just
544 * verify that _some_ field of gpio_class got initialized.
545 */
546 if (!gpio_class.p)
547 return 0;
548
549 /* use chip->base for the ID; it's already known to be unique */
550 mutex_lock(&sysfs_lock);
551 dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
552 "gpiochip%d", chip->base);
553 if (dev) {
554 status = sysfs_create_group(&dev->kobj,
555 &gpiochip_attr_group);
556 } else
557 status = -ENODEV;
558 chip->exported = (status == 0);
559 mutex_unlock(&sysfs_lock);
560
561 if (status) {
562 unsigned long flags;
563 unsigned gpio;
564
565 spin_lock_irqsave(&gpio_lock, flags);
566 gpio = chip->base;
567 while (gpio_desc[gpio].chip == chip)
568 gpio_desc[gpio++].chip = NULL;
569 spin_unlock_irqrestore(&gpio_lock, flags);
570
571 pr_debug("%s: chip %s status %d\n", __func__,
572 chip->label, status);
573 }
574
575 return status;
576}
577
578static void gpiochip_unexport(struct gpio_chip *chip)
579{
580 int status;
581 struct device *dev;
582
583 mutex_lock(&sysfs_lock);
584 dev = class_find_device(&gpio_class, NULL, chip, match_export);
585 if (dev) {
586 put_device(dev);
587 device_unregister(dev);
588 chip->exported = 0;
589 status = 0;
590 } else
591 status = -ENODEV;
592 mutex_unlock(&sysfs_lock);
593
594 if (status)
595 pr_debug("%s: chip %s status %d\n", __func__,
596 chip->label, status);
597}
598
599static int __init gpiolib_sysfs_init(void)
600{
601 int status;
602 unsigned long flags;
603 unsigned gpio;
604
605 status = class_register(&gpio_class);
606 if (status < 0)
607 return status;
608
609 /* Scan and register the gpio_chips which registered very
610 * early (e.g. before the class_register above was called).
611 *
612 * We run before arch_initcall() so chip->dev nodes can have
613 * registered, and so arch_initcall() can always gpio_export().
614 */
615 spin_lock_irqsave(&gpio_lock, flags);
616 for (gpio = 0; gpio < ARCH_NR_GPIOS; gpio++) {
617 struct gpio_chip *chip;
618
619 chip = gpio_desc[gpio].chip;
620 if (!chip || chip->exported)
621 continue;
622
623 spin_unlock_irqrestore(&gpio_lock, flags);
624 status = gpiochip_export(chip);
625 spin_lock_irqsave(&gpio_lock, flags);
626 }
627 spin_unlock_irqrestore(&gpio_lock, flags);
628
629
630 return status;
631}
632postcore_initcall(gpiolib_sysfs_init);
633
634#else
635static inline int gpiochip_export(struct gpio_chip *chip)
636{
637 return 0;
638}
639
640static inline void gpiochip_unexport(struct gpio_chip *chip)
641{
642}
643
644#endif /* CONFIG_GPIO_SYSFS */
645
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700646/**
David Brownelld2876d02008-02-04 22:28:20 -0800647 * gpiochip_add() - register a gpio_chip
648 * @chip: the chip to register, with chip->base initialized
649 * Context: potentially before irqs or kmalloc will work
650 *
651 * Returns a negative errno if the chip can't be registered, such as
652 * because the chip->base is invalid or already associated with a
653 * different chip. Otherwise it returns zero as a success code.
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700654 *
David Brownelld8f388d2008-07-25 01:46:07 -0700655 * When gpiochip_add() is called very early during boot, so that GPIOs
656 * can be freely used, the chip->dev device must be registered before
657 * the gpio framework's arch_initcall(). Otherwise sysfs initialization
658 * for GPIOs will fail rudely.
659 *
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700660 * If chip->base is negative, this requests dynamic assignment of
661 * a range of valid GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -0800662 */
663int gpiochip_add(struct gpio_chip *chip)
664{
665 unsigned long flags;
666 int status = 0;
667 unsigned id;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700668 int base = chip->base;
David Brownelld2876d02008-02-04 22:28:20 -0800669
Trent Piephobff5fda2008-05-23 13:04:44 -0700670 if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700671 && base >= 0) {
David Brownelld2876d02008-02-04 22:28:20 -0800672 status = -EINVAL;
673 goto fail;
674 }
675
676 spin_lock_irqsave(&gpio_lock, flags);
677
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700678 if (base < 0) {
679 base = gpiochip_find_base(chip->ngpio);
680 if (base < 0) {
681 status = base;
David Brownelld8f388d2008-07-25 01:46:07 -0700682 goto unlock;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700683 }
684 chip->base = base;
685 }
686
David Brownelld2876d02008-02-04 22:28:20 -0800687 /* these GPIO numbers must not be managed by another gpio_chip */
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700688 for (id = base; id < base + chip->ngpio; id++) {
David Brownelld2876d02008-02-04 22:28:20 -0800689 if (gpio_desc[id].chip != NULL) {
690 status = -EBUSY;
691 break;
692 }
693 }
694 if (status == 0) {
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700695 for (id = base; id < base + chip->ngpio; id++) {
David Brownelld2876d02008-02-04 22:28:20 -0800696 gpio_desc[id].chip = chip;
David Brownelld8f388d2008-07-25 01:46:07 -0700697
698 /* REVISIT: most hardware initializes GPIOs as
699 * inputs (often with pullups enabled) so power
700 * usage is minimized. Linux code should set the
701 * gpio direction first thing; but until it does,
702 * we may expose the wrong direction in sysfs.
703 */
704 gpio_desc[id].flags = !chip->direction_input
705 ? (1 << FLAG_IS_OUT)
706 : 0;
David Brownelld2876d02008-02-04 22:28:20 -0800707 }
708 }
709
David Brownelld8f388d2008-07-25 01:46:07 -0700710unlock:
David Brownelld2876d02008-02-04 22:28:20 -0800711 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownelld8f388d2008-07-25 01:46:07 -0700712 if (status == 0)
713 status = gpiochip_export(chip);
David Brownelld2876d02008-02-04 22:28:20 -0800714fail:
715 /* failures here can mean systems won't boot... */
716 if (status)
717 pr_err("gpiochip_add: gpios %d..%d (%s) not registered\n",
Trent Piephobff5fda2008-05-23 13:04:44 -0700718 chip->base, chip->base + chip->ngpio - 1,
David Brownelld2876d02008-02-04 22:28:20 -0800719 chip->label ? : "generic");
720 return status;
721}
722EXPORT_SYMBOL_GPL(gpiochip_add);
723
724/**
725 * gpiochip_remove() - unregister a gpio_chip
726 * @chip: the chip to unregister
727 *
728 * A gpio_chip with any GPIOs still requested may not be removed.
729 */
730int gpiochip_remove(struct gpio_chip *chip)
731{
732 unsigned long flags;
733 int status = 0;
734 unsigned id;
735
736 spin_lock_irqsave(&gpio_lock, flags);
737
738 for (id = chip->base; id < chip->base + chip->ngpio; id++) {
739 if (test_bit(FLAG_REQUESTED, &gpio_desc[id].flags)) {
740 status = -EBUSY;
741 break;
742 }
743 }
744 if (status == 0) {
745 for (id = chip->base; id < chip->base + chip->ngpio; id++)
746 gpio_desc[id].chip = NULL;
747 }
748
749 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownelld8f388d2008-07-25 01:46:07 -0700750
751 if (status == 0)
752 gpiochip_unexport(chip);
753
David Brownelld2876d02008-02-04 22:28:20 -0800754 return status;
755}
756EXPORT_SYMBOL_GPL(gpiochip_remove);
757
758
759/* These "optional" allocation calls help prevent drivers from stomping
760 * on each other, and help provide better diagnostics in debugfs.
761 * They're called even less than the "set direction" calls.
762 */
763int gpio_request(unsigned gpio, const char *label)
764{
765 struct gpio_desc *desc;
David Brownell35e8bb52008-10-15 22:03:16 -0700766 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -0800767 int status = -EINVAL;
768 unsigned long flags;
769
770 spin_lock_irqsave(&gpio_lock, flags);
771
Guennadi Liakhovetskie6de1802008-04-28 02:14:46 -0700772 if (!gpio_is_valid(gpio))
David Brownelld2876d02008-02-04 22:28:20 -0800773 goto done;
774 desc = &gpio_desc[gpio];
David Brownell35e8bb52008-10-15 22:03:16 -0700775 chip = desc->chip;
776 if (chip == NULL)
David Brownelld2876d02008-02-04 22:28:20 -0800777 goto done;
778
David Brownell35e8bb52008-10-15 22:03:16 -0700779 if (!try_module_get(chip->owner))
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -0700780 goto done;
781
David Brownelld2876d02008-02-04 22:28:20 -0800782 /* NOTE: gpio_request() can be called in early boot,
David Brownell35e8bb52008-10-15 22:03:16 -0700783 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -0800784 */
785
786 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
787 desc_set_label(desc, label ? : "?");
788 status = 0;
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -0700789 } else {
David Brownelld2876d02008-02-04 22:28:20 -0800790 status = -EBUSY;
David Brownell35e8bb52008-10-15 22:03:16 -0700791 module_put(chip->owner);
Magnus Damm7460db52009-01-29 14:25:12 -0800792 goto done;
David Brownell35e8bb52008-10-15 22:03:16 -0700793 }
794
795 if (chip->request) {
796 /* chip->request may sleep */
797 spin_unlock_irqrestore(&gpio_lock, flags);
798 status = chip->request(chip, gpio - chip->base);
799 spin_lock_irqsave(&gpio_lock, flags);
800
801 if (status < 0) {
802 desc_set_label(desc, NULL);
803 module_put(chip->owner);
804 clear_bit(FLAG_REQUESTED, &desc->flags);
805 }
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -0700806 }
David Brownelld2876d02008-02-04 22:28:20 -0800807
808done:
809 if (status)
810 pr_debug("gpio_request: gpio-%d (%s) status %d\n",
811 gpio, label ? : "?", status);
812 spin_unlock_irqrestore(&gpio_lock, flags);
813 return status;
814}
815EXPORT_SYMBOL_GPL(gpio_request);
816
817void gpio_free(unsigned gpio)
818{
819 unsigned long flags;
820 struct gpio_desc *desc;
David Brownell35e8bb52008-10-15 22:03:16 -0700821 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -0800822
Uwe Kleine-König3d599d12008-10-15 22:03:12 -0700823 might_sleep();
824
Guennadi Liakhovetskie6de1802008-04-28 02:14:46 -0700825 if (!gpio_is_valid(gpio)) {
David Brownelld2876d02008-02-04 22:28:20 -0800826 WARN_ON(extra_checks);
827 return;
828 }
829
David Brownelld8f388d2008-07-25 01:46:07 -0700830 gpio_unexport(gpio);
831
David Brownelld2876d02008-02-04 22:28:20 -0800832 spin_lock_irqsave(&gpio_lock, flags);
833
834 desc = &gpio_desc[gpio];
David Brownell35e8bb52008-10-15 22:03:16 -0700835 chip = desc->chip;
836 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
837 if (chip->free) {
838 spin_unlock_irqrestore(&gpio_lock, flags);
839 might_sleep_if(extra_checks && chip->can_sleep);
840 chip->free(chip, gpio - chip->base);
841 spin_lock_irqsave(&gpio_lock, flags);
842 }
David Brownelld2876d02008-02-04 22:28:20 -0800843 desc_set_label(desc, NULL);
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -0700844 module_put(desc->chip->owner);
David Brownell35e8bb52008-10-15 22:03:16 -0700845 clear_bit(FLAG_REQUESTED, &desc->flags);
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -0700846 } else
David Brownelld2876d02008-02-04 22:28:20 -0800847 WARN_ON(extra_checks);
848
849 spin_unlock_irqrestore(&gpio_lock, flags);
850}
851EXPORT_SYMBOL_GPL(gpio_free);
852
853
854/**
855 * gpiochip_is_requested - return string iff signal was requested
856 * @chip: controller managing the signal
857 * @offset: of signal within controller's 0..(ngpio - 1) range
858 *
859 * Returns NULL if the GPIO is not currently requested, else a string.
860 * If debugfs support is enabled, the string returned is the label passed
861 * to gpio_request(); otherwise it is a meaningless constant.
862 *
863 * This function is for use by GPIO controller drivers. The label can
864 * help with diagnostics, and knowing that the signal is used as a GPIO
865 * can help avoid accidentally multiplexing it to another controller.
866 */
867const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
868{
869 unsigned gpio = chip->base + offset;
870
Guennadi Liakhovetskie6de1802008-04-28 02:14:46 -0700871 if (!gpio_is_valid(gpio) || gpio_desc[gpio].chip != chip)
David Brownelld2876d02008-02-04 22:28:20 -0800872 return NULL;
873 if (test_bit(FLAG_REQUESTED, &gpio_desc[gpio].flags) == 0)
874 return NULL;
875#ifdef CONFIG_DEBUG_FS
876 return gpio_desc[gpio].label;
877#else
878 return "?";
879#endif
880}
881EXPORT_SYMBOL_GPL(gpiochip_is_requested);
882
883
884/* Drivers MUST set GPIO direction before making get/set calls. In
885 * some cases this is done in early boot, before IRQs are enabled.
886 *
887 * As a rule these aren't called more than once (except for drivers
888 * using the open-drain emulation idiom) so these are natural places
889 * to accumulate extra debugging checks. Note that we can't (yet)
890 * rely on gpio_request() having been called beforehand.
891 */
892
893int gpio_direction_input(unsigned gpio)
894{
895 unsigned long flags;
896 struct gpio_chip *chip;
897 struct gpio_desc *desc = &gpio_desc[gpio];
898 int status = -EINVAL;
899
900 spin_lock_irqsave(&gpio_lock, flags);
901
Guennadi Liakhovetskie6de1802008-04-28 02:14:46 -0700902 if (!gpio_is_valid(gpio))
David Brownelld2876d02008-02-04 22:28:20 -0800903 goto fail;
904 chip = desc->chip;
905 if (!chip || !chip->get || !chip->direction_input)
906 goto fail;
907 gpio -= chip->base;
908 if (gpio >= chip->ngpio)
909 goto fail;
David Brownell35e8bb52008-10-15 22:03:16 -0700910 status = gpio_ensure_requested(desc, gpio);
911 if (status < 0)
912 goto fail;
David Brownelld2876d02008-02-04 22:28:20 -0800913
914 /* now we know the gpio is valid and chip won't vanish */
915
916 spin_unlock_irqrestore(&gpio_lock, flags);
917
918 might_sleep_if(extra_checks && chip->can_sleep);
919
David Brownell35e8bb52008-10-15 22:03:16 -0700920 if (status) {
921 status = chip->request(chip, gpio);
922 if (status < 0) {
923 pr_debug("GPIO-%d: chip request fail, %d\n",
924 chip->base + gpio, status);
925 /* and it's not available to anyone else ...
926 * gpio_request() is the fully clean solution.
927 */
928 goto lose;
929 }
930 }
931
David Brownelld2876d02008-02-04 22:28:20 -0800932 status = chip->direction_input(chip, gpio);
933 if (status == 0)
934 clear_bit(FLAG_IS_OUT, &desc->flags);
David Brownell35e8bb52008-10-15 22:03:16 -0700935lose:
David Brownelld2876d02008-02-04 22:28:20 -0800936 return status;
937fail:
938 spin_unlock_irqrestore(&gpio_lock, flags);
939 if (status)
940 pr_debug("%s: gpio-%d status %d\n",
Harvey Harrison145980a2008-04-30 00:54:57 -0700941 __func__, gpio, status);
David Brownelld2876d02008-02-04 22:28:20 -0800942 return status;
943}
944EXPORT_SYMBOL_GPL(gpio_direction_input);
945
946int gpio_direction_output(unsigned gpio, int value)
947{
948 unsigned long flags;
949 struct gpio_chip *chip;
950 struct gpio_desc *desc = &gpio_desc[gpio];
951 int status = -EINVAL;
952
953 spin_lock_irqsave(&gpio_lock, flags);
954
Guennadi Liakhovetskie6de1802008-04-28 02:14:46 -0700955 if (!gpio_is_valid(gpio))
David Brownelld2876d02008-02-04 22:28:20 -0800956 goto fail;
957 chip = desc->chip;
958 if (!chip || !chip->set || !chip->direction_output)
959 goto fail;
960 gpio -= chip->base;
961 if (gpio >= chip->ngpio)
962 goto fail;
David Brownell35e8bb52008-10-15 22:03:16 -0700963 status = gpio_ensure_requested(desc, gpio);
964 if (status < 0)
965 goto fail;
David Brownelld2876d02008-02-04 22:28:20 -0800966
967 /* now we know the gpio is valid and chip won't vanish */
968
969 spin_unlock_irqrestore(&gpio_lock, flags);
970
971 might_sleep_if(extra_checks && chip->can_sleep);
972
David Brownell35e8bb52008-10-15 22:03:16 -0700973 if (status) {
974 status = chip->request(chip, gpio);
975 if (status < 0) {
976 pr_debug("GPIO-%d: chip request fail, %d\n",
977 chip->base + gpio, status);
978 /* and it's not available to anyone else ...
979 * gpio_request() is the fully clean solution.
980 */
981 goto lose;
982 }
983 }
984
David Brownelld2876d02008-02-04 22:28:20 -0800985 status = chip->direction_output(chip, gpio, value);
986 if (status == 0)
987 set_bit(FLAG_IS_OUT, &desc->flags);
David Brownell35e8bb52008-10-15 22:03:16 -0700988lose:
David Brownelld2876d02008-02-04 22:28:20 -0800989 return status;
990fail:
991 spin_unlock_irqrestore(&gpio_lock, flags);
992 if (status)
993 pr_debug("%s: gpio-%d status %d\n",
Harvey Harrison145980a2008-04-30 00:54:57 -0700994 __func__, gpio, status);
David Brownelld2876d02008-02-04 22:28:20 -0800995 return status;
996}
997EXPORT_SYMBOL_GPL(gpio_direction_output);
998
999
1000/* I/O calls are only valid after configuration completed; the relevant
1001 * "is this a valid GPIO" error checks should already have been done.
1002 *
1003 * "Get" operations are often inlinable as reading a pin value register,
1004 * and masking the relevant bit in that register.
1005 *
1006 * When "set" operations are inlinable, they involve writing that mask to
1007 * one register to set a low value, or a different register to set it high.
1008 * Otherwise locking is needed, so there may be little value to inlining.
1009 *
1010 *------------------------------------------------------------------------
1011 *
1012 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers
1013 * have requested the GPIO. That can include implicit requesting by
1014 * a direction setting call. Marking a gpio as requested locks its chip
1015 * in memory, guaranteeing that these table lookups need no more locking
1016 * and that gpiochip_remove() will fail.
1017 *
1018 * REVISIT when debugging, consider adding some instrumentation to ensure
1019 * that the GPIO was actually requested.
1020 */
1021
1022/**
1023 * __gpio_get_value() - return a gpio's value
1024 * @gpio: gpio whose value will be returned
1025 * Context: any
1026 *
1027 * This is used directly or indirectly to implement gpio_get_value().
1028 * It returns the zero or nonzero value provided by the associated
1029 * gpio_chip.get() method; or zero if no such method is provided.
1030 */
1031int __gpio_get_value(unsigned gpio)
1032{
1033 struct gpio_chip *chip;
1034
1035 chip = gpio_to_chip(gpio);
1036 WARN_ON(extra_checks && chip->can_sleep);
1037 return chip->get ? chip->get(chip, gpio - chip->base) : 0;
1038}
1039EXPORT_SYMBOL_GPL(__gpio_get_value);
1040
1041/**
1042 * __gpio_set_value() - assign a gpio's value
1043 * @gpio: gpio whose value will be assigned
1044 * @value: value to assign
1045 * Context: any
1046 *
1047 * This is used directly or indirectly to implement gpio_set_value().
1048 * It invokes the associated gpio_chip.set() method.
1049 */
1050void __gpio_set_value(unsigned gpio, int value)
1051{
1052 struct gpio_chip *chip;
1053
1054 chip = gpio_to_chip(gpio);
1055 WARN_ON(extra_checks && chip->can_sleep);
1056 chip->set(chip, gpio - chip->base, value);
1057}
1058EXPORT_SYMBOL_GPL(__gpio_set_value);
1059
1060/**
1061 * __gpio_cansleep() - report whether gpio value access will sleep
1062 * @gpio: gpio in question
1063 * Context: any
1064 *
1065 * This is used directly or indirectly to implement gpio_cansleep(). It
1066 * returns nonzero if access reading or writing the GPIO value can sleep.
1067 */
1068int __gpio_cansleep(unsigned gpio)
1069{
1070 struct gpio_chip *chip;
1071
1072 /* only call this on GPIOs that are valid! */
1073 chip = gpio_to_chip(gpio);
1074
1075 return chip->can_sleep;
1076}
1077EXPORT_SYMBOL_GPL(__gpio_cansleep);
1078
David Brownell0f6d5042008-10-15 22:03:14 -07001079/**
1080 * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1081 * @gpio: gpio whose IRQ will be returned (already requested)
1082 * Context: any
1083 *
1084 * This is used directly or indirectly to implement gpio_to_irq().
1085 * It returns the number of the IRQ signaled by this (input) GPIO,
1086 * or a negative errno.
1087 */
1088int __gpio_to_irq(unsigned gpio)
1089{
1090 struct gpio_chip *chip;
1091
1092 chip = gpio_to_chip(gpio);
1093 return chip->to_irq ? chip->to_irq(chip, gpio - chip->base) : -ENXIO;
1094}
1095EXPORT_SYMBOL_GPL(__gpio_to_irq);
1096
David Brownelld2876d02008-02-04 22:28:20 -08001097
1098
1099/* There's no value in making it easy to inline GPIO calls that may sleep.
1100 * Common examples include ones connected to I2C or SPI chips.
1101 */
1102
1103int gpio_get_value_cansleep(unsigned gpio)
1104{
1105 struct gpio_chip *chip;
1106
1107 might_sleep_if(extra_checks);
1108 chip = gpio_to_chip(gpio);
David Brownell978ccaa2008-10-18 20:27:49 -07001109 return chip->get ? chip->get(chip, gpio - chip->base) : 0;
David Brownelld2876d02008-02-04 22:28:20 -08001110}
1111EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
1112
1113void gpio_set_value_cansleep(unsigned gpio, int value)
1114{
1115 struct gpio_chip *chip;
1116
1117 might_sleep_if(extra_checks);
1118 chip = gpio_to_chip(gpio);
1119 chip->set(chip, gpio - chip->base, value);
1120}
1121EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
1122
1123
1124#ifdef CONFIG_DEBUG_FS
1125
David Brownelld2876d02008-02-04 22:28:20 -08001126static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
1127{
1128 unsigned i;
1129 unsigned gpio = chip->base;
1130 struct gpio_desc *gdesc = &gpio_desc[gpio];
1131 int is_out;
1132
1133 for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
1134 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
1135 continue;
1136
1137 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
Jarkko Nikula6e8ba722008-11-19 15:36:17 -08001138 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
David Brownelld2876d02008-02-04 22:28:20 -08001139 gpio, gdesc->label,
1140 is_out ? "out" : "in ",
1141 chip->get
1142 ? (chip->get(chip, i) ? "hi" : "lo")
1143 : "? ");
1144
1145 if (!is_out) {
1146 int irq = gpio_to_irq(gpio);
Yinghai Lu08678b02008-08-19 20:50:05 -07001147 struct irq_desc *desc = irq_to_desc(irq);
David Brownelld2876d02008-02-04 22:28:20 -08001148
1149 /* This races with request_irq(), set_irq_type(),
1150 * and set_irq_wake() ... but those are "rare".
1151 *
1152 * More significantly, trigger type flags aren't
1153 * currently maintained by genirq.
1154 */
1155 if (irq >= 0 && desc->action) {
1156 char *trigger;
1157
1158 switch (desc->status & IRQ_TYPE_SENSE_MASK) {
1159 case IRQ_TYPE_NONE:
1160 trigger = "(default)";
1161 break;
1162 case IRQ_TYPE_EDGE_FALLING:
1163 trigger = "edge-falling";
1164 break;
1165 case IRQ_TYPE_EDGE_RISING:
1166 trigger = "edge-rising";
1167 break;
1168 case IRQ_TYPE_EDGE_BOTH:
1169 trigger = "edge-both";
1170 break;
1171 case IRQ_TYPE_LEVEL_HIGH:
1172 trigger = "level-high";
1173 break;
1174 case IRQ_TYPE_LEVEL_LOW:
1175 trigger = "level-low";
1176 break;
1177 default:
1178 trigger = "?trigger?";
1179 break;
1180 }
1181
1182 seq_printf(s, " irq-%d %s%s",
1183 irq, trigger,
1184 (desc->status & IRQ_WAKEUP)
1185 ? " wakeup" : "");
1186 }
1187 }
1188
1189 seq_printf(s, "\n");
1190 }
1191}
1192
1193static int gpiolib_show(struct seq_file *s, void *unused)
1194{
1195 struct gpio_chip *chip = NULL;
1196 unsigned gpio;
1197 int started = 0;
1198
1199 /* REVISIT this isn't locked against gpio_chip removal ... */
1200
Guennadi Liakhovetskie6de1802008-04-28 02:14:46 -07001201 for (gpio = 0; gpio_is_valid(gpio); gpio++) {
David Brownelld8f388d2008-07-25 01:46:07 -07001202 struct device *dev;
1203
David Brownelld2876d02008-02-04 22:28:20 -08001204 if (chip == gpio_desc[gpio].chip)
1205 continue;
1206 chip = gpio_desc[gpio].chip;
1207 if (!chip)
1208 continue;
1209
David Brownelld8f388d2008-07-25 01:46:07 -07001210 seq_printf(s, "%sGPIOs %d-%d",
David Brownelld2876d02008-02-04 22:28:20 -08001211 started ? "\n" : "",
David Brownelld8f388d2008-07-25 01:46:07 -07001212 chip->base, chip->base + chip->ngpio - 1);
1213 dev = chip->dev;
1214 if (dev)
1215 seq_printf(s, ", %s/%s",
1216 dev->bus ? dev->bus->name : "no-bus",
Kay Sievers14ab3092009-01-06 10:44:42 -08001217 dev_name(dev));
David Brownelld8f388d2008-07-25 01:46:07 -07001218 if (chip->label)
1219 seq_printf(s, ", %s", chip->label);
1220 if (chip->can_sleep)
1221 seq_printf(s, ", can sleep");
1222 seq_printf(s, ":\n");
1223
David Brownelld2876d02008-02-04 22:28:20 -08001224 started = 1;
1225 if (chip->dbg_show)
1226 chip->dbg_show(s, chip);
1227 else
1228 gpiolib_dbg_show(s, chip);
1229 }
1230 return 0;
1231}
1232
1233static int gpiolib_open(struct inode *inode, struct file *file)
1234{
1235 return single_open(file, gpiolib_show, NULL);
1236}
1237
1238static struct file_operations gpiolib_operations = {
1239 .open = gpiolib_open,
1240 .read = seq_read,
1241 .llseek = seq_lseek,
1242 .release = single_release,
1243};
1244
1245static int __init gpiolib_debugfs_init(void)
1246{
1247 /* /sys/kernel/debug/gpio */
1248 (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
1249 NULL, NULL, &gpiolib_operations);
1250 return 0;
1251}
1252subsys_initcall(gpiolib_debugfs_init);
1253
1254#endif /* DEBUG_FS */