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.h>
   6 #include <linux/gpio/consumer.h>
   7 #include <linux/gpio/driver.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/kdev_t.h>
  10 #include <linux/slab.h>
  11
  12 #include "gpiolib.h"
  13
  14 #define GPIO_IRQF_TRIGGER_FALLING       BIT(0)
  15 #define GPIO_IRQF_TRIGGER_RISING        BIT(1)
  16 #define GPIO_IRQF_TRIGGER_BOTH          (GPIO_IRQF_TRIGGER_FALLING | \
  17                                          GPIO_IRQF_TRIGGER_RISING)
  18
  19 struct gpiod_data {
  20         struct gpio_desc *desc;
  21
  22         struct mutex mutex;
  23         struct kernfs_node *value_kn;
  24         int irq;
  25         unsigned char irq_flags;
  26
  27         bool direction_can_change;
  28 };
  29
  30 /*
  31  * Lock to serialise gpiod export and unexport, and prevent re-export of
  32  * gpiod whose chip is being unregistered.
  33  */
  34 static DEFINE_MUTEX(sysfs_lock);
  35
  36 /*
  37  * /sys/class/gpio/gpioN... only for GPIOs that are exported
  38  *   /direction
  39  *      * MAY BE OMITTED if kernel won't allow direction changes
  40  *      * is read/write as "in" or "out"
  41  *      * may also be written as "high" or "low", initializing
  42  *        output value as specified ("out" implies "low")
  43  *   /value
  44  *      * always readable, subject to hardware behavior
  45  *      * may be writable, as zero/nonzero
  46  *   /edge
  47  *      * configures behavior of poll(2) on /value
  48  *      * available only if pin can generate IRQs on input
  49  *      * is read/write as "none", "falling", "rising", or "both"
  50  *   /active_low
  51  *      * configures polarity of /value
  52  *      * is read/write as zero/nonzero
  53  *      * also affects existing and subsequent "falling" and "rising"
  54  *        /edge configuration
  55  */
  56
  57 static ssize_t direction_show(struct device *dev,
  58                 struct device_attribute *attr, char *buf)
  59 {
  60         struct gpiod_data *data = dev_get_drvdata(dev);
  61         struct gpio_desc *desc = data->desc;
  62         ssize_t                 status;
  63
  64         mutex_lock(&data->mutex);
  65
  66         gpiod_get_direction(desc);
  67         status = sprintf(buf, "%s\n",
  68                         test_bit(FLAG_IS_OUT, &desc->flags)
  69                                 ? "out" : "in");
  70
  71         mutex_unlock(&data->mutex);
  72
  73         return status;
  74 }
  75
  76 static ssize_t direction_store(struct device *dev,
  77                 struct device_attribute *attr, const char *buf, size_t size)
  78 {
  79         struct gpiod_data *data = dev_get_drvdata(dev);
  80         struct gpio_desc *desc = data->desc;
  81         ssize_t                 status;
  82
  83         mutex_lock(&data->mutex);
  84
  85         if (sysfs_streq(buf, "high"))
  86                 status = gpiod_direction_output_raw(desc, 1);
  87         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
  88                 status = gpiod_direction_output_raw(desc, 0);
  89         else if (sysfs_streq(buf, "in"))
  90                 status = gpiod_direction_input(desc);
  91         else
  92                 status = -EINVAL;
  93
  94         mutex_unlock(&data->mutex);
  95
  96         return status ? : size;
  97 }
  98 static DEVICE_ATTR_RW(direction);
  99
 100 static ssize_t value_show(struct device *dev,
 101                 struct device_attribute *attr, char *buf)
 102 {
 103         struct gpiod_data *data = dev_get_drvdata(dev);
 104         struct gpio_desc *desc = data->desc;
 105         ssize_t                 status;
 106
 107         mutex_lock(&data->mutex);
 108
 109         status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
 110
 111         mutex_unlock(&data->mutex);
 112
 113         return status;
 114 }
 115
 116 static ssize_t value_store(struct device *dev,
 117                 struct device_attribute *attr, const char *buf, size_t size)
 118 {
 119         struct gpiod_data *data = dev_get_drvdata(dev);
 120         struct gpio_desc *desc = data->desc;
 121         ssize_t                 status;
 122
 123         mutex_lock(&data->mutex);
 124
 125         if (!test_bit(FLAG_IS_OUT, &desc->flags)) {
 126                 status = -EPERM;
 127         } else {
 128                 long            value;
 129
 130                 status = kstrtol(buf, 0, &value);
 131                 if (status == 0) {
 132                         gpiod_set_value_cansleep(desc, value);
 133                         status = size;
 134                 }
 135         }
 136
 137         mutex_unlock(&data->mutex);
 138
 139         return status;
 140 }
 141 static DEVICE_ATTR_RW(value);
 142
 143 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
 144 {
 145         struct gpiod_data *data = priv;
 146
 147         sysfs_notify_dirent(data->value_kn);
 148
 149         return IRQ_HANDLED;
 150 }
 151
 152 /* Caller holds gpiod-data mutex. */
 153 static int gpio_sysfs_request_irq(struct device *dev, unsigned char flags)
 154 {
 155         struct gpiod_data       *data = dev_get_drvdata(dev);
 156         struct gpio_desc        *desc = data->desc;
 157         unsigned long           irq_flags;
 158         int                     ret;
 159
 160         data->irq = gpiod_to_irq(desc);
 161         if (data->irq < 0)
 162                 return -EIO;
 163
 164         data->value_kn = sysfs_get_dirent(dev->kobj.sd, "value");
 165         if (!data->value_kn)
 166                 return -ENODEV;
 167
 168         irq_flags = IRQF_SHARED;
 169         if (flags & GPIO_IRQF_TRIGGER_FALLING)
 170                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 171                         IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
 172         if (flags & GPIO_IRQF_TRIGGER_RISING)
 173                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
 174                         IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
 175
 176         /*
 177          * FIXME: This should be done in the irq_request_resources callback
 178          *        when the irq is requested, but a few drivers currently fail
 179          *        to do so.
 180          *
 181          *        Remove this redundant call (along with the corresponding
 182          *        unlock) when those drivers have been fixed.
 183          */
 184         ret = gpiochip_lock_as_irq(desc->gdev->chip, gpio_chip_hwgpio(desc));
 185         if (ret < 0)
 186                 goto err_put_kn;
 187
 188         ret = request_any_context_irq(data->irq, gpio_sysfs_irq, irq_flags,
 189                                 "gpiolib", data);
 190         if (ret < 0)
 191                 goto err_unlock;
 192
 193         data->irq_flags = flags;
 194
 195         return 0;
 196
 197 err_unlock:
 198         gpiochip_unlock_as_irq(desc->gdev->chip, gpio_chip_hwgpio(desc));
 199 err_put_kn:
 200         sysfs_put(data->value_kn);
 201
 202         return ret;
 203 }
 204
 205 /*
 206  * Caller holds gpiod-data mutex (unless called after class-device
 207  * deregistration).
 208  */
 209 static void gpio_sysfs_free_irq(struct device *dev)
 210 {
 211         struct gpiod_data *data = dev_get_drvdata(dev);
 212         struct gpio_desc *desc = data->desc;
 213
 214         data->irq_flags = 0;
 215         free_irq(data->irq, data);
 216         gpiochip_unlock_as_irq(desc->gdev->chip, gpio_chip_hwgpio(desc));
 217         sysfs_put(data->value_kn);
 218 }
 219
 220 static const struct {
 221         const char *name;
 222         unsigned char flags;
 223 } trigger_types[] = {
 224         { "none",    0 },
 225         { "falling", GPIO_IRQF_TRIGGER_FALLING },
 226         { "rising",  GPIO_IRQF_TRIGGER_RISING },
 227         { "both",    GPIO_IRQF_TRIGGER_BOTH },
 228 };
 229
 230 static ssize_t edge_show(struct device *dev,
 231                 struct device_attribute *attr, char *buf)
 232 {
 233         struct gpiod_data *data = dev_get_drvdata(dev);
 234         ssize_t status = 0;
 235         int i;
 236
 237         mutex_lock(&data->mutex);
 238
 239         for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
 240                 if (data->irq_flags == trigger_types[i].flags) {
 241                         status = sprintf(buf, "%s\n", trigger_types[i].name);
 242                         break;
 243                 }
 244         }
 245
 246         mutex_unlock(&data->mutex);
 247
 248         return status;
 249 }
 250
 251 static ssize_t edge_store(struct device *dev,
 252                 struct device_attribute *attr, const char *buf, size_t size)
 253 {
 254         struct gpiod_data *data = dev_get_drvdata(dev);
 255         unsigned char flags;
 256         ssize_t status = size;
 257         int i;
 258
 259         for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
 260                 if (sysfs_streq(trigger_types[i].name, buf))
 261                         break;
 262         }
 263
 264         if (i == ARRAY_SIZE(trigger_types))
 265                 return -EINVAL;
 266
 267         flags = trigger_types[i].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         if (value)
 304                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
 305         else
 306                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
 307
 308         /* reconfigure poll(2) support if enabled on one edge only */
 309         if (flags == GPIO_IRQF_TRIGGER_FALLING ||
 310                                         flags == GPIO_IRQF_TRIGGER_RISING) {
 311                 gpio_sysfs_free_irq(dev);
 312                 status = gpio_sysfs_request_irq(dev, flags);
 313         }
 314
 315         return status;
 316 }
 317
 318 static ssize_t active_low_show(struct device *dev,
 319                 struct device_attribute *attr, char *buf)
 320 {
 321         struct gpiod_data *data = dev_get_drvdata(dev);
 322         struct gpio_desc *desc = data->desc;
 323         ssize_t                 status;
 324
 325         mutex_lock(&data->mutex);
 326
 327         status = sprintf(buf, "%d\n",
 328                                 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
 329
 330         mutex_unlock(&data->mutex);
 331
 332         return status;
 333 }
 334
 335 static ssize_t active_low_store(struct device *dev,
 336                 struct device_attribute *attr, const char *buf, size_t size)
 337 {
 338         struct gpiod_data       *data = dev_get_drvdata(dev);
 339         ssize_t                 status;
 340         long                    value;
 341
 342         mutex_lock(&data->mutex);
 343
 344         status = kstrtol(buf, 0, &value);
 345         if (status == 0)
 346                 status = gpio_sysfs_set_active_low(dev, value);
 347
 348         mutex_unlock(&data->mutex);
 349
 350         return status ? : size;
 351 }
 352 static DEVICE_ATTR_RW(active_low);
 353
 354 static umode_t gpio_is_visible(struct kobject *kobj, struct attribute *attr,
 355                                int n)
 356 {
 357         struct device *dev = container_of(kobj, struct device, kobj);
 358         struct gpiod_data *data = dev_get_drvdata(dev);
 359         struct gpio_desc *desc = data->desc;
 360         umode_t mode = attr->mode;
 361         bool show_direction = data->direction_can_change;
 362
 363         if (attr == &dev_attr_direction.attr) {
 364                 if (!show_direction)
 365                         mode = 0;
 366         } else if (attr == &dev_attr_edge.attr) {
 367                 if (gpiod_to_irq(desc) < 0)
 368                         mode = 0;
 369                 if (!show_direction && test_bit(FLAG_IS_OUT, &desc->flags))
 370                         mode = 0;
 371         }
 372
 373         return mode;
 374 }
 375
 376 static struct attribute *gpio_attrs[] = {
 377         &dev_attr_direction.attr,
 378         &dev_attr_edge.attr,
 379         &dev_attr_value.attr,
 380         &dev_attr_active_low.attr,
 381         NULL,
 382 };
 383
 384 static const struct attribute_group gpio_group = {
 385         .attrs = gpio_attrs,
 386         .is_visible = gpio_is_visible,
 387 };
 388
 389 static const struct attribute_group *gpio_groups[] = {
 390         &gpio_group,
 391         NULL
 392 };
 393
 394 /*
 395  * /sys/class/gpio/gpiochipN/
 396  *   /base ... matching gpio_chip.base (N)
 397  *   /label ... matching gpio_chip.label
 398  *   /ngpio ... matching gpio_chip.ngpio
 399  */
 400
 401 static ssize_t base_show(struct device *dev,
 402                                struct device_attribute *attr, char *buf)
 403 {
 404         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 405
 406         return sprintf(buf, "%d\n", chip->base);
 407 }
 408 static DEVICE_ATTR_RO(base);
 409
 410 static ssize_t label_show(struct device *dev,
 411                                struct device_attribute *attr, char *buf)
 412 {
 413         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 414
 415         return sprintf(buf, "%s\n", chip->label ? : "");
 416 }
 417 static DEVICE_ATTR_RO(label);
 418
 419 static ssize_t ngpio_show(struct device *dev,
 420                                struct device_attribute *attr, char *buf)
 421 {
 422         const struct gpio_chip  *chip = dev_get_drvdata(dev);
 423
 424         return sprintf(buf, "%u\n", chip->ngpio);
 425 }
 426 static DEVICE_ATTR_RO(ngpio);
 427
 428 static struct attribute *gpiochip_attrs[] = {
 429         &dev_attr_base.attr,
 430         &dev_attr_label.attr,
 431         &dev_attr_ngpio.attr,
 432         NULL,
 433 };
 434 ATTRIBUTE_GROUPS(gpiochip);
 435
 436 static struct gpio_desc *gpio_to_valid_desc(int gpio)
 437 {
 438         return gpio_is_valid(gpio) ? gpio_to_desc(gpio) : NULL;
 439 }
 440
 441 /*
 442  * /sys/class/gpio/export ... write-only
 443  *      integer N ... number of GPIO to export (full access)
 444  * /sys/class/gpio/unexport ... write-only
 445  *      integer N ... number of GPIO to unexport
 446  */
 447 static ssize_t export_store(struct class *class,
 448                                 struct class_attribute *attr,
 449                                 const char *buf, size_t len)
 450 {
 451         long                    gpio;
 452         struct gpio_desc        *desc;
 453         int                     status;
 454
 455         status = kstrtol(buf, 0, &gpio);
 456         if (status < 0)
 457                 goto done;
 458
 459         desc = gpio_to_valid_desc(gpio);
 460         /* reject invalid GPIOs */
 461         if (!desc) {
 462                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 463                 return -EINVAL;
 464         }
 465
 466         /* No extra locking here; FLAG_SYSFS just signifies that the
 467          * request and export were done by on behalf of userspace, so
 468          * they may be undone on its behalf too.
 469          */
 470
 471         status = gpiod_request(desc, "sysfs");
 472         if (status < 0) {
 473                 if (status == -EPROBE_DEFER)
 474                         status = -ENODEV;
 475                 goto done;
 476         }
 477         status = gpiod_export(desc, true);
 478         if (status < 0)
 479                 gpiod_free(desc);
 480         else
 481                 set_bit(FLAG_SYSFS, &desc->flags);
 482
 483 done:
 484         if (status)
 485                 pr_debug("%s: status %d\n", __func__, status);
 486         return status ? : len;
 487 }
 488 static CLASS_ATTR_WO(export);
 489
 490 static ssize_t unexport_store(struct class *class,
 491                                 struct class_attribute *attr,
 492                                 const char *buf, size_t len)
 493 {
 494         long                    gpio;
 495         struct gpio_desc        *desc;
 496         int                     status;
 497
 498         status = kstrtol(buf, 0, &gpio);
 499         if (status < 0)
 500                 goto done;
 501
 502         desc = gpio_to_valid_desc(gpio);
 503         /* reject bogus commands (gpio_unexport ignores them) */
 504         if (!desc) {
 505                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 506                 return -EINVAL;
 507         }
 508
 509         status = -EINVAL;
 510
 511         /* No extra locking here; FLAG_SYSFS just signifies that the
 512          * request and export were done by on behalf of userspace, so
 513          * they may be undone on its behalf too.
 514          */
 515         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
 516                 status = 0;
 517                 gpiod_free(desc);
 518         }
 519 done:
 520         if (status)
 521                 pr_debug("%s: status %d\n", __func__, status);
 522         return status ? : len;
 523 }
 524 static CLASS_ATTR_WO(unexport);
 525
 526 static struct attribute *gpio_class_attrs[] = {
 527         &class_attr_export.attr,
 528         &class_attr_unexport.attr,
 529         NULL,
 530 };
 531 ATTRIBUTE_GROUPS(gpio_class);
 532
 533 static struct class gpio_class = {
 534         .name =         "gpio",
 535         .owner =        THIS_MODULE,
 536
 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 (!gpio_class.p) {
 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 (!gpio_class.p)
 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,
 756                                         MKDEV(0, 0),
 757                                         chip, gpiochip_groups,
 758                                         "gpiochip%d", 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         unsigned int i;
 774
 775         if (!gdev->mockdev)
 776                 return;
 777
 778         device_unregister(gdev->mockdev);
 779
 780         /* prevent further gpiod exports */
 781         mutex_lock(&sysfs_lock);
 782         gdev->mockdev = NULL;
 783         mutex_unlock(&sysfs_lock);
 784
 785         /* unregister gpiod class devices owned by sysfs */
 786         for (i = 0; i < chip->ngpio; i++) {
 787                 desc = &gdev->descs[i];
 788                 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags))
 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 gpio_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 gpiochip_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);