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