drivers/gpio/gpiolib-acpi.c

   1 /*
   2  * ACPI helpers for GPIO API
   3  *
   4  * Copyright (C) 2012, Intel Corporation
   5  * Authors: Mathias Nyman <mathias.nyman@linux.intel.com>
   6  *          Mika Westerberg <mika.westerberg@linux.intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/errno.h>
  14 #include <linux/gpio.h>
  15 #include <linux/gpio/consumer.h>
  16 #include <linux/gpio/driver.h>
  17 #include <linux/gpio/machine.h>
  18 #include <linux/export.h>
  19 #include <linux/acpi.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/mutex.h>
  22 #include <linux/pinctrl/pinctrl.h>
  23
  24 #include "gpiolib.h"
  25
  26 /**
  27  * struct acpi_gpio_event - ACPI GPIO event handler data
  28  *
  29  * @node:         list-entry of the events list of the struct acpi_gpio_chip
  30  * @handle:       handle of ACPI method to execute when the IRQ triggers
  31  * @handler:      irq_handler to pass to request_irq when requesting the IRQ
  32  * @pin:          GPIO pin number on the gpio_chip
  33  * @irq:          Linux IRQ number for the event, for request_ / free_irq
  34  * @irqflags:     flags to pass to request_irq when requesting the IRQ
  35  * @irq_is_wake:  If the ACPI flags indicate the IRQ is a wakeup source
  36  * @is_requested: True if request_irq has been done
  37  * @desc:         gpio_desc for the GPIO pin for this event
  38  */
  39 struct acpi_gpio_event {
  40         struct list_head node;
  41         acpi_handle handle;
  42         irq_handler_t handler;
  43         unsigned int pin;
  44         unsigned int irq;
  45         unsigned long irqflags;
  46         bool irq_is_wake;
  47         bool irq_requested;
  48         struct gpio_desc *desc;
  49 };
  50
  51 struct acpi_gpio_connection {
  52         struct list_head node;
  53         unsigned int pin;
  54         struct gpio_desc *desc;
  55 };
  56
  57 struct acpi_gpio_chip {
  58         /*
  59          * ACPICA requires that the first field of the context parameter
  60          * passed to acpi_install_address_space_handler() is large enough
  61          * to hold struct acpi_connection_info.
  62          */
  63         struct acpi_connection_info conn_info;
  64         struct list_head conns;
  65         struct mutex conn_lock;
  66         struct gpio_chip *chip;
  67         struct list_head events;
  68         struct list_head deferred_req_irqs_list_entry;
  69 };
  70
  71 /*
  72  * For gpiochips which call acpi_gpiochip_request_interrupts() before late_init
  73  * (so builtin drivers) we register the ACPI GpioInt IRQ handlers from a
  74  * late_initcall_sync handler, so that other builtin drivers can register their
  75  * OpRegions before the event handlers can run.  This list contains gpiochips
  76  * for which the acpi_gpiochip_request_irqs() call has been deferred.
  77  */
  78 static DEFINE_MUTEX(acpi_gpio_deferred_req_irqs_lock);
  79 static LIST_HEAD(acpi_gpio_deferred_req_irqs_list);
  80 static bool acpi_gpio_deferred_req_irqs_done;
  81
  82 static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
  83 {
  84         if (!gc->parent)
  85                 return false;
  86
  87         return ACPI_HANDLE(gc->parent) == data;
  88 }
  89
  90 #ifdef CONFIG_PINCTRL
  91 /**
  92  * acpi_gpiochip_pin_to_gpio_offset() - translates ACPI GPIO to Linux GPIO
  93  * @gdev: GPIO device
  94  * @pin: ACPI GPIO pin number from GpioIo/GpioInt resource
  95  *
  96  * Function takes ACPI GpioIo/GpioInt pin number as a parameter and
  97  * translates it to a corresponding offset suitable to be passed to a
  98  * GPIO controller driver.
  99  *
 100  * Typically the returned offset is same as @pin, but if the GPIO
 101  * controller uses pin controller and the mapping is not contiguous the
 102  * offset might be different.
 103  */
 104 static int acpi_gpiochip_pin_to_gpio_offset(struct gpio_device *gdev, int pin)
 105 {
 106         struct gpio_pin_range *pin_range;
 107
 108         /* If there are no ranges in this chip, use 1:1 mapping */
 109         if (list_empty(&gdev->pin_ranges))
 110                 return pin;
 111
 112         list_for_each_entry(pin_range, &gdev->pin_ranges, node) {
 113                 const struct pinctrl_gpio_range *range = &pin_range->range;
 114                 int i;
 115
 116                 if (range->pins) {
 117                         for (i = 0; i < range->npins; i++) {
 118                                 if (range->pins[i] == pin)
 119                                         return range->base + i - gdev->base;
 120                         }
 121                 } else {
 122                         if (pin >= range->pin_base &&
 123                             pin < range->pin_base + range->npins) {
 124                                 unsigned gpio_base;
 125
 126                                 gpio_base = range->base - gdev->base;
 127                                 return gpio_base + pin - range->pin_base;
 128                         }
 129                 }
 130         }
 131
 132         return -EINVAL;
 133 }
 134 #else
 135 static inline int acpi_gpiochip_pin_to_gpio_offset(struct gpio_device *gdev,
 136                                                    int pin)
 137 {
 138         return pin;
 139 }
 140 #endif
 141
 142 /**
 143  * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API
 144  * @path:       ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1")
 145  * @pin:        ACPI GPIO pin number (0-based, controller-relative)
 146  *
 147  * Return: GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR
 148  * error value. Specifically returns %-EPROBE_DEFER if the referenced GPIO
 149  * controller does not have gpiochip registered at the moment. This is to
 150  * support probe deferral.
 151  */
 152 static struct gpio_desc *acpi_get_gpiod(char *path, int pin)
 153 {
 154         struct gpio_chip *chip;
 155         acpi_handle handle;
 156         acpi_status status;
 157         int offset;
 158
 159         status = acpi_get_handle(NULL, path, &handle);
 160         if (ACPI_FAILURE(status))
 161                 return ERR_PTR(-ENODEV);
 162
 163         chip = gpiochip_find(handle, acpi_gpiochip_find);
 164         if (!chip)
 165                 return ERR_PTR(-EPROBE_DEFER);
 166
 167         offset = acpi_gpiochip_pin_to_gpio_offset(chip->gpiodev, pin);
 168         if (offset < 0)
 169                 return ERR_PTR(offset);
 170
 171         return gpiochip_get_desc(chip, offset);
 172 }
 173
 174 static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
 175 {
 176         struct acpi_gpio_event *event = data;
 177
 178         acpi_evaluate_object(event->handle, NULL, NULL, NULL);
 179
 180         return IRQ_HANDLED;
 181 }
 182
 183 static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data)
 184 {
 185         struct acpi_gpio_event *event = data;
 186
 187         acpi_execute_simple_method(event->handle, NULL, event->pin);
 188
 189         return IRQ_HANDLED;
 190 }
 191
 192 static void acpi_gpio_chip_dh(acpi_handle handle, void *data)
 193 {
 194         /* The address of this function is used as a key. */
 195 }
 196
 197 bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
 198                                 struct acpi_resource_gpio **agpio)
 199 {
 200         struct acpi_resource_gpio *gpio;
 201
 202         if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
 203                 return false;
 204
 205         gpio = &ares->data.gpio;
 206         if (gpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT)
 207                 return false;
 208
 209         *agpio = gpio;
 210         return true;
 211 }
 212 EXPORT_SYMBOL_GPL(acpi_gpio_get_irq_resource);
 213
 214 static void acpi_gpiochip_request_irq(struct acpi_gpio_chip *acpi_gpio,
 215                                       struct acpi_gpio_event *event)
 216 {
 217         int ret, value;
 218
 219         ret = request_threaded_irq(event->irq, NULL, event->handler,
 220                                    event->irqflags, "ACPI:Event", event);
 221         if (ret) {
 222                 dev_err(acpi_gpio->chip->parent,
 223                         "Failed to setup interrupt handler for %d\n",
 224                         event->irq);
 225                 return;
 226         }
 227
 228         if (event->irq_is_wake)
 229                 enable_irq_wake(event->irq);
 230
 231         event->irq_requested = true;
 232
 233         /* Make sure we trigger the initial state of edge-triggered IRQs */
 234         value = gpiod_get_raw_value_cansleep(event->desc);
 235         if (((event->irqflags & IRQF_TRIGGER_RISING) && value == 1) ||
 236             ((event->irqflags & IRQF_TRIGGER_FALLING) && value == 0))
 237                 event->handler(event->irq, event);
 238 }
 239
 240 static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio)
 241 {
 242         struct acpi_gpio_event *event;
 243
 244         list_for_each_entry(event, &acpi_gpio->events, node)
 245                 acpi_gpiochip_request_irq(acpi_gpio, event);
 246 }
 247
 248 static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares,
 249                                              void *context)
 250 {
 251         struct acpi_gpio_chip *acpi_gpio = context;
 252         struct gpio_chip *chip = acpi_gpio->chip;
 253         struct acpi_resource_gpio *agpio;
 254         acpi_handle handle, evt_handle;
 255         struct acpi_gpio_event *event;
 256         irq_handler_t handler = NULL;
 257         struct gpio_desc *desc;
 258         int ret, pin, irq;
 259
 260         if (!acpi_gpio_get_irq_resource(ares, &agpio))
 261                 return AE_OK;
 262
 263         handle = ACPI_HANDLE(chip->parent);
 264         pin = agpio->pin_table[0];
 265
 266         if (pin <= 255) {
 267                 char ev_name[5];
 268                 sprintf(ev_name, "_%c%02hhX",
 269                         agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L',
 270                         pin);
 271                 if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle)))
 272                         handler = acpi_gpio_irq_handler;
 273         }
 274         if (!handler) {
 275                 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle)))
 276                         handler = acpi_gpio_irq_handler_evt;
 277         }
 278         if (!handler)
 279                 return AE_OK;
 280
 281         pin = acpi_gpiochip_pin_to_gpio_offset(chip->gpiodev, pin);
 282         if (pin < 0)
 283                 return AE_BAD_PARAMETER;
 284
 285         desc = gpiochip_request_own_desc(chip, pin, "ACPI:Event");
 286         if (IS_ERR(desc)) {
 287                 dev_err(chip->parent, "Failed to request GPIO\n");
 288                 return AE_ERROR;
 289         }
 290
 291         gpiod_direction_input(desc);
 292
 293         ret = gpiochip_lock_as_irq(chip, pin);
 294         if (ret) {
 295                 dev_err(chip->parent, "Failed to lock GPIO as interrupt\n");
 296                 goto fail_free_desc;
 297         }
 298
 299         irq = gpiod_to_irq(desc);
 300         if (irq < 0) {
 301                 dev_err(chip->parent, "Failed to translate GPIO to IRQ\n");
 302                 goto fail_unlock_irq;
 303         }
 304
 305         event = kzalloc(sizeof(*event), GFP_KERNEL);
 306         if (!event)
 307                 goto fail_unlock_irq;
 308
 309         event->irqflags = IRQF_ONESHOT;
 310         if (agpio->triggering == ACPI_LEVEL_SENSITIVE) {
 311                 if (agpio->polarity == ACPI_ACTIVE_HIGH)
 312                         event->irqflags |= IRQF_TRIGGER_HIGH;
 313                 else
 314                         event->irqflags |= IRQF_TRIGGER_LOW;
 315         } else {
 316                 switch (agpio->polarity) {
 317                 case ACPI_ACTIVE_HIGH:
 318                         event->irqflags |= IRQF_TRIGGER_RISING;
 319                         break;
 320                 case ACPI_ACTIVE_LOW:
 321                         event->irqflags |= IRQF_TRIGGER_FALLING;
 322                         break;
 323                 default:
 324                         event->irqflags |= IRQF_TRIGGER_RISING |
 325                                            IRQF_TRIGGER_FALLING;
 326                         break;
 327                 }
 328         }
 329
 330         event->handle = evt_handle;
 331         event->handler = handler;
 332         event->irq = irq;
 333         event->irq_is_wake = agpio->wake_capable == ACPI_WAKE_CAPABLE;
 334         event->pin = pin;
 335         event->desc = desc;
 336
 337         list_add_tail(&event->node, &acpi_gpio->events);
 338
 339         return AE_OK;
 340
 341 fail_unlock_irq:
 342         gpiochip_unlock_as_irq(chip, pin);
 343 fail_free_desc:
 344         gpiochip_free_own_desc(desc);
 345
 346         return AE_ERROR;
 347 }
 348
 349 /**
 350  * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events
 351  * @chip:      GPIO chip
 352  *
 353  * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are
 354  * handled by ACPI event methods which need to be called from the GPIO
 355  * chip's interrupt handler. acpi_gpiochip_request_interrupts finds out which
 356  * gpio pins have acpi event methods and assigns interrupt handlers that calls
 357  * the acpi event methods for those pins.
 358  */
 359 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
 360 {
 361         struct acpi_gpio_chip *acpi_gpio;
 362         acpi_handle handle;
 363         acpi_status status;
 364         bool defer;
 365
 366         if (!chip->parent || !chip->to_irq)
 367                 return;
 368
 369         handle = ACPI_HANDLE(chip->parent);
 370         if (!handle)
 371                 return;
 372
 373         status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
 374         if (ACPI_FAILURE(status))
 375                 return;
 376
 377         acpi_walk_resources(handle, "_AEI",
 378                             acpi_gpiochip_alloc_event, acpi_gpio);
 379
 380         mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
 381         defer = !acpi_gpio_deferred_req_irqs_done;
 382         if (defer)
 383                 list_add(&acpi_gpio->deferred_req_irqs_list_entry,
 384                          &acpi_gpio_deferred_req_irqs_list);
 385         mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
 386
 387         if (defer)
 388                 return;
 389
 390         acpi_gpiochip_request_irqs(acpi_gpio);
 391 }
 392 EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts);
 393
 394 /**
 395  * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts.
 396  * @chip:      GPIO chip
 397  *
 398  * Free interrupts associated with GPIO ACPI event method for the given
 399  * GPIO chip.
 400  */
 401 void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
 402 {
 403         struct acpi_gpio_chip *acpi_gpio;
 404         struct acpi_gpio_event *event, *ep;
 405         acpi_handle handle;
 406         acpi_status status;
 407
 408         if (!chip->parent || !chip->to_irq)
 409                 return;
 410
 411         handle = ACPI_HANDLE(chip->parent);
 412         if (!handle)
 413                 return;
 414
 415         status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
 416         if (ACPI_FAILURE(status))
 417                 return;
 418
 419         mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
 420         if (!list_empty(&acpi_gpio->deferred_req_irqs_list_entry))
 421                 list_del_init(&acpi_gpio->deferred_req_irqs_list_entry);
 422         mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
 423
 424         list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {
 425                 struct gpio_desc *desc;
 426
 427                 if (event->irq_requested) {
 428                         if (event->irq_is_wake)
 429                                 disable_irq_wake(event->irq);
 430
 431                         free_irq(event->irq, event);
 432                 }
 433
 434                 desc = event->desc;
 435                 if (WARN_ON(IS_ERR(desc)))
 436                         continue;
 437                 gpiochip_unlock_as_irq(chip, event->pin);
 438                 gpiochip_free_own_desc(desc);
 439                 list_del(&event->node);
 440                 kfree(event);
 441         }
 442 }
 443 EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts);
 444
 445 int acpi_dev_add_driver_gpios(struct acpi_device *adev,
 446                               const struct acpi_gpio_mapping *gpios)
 447 {
 448         if (adev && gpios) {
 449                 adev->driver_gpios = gpios;
 450                 return 0;
 451         }
 452         return -EINVAL;
 453 }
 454 EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios);
 455
 456 static void devm_acpi_dev_release_driver_gpios(struct device *dev, void *res)
 457 {
 458         acpi_dev_remove_driver_gpios(ACPI_COMPANION(dev));
 459 }
 460
 461 int devm_acpi_dev_add_driver_gpios(struct device *dev,
 462                                    const struct acpi_gpio_mapping *gpios)
 463 {
 464         void *res;
 465         int ret;
 466
 467         res = devres_alloc(devm_acpi_dev_release_driver_gpios, 0, GFP_KERNEL);
 468         if (!res)
 469                 return -ENOMEM;
 470
 471         ret = acpi_dev_add_driver_gpios(ACPI_COMPANION(dev), gpios);
 472         if (ret) {
 473                 devres_free(res);
 474                 return ret;
 475         }
 476         devres_add(dev, res);
 477         return 0;
 478 }
 479 EXPORT_SYMBOL_GPL(devm_acpi_dev_add_driver_gpios);
 480
 481 void devm_acpi_dev_remove_driver_gpios(struct device *dev)
 482 {
 483         WARN_ON(devres_release(dev, devm_acpi_dev_release_driver_gpios, NULL, NULL));
 484 }
 485 EXPORT_SYMBOL_GPL(devm_acpi_dev_remove_driver_gpios);
 486
 487 static bool acpi_get_driver_gpio_data(struct acpi_device *adev,
 488                                       const char *name, int index,
 489                                       struct acpi_reference_args *args)
 490 {
 491         const struct acpi_gpio_mapping *gm;
 492
 493         if (!adev->driver_gpios)
 494                 return false;
 495
 496         for (gm = adev->driver_gpios; gm->name; gm++)
 497                 if (!strcmp(name, gm->name) && gm->data && index < gm->size) {
 498                         const struct acpi_gpio_params *par = gm->data + index;
 499
 500                         args->adev = adev;
 501                         args->args[0] = par->crs_entry_index;
 502                         args->args[1] = par->line_index;
 503                         args->args[2] = par->active_low;
 504                         args->nargs = 3;
 505                         return true;
 506                 }
 507
 508         return false;
 509 }
 510
 511 static enum gpiod_flags
 512 acpi_gpio_to_gpiod_flags(const struct acpi_resource_gpio *agpio)
 513 {
 514         bool pull_up = agpio->pin_config == ACPI_PIN_CONFIG_PULLUP;
 515
 516         switch (agpio->io_restriction) {
 517         case ACPI_IO_RESTRICT_INPUT:
 518                 return GPIOD_IN;
 519         case ACPI_IO_RESTRICT_OUTPUT:
 520                 /*
 521                  * ACPI GPIO resources don't contain an initial value for the
 522                  * GPIO. Therefore we deduce that value from the pull field
 523                  * instead. If the pin is pulled up we assume default to be
 524                  * high, otherwise low.
 525                  */
 526                 return pull_up ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
 527         default:
 528                 /*
 529                  * Assume that the BIOS has configured the direction and pull
 530                  * accordingly.
 531                  */
 532                 return GPIOD_ASIS;
 533         }
 534 }
 535
 536 int
 537 acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, enum gpiod_flags update)
 538 {
 539         int ret = 0;
 540
 541         /*
 542          * Check if the BIOS has IoRestriction with explicitly set direction
 543          * and update @flags accordingly. Otherwise use whatever caller asked
 544          * for.
 545          */
 546         if (update & GPIOD_FLAGS_BIT_DIR_SET) {
 547                 enum gpiod_flags diff = *flags ^ update;
 548
 549                 /*
 550                  * Check if caller supplied incompatible GPIO initialization
 551                  * flags.
 552                  *
 553                  * Return %-EINVAL to notify that firmware has different
 554                  * settings and we are going to use them.
 555                  */
 556                 if (((*flags & GPIOD_FLAGS_BIT_DIR_SET) && (diff & GPIOD_FLAGS_BIT_DIR_OUT)) ||
 557                     ((*flags & GPIOD_FLAGS_BIT_DIR_OUT) && (diff & GPIOD_FLAGS_BIT_DIR_VAL)))
 558                         ret = -EINVAL;
 559                 *flags = update;
 560         }
 561         return ret;
 562 }
 563
 564 struct acpi_gpio_lookup {
 565         struct acpi_gpio_info info;
 566         int index;
 567         int pin_index;
 568         bool active_low;
 569         struct acpi_device *adev;
 570         struct gpio_desc *desc;
 571         int n;
 572 };
 573
 574 static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data)
 575 {
 576         struct acpi_gpio_lookup *lookup = data;
 577
 578         if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
 579                 return 1;
 580
 581         if (lookup->n++ == lookup->index && !lookup->desc) {
 582                 const struct acpi_resource_gpio *agpio = &ares->data.gpio;
 583                 int pin_index = lookup->pin_index;
 584
 585                 if (pin_index >= agpio->pin_table_length)
 586                         return 1;
 587
 588                 lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr,
 589                                               agpio->pin_table[pin_index]);
 590                 lookup->info.gpioint =
 591                         agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT;
 592
 593                 /*
 594                  * Polarity and triggering are only specified for GpioInt
 595                  * resource.
 596                  * Note: we expect here:
 597                  * - ACPI_ACTIVE_LOW == GPIO_ACTIVE_LOW
 598                  * - ACPI_ACTIVE_HIGH == GPIO_ACTIVE_HIGH
 599                  */
 600                 if (lookup->info.gpioint) {
 601                         lookup->info.flags = GPIOD_IN;
 602                         lookup->info.polarity = agpio->polarity;
 603                         lookup->info.triggering = agpio->triggering;
 604                 } else {
 605                         lookup->info.flags = acpi_gpio_to_gpiod_flags(agpio);
 606                 }
 607
 608         }
 609
 610         return 1;
 611 }
 612
 613 static int acpi_gpio_resource_lookup(struct acpi_gpio_lookup *lookup,
 614                                      struct acpi_gpio_info *info)
 615 {
 616         struct list_head res_list;
 617         int ret;
 618
 619         INIT_LIST_HEAD(&res_list);
 620
 621         ret = acpi_dev_get_resources(lookup->adev, &res_list,
 622                                      acpi_populate_gpio_lookup,
 623                                      lookup);
 624         if (ret < 0)
 625                 return ret;
 626
 627         acpi_dev_free_resource_list(&res_list);
 628
 629         if (!lookup->desc)
 630                 return -ENOENT;
 631
 632         if (info) {
 633                 *info = lookup->info;
 634                 if (lookup->active_low)
 635                         info->polarity = lookup->active_low;
 636         }
 637         return 0;
 638 }
 639
 640 static int acpi_gpio_property_lookup(struct fwnode_handle *fwnode,
 641                                      const char *propname, int index,
 642                                      struct acpi_gpio_lookup *lookup)
 643 {
 644         struct acpi_reference_args args;
 645         int ret;
 646
 647         memset(&args, 0, sizeof(args));
 648         ret = __acpi_node_get_property_reference(fwnode, propname, index, 3,
 649                                                  &args);
 650         if (ret) {
 651                 struct acpi_device *adev = to_acpi_device_node(fwnode);
 652
 653                 if (!adev)
 654                         return ret;
 655
 656                 if (!acpi_get_driver_gpio_data(adev, propname, index, &args))
 657                         return ret;
 658         }
 659         /*
 660          * The property was found and resolved, so need to lookup the GPIO based
 661          * on returned args.
 662          */
 663         lookup->adev = args.adev;
 664         if (args.nargs != 3)
 665                 return -EPROTO;
 666
 667         lookup->index = args.args[0];
 668         lookup->pin_index = args.args[1];
 669         lookup->active_low = !!args.args[2];
 670
 671         return 0;
 672 }
 673
 674 /**
 675  * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources
 676  * @adev: pointer to a ACPI device to get GPIO from
 677  * @propname: Property name of the GPIO (optional)
 678  * @index: index of GpioIo/GpioInt resource (starting from %0)
 679  * @info: info pointer to fill in (optional)
 680  *
 681  * Function goes through ACPI resources for @adev and based on @index looks
 682  * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor,
 683  * and returns it. @index matches GpioIo/GpioInt resources only so if there
 684  * are total %3 GPIO resources, the index goes from %0 to %2.
 685  *
 686  * If @propname is specified the GPIO is looked using device property. In
 687  * that case @index is used to select the GPIO entry in the property value
 688  * (in case of multiple).
 689  *
 690  * If the GPIO cannot be translated or there is an error an ERR_PTR is
 691  * returned.
 692  *
 693  * Note: if the GPIO resource has multiple entries in the pin list, this
 694  * function only returns the first.
 695  */
 696 static struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
 697                                           const char *propname, int index,
 698                                           struct acpi_gpio_info *info)
 699 {
 700         struct acpi_gpio_lookup lookup;
 701         int ret;
 702
 703         if (!adev)
 704                 return ERR_PTR(-ENODEV);
 705
 706         memset(&lookup, 0, sizeof(lookup));
 707         lookup.index = index;
 708
 709         if (propname) {
 710                 dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);
 711
 712                 ret = acpi_gpio_property_lookup(acpi_fwnode_handle(adev),
 713                                                 propname, index, &lookup);
 714                 if (ret)
 715                         return ERR_PTR(ret);
 716
 717                 dev_dbg(&adev->dev, "GPIO: _DSD returned %s %d %d %u\n",
 718                         dev_name(&lookup.adev->dev), lookup.index,
 719                         lookup.pin_index, lookup.active_low);
 720         } else {
 721                 dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);
 722                 lookup.adev = adev;
 723         }
 724
 725         ret = acpi_gpio_resource_lookup(&lookup, info);
 726         return ret ? ERR_PTR(ret) : lookup.desc;
 727 }
 728
 729 struct gpio_desc *acpi_find_gpio(struct device *dev,
 730                                  const char *con_id,
 731                                  unsigned int idx,
 732                                  enum gpiod_flags *dflags,
 733                                  enum gpio_lookup_flags *lookupflags)
 734 {
 735         struct acpi_device *adev = ACPI_COMPANION(dev);
 736         struct acpi_gpio_info info;
 737         struct gpio_desc *desc;
 738         char propname[32];
 739         int err;
 740         int i;
 741
 742         /* Try first from _DSD */
 743         for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
 744                 if (con_id) {
 745                         snprintf(propname, sizeof(propname), "%s-%s",
 746                                  con_id, gpio_suffixes[i]);
 747                 } else {
 748                         snprintf(propname, sizeof(propname), "%s",
 749                                  gpio_suffixes[i]);
 750                 }
 751
 752                 desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
 753                 if (!IS_ERR(desc))
 754                         break;
 755                 if (PTR_ERR(desc) == -EPROBE_DEFER)
 756                         return ERR_CAST(desc);
 757         }
 758
 759         /* Then from plain _CRS GPIOs */
 760         if (IS_ERR(desc)) {
 761                 if (!acpi_can_fallback_to_crs(adev, con_id))
 762                         return ERR_PTR(-ENOENT);
 763
 764                 desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
 765                 if (IS_ERR(desc))
 766                         return desc;
 767         }
 768
 769         if (info.gpioint &&
 770             (*dflags == GPIOD_OUT_LOW || *dflags == GPIOD_OUT_HIGH)) {
 771                 dev_dbg(dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");
 772                 return ERR_PTR(-ENOENT);
 773         }
 774
 775         if (info.polarity == GPIO_ACTIVE_LOW)
 776                 *lookupflags |= GPIO_ACTIVE_LOW;
 777
 778         err = acpi_gpio_update_gpiod_flags(dflags, info.flags);
 779         if (err)
 780                 dev_dbg(dev, "Override GPIO initialization flags\n");
 781
 782         return desc;
 783 }
 784
 785 /**
 786  * acpi_node_get_gpiod() - get a GPIO descriptor from ACPI resources
 787  * @fwnode: pointer to an ACPI firmware node to get the GPIO information from
 788  * @propname: Property name of the GPIO
 789  * @index: index of GpioIo/GpioInt resource (starting from %0)
 790  * @info: info pointer to fill in (optional)
 791  *
 792  * If @fwnode is an ACPI device object, call %acpi_get_gpiod_by_index() for it.
 793  * Otherwise (ie. it is a data-only non-device object), use the property-based
 794  * GPIO lookup to get to the GPIO resource with the relevant information and use
 795  * that to obtain the GPIO descriptor to return.
 796  */
 797 struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
 798                                       const char *propname, int index,
 799                                       struct acpi_gpio_info *info)
 800 {
 801         struct acpi_gpio_lookup lookup;
 802         struct acpi_device *adev;
 803         int ret;
 804
 805         adev = to_acpi_device_node(fwnode);
 806         if (adev)
 807                 return acpi_get_gpiod_by_index(adev, propname, index, info);
 808
 809         if (!is_acpi_data_node(fwnode))
 810                 return ERR_PTR(-ENODEV);
 811
 812         if (!propname)
 813                 return ERR_PTR(-EINVAL);
 814
 815         memset(&lookup, 0, sizeof(lookup));
 816         lookup.index = index;
 817
 818         ret = acpi_gpio_property_lookup(fwnode, propname, index, &lookup);
 819         if (ret)
 820                 return ERR_PTR(ret);
 821
 822         ret = acpi_gpio_resource_lookup(&lookup, info);
 823         return ret ? ERR_PTR(ret) : lookup.desc;
 824 }
 825
 826 /**
 827  * acpi_dev_gpio_irq_get() - Find GpioInt and translate it to Linux IRQ number
 828  * @adev: pointer to a ACPI device to get IRQ from
 829  * @index: index of GpioInt resource (starting from %0)
 830  *
 831  * If the device has one or more GpioInt resources, this function can be
 832  * used to translate from the GPIO offset in the resource to the Linux IRQ
 833  * number.
 834  *
 835  * The function is idempotent, though each time it runs it will configure GPIO
 836  * pin direction according to the flags in GpioInt resource.
 837  *
 838  * Return: Linux IRQ number (> %0) on success, negative errno on failure.
 839  */
 840 int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
 841 {
 842         int idx, i;
 843         unsigned int irq_flags;
 844         int ret;
 845
 846         for (i = 0, idx = 0; idx <= index; i++) {
 847                 struct acpi_gpio_info info;
 848                 struct gpio_desc *desc;
 849
 850                 desc = acpi_get_gpiod_by_index(adev, NULL, i, &info);
 851
 852                 /* Ignore -EPROBE_DEFER, it only matters if idx matches */
 853                 if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER)
 854                         return PTR_ERR(desc);
 855
 856                 if (info.gpioint && idx++ == index) {
 857                         char label[32];
 858                         int irq;
 859
 860                         if (IS_ERR(desc))
 861                                 return PTR_ERR(desc);
 862
 863                         irq = gpiod_to_irq(desc);
 864                         if (irq < 0)
 865                                 return irq;
 866
 867                         snprintf(label, sizeof(label), "GpioInt() %d", index);
 868                         ret = gpiod_configure_flags(desc, label, 0, info.flags);
 869                         if (ret < 0)
 870                                 return ret;
 871
 872                         irq_flags = acpi_dev_get_irq_type(info.triggering,
 873                                                           info.polarity);
 874
 875                         /* Set type if specified and different than the current one */
 876                         if (irq_flags != IRQ_TYPE_NONE &&
 877                             irq_flags != irq_get_trigger_type(irq))
 878                                 irq_set_irq_type(irq, irq_flags);
 879
 880                         return irq;
 881                 }
 882
 883         }
 884         return -ENOENT;
 885 }
 886 EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get);
 887
 888 static acpi_status
 889 acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
 890                             u32 bits, u64 *value, void *handler_context,
 891                             void *region_context)
 892 {
 893         struct acpi_gpio_chip *achip = region_context;
 894         struct gpio_chip *chip = achip->chip;
 895         struct acpi_resource_gpio *agpio;
 896         struct acpi_resource *ares;
 897         int pin_index = (int)address;
 898         acpi_status status;
 899         int length;
 900         int i;
 901
 902         status = acpi_buffer_to_resource(achip->conn_info.connection,
 903                                          achip->conn_info.length, &ares);
 904         if (ACPI_FAILURE(status))
 905                 return status;
 906
 907         if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) {
 908                 ACPI_FREE(ares);
 909                 return AE_BAD_PARAMETER;
 910         }
 911
 912         agpio = &ares->data.gpio;
 913
 914         if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT &&
 915             function == ACPI_WRITE)) {
 916                 ACPI_FREE(ares);
 917                 return AE_BAD_PARAMETER;
 918         }
 919
 920         length = min(agpio->pin_table_length, (u16)(pin_index + bits));
 921         for (i = pin_index; i < length; ++i) {
 922                 int pin = agpio->pin_table[i];
 923                 struct acpi_gpio_connection *conn;
 924                 struct gpio_desc *desc;
 925                 bool found;
 926
 927                 pin = acpi_gpiochip_pin_to_gpio_offset(chip->gpiodev, pin);
 928                 if (pin < 0) {
 929                         status = AE_BAD_PARAMETER;
 930                         goto out;
 931                 }
 932
 933                 mutex_lock(&achip->conn_lock);
 934
 935                 found = false;
 936                 list_for_each_entry(conn, &achip->conns, node) {
 937                         if (conn->pin == pin) {
 938                                 found = true;
 939                                 desc = conn->desc;
 940                                 break;
 941                         }
 942                 }
 943
 944                 /*
 945                  * The same GPIO can be shared between operation region and
 946                  * event but only if the access here is ACPI_READ. In that
 947                  * case we "borrow" the event GPIO instead.
 948                  */
 949                 if (!found && agpio->sharable == ACPI_SHARED &&
 950                      function == ACPI_READ) {
 951                         struct acpi_gpio_event *event;
 952
 953                         list_for_each_entry(event, &achip->events, node) {
 954                                 if (event->pin == pin) {
 955                                         desc = event->desc;
 956                                         found = true;
 957                                         break;
 958                                 }
 959                         }
 960                 }
 961
 962                 if (!found) {
 963                         enum gpiod_flags flags = acpi_gpio_to_gpiod_flags(agpio);
 964                         const char *label = "ACPI:OpRegion";
 965                         int err;
 966
 967                         desc = gpiochip_request_own_desc(chip, pin, label);
 968                         if (IS_ERR(desc)) {
 969                                 status = AE_ERROR;
 970                                 mutex_unlock(&achip->conn_lock);
 971                                 goto out;
 972                         }
 973
 974                         err = gpiod_configure_flags(desc, label, 0, flags);
 975                         if (err < 0) {
 976                                 status = AE_NOT_CONFIGURED;
 977                                 gpiochip_free_own_desc(desc);
 978                                 mutex_unlock(&achip->conn_lock);
 979                                 goto out;
 980                         }
 981
 982                         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
 983                         if (!conn) {
 984                                 status = AE_NO_MEMORY;
 985                                 gpiochip_free_own_desc(desc);
 986                                 mutex_unlock(&achip->conn_lock);
 987                                 goto out;
 988                         }
 989
 990                         conn->pin = pin;
 991                         conn->desc = desc;
 992                         list_add_tail(&conn->node, &achip->conns);
 993                 }
 994
 995                 mutex_unlock(&achip->conn_lock);
 996
 997                 if (function == ACPI_WRITE)
 998                         gpiod_set_raw_value_cansleep(desc,
 999                                                      !!((1 << i) & *value));
1000                 else
1001                         *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i;
1002         }
1003
1004 out:
1005         ACPI_FREE(ares);
1006         return status;
1007 }
1008
1009 static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)
1010 {
1011         struct gpio_chip *chip = achip->chip;
1012         acpi_handle handle = ACPI_HANDLE(chip->parent);
1013         acpi_status status;
1014
1015         INIT_LIST_HEAD(&achip->conns);
1016         mutex_init(&achip->conn_lock);
1017         status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
1018                                                     acpi_gpio_adr_space_handler,
1019                                                     NULL, achip);
1020         if (ACPI_FAILURE(status))
1021                 dev_err(chip->parent,
1022                         "Failed to install GPIO OpRegion handler\n");
1023 }
1024
1025 static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip)
1026 {
1027         struct gpio_chip *chip = achip->chip;
1028         acpi_handle handle = ACPI_HANDLE(chip->parent);
1029         struct acpi_gpio_connection *conn, *tmp;
1030         acpi_status status;
1031
1032         status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
1033                                                    acpi_gpio_adr_space_handler);
1034         if (ACPI_FAILURE(status)) {
1035                 dev_err(chip->parent,
1036                         "Failed to remove GPIO OpRegion handler\n");
1037                 return;
1038         }
1039
1040         list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) {
1041                 gpiochip_free_own_desc(conn->desc);
1042                 list_del(&conn->node);
1043                 kfree(conn);
1044         }
1045 }
1046
1047 static struct gpio_desc *acpi_gpiochip_parse_own_gpio(
1048         struct acpi_gpio_chip *achip, struct fwnode_handle *fwnode,
1049         const char **name, unsigned int *lflags, unsigned int *dflags)
1050 {
1051         struct gpio_chip *chip = achip->chip;
1052         struct gpio_desc *desc;
1053         u32 gpios[2];
1054         int ret;
1055
1056         *lflags = 0;
1057         *dflags = 0;
1058         *name = NULL;
1059
1060         ret = fwnode_property_read_u32_array(fwnode, "gpios", gpios,
1061                                              ARRAY_SIZE(gpios));
1062         if (ret < 0)
1063                 return ERR_PTR(ret);
1064
1065         ret = acpi_gpiochip_pin_to_gpio_offset(chip->gpiodev, gpios[0]);
1066         if (ret < 0)
1067                 return ERR_PTR(ret);
1068
1069         desc = gpiochip_get_desc(chip, ret);
1070         if (IS_ERR(desc))
1071                 return desc;
1072
1073         if (gpios[1])
1074                 *lflags |= GPIO_ACTIVE_LOW;
1075
1076         if (fwnode_property_present(fwnode, "input"))
1077                 *dflags |= GPIOD_IN;
1078         else if (fwnode_property_present(fwnode, "output-low"))
1079                 *dflags |= GPIOD_OUT_LOW;
1080         else if (fwnode_property_present(fwnode, "output-high"))
1081                 *dflags |= GPIOD_OUT_HIGH;
1082         else
1083                 return ERR_PTR(-EINVAL);
1084
1085         fwnode_property_read_string(fwnode, "line-name", name);
1086
1087         return desc;
1088 }
1089
1090 static void acpi_gpiochip_scan_gpios(struct acpi_gpio_chip *achip)
1091 {
1092         struct gpio_chip *chip = achip->chip;
1093         struct fwnode_handle *fwnode;
1094
1095         device_for_each_child_node(chip->parent, fwnode) {
1096                 unsigned int lflags, dflags;
1097                 struct gpio_desc *desc;
1098                 const char *name;
1099                 int ret;
1100
1101                 if (!fwnode_property_present(fwnode, "gpio-hog"))
1102                         continue;
1103
1104                 desc = acpi_gpiochip_parse_own_gpio(achip, fwnode, &name,
1105                                                     &lflags, &dflags);
1106                 if (IS_ERR(desc))
1107                         continue;
1108
1109                 ret = gpiod_hog(desc, name, lflags, dflags);
1110                 if (ret) {
1111                         dev_err(chip->parent, "Failed to hog GPIO\n");
1112                         fwnode_handle_put(fwnode);
1113                         return;
1114                 }
1115         }
1116 }
1117
1118 void acpi_gpiochip_add(struct gpio_chip *chip)
1119 {
1120         struct acpi_gpio_chip *acpi_gpio;
1121         acpi_handle handle;
1122         acpi_status status;
1123
1124         if (!chip || !chip->parent)
1125                 return;
1126
1127         handle = ACPI_HANDLE(chip->parent);
1128         if (!handle)
1129                 return;
1130
1131         acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);
1132         if (!acpi_gpio) {
1133                 dev_err(chip->parent,
1134                         "Failed to allocate memory for ACPI GPIO chip\n");
1135                 return;
1136         }
1137
1138         acpi_gpio->chip = chip;
1139         INIT_LIST_HEAD(&acpi_gpio->events);
1140         INIT_LIST_HEAD(&acpi_gpio->deferred_req_irqs_list_entry);
1141
1142         status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio);
1143         if (ACPI_FAILURE(status)) {
1144                 dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n");
1145                 kfree(acpi_gpio);
1146                 return;
1147         }
1148
1149         if (!chip->names)
1150                 devprop_gpiochip_set_names(chip, dev_fwnode(chip->parent));
1151
1152         acpi_gpiochip_request_regions(acpi_gpio);
1153         acpi_gpiochip_scan_gpios(acpi_gpio);
1154         acpi_walk_dep_device_list(handle);
1155 }
1156
1157 void acpi_gpiochip_remove(struct gpio_chip *chip)
1158 {
1159         struct acpi_gpio_chip *acpi_gpio;
1160         acpi_handle handle;
1161         acpi_status status;
1162
1163         if (!chip || !chip->parent)
1164                 return;
1165
1166         handle = ACPI_HANDLE(chip->parent);
1167         if (!handle)
1168                 return;
1169
1170         status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
1171         if (ACPI_FAILURE(status)) {
1172                 dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n");
1173                 return;
1174         }
1175
1176         acpi_gpiochip_free_regions(acpi_gpio);
1177
1178         acpi_detach_data(handle, acpi_gpio_chip_dh);
1179         kfree(acpi_gpio);
1180 }
1181
1182 static int acpi_gpio_package_count(const union acpi_object *obj)
1183 {
1184         const union acpi_object *element = obj->package.elements;
1185         const union acpi_object *end = element + obj->package.count;
1186         unsigned int count = 0;
1187
1188         while (element < end) {
1189                 switch (element->type) {
1190                 case ACPI_TYPE_LOCAL_REFERENCE:
1191                         element += 3;
1192                         /* Fallthrough */
1193                 case ACPI_TYPE_INTEGER:
1194                         element++;
1195                         count++;
1196                         break;
1197
1198                 default:
1199                         return -EPROTO;
1200                 }
1201         }
1202
1203         return count;
1204 }
1205
1206 static int acpi_find_gpio_count(struct acpi_resource *ares, void *data)
1207 {
1208         unsigned int *count = data;
1209
1210         if (ares->type == ACPI_RESOURCE_TYPE_GPIO)
1211                 *count += ares->data.gpio.pin_table_length;
1212
1213         return 1;
1214 }
1215
1216 /**
1217  * acpi_gpio_count - return the number of GPIOs associated with a
1218  *              device / function or -ENOENT if no GPIO has been
1219  *              assigned to the requested function.
1220  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
1221  * @con_id:     function within the GPIO consumer
1222  */
1223 int acpi_gpio_count(struct device *dev, const char *con_id)
1224 {
1225         struct acpi_device *adev = ACPI_COMPANION(dev);
1226         const union acpi_object *obj;
1227         const struct acpi_gpio_mapping *gm;
1228         int count = -ENOENT;
1229         int ret;
1230         char propname[32];
1231         unsigned int i;
1232
1233         /* Try first from _DSD */
1234         for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
1235                 if (con_id)
1236                         snprintf(propname, sizeof(propname), "%s-%s",
1237                                  con_id, gpio_suffixes[i]);
1238                 else
1239                         snprintf(propname, sizeof(propname), "%s",
1240                                  gpio_suffixes[i]);
1241
1242                 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
1243                                             &obj);
1244                 if (ret == 0) {
1245                         if (obj->type == ACPI_TYPE_LOCAL_REFERENCE)
1246                                 count = 1;
1247                         else if (obj->type == ACPI_TYPE_PACKAGE)
1248                                 count = acpi_gpio_package_count(obj);
1249                 } else if (adev->driver_gpios) {
1250                         for (gm = adev->driver_gpios; gm->name; gm++)
1251                                 if (strcmp(propname, gm->name) == 0) {
1252                                         count = gm->size;
1253                                         break;
1254                                 }
1255                 }
1256                 if (count > 0)
1257                         break;
1258         }
1259
1260         /* Then from plain _CRS GPIOs */
1261         if (count < 0) {
1262                 struct list_head resource_list;
1263                 unsigned int crs_count = 0;
1264
1265                 if (!acpi_can_fallback_to_crs(adev, con_id))
1266                         return count;
1267
1268                 INIT_LIST_HEAD(&resource_list);
1269                 acpi_dev_get_resources(adev, &resource_list,
1270                                        acpi_find_gpio_count, &crs_count);
1271                 acpi_dev_free_resource_list(&resource_list);
1272                 if (crs_count > 0)
1273                         count = crs_count;
1274         }
1275         return count ? count : -ENOENT;
1276 }
1277
1278 bool acpi_can_fallback_to_crs(struct acpi_device *adev, const char *con_id)
1279 {
1280         /* Never allow fallback if the device has properties */
1281         if (adev->data.properties || adev->driver_gpios)
1282                 return false;
1283
1284         return con_id == NULL;
1285 }
1286
1287 /* Run deferred acpi_gpiochip_request_irqs() */
1288 static int acpi_gpio_handle_deferred_request_irqs(void)
1289 {
1290         struct acpi_gpio_chip *acpi_gpio, *tmp;
1291
1292         mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
1293         list_for_each_entry_safe(acpi_gpio, tmp,
1294                                  &acpi_gpio_deferred_req_irqs_list,
1295                                  deferred_req_irqs_list_entry)
1296                 acpi_gpiochip_request_irqs(acpi_gpio);
1297
1298         acpi_gpio_deferred_req_irqs_done = true;
1299         mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
1300
1301         return 0;
1302 }
1303 /* We must use _sync so that this runs after the first deferred_probe run */
1304 late_initcall_sync(acpi_gpio_handle_deferred_request_irqs);