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/consumer.h> 15 #include <linux/gpio/driver.h> 16 #include <linux/export.h> 17 #include <linux/acpi.h> 18 #include <linux/interrupt.h> 19 #include <linux/mutex.h> 20 21 #include "gpiolib.h" 22 23 struct acpi_gpio_event { 24 struct list_head node; 25 acpi_handle handle; 26 unsigned int pin; 27 unsigned int irq; 28 }; 29 30 struct acpi_gpio_connection { 31 struct list_head node; 32 struct gpio_desc *desc; 33 }; 34 35 struct acpi_gpio_chip { 36 /* 37 * ACPICA requires that the first field of the context parameter 38 * passed to acpi_install_address_space_handler() is large enough 39 * to hold struct acpi_connection_info. 40 */ 41 struct acpi_connection_info conn_info; 42 struct list_head conns; 43 struct mutex conn_lock; 44 struct gpio_chip *chip; 45 struct list_head events; 46 }; 47 48 static int acpi_gpiochip_find(struct gpio_chip *gc, void *data) 49 { 50 if (!gc->dev) 51 return false; 52 53 return ACPI_HANDLE(gc->dev) == data; 54 } 55 56 /** 57 * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API 58 * @path: ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1") 59 * @pin: ACPI GPIO pin number (0-based, controller-relative) 60 * 61 * Returns GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR 62 * error value 63 */ 64 65 static struct gpio_desc *acpi_get_gpiod(char *path, int pin) 66 { 67 struct gpio_chip *chip; 68 acpi_handle handle; 69 acpi_status status; 70 71 status = acpi_get_handle(NULL, path, &handle); 72 if (ACPI_FAILURE(status)) 73 return ERR_PTR(-ENODEV); 74 75 chip = gpiochip_find(handle, acpi_gpiochip_find); 76 if (!chip) 77 return ERR_PTR(-ENODEV); 78 79 if (pin < 0 || pin > chip->ngpio) 80 return ERR_PTR(-EINVAL); 81 82 return gpiochip_get_desc(chip, pin); 83 } 84 85 static irqreturn_t acpi_gpio_irq_handler(int irq, void *data) 86 { 87 struct acpi_gpio_event *event = data; 88 89 acpi_evaluate_object(event->handle, NULL, NULL, NULL); 90 91 return IRQ_HANDLED; 92 } 93 94 static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data) 95 { 96 struct acpi_gpio_event *event = data; 97 98 acpi_execute_simple_method(event->handle, NULL, event->pin); 99 100 return IRQ_HANDLED; 101 } 102 103 static void acpi_gpio_chip_dh(acpi_handle handle, void *data) 104 { 105 /* The address of this function is used as a key. */ 106 } 107 108 static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares, 109 void *context) 110 { 111 struct acpi_gpio_chip *acpi_gpio = context; 112 struct gpio_chip *chip = acpi_gpio->chip; 113 struct acpi_resource_gpio *agpio; 114 acpi_handle handle, evt_handle; 115 struct acpi_gpio_event *event; 116 irq_handler_t handler = NULL; 117 struct gpio_desc *desc; 118 unsigned long irqflags; 119 int ret, pin, irq; 120 121 if (ares->type != ACPI_RESOURCE_TYPE_GPIO) 122 return AE_OK; 123 124 agpio = &ares->data.gpio; 125 if (agpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT) 126 return AE_OK; 127 128 handle = ACPI_HANDLE(chip->dev); 129 pin = agpio->pin_table[0]; 130 131 if (pin <= 255) { 132 char ev_name[5]; 133 sprintf(ev_name, "_%c%02X", 134 agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L', 135 pin); 136 if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle))) 137 handler = acpi_gpio_irq_handler; 138 } 139 if (!handler) { 140 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle))) 141 handler = acpi_gpio_irq_handler_evt; 142 } 143 if (!handler) 144 return AE_BAD_PARAMETER; 145 146 desc = gpiochip_get_desc(chip, pin); 147 if (IS_ERR(desc)) { 148 dev_err(chip->dev, "Failed to get GPIO descriptor\n"); 149 return AE_ERROR; 150 } 151 152 ret = gpiochip_request_own_desc(desc, "ACPI:Event"); 153 if (ret) { 154 dev_err(chip->dev, "Failed to request GPIO\n"); 155 return AE_ERROR; 156 } 157 158 gpiod_direction_input(desc); 159 160 ret = gpio_lock_as_irq(chip, pin); 161 if (ret) { 162 dev_err(chip->dev, "Failed to lock GPIO as interrupt\n"); 163 goto fail_free_desc; 164 } 165 166 irq = gpiod_to_irq(desc); 167 if (irq < 0) { 168 dev_err(chip->dev, "Failed to translate GPIO to IRQ\n"); 169 goto fail_unlock_irq; 170 } 171 172 irqflags = IRQF_ONESHOT; 173 if (agpio->triggering == ACPI_LEVEL_SENSITIVE) { 174 if (agpio->polarity == ACPI_ACTIVE_HIGH) 175 irqflags |= IRQF_TRIGGER_HIGH; 176 else 177 irqflags |= IRQF_TRIGGER_LOW; 178 } else { 179 switch (agpio->polarity) { 180 case ACPI_ACTIVE_HIGH: 181 irqflags |= IRQF_TRIGGER_RISING; 182 break; 183 case ACPI_ACTIVE_LOW: 184 irqflags |= IRQF_TRIGGER_FALLING; 185 break; 186 default: 187 irqflags |= IRQF_TRIGGER_RISING | 188 IRQF_TRIGGER_FALLING; 189 break; 190 } 191 } 192 193 event = kzalloc(sizeof(*event), GFP_KERNEL); 194 if (!event) 195 goto fail_unlock_irq; 196 197 event->handle = evt_handle; 198 event->irq = irq; 199 event->pin = pin; 200 201 ret = request_threaded_irq(event->irq, NULL, handler, irqflags, 202 "ACPI:Event", event); 203 if (ret) { 204 dev_err(chip->dev, "Failed to setup interrupt handler for %d\n", 205 event->irq); 206 goto fail_free_event; 207 } 208 209 list_add_tail(&event->node, &acpi_gpio->events); 210 return AE_OK; 211 212 fail_free_event: 213 kfree(event); 214 fail_unlock_irq: 215 gpio_unlock_as_irq(chip, pin); 216 fail_free_desc: 217 gpiochip_free_own_desc(desc); 218 219 return AE_ERROR; 220 } 221 222 /** 223 * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events 224 * @chip: GPIO chip 225 * 226 * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are 227 * handled by ACPI event methods which need to be called from the GPIO 228 * chip's interrupt handler. acpi_gpiochip_request_interrupts finds out which 229 * gpio pins have acpi event methods and assigns interrupt handlers that calls 230 * the acpi event methods for those pins. 231 */ 232 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip) 233 { 234 struct acpi_gpio_chip *acpi_gpio; 235 acpi_handle handle; 236 acpi_status status; 237 238 if (!chip->dev || !chip->to_irq) 239 return; 240 241 handle = ACPI_HANDLE(chip->dev); 242 if (!handle) 243 return; 244 245 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); 246 if (ACPI_FAILURE(status)) 247 return; 248 249 INIT_LIST_HEAD(&acpi_gpio->events); 250 acpi_walk_resources(ACPI_HANDLE(chip->dev), "_AEI", 251 acpi_gpiochip_request_interrupt, acpi_gpio); 252 } 253 254 /** 255 * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts. 256 * @chip: GPIO chip 257 * 258 * Free interrupts associated with GPIO ACPI event method for the given 259 * GPIO chip. 260 */ 261 void acpi_gpiochip_free_interrupts(struct gpio_chip *chip) 262 { 263 struct acpi_gpio_chip *acpi_gpio; 264 struct acpi_gpio_event *event, *ep; 265 acpi_handle handle; 266 acpi_status status; 267 268 if (!chip->dev || !chip->to_irq) 269 return; 270 271 handle = ACPI_HANDLE(chip->dev); 272 if (!handle) 273 return; 274 275 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); 276 if (ACPI_FAILURE(status)) 277 return; 278 279 list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) { 280 struct gpio_desc *desc; 281 282 free_irq(event->irq, event); 283 desc = gpiochip_get_desc(chip, event->pin); 284 if (WARN_ON(IS_ERR(desc))) 285 continue; 286 gpio_unlock_as_irq(chip, event->pin); 287 gpiochip_free_own_desc(desc); 288 list_del(&event->node); 289 kfree(event); 290 } 291 } 292 293 struct acpi_gpio_lookup { 294 struct acpi_gpio_info info; 295 int index; 296 struct gpio_desc *desc; 297 int n; 298 }; 299 300 static int acpi_find_gpio(struct acpi_resource *ares, void *data) 301 { 302 struct acpi_gpio_lookup *lookup = data; 303 304 if (ares->type != ACPI_RESOURCE_TYPE_GPIO) 305 return 1; 306 307 if (lookup->n++ == lookup->index && !lookup->desc) { 308 const struct acpi_resource_gpio *agpio = &ares->data.gpio; 309 310 lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr, 311 agpio->pin_table[0]); 312 lookup->info.gpioint = 313 agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT; 314 lookup->info.active_low = 315 agpio->polarity == ACPI_ACTIVE_LOW; 316 } 317 318 return 1; 319 } 320 321 /** 322 * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources 323 * @dev: pointer to a device to get GPIO from 324 * @index: index of GpioIo/GpioInt resource (starting from %0) 325 * @info: info pointer to fill in (optional) 326 * 327 * Function goes through ACPI resources for @dev and based on @index looks 328 * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor, 329 * and returns it. @index matches GpioIo/GpioInt resources only so if there 330 * are total %3 GPIO resources, the index goes from %0 to %2. 331 * 332 * If the GPIO cannot be translated or there is an error an ERR_PTR is 333 * returned. 334 * 335 * Note: if the GPIO resource has multiple entries in the pin list, this 336 * function only returns the first. 337 */ 338 struct gpio_desc *acpi_get_gpiod_by_index(struct device *dev, int index, 339 struct acpi_gpio_info *info) 340 { 341 struct acpi_gpio_lookup lookup; 342 struct list_head resource_list; 343 struct acpi_device *adev; 344 acpi_handle handle; 345 int ret; 346 347 if (!dev) 348 return ERR_PTR(-EINVAL); 349 350 handle = ACPI_HANDLE(dev); 351 if (!handle || acpi_bus_get_device(handle, &adev)) 352 return ERR_PTR(-ENODEV); 353 354 memset(&lookup, 0, sizeof(lookup)); 355 lookup.index = index; 356 357 INIT_LIST_HEAD(&resource_list); 358 ret = acpi_dev_get_resources(adev, &resource_list, acpi_find_gpio, 359 &lookup); 360 if (ret < 0) 361 return ERR_PTR(ret); 362 363 acpi_dev_free_resource_list(&resource_list); 364 365 if (lookup.desc && info) 366 *info = lookup.info; 367 368 return lookup.desc ? lookup.desc : ERR_PTR(-ENOENT); 369 } 370 371 static acpi_status 372 acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address, 373 u32 bits, u64 *value, void *handler_context, 374 void *region_context) 375 { 376 struct acpi_gpio_chip *achip = region_context; 377 struct gpio_chip *chip = achip->chip; 378 struct acpi_resource_gpio *agpio; 379 struct acpi_resource *ares; 380 int pin_index = (int)address; 381 acpi_status status; 382 bool pull_up; 383 int length; 384 int i; 385 386 status = acpi_buffer_to_resource(achip->conn_info.connection, 387 achip->conn_info.length, &ares); 388 if (ACPI_FAILURE(status)) 389 return status; 390 391 if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) { 392 ACPI_FREE(ares); 393 return AE_BAD_PARAMETER; 394 } 395 396 agpio = &ares->data.gpio; 397 pull_up = agpio->pin_config == ACPI_PIN_CONFIG_PULLUP; 398 399 if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT && 400 function == ACPI_WRITE)) { 401 ACPI_FREE(ares); 402 return AE_BAD_PARAMETER; 403 } 404 405 length = min(agpio->pin_table_length, (u16)(pin_index + bits)); 406 for (i = pin_index; i < length; ++i) { 407 unsigned pin = agpio->pin_table[i]; 408 struct acpi_gpio_connection *conn; 409 struct gpio_desc *desc; 410 bool found; 411 412 desc = gpiochip_get_desc(chip, pin); 413 if (IS_ERR(desc)) { 414 status = AE_ERROR; 415 goto out; 416 } 417 418 mutex_lock(&achip->conn_lock); 419 420 found = false; 421 list_for_each_entry(conn, &achip->conns, node) { 422 if (conn->desc == desc) { 423 found = true; 424 break; 425 } 426 } 427 if (!found) { 428 int ret; 429 430 ret = gpiochip_request_own_desc(desc, "ACPI:OpRegion"); 431 if (ret) { 432 status = AE_ERROR; 433 mutex_unlock(&achip->conn_lock); 434 goto out; 435 } 436 437 switch (agpio->io_restriction) { 438 case ACPI_IO_RESTRICT_INPUT: 439 gpiod_direction_input(desc); 440 break; 441 case ACPI_IO_RESTRICT_OUTPUT: 442 /* 443 * ACPI GPIO resources don't contain an 444 * initial value for the GPIO. Therefore we 445 * deduce that value from the pull field 446 * instead. If the pin is pulled up we 447 * assume default to be high, otherwise 448 * low. 449 */ 450 gpiod_direction_output(desc, pull_up); 451 break; 452 default: 453 /* 454 * Assume that the BIOS has configured the 455 * direction and pull accordingly. 456 */ 457 break; 458 } 459 460 conn = kzalloc(sizeof(*conn), GFP_KERNEL); 461 if (!conn) { 462 status = AE_NO_MEMORY; 463 gpiochip_free_own_desc(desc); 464 mutex_unlock(&achip->conn_lock); 465 goto out; 466 } 467 468 conn->desc = desc; 469 list_add_tail(&conn->node, &achip->conns); 470 } 471 472 mutex_unlock(&achip->conn_lock); 473 474 if (function == ACPI_WRITE) 475 gpiod_set_raw_value_cansleep(desc, 476 !!((1 << i) & *value)); 477 else 478 *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i; 479 } 480 481 out: 482 ACPI_FREE(ares); 483 return status; 484 } 485 486 static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip) 487 { 488 struct gpio_chip *chip = achip->chip; 489 acpi_handle handle = ACPI_HANDLE(chip->dev); 490 acpi_status status; 491 492 INIT_LIST_HEAD(&achip->conns); 493 mutex_init(&achip->conn_lock); 494 status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, 495 acpi_gpio_adr_space_handler, 496 NULL, achip); 497 if (ACPI_FAILURE(status)) 498 dev_err(chip->dev, "Failed to install GPIO OpRegion handler\n"); 499 } 500 501 static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip) 502 { 503 struct gpio_chip *chip = achip->chip; 504 acpi_handle handle = ACPI_HANDLE(chip->dev); 505 struct acpi_gpio_connection *conn, *tmp; 506 acpi_status status; 507 508 status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, 509 acpi_gpio_adr_space_handler); 510 if (ACPI_FAILURE(status)) { 511 dev_err(chip->dev, "Failed to remove GPIO OpRegion handler\n"); 512 return; 513 } 514 515 list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) { 516 gpiochip_free_own_desc(conn->desc); 517 list_del(&conn->node); 518 kfree(conn); 519 } 520 } 521 522 void acpi_gpiochip_add(struct gpio_chip *chip) 523 { 524 struct acpi_gpio_chip *acpi_gpio; 525 acpi_handle handle; 526 acpi_status status; 527 528 if (!chip || !chip->dev) 529 return; 530 531 handle = ACPI_HANDLE(chip->dev); 532 if (!handle) 533 return; 534 535 acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL); 536 if (!acpi_gpio) { 537 dev_err(chip->dev, 538 "Failed to allocate memory for ACPI GPIO chip\n"); 539 return; 540 } 541 542 acpi_gpio->chip = chip; 543 544 status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio); 545 if (ACPI_FAILURE(status)) { 546 dev_err(chip->dev, "Failed to attach ACPI GPIO chip\n"); 547 kfree(acpi_gpio); 548 return; 549 } 550 551 acpi_gpiochip_request_regions(acpi_gpio); 552 } 553 554 void acpi_gpiochip_remove(struct gpio_chip *chip) 555 { 556 struct acpi_gpio_chip *acpi_gpio; 557 acpi_handle handle; 558 acpi_status status; 559 560 if (!chip || !chip->dev) 561 return; 562 563 handle = ACPI_HANDLE(chip->dev); 564 if (!handle) 565 return; 566 567 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); 568 if (ACPI_FAILURE(status)) { 569 dev_warn(chip->dev, "Failed to retrieve ACPI GPIO chip\n"); 570 return; 571 } 572 573 acpi_gpiochip_free_regions(acpi_gpio); 574 575 acpi_detach_data(handle, acpi_gpio_chip_dh); 576 kfree(acpi_gpio); 577 } 578