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