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 zero on success, else an error.
 572  */
 573 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 574 {
 575         const char *ioname = NULL;
 576         struct gpio_device *gdev;
 577         struct gpiod_data *data;
 578         struct device *dev;
 579         int status, offset;
 580
 581         /* can't export until sysfs is available ... */
 582         if (!class_is_registered(&gpio_class)) {
 583                 pr_debug("%s: called too early!\n", __func__);
 584                 return -ENOENT;
 585         }
 586
 587         if (!desc) {
 588                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 589                 return -EINVAL;
 590         }
 591
 592         CLASS(gpio_chip_guard, guard)(desc);
 593         if (!guard.gc)
 594                 return -ENODEV;
 595
 596         if (test_and_set_bit(FLAG_EXPORT, &desc->flags))
 597                 return -EPERM;
 598
 599         gdev = desc->gdev;
 600
 601         mutex_lock(&sysfs_lock);
 602
 603         /* check if chip is being removed */
 604         if (!gdev->mockdev) {
 605                 status = -ENODEV;
 606                 goto err_unlock;
 607         }
 608
 609         if (!test_bit(FLAG_REQUESTED, &desc->flags)) {
 610                 gpiod_dbg(desc, "%s: unavailable (not requested)\n", __func__);
 611                 status = -EPERM;
 612                 goto err_unlock;
 613         }
 614
 615         data = kzalloc(sizeof(*data), GFP_KERNEL);
 616         if (!data) {
 617                 status = -ENOMEM;
 618                 goto err_unlock;
 619         }
 620
 621         data->desc = desc;
 622         mutex_init(&data->mutex);
 623         if (guard.gc->direction_input && guard.gc->direction_output)
 624                 data->direction_can_change = direction_may_change;
 625         else
 626                 data->direction_can_change = false;
 627
 628         offset = gpio_chip_hwgpio(desc);
 629         if (guard.gc->names && guard.gc->names[offset])
 630                 ioname = guard.gc->names[offset];
 631
 632         dev = device_create_with_groups(&gpio_class, &gdev->dev,
 633                                         MKDEV(0, 0), data, gpio_groups,
 634                                         ioname ? ioname : "gpio%u",
 635                                         desc_to_gpio(desc));
 636         if (IS_ERR(dev)) {
 637                 status = PTR_ERR(dev);
 638                 goto err_free_data;
 639         }
 640
 641         mutex_unlock(&sysfs_lock);
 642         return 0;
 643
 644 err_free_data:
 645         kfree(data);
 646 err_unlock:
 647         mutex_unlock(&sysfs_lock);
 648         clear_bit(FLAG_EXPORT, &desc->flags);
 649         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 650         return status;
 651 }
 652 EXPORT_SYMBOL_GPL(gpiod_export);
 653
 654 static int match_export(struct device *dev, const void *desc)
 655 {
 656         struct gpiod_data *data = dev_get_drvdata(dev);
 657
 658         return data->desc == desc;
 659 }
 660
 661 /**
 662  * gpiod_export_link - create a sysfs link to an exported GPIO node
 663  * @dev: device under which to create symlink
 664  * @name: name of the symlink
 665  * @desc: GPIO to create symlink to, already exported
 666  *
 667  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 668  * node. Caller is responsible for unlinking.
 669  *
 670  * Returns zero on success, else an error.
 671  */
 672 int gpiod_export_link(struct device *dev, const char *name,
 673                       struct gpio_desc *desc)
 674 {
 675         struct device *cdev;
 676         int ret;
 677
 678         if (!desc) {
 679                 pr_warn("%s: invalid GPIO\n", __func__);
 680                 return -EINVAL;
 681         }
 682
 683         cdev = class_find_device(&gpio_class, NULL, desc, match_export);
 684         if (!cdev)
 685                 return -ENODEV;
 686
 687         ret = sysfs_create_link(&dev->kobj, &cdev->kobj, name);
 688         put_device(cdev);
 689
 690         return ret;
 691 }
 692 EXPORT_SYMBOL_GPL(gpiod_export_link);
 693
 694 /**
 695  * gpiod_unexport - reverse effect of gpiod_export()
 696  * @desc: GPIO to make unavailable
 697  *
 698  * This is implicit on gpiod_free().
 699  */
 700 void gpiod_unexport(struct gpio_desc *desc)
 701 {
 702         struct gpiod_data *data;
 703         struct device *dev;
 704
 705         if (!desc) {
 706                 pr_warn("%s: invalid GPIO\n", __func__);
 707                 return;
 708         }
 709
 710         mutex_lock(&sysfs_lock);
 711
 712         if (!test_bit(FLAG_EXPORT, &desc->flags))
 713                 goto err_unlock;
 714
 715         dev = class_find_device(&gpio_class, NULL, desc, match_export);
 716         if (!dev)
 717                 goto err_unlock;
 718
 719         data = dev_get_drvdata(dev);
 720
 721         clear_bit(FLAG_EXPORT, &desc->flags);
 722
 723         device_unregister(dev);
 724
 725         /*
 726          * Release irq after deregistration to prevent race with edge_store.
 727          */
 728         if (data->irq_flags)
 729                 gpio_sysfs_free_irq(dev);
 730
 731         mutex_unlock(&sysfs_lock);
 732
 733         put_device(dev);
 734         kfree(data);
 735
 736         return;
 737
 738 err_unlock:
 739         mutex_unlock(&sysfs_lock);
 740 }
 741 EXPORT_SYMBOL_GPL(gpiod_unexport);
 742
 743 int gpiochip_sysfs_register(struct gpio_device *gdev)
 744 {
 745         struct gpio_chip *chip;
 746         struct device *parent;
 747         struct device *dev;
 748
 749         /*
 750          * Many systems add gpio chips for SOC support very early,
 751          * before driver model support is available.  In those cases we
 752          * register later, in gpiolib_sysfs_init() ... here we just
 753          * verify that _some_ field of gpio_class got initialized.
 754          */
 755         if (!class_is_registered(&gpio_class))
 756                 return 0;
 757
 758         guard(srcu)(&gdev->srcu);
 759
 760         chip = srcu_dereference(gdev->chip, &gdev->srcu);
 761         if (!chip)
 762                 return -ENODEV;
 763
 764         /*
 765          * For sysfs backward compatibility we need to preserve this
 766          * preferred parenting to the gpio_chip parent field, if set.
 767          */
 768         if (chip->parent)
 769                 parent = chip->parent;
 770         else
 771                 parent = &gdev->dev;
 772
 773         /* use chip->base for the ID; it's already known to be unique */
 774         dev = device_create_with_groups(&gpio_class, parent, MKDEV(0, 0), gdev,
 775                                         gpiochip_groups, GPIOCHIP_NAME "%d",
 776                                         chip->base);
 777         if (IS_ERR(dev))
 778                 return PTR_ERR(dev);
 779
 780         mutex_lock(&sysfs_lock);
 781         gdev->mockdev = dev;
 782         mutex_unlock(&sysfs_lock);
 783
 784         return 0;
 785 }
 786
 787 void gpiochip_sysfs_unregister(struct gpio_device *gdev)
 788 {
 789         struct gpio_desc *desc;
 790         struct gpio_chip *chip;
 791
 792         scoped_guard(mutex, &sysfs_lock) {
 793                 if (!gdev->mockdev)
 794                         return;
 795
 796                 device_unregister(gdev->mockdev);
 797
 798                 /* prevent further gpiod exports */
 799                 gdev->mockdev = NULL;
 800         }
 801
 802         guard(srcu)(&gdev->srcu);
 803
 804         chip = srcu_dereference(gdev->chip, &gdev->srcu);
 805         if (!chip)
 806                 return;
 807
 808         /* unregister gpiod class devices owned by sysfs */
 809         for_each_gpio_desc_with_flag(chip, desc, FLAG_SYSFS) {
 810                 gpiod_unexport(desc);
 811                 gpiod_free(desc);
 812         }
 813 }
 814
 815 /*
 816  * We're not really looking for a device - we just want to iterate over the
 817  * list and call this callback for each GPIO device. This is why this function
 818  * always returns 0.
 819  */
 820 static int gpiofind_sysfs_register(struct gpio_chip *gc, const void *data)
 821 {
 822         struct gpio_device *gdev = gc->gpiodev;
 823         int ret;
 824
 825         if (gdev->mockdev)
 826                 return 0;
 827
 828         ret = gpiochip_sysfs_register(gdev);
 829         if (ret)
 830                 chip_err(gc, "failed to register the sysfs entry: %d\n", ret);
 831
 832         return 0;
 833 }
 834
 835 static int __init gpiolib_sysfs_init(void)
 836 {
 837         int status;
 838
 839         status = class_register(&gpio_class);
 840         if (status < 0)
 841                 return status;
 842
 843         /* Scan and register the gpio_chips which registered very
 844          * early (e.g. before the class_register above was called).
 845          *
 846          * We run before arch_initcall() so chip->dev nodes can have
 847          * registered, and so arch_initcall() can always gpiod_export().
 848          */
 849         (void)gpio_device_find(NULL, gpiofind_sysfs_register);
 850
 851         return 0;
 852 }
 853 postcore_initcall(gpiolib_sysfs_init);