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         unsigned int flags = data->irq_flags;
 297         struct gpio_desc *desc = data->desc;
 298         int status = 0;
 299
 300
 301         if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
 302                 return 0;
 303
 304         assign_bit(FLAG_ACTIVE_LOW, &desc->flags, value);
 305
 306         /* reconfigure poll(2) support if enabled on one edge only */
 307         if (flags == GPIO_IRQF_TRIGGER_FALLING ||
 308                                         flags == GPIO_IRQF_TRIGGER_RISING) {
 309                 gpio_sysfs_free_irq(dev);
 310                 status = gpio_sysfs_request_irq(dev, flags);
 311         }
 312
 313         return status;
 314 }
 315
 316 static ssize_t active_low_show(struct device *dev,
 317                 struct device_attribute *attr, char *buf)
 318 {
 319         struct gpiod_data *data = dev_get_drvdata(dev);
 320         struct gpio_desc *desc = data->desc;
 321         int value;
 322
 323         mutex_lock(&data->mutex);
 324
 325         value = !!test_bit(FLAG_ACTIVE_LOW, &desc->flags);
 326
 327         mutex_unlock(&data->mutex);
 328
 329         return sysfs_emit(buf, "%d\n", value);
 330 }
 331
 332 static ssize_t active_low_store(struct device *dev,
 333                 struct device_attribute *attr, const char *buf, size_t size)
 334 {
 335         struct gpiod_data *data = dev_get_drvdata(dev);
 336         ssize_t status;
 337         long value;
 338
 339         status = kstrtol(buf, 0, &value);
 340         if (status)
 341                 return status;
 342
 343         mutex_lock(&data->mutex);
 344
 345         status = gpio_sysfs_set_active_low(dev, value);
 346
 347         mutex_unlock(&data->mutex);
 348
 349         return status ? : size;
 350 }
 351 static DEVICE_ATTR_RW(active_low);
 352
 353 static umode_t gpio_is_visible(struct kobject *kobj, struct attribute *attr,
 354                                int n)
 355 {
 356         struct device *dev = kobj_to_dev(kobj);
 357         struct gpiod_data *data = dev_get_drvdata(dev);
 358         struct gpio_desc *desc = data->desc;
 359         umode_t mode = attr->mode;
 360         bool show_direction = data->direction_can_change;
 361
 362         if (attr == &dev_attr_direction.attr) {
 363                 if (!show_direction)
 364                         mode = 0;
 365         } else if (attr == &dev_attr_edge.attr) {
 366                 if (gpiod_to_irq(desc) < 0)
 367                         mode = 0;
 368                 if (!show_direction && test_bit(FLAG_IS_OUT, &desc->flags))
 369                         mode = 0;
 370         }
 371
 372         return mode;
 373 }
 374
 375 static struct attribute *gpio_attrs[] = {
 376         &dev_attr_direction.attr,
 377         &dev_attr_edge.attr,
 378         &dev_attr_value.attr,
 379         &dev_attr_active_low.attr,
 380         NULL,
 381 };
 382
 383 static const struct attribute_group gpio_group = {
 384         .attrs = gpio_attrs,
 385         .is_visible = gpio_is_visible,
 386 };
 387
 388 static const struct attribute_group *gpio_groups[] = {
 389         &gpio_group,
 390         NULL
 391 };
 392
 393 /*
 394  * /sys/class/gpio/gpiochipN/
 395  *   /base ... matching gpio_chip.base (N)
 396  *   /label ... matching gpio_chip.label
 397  *   /ngpio ... matching gpio_chip.ngpio
 398  */
 399
 400 static ssize_t base_show(struct device *dev,
 401                                struct device_attribute *attr, char *buf)
 402 {
 403         const struct gpio_chip *chip = dev_get_drvdata(dev);
 404
 405         return sysfs_emit(buf, "%d\n", chip->base);
 406 }
 407 static DEVICE_ATTR_RO(base);
 408
 409 static ssize_t label_show(struct device *dev,
 410                                struct device_attribute *attr, char *buf)
 411 {
 412         const struct gpio_chip *chip = dev_get_drvdata(dev);
 413
 414         return sysfs_emit(buf, "%s\n", chip->label ?: "");
 415 }
 416 static DEVICE_ATTR_RO(label);
 417
 418 static ssize_t ngpio_show(struct device *dev,
 419                                struct device_attribute *attr, char *buf)
 420 {
 421         const struct gpio_chip *chip = dev_get_drvdata(dev);
 422
 423         return sysfs_emit(buf, "%u\n", chip->ngpio);
 424 }
 425 static DEVICE_ATTR_RO(ngpio);
 426
 427 static struct attribute *gpiochip_attrs[] = {
 428         &dev_attr_base.attr,
 429         &dev_attr_label.attr,
 430         &dev_attr_ngpio.attr,
 431         NULL,
 432 };
 433 ATTRIBUTE_GROUPS(gpiochip);
 434
 435 /*
 436  * /sys/class/gpio/export ... write-only
 437  *      integer N ... number of GPIO to export (full access)
 438  * /sys/class/gpio/unexport ... write-only
 439  *      integer N ... number of GPIO to unexport
 440  */
 441 static ssize_t export_store(const struct class *class,
 442                                 const struct class_attribute *attr,
 443                                 const char *buf, size_t len)
 444 {
 445         struct gpio_desc *desc;
 446         struct gpio_chip *gc;
 447         int status, offset;
 448         long gpio;
 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                 gpiod_free(desc);
 479                 goto done;
 480         }
 481
 482         status = gpiod_export(desc, true);
 483         if (status < 0)
 484                 gpiod_free(desc);
 485         else
 486                 set_bit(FLAG_SYSFS, &desc->flags);
 487
 488 done:
 489         if (status)
 490                 pr_debug("%s: status %d\n", __func__, status);
 491         return status ? : len;
 492 }
 493 static CLASS_ATTR_WO(export);
 494
 495 static ssize_t unexport_store(const struct class *class,
 496                                 const struct class_attribute *attr,
 497                                 const char *buf, size_t len)
 498 {
 499         struct gpio_desc *desc;
 500         int status;
 501         long gpio;
 502
 503         status = kstrtol(buf, 0, &gpio);
 504         if (status < 0)
 505                 goto done;
 506
 507         desc = gpio_to_desc(gpio);
 508         /* reject bogus commands (gpiod_unexport() ignores them) */
 509         if (!desc) {
 510                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 511                 return -EINVAL;
 512         }
 513
 514         status = -EINVAL;
 515
 516         /* No extra locking here; FLAG_SYSFS just signifies that the
 517          * request and export were done by on behalf of userspace, so
 518          * they may be undone on its behalf too.
 519          */
 520         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
 521                 gpiod_unexport(desc);
 522                 gpiod_free(desc);
 523                 status = 0;
 524         }
 525 done:
 526         if (status)
 527                 pr_debug("%s: status %d\n", __func__, status);
 528         return status ? : len;
 529 }
 530 static CLASS_ATTR_WO(unexport);
 531
 532 static struct attribute *gpio_class_attrs[] = {
 533         &class_attr_export.attr,
 534         &class_attr_unexport.attr,
 535         NULL,
 536 };
 537 ATTRIBUTE_GROUPS(gpio_class);
 538
 539 static struct class gpio_class = {
 540         .name =         "gpio",
 541         .class_groups = gpio_class_groups,
 542 };
 543
 544
 545 /**
 546  * gpiod_export - export a GPIO through sysfs
 547  * @desc: GPIO to make available, already requested
 548  * @direction_may_change: true if userspace may change GPIO direction
 549  * Context: arch_initcall or later
 550  *
 551  * When drivers want to make a GPIO accessible to userspace after they
 552  * have requested it -- perhaps while debugging, or as part of their
 553  * public interface -- they may use this routine.  If the GPIO can
 554  * change direction (some can't) and the caller allows it, userspace
 555  * will see "direction" sysfs attribute which may be used to change
 556  * the gpio's direction.  A "value" attribute will always be provided.
 557  *
 558  * Returns zero on success, else an error.
 559  */
 560 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 561 {
 562         const char *ioname = NULL;
 563         struct gpio_device *gdev;
 564         struct gpiod_data *data;
 565         struct gpio_chip *chip;
 566         unsigned long flags;
 567         struct device *dev;
 568         int status, offset;
 569
 570         /* can't export until sysfs is available ... */
 571         if (!class_is_registered(&gpio_class)) {
 572                 pr_debug("%s: called too early!\n", __func__);
 573                 return -ENOENT;
 574         }
 575
 576         if (!desc) {
 577                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 578                 return -EINVAL;
 579         }
 580
 581         gdev = desc->gdev;
 582         chip = gdev->chip;
 583
 584         mutex_lock(&sysfs_lock);
 585
 586         /* check if chip is being removed */
 587         if (!chip || !gdev->mockdev) {
 588                 status = -ENODEV;
 589                 goto err_unlock;
 590         }
 591
 592         spin_lock_irqsave(&gpio_lock, flags);
 593         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
 594              test_bit(FLAG_EXPORT, &desc->flags)) {
 595                 spin_unlock_irqrestore(&gpio_lock, flags);
 596                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
 597                                 __func__,
 598                                 test_bit(FLAG_REQUESTED, &desc->flags),
 599                                 test_bit(FLAG_EXPORT, &desc->flags));
 600                 status = -EPERM;
 601                 goto err_unlock;
 602         }
 603         spin_unlock_irqrestore(&gpio_lock, flags);
 604
 605         data = kzalloc(sizeof(*data), GFP_KERNEL);
 606         if (!data) {
 607                 status = -ENOMEM;
 608                 goto err_unlock;
 609         }
 610
 611         data->desc = desc;
 612         mutex_init(&data->mutex);
 613         if (chip->direction_input && chip->direction_output)
 614                 data->direction_can_change = direction_may_change;
 615         else
 616                 data->direction_can_change = false;
 617
 618         offset = gpio_chip_hwgpio(desc);
 619         if (chip->names && chip->names[offset])
 620                 ioname = chip->names[offset];
 621
 622         dev = device_create_with_groups(&gpio_class, &gdev->dev,
 623                                         MKDEV(0, 0), data, gpio_groups,
 624                                         ioname ? ioname : "gpio%u",
 625                                         desc_to_gpio(desc));
 626         if (IS_ERR(dev)) {
 627                 status = PTR_ERR(dev);
 628                 goto err_free_data;
 629         }
 630
 631         set_bit(FLAG_EXPORT, &desc->flags);
 632         mutex_unlock(&sysfs_lock);
 633         return 0;
 634
 635 err_free_data:
 636         kfree(data);
 637 err_unlock:
 638         mutex_unlock(&sysfs_lock);
 639         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 640         return status;
 641 }
 642 EXPORT_SYMBOL_GPL(gpiod_export);
 643
 644 static int match_export(struct device *dev, const void *desc)
 645 {
 646         struct gpiod_data *data = dev_get_drvdata(dev);
 647
 648         return data->desc == desc;
 649 }
 650
 651 /**
 652  * gpiod_export_link - create a sysfs link to an exported GPIO node
 653  * @dev: device under which to create symlink
 654  * @name: name of the symlink
 655  * @desc: GPIO to create symlink to, already exported
 656  *
 657  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 658  * node. Caller is responsible for unlinking.
 659  *
 660  * Returns zero on success, else an error.
 661  */
 662 int gpiod_export_link(struct device *dev, const char *name,
 663                       struct gpio_desc *desc)
 664 {
 665         struct device *cdev;
 666         int ret;
 667
 668         if (!desc) {
 669                 pr_warn("%s: invalid GPIO\n", __func__);
 670                 return -EINVAL;
 671         }
 672
 673         cdev = class_find_device(&gpio_class, NULL, desc, match_export);
 674         if (!cdev)
 675                 return -ENODEV;
 676
 677         ret = sysfs_create_link(&dev->kobj, &cdev->kobj, name);
 678         put_device(cdev);
 679
 680         return ret;
 681 }
 682 EXPORT_SYMBOL_GPL(gpiod_export_link);
 683
 684 /**
 685  * gpiod_unexport - reverse effect of gpiod_export()
 686  * @desc: GPIO to make unavailable
 687  *
 688  * This is implicit on gpiod_free().
 689  */
 690 void gpiod_unexport(struct gpio_desc *desc)
 691 {
 692         struct gpiod_data *data;
 693         struct device *dev;
 694
 695         if (!desc) {
 696                 pr_warn("%s: invalid GPIO\n", __func__);
 697                 return;
 698         }
 699
 700         mutex_lock(&sysfs_lock);
 701
 702         if (!test_bit(FLAG_EXPORT, &desc->flags))
 703                 goto err_unlock;
 704
 705         dev = class_find_device(&gpio_class, NULL, desc, match_export);
 706         if (!dev)
 707                 goto err_unlock;
 708
 709         data = dev_get_drvdata(dev);
 710
 711         clear_bit(FLAG_EXPORT, &desc->flags);
 712
 713         device_unregister(dev);
 714
 715         /*
 716          * Release irq after deregistration to prevent race with edge_store.
 717          */
 718         if (data->irq_flags)
 719                 gpio_sysfs_free_irq(dev);
 720
 721         mutex_unlock(&sysfs_lock);
 722
 723         put_device(dev);
 724         kfree(data);
 725
 726         return;
 727
 728 err_unlock:
 729         mutex_unlock(&sysfs_lock);
 730 }
 731 EXPORT_SYMBOL_GPL(gpiod_unexport);
 732
 733 int gpiochip_sysfs_register(struct gpio_device *gdev)
 734 {
 735         struct gpio_chip *chip = gdev->chip;
 736         struct device *parent;
 737         struct device *dev;
 738
 739         /*
 740          * Many systems add gpio chips for SOC support very early,
 741          * before driver model support is available.  In those cases we
 742          * register later, in gpiolib_sysfs_init() ... here we just
 743          * verify that _some_ field of gpio_class got initialized.
 744          */
 745         if (!class_is_registered(&gpio_class))
 746                 return 0;
 747
 748         /*
 749          * For sysfs backward compatibility we need to preserve this
 750          * preferred parenting to the gpio_chip parent field, if set.
 751          */
 752         if (chip->parent)
 753                 parent = chip->parent;
 754         else
 755                 parent = &gdev->dev;
 756
 757         /* use chip->base for the ID; it's already known to be unique */
 758         dev = device_create_with_groups(&gpio_class, parent, MKDEV(0, 0), chip,
 759                                         gpiochip_groups, GPIOCHIP_NAME "%d",
 760                                         chip->base);
 761         if (IS_ERR(dev))
 762                 return PTR_ERR(dev);
 763
 764         mutex_lock(&sysfs_lock);
 765         gdev->mockdev = dev;
 766         mutex_unlock(&sysfs_lock);
 767
 768         return 0;
 769 }
 770
 771 void gpiochip_sysfs_unregister(struct gpio_device *gdev)
 772 {
 773         struct gpio_desc *desc;
 774         struct gpio_chip *chip = gdev->chip;
 775
 776         if (!gdev->mockdev)
 777                 return;
 778
 779         device_unregister(gdev->mockdev);
 780
 781         /* prevent further gpiod exports */
 782         mutex_lock(&sysfs_lock);
 783         gdev->mockdev = NULL;
 784         mutex_unlock(&sysfs_lock);
 785
 786         /* unregister gpiod class devices owned by sysfs */
 787         for_each_gpio_desc_with_flag(chip, desc, FLAG_SYSFS) {
 788                 gpiod_unexport(desc);
 789                 gpiod_free(desc);
 790         }
 791 }
 792
 793 static int __init gpiolib_sysfs_init(void)
 794 {
 795         int             status;
 796         unsigned long   flags;
 797         struct gpio_device *gdev;
 798
 799         status = class_register(&gpio_class);
 800         if (status < 0)
 801                 return status;
 802
 803         /* Scan and register the gpio_chips which registered very
 804          * early (e.g. before the class_register above was called).
 805          *
 806          * We run before arch_initcall() so chip->dev nodes can have
 807          * registered, and so arch_initcall() can always gpiod_export().
 808          */
 809         spin_lock_irqsave(&gpio_lock, flags);
 810         list_for_each_entry(gdev, &gpio_devices, list) {
 811                 if (gdev->mockdev)
 812                         continue;
 813
 814                 /*
 815                  * TODO we yield gpio_lock here because
 816                  * gpiochip_sysfs_register() acquires a mutex. This is unsafe
 817                  * and needs to be fixed.
 818                  *
 819                  * Also it would be nice to use gpio_device_find() here so we
 820                  * can keep gpio_chips local to gpiolib.c, but the yield of
 821                  * gpio_lock prevents us from doing this.
 822                  */
 823                 spin_unlock_irqrestore(&gpio_lock, flags);
 824                 status = gpiochip_sysfs_register(gdev);
 825                 spin_lock_irqsave(&gpio_lock, flags);
 826         }
 827         spin_unlock_irqrestore(&gpio_lock, flags);
 828
 829         return status;
 830 }
 831 postcore_initcall(gpiolib_sysfs_init);