drivers/gpio/gpiolib-acpi.c

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