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 const struct attribute *gpiochip_attrs[] = {
 404         &dev_attr_base.attr,
 405         &dev_attr_label.attr,
 406         &dev_attr_ngpio.attr,
 407         NULL,
 408 };
 409
 410 static const struct attribute_group gpiochip_attr_group = {
 411         .attrs = (struct attribute **) gpiochip_attrs,
 412 };
 413
 414 /*
 415  * /sys/class/gpio/export ... write-only
 416  *      integer N ... number of GPIO to export (full access)
 417  * /sys/class/gpio/unexport ... write-only
 418  *      integer N ... number of GPIO to unexport
 419  */
 420 static ssize_t export_store(struct class *class,
 421                                 struct class_attribute *attr,
 422                                 const char *buf, size_t len)
 423 {
 424         long                    gpio;
 425         struct gpio_desc        *desc;
 426         int                     status;
 427
 428         status = kstrtol(buf, 0, &gpio);
 429         if (status < 0)
 430                 goto done;
 431
 432         desc = gpio_to_desc(gpio);
 433         /* reject invalid GPIOs */
 434         if (!desc) {
 435                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 436                 return -EINVAL;
 437         }
 438
 439         /* No extra locking here; FLAG_SYSFS just signifies that the
 440          * request and export were done by on behalf of userspace, so
 441          * they may be undone on its behalf too.
 442          */
 443
 444         status = gpiod_request(desc, "sysfs");
 445         if (status < 0) {
 446                 if (status == -EPROBE_DEFER)
 447                         status = -ENODEV;
 448                 goto done;
 449         }
 450         status = gpiod_export(desc, true);
 451         if (status < 0)
 452                 gpiod_free(desc);
 453         else
 454                 set_bit(FLAG_SYSFS, &desc->flags);
 455
 456 done:
 457         if (status)
 458                 pr_debug("%s: status %d\n", __func__, status);
 459         return status ? : len;
 460 }
 461
 462 static ssize_t unexport_store(struct class *class,
 463                                 struct class_attribute *attr,
 464                                 const char *buf, size_t len)
 465 {
 466         long                    gpio;
 467         struct gpio_desc        *desc;
 468         int                     status;
 469
 470         status = kstrtol(buf, 0, &gpio);
 471         if (status < 0)
 472                 goto done;
 473
 474         desc = gpio_to_desc(gpio);
 475         /* reject bogus commands (gpio_unexport ignores them) */
 476         if (!desc) {
 477                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 478                 return -EINVAL;
 479         }
 480
 481         status = -EINVAL;
 482
 483         /* No extra locking here; FLAG_SYSFS just signifies that the
 484          * request and export were done by on behalf of userspace, so
 485          * they may be undone on its behalf too.
 486          */
 487         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
 488                 status = 0;
 489                 gpiod_free(desc);
 490         }
 491 done:
 492         if (status)
 493                 pr_debug("%s: status %d\n", __func__, status);
 494         return status ? : len;
 495 }
 496
 497 static struct class_attribute gpio_class_attrs[] = {
 498         __ATTR(export, 0200, NULL, export_store),
 499         __ATTR(unexport, 0200, NULL, unexport_store),
 500         __ATTR_NULL,
 501 };
 502
 503 static struct class gpio_class = {
 504         .name =         "gpio",
 505         .owner =        THIS_MODULE,
 506
 507         .class_attrs =  gpio_class_attrs,
 508 };
 509
 510
 511 /**
 512  * gpiod_export - export a GPIO through sysfs
 513  * @gpio: gpio to make available, already requested
 514  * @direction_may_change: true if userspace may change gpio direction
 515  * Context: arch_initcall or later
 516  *
 517  * When drivers want to make a GPIO accessible to userspace after they
 518  * have requested it -- perhaps while debugging, or as part of their
 519  * public interface -- they may use this routine.  If the GPIO can
 520  * change direction (some can't) and the caller allows it, userspace
 521  * will see "direction" sysfs attribute which may be used to change
 522  * the gpio's direction.  A "value" attribute will always be provided.
 523  *
 524  * Returns zero on success, else an error.
 525  */
 526 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 527 {
 528         unsigned long           flags;
 529         int                     status;
 530         const char              *ioname = NULL;
 531         struct device           *dev;
 532         int                     offset;
 533
 534         /* can't export until sysfs is available ... */
 535         if (!gpio_class.p) {
 536                 pr_debug("%s: called too early!\n", __func__);
 537                 return -ENOENT;
 538         }
 539
 540         if (!desc) {
 541                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 542                 return -EINVAL;
 543         }
 544
 545         mutex_lock(&sysfs_lock);
 546
 547         spin_lock_irqsave(&gpio_lock, flags);
 548         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
 549              test_bit(FLAG_EXPORT, &desc->flags)) {
 550                 spin_unlock_irqrestore(&gpio_lock, flags);
 551                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
 552                                 __func__,
 553                                 test_bit(FLAG_REQUESTED, &desc->flags),
 554                                 test_bit(FLAG_EXPORT, &desc->flags));
 555                 status = -EPERM;
 556                 goto fail_unlock;
 557         }
 558
 559         if (!desc->chip->direction_input || !desc->chip->direction_output)
 560                 direction_may_change = false;
 561         spin_unlock_irqrestore(&gpio_lock, flags);
 562
 563         offset = gpio_chip_hwgpio(desc);
 564         if (desc->chip->names && desc->chip->names[offset])
 565                 ioname = desc->chip->names[offset];
 566
 567         dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
 568                             desc, ioname ? ioname : "gpio%u",
 569                             desc_to_gpio(desc));
 570         if (IS_ERR(dev)) {
 571                 status = PTR_ERR(dev);
 572                 goto fail_unlock;
 573         }
 574
 575         status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
 576         if (status)
 577                 goto fail_unregister_device;
 578
 579         if (direction_may_change) {
 580                 status = device_create_file(dev, &dev_attr_direction);
 581                 if (status)
 582                         goto fail_unregister_device;
 583         }
 584
 585         if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
 586                                        !test_bit(FLAG_IS_OUT, &desc->flags))) {
 587                 status = device_create_file(dev, &dev_attr_edge);
 588                 if (status)
 589                         goto fail_unregister_device;
 590         }
 591
 592         set_bit(FLAG_EXPORT, &desc->flags);
 593         mutex_unlock(&sysfs_lock);
 594         return 0;
 595
 596 fail_unregister_device:
 597         device_unregister(dev);
 598 fail_unlock:
 599         mutex_unlock(&sysfs_lock);
 600         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 601         return status;
 602 }
 603 EXPORT_SYMBOL_GPL(gpiod_export);
 604
 605 static int match_export(struct device *dev, const void *data)
 606 {
 607         return dev_get_drvdata(dev) == data;
 608 }
 609
 610 /**
 611  * gpiod_export_link - create a sysfs link to an exported GPIO node
 612  * @dev: device under which to create symlink
 613  * @name: name of the symlink
 614  * @gpio: gpio to create symlink to, already exported
 615  *
 616  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 617  * node. Caller is responsible for unlinking.
 618  *
 619  * Returns zero on success, else an error.
 620  */
 621 int gpiod_export_link(struct device *dev, const char *name,
 622                       struct gpio_desc *desc)
 623 {
 624         int                     status = -EINVAL;
 625
 626         if (!desc) {
 627                 pr_warn("%s: invalid GPIO\n", __func__);
 628                 return -EINVAL;
 629         }
 630
 631         mutex_lock(&sysfs_lock);
 632
 633         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 634                 struct device *tdev;
 635
 636                 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
 637                 if (tdev != NULL) {
 638                         status = sysfs_create_link(&dev->kobj, &tdev->kobj,
 639                                                 name);
 640                 } else {
 641                         status = -ENODEV;
 642                 }
 643         }
 644
 645         mutex_unlock(&sysfs_lock);
 646
 647         if (status)
 648                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 649
 650         return status;
 651 }
 652 EXPORT_SYMBOL_GPL(gpiod_export_link);
 653
 654 /**
 655  * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
 656  * @gpio: gpio to change
 657  * @value: non-zero to use active low, i.e. inverted values
 658  *
 659  * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
 660  * The GPIO does not have to be exported yet.  If poll(2) support has
 661  * been enabled for either rising or falling edge, it will be
 662  * reconfigured to follow the new polarity.
 663  *
 664  * Returns zero on success, else an error.
 665  */
 666 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 667 {
 668         struct device           *dev = NULL;
 669         int                     status = -EINVAL;
 670
 671         if (!desc) {
 672                 pr_warn("%s: invalid GPIO\n", __func__);
 673                 return -EINVAL;
 674         }
 675
 676         mutex_lock(&sysfs_lock);
 677
 678         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 679                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
 680                 if (dev == NULL) {
 681                         status = -ENODEV;
 682                         goto unlock;
 683                 }
 684         }
 685
 686         status = sysfs_set_active_low(desc, dev, value);
 687
 688 unlock:
 689         mutex_unlock(&sysfs_lock);
 690
 691         if (status)
 692                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 693
 694         return status;
 695 }
 696 EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low);
 697
 698 /**
 699  * gpiod_unexport - reverse effect of gpio_export()
 700  * @gpio: gpio to make unavailable
 701  *
 702  * This is implicit on gpio_free().
 703  */
 704 void gpiod_unexport(struct gpio_desc *desc)
 705 {
 706         int                     status = 0;
 707         struct device           *dev = NULL;
 708
 709         if (!desc) {
 710                 pr_warn("%s: invalid GPIO\n", __func__);
 711                 return;
 712         }
 713
 714         mutex_lock(&sysfs_lock);
 715
 716         if (test_bit(FLAG_EXPORT, &desc->flags)) {
 717
 718                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
 719                 if (dev) {
 720                         gpio_setup_irq(desc, dev, 0);
 721                         clear_bit(FLAG_EXPORT, &desc->flags);
 722                 } else
 723                         status = -ENODEV;
 724         }
 725
 726         mutex_unlock(&sysfs_lock);
 727
 728         if (dev) {
 729                 device_unregister(dev);
 730                 put_device(dev);
 731         }
 732
 733         if (status)
 734                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 735 }
 736 EXPORT_SYMBOL_GPL(gpiod_unexport);
 737
 738 int gpiochip_export(struct gpio_chip *chip)
 739 {
 740         int             status;
 741         struct device   *dev;
 742
 743         /* Many systems register gpio chips for SOC support very early,
 744          * before driver model support is available.  In those cases we
 745          * export this later, in gpiolib_sysfs_init() ... here we just
 746          * verify that _some_ field of gpio_class got initialized.
 747          */
 748         if (!gpio_class.p)
 749                 return 0;
 750
 751         /* use chip->base for the ID; it's already known to be unique */
 752         mutex_lock(&sysfs_lock);
 753         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
 754                                 "gpiochip%d", chip->base);
 755         if (!IS_ERR(dev)) {
 756                 status = sysfs_create_group(&dev->kobj,
 757                                 &gpiochip_attr_group);
 758         } else
 759                 status = PTR_ERR(dev);
 760         chip->exported = (status == 0);
 761         mutex_unlock(&sysfs_lock);
 762
 763         if (status)
 764                 chip_dbg(chip, "%s: status %d\n", __func__, status);
 765
 766         return status;
 767 }
 768
 769 void gpiochip_unexport(struct gpio_chip *chip)
 770 {
 771         int                     status;
 772         struct device           *dev;
 773
 774         mutex_lock(&sysfs_lock);
 775         dev = class_find_device(&gpio_class, NULL, chip, match_export);
 776         if (dev) {
 777                 put_device(dev);
 778                 device_unregister(dev);
 779                 chip->exported = false;
 780                 status = 0;
 781         } else
 782                 status = -ENODEV;
 783         mutex_unlock(&sysfs_lock);
 784
 785         if (status)
 786                 chip_dbg(chip, "%s: status %d\n", __func__, status);
 787 }
 788
 789 static int __init gpiolib_sysfs_init(void)
 790 {
 791         int             status;
 792         unsigned long   flags;
 793         struct gpio_chip *chip;
 794
 795         status = class_register(&gpio_class);
 796         if (status < 0)
 797                 return status;
 798
 799         /* Scan and register the gpio_chips which registered very
 800          * early (e.g. before the class_register above was called).
 801          *
 802          * We run before arch_initcall() so chip->dev nodes can have
 803          * registered, and so arch_initcall() can always gpio_export().
 804          */
 805         spin_lock_irqsave(&gpio_lock, flags);
 806         list_for_each_entry(chip, &gpio_chips, list) {
 807                 if (chip->exported)
 808                         continue;
 809
 810                 /*
 811                  * TODO we yield gpio_lock here because gpiochip_export()
 812                  * acquires a mutex. This is unsafe 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_export(chip);
 820                 spin_lock_irqsave(&gpio_lock, flags);
 821         }
 822         spin_unlock_irqrestore(&gpio_lock, flags);
 823
 824
 825         return status;
 826 }
 827 postcore_initcall(gpiolib_sysfs_init);