drivers/gpio/gpiolib-sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/idr.h>
   3 #include <linux/mutex.h>
   4 #include <linux/device.h>
   5 #include <linux/sysfs.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 /*
 448  * /sys/class/gpio/export ... write-only
 449  *      integer N ... number of GPIO to export (full access)
 450  * /sys/class/gpio/unexport ... write-only
 451  *      integer N ... number of GPIO to unexport
 452  */
 453 static ssize_t export_store(struct class *class,
 454                                 struct class_attribute *attr,
 455                                 const char *buf, size_t len)
 456 {
 457         long                    gpio;
 458         struct gpio_desc        *desc;
 459         int                     status;
 460         struct gpio_chip        *gc;
 461         int                     offset;
 462
 463         status = kstrtol(buf, 0, &gpio);
 464         if (status < 0)
 465                 goto done;
 466
 467         desc = gpio_to_desc(gpio);
 468         /* reject invalid GPIOs */
 469         if (!desc) {
 470                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
 471                 return -EINVAL;
 472         }
 473         gc = desc->gdev->chip;
 474         offset = gpio_chip_hwgpio(desc);
 475         if (!gpiochip_line_is_valid(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(desc, "sysfs");
 486         if (status < 0) {
 487                 if (status == -EPROBE_DEFER)
 488                         status = -ENODEV;
 489                 goto done;
 490         }
 491
 492         status = gpiod_set_transitory(desc, false);
 493         if (!status) {
 494                 status = gpiod_export(desc, true);
 495                 if (status < 0)
 496                         gpiod_free(desc);
 497                 else
 498                         set_bit(FLAG_SYSFS, &desc->flags);
 499         }
 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(struct class *class,
 509                                 struct class_attribute *attr,
 510                                 const char *buf, size_t len)
 511 {
 512         long                    gpio;
 513         struct gpio_desc        *desc;
 514         int                     status;
 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 (gpio_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                 status = 0;
 535                 gpiod_free(desc);
 536         }
 537 done:
 538         if (status)
 539                 pr_debug("%s: status %d\n", __func__, status);
 540         return status ? : len;
 541 }
 542 static CLASS_ATTR_WO(unexport);
 543
 544 static struct attribute *gpio_class_attrs[] = {
 545         &class_attr_export.attr,
 546         &class_attr_unexport.attr,
 547         NULL,
 548 };
 549 ATTRIBUTE_GROUPS(gpio_class);
 550
 551 static struct class gpio_class = {
 552         .name =         "gpio",
 553         .owner =        THIS_MODULE,
 554
 555         .class_groups = gpio_class_groups,
 556 };
 557
 558
 559 /**
 560  * gpiod_export - export a GPIO through sysfs
 561  * @desc: GPIO to make available, already requested
 562  * @direction_may_change: true if userspace may change GPIO direction
 563  * Context: arch_initcall or later
 564  *
 565  * When drivers want to make a GPIO accessible to userspace after they
 566  * have requested it -- perhaps while debugging, or as part of their
 567  * public interface -- they may use this routine.  If the GPIO can
 568  * change direction (some can't) and the caller allows it, userspace
 569  * will see "direction" sysfs attribute which may be used to change
 570  * the gpio's direction.  A "value" attribute will always be provided.
 571  *
 572  * Returns zero on success, else an error.
 573  */
 574 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 575 {
 576         struct gpio_chip        *chip;
 577         struct gpio_device      *gdev;
 578         struct gpiod_data       *data;
 579         unsigned long           flags;
 580         int                     status;
 581         const char              *ioname = NULL;
 582         struct device           *dev;
 583         int                     offset;
 584
 585         /* can't export until sysfs is available ... */
 586         if (!gpio_class.p) {
 587                 pr_debug("%s: called too early!\n", __func__);
 588                 return -ENOENT;
 589         }
 590
 591         if (!desc) {
 592                 pr_debug("%s: invalid gpio descriptor\n", __func__);
 593                 return -EINVAL;
 594         }
 595
 596         gdev = desc->gdev;
 597         chip = gdev->chip;
 598
 599         mutex_lock(&sysfs_lock);
 600
 601         /* check if chip is being removed */
 602         if (!chip || !gdev->mockdev) {
 603                 status = -ENODEV;
 604                 goto err_unlock;
 605         }
 606
 607         spin_lock_irqsave(&gpio_lock, flags);
 608         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
 609              test_bit(FLAG_EXPORT, &desc->flags)) {
 610                 spin_unlock_irqrestore(&gpio_lock, flags);
 611                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
 612                                 __func__,
 613                                 test_bit(FLAG_REQUESTED, &desc->flags),
 614                                 test_bit(FLAG_EXPORT, &desc->flags));
 615                 status = -EPERM;
 616                 goto err_unlock;
 617         }
 618         spin_unlock_irqrestore(&gpio_lock, flags);
 619
 620         data = kzalloc(sizeof(*data), GFP_KERNEL);
 621         if (!data) {
 622                 status = -ENOMEM;
 623                 goto err_unlock;
 624         }
 625
 626         data->desc = desc;
 627         mutex_init(&data->mutex);
 628         if (chip->direction_input && chip->direction_output)
 629                 data->direction_can_change = direction_may_change;
 630         else
 631                 data->direction_can_change = false;
 632
 633         offset = gpio_chip_hwgpio(desc);
 634         if (chip->names && chip->names[offset])
 635                 ioname = chip->names[offset];
 636
 637         dev = device_create_with_groups(&gpio_class, &gdev->dev,
 638                                         MKDEV(0, 0), data, gpio_groups,
 639                                         ioname ? ioname : "gpio%u",
 640                                         desc_to_gpio(desc));
 641         if (IS_ERR(dev)) {
 642                 status = PTR_ERR(dev);
 643                 goto err_free_data;
 644         }
 645
 646         set_bit(FLAG_EXPORT, &desc->flags);
 647         mutex_unlock(&sysfs_lock);
 648         return 0;
 649
 650 err_free_data:
 651         kfree(data);
 652 err_unlock:
 653         mutex_unlock(&sysfs_lock);
 654         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
 655         return status;
 656 }
 657 EXPORT_SYMBOL_GPL(gpiod_export);
 658
 659 static int match_export(struct device *dev, const void *desc)
 660 {
 661         struct gpiod_data *data = dev_get_drvdata(dev);
 662
 663         return data->desc == desc;
 664 }
 665
 666 /**
 667  * gpiod_export_link - create a sysfs link to an exported GPIO node
 668  * @dev: device under which to create symlink
 669  * @name: name of the symlink
 670  * @desc: GPIO to create symlink to, already exported
 671  *
 672  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
 673  * node. Caller is responsible for unlinking.
 674  *
 675  * Returns zero on success, else an error.
 676  */
 677 int gpiod_export_link(struct device *dev, const char *name,
 678                       struct gpio_desc *desc)
 679 {
 680         struct device *cdev;
 681         int ret;
 682
 683         if (!desc) {
 684                 pr_warn("%s: invalid GPIO\n", __func__);
 685                 return -EINVAL;
 686         }
 687
 688         cdev = class_find_device(&gpio_class, NULL, desc, match_export);
 689         if (!cdev)
 690                 return -ENODEV;
 691
 692         ret = sysfs_create_link(&dev->kobj, &cdev->kobj, name);
 693         put_device(cdev);
 694
 695         return ret;
 696 }
 697 EXPORT_SYMBOL_GPL(gpiod_export_link);
 698
 699 /**
 700  * gpiod_unexport - reverse effect of gpiod_export()
 701  * @desc: GPIO to make unavailable
 702  *
 703  * This is implicit on gpiod_free().
 704  */
 705 void gpiod_unexport(struct gpio_desc *desc)
 706 {
 707         struct gpiod_data *data;
 708         struct device *dev;
 709
 710         if (!desc) {
 711                 pr_warn("%s: invalid GPIO\n", __func__);
 712                 return;
 713         }
 714
 715         mutex_lock(&sysfs_lock);
 716
 717         if (!test_bit(FLAG_EXPORT, &desc->flags))
 718                 goto err_unlock;
 719
 720         dev = class_find_device(&gpio_class, NULL, desc, match_export);
 721         if (!dev)
 722                 goto err_unlock;
 723
 724         data = dev_get_drvdata(dev);
 725
 726         clear_bit(FLAG_EXPORT, &desc->flags);
 727
 728         device_unregister(dev);
 729
 730         /*
 731          * Release irq after deregistration to prevent race with edge_store.
 732          */
 733         if (data->irq_flags)
 734                 gpio_sysfs_free_irq(dev);
 735
 736         mutex_unlock(&sysfs_lock);
 737
 738         put_device(dev);
 739         kfree(data);
 740
 741         return;
 742
 743 err_unlock:
 744         mutex_unlock(&sysfs_lock);
 745 }
 746 EXPORT_SYMBOL_GPL(gpiod_unexport);
 747
 748 int gpiochip_sysfs_register(struct gpio_device *gdev)
 749 {
 750         struct device   *dev;
 751         struct device   *parent;
 752         struct gpio_chip *chip = gdev->chip;
 753
 754         /*
 755          * Many systems add gpio chips for SOC support very early,
 756          * before driver model support is available.  In those cases we
 757          * register later, in gpiolib_sysfs_init() ... here we just
 758          * verify that _some_ field of gpio_class got initialized.
 759          */
 760         if (!gpio_class.p)
 761                 return 0;
 762
 763         /*
 764          * For sysfs backward compatibility we need to preserve this
 765          * preferred parenting to the gpio_chip parent field, if set.
 766          */
 767         if (chip->parent)
 768                 parent = chip->parent;
 769         else
 770                 parent = &gdev->dev;
 771
 772         /* use chip->base for the ID; it's already known to be unique */
 773         dev = device_create_with_groups(&gpio_class, parent,
 774                                         MKDEV(0, 0),
 775                                         chip, gpiochip_groups,
 776                                         "gpiochip%d", 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 = gdev->chip;
 791         unsigned int i;
 792
 793         if (!gdev->mockdev)
 794                 return;
 795
 796         device_unregister(gdev->mockdev);
 797
 798         /* prevent further gpiod exports */
 799         mutex_lock(&sysfs_lock);
 800         gdev->mockdev = NULL;
 801         mutex_unlock(&sysfs_lock);
 802
 803         /* unregister gpiod class devices owned by sysfs */
 804         for (i = 0; i < chip->ngpio; i++) {
 805                 desc = &gdev->descs[i];
 806                 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags))
 807                         gpiod_free(desc);
 808         }
 809 }
 810
 811 static int __init gpiolib_sysfs_init(void)
 812 {
 813         int             status;
 814         unsigned long   flags;
 815         struct gpio_device *gdev;
 816
 817         status = class_register(&gpio_class);
 818         if (status < 0)
 819                 return status;
 820
 821         /* Scan and register the gpio_chips which registered very
 822          * early (e.g. before the class_register above was called).
 823          *
 824          * We run before arch_initcall() so chip->dev nodes can have
 825          * registered, and so arch_initcall() can always gpio_export().
 826          */
 827         spin_lock_irqsave(&gpio_lock, flags);
 828         list_for_each_entry(gdev, &gpio_devices, list) {
 829                 if (gdev->mockdev)
 830                         continue;
 831
 832                 /*
 833                  * TODO we yield gpio_lock here because
 834                  * gpiochip_sysfs_register() acquires a mutex. This is unsafe
 835                  * and needs to be fixed.
 836                  *
 837                  * Also it would be nice to use gpiochip_find() here so we
 838                  * can keep gpio_chips local to gpiolib.c, but the yield of
 839                  * gpio_lock prevents us from doing this.
 840                  */
 841                 spin_unlock_irqrestore(&gpio_lock, flags);
 842                 status = gpiochip_sysfs_register(gdev);
 843                 spin_lock_irqsave(&gpio_lock, flags);
 844         }
 845         spin_unlock_irqrestore(&gpio_lock, flags);
 846
 847         return status;
 848 }
 849 postcore_initcall(gpiolib_sysfs_init);