drivers/gpio/gpiolib-sysfs.c

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