drivers/gpio/gpiolib-sysfs.c

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