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