drivers/gpio/gpiolib-sysfs.c

   1 #include <linux/idr.h>
   2 #include <linux/mutex.h>
   3 #include <linux/device.h>
   4 #include <linux/sysfs.h>
   5 #include <linux/gpio/consumer.h>
   6 #include <linux/gpio/driver.h>
   7 #include <linux/interrupt.h>
   8 #include <linux/kdev_t.h>
   9 #include <linux/slab.h>
  10
  11 #include "gpiolib.h"
  12
  13 struct gpiod_data {
  14         struct gpio_desc *desc;
  15
  16         struct mutex mutex;
  17         struct kernfs_node *value_kn;
  18         int irq;
  19 };
  20
  21 /*
  22  * Lock to serialise gpiod export and unexport, and prevent re-export of
  23  * gpiod whose chip is being unregistered.
  24  */
  25 static DEFINE_MUTEX(sysfs_lock);
  26
  27 /*
  28  * /sys/class/gpio/gpioN... only for GPIOs that are exported
  29  *   /direction
  30  *      * MAY BE OMITTED if kernel won't allow direction changes
  31  *      * is read/write as "in" or "out"
  32  *      * may also be written as "high" or "low", initializing
  33  *        output value as specified ("out" implies "low")
  34  *   /value
  35  *      * always readable, subject to hardware behavior
  36  *      * may be writable, as zero/nonzero
  37  *   /edge
  38  *      * configures behavior of poll(2) on /value
  39  *      * available only if pin can generate IRQs on input
  40  *      * is read/write as "none", "falling", "rising", or "both"
  41  *   /active_low
  42  *      * configures polarity of /value
  43  *      * is read/write as zero/nonzero
  44  *      * also affects existing and subsequent "falling" and "rising"
  45  *        /edge configuration
  46  */
  47
  48 static ssize_t direction_show(struct device *dev,
  49                 struct device_attribute *attr, char *buf)
  50 {
  51         struct gpiod_data *data = dev_get_drvdata(dev);
  52         struct gpio_desc *desc = data->desc;
  53         ssize_t                 status;
  54
  55         mutex_lock(&data->mutex);
  56
  57         gpiod_get_direction(desc);
  58         status = sprintf(buf, "%s\n",
  59                         test_bit(FLAG_IS_OUT, &desc->flags)
  60                                 ? "out" : "in");
  61
  62         mutex_unlock(&data->mutex);
  63
  64         return status;
  65 }
  66
  67 static ssize_t direction_store(struct device *dev,
  68                 struct device_attribute *attr, const char *buf, size_t size)
  69 {
  70         struct gpiod_data *data = dev_get_drvdata(dev);
  71         struct gpio_desc *desc = data->desc;
  72         ssize_t                 status;
  73
  74         mutex_lock(&data->mutex);
  75
  76         if (sysfs_streq(buf, "high"))
  77                 status = gpiod_direction_output_raw(desc, 1);
  78         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
  79                 status = gpiod_direction_output_raw(desc, 0);
  80         else if (sysfs_streq(buf, "in"))
  81                 status = gpiod_direction_input(desc);
  82         else
  83                 status = -EINVAL;
  84
  85         mutex_unlock(&data->mutex);
  86
  87         return status ? : size;
  88 }
  89 static DEVICE_ATTR_RW(direction);
  90
  91 static ssize_t value_show(struct device *dev,
  92                 struct device_attribute *attr, char *buf)
  93 {
  94         struct gpiod_data *data = dev_get_drvdata(dev);
  95         struct gpio_desc *desc = data->desc;
  96         ssize_t                 status;
  97
  98         mutex_lock(&data->mutex);
  99
 100         status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
 101
 102         mutex_unlock(&data->mutex);
 103
 104         return status;
 105 }
 106
 107 static ssize_t value_store(struct device *dev,
 108                 struct device_attribute *attr, const char *buf, size_t size)
 109 {
 110         struct gpiod_data *data = dev_get_drvdata(dev);
 111         struct gpio_desc *desc = data->desc;
 112         ssize_t                 status;
 113
 114         mutex_lock(&data->mutex);
 115
 116         if (!test_bit(FLAG_IS_OUT, &desc->flags)) {
 117                 status = -EPERM;
 118         } else {
 119                 long            value;
 120
 121                 status = kstrtol(buf, 0, &value);
 122                 if (status == 0) {
 123                         gpiod_set_value_cansleep(desc, value);
 124                         status = size;
 125                 }
 126         }
 127
 128         mutex_unlock(&data->mutex);
 129
 130         return status;
 131 }
 132 static DEVICE_ATTR_RW(value);
 133
 134 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
 135 {
 136         struct gpiod_data *data = priv;
 137
 138         sysfs_notify_dirent(data->value_kn);
 139
 140         return IRQ_HANDLED;
 141 }
 142
 143 /* Caller holds gpiod-data mutex. */
 144 static int gpio_sysfs_request_irq(struct device *dev, unsigned long gpio_flags)
 145 {
 146         struct gpiod_data       *data = dev_get_drvdata(dev);
 147         struct gpio_desc        *desc = data->desc;
 148         unsigned long           irq_flags;
 149         int                     ret;
 150
 151         data->irq = gpiod_to_irq(desc);
 152         if (data->irq < 0)
 153                 return -EIO;
 154
 155         data->value_kn = sysfs_get_dirent(dev->kobj.sd, "value");
 156         if (!data->value_kn)
 157                 return -ENODEV;
 158
 159         irq_flags = IRQF_SHARED;
 160         if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
 161                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 162                         IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
 163         if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
 164                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 165                         IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
 166
 167         /*
 168          * FIXME: This should be done in the irq_request_resources callback
 169          *        when the irq is requested, but a few drivers currently fail
 170          *        to do so.
 171          *
 172          *        Remove this redundant call (along with the corresponding
 173          *        unlock) when those drivers have been fixed.
 174          */
 175         ret = gpiochip_lock_as_irq(desc->chip, gpio_chip_hwgpio(desc));
 176         if (ret < 0)
 177                 goto err_put_kn;
 178
 179         ret = request_any_context_irq(data->irq, gpio_sysfs_irq, irq_flags,
 180                                 "gpiolib", data);
 181         if (ret < 0)
 182                 goto err_unlock;
 183
 184         desc->flags |= gpio_flags;
 185
 186         return 0;
 187
 188 err_unlock:
 189         gpiochip_unlock_as_irq(desc->chip, gpio_chip_hwgpio(desc));
 190 err_put_kn:
 191         sysfs_put(data->value_kn);
 192
 193         return ret;
 194 }
 195
 196 /*
 197  * Caller holds gpiod-data mutex (unless called after class-device
 198  * deregistration).
 199  */
 200 static void gpio_sysfs_free_irq(struct device *dev)
 201 {
 202         struct gpiod_data *data = dev_get_drvdata(dev);
 203         struct gpio_desc *desc = data->desc;
 204
 205         desc->flags &= ~GPIO_TRIGGER_MASK;
 206         free_irq(data->irq, data);
 207         gpiochip_unlock_as_irq(desc->chip, gpio_chip_hwgpio(desc));
 208         sysfs_put(data->value_kn);
 209 }
 210
 211 static const struct {
 212         const char *name;
 213         unsigned long flags;
 214 } trigger_types[] = {
 215         { "none",    0 },
 216         { "falling", BIT(FLAG_TRIG_FALL) },
 217         { "rising",  BIT(FLAG_TRIG_RISE) },
 218         { "both",    BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
 219 };
 220
 221 static ssize_t edge_show(struct device *dev,
 222                 struct device_attribute *attr, char *buf)
 223 {
 224         struct gpiod_data *data = dev_get_drvdata(dev);
 225         struct gpio_desc *desc = data->desc;
 226         unsigned long mask;
 227         ssize_t status = 0;
 228         int i;
 229
 230         mutex_lock(&data->mutex);
 231
 232         for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
 233                 mask = desc->flags & GPIO_TRIGGER_MASK;
 234                 if (mask == trigger_types[i].flags) {
 235                         status = sprintf(buf, "%s\n", trigger_types[i].name);
 236                         break;
 237                 }
 238         }
 239
 240         mutex_unlock(&data->mutex);
 241
 242         return status;
 243 }
 244
 245 static ssize_t edge_store(struct device *dev,
 246                 struct device_attribute *attr, const char *buf, size_t size)
 247 {
 248         struct gpiod_data *data = dev_get_drvdata(dev);
 249         struct gpio_desc *desc = data->desc;
 250         unsigned long flags;
 251         ssize_t status = size;
 252         int i;
 253
 254         for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
 255                 if (sysfs_streq(trigger_types[i].name, buf))
 256                         break;
 257         }
 258
 259         if (i == ARRAY_SIZE(trigger_types))
 260                 return -EINVAL;
 261
 262         flags = trigger_types[i].flags;
 263
 264         mutex_lock(&data->mutex);
 265
 266         if ((desc->flags & GPIO_TRIGGER_MASK) == flags) {
 267                 status = size;
 268                 goto out_unlock;
 269         }
 270
 271         if (desc->flags & GPIO_TRIGGER_MASK)
 272                 gpio_sysfs_free_irq(dev);
 273
 274         if (flags) {
 275                 status = gpio_sysfs_request_irq(dev, flags);
 276                 if (!status)
 277                         status = size;
 278         }
 279
 280 out_unlock:
 281         mutex_unlock(&data->mutex);
 282
 283         return status;
 284 }
 285 static DEVICE_ATTR_RW(edge);
 286
 287 /* Caller holds gpiod-data mutex. */
 288 static int gpio_sysfs_set_active_low(struct device *dev, int value)
 289 {
 290         struct gpiod_data       *data = dev_get_drvdata(dev);
 291         struct gpio_desc        *desc = data->desc;
 292         int                     status = 0;
 293
 294         if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
 295                 return 0;
 296
 297         if (value)
 298                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 299         else
 300                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
 301
 302         /* reconfigure poll(2) support if enabled on one edge only */
 303         if (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
 304                                 !!test_bit(FLAG_TRIG_FALL, &desc->flags)) {
 305                 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
 306
 307                 gpio_sysfs_free_irq(dev);
 308                 status = gpio_sysfs_request_irq(dev, trigger_flags);
 309         }
 310
 311         return status;
 312 }
 313
 314 static ssize_t active_low_show(struct device *dev,
 315                 struct device_attribute *attr, char *buf)
 316 {
 317         struct gpiod_data *data = dev_get_drvdata(dev);
 318         struct gpio_desc *desc = data->desc;
 319         ssize_t                 status;
 320
 321         mutex_lock(&data->mutex);
 322
 323         status = sprintf(buf, "%d\n",
 324                                 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
 325
 326         mutex_unlock(&data->mutex);
 327
 328         return status;
 329 }
 330
 331 static ssize_t active_low_store(struct device *dev,
 332                 struct device_attribute *attr, const char *buf, size_t size)
 333 {
 334         struct gpiod_data       *data = dev_get_drvdata(dev);
 335         ssize_t                 status;
 336         long                    value;
 337
 338         mutex_lock(&data->mutex);
 339
 340         status = kstrtol(buf, 0, &value);
 341         if (status == 0)
 342                 status = gpio_sysfs_set_active_low(dev, value);
 343
 344         mutex_unlock(&data->mutex);
 345
 346         return status ? : size;
 347 }
 348 static DEVICE_ATTR_RW(active_low);
 349
 350 static umode_t gpio_is_visible(struct kobject *kobj, struct attribute *attr,
 351                                int n)
 352 {
 353         struct device *dev = container_of(kobj, struct device, kobj);
 354         struct gpiod_data *data = dev_get_drvdata(dev);
 355         struct gpio_desc *desc = data->desc;
 356         umode_t mode = attr->mode;
 357         bool show_direction = test_bit(FLAG_SYSFS_DIR, &desc->flags);
 358
 359         if (attr == &dev_attr_direction.attr) {
 360                 if (!show_direction)
 361                         mode = 0;
 362         } else if (attr == &dev_attr_edge.attr) {
 363                 if (gpiod_to_irq(desc) < 0)
 364                         mode = 0;
 365                 if (!show_direction && test_bit(FLAG_IS_OUT, &desc->flags))
 366                         mode = 0;
 367         }
 368
 369         return mode;
 370 }
 371
 372 static struct attribute *gpio_attrs[] = {
 373         &dev_attr_direction.attr,
 374         &dev_attr_edge.attr,
 375         &dev_attr_value.attr,
 376         &dev_attr_active_low.attr,
 377         NULL,
 378 };
 379
 380 static const struct attribute_group gpio_group = {
 381         .attrs = gpio_attrs,
 382         .is_visible = gpio_is_visible,
 383 };
 384
 385 static const struct attribute_group *gpio_groups[] = {
 386         &gpio_group,
 387         NULL
 388 };
 389
 390 /*
 391  * /sys/class/gpio/gpiochipN/
 392  *   /base ... matching gpio_chip.base (N)
 393  *   /label ... matching gpio_chip.label
 394  *   /ngpio ... matching gpio_chip.ngpio
 395  */
 396
 397 static ssize_t base_show(struct device *dev,
 398                                struct device_attribute *attr, char *buf)
 399 {
 400         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 401
 402         return sprintf(buf, "%d\n", chip->base);
 403 }
 404 static DEVICE_ATTR_RO(base);
 405
 406 static ssize_t label_show(struct device *dev,
 407                                struct device_attribute *attr, char *buf)
 408 {
 409         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 410
 411         return sprintf(buf, "%s\n", chip->label ? : "");
 412 }
 413 static DEVICE_ATTR_RO(label);
 414
 415 static ssize_t ngpio_show(struct device *dev,
 416                                struct device_attribute *attr, char *buf)
 417 {
 418         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 419
 420         return sprintf(buf, "%u\n", chip->ngpio);
 421 }
 422 static DEVICE_ATTR_RO(ngpio);
 423
 424 static struct attribute *gpiochip_attrs[] = {
 425         &dev_attr_base.attr,
 426         &dev_attr_label.attr,
 427         &dev_attr_ngpio.attr,
 428         NULL,
 429 };
 430 ATTRIBUTE_GROUPS(gpiochip);
 431
 432 /*
 433  * /sys/class/gpio/export ... write-only
 434  *      integer N ... number of GPIO to export (full access)
 435  * /sys/class/gpio/unexport ... write-only
 436  *      integer N ... number of GPIO to unexport
 437  */
 438 static ssize_t export_store(struct class *class,
 439                                 struct class_attribute *attr,
 440                                 const char *buf, size_t len)
 441 {
 442         long                    gpio;
 443         struct gpio_desc        *desc;
 444         int                     status;
 445
 446         status = kstrtol(buf, 0, &gpio);
 447         if (status < 0)
 448                 goto done;
 449
 450         desc = gpio_to_desc(gpio);
 451         /* reject invalid GPIOs */
 452         if (!desc) {
 453                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 454                 return -EINVAL;
 455         }
 456
 457         /* No extra locking here; FLAG_SYSFS just signifies that the
 458          * request and export were done by on behalf of userspace, so
 459          * they may be undone on its behalf too.
 460          */
 461
 462         status = gpiod_request(desc, "sysfs");
 463         if (status < 0) {
 464                 if (status == -EPROBE_DEFER)
 465                         status = -ENODEV;
 466                 goto done;
 467         }
 468         status = gpiod_export(desc, true);
 469         if (status < 0)
 470                 gpiod_free(desc);
 471         else
 472                 set_bit(FLAG_SYSFS, &desc->flags);
 473
 474 done:
 475         if (status)
 476                 pr_debug("%s: status %d\n", __func__, status);
 477         return status ? : len;
 478 }
 479
 480 static ssize_t unexport_store(struct class *class,
 481                                 struct class_attribute *attr,
 482                                 const char *buf, size_t len)
 483 {
 484         long                    gpio;
 485         struct gpio_desc        *desc;
 486         int                     status;
 487
 488         status = kstrtol(buf, 0, &gpio);
 489         if (status < 0)
 490                 goto done;
 491
 492         desc = gpio_to_desc(gpio);
 493         /* reject bogus commands (gpio_unexport ignores them) */
 494         if (!desc) {
 495                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 496                 return -EINVAL;
 497         }
 498
 499         status = -EINVAL;
 500
 501         /* No extra locking here; FLAG_SYSFS just signifies that the
 502          * request and export were done by on behalf of userspace, so
 503          * they may be undone on its behalf too.
 504          */
 505         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
 506                 status = 0;
 507                 gpiod_free(desc);
 508         }
 509 done:
 510         if (status)
 511                 pr_debug("%s: status %d\n", __func__, status);
 512         return status ? : len;
 513 }
 514
 515 static struct class_attribute gpio_class_attrs[] = {
 516         __ATTR(export, 0200, NULL, export_store),
 517         __ATTR(unexport, 0200, NULL, unexport_store),
 518         __ATTR_NULL,
 519 };
 520
 521 static struct class gpio_class = {
 522         .name =         "gpio",
 523         .owner =        THIS_MODULE,
 524
 525         .class_attrs =  gpio_class_attrs,
 526 };
 527
 528
 529 /**
 530  * gpiod_export - export a GPIO through sysfs
 531  * @gpio: gpio to make available, already requested
 532  * @direction_may_change: true if userspace may change gpio direction
 533  * Context: arch_initcall or later
 534  *
 535  * When drivers want to make a GPIO accessible to userspace after they
 536  * have requested it -- perhaps while debugging, or as part of their
 537  * public interface -- they may use this routine.  If the GPIO can
 538  * change direction (some can't) and the caller allows it, userspace
 539  * will see "direction" sysfs attribute which may be used to change
 540  * the gpio's direction.  A "value" attribute will always be provided.
 541  *
 542  * Returns zero on success, else an error.
 543  */
 544 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 545 {
 546         struct gpio_chip        *chip;
 547         struct gpiod_data       *data;
 548         unsigned long           flags;
 549         int                     status;
 550         const char              *ioname = NULL;
 551         struct device           *dev;
 552         int                     offset;
 553
 554         /* can't export until sysfs is available ... */
 555         if (!gpio_class.p) {
 556                 pr_debug("%s: called too early!\n", __func__);
 557                 return -ENOENT;
 558         }
 559
 560         if (!desc) {
 561                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 562                 return -EINVAL;
 563         }
 564
 565         chip = desc->chip;
 566
 567         mutex_lock(&sysfs_lock);
 568
 569         /* check if chip is being removed */
 570         if (!chip || !chip->cdev) {
 571                 status = -ENODEV;
 572                 goto err_unlock;
 573         }
 574
 575         spin_lock_irqsave(&gpio_lock, flags);
 576         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
 577              test_bit(FLAG_EXPORT, &desc->flags)) {
 578                 spin_unlock_irqrestore(&gpio_lock, flags);
 579                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
 580                                 __func__,
 581                                 test_bit(FLAG_REQUESTED, &desc->flags),
 582                                 test_bit(FLAG_EXPORT, &desc->flags));
 583                 status = -EPERM;
 584                 goto err_unlock;
 585         }
 586
 587         if (chip->direction_input && chip->direction_output &&
 588                         direction_may_change) {
 589                 set_bit(FLAG_SYSFS_DIR, &desc->flags);
 590         }
 591
 592         spin_unlock_irqrestore(&gpio_lock, flags);
 593
 594         data = kzalloc(sizeof(*data), GFP_KERNEL);
 595         if (!data) {
 596                 status = -ENOMEM;
 597                 goto err_unlock;
 598         }
 599
 600         data->desc = desc;
 601         mutex_init(&data->mutex);
 602
 603         offset = gpio_chip_hwgpio(desc);
 604         if (chip->names && chip->names[offset])
 605                 ioname = chip->names[offset];
 606
 607         dev = device_create_with_groups(&gpio_class, chip->dev,
 608                                         MKDEV(0, 0), data, gpio_groups,
 609                                         ioname ? ioname : "gpio%u",
 610                                         desc_to_gpio(desc));
 611         if (IS_ERR(dev)) {
 612                 status = PTR_ERR(dev);
 613                 goto err_free_data;
 614         }
 615
 616         set_bit(FLAG_EXPORT, &desc->flags);
 617         mutex_unlock(&sysfs_lock);
 618         return 0;
 619
 620 err_free_data:
 621         kfree(data);
 622 err_unlock:
 623         mutex_unlock(&sysfs_lock);
 624         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 625         return status;
 626 }
 627 EXPORT_SYMBOL_GPL(gpiod_export);
 628
 629 static int match_export(struct device *dev, const void *desc)
 630 {
 631         struct gpiod_data *data = dev_get_drvdata(dev);
 632
 633         return data->desc == desc;
 634 }
 635
 636 /**
 637  * gpiod_export_link - create a sysfs link to an exported GPIO node
 638  * @dev: device under which to create symlink
 639  * @name: name of the symlink
 640  * @gpio: gpio to create symlink to, already exported
 641  *
 642  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 643  * node. Caller is responsible for unlinking.
 644  *
 645  * Returns zero on success, else an error.
 646  */
 647 int gpiod_export_link(struct device *dev, const char *name,
 648                       struct gpio_desc *desc)
 649 {
 650         struct device *cdev;
 651         int ret;
 652
 653         if (!desc) {
 654                 pr_warn("%s: invalid GPIO\n", __func__);
 655                 return -EINVAL;
 656         }
 657
 658         cdev = class_find_device(&gpio_class, NULL, desc, match_export);
 659         if (!cdev)
 660                 return -ENODEV;
 661
 662         ret = sysfs_create_link(&dev->kobj, &cdev->kobj, name);
 663         put_device(cdev);
 664
 665         return ret;
 666 }
 667 EXPORT_SYMBOL_GPL(gpiod_export_link);
 668
 669 /**
 670  * gpiod_unexport - reverse effect of gpio_export()
 671  * @gpio: gpio to make unavailable
 672  *
 673  * This is implicit on gpio_free().
 674  */
 675 void gpiod_unexport(struct gpio_desc *desc)
 676 {
 677         struct gpiod_data *data;
 678         struct device *dev;
 679
 680         if (!desc) {
 681                 pr_warn("%s: invalid GPIO\n", __func__);
 682                 return;
 683         }
 684
 685         mutex_lock(&sysfs_lock);
 686
 687         if (!test_bit(FLAG_EXPORT, &desc->flags))
 688                 goto err_unlock;
 689
 690         dev = class_find_device(&gpio_class, NULL, desc, match_export);
 691         if (!dev)
 692                 goto err_unlock;
 693
 694         data = dev_get_drvdata(dev);
 695
 696         clear_bit(FLAG_SYSFS_DIR, &desc->flags);
 697         clear_bit(FLAG_EXPORT, &desc->flags);
 698
 699         device_unregister(dev);
 700
 701         /*
 702          * Release irq after deregistration to prevent race with edge_store.
 703          */
 704         if (desc->flags & GPIO_TRIGGER_MASK)
 705                 gpio_sysfs_free_irq(dev);
 706
 707         mutex_unlock(&sysfs_lock);
 708
 709         put_device(dev);
 710         kfree(data);
 711
 712         return;
 713
 714 err_unlock:
 715         mutex_unlock(&sysfs_lock);
 716 }
 717 EXPORT_SYMBOL_GPL(gpiod_unexport);
 718
 719 int gpiochip_sysfs_register(struct gpio_chip *chip)
 720 {
 721         struct device   *dev;
 722
 723         /*
 724          * Many systems add gpio chips for SOC support very early,
 725          * before driver model support is available.  In those cases we
 726          * register later, in gpiolib_sysfs_init() ... here we just
 727          * verify that _some_ field of gpio_class got initialized.
 728          */
 729         if (!gpio_class.p)
 730                 return 0;
 731
 732         /* use chip->base for the ID; it's already known to be unique */
 733         dev = device_create_with_groups(&gpio_class, chip->dev, MKDEV(0, 0),
 734                                         chip, gpiochip_groups,
 735                                         "gpiochip%d", chip->base);
 736         if (IS_ERR(dev))
 737                 return PTR_ERR(dev);
 738
 739         mutex_lock(&sysfs_lock);
 740         chip->cdev = dev;
 741         mutex_unlock(&sysfs_lock);
 742
 743         return 0;
 744 }
 745
 746 void gpiochip_sysfs_unregister(struct gpio_chip *chip)
 747 {
 748         struct gpio_desc *desc;
 749         unsigned int i;
 750
 751         if (!chip->cdev)
 752                 return;
 753
 754         device_unregister(chip->cdev);
 755
 756         /* prevent further gpiod exports */
 757         mutex_lock(&sysfs_lock);
 758         chip->cdev = NULL;
 759         mutex_unlock(&sysfs_lock);
 760
 761         /* unregister gpiod class devices owned by sysfs */
 762         for (i = 0; i < chip->ngpio; i++) {
 763                 desc = &chip->desc[i];
 764                 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags))
 765                         gpiod_free(desc);
 766         }
 767 }
 768
 769 static int __init gpiolib_sysfs_init(void)
 770 {
 771         int             status;
 772         unsigned long   flags;
 773         struct gpio_chip *chip;
 774
 775         status = class_register(&gpio_class);
 776         if (status < 0)
 777                 return status;
 778
 779         /* Scan and register the gpio_chips which registered very
 780          * early (e.g. before the class_register above was called).
 781          *
 782          * We run before arch_initcall() so chip->dev nodes can have
 783          * registered, and so arch_initcall() can always gpio_export().
 784          */
 785         spin_lock_irqsave(&gpio_lock, flags);
 786         list_for_each_entry(chip, &gpio_chips, list) {
 787                 if (chip->cdev)
 788                         continue;
 789
 790                 /*
 791                  * TODO we yield gpio_lock here because
 792                  * gpiochip_sysfs_register() acquires a mutex. This is unsafe
 793                  * and needs to be fixed.
 794                  *
 795                  * Also it would be nice to use gpiochip_find() here so we
 796                  * can keep gpio_chips local to gpiolib.c, but the yield of
 797                  * gpio_lock prevents us from doing this.
 798                  */
 799                 spin_unlock_irqrestore(&gpio_lock, flags);
 800                 status = gpiochip_sysfs_register(chip);
 801                 spin_lock_irqsave(&gpio_lock, flags);
 802         }
 803         spin_unlock_irqrestore(&gpio_lock, flags);
 804
 805
 806         return status;
 807 }
 808 postcore_initcall(gpiolib_sysfs_init);