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                 status = 0;
 519                 gpiod_free(desc);
 520         }
 521 done:
 522         if (status)
 523                 pr_debug("%s: status %d\n", __func__, status);
 524         return status ? : len;
 525 }
 526 static CLASS_ATTR_WO(unexport);
 527
 528 static struct attribute *gpio_class_attrs[] = {
 529         &class_attr_export.attr,
 530         &class_attr_unexport.attr,
 531         NULL,
 532 };
 533 ATTRIBUTE_GROUPS(gpio_class);
 534
 535 static struct class gpio_class = {
 536         .name =         "gpio",
 537         .class_groups = gpio_class_groups,
 538 };
 539
 540
 541 /**
 542  * gpiod_export - export a GPIO through sysfs
 543  * @desc: GPIO to make available, already requested
 544  * @direction_may_change: true if userspace may change GPIO direction
 545  * Context: arch_initcall or later
 546  *
 547  * When drivers want to make a GPIO accessible to userspace after they
 548  * have requested it -- perhaps while debugging, or as part of their
 549  * public interface -- they may use this routine.  If the GPIO can
 550  * change direction (some can't) and the caller allows it, userspace
 551  * will see "direction" sysfs attribute which may be used to change
 552  * the gpio's direction.  A "value" attribute will always be provided.
 553  *
 554  * Returns zero on success, else an error.
 555  */
 556 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 557 {
 558         struct gpio_chip        *chip;
 559         struct gpio_device      *gdev;
 560         struct gpiod_data       *data;
 561         unsigned long           flags;
 562         int                     status;
 563         const char              *ioname = NULL;
 564         struct device           *dev;
 565         int                     offset;
 566
 567         /* can't export until sysfs is available ... */
 568         if (!class_is_registered(&gpio_class)) {
 569                 pr_debug("%s: called too early!\n", __func__);
 570                 return -ENOENT;
 571         }
 572
 573         if (!desc) {
 574                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 575                 return -EINVAL;
 576         }
 577
 578         gdev = desc->gdev;
 579         chip = gdev->chip;
 580
 581         mutex_lock(&sysfs_lock);
 582
 583         /* check if chip is being removed */
 584         if (!chip || !gdev->mockdev) {
 585                 status = -ENODEV;
 586                 goto err_unlock;
 587         }
 588
 589         spin_lock_irqsave(&gpio_lock, flags);
 590         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
 591              test_bit(FLAG_EXPORT, &desc->flags)) {
 592                 spin_unlock_irqrestore(&gpio_lock, flags);
 593                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
 594                                 __func__,
 595                                 test_bit(FLAG_REQUESTED, &desc->flags),
 596                                 test_bit(FLAG_EXPORT, &desc->flags));
 597                 status = -EPERM;
 598                 goto err_unlock;
 599         }
 600         spin_unlock_irqrestore(&gpio_lock, flags);
 601
 602         data = kzalloc(sizeof(*data), GFP_KERNEL);
 603         if (!data) {
 604                 status = -ENOMEM;
 605                 goto err_unlock;
 606         }
 607
 608         data->desc = desc;
 609         mutex_init(&data->mutex);
 610         if (chip->direction_input && chip->direction_output)
 611                 data->direction_can_change = direction_may_change;
 612         else
 613                 data->direction_can_change = false;
 614
 615         offset = gpio_chip_hwgpio(desc);
 616         if (chip->names && chip->names[offset])
 617                 ioname = chip->names[offset];
 618
 619         dev = device_create_with_groups(&gpio_class, &gdev->dev,
 620                                         MKDEV(0, 0), data, gpio_groups,
 621                                         ioname ? ioname : "gpio%u",
 622                                         desc_to_gpio(desc));
 623         if (IS_ERR(dev)) {
 624                 status = PTR_ERR(dev);
 625                 goto err_free_data;
 626         }
 627
 628         set_bit(FLAG_EXPORT, &desc->flags);
 629         mutex_unlock(&sysfs_lock);
 630         return 0;
 631
 632 err_free_data:
 633         kfree(data);
 634 err_unlock:
 635         mutex_unlock(&sysfs_lock);
 636         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 637         return status;
 638 }
 639 EXPORT_SYMBOL_GPL(gpiod_export);
 640
 641 static int match_export(struct device *dev, const void *desc)
 642 {
 643         struct gpiod_data *data = dev_get_drvdata(dev);
 644
 645         return data->desc == desc;
 646 }
 647
 648 /**
 649  * gpiod_export_link - create a sysfs link to an exported GPIO node
 650  * @dev: device under which to create symlink
 651  * @name: name of the symlink
 652  * @desc: GPIO to create symlink to, already exported
 653  *
 654  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 655  * node. Caller is responsible for unlinking.
 656  *
 657  * Returns zero on success, else an error.
 658  */
 659 int gpiod_export_link(struct device *dev, const char *name,
 660                       struct gpio_desc *desc)
 661 {
 662         struct device *cdev;
 663         int ret;
 664
 665         if (!desc) {
 666                 pr_warn("%s: invalid GPIO\n", __func__);
 667                 return -EINVAL;
 668         }
 669
 670         cdev = class_find_device(&gpio_class, NULL, desc, match_export);
 671         if (!cdev)
 672                 return -ENODEV;
 673
 674         ret = sysfs_create_link(&dev->kobj, &cdev->kobj, name);
 675         put_device(cdev);
 676
 677         return ret;
 678 }
 679 EXPORT_SYMBOL_GPL(gpiod_export_link);
 680
 681 /**
 682  * gpiod_unexport - reverse effect of gpiod_export()
 683  * @desc: GPIO to make unavailable
 684  *
 685  * This is implicit on gpiod_free().
 686  */
 687 void gpiod_unexport(struct gpio_desc *desc)
 688 {
 689         struct gpiod_data *data;
 690         struct device *dev;
 691
 692         if (!desc) {
 693                 pr_warn("%s: invalid GPIO\n", __func__);
 694                 return;
 695         }
 696
 697         mutex_lock(&sysfs_lock);
 698
 699         if (!test_bit(FLAG_EXPORT, &desc->flags))
 700                 goto err_unlock;
 701
 702         dev = class_find_device(&gpio_class, NULL, desc, match_export);
 703         if (!dev)
 704                 goto err_unlock;
 705
 706         data = dev_get_drvdata(dev);
 707
 708         clear_bit(FLAG_EXPORT, &desc->flags);
 709
 710         device_unregister(dev);
 711
 712         /*
 713          * Release irq after deregistration to prevent race with edge_store.
 714          */
 715         if (data->irq_flags)
 716                 gpio_sysfs_free_irq(dev);
 717
 718         mutex_unlock(&sysfs_lock);
 719
 720         put_device(dev);
 721         kfree(data);
 722
 723         return;
 724
 725 err_unlock:
 726         mutex_unlock(&sysfs_lock);
 727 }
 728 EXPORT_SYMBOL_GPL(gpiod_unexport);
 729
 730 int gpiochip_sysfs_register(struct gpio_device *gdev)
 731 {
 732         struct device   *dev;
 733         struct device   *parent;
 734         struct gpio_chip *chip = gdev->chip;
 735
 736         /*
 737          * Many systems add gpio chips for SOC support very early,
 738          * before driver model support is available.  In those cases we
 739          * register later, in gpiolib_sysfs_init() ... here we just
 740          * verify that _some_ field of gpio_class got initialized.
 741          */
 742         if (!class_is_registered(&gpio_class))
 743                 return 0;
 744
 745         /*
 746          * For sysfs backward compatibility we need to preserve this
 747          * preferred parenting to the gpio_chip parent field, if set.
 748          */
 749         if (chip->parent)
 750                 parent = chip->parent;
 751         else
 752                 parent = &gdev->dev;
 753
 754         /* use chip->base for the ID; it's already known to be unique */
 755         dev = device_create_with_groups(&gpio_class, parent, MKDEV(0, 0), chip,
 756                                         gpiochip_groups, GPIOCHIP_NAME "%d",
 757                                         chip->base);
 758         if (IS_ERR(dev))
 759                 return PTR_ERR(dev);
 760
 761         mutex_lock(&sysfs_lock);
 762         gdev->mockdev = dev;
 763         mutex_unlock(&sysfs_lock);
 764
 765         return 0;
 766 }
 767
 768 void gpiochip_sysfs_unregister(struct gpio_device *gdev)
 769 {
 770         struct gpio_desc *desc;
 771         struct gpio_chip *chip = gdev->chip;
 772
 773         if (!gdev->mockdev)
 774                 return;
 775
 776         device_unregister(gdev->mockdev);
 777
 778         /* prevent further gpiod exports */
 779         mutex_lock(&sysfs_lock);
 780         gdev->mockdev = NULL;
 781         mutex_unlock(&sysfs_lock);
 782
 783         /* unregister gpiod class devices owned by sysfs */
 784         for_each_gpio_desc_with_flag(chip, desc, FLAG_SYSFS)
 785                 gpiod_free(desc);
 786 }
 787
 788 static int __init gpiolib_sysfs_init(void)
 789 {
 790         int             status;
 791         unsigned long   flags;
 792         struct gpio_device *gdev;
 793
 794         status = class_register(&gpio_class);
 795         if (status < 0)
 796                 return status;
 797
 798         /* Scan and register the gpio_chips which registered very
 799          * early (e.g. before the class_register above was called).
 800          *
 801          * We run before arch_initcall() so chip->dev nodes can have
 802          * registered, and so arch_initcall() can always gpiod_export().
 803          */
 804         spin_lock_irqsave(&gpio_lock, flags);
 805         list_for_each_entry(gdev, &gpio_devices, list) {
 806                 if (gdev->mockdev)
 807                         continue;
 808
 809                 /*
 810                  * TODO we yield gpio_lock here because
 811                  * gpiochip_sysfs_register() acquires a mutex. This is unsafe
 812                  * and needs to be fixed.
 813                  *
 814                  * Also it would be nice to use gpiochip_find() here so we
 815                  * can keep gpio_chips local to gpiolib.c, but the yield of
 816                  * gpio_lock prevents us from doing this.
 817                  */
 818                 spin_unlock_irqrestore(&gpio_lock, flags);
 819                 status = gpiochip_sysfs_register(gdev);
 820                 spin_lock_irqsave(&gpio_lock, flags);
 821         }
 822         spin_unlock_irqrestore(&gpio_lock, flags);
 823
 824         return status;
 825 }
 826 postcore_initcall(gpiolib_sysfs_init);