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