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