drivers/gpio/gpiolib-acpi.c

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