drivers/gpio/gpiolib-sysfs.c

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

DEFINITIONS
