1#include <linux/kernel.h> 2#include <linux/module.h> 3#include <linux/interrupt.h> 4#include <linux/irq.h> 5#include <linux/spinlock.h> 6#include <linux/list.h> 7#include <linux/device.h> 8#include <linux/err.h> 9#include <linux/debugfs.h> 10#include <linux/seq_file.h> 11#include <linux/gpio.h> 12#include <linux/of_gpio.h> 13#include <linux/idr.h> 14#include <linux/slab.h> 15#include <linux/acpi.h> 16#include <linux/gpio/driver.h> 17#include <linux/gpio/machine.h> 18#include <linux/pinctrl/consumer.h> 19 20#include "gpiolib.h" 21 22#define CREATE_TRACE_POINTS 23#include <trace/events/gpio.h> 24 25/* Implementation infrastructure for GPIO interfaces. 26 * 27 * The GPIO programming interface allows for inlining speed-critical 28 * get/set operations for common cases, so that access to SOC-integrated 29 * GPIOs can sometimes cost only an instruction or two per bit. 30 */ 31 32 33/* When debugging, extend minimal trust to callers and platform code. 34 * Also emit diagnostic messages that may help initial bringup, when 35 * board setup or driver bugs are most common. 36 * 37 * Otherwise, minimize overhead in what may be bitbanging codepaths. 38 */ 39#ifdef DEBUG 40#define extra_checks 1 41#else 42#define extra_checks 0 43#endif 44 45/* gpio_lock prevents conflicts during gpio_desc[] table updates. 46 * While any GPIO is requested, its gpio_chip is not removable; 47 * each GPIO's "requested" flag serves as a lock and refcount. 48 */ 49DEFINE_SPINLOCK(gpio_lock); 50 51static DEFINE_MUTEX(gpio_lookup_lock); 52static LIST_HEAD(gpio_lookup_list); 53LIST_HEAD(gpio_chips); 54 55 56static void gpiochip_free_hogs(struct gpio_chip *chip); 57static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip); 58 59 60static inline void desc_set_label(struct gpio_desc *d, const char *label) 61{ 62 d->label = label; 63} 64 65/** 66 * Convert a GPIO number to its descriptor 67 */ 68struct gpio_desc *gpio_to_desc(unsigned gpio) 69{ 70 struct gpio_chip *chip; 71 unsigned long flags; 72 73 spin_lock_irqsave(&gpio_lock, flags); 74 75 list_for_each_entry(chip, &gpio_chips, list) { 76 if (chip->base <= gpio && chip->base + chip->ngpio > gpio) { 77 spin_unlock_irqrestore(&gpio_lock, flags); 78 return &chip->desc[gpio - chip->base]; 79 } 80 } 81 82 spin_unlock_irqrestore(&gpio_lock, flags); 83 84 if (!gpio_is_valid(gpio)) 85 WARN(1, "invalid GPIO %d\n", gpio); 86 87 return NULL; 88} 89EXPORT_SYMBOL_GPL(gpio_to_desc); 90 91/** 92 * Get the GPIO descriptor corresponding to the given hw number for this chip. 93 */ 94struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip, 95 u16 hwnum) 96{ 97 if (hwnum >= chip->ngpio) 98 return ERR_PTR(-EINVAL); 99 100 return &chip->desc[hwnum]; 101} 102 103/** 104 * Convert a GPIO descriptor to the integer namespace. 105 * This should disappear in the future but is needed since we still 106 * use GPIO numbers for error messages and sysfs nodes 107 */ 108int desc_to_gpio(const struct gpio_desc *desc) 109{ 110 return desc->chip->base + (desc - &desc->chip->desc[0]); 111} 112EXPORT_SYMBOL_GPL(desc_to_gpio); 113 114 115/** 116 * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs 117 * @desc: descriptor to return the chip of 118 */ 119struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc) 120{ 121 return desc ? desc->chip : NULL; 122} 123EXPORT_SYMBOL_GPL(gpiod_to_chip); 124 125/* dynamic allocation of GPIOs, e.g. on a hotplugged device */ 126static int gpiochip_find_base(int ngpio) 127{ 128 struct gpio_chip *chip; 129 int base = ARCH_NR_GPIOS - ngpio; 130 131 list_for_each_entry_reverse(chip, &gpio_chips, list) { 132 /* found a free space? */ 133 if (chip->base + chip->ngpio <= base) 134 break; 135 else 136 /* nope, check the space right before the chip */ 137 base = chip->base - ngpio; 138 } 139 140 if (gpio_is_valid(base)) { 141 pr_debug("%s: found new base at %d\n", __func__, base); 142 return base; 143 } else { 144 pr_err("%s: cannot find free range\n", __func__); 145 return -ENOSPC; 146 } 147} 148 149/** 150 * gpiod_get_direction - return the current direction of a GPIO 151 * @desc: GPIO to get the direction of 152 * 153 * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error. 154 * 155 * This function may sleep if gpiod_cansleep() is true. 156 */ 157int gpiod_get_direction(struct gpio_desc *desc) 158{ 159 struct gpio_chip *chip; 160 unsigned offset; 161 int status = -EINVAL; 162 163 chip = gpiod_to_chip(desc); 164 offset = gpio_chip_hwgpio(desc); 165 166 if (!chip->get_direction) 167 return status; 168 169 status = chip->get_direction(chip, offset); 170 if (status > 0) { 171 /* GPIOF_DIR_IN, or other positive */ 172 status = 1; 173 clear_bit(FLAG_IS_OUT, &desc->flags); 174 } 175 if (status == 0) { 176 /* GPIOF_DIR_OUT */ 177 set_bit(FLAG_IS_OUT, &desc->flags); 178 } 179 return status; 180} 181EXPORT_SYMBOL_GPL(gpiod_get_direction); 182 183/* 184 * Add a new chip to the global chips list, keeping the list of chips sorted 185 * by base order. 186 * 187 * Return -EBUSY if the new chip overlaps with some other chip's integer 188 * space. 189 */ 190static int gpiochip_add_to_list(struct gpio_chip *chip) 191{ 192 struct list_head *pos; 193 struct gpio_chip *_chip; 194 int err = 0; 195 196 /* find where to insert our chip */ 197 list_for_each(pos, &gpio_chips) { 198 _chip = list_entry(pos, struct gpio_chip, list); 199 /* shall we insert before _chip? */ 200 if (_chip->base >= chip->base + chip->ngpio) 201 break; 202 } 203 204 /* are we stepping on the chip right before? */ 205 if (pos != &gpio_chips && pos->prev != &gpio_chips) { 206 _chip = list_entry(pos->prev, struct gpio_chip, list); 207 if (_chip->base + _chip->ngpio > chip->base) { 208 dev_err(chip->dev, 209 "GPIO integer space overlap, cannot add chip\n"); 210 err = -EBUSY; 211 } 212 } 213 214 if (!err) 215 list_add_tail(&chip->list, pos); 216 217 return err; 218} 219 220/** 221 * Convert a GPIO name to its descriptor 222 */ 223static struct gpio_desc *gpio_name_to_desc(const char * const name) 224{ 225 struct gpio_chip *chip; 226 unsigned long flags; 227 228 spin_lock_irqsave(&gpio_lock, flags); 229 230 list_for_each_entry(chip, &gpio_chips, list) { 231 int i; 232 233 for (i = 0; i != chip->ngpio; ++i) { 234 struct gpio_desc *gpio = &chip->desc[i]; 235 236 if (!gpio->name || !name) 237 continue; 238 239 if (!strcmp(gpio->name, name)) { 240 spin_unlock_irqrestore(&gpio_lock, flags); 241 return gpio; 242 } 243 } 244 } 245 246 spin_unlock_irqrestore(&gpio_lock, flags); 247 248 return NULL; 249} 250 251/* 252 * Takes the names from gc->names and checks if they are all unique. If they 253 * are, they are assigned to their gpio descriptors. 254 * 255 * Returns -EEXIST if one of the names is already used for a different GPIO. 256 */ 257static int gpiochip_set_desc_names(struct gpio_chip *gc) 258{ 259 int i; 260 261 if (!gc->names) 262 return 0; 263 264 /* First check all names if they are unique */ 265 for (i = 0; i != gc->ngpio; ++i) { 266 struct gpio_desc *gpio; 267 268 gpio = gpio_name_to_desc(gc->names[i]); 269 if (gpio) 270 dev_warn(gc->dev, "Detected name collision for " 271 "GPIO name '%s'\n", 272 gc->names[i]); 273 } 274 275 /* Then add all names to the GPIO descriptors */ 276 for (i = 0; i != gc->ngpio; ++i) 277 gc->desc[i].name = gc->names[i]; 278 279 return 0; 280} 281 282/** 283 * gpiochip_add() - register a gpio_chip 284 * @chip: the chip to register, with chip->base initialized 285 * Context: potentially before irqs will work 286 * 287 * Returns a negative errno if the chip can't be registered, such as 288 * because the chip->base is invalid or already associated with a 289 * different chip. Otherwise it returns zero as a success code. 290 * 291 * When gpiochip_add() is called very early during boot, so that GPIOs 292 * can be freely used, the chip->dev device must be registered before 293 * the gpio framework's arch_initcall(). Otherwise sysfs initialization 294 * for GPIOs will fail rudely. 295 * 296 * If chip->base is negative, this requests dynamic assignment of 297 * a range of valid GPIOs. 298 */ 299int gpiochip_add(struct gpio_chip *chip) 300{ 301 unsigned long flags; 302 int status = 0; 303 unsigned id; 304 int base = chip->base; 305 struct gpio_desc *descs; 306 307 descs = kcalloc(chip->ngpio, sizeof(descs[0]), GFP_KERNEL); 308 if (!descs) 309 return -ENOMEM; 310 311 spin_lock_irqsave(&gpio_lock, flags); 312 313 if (base < 0) { 314 base = gpiochip_find_base(chip->ngpio); 315 if (base < 0) { 316 status = base; 317 spin_unlock_irqrestore(&gpio_lock, flags); 318 goto err_free_descs; 319 } 320 chip->base = base; 321 } 322 323 status = gpiochip_add_to_list(chip); 324 if (status) { 325 spin_unlock_irqrestore(&gpio_lock, flags); 326 goto err_free_descs; 327 } 328 329 for (id = 0; id < chip->ngpio; id++) { 330 struct gpio_desc *desc = &descs[id]; 331 332 desc->chip = chip; 333 334 /* REVISIT: most hardware initializes GPIOs as inputs (often 335 * with pullups enabled) so power usage is minimized. Linux 336 * code should set the gpio direction first thing; but until 337 * it does, and in case chip->get_direction is not set, we may 338 * expose the wrong direction in sysfs. 339 */ 340 desc->flags = !chip->direction_input ? (1 << FLAG_IS_OUT) : 0; 341 } 342 343 chip->desc = descs; 344 345 spin_unlock_irqrestore(&gpio_lock, flags); 346 347#ifdef CONFIG_PINCTRL 348 INIT_LIST_HEAD(&chip->pin_ranges); 349#endif 350 351 if (!chip->owner && chip->dev && chip->dev->driver) 352 chip->owner = chip->dev->driver->owner; 353 354 status = gpiochip_set_desc_names(chip); 355 if (status) 356 goto err_remove_from_list; 357 358 status = of_gpiochip_add(chip); 359 if (status) 360 goto err_remove_chip; 361 362 acpi_gpiochip_add(chip); 363 364 status = gpiochip_sysfs_register(chip); 365 if (status) 366 goto err_remove_chip; 367 368 pr_debug("%s: registered GPIOs %d to %d on device: %s\n", __func__, 369 chip->base, chip->base + chip->ngpio - 1, 370 chip->label ? : "generic"); 371 372 return 0; 373 374err_remove_chip: 375 acpi_gpiochip_remove(chip); 376 gpiochip_free_hogs(chip); 377 of_gpiochip_remove(chip); 378err_remove_from_list: 379 spin_lock_irqsave(&gpio_lock, flags); 380 list_del(&chip->list); 381 spin_unlock_irqrestore(&gpio_lock, flags); 382 chip->desc = NULL; 383err_free_descs: 384 kfree(descs); 385 386 /* failures here can mean systems won't boot... */ 387 pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__, 388 chip->base, chip->base + chip->ngpio - 1, 389 chip->label ? : "generic"); 390 return status; 391} 392EXPORT_SYMBOL_GPL(gpiochip_add); 393 394/** 395 * gpiochip_remove() - unregister a gpio_chip 396 * @chip: the chip to unregister 397 * 398 * A gpio_chip with any GPIOs still requested may not be removed. 399 */ 400void gpiochip_remove(struct gpio_chip *chip) 401{ 402 struct gpio_desc *desc; 403 unsigned long flags; 404 unsigned id; 405 bool requested = false; 406 407 gpiochip_sysfs_unregister(chip); 408 409 gpiochip_irqchip_remove(chip); 410 411 acpi_gpiochip_remove(chip); 412 gpiochip_remove_pin_ranges(chip); 413 gpiochip_free_hogs(chip); 414 of_gpiochip_remove(chip); 415 416 spin_lock_irqsave(&gpio_lock, flags); 417 for (id = 0; id < chip->ngpio; id++) { 418 desc = &chip->desc[id]; 419 desc->chip = NULL; 420 if (test_bit(FLAG_REQUESTED, &desc->flags)) 421 requested = true; 422 } 423 list_del(&chip->list); 424 spin_unlock_irqrestore(&gpio_lock, flags); 425 426 if (requested) 427 dev_crit(chip->dev, "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n"); 428 429 kfree(chip->desc); 430 chip->desc = NULL; 431} 432EXPORT_SYMBOL_GPL(gpiochip_remove); 433 434/** 435 * gpiochip_find() - iterator for locating a specific gpio_chip 436 * @data: data to pass to match function 437 * @callback: Callback function to check gpio_chip 438 * 439 * Similar to bus_find_device. It returns a reference to a gpio_chip as 440 * determined by a user supplied @match callback. The callback should return 441 * 0 if the device doesn't match and non-zero if it does. If the callback is 442 * non-zero, this function will return to the caller and not iterate over any 443 * more gpio_chips. 444 */ 445struct gpio_chip *gpiochip_find(void *data, 446 int (*match)(struct gpio_chip *chip, 447 void *data)) 448{ 449 struct gpio_chip *chip; 450 unsigned long flags; 451 452 spin_lock_irqsave(&gpio_lock, flags); 453 list_for_each_entry(chip, &gpio_chips, list) 454 if (match(chip, data)) 455 break; 456 457 /* No match? */ 458 if (&chip->list == &gpio_chips) 459 chip = NULL; 460 spin_unlock_irqrestore(&gpio_lock, flags); 461 462 return chip; 463} 464EXPORT_SYMBOL_GPL(gpiochip_find); 465 466static int gpiochip_match_name(struct gpio_chip *chip, void *data) 467{ 468 const char *name = data; 469 470 return !strcmp(chip->label, name); 471} 472 473static struct gpio_chip *find_chip_by_name(const char *name) 474{ 475 return gpiochip_find((void *)name, gpiochip_match_name); 476} 477 478#ifdef CONFIG_GPIOLIB_IRQCHIP 479 480/* 481 * The following is irqchip helper code for gpiochips. 482 */ 483 484/** 485 * gpiochip_set_chained_irqchip() - sets a chained irqchip to a gpiochip 486 * @gpiochip: the gpiochip to set the irqchip chain to 487 * @irqchip: the irqchip to chain to the gpiochip 488 * @parent_irq: the irq number corresponding to the parent IRQ for this 489 * chained irqchip 490 * @parent_handler: the parent interrupt handler for the accumulated IRQ 491 * coming out of the gpiochip. If the interrupt is nested rather than 492 * cascaded, pass NULL in this handler argument 493 */ 494void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip, 495 struct irq_chip *irqchip, 496 int parent_irq, 497 irq_flow_handler_t parent_handler) 498{ 499 unsigned int offset; 500 501 if (!gpiochip->irqdomain) { 502 chip_err(gpiochip, "called %s before setting up irqchip\n", 503 __func__); 504 return; 505 } 506 507 if (parent_handler) { 508 if (gpiochip->can_sleep) { 509 chip_err(gpiochip, 510 "you cannot have chained interrupts on a " 511 "chip that may sleep\n"); 512 return; 513 } 514 /* 515 * The parent irqchip is already using the chip_data for this 516 * irqchip, so our callbacks simply use the handler_data. 517 */ 518 irq_set_chained_handler_and_data(parent_irq, parent_handler, 519 gpiochip); 520 521 gpiochip->irq_parent = parent_irq; 522 } 523 524 /* Set the parent IRQ for all affected IRQs */ 525 for (offset = 0; offset < gpiochip->ngpio; offset++) 526 irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset), 527 parent_irq); 528} 529EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip); 530 531/** 532 * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip 533 * @d: the irqdomain used by this irqchip 534 * @irq: the global irq number used by this GPIO irqchip irq 535 * @hwirq: the local IRQ/GPIO line offset on this gpiochip 536 * 537 * This function will set up the mapping for a certain IRQ line on a 538 * gpiochip by assigning the gpiochip as chip data, and using the irqchip 539 * stored inside the gpiochip. 540 */ 541static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq, 542 irq_hw_number_t hwirq) 543{ 544 struct gpio_chip *chip = d->host_data; 545 546 irq_set_chip_data(irq, chip); 547 /* 548 * This lock class tells lockdep that GPIO irqs are in a different 549 * category than their parents, so it won't report false recursion. 550 */ 551 irq_set_lockdep_class(irq, chip->lock_key); 552 irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler); 553 /* Chips that can sleep need nested thread handlers */ 554 if (chip->can_sleep && !chip->irq_not_threaded) 555 irq_set_nested_thread(irq, 1); 556 irq_set_noprobe(irq); 557 558 /* 559 * No set-up of the hardware will happen if IRQ_TYPE_NONE 560 * is passed as default type. 561 */ 562 if (chip->irq_default_type != IRQ_TYPE_NONE) 563 irq_set_irq_type(irq, chip->irq_default_type); 564 565 return 0; 566} 567 568static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq) 569{ 570 struct gpio_chip *chip = d->host_data; 571 572 if (chip->can_sleep) 573 irq_set_nested_thread(irq, 0); 574 irq_set_chip_and_handler(irq, NULL, NULL); 575 irq_set_chip_data(irq, NULL); 576} 577 578static const struct irq_domain_ops gpiochip_domain_ops = { 579 .map = gpiochip_irq_map, 580 .unmap = gpiochip_irq_unmap, 581 /* Virtually all GPIO irqchips are twocell:ed */ 582 .xlate = irq_domain_xlate_twocell, 583}; 584 585static int gpiochip_irq_reqres(struct irq_data *d) 586{ 587 struct gpio_chip *chip = irq_data_get_irq_chip_data(d); 588 589 if (!try_module_get(chip->owner)) 590 return -ENODEV; 591 592 if (gpiochip_lock_as_irq(chip, d->hwirq)) { 593 chip_err(chip, 594 "unable to lock HW IRQ %lu for IRQ\n", 595 d->hwirq); 596 module_put(chip->owner); 597 return -EINVAL; 598 } 599 return 0; 600} 601 602static void gpiochip_irq_relres(struct irq_data *d) 603{ 604 struct gpio_chip *chip = irq_data_get_irq_chip_data(d); 605 606 gpiochip_unlock_as_irq(chip, d->hwirq); 607 module_put(chip->owner); 608} 609 610static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset) 611{ 612 return irq_find_mapping(chip->irqdomain, offset); 613} 614 615/** 616 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip 617 * @gpiochip: the gpiochip to remove the irqchip from 618 * 619 * This is called only from gpiochip_remove() 620 */ 621static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) 622{ 623 unsigned int offset; 624 625 acpi_gpiochip_free_interrupts(gpiochip); 626 627 if (gpiochip->irq_parent) { 628 irq_set_chained_handler(gpiochip->irq_parent, NULL); 629 irq_set_handler_data(gpiochip->irq_parent, NULL); 630 } 631 632 /* Remove all IRQ mappings and delete the domain */ 633 if (gpiochip->irqdomain) { 634 for (offset = 0; offset < gpiochip->ngpio; offset++) 635 irq_dispose_mapping( 636 irq_find_mapping(gpiochip->irqdomain, offset)); 637 irq_domain_remove(gpiochip->irqdomain); 638 } 639 640 if (gpiochip->irqchip) { 641 gpiochip->irqchip->irq_request_resources = NULL; 642 gpiochip->irqchip->irq_release_resources = NULL; 643 gpiochip->irqchip = NULL; 644 } 645} 646 647/** 648 * gpiochip_irqchip_add() - adds an irqchip to a gpiochip 649 * @gpiochip: the gpiochip to add the irqchip to 650 * @irqchip: the irqchip to add to the gpiochip 651 * @first_irq: if not dynamically assigned, the base (first) IRQ to 652 * allocate gpiochip irqs from 653 * @handler: the irq handler to use (often a predefined irq core function) 654 * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE 655 * to have the core avoid setting up any default type in the hardware. 656 * @lock_key: lockdep class 657 * 658 * This function closely associates a certain irqchip with a certain 659 * gpiochip, providing an irq domain to translate the local IRQs to 660 * global irqs in the gpiolib core, and making sure that the gpiochip 661 * is passed as chip data to all related functions. Driver callbacks 662 * need to use container_of() to get their local state containers back 663 * from the gpiochip passed as chip data. An irqdomain will be stored 664 * in the gpiochip that shall be used by the driver to handle IRQ number 665 * translation. The gpiochip will need to be initialized and registered 666 * before calling this function. 667 * 668 * This function will handle two cell:ed simple IRQs and assumes all 669 * the pins on the gpiochip can generate a unique IRQ. Everything else 670 * need to be open coded. 671 */ 672int _gpiochip_irqchip_add(struct gpio_chip *gpiochip, 673 struct irq_chip *irqchip, 674 unsigned int first_irq, 675 irq_flow_handler_t handler, 676 unsigned int type, 677 struct lock_class_key *lock_key) 678{ 679 struct device_node *of_node; 680 unsigned int offset; 681 unsigned irq_base = 0; 682 683 if (!gpiochip || !irqchip) 684 return -EINVAL; 685 686 if (!gpiochip->dev) { 687 pr_err("missing gpiochip .dev parent pointer\n"); 688 return -EINVAL; 689 } 690 of_node = gpiochip->dev->of_node; 691#ifdef CONFIG_OF_GPIO 692 /* 693 * If the gpiochip has an assigned OF node this takes precedence 694 * FIXME: get rid of this and use gpiochip->dev->of_node everywhere 695 */ 696 if (gpiochip->of_node) 697 of_node = gpiochip->of_node; 698#endif 699 gpiochip->irqchip = irqchip; 700 gpiochip->irq_handler = handler; 701 gpiochip->irq_default_type = type; 702 gpiochip->to_irq = gpiochip_to_irq; 703 gpiochip->lock_key = lock_key; 704 gpiochip->irqdomain = irq_domain_add_simple(of_node, 705 gpiochip->ngpio, first_irq, 706 &gpiochip_domain_ops, gpiochip); 707 if (!gpiochip->irqdomain) { 708 gpiochip->irqchip = NULL; 709 return -EINVAL; 710 } 711 712 /* 713 * It is possible for a driver to override this, but only if the 714 * alternative functions are both implemented. 715 */ 716 if (!irqchip->irq_request_resources && 717 !irqchip->irq_release_resources) { 718 irqchip->irq_request_resources = gpiochip_irq_reqres; 719 irqchip->irq_release_resources = gpiochip_irq_relres; 720 } 721 722 /* 723 * Prepare the mapping since the irqchip shall be orthogonal to 724 * any gpiochip calls. If the first_irq was zero, this is 725 * necessary to allocate descriptors for all IRQs. 726 */ 727 for (offset = 0; offset < gpiochip->ngpio; offset++) { 728 irq_base = irq_create_mapping(gpiochip->irqdomain, offset); 729 if (offset == 0) 730 /* 731 * Store the base into the gpiochip to be used when 732 * unmapping the irqs. 733 */ 734 gpiochip->irq_base = irq_base; 735 } 736 737 acpi_gpiochip_request_interrupts(gpiochip); 738 739 return 0; 740} 741EXPORT_SYMBOL_GPL(_gpiochip_irqchip_add); 742 743#else /* CONFIG_GPIOLIB_IRQCHIP */ 744 745static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {} 746 747#endif /* CONFIG_GPIOLIB_IRQCHIP */ 748 749/** 750 * gpiochip_generic_request() - request the gpio function for a pin 751 * @chip: the gpiochip owning the GPIO 752 * @offset: the offset of the GPIO to request for GPIO function 753 */ 754int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset) 755{ 756 return pinctrl_request_gpio(chip->base + offset); 757} 758EXPORT_SYMBOL_GPL(gpiochip_generic_request); 759 760/** 761 * gpiochip_generic_free() - free the gpio function from a pin 762 * @chip: the gpiochip to request the gpio function for 763 * @offset: the offset of the GPIO to free from GPIO function 764 */ 765void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset) 766{ 767 pinctrl_free_gpio(chip->base + offset); 768} 769EXPORT_SYMBOL_GPL(gpiochip_generic_free); 770 771#ifdef CONFIG_PINCTRL 772 773/** 774 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping 775 * @chip: the gpiochip to add the range for 776 * @pctldev: the pin controller to map to 777 * @gpio_offset: the start offset in the current gpio_chip number space 778 * @pin_group: name of the pin group inside the pin controller 779 */ 780int gpiochip_add_pingroup_range(struct gpio_chip *chip, 781 struct pinctrl_dev *pctldev, 782 unsigned int gpio_offset, const char *pin_group) 783{ 784 struct gpio_pin_range *pin_range; 785 int ret; 786 787 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL); 788 if (!pin_range) { 789 chip_err(chip, "failed to allocate pin ranges\n"); 790 return -ENOMEM; 791 } 792 793 /* Use local offset as range ID */ 794 pin_range->range.id = gpio_offset; 795 pin_range->range.gc = chip; 796 pin_range->range.name = chip->label; 797 pin_range->range.base = chip->base + gpio_offset; 798 pin_range->pctldev = pctldev; 799 800 ret = pinctrl_get_group_pins(pctldev, pin_group, 801 &pin_range->range.pins, 802 &pin_range->range.npins); 803 if (ret < 0) { 804 kfree(pin_range); 805 return ret; 806 } 807 808 pinctrl_add_gpio_range(pctldev, &pin_range->range); 809 810 chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n", 811 gpio_offset, gpio_offset + pin_range->range.npins - 1, 812 pinctrl_dev_get_devname(pctldev), pin_group); 813 814 list_add_tail(&pin_range->node, &chip->pin_ranges); 815 816 return 0; 817} 818EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range); 819 820/** 821 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping 822 * @chip: the gpiochip to add the range for 823 * @pinctrl_name: the dev_name() of the pin controller to map to 824 * @gpio_offset: the start offset in the current gpio_chip number space 825 * @pin_offset: the start offset in the pin controller number space 826 * @npins: the number of pins from the offset of each pin space (GPIO and 827 * pin controller) to accumulate in this range 828 */ 829int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name, 830 unsigned int gpio_offset, unsigned int pin_offset, 831 unsigned int npins) 832{ 833 struct gpio_pin_range *pin_range; 834 int ret; 835 836 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL); 837 if (!pin_range) { 838 chip_err(chip, "failed to allocate pin ranges\n"); 839 return -ENOMEM; 840 } 841 842 /* Use local offset as range ID */ 843 pin_range->range.id = gpio_offset; 844 pin_range->range.gc = chip; 845 pin_range->range.name = chip->label; 846 pin_range->range.base = chip->base + gpio_offset; 847 pin_range->range.pin_base = pin_offset; 848 pin_range->range.npins = npins; 849 pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name, 850 &pin_range->range); 851 if (IS_ERR(pin_range->pctldev)) { 852 ret = PTR_ERR(pin_range->pctldev); 853 chip_err(chip, "could not create pin range\n"); 854 kfree(pin_range); 855 return ret; 856 } 857 chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n", 858 gpio_offset, gpio_offset + npins - 1, 859 pinctl_name, 860 pin_offset, pin_offset + npins - 1); 861 862 list_add_tail(&pin_range->node, &chip->pin_ranges); 863 864 return 0; 865} 866EXPORT_SYMBOL_GPL(gpiochip_add_pin_range); 867 868/** 869 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings 870 * @chip: the chip to remove all the mappings for 871 */ 872void gpiochip_remove_pin_ranges(struct gpio_chip *chip) 873{ 874 struct gpio_pin_range *pin_range, *tmp; 875 876 list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) { 877 list_del(&pin_range->node); 878 pinctrl_remove_gpio_range(pin_range->pctldev, 879 &pin_range->range); 880 kfree(pin_range); 881 } 882} 883EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges); 884 885#endif /* CONFIG_PINCTRL */ 886 887/* These "optional" allocation calls help prevent drivers from stomping 888 * on each other, and help provide better diagnostics in debugfs. 889 * They're called even less than the "set direction" calls. 890 */ 891static int __gpiod_request(struct gpio_desc *desc, const char *label) 892{ 893 struct gpio_chip *chip = desc->chip; 894 int status; 895 unsigned long flags; 896 897 spin_lock_irqsave(&gpio_lock, flags); 898 899 /* NOTE: gpio_request() can be called in early boot, 900 * before IRQs are enabled, for non-sleeping (SOC) GPIOs. 901 */ 902 903 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) { 904 desc_set_label(desc, label ? : "?"); 905 status = 0; 906 } else { 907 status = -EBUSY; 908 goto done; 909 } 910 911 if (chip->request) { 912 /* chip->request may sleep */ 913 spin_unlock_irqrestore(&gpio_lock, flags); 914 status = chip->request(chip, gpio_chip_hwgpio(desc)); 915 spin_lock_irqsave(&gpio_lock, flags); 916 917 if (status < 0) { 918 desc_set_label(desc, NULL); 919 clear_bit(FLAG_REQUESTED, &desc->flags); 920 goto done; 921 } 922 } 923 if (chip->get_direction) { 924 /* chip->get_direction may sleep */ 925 spin_unlock_irqrestore(&gpio_lock, flags); 926 gpiod_get_direction(desc); 927 spin_lock_irqsave(&gpio_lock, flags); 928 } 929done: 930 if (status < 0) { 931 /* Clear flags that might have been set by the caller before 932 * requesting the GPIO. 933 */ 934 clear_bit(FLAG_ACTIVE_LOW, &desc->flags); 935 clear_bit(FLAG_OPEN_DRAIN, &desc->flags); 936 clear_bit(FLAG_OPEN_SOURCE, &desc->flags); 937 } 938 spin_unlock_irqrestore(&gpio_lock, flags); 939 return status; 940} 941 942int gpiod_request(struct gpio_desc *desc, const char *label) 943{ 944 int status = -EPROBE_DEFER; 945 struct gpio_chip *chip; 946 947 if (!desc) { 948 pr_warn("%s: invalid GPIO\n", __func__); 949 return -EINVAL; 950 } 951 952 chip = desc->chip; 953 if (!chip) 954 goto done; 955 956 if (try_module_get(chip->owner)) { 957 status = __gpiod_request(desc, label); 958 if (status < 0) 959 module_put(chip->owner); 960 } 961 962done: 963 if (status) 964 gpiod_dbg(desc, "%s: status %d\n", __func__, status); 965 966 return status; 967} 968 969static bool __gpiod_free(struct gpio_desc *desc) 970{ 971 bool ret = false; 972 unsigned long flags; 973 struct gpio_chip *chip; 974 975 might_sleep(); 976 977 gpiod_unexport(desc); 978 979 spin_lock_irqsave(&gpio_lock, flags); 980 981 chip = desc->chip; 982 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) { 983 if (chip->free) { 984 spin_unlock_irqrestore(&gpio_lock, flags); 985 might_sleep_if(chip->can_sleep); 986 chip->free(chip, gpio_chip_hwgpio(desc)); 987 spin_lock_irqsave(&gpio_lock, flags); 988 } 989 desc_set_label(desc, NULL); 990 clear_bit(FLAG_ACTIVE_LOW, &desc->flags); 991 clear_bit(FLAG_REQUESTED, &desc->flags); 992 clear_bit(FLAG_OPEN_DRAIN, &desc->flags); 993 clear_bit(FLAG_OPEN_SOURCE, &desc->flags); 994 clear_bit(FLAG_IS_HOGGED, &desc->flags); 995 ret = true; 996 } 997 998 spin_unlock_irqrestore(&gpio_lock, flags); 999 return ret; 1000} 1001 1002void gpiod_free(struct gpio_desc *desc) 1003{ 1004 if (desc && __gpiod_free(desc)) 1005 module_put(desc->chip->owner); 1006 else 1007 WARN_ON(extra_checks); 1008} 1009 1010/** 1011 * gpiochip_is_requested - return string iff signal was requested 1012 * @chip: controller managing the signal 1013 * @offset: of signal within controller's 0..(ngpio - 1) range 1014 * 1015 * Returns NULL if the GPIO is not currently requested, else a string. 1016 * The string returned is the label passed to gpio_request(); if none has been 1017 * passed it is a meaningless, non-NULL constant. 1018 * 1019 * This function is for use by GPIO controller drivers. The label can 1020 * help with diagnostics, and knowing that the signal is used as a GPIO 1021 * can help avoid accidentally multiplexing it to another controller. 1022 */ 1023const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset) 1024{ 1025 struct gpio_desc *desc; 1026 1027 if (offset >= chip->ngpio) 1028 return NULL; 1029 1030 desc = &chip->desc[offset]; 1031 1032 if (test_bit(FLAG_REQUESTED, &desc->flags) == 0) 1033 return NULL; 1034 return desc->label; 1035} 1036EXPORT_SYMBOL_GPL(gpiochip_is_requested); 1037 1038/** 1039 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor 1040 * @desc: GPIO descriptor to request 1041 * @label: label for the GPIO 1042 * 1043 * Function allows GPIO chip drivers to request and use their own GPIO 1044 * descriptors via gpiolib API. Difference to gpiod_request() is that this 1045 * function will not increase reference count of the GPIO chip module. This 1046 * allows the GPIO chip module to be unloaded as needed (we assume that the 1047 * GPIO chip driver handles freeing the GPIOs it has requested). 1048 */ 1049struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum, 1050 const char *label) 1051{ 1052 struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum); 1053 int err; 1054 1055 if (IS_ERR(desc)) { 1056 chip_err(chip, "failed to get GPIO descriptor\n"); 1057 return desc; 1058 } 1059 1060 err = __gpiod_request(desc, label); 1061 if (err < 0) 1062 return ERR_PTR(err); 1063 1064 return desc; 1065} 1066EXPORT_SYMBOL_GPL(gpiochip_request_own_desc); 1067 1068/** 1069 * gpiochip_free_own_desc - Free GPIO requested by the chip driver 1070 * @desc: GPIO descriptor to free 1071 * 1072 * Function frees the given GPIO requested previously with 1073 * gpiochip_request_own_desc(). 1074 */ 1075void gpiochip_free_own_desc(struct gpio_desc *desc) 1076{ 1077 if (desc) 1078 __gpiod_free(desc); 1079} 1080EXPORT_SYMBOL_GPL(gpiochip_free_own_desc); 1081 1082/* Drivers MUST set GPIO direction before making get/set calls. In 1083 * some cases this is done in early boot, before IRQs are enabled. 1084 * 1085 * As a rule these aren't called more than once (except for drivers 1086 * using the open-drain emulation idiom) so these are natural places 1087 * to accumulate extra debugging checks. Note that we can't (yet) 1088 * rely on gpio_request() having been called beforehand. 1089 */ 1090 1091/** 1092 * gpiod_direction_input - set the GPIO direction to input 1093 * @desc: GPIO to set to input 1094 * 1095 * Set the direction of the passed GPIO to input, such as gpiod_get_value() can 1096 * be called safely on it. 1097 * 1098 * Return 0 in case of success, else an error code. 1099 */ 1100int gpiod_direction_input(struct gpio_desc *desc) 1101{ 1102 struct gpio_chip *chip; 1103 int status = -EINVAL; 1104 1105 if (!desc || !desc->chip) { 1106 pr_warn("%s: invalid GPIO\n", __func__); 1107 return -EINVAL; 1108 } 1109 1110 chip = desc->chip; 1111 if (!chip->get || !chip->direction_input) { 1112 gpiod_warn(desc, 1113 "%s: missing get() or direction_input() operations\n", 1114 __func__); 1115 return -EIO; 1116 } 1117 1118 status = chip->direction_input(chip, gpio_chip_hwgpio(desc)); 1119 if (status == 0) 1120 clear_bit(FLAG_IS_OUT, &desc->flags); 1121 1122 trace_gpio_direction(desc_to_gpio(desc), 1, status); 1123 1124 return status; 1125} 1126EXPORT_SYMBOL_GPL(gpiod_direction_input); 1127 1128static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value) 1129{ 1130 struct gpio_chip *chip; 1131 int status = -EINVAL; 1132 1133 /* GPIOs used for IRQs shall not be set as output */ 1134 if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) { 1135 gpiod_err(desc, 1136 "%s: tried to set a GPIO tied to an IRQ as output\n", 1137 __func__); 1138 return -EIO; 1139 } 1140 1141 /* Open drain pin should not be driven to 1 */ 1142 if (value && test_bit(FLAG_OPEN_DRAIN, &desc->flags)) 1143 return gpiod_direction_input(desc); 1144 1145 /* Open source pin should not be driven to 0 */ 1146 if (!value && test_bit(FLAG_OPEN_SOURCE, &desc->flags)) 1147 return gpiod_direction_input(desc); 1148 1149 chip = desc->chip; 1150 if (!chip->set || !chip->direction_output) { 1151 gpiod_warn(desc, 1152 "%s: missing set() or direction_output() operations\n", 1153 __func__); 1154 return -EIO; 1155 } 1156 1157 status = chip->direction_output(chip, gpio_chip_hwgpio(desc), value); 1158 if (status == 0) 1159 set_bit(FLAG_IS_OUT, &desc->flags); 1160 trace_gpio_value(desc_to_gpio(desc), 0, value); 1161 trace_gpio_direction(desc_to_gpio(desc), 0, status); 1162 return status; 1163} 1164 1165/** 1166 * gpiod_direction_output_raw - set the GPIO direction to output 1167 * @desc: GPIO to set to output 1168 * @value: initial output value of the GPIO 1169 * 1170 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can 1171 * be called safely on it. The initial value of the output must be specified 1172 * as raw value on the physical line without regard for the ACTIVE_LOW status. 1173 * 1174 * Return 0 in case of success, else an error code. 1175 */ 1176int gpiod_direction_output_raw(struct gpio_desc *desc, int value) 1177{ 1178 if (!desc || !desc->chip) { 1179 pr_warn("%s: invalid GPIO\n", __func__); 1180 return -EINVAL; 1181 } 1182 return _gpiod_direction_output_raw(desc, value); 1183} 1184EXPORT_SYMBOL_GPL(gpiod_direction_output_raw); 1185 1186/** 1187 * gpiod_direction_output - set the GPIO direction to output 1188 * @desc: GPIO to set to output 1189 * @value: initial output value of the GPIO 1190 * 1191 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can 1192 * be called safely on it. The initial value of the output must be specified 1193 * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into 1194 * account. 1195 * 1196 * Return 0 in case of success, else an error code. 1197 */ 1198int gpiod_direction_output(struct gpio_desc *desc, int value) 1199{ 1200 if (!desc || !desc->chip) { 1201 pr_warn("%s: invalid GPIO\n", __func__); 1202 return -EINVAL; 1203 } 1204 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 1205 value = !value; 1206 return _gpiod_direction_output_raw(desc, value); 1207} 1208EXPORT_SYMBOL_GPL(gpiod_direction_output); 1209 1210/** 1211 * gpiod_set_debounce - sets @debounce time for a @gpio 1212 * @gpio: the gpio to set debounce time 1213 * @debounce: debounce time is microseconds 1214 * 1215 * returns -ENOTSUPP if the controller does not support setting 1216 * debounce. 1217 */ 1218int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce) 1219{ 1220 struct gpio_chip *chip; 1221 1222 if (!desc || !desc->chip) { 1223 pr_warn("%s: invalid GPIO\n", __func__); 1224 return -EINVAL; 1225 } 1226 1227 chip = desc->chip; 1228 if (!chip->set || !chip->set_debounce) { 1229 gpiod_dbg(desc, 1230 "%s: missing set() or set_debounce() operations\n", 1231 __func__); 1232 return -ENOTSUPP; 1233 } 1234 1235 return chip->set_debounce(chip, gpio_chip_hwgpio(desc), debounce); 1236} 1237EXPORT_SYMBOL_GPL(gpiod_set_debounce); 1238 1239/** 1240 * gpiod_is_active_low - test whether a GPIO is active-low or not 1241 * @desc: the gpio descriptor to test 1242 * 1243 * Returns 1 if the GPIO is active-low, 0 otherwise. 1244 */ 1245int gpiod_is_active_low(const struct gpio_desc *desc) 1246{ 1247 return test_bit(FLAG_ACTIVE_LOW, &desc->flags); 1248} 1249EXPORT_SYMBOL_GPL(gpiod_is_active_low); 1250 1251/* I/O calls are only valid after configuration completed; the relevant 1252 * "is this a valid GPIO" error checks should already have been done. 1253 * 1254 * "Get" operations are often inlinable as reading a pin value register, 1255 * and masking the relevant bit in that register. 1256 * 1257 * When "set" operations are inlinable, they involve writing that mask to 1258 * one register to set a low value, or a different register to set it high. 1259 * Otherwise locking is needed, so there may be little value to inlining. 1260 * 1261 *------------------------------------------------------------------------ 1262 * 1263 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers 1264 * have requested the GPIO. That can include implicit requesting by 1265 * a direction setting call. Marking a gpio as requested locks its chip 1266 * in memory, guaranteeing that these table lookups need no more locking 1267 * and that gpiochip_remove() will fail. 1268 * 1269 * REVISIT when debugging, consider adding some instrumentation to ensure 1270 * that the GPIO was actually requested. 1271 */ 1272 1273static int _gpiod_get_raw_value(const struct gpio_desc *desc) 1274{ 1275 struct gpio_chip *chip; 1276 int offset; 1277 int value; 1278 1279 chip = desc->chip; 1280 offset = gpio_chip_hwgpio(desc); 1281 value = chip->get ? chip->get(chip, offset) : -EIO; 1282 /* 1283 * FIXME: fix all drivers to clamp to [0,1] or return negative, 1284 * then change this to: 1285 * value = value < 0 ? value : !!value; 1286 * so we can properly propagate error codes. 1287 */ 1288 value = !!value; 1289 trace_gpio_value(desc_to_gpio(desc), 1, value); 1290 return value; 1291} 1292 1293/** 1294 * gpiod_get_raw_value() - return a gpio's raw value 1295 * @desc: gpio whose value will be returned 1296 * 1297 * Return the GPIO's raw value, i.e. the value of the physical line disregarding 1298 * its ACTIVE_LOW status, or negative errno on failure. 1299 * 1300 * This function should be called from contexts where we cannot sleep, and will 1301 * complain if the GPIO chip functions potentially sleep. 1302 */ 1303int gpiod_get_raw_value(const struct gpio_desc *desc) 1304{ 1305 if (!desc) 1306 return 0; 1307 /* Should be using gpio_get_value_cansleep() */ 1308 WARN_ON(desc->chip->can_sleep); 1309 return _gpiod_get_raw_value(desc); 1310} 1311EXPORT_SYMBOL_GPL(gpiod_get_raw_value); 1312 1313/** 1314 * gpiod_get_value() - return a gpio's value 1315 * @desc: gpio whose value will be returned 1316 * 1317 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into 1318 * account, or negative errno on failure. 1319 * 1320 * This function should be called from contexts where we cannot sleep, and will 1321 * complain if the GPIO chip functions potentially sleep. 1322 */ 1323int gpiod_get_value(const struct gpio_desc *desc) 1324{ 1325 int value; 1326 if (!desc) 1327 return 0; 1328 /* Should be using gpio_get_value_cansleep() */ 1329 WARN_ON(desc->chip->can_sleep); 1330 1331 value = _gpiod_get_raw_value(desc); 1332 if (value < 0) 1333 return value; 1334 1335 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 1336 value = !value; 1337 1338 return value; 1339} 1340EXPORT_SYMBOL_GPL(gpiod_get_value); 1341 1342/* 1343 * _gpio_set_open_drain_value() - Set the open drain gpio's value. 1344 * @desc: gpio descriptor whose state need to be set. 1345 * @value: Non-zero for setting it HIGH otherwise it will set to LOW. 1346 */ 1347static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value) 1348{ 1349 int err = 0; 1350 struct gpio_chip *chip = desc->chip; 1351 int offset = gpio_chip_hwgpio(desc); 1352 1353 if (value) { 1354 err = chip->direction_input(chip, offset); 1355 if (!err) 1356 clear_bit(FLAG_IS_OUT, &desc->flags); 1357 } else { 1358 err = chip->direction_output(chip, offset, 0); 1359 if (!err) 1360 set_bit(FLAG_IS_OUT, &desc->flags); 1361 } 1362 trace_gpio_direction(desc_to_gpio(desc), value, err); 1363 if (err < 0) 1364 gpiod_err(desc, 1365 "%s: Error in set_value for open drain err %d\n", 1366 __func__, err); 1367} 1368 1369/* 1370 * _gpio_set_open_source_value() - Set the open source gpio's value. 1371 * @desc: gpio descriptor whose state need to be set. 1372 * @value: Non-zero for setting it HIGH otherwise it will set to LOW. 1373 */ 1374static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value) 1375{ 1376 int err = 0; 1377 struct gpio_chip *chip = desc->chip; 1378 int offset = gpio_chip_hwgpio(desc); 1379 1380 if (value) { 1381 err = chip->direction_output(chip, offset, 1); 1382 if (!err) 1383 set_bit(FLAG_IS_OUT, &desc->flags); 1384 } else { 1385 err = chip->direction_input(chip, offset); 1386 if (!err) 1387 clear_bit(FLAG_IS_OUT, &desc->flags); 1388 } 1389 trace_gpio_direction(desc_to_gpio(desc), !value, err); 1390 if (err < 0) 1391 gpiod_err(desc, 1392 "%s: Error in set_value for open source err %d\n", 1393 __func__, err); 1394} 1395 1396static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) 1397{ 1398 struct gpio_chip *chip; 1399 1400 chip = desc->chip; 1401 trace_gpio_value(desc_to_gpio(desc), 0, value); 1402 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) 1403 _gpio_set_open_drain_value(desc, value); 1404 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) 1405 _gpio_set_open_source_value(desc, value); 1406 else 1407 chip->set(chip, gpio_chip_hwgpio(desc), value); 1408} 1409 1410/* 1411 * set multiple outputs on the same chip; 1412 * use the chip's set_multiple function if available; 1413 * otherwise set the outputs sequentially; 1414 * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word 1415 * defines which outputs are to be changed 1416 * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word 1417 * defines the values the outputs specified by mask are to be set to 1418 */ 1419static void gpio_chip_set_multiple(struct gpio_chip *chip, 1420 unsigned long *mask, unsigned long *bits) 1421{ 1422 if (chip->set_multiple) { 1423 chip->set_multiple(chip, mask, bits); 1424 } else { 1425 int i; 1426 for (i = 0; i < chip->ngpio; i++) { 1427 if (mask[BIT_WORD(i)] == 0) { 1428 /* no more set bits in this mask word; 1429 * skip ahead to the next word */ 1430 i = (BIT_WORD(i) + 1) * BITS_PER_LONG - 1; 1431 continue; 1432 } 1433 /* set outputs if the corresponding mask bit is set */ 1434 if (__test_and_clear_bit(i, mask)) 1435 chip->set(chip, i, test_bit(i, bits)); 1436 } 1437 } 1438} 1439 1440static void gpiod_set_array_value_priv(bool raw, bool can_sleep, 1441 unsigned int array_size, 1442 struct gpio_desc **desc_array, 1443 int *value_array) 1444{ 1445 int i = 0; 1446 1447 while (i < array_size) { 1448 struct gpio_chip *chip = desc_array[i]->chip; 1449 unsigned long mask[BITS_TO_LONGS(chip->ngpio)]; 1450 unsigned long bits[BITS_TO_LONGS(chip->ngpio)]; 1451 int count = 0; 1452 1453 if (!can_sleep) 1454 WARN_ON(chip->can_sleep); 1455 1456 memset(mask, 0, sizeof(mask)); 1457 do { 1458 struct gpio_desc *desc = desc_array[i]; 1459 int hwgpio = gpio_chip_hwgpio(desc); 1460 int value = value_array[i]; 1461 1462 if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 1463 value = !value; 1464 trace_gpio_value(desc_to_gpio(desc), 0, value); 1465 /* 1466 * collect all normal outputs belonging to the same chip 1467 * open drain and open source outputs are set individually 1468 */ 1469 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) { 1470 _gpio_set_open_drain_value(desc, value); 1471 } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) { 1472 _gpio_set_open_source_value(desc, value); 1473 } else { 1474 __set_bit(hwgpio, mask); 1475 if (value) 1476 __set_bit(hwgpio, bits); 1477 else 1478 __clear_bit(hwgpio, bits); 1479 count++; 1480 } 1481 i++; 1482 } while ((i < array_size) && (desc_array[i]->chip == chip)); 1483 /* push collected bits to outputs */ 1484 if (count != 0) 1485 gpio_chip_set_multiple(chip, mask, bits); 1486 } 1487} 1488 1489/** 1490 * gpiod_set_raw_value() - assign a gpio's raw value 1491 * @desc: gpio whose value will be assigned 1492 * @value: value to assign 1493 * 1494 * Set the raw value of the GPIO, i.e. the value of its physical line without 1495 * regard for its ACTIVE_LOW status. 1496 * 1497 * This function should be called from contexts where we cannot sleep, and will 1498 * complain if the GPIO chip functions potentially sleep. 1499 */ 1500void gpiod_set_raw_value(struct gpio_desc *desc, int value) 1501{ 1502 if (!desc) 1503 return; 1504 /* Should be using gpio_set_value_cansleep() */ 1505 WARN_ON(desc->chip->can_sleep); 1506 _gpiod_set_raw_value(desc, value); 1507} 1508EXPORT_SYMBOL_GPL(gpiod_set_raw_value); 1509 1510/** 1511 * gpiod_set_value() - assign a gpio's value 1512 * @desc: gpio whose value will be assigned 1513 * @value: value to assign 1514 * 1515 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into 1516 * account 1517 * 1518 * This function should be called from contexts where we cannot sleep, and will 1519 * complain if the GPIO chip functions potentially sleep. 1520 */ 1521void gpiod_set_value(struct gpio_desc *desc, int value) 1522{ 1523 if (!desc) 1524 return; 1525 /* Should be using gpio_set_value_cansleep() */ 1526 WARN_ON(desc->chip->can_sleep); 1527 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 1528 value = !value; 1529 _gpiod_set_raw_value(desc, value); 1530} 1531EXPORT_SYMBOL_GPL(gpiod_set_value); 1532 1533/** 1534 * gpiod_set_raw_array_value() - assign values to an array of GPIOs 1535 * @array_size: number of elements in the descriptor / value arrays 1536 * @desc_array: array of GPIO descriptors whose values will be assigned 1537 * @value_array: array of values to assign 1538 * 1539 * Set the raw values of the GPIOs, i.e. the values of the physical lines 1540 * without regard for their ACTIVE_LOW status. 1541 * 1542 * This function should be called from contexts where we cannot sleep, and will 1543 * complain if the GPIO chip functions potentially sleep. 1544 */ 1545void gpiod_set_raw_array_value(unsigned int array_size, 1546 struct gpio_desc **desc_array, int *value_array) 1547{ 1548 if (!desc_array) 1549 return; 1550 gpiod_set_array_value_priv(true, false, array_size, desc_array, 1551 value_array); 1552} 1553EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value); 1554 1555/** 1556 * gpiod_set_array_value() - assign values to an array of GPIOs 1557 * @array_size: number of elements in the descriptor / value arrays 1558 * @desc_array: array of GPIO descriptors whose values will be assigned 1559 * @value_array: array of values to assign 1560 * 1561 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status 1562 * into account. 1563 * 1564 * This function should be called from contexts where we cannot sleep, and will 1565 * complain if the GPIO chip functions potentially sleep. 1566 */ 1567void gpiod_set_array_value(unsigned int array_size, 1568 struct gpio_desc **desc_array, int *value_array) 1569{ 1570 if (!desc_array) 1571 return; 1572 gpiod_set_array_value_priv(false, false, array_size, desc_array, 1573 value_array); 1574} 1575EXPORT_SYMBOL_GPL(gpiod_set_array_value); 1576 1577/** 1578 * gpiod_cansleep() - report whether gpio value access may sleep 1579 * @desc: gpio to check 1580 * 1581 */ 1582int gpiod_cansleep(const struct gpio_desc *desc) 1583{ 1584 if (!desc) 1585 return 0; 1586 return desc->chip->can_sleep; 1587} 1588EXPORT_SYMBOL_GPL(gpiod_cansleep); 1589 1590/** 1591 * gpiod_to_irq() - return the IRQ corresponding to a GPIO 1592 * @desc: gpio whose IRQ will be returned (already requested) 1593 * 1594 * Return the IRQ corresponding to the passed GPIO, or an error code in case of 1595 * error. 1596 */ 1597int gpiod_to_irq(const struct gpio_desc *desc) 1598{ 1599 struct gpio_chip *chip; 1600 int offset; 1601 1602 if (!desc) 1603 return -EINVAL; 1604 chip = desc->chip; 1605 offset = gpio_chip_hwgpio(desc); 1606 return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO; 1607} 1608EXPORT_SYMBOL_GPL(gpiod_to_irq); 1609 1610/** 1611 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ 1612 * @chip: the chip the GPIO to lock belongs to 1613 * @offset: the offset of the GPIO to lock as IRQ 1614 * 1615 * This is used directly by GPIO drivers that want to lock down 1616 * a certain GPIO line to be used for IRQs. 1617 */ 1618int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset) 1619{ 1620 if (offset >= chip->ngpio) 1621 return -EINVAL; 1622 1623 if (test_bit(FLAG_IS_OUT, &chip->desc[offset].flags)) { 1624 chip_err(chip, 1625 "%s: tried to flag a GPIO set as output for IRQ\n", 1626 __func__); 1627 return -EIO; 1628 } 1629 1630 set_bit(FLAG_USED_AS_IRQ, &chip->desc[offset].flags); 1631 return 0; 1632} 1633EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq); 1634 1635/** 1636 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ 1637 * @chip: the chip the GPIO to lock belongs to 1638 * @offset: the offset of the GPIO to lock as IRQ 1639 * 1640 * This is used directly by GPIO drivers that want to indicate 1641 * that a certain GPIO is no longer used exclusively for IRQ. 1642 */ 1643void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset) 1644{ 1645 if (offset >= chip->ngpio) 1646 return; 1647 1648 clear_bit(FLAG_USED_AS_IRQ, &chip->desc[offset].flags); 1649} 1650EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq); 1651 1652/** 1653 * gpiod_get_raw_value_cansleep() - return a gpio's raw value 1654 * @desc: gpio whose value will be returned 1655 * 1656 * Return the GPIO's raw value, i.e. the value of the physical line disregarding 1657 * its ACTIVE_LOW status, or negative errno on failure. 1658 * 1659 * This function is to be called from contexts that can sleep. 1660 */ 1661int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc) 1662{ 1663 might_sleep_if(extra_checks); 1664 if (!desc) 1665 return 0; 1666 return _gpiod_get_raw_value(desc); 1667} 1668EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep); 1669 1670/** 1671 * gpiod_get_value_cansleep() - return a gpio's value 1672 * @desc: gpio whose value will be returned 1673 * 1674 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into 1675 * account, or negative errno on failure. 1676 * 1677 * This function is to be called from contexts that can sleep. 1678 */ 1679int gpiod_get_value_cansleep(const struct gpio_desc *desc) 1680{ 1681 int value; 1682 1683 might_sleep_if(extra_checks); 1684 if (!desc) 1685 return 0; 1686 1687 value = _gpiod_get_raw_value(desc); 1688 if (value < 0) 1689 return value; 1690 1691 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 1692 value = !value; 1693 1694 return value; 1695} 1696EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep); 1697 1698/** 1699 * gpiod_set_raw_value_cansleep() - assign a gpio's raw value 1700 * @desc: gpio whose value will be assigned 1701 * @value: value to assign 1702 * 1703 * Set the raw value of the GPIO, i.e. the value of its physical line without 1704 * regard for its ACTIVE_LOW status. 1705 * 1706 * This function is to be called from contexts that can sleep. 1707 */ 1708void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value) 1709{ 1710 might_sleep_if(extra_checks); 1711 if (!desc) 1712 return; 1713 _gpiod_set_raw_value(desc, value); 1714} 1715EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep); 1716 1717/** 1718 * gpiod_set_value_cansleep() - assign a gpio's value 1719 * @desc: gpio whose value will be assigned 1720 * @value: value to assign 1721 * 1722 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into 1723 * account 1724 * 1725 * This function is to be called from contexts that can sleep. 1726 */ 1727void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) 1728{ 1729 might_sleep_if(extra_checks); 1730 if (!desc) 1731 return; 1732 1733 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 1734 value = !value; 1735 _gpiod_set_raw_value(desc, value); 1736} 1737EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep); 1738 1739/** 1740 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs 1741 * @array_size: number of elements in the descriptor / value arrays 1742 * @desc_array: array of GPIO descriptors whose values will be assigned 1743 * @value_array: array of values to assign 1744 * 1745 * Set the raw values of the GPIOs, i.e. the values of the physical lines 1746 * without regard for their ACTIVE_LOW status. 1747 * 1748 * This function is to be called from contexts that can sleep. 1749 */ 1750void gpiod_set_raw_array_value_cansleep(unsigned int array_size, 1751 struct gpio_desc **desc_array, 1752 int *value_array) 1753{ 1754 might_sleep_if(extra_checks); 1755 if (!desc_array) 1756 return; 1757 gpiod_set_array_value_priv(true, true, array_size, desc_array, 1758 value_array); 1759} 1760EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep); 1761 1762/** 1763 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs 1764 * @array_size: number of elements in the descriptor / value arrays 1765 * @desc_array: array of GPIO descriptors whose values will be assigned 1766 * @value_array: array of values to assign 1767 * 1768 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status 1769 * into account. 1770 * 1771 * This function is to be called from contexts that can sleep. 1772 */ 1773void gpiod_set_array_value_cansleep(unsigned int array_size, 1774 struct gpio_desc **desc_array, 1775 int *value_array) 1776{ 1777 might_sleep_if(extra_checks); 1778 if (!desc_array) 1779 return; 1780 gpiod_set_array_value_priv(false, true, array_size, desc_array, 1781 value_array); 1782} 1783EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep); 1784 1785/** 1786 * gpiod_add_lookup_table() - register GPIO device consumers 1787 * @table: table of consumers to register 1788 */ 1789void gpiod_add_lookup_table(struct gpiod_lookup_table *table) 1790{ 1791 mutex_lock(&gpio_lookup_lock); 1792 1793 list_add_tail(&table->list, &gpio_lookup_list); 1794 1795 mutex_unlock(&gpio_lookup_lock); 1796} 1797 1798/** 1799 * gpiod_remove_lookup_table() - unregister GPIO device consumers 1800 * @table: table of consumers to unregister 1801 */ 1802void gpiod_remove_lookup_table(struct gpiod_lookup_table *table) 1803{ 1804 mutex_lock(&gpio_lookup_lock); 1805 1806 list_del(&table->list); 1807 1808 mutex_unlock(&gpio_lookup_lock); 1809} 1810 1811static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id, 1812 unsigned int idx, 1813 enum gpio_lookup_flags *flags) 1814{ 1815 char prop_name[32]; /* 32 is max size of property name */ 1816 enum of_gpio_flags of_flags; 1817 struct gpio_desc *desc; 1818 unsigned int i; 1819 1820 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 1821 if (con_id) 1822 snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id, 1823 gpio_suffixes[i]); 1824 else 1825 snprintf(prop_name, sizeof(prop_name), "%s", 1826 gpio_suffixes[i]); 1827 1828 desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx, 1829 &of_flags); 1830 if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER)) 1831 break; 1832 } 1833 1834 if (IS_ERR(desc)) 1835 return desc; 1836 1837 if (of_flags & OF_GPIO_ACTIVE_LOW) 1838 *flags |= GPIO_ACTIVE_LOW; 1839 1840 if (of_flags & OF_GPIO_SINGLE_ENDED) { 1841 if (of_flags & OF_GPIO_ACTIVE_LOW) 1842 *flags |= GPIO_OPEN_DRAIN; 1843 else 1844 *flags |= GPIO_OPEN_SOURCE; 1845 } 1846 1847 return desc; 1848} 1849 1850static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id, 1851 unsigned int idx, 1852 enum gpio_lookup_flags *flags) 1853{ 1854 struct acpi_device *adev = ACPI_COMPANION(dev); 1855 struct acpi_gpio_info info; 1856 struct gpio_desc *desc; 1857 char propname[32]; 1858 int i; 1859 1860 /* Try first from _DSD */ 1861 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 1862 if (con_id && strcmp(con_id, "gpios")) { 1863 snprintf(propname, sizeof(propname), "%s-%s", 1864 con_id, gpio_suffixes[i]); 1865 } else { 1866 snprintf(propname, sizeof(propname), "%s", 1867 gpio_suffixes[i]); 1868 } 1869 1870 desc = acpi_get_gpiod_by_index(adev, propname, idx, &info); 1871 if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER)) 1872 break; 1873 } 1874 1875 /* Then from plain _CRS GPIOs */ 1876 if (IS_ERR(desc)) { 1877 desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info); 1878 if (IS_ERR(desc)) 1879 return desc; 1880 } 1881 1882 if (info.active_low) 1883 *flags |= GPIO_ACTIVE_LOW; 1884 1885 return desc; 1886} 1887 1888static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev) 1889{ 1890 const char *dev_id = dev ? dev_name(dev) : NULL; 1891 struct gpiod_lookup_table *table; 1892 1893 mutex_lock(&gpio_lookup_lock); 1894 1895 list_for_each_entry(table, &gpio_lookup_list, list) { 1896 if (table->dev_id && dev_id) { 1897 /* 1898 * Valid strings on both ends, must be identical to have 1899 * a match 1900 */ 1901 if (!strcmp(table->dev_id, dev_id)) 1902 goto found; 1903 } else { 1904 /* 1905 * One of the pointers is NULL, so both must be to have 1906 * a match 1907 */ 1908 if (dev_id == table->dev_id) 1909 goto found; 1910 } 1911 } 1912 table = NULL; 1913 1914found: 1915 mutex_unlock(&gpio_lookup_lock); 1916 return table; 1917} 1918 1919static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id, 1920 unsigned int idx, 1921 enum gpio_lookup_flags *flags) 1922{ 1923 struct gpio_desc *desc = ERR_PTR(-ENOENT); 1924 struct gpiod_lookup_table *table; 1925 struct gpiod_lookup *p; 1926 1927 table = gpiod_find_lookup_table(dev); 1928 if (!table) 1929 return desc; 1930 1931 for (p = &table->table[0]; p->chip_label; p++) { 1932 struct gpio_chip *chip; 1933 1934 /* idx must always match exactly */ 1935 if (p->idx != idx) 1936 continue; 1937 1938 /* If the lookup entry has a con_id, require exact match */ 1939 if (p->con_id && (!con_id || strcmp(p->con_id, con_id))) 1940 continue; 1941 1942 chip = find_chip_by_name(p->chip_label); 1943 1944 if (!chip) { 1945 dev_err(dev, "cannot find GPIO chip %s\n", 1946 p->chip_label); 1947 return ERR_PTR(-ENODEV); 1948 } 1949 1950 if (chip->ngpio <= p->chip_hwnum) { 1951 dev_err(dev, 1952 "requested GPIO %d is out of range [0..%d] for chip %s\n", 1953 idx, chip->ngpio, chip->label); 1954 return ERR_PTR(-EINVAL); 1955 } 1956 1957 desc = gpiochip_get_desc(chip, p->chip_hwnum); 1958 *flags = p->flags; 1959 1960 return desc; 1961 } 1962 1963 return desc; 1964} 1965 1966static int dt_gpio_count(struct device *dev, const char *con_id) 1967{ 1968 int ret; 1969 char propname[32]; 1970 unsigned int i; 1971 1972 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 1973 if (con_id) 1974 snprintf(propname, sizeof(propname), "%s-%s", 1975 con_id, gpio_suffixes[i]); 1976 else 1977 snprintf(propname, sizeof(propname), "%s", 1978 gpio_suffixes[i]); 1979 1980 ret = of_gpio_named_count(dev->of_node, propname); 1981 if (ret >= 0) 1982 break; 1983 } 1984 return ret; 1985} 1986 1987static int platform_gpio_count(struct device *dev, const char *con_id) 1988{ 1989 struct gpiod_lookup_table *table; 1990 struct gpiod_lookup *p; 1991 unsigned int count = 0; 1992 1993 table = gpiod_find_lookup_table(dev); 1994 if (!table) 1995 return -ENOENT; 1996 1997 for (p = &table->table[0]; p->chip_label; p++) { 1998 if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) || 1999 (!con_id && !p->con_id)) 2000 count++; 2001 } 2002 if (!count) 2003 return -ENOENT; 2004 2005 return count; 2006} 2007 2008/** 2009 * gpiod_count - return the number of GPIOs associated with a device / function 2010 * or -ENOENT if no GPIO has been assigned to the requested function 2011 * @dev: GPIO consumer, can be NULL for system-global GPIOs 2012 * @con_id: function within the GPIO consumer 2013 */ 2014int gpiod_count(struct device *dev, const char *con_id) 2015{ 2016 int count = -ENOENT; 2017 2018 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) 2019 count = dt_gpio_count(dev, con_id); 2020 else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev)) 2021 count = acpi_gpio_count(dev, con_id); 2022 2023 if (count < 0) 2024 count = platform_gpio_count(dev, con_id); 2025 2026 return count; 2027} 2028EXPORT_SYMBOL_GPL(gpiod_count); 2029 2030/** 2031 * gpiod_get - obtain a GPIO for a given GPIO function 2032 * @dev: GPIO consumer, can be NULL for system-global GPIOs 2033 * @con_id: function within the GPIO consumer 2034 * @flags: optional GPIO initialization flags 2035 * 2036 * Return the GPIO descriptor corresponding to the function con_id of device 2037 * dev, -ENOENT if no GPIO has been assigned to the requested function, or 2038 * another IS_ERR() code if an error occurred while trying to acquire the GPIO. 2039 */ 2040struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id, 2041 enum gpiod_flags flags) 2042{ 2043 return gpiod_get_index(dev, con_id, 0, flags); 2044} 2045EXPORT_SYMBOL_GPL(gpiod_get); 2046 2047/** 2048 * gpiod_get_optional - obtain an optional GPIO for a given GPIO function 2049 * @dev: GPIO consumer, can be NULL for system-global GPIOs 2050 * @con_id: function within the GPIO consumer 2051 * @flags: optional GPIO initialization flags 2052 * 2053 * This is equivalent to gpiod_get(), except that when no GPIO was assigned to 2054 * the requested function it will return NULL. This is convenient for drivers 2055 * that need to handle optional GPIOs. 2056 */ 2057struct gpio_desc *__must_check gpiod_get_optional(struct device *dev, 2058 const char *con_id, 2059 enum gpiod_flags flags) 2060{ 2061 return gpiod_get_index_optional(dev, con_id, 0, flags); 2062} 2063EXPORT_SYMBOL_GPL(gpiod_get_optional); 2064 2065/** 2066 * gpiod_parse_flags - helper function to parse GPIO lookup flags 2067 * @desc: gpio to be setup 2068 * @lflags: gpio_lookup_flags - returned from of_find_gpio() or 2069 * of_get_gpio_hog() 2070 * 2071 * Set the GPIO descriptor flags based on the given GPIO lookup flags. 2072 */ 2073static void gpiod_parse_flags(struct gpio_desc *desc, unsigned long lflags) 2074{ 2075 if (lflags & GPIO_ACTIVE_LOW) 2076 set_bit(FLAG_ACTIVE_LOW, &desc->flags); 2077 if (lflags & GPIO_OPEN_DRAIN) 2078 set_bit(FLAG_OPEN_DRAIN, &desc->flags); 2079 if (lflags & GPIO_OPEN_SOURCE) 2080 set_bit(FLAG_OPEN_SOURCE, &desc->flags); 2081} 2082 2083/** 2084 * gpiod_configure_flags - helper function to configure a given GPIO 2085 * @desc: gpio whose value will be assigned 2086 * @con_id: function within the GPIO consumer 2087 * @dflags: gpiod_flags - optional GPIO initialization flags 2088 * 2089 * Return 0 on success, -ENOENT if no GPIO has been assigned to the 2090 * requested function and/or index, or another IS_ERR() code if an error 2091 * occurred while trying to acquire the GPIO. 2092 */ 2093static int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id, 2094 enum gpiod_flags dflags) 2095{ 2096 int status; 2097 2098 /* No particular flag request, return here... */ 2099 if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) { 2100 pr_debug("no flags found for %s\n", con_id); 2101 return 0; 2102 } 2103 2104 /* Process flags */ 2105 if (dflags & GPIOD_FLAGS_BIT_DIR_OUT) 2106 status = gpiod_direction_output(desc, 2107 dflags & GPIOD_FLAGS_BIT_DIR_VAL); 2108 else 2109 status = gpiod_direction_input(desc); 2110 2111 return status; 2112} 2113 2114/** 2115 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function 2116 * @dev: GPIO consumer, can be NULL for system-global GPIOs 2117 * @con_id: function within the GPIO consumer 2118 * @idx: index of the GPIO to obtain in the consumer 2119 * @flags: optional GPIO initialization flags 2120 * 2121 * This variant of gpiod_get() allows to access GPIOs other than the first 2122 * defined one for functions that define several GPIOs. 2123 * 2124 * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the 2125 * requested function and/or index, or another IS_ERR() code if an error 2126 * occurred while trying to acquire the GPIO. 2127 */ 2128struct gpio_desc *__must_check gpiod_get_index(struct device *dev, 2129 const char *con_id, 2130 unsigned int idx, 2131 enum gpiod_flags flags) 2132{ 2133 struct gpio_desc *desc = NULL; 2134 int status; 2135 enum gpio_lookup_flags lookupflags = 0; 2136 2137 dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id); 2138 2139 if (dev) { 2140 /* Using device tree? */ 2141 if (IS_ENABLED(CONFIG_OF) && dev->of_node) { 2142 dev_dbg(dev, "using device tree for GPIO lookup\n"); 2143 desc = of_find_gpio(dev, con_id, idx, &lookupflags); 2144 } else if (ACPI_COMPANION(dev)) { 2145 dev_dbg(dev, "using ACPI for GPIO lookup\n"); 2146 desc = acpi_find_gpio(dev, con_id, idx, &lookupflags); 2147 } 2148 } 2149 2150 /* 2151 * Either we are not using DT or ACPI, or their lookup did not return 2152 * a result. In that case, use platform lookup as a fallback. 2153 */ 2154 if (!desc || desc == ERR_PTR(-ENOENT)) { 2155 dev_dbg(dev, "using lookup tables for GPIO lookup\n"); 2156 desc = gpiod_find(dev, con_id, idx, &lookupflags); 2157 } 2158 2159 if (IS_ERR(desc)) { 2160 dev_dbg(dev, "lookup for GPIO %s failed\n", con_id); 2161 return desc; 2162 } 2163 2164 gpiod_parse_flags(desc, lookupflags); 2165 2166 status = gpiod_request(desc, con_id); 2167 if (status < 0) 2168 return ERR_PTR(status); 2169 2170 status = gpiod_configure_flags(desc, con_id, flags); 2171 if (status < 0) { 2172 dev_dbg(dev, "setup of GPIO %s failed\n", con_id); 2173 gpiod_put(desc); 2174 return ERR_PTR(status); 2175 } 2176 2177 return desc; 2178} 2179EXPORT_SYMBOL_GPL(gpiod_get_index); 2180 2181/** 2182 * fwnode_get_named_gpiod - obtain a GPIO from firmware node 2183 * @fwnode: handle of the firmware node 2184 * @propname: name of the firmware property representing the GPIO 2185 * 2186 * This function can be used for drivers that get their configuration 2187 * from firmware. 2188 * 2189 * Function properly finds the corresponding GPIO using whatever is the 2190 * underlying firmware interface and then makes sure that the GPIO 2191 * descriptor is requested before it is returned to the caller. 2192 * 2193 * In case of error an ERR_PTR() is returned. 2194 */ 2195struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode, 2196 const char *propname) 2197{ 2198 struct gpio_desc *desc = ERR_PTR(-ENODEV); 2199 bool active_low = false; 2200 bool single_ended = false; 2201 int ret; 2202 2203 if (!fwnode) 2204 return ERR_PTR(-EINVAL); 2205 2206 if (is_of_node(fwnode)) { 2207 enum of_gpio_flags flags; 2208 2209 desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname, 0, 2210 &flags); 2211 if (!IS_ERR(desc)) { 2212 active_low = flags & OF_GPIO_ACTIVE_LOW; 2213 single_ended = flags & OF_GPIO_SINGLE_ENDED; 2214 } 2215 } else if (is_acpi_node(fwnode)) { 2216 struct acpi_gpio_info info; 2217 2218 desc = acpi_node_get_gpiod(fwnode, propname, 0, &info); 2219 if (!IS_ERR(desc)) 2220 active_low = info.active_low; 2221 } 2222 2223 if (IS_ERR(desc)) 2224 return desc; 2225 2226 if (active_low) 2227 set_bit(FLAG_ACTIVE_LOW, &desc->flags); 2228 2229 if (single_ended) { 2230 if (active_low) 2231 set_bit(FLAG_OPEN_DRAIN, &desc->flags); 2232 else 2233 set_bit(FLAG_OPEN_SOURCE, &desc->flags); 2234 } 2235 2236 ret = gpiod_request(desc, NULL); 2237 if (ret) 2238 return ERR_PTR(ret); 2239 2240 return desc; 2241} 2242EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod); 2243 2244/** 2245 * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO 2246 * function 2247 * @dev: GPIO consumer, can be NULL for system-global GPIOs 2248 * @con_id: function within the GPIO consumer 2249 * @index: index of the GPIO to obtain in the consumer 2250 * @flags: optional GPIO initialization flags 2251 * 2252 * This is equivalent to gpiod_get_index(), except that when no GPIO with the 2253 * specified index was assigned to the requested function it will return NULL. 2254 * This is convenient for drivers that need to handle optional GPIOs. 2255 */ 2256struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev, 2257 const char *con_id, 2258 unsigned int index, 2259 enum gpiod_flags flags) 2260{ 2261 struct gpio_desc *desc; 2262 2263 desc = gpiod_get_index(dev, con_id, index, flags); 2264 if (IS_ERR(desc)) { 2265 if (PTR_ERR(desc) == -ENOENT) 2266 return NULL; 2267 } 2268 2269 return desc; 2270} 2271EXPORT_SYMBOL_GPL(gpiod_get_index_optional); 2272 2273/** 2274 * gpiod_hog - Hog the specified GPIO desc given the provided flags 2275 * @desc: gpio whose value will be assigned 2276 * @name: gpio line name 2277 * @lflags: gpio_lookup_flags - returned from of_find_gpio() or 2278 * of_get_gpio_hog() 2279 * @dflags: gpiod_flags - optional GPIO initialization flags 2280 */ 2281int gpiod_hog(struct gpio_desc *desc, const char *name, 2282 unsigned long lflags, enum gpiod_flags dflags) 2283{ 2284 struct gpio_chip *chip; 2285 struct gpio_desc *local_desc; 2286 int hwnum; 2287 int status; 2288 2289 chip = gpiod_to_chip(desc); 2290 hwnum = gpio_chip_hwgpio(desc); 2291 2292 gpiod_parse_flags(desc, lflags); 2293 2294 local_desc = gpiochip_request_own_desc(chip, hwnum, name); 2295 if (IS_ERR(local_desc)) { 2296 pr_err("requesting hog GPIO %s (chip %s, offset %d) failed\n", 2297 name, chip->label, hwnum); 2298 return PTR_ERR(local_desc); 2299 } 2300 2301 status = gpiod_configure_flags(desc, name, dflags); 2302 if (status < 0) { 2303 pr_err("setup of hog GPIO %s (chip %s, offset %d) failed\n", 2304 name, chip->label, hwnum); 2305 gpiochip_free_own_desc(desc); 2306 return status; 2307 } 2308 2309 /* Mark GPIO as hogged so it can be identified and removed later */ 2310 set_bit(FLAG_IS_HOGGED, &desc->flags); 2311 2312 pr_info("GPIO line %d (%s) hogged as %s%s\n", 2313 desc_to_gpio(desc), name, 2314 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input", 2315 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? 2316 (dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":""); 2317 2318 return 0; 2319} 2320 2321/** 2322 * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog 2323 * @chip: gpio chip to act on 2324 * 2325 * This is only used by of_gpiochip_remove to free hogged gpios 2326 */ 2327static void gpiochip_free_hogs(struct gpio_chip *chip) 2328{ 2329 int id; 2330 2331 for (id = 0; id < chip->ngpio; id++) { 2332 if (test_bit(FLAG_IS_HOGGED, &chip->desc[id].flags)) 2333 gpiochip_free_own_desc(&chip->desc[id]); 2334 } 2335} 2336 2337/** 2338 * gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function 2339 * @dev: GPIO consumer, can be NULL for system-global GPIOs 2340 * @con_id: function within the GPIO consumer 2341 * @flags: optional GPIO initialization flags 2342 * 2343 * This function acquires all the GPIOs defined under a given function. 2344 * 2345 * Return a struct gpio_descs containing an array of descriptors, -ENOENT if 2346 * no GPIO has been assigned to the requested function, or another IS_ERR() 2347 * code if an error occurred while trying to acquire the GPIOs. 2348 */ 2349struct gpio_descs *__must_check gpiod_get_array(struct device *dev, 2350 const char *con_id, 2351 enum gpiod_flags flags) 2352{ 2353 struct gpio_desc *desc; 2354 struct gpio_descs *descs; 2355 int count; 2356 2357 count = gpiod_count(dev, con_id); 2358 if (count < 0) 2359 return ERR_PTR(count); 2360 2361 descs = kzalloc(sizeof(*descs) + sizeof(descs->desc[0]) * count, 2362 GFP_KERNEL); 2363 if (!descs) 2364 return ERR_PTR(-ENOMEM); 2365 2366 for (descs->ndescs = 0; descs->ndescs < count; ) { 2367 desc = gpiod_get_index(dev, con_id, descs->ndescs, flags); 2368 if (IS_ERR(desc)) { 2369 gpiod_put_array(descs); 2370 return ERR_CAST(desc); 2371 } 2372 descs->desc[descs->ndescs] = desc; 2373 descs->ndescs++; 2374 } 2375 return descs; 2376} 2377EXPORT_SYMBOL_GPL(gpiod_get_array); 2378 2379/** 2380 * gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO 2381 * function 2382 * @dev: GPIO consumer, can be NULL for system-global GPIOs 2383 * @con_id: function within the GPIO consumer 2384 * @flags: optional GPIO initialization flags 2385 * 2386 * This is equivalent to gpiod_get_array(), except that when no GPIO was 2387 * assigned to the requested function it will return NULL. 2388 */ 2389struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev, 2390 const char *con_id, 2391 enum gpiod_flags flags) 2392{ 2393 struct gpio_descs *descs; 2394 2395 descs = gpiod_get_array(dev, con_id, flags); 2396 if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT)) 2397 return NULL; 2398 2399 return descs; 2400} 2401EXPORT_SYMBOL_GPL(gpiod_get_array_optional); 2402 2403/** 2404 * gpiod_put - dispose of a GPIO descriptor 2405 * @desc: GPIO descriptor to dispose of 2406 * 2407 * No descriptor can be used after gpiod_put() has been called on it. 2408 */ 2409void gpiod_put(struct gpio_desc *desc) 2410{ 2411 gpiod_free(desc); 2412} 2413EXPORT_SYMBOL_GPL(gpiod_put); 2414 2415/** 2416 * gpiod_put_array - dispose of multiple GPIO descriptors 2417 * @descs: struct gpio_descs containing an array of descriptors 2418 */ 2419void gpiod_put_array(struct gpio_descs *descs) 2420{ 2421 unsigned int i; 2422 2423 for (i = 0; i < descs->ndescs; i++) 2424 gpiod_put(descs->desc[i]); 2425 2426 kfree(descs); 2427} 2428EXPORT_SYMBOL_GPL(gpiod_put_array); 2429 2430#ifdef CONFIG_DEBUG_FS 2431 2432static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip) 2433{ 2434 unsigned i; 2435 unsigned gpio = chip->base; 2436 struct gpio_desc *gdesc = &chip->desc[0]; 2437 int is_out; 2438 int is_irq; 2439 2440 for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) { 2441 if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) { 2442 if (gdesc->name) { 2443 seq_printf(s, " gpio-%-3d (%-20.20s)\n", 2444 gpio, gdesc->name); 2445 } 2446 continue; 2447 } 2448 2449 gpiod_get_direction(gdesc); 2450 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags); 2451 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags); 2452 seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s", 2453 gpio, gdesc->name ? gdesc->name : "", gdesc->label, 2454 is_out ? "out" : "in ", 2455 chip->get 2456 ? (chip->get(chip, i) ? "hi" : "lo") 2457 : "? ", 2458 is_irq ? "IRQ" : " "); 2459 seq_printf(s, "\n"); 2460 } 2461} 2462 2463static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos) 2464{ 2465 unsigned long flags; 2466 struct gpio_chip *chip = NULL; 2467 loff_t index = *pos; 2468 2469 s->private = ""; 2470 2471 spin_lock_irqsave(&gpio_lock, flags); 2472 list_for_each_entry(chip, &gpio_chips, list) 2473 if (index-- == 0) { 2474 spin_unlock_irqrestore(&gpio_lock, flags); 2475 return chip; 2476 } 2477 spin_unlock_irqrestore(&gpio_lock, flags); 2478 2479 return NULL; 2480} 2481 2482static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos) 2483{ 2484 unsigned long flags; 2485 struct gpio_chip *chip = v; 2486 void *ret = NULL; 2487 2488 spin_lock_irqsave(&gpio_lock, flags); 2489 if (list_is_last(&chip->list, &gpio_chips)) 2490 ret = NULL; 2491 else 2492 ret = list_entry(chip->list.next, struct gpio_chip, list); 2493 spin_unlock_irqrestore(&gpio_lock, flags); 2494 2495 s->private = "\n"; 2496 ++*pos; 2497 2498 return ret; 2499} 2500 2501static void gpiolib_seq_stop(struct seq_file *s, void *v) 2502{ 2503} 2504 2505static int gpiolib_seq_show(struct seq_file *s, void *v) 2506{ 2507 struct gpio_chip *chip = v; 2508 struct device *dev; 2509 2510 seq_printf(s, "%sGPIOs %d-%d", (char *)s->private, 2511 chip->base, chip->base + chip->ngpio - 1); 2512 dev = chip->dev; 2513 if (dev) 2514 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus", 2515 dev_name(dev)); 2516 if (chip->label) 2517 seq_printf(s, ", %s", chip->label); 2518 if (chip->can_sleep) 2519 seq_printf(s, ", can sleep"); 2520 seq_printf(s, ":\n"); 2521 2522 if (chip->dbg_show) 2523 chip->dbg_show(s, chip); 2524 else 2525 gpiolib_dbg_show(s, chip); 2526 2527 return 0; 2528} 2529 2530static const struct seq_operations gpiolib_seq_ops = { 2531 .start = gpiolib_seq_start, 2532 .next = gpiolib_seq_next, 2533 .stop = gpiolib_seq_stop, 2534 .show = gpiolib_seq_show, 2535}; 2536 2537static int gpiolib_open(struct inode *inode, struct file *file) 2538{ 2539 return seq_open(file, &gpiolib_seq_ops); 2540} 2541 2542static const struct file_operations gpiolib_operations = { 2543 .owner = THIS_MODULE, 2544 .open = gpiolib_open, 2545 .read = seq_read, 2546 .llseek = seq_lseek, 2547 .release = seq_release, 2548}; 2549 2550static int __init gpiolib_debugfs_init(void) 2551{ 2552 /* /sys/kernel/debug/gpio */ 2553 (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO, 2554 NULL, NULL, &gpiolib_operations); 2555 return 0; 2556} 2557subsys_initcall(gpiolib_debugfs_init); 2558 2559#endif /* DEBUG_FS */ 2560