drivers/gpio/gpiolib-sysfs.c

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