1 /* 2 * drivers/acpi/resource.c - ACPI device resources interpretation. 3 * 4 * Copyright (C) 2012, Intel Corp. 5 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as published 11 * by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 19 */ 20 21 #include <linux/acpi.h> 22 #include <linux/device.h> 23 #include <linux/export.h> 24 #include <linux/ioport.h> 25 #include <linux/slab.h> 26 #include <linux/irq.h> 27 28 #ifdef CONFIG_X86 29 #define valid_IRQ(i) (((i) != 0) && ((i) != 2)) 30 static inline bool acpi_iospace_resource_valid(struct resource *res) 31 { 32 /* On X86 IO space is limited to the [0 - 64K] IO port range */ 33 return res->end < 0x10003; 34 } 35 #else 36 #define valid_IRQ(i) (true) 37 /* 38 * ACPI IO descriptors on arches other than X86 contain MMIO CPU physical 39 * addresses mapping IO space in CPU physical address space, IO space 40 * resources can be placed anywhere in the 64-bit physical address space. 41 */ 42 static inline bool 43 acpi_iospace_resource_valid(struct resource *res) { return true; } 44 #endif 45 46 #if IS_ENABLED(CONFIG_ACPI_GENERIC_GSI) 47 static inline bool is_gsi(struct acpi_resource_extended_irq *ext_irq) 48 { 49 return ext_irq->resource_source.string_length == 0 && 50 ext_irq->producer_consumer == ACPI_CONSUMER; 51 } 52 #else 53 static inline bool is_gsi(struct acpi_resource_extended_irq *ext_irq) 54 { 55 return true; 56 } 57 #endif 58 59 static bool acpi_dev_resource_len_valid(u64 start, u64 end, u64 len, bool io) 60 { 61 u64 reslen = end - start + 1; 62 63 /* 64 * CHECKME: len might be required to check versus a minimum 65 * length as well. 1 for io is fine, but for memory it does 66 * not make any sense at all. 67 * Note: some BIOSes report incorrect length for ACPI address space 68 * descriptor, so remove check of 'reslen == len' to avoid regression. 69 */ 70 if (len && reslen && start <= end) 71 return true; 72 73 pr_debug("ACPI: invalid or unassigned resource %s [%016llx - %016llx] length [%016llx]\n", 74 io ? "io" : "mem", start, end, len); 75 76 return false; 77 } 78 79 static void acpi_dev_memresource_flags(struct resource *res, u64 len, 80 u8 write_protect) 81 { 82 res->flags = IORESOURCE_MEM; 83 84 if (!acpi_dev_resource_len_valid(res->start, res->end, len, false)) 85 res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET; 86 87 if (write_protect == ACPI_READ_WRITE_MEMORY) 88 res->flags |= IORESOURCE_MEM_WRITEABLE; 89 } 90 91 static void acpi_dev_get_memresource(struct resource *res, u64 start, u64 len, 92 u8 write_protect) 93 { 94 res->start = start; 95 res->end = start + len - 1; 96 acpi_dev_memresource_flags(res, len, write_protect); 97 } 98 99 /** 100 * acpi_dev_resource_memory - Extract ACPI memory resource information. 101 * @ares: Input ACPI resource object. 102 * @res: Output generic resource object. 103 * 104 * Check if the given ACPI resource object represents a memory resource and 105 * if that's the case, use the information in it to populate the generic 106 * resource object pointed to by @res. 107 * 108 * Return: 109 * 1) false with res->flags setting to zero: not the expected resource type 110 * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource 111 * 3) true: valid assigned resource 112 */ 113 bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res) 114 { 115 struct acpi_resource_memory24 *memory24; 116 struct acpi_resource_memory32 *memory32; 117 struct acpi_resource_fixed_memory32 *fixed_memory32; 118 119 switch (ares->type) { 120 case ACPI_RESOURCE_TYPE_MEMORY24: 121 memory24 = &ares->data.memory24; 122 acpi_dev_get_memresource(res, memory24->minimum << 8, 123 memory24->address_length << 8, 124 memory24->write_protect); 125 break; 126 case ACPI_RESOURCE_TYPE_MEMORY32: 127 memory32 = &ares->data.memory32; 128 acpi_dev_get_memresource(res, memory32->minimum, 129 memory32->address_length, 130 memory32->write_protect); 131 break; 132 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: 133 fixed_memory32 = &ares->data.fixed_memory32; 134 acpi_dev_get_memresource(res, fixed_memory32->address, 135 fixed_memory32->address_length, 136 fixed_memory32->write_protect); 137 break; 138 default: 139 res->flags = 0; 140 return false; 141 } 142 143 return !(res->flags & IORESOURCE_DISABLED); 144 } 145 EXPORT_SYMBOL_GPL(acpi_dev_resource_memory); 146 147 static void acpi_dev_ioresource_flags(struct resource *res, u64 len, 148 u8 io_decode, u8 translation_type) 149 { 150 res->flags = IORESOURCE_IO; 151 152 if (!acpi_dev_resource_len_valid(res->start, res->end, len, true)) 153 res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET; 154 155 if (!acpi_iospace_resource_valid(res)) 156 res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET; 157 158 if (io_decode == ACPI_DECODE_16) 159 res->flags |= IORESOURCE_IO_16BIT_ADDR; 160 if (translation_type == ACPI_SPARSE_TRANSLATION) 161 res->flags |= IORESOURCE_IO_SPARSE; 162 } 163 164 static void acpi_dev_get_ioresource(struct resource *res, u64 start, u64 len, 165 u8 io_decode) 166 { 167 res->start = start; 168 res->end = start + len - 1; 169 acpi_dev_ioresource_flags(res, len, io_decode, 0); 170 } 171 172 /** 173 * acpi_dev_resource_io - Extract ACPI I/O resource information. 174 * @ares: Input ACPI resource object. 175 * @res: Output generic resource object. 176 * 177 * Check if the given ACPI resource object represents an I/O resource and 178 * if that's the case, use the information in it to populate the generic 179 * resource object pointed to by @res. 180 * 181 * Return: 182 * 1) false with res->flags setting to zero: not the expected resource type 183 * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource 184 * 3) true: valid assigned resource 185 */ 186 bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res) 187 { 188 struct acpi_resource_io *io; 189 struct acpi_resource_fixed_io *fixed_io; 190 191 switch (ares->type) { 192 case ACPI_RESOURCE_TYPE_IO: 193 io = &ares->data.io; 194 acpi_dev_get_ioresource(res, io->minimum, 195 io->address_length, 196 io->io_decode); 197 break; 198 case ACPI_RESOURCE_TYPE_FIXED_IO: 199 fixed_io = &ares->data.fixed_io; 200 acpi_dev_get_ioresource(res, fixed_io->address, 201 fixed_io->address_length, 202 ACPI_DECODE_10); 203 break; 204 default: 205 res->flags = 0; 206 return false; 207 } 208 209 return !(res->flags & IORESOURCE_DISABLED); 210 } 211 EXPORT_SYMBOL_GPL(acpi_dev_resource_io); 212 213 static bool acpi_decode_space(struct resource_win *win, 214 struct acpi_resource_address *addr, 215 struct acpi_address64_attribute *attr) 216 { 217 u8 iodec = attr->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16; 218 bool wp = addr->info.mem.write_protect; 219 u64 len = attr->address_length; 220 u64 start, end, offset = 0; 221 struct resource *res = &win->res; 222 223 /* 224 * Filter out invalid descriptor according to ACPI Spec 5.0, section 225 * 6.4.3.5 Address Space Resource Descriptors. 226 */ 227 if ((addr->min_address_fixed != addr->max_address_fixed && len) || 228 (addr->min_address_fixed && addr->max_address_fixed && !len)) 229 pr_debug("ACPI: Invalid address space min_addr_fix %d, max_addr_fix %d, len %llx\n", 230 addr->min_address_fixed, addr->max_address_fixed, len); 231 232 /* 233 * For bridges that translate addresses across the bridge, 234 * translation_offset is the offset that must be added to the 235 * address on the secondary side to obtain the address on the 236 * primary side. Non-bridge devices must list 0 for all Address 237 * Translation offset bits. 238 */ 239 if (addr->producer_consumer == ACPI_PRODUCER) 240 offset = attr->translation_offset; 241 else if (attr->translation_offset) 242 pr_debug("ACPI: translation_offset(%lld) is invalid for non-bridge device.\n", 243 attr->translation_offset); 244 start = attr->minimum + offset; 245 end = attr->maximum + offset; 246 247 win->offset = offset; 248 res->start = start; 249 res->end = end; 250 if (sizeof(resource_size_t) < sizeof(u64) && 251 (offset != win->offset || start != res->start || end != res->end)) { 252 pr_warn("acpi resource window ([%#llx-%#llx] ignored, not CPU addressable)\n", 253 attr->minimum, attr->maximum); 254 return false; 255 } 256 257 switch (addr->resource_type) { 258 case ACPI_MEMORY_RANGE: 259 acpi_dev_memresource_flags(res, len, wp); 260 break; 261 case ACPI_IO_RANGE: 262 acpi_dev_ioresource_flags(res, len, iodec, 263 addr->info.io.translation_type); 264 break; 265 case ACPI_BUS_NUMBER_RANGE: 266 res->flags = IORESOURCE_BUS; 267 break; 268 default: 269 return false; 270 } 271 272 if (addr->producer_consumer == ACPI_PRODUCER) 273 res->flags |= IORESOURCE_WINDOW; 274 275 if (addr->info.mem.caching == ACPI_PREFETCHABLE_MEMORY) 276 res->flags |= IORESOURCE_PREFETCH; 277 278 return !(res->flags & IORESOURCE_DISABLED); 279 } 280 281 /** 282 * acpi_dev_resource_address_space - Extract ACPI address space information. 283 * @ares: Input ACPI resource object. 284 * @win: Output generic resource object. 285 * 286 * Check if the given ACPI resource object represents an address space resource 287 * and if that's the case, use the information in it to populate the generic 288 * resource object pointed to by @win. 289 * 290 * Return: 291 * 1) false with win->res.flags setting to zero: not the expected resource type 292 * 2) false with IORESOURCE_DISABLED in win->res.flags: valid unassigned 293 * resource 294 * 3) true: valid assigned resource 295 */ 296 bool acpi_dev_resource_address_space(struct acpi_resource *ares, 297 struct resource_win *win) 298 { 299 struct acpi_resource_address64 addr; 300 301 win->res.flags = 0; 302 if (ACPI_FAILURE(acpi_resource_to_address64(ares, &addr))) 303 return false; 304 305 return acpi_decode_space(win, (struct acpi_resource_address *)&addr, 306 &addr.address); 307 } 308 EXPORT_SYMBOL_GPL(acpi_dev_resource_address_space); 309 310 /** 311 * acpi_dev_resource_ext_address_space - Extract ACPI address space information. 312 * @ares: Input ACPI resource object. 313 * @win: Output generic resource object. 314 * 315 * Check if the given ACPI resource object represents an extended address space 316 * resource and if that's the case, use the information in it to populate the 317 * generic resource object pointed to by @win. 318 * 319 * Return: 320 * 1) false with win->res.flags setting to zero: not the expected resource type 321 * 2) false with IORESOURCE_DISABLED in win->res.flags: valid unassigned 322 * resource 323 * 3) true: valid assigned resource 324 */ 325 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares, 326 struct resource_win *win) 327 { 328 struct acpi_resource_extended_address64 *ext_addr; 329 330 win->res.flags = 0; 331 if (ares->type != ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64) 332 return false; 333 334 ext_addr = &ares->data.ext_address64; 335 336 return acpi_decode_space(win, (struct acpi_resource_address *)ext_addr, 337 &ext_addr->address); 338 } 339 EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space); 340 341 /** 342 * acpi_dev_irq_flags - Determine IRQ resource flags. 343 * @triggering: Triggering type as provided by ACPI. 344 * @polarity: Interrupt polarity as provided by ACPI. 345 * @shareable: Whether or not the interrupt is shareable. 346 */ 347 unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable) 348 { 349 unsigned long flags; 350 351 if (triggering == ACPI_LEVEL_SENSITIVE) 352 flags = polarity == ACPI_ACTIVE_LOW ? 353 IORESOURCE_IRQ_LOWLEVEL : IORESOURCE_IRQ_HIGHLEVEL; 354 else 355 flags = polarity == ACPI_ACTIVE_LOW ? 356 IORESOURCE_IRQ_LOWEDGE : IORESOURCE_IRQ_HIGHEDGE; 357 358 if (shareable == ACPI_SHARED) 359 flags |= IORESOURCE_IRQ_SHAREABLE; 360 361 return flags | IORESOURCE_IRQ; 362 } 363 EXPORT_SYMBOL_GPL(acpi_dev_irq_flags); 364 365 /** 366 * acpi_dev_get_irq_type - Determine irq type. 367 * @triggering: Triggering type as provided by ACPI. 368 * @polarity: Interrupt polarity as provided by ACPI. 369 */ 370 unsigned int acpi_dev_get_irq_type(int triggering, int polarity) 371 { 372 switch (polarity) { 373 case ACPI_ACTIVE_LOW: 374 return triggering == ACPI_EDGE_SENSITIVE ? 375 IRQ_TYPE_EDGE_FALLING : 376 IRQ_TYPE_LEVEL_LOW; 377 case ACPI_ACTIVE_HIGH: 378 return triggering == ACPI_EDGE_SENSITIVE ? 379 IRQ_TYPE_EDGE_RISING : 380 IRQ_TYPE_LEVEL_HIGH; 381 case ACPI_ACTIVE_BOTH: 382 if (triggering == ACPI_EDGE_SENSITIVE) 383 return IRQ_TYPE_EDGE_BOTH; 384 /* fall through */ 385 default: 386 return IRQ_TYPE_NONE; 387 } 388 } 389 EXPORT_SYMBOL_GPL(acpi_dev_get_irq_type); 390 391 static void acpi_dev_irqresource_disabled(struct resource *res, u32 gsi) 392 { 393 res->start = gsi; 394 res->end = gsi; 395 res->flags = IORESOURCE_IRQ | IORESOURCE_DISABLED | IORESOURCE_UNSET; 396 } 397 398 static void acpi_dev_get_irqresource(struct resource *res, u32 gsi, 399 u8 triggering, u8 polarity, u8 shareable, 400 bool legacy) 401 { 402 int irq, p, t; 403 404 if (!valid_IRQ(gsi)) { 405 acpi_dev_irqresource_disabled(res, gsi); 406 return; 407 } 408 409 /* 410 * In IO-APIC mode, use overridden attribute. Two reasons: 411 * 1. BIOS bug in DSDT 412 * 2. BIOS uses IO-APIC mode Interrupt Source Override 413 * 414 * We do this only if we are dealing with IRQ() or IRQNoFlags() 415 * resource (the legacy ISA resources). With modern ACPI 5 devices 416 * using extended IRQ descriptors we take the IRQ configuration 417 * from _CRS directly. 418 */ 419 if (legacy && !acpi_get_override_irq(gsi, &t, &p)) { 420 u8 trig = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE; 421 u8 pol = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; 422 423 if (triggering != trig || polarity != pol) { 424 pr_warning("ACPI: IRQ %d override to %s, %s\n", gsi, 425 t ? "level" : "edge", p ? "low" : "high"); 426 triggering = trig; 427 polarity = pol; 428 } 429 } 430 431 res->flags = acpi_dev_irq_flags(triggering, polarity, shareable); 432 irq = acpi_register_gsi(NULL, gsi, triggering, polarity); 433 if (irq >= 0) { 434 res->start = irq; 435 res->end = irq; 436 } else { 437 acpi_dev_irqresource_disabled(res, gsi); 438 } 439 } 440 441 /** 442 * acpi_dev_resource_interrupt - Extract ACPI interrupt resource information. 443 * @ares: Input ACPI resource object. 444 * @index: Index into the array of GSIs represented by the resource. 445 * @res: Output generic resource object. 446 * 447 * Check if the given ACPI resource object represents an interrupt resource 448 * and @index does not exceed the resource's interrupt count (true is returned 449 * in that case regardless of the results of the other checks)). If that's the 450 * case, register the GSI corresponding to @index from the array of interrupts 451 * represented by the resource and populate the generic resource object pointed 452 * to by @res accordingly. If the registration of the GSI is not successful, 453 * IORESOURCE_DISABLED will be set it that object's flags. 454 * 455 * Return: 456 * 1) false with res->flags setting to zero: not the expected resource type 457 * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource 458 * 3) true: valid assigned resource 459 */ 460 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index, 461 struct resource *res) 462 { 463 struct acpi_resource_irq *irq; 464 struct acpi_resource_extended_irq *ext_irq; 465 466 switch (ares->type) { 467 case ACPI_RESOURCE_TYPE_IRQ: 468 /* 469 * Per spec, only one interrupt per descriptor is allowed in 470 * _CRS, but some firmware violates this, so parse them all. 471 */ 472 irq = &ares->data.irq; 473 if (index >= irq->interrupt_count) { 474 acpi_dev_irqresource_disabled(res, 0); 475 return false; 476 } 477 acpi_dev_get_irqresource(res, irq->interrupts[index], 478 irq->triggering, irq->polarity, 479 irq->sharable, true); 480 break; 481 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 482 ext_irq = &ares->data.extended_irq; 483 if (index >= ext_irq->interrupt_count) { 484 acpi_dev_irqresource_disabled(res, 0); 485 return false; 486 } 487 if (is_gsi(ext_irq)) 488 acpi_dev_get_irqresource(res, ext_irq->interrupts[index], 489 ext_irq->triggering, ext_irq->polarity, 490 ext_irq->sharable, false); 491 else 492 acpi_dev_irqresource_disabled(res, 0); 493 break; 494 default: 495 res->flags = 0; 496 return false; 497 } 498 499 return true; 500 } 501 EXPORT_SYMBOL_GPL(acpi_dev_resource_interrupt); 502 503 /** 504 * acpi_dev_free_resource_list - Free resource from %acpi_dev_get_resources(). 505 * @list: The head of the resource list to free. 506 */ 507 void acpi_dev_free_resource_list(struct list_head *list) 508 { 509 resource_list_free(list); 510 } 511 EXPORT_SYMBOL_GPL(acpi_dev_free_resource_list); 512 513 struct res_proc_context { 514 struct list_head *list; 515 int (*preproc)(struct acpi_resource *, void *); 516 void *preproc_data; 517 int count; 518 int error; 519 }; 520 521 static acpi_status acpi_dev_new_resource_entry(struct resource_win *win, 522 struct res_proc_context *c) 523 { 524 struct resource_entry *rentry; 525 526 rentry = resource_list_create_entry(NULL, 0); 527 if (!rentry) { 528 c->error = -ENOMEM; 529 return AE_NO_MEMORY; 530 } 531 *rentry->res = win->res; 532 rentry->offset = win->offset; 533 resource_list_add_tail(rentry, c->list); 534 c->count++; 535 return AE_OK; 536 } 537 538 static acpi_status acpi_dev_process_resource(struct acpi_resource *ares, 539 void *context) 540 { 541 struct res_proc_context *c = context; 542 struct resource_win win; 543 struct resource *res = &win.res; 544 int i; 545 546 if (c->preproc) { 547 int ret; 548 549 ret = c->preproc(ares, c->preproc_data); 550 if (ret < 0) { 551 c->error = ret; 552 return AE_CTRL_TERMINATE; 553 } else if (ret > 0) { 554 return AE_OK; 555 } 556 } 557 558 memset(&win, 0, sizeof(win)); 559 560 if (acpi_dev_resource_memory(ares, res) 561 || acpi_dev_resource_io(ares, res) 562 || acpi_dev_resource_address_space(ares, &win) 563 || acpi_dev_resource_ext_address_space(ares, &win)) 564 return acpi_dev_new_resource_entry(&win, c); 565 566 for (i = 0; acpi_dev_resource_interrupt(ares, i, res); i++) { 567 acpi_status status; 568 569 status = acpi_dev_new_resource_entry(&win, c); 570 if (ACPI_FAILURE(status)) 571 return status; 572 } 573 574 return AE_OK; 575 } 576 577 static int __acpi_dev_get_resources(struct acpi_device *adev, 578 struct list_head *list, 579 int (*preproc)(struct acpi_resource *, void *), 580 void *preproc_data, char *method) 581 { 582 struct res_proc_context c; 583 acpi_status status; 584 585 if (!adev || !adev->handle || !list_empty(list)) 586 return -EINVAL; 587 588 if (!acpi_has_method(adev->handle, method)) 589 return 0; 590 591 c.list = list; 592 c.preproc = preproc; 593 c.preproc_data = preproc_data; 594 c.count = 0; 595 c.error = 0; 596 status = acpi_walk_resources(adev->handle, method, 597 acpi_dev_process_resource, &c); 598 if (ACPI_FAILURE(status)) { 599 acpi_dev_free_resource_list(list); 600 return c.error ? c.error : -EIO; 601 } 602 603 return c.count; 604 } 605 606 /** 607 * acpi_dev_get_resources - Get current resources of a device. 608 * @adev: ACPI device node to get the resources for. 609 * @list: Head of the resultant list of resources (must be empty). 610 * @preproc: The caller's preprocessing routine. 611 * @preproc_data: Pointer passed to the caller's preprocessing routine. 612 * 613 * Evaluate the _CRS method for the given device node and process its output by 614 * (1) executing the @preproc() rountine provided by the caller, passing the 615 * resource pointer and @preproc_data to it as arguments, for each ACPI resource 616 * returned and (2) converting all of the returned ACPI resources into struct 617 * resource objects if possible. If the return value of @preproc() in step (1) 618 * is different from 0, step (2) is not applied to the given ACPI resource and 619 * if that value is negative, the whole processing is aborted and that value is 620 * returned as the final error code. 621 * 622 * The resultant struct resource objects are put on the list pointed to by 623 * @list, that must be empty initially, as members of struct resource_entry 624 * objects. Callers of this routine should use %acpi_dev_free_resource_list() to 625 * free that list. 626 * 627 * The number of resources in the output list is returned on success, an error 628 * code reflecting the error condition is returned otherwise. 629 */ 630 int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list, 631 int (*preproc)(struct acpi_resource *, void *), 632 void *preproc_data) 633 { 634 return __acpi_dev_get_resources(adev, list, preproc, preproc_data, 635 METHOD_NAME__CRS); 636 } 637 EXPORT_SYMBOL_GPL(acpi_dev_get_resources); 638 639 static int is_memory(struct acpi_resource *ares, void *not_used) 640 { 641 struct resource_win win; 642 struct resource *res = &win.res; 643 644 memset(&win, 0, sizeof(win)); 645 646 return !(acpi_dev_resource_memory(ares, res) 647 || acpi_dev_resource_address_space(ares, &win) 648 || acpi_dev_resource_ext_address_space(ares, &win)); 649 } 650 651 /** 652 * acpi_dev_get_dma_resources - Get current DMA resources of a device. 653 * @adev: ACPI device node to get the resources for. 654 * @list: Head of the resultant list of resources (must be empty). 655 * 656 * Evaluate the _DMA method for the given device node and process its 657 * output. 658 * 659 * The resultant struct resource objects are put on the list pointed to 660 * by @list, that must be empty initially, as members of struct 661 * resource_entry objects. Callers of this routine should use 662 * %acpi_dev_free_resource_list() to free that list. 663 * 664 * The number of resources in the output list is returned on success, 665 * an error code reflecting the error condition is returned otherwise. 666 */ 667 int acpi_dev_get_dma_resources(struct acpi_device *adev, struct list_head *list) 668 { 669 return __acpi_dev_get_resources(adev, list, is_memory, NULL, 670 METHOD_NAME__DMA); 671 } 672 EXPORT_SYMBOL_GPL(acpi_dev_get_dma_resources); 673 674 /** 675 * acpi_dev_filter_resource_type - Filter ACPI resource according to resource 676 * types 677 * @ares: Input ACPI resource object. 678 * @types: Valid resource types of IORESOURCE_XXX 679 * 680 * This is a helper function to support acpi_dev_get_resources(), which filters 681 * ACPI resource objects according to resource types. 682 */ 683 int acpi_dev_filter_resource_type(struct acpi_resource *ares, 684 unsigned long types) 685 { 686 unsigned long type = 0; 687 688 switch (ares->type) { 689 case ACPI_RESOURCE_TYPE_MEMORY24: 690 case ACPI_RESOURCE_TYPE_MEMORY32: 691 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: 692 type = IORESOURCE_MEM; 693 break; 694 case ACPI_RESOURCE_TYPE_IO: 695 case ACPI_RESOURCE_TYPE_FIXED_IO: 696 type = IORESOURCE_IO; 697 break; 698 case ACPI_RESOURCE_TYPE_IRQ: 699 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 700 type = IORESOURCE_IRQ; 701 break; 702 case ACPI_RESOURCE_TYPE_DMA: 703 case ACPI_RESOURCE_TYPE_FIXED_DMA: 704 type = IORESOURCE_DMA; 705 break; 706 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: 707 type = IORESOURCE_REG; 708 break; 709 case ACPI_RESOURCE_TYPE_ADDRESS16: 710 case ACPI_RESOURCE_TYPE_ADDRESS32: 711 case ACPI_RESOURCE_TYPE_ADDRESS64: 712 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: 713 if (ares->data.address.resource_type == ACPI_MEMORY_RANGE) 714 type = IORESOURCE_MEM; 715 else if (ares->data.address.resource_type == ACPI_IO_RANGE) 716 type = IORESOURCE_IO; 717 else if (ares->data.address.resource_type == 718 ACPI_BUS_NUMBER_RANGE) 719 type = IORESOURCE_BUS; 720 break; 721 default: 722 break; 723 } 724 725 return (type & types) ? 0 : 1; 726 } 727 EXPORT_SYMBOL_GPL(acpi_dev_filter_resource_type); 728 729 static int acpi_dev_consumes_res(struct acpi_device *adev, struct resource *res) 730 { 731 struct list_head resource_list; 732 struct resource_entry *rentry; 733 int ret, found = 0; 734 735 INIT_LIST_HEAD(&resource_list); 736 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL); 737 if (ret < 0) 738 return 0; 739 740 list_for_each_entry(rentry, &resource_list, node) { 741 if (resource_contains(rentry->res, res)) { 742 found = 1; 743 break; 744 } 745 746 } 747 748 acpi_dev_free_resource_list(&resource_list); 749 return found; 750 } 751 752 static acpi_status acpi_res_consumer_cb(acpi_handle handle, u32 depth, 753 void *context, void **ret) 754 { 755 struct resource *res = context; 756 struct acpi_device **consumer = (struct acpi_device **) ret; 757 struct acpi_device *adev; 758 759 if (acpi_bus_get_device(handle, &adev)) 760 return AE_OK; 761 762 if (acpi_dev_consumes_res(adev, res)) { 763 *consumer = adev; 764 return AE_CTRL_TERMINATE; 765 } 766 767 return AE_OK; 768 } 769 770 /** 771 * acpi_resource_consumer - Find the ACPI device that consumes @res. 772 * @res: Resource to search for. 773 * 774 * Search the current resource settings (_CRS) of every ACPI device node 775 * for @res. If we find an ACPI device whose _CRS includes @res, return 776 * it. Otherwise, return NULL. 777 */ 778 struct acpi_device *acpi_resource_consumer(struct resource *res) 779 { 780 struct acpi_device *consumer = NULL; 781 782 acpi_get_devices(NULL, acpi_res_consumer_cb, res, (void **) &consumer); 783 return consumer; 784 } 785