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