1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * pci_link.c - ACPI PCI Interrupt Link Device Driver ($Revision: 34 $) 4 * 5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * Copyright (C) 2002 Dominik Brodowski <devel@brodo.de> 8 * 9 * TBD: 10 * 1. Support more than one IRQ resource entry per link device (index). 11 * 2. Implement start/stop mechanism and use ACPI Bus Driver facilities 12 * for IRQ management (e.g. start()->_SRS). 13 */ 14 15 #define pr_fmt(fmt) "ACPI: PCI: " fmt 16 17 #include <linux/syscore_ops.h> 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/init.h> 21 #include <linux/types.h> 22 #include <linux/spinlock.h> 23 #include <linux/pm.h> 24 #include <linux/pci.h> 25 #include <linux/mutex.h> 26 #include <linux/slab.h> 27 #include <linux/acpi.h> 28 #include <linux/irq.h> 29 30 #include "internal.h" 31 32 #define ACPI_PCI_LINK_CLASS "pci_irq_routing" 33 #define ACPI_PCI_LINK_DEVICE_NAME "PCI Interrupt Link" 34 #define ACPI_PCI_LINK_MAX_POSSIBLE 16 35 36 static int acpi_pci_link_add(struct acpi_device *device, 37 const struct acpi_device_id *not_used); 38 static void acpi_pci_link_remove(struct acpi_device *device); 39 40 static const struct acpi_device_id link_device_ids[] = { 41 {"PNP0C0F", 0}, 42 {"", 0}, 43 }; 44 45 static struct acpi_scan_handler pci_link_handler = { 46 .ids = link_device_ids, 47 .attach = acpi_pci_link_add, 48 .detach = acpi_pci_link_remove, 49 }; 50 51 /* 52 * If a link is initialized, we never change its active and initialized 53 * later even the link is disable. Instead, we just repick the active irq 54 */ 55 struct acpi_pci_link_irq { 56 u32 active; /* Current IRQ */ 57 u8 triggering; /* All IRQs */ 58 u8 polarity; /* All IRQs */ 59 u8 resource_type; 60 u8 possible_count; 61 u32 possible[ACPI_PCI_LINK_MAX_POSSIBLE]; 62 u8 initialized:1; 63 u8 reserved:7; 64 }; 65 66 struct acpi_pci_link { 67 struct list_head list; 68 struct acpi_device *device; 69 struct acpi_pci_link_irq irq; 70 int refcnt; 71 }; 72 73 static LIST_HEAD(acpi_link_list); 74 static DEFINE_MUTEX(acpi_link_lock); 75 static int sci_irq = -1, sci_penalty; 76 77 /* -------------------------------------------------------------------------- 78 PCI Link Device Management 79 -------------------------------------------------------------------------- */ 80 81 /* 82 * set context (link) possible list from resource list 83 */ 84 static acpi_status acpi_pci_link_check_possible(struct acpi_resource *resource, 85 void *context) 86 { 87 struct acpi_pci_link *link = context; 88 acpi_handle handle = link->device->handle; 89 u32 i; 90 91 switch (resource->type) { 92 case ACPI_RESOURCE_TYPE_START_DEPENDENT: 93 case ACPI_RESOURCE_TYPE_END_TAG: 94 return AE_OK; 95 case ACPI_RESOURCE_TYPE_IRQ: 96 { 97 struct acpi_resource_irq *p = &resource->data.irq; 98 if (!p || !p->interrupt_count) { 99 acpi_handle_debug(handle, 100 "Blank _PRS IRQ resource\n"); 101 return AE_OK; 102 } 103 for (i = 0; 104 (i < p->interrupt_count 105 && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) { 106 if (!p->interrupts[i]) { 107 acpi_handle_debug(handle, 108 "Invalid _PRS IRQ %d\n", 109 p->interrupts[i]); 110 continue; 111 } 112 link->irq.possible[i] = p->interrupts[i]; 113 link->irq.possible_count++; 114 } 115 link->irq.triggering = p->triggering; 116 link->irq.polarity = p->polarity; 117 link->irq.resource_type = ACPI_RESOURCE_TYPE_IRQ; 118 break; 119 } 120 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 121 { 122 struct acpi_resource_extended_irq *p = 123 &resource->data.extended_irq; 124 if (!p || !p->interrupt_count) { 125 acpi_handle_debug(handle, 126 "Blank _PRS EXT IRQ resource\n"); 127 return AE_OK; 128 } 129 for (i = 0; 130 (i < p->interrupt_count 131 && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) { 132 if (!p->interrupts[i]) { 133 acpi_handle_debug(handle, 134 "Invalid _PRS IRQ %d\n", 135 p->interrupts[i]); 136 continue; 137 } 138 link->irq.possible[i] = p->interrupts[i]; 139 link->irq.possible_count++; 140 } 141 link->irq.triggering = p->triggering; 142 link->irq.polarity = p->polarity; 143 link->irq.resource_type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ; 144 break; 145 } 146 default: 147 acpi_handle_debug(handle, "_PRS resource type 0x%x is not IRQ\n", 148 resource->type); 149 return AE_OK; 150 } 151 152 return AE_CTRL_TERMINATE; 153 } 154 155 static int acpi_pci_link_get_possible(struct acpi_pci_link *link) 156 { 157 acpi_handle handle = link->device->handle; 158 acpi_status status; 159 160 status = acpi_walk_resources(handle, METHOD_NAME__PRS, 161 acpi_pci_link_check_possible, link); 162 if (ACPI_FAILURE(status)) { 163 acpi_handle_debug(handle, "_PRS not present or invalid"); 164 return 0; 165 } 166 167 acpi_handle_debug(handle, "Found %d possible IRQs\n", 168 link->irq.possible_count); 169 170 return 0; 171 } 172 173 static acpi_status acpi_pci_link_check_current(struct acpi_resource *resource, 174 void *context) 175 { 176 int *irq = context; 177 178 switch (resource->type) { 179 case ACPI_RESOURCE_TYPE_START_DEPENDENT: 180 case ACPI_RESOURCE_TYPE_END_TAG: 181 return AE_OK; 182 case ACPI_RESOURCE_TYPE_IRQ: 183 { 184 struct acpi_resource_irq *p = &resource->data.irq; 185 if (!p || !p->interrupt_count) { 186 /* 187 * IRQ descriptors may have no IRQ# bits set, 188 * particularly those those w/ _STA disabled 189 */ 190 pr_debug("Blank _CRS IRQ resource\n"); 191 return AE_OK; 192 } 193 *irq = p->interrupts[0]; 194 break; 195 } 196 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 197 { 198 struct acpi_resource_extended_irq *p = 199 &resource->data.extended_irq; 200 if (!p || !p->interrupt_count) { 201 /* 202 * extended IRQ descriptors must 203 * return at least 1 IRQ 204 */ 205 pr_debug("Blank _CRS EXT IRQ resource\n"); 206 return AE_OK; 207 } 208 *irq = p->interrupts[0]; 209 break; 210 } 211 break; 212 default: 213 pr_debug("_CRS resource type 0x%x is not IRQ\n", 214 resource->type); 215 return AE_OK; 216 } 217 218 return AE_CTRL_TERMINATE; 219 } 220 221 /* 222 * Run _CRS and set link->irq.active 223 * 224 * return value: 225 * 0 - success 226 * !0 - failure 227 */ 228 static int acpi_pci_link_get_current(struct acpi_pci_link *link) 229 { 230 acpi_handle handle = link->device->handle; 231 acpi_status status; 232 int result = 0; 233 int irq = 0; 234 235 link->irq.active = 0; 236 237 /* in practice, status disabled is meaningless, ignore it */ 238 if (acpi_strict) { 239 /* Query _STA, set link->device->status */ 240 result = acpi_bus_get_status(link->device); 241 if (result) { 242 acpi_handle_err(handle, "Unable to read status\n"); 243 goto end; 244 } 245 246 if (!link->device->status.enabled) { 247 acpi_handle_debug(handle, "Link disabled\n"); 248 return 0; 249 } 250 } 251 252 /* 253 * Query and parse _CRS to get the current IRQ assignment. 254 */ 255 256 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 257 acpi_pci_link_check_current, &irq); 258 if (ACPI_FAILURE(status)) { 259 acpi_handle_warn(handle, "_CRS evaluation failed: %s\n", 260 acpi_format_exception(status)); 261 result = -ENODEV; 262 goto end; 263 } 264 265 if (acpi_strict && !irq) { 266 acpi_handle_err(handle, "_CRS returned 0\n"); 267 result = -ENODEV; 268 } 269 270 link->irq.active = irq; 271 272 acpi_handle_debug(handle, "Link at IRQ %d \n", link->irq.active); 273 274 end: 275 return result; 276 } 277 278 static int acpi_pci_link_set(struct acpi_pci_link *link, int irq) 279 { 280 struct { 281 struct acpi_resource res; 282 struct acpi_resource end; 283 } *resource; 284 struct acpi_buffer buffer = { 0, NULL }; 285 acpi_handle handle = link->device->handle; 286 acpi_status status; 287 int result; 288 289 if (!irq) 290 return -EINVAL; 291 292 resource = kzalloc(sizeof(*resource) + 1, irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL); 293 if (!resource) 294 return -ENOMEM; 295 296 buffer.length = sizeof(*resource) + 1; 297 buffer.pointer = resource; 298 299 switch (link->irq.resource_type) { 300 case ACPI_RESOURCE_TYPE_IRQ: 301 resource->res.type = ACPI_RESOURCE_TYPE_IRQ; 302 resource->res.length = sizeof(struct acpi_resource); 303 resource->res.data.irq.triggering = link->irq.triggering; 304 resource->res.data.irq.polarity = 305 link->irq.polarity; 306 if (link->irq.triggering == ACPI_EDGE_SENSITIVE) 307 resource->res.data.irq.shareable = 308 ACPI_EXCLUSIVE; 309 else 310 resource->res.data.irq.shareable = ACPI_SHARED; 311 resource->res.data.irq.interrupt_count = 1; 312 resource->res.data.irq.interrupts[0] = irq; 313 break; 314 315 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 316 resource->res.type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ; 317 resource->res.length = sizeof(struct acpi_resource); 318 resource->res.data.extended_irq.producer_consumer = 319 ACPI_CONSUMER; 320 resource->res.data.extended_irq.triggering = 321 link->irq.triggering; 322 resource->res.data.extended_irq.polarity = 323 link->irq.polarity; 324 if (link->irq.triggering == ACPI_EDGE_SENSITIVE) 325 resource->res.data.extended_irq.shareable = 326 ACPI_EXCLUSIVE; 327 else 328 resource->res.data.extended_irq.shareable = ACPI_SHARED; 329 resource->res.data.extended_irq.interrupt_count = 1; 330 resource->res.data.extended_irq.interrupts[0] = irq; 331 /* ignore resource_source, it's optional */ 332 break; 333 default: 334 acpi_handle_err(handle, "Invalid resource type %d\n", 335 link->irq.resource_type); 336 result = -EINVAL; 337 goto end; 338 339 } 340 resource->end.type = ACPI_RESOURCE_TYPE_END_TAG; 341 resource->end.length = sizeof(struct acpi_resource); 342 343 /* Attempt to set the resource */ 344 status = acpi_set_current_resources(link->device->handle, &buffer); 345 346 /* check for total failure */ 347 if (ACPI_FAILURE(status)) { 348 acpi_handle_warn(handle, "_SRS evaluation failed: %s", 349 acpi_format_exception(status)); 350 result = -ENODEV; 351 goto end; 352 } 353 354 /* Query _STA, set device->status */ 355 result = acpi_bus_get_status(link->device); 356 if (result) { 357 acpi_handle_err(handle, "Unable to read status\n"); 358 goto end; 359 } 360 if (!link->device->status.enabled) 361 acpi_handle_warn(handle, "Disabled and referenced, BIOS bug\n"); 362 363 /* Query _CRS, set link->irq.active */ 364 result = acpi_pci_link_get_current(link); 365 if (result) { 366 goto end; 367 } 368 369 /* 370 * Is current setting not what we set? 371 * set link->irq.active 372 */ 373 if (link->irq.active != irq) { 374 /* 375 * policy: when _CRS doesn't return what we just _SRS 376 * assume _SRS worked and override _CRS value. 377 */ 378 acpi_handle_warn(handle, "BIOS reported IRQ %d, using IRQ %d\n", 379 link->irq.active, irq); 380 link->irq.active = irq; 381 } 382 383 acpi_handle_debug(handle, "Set IRQ %d\n", link->irq.active); 384 385 end: 386 kfree(resource); 387 return result; 388 } 389 390 /* -------------------------------------------------------------------------- 391 PCI Link IRQ Management 392 -------------------------------------------------------------------------- */ 393 394 /* 395 * "acpi_irq_balance" (default in APIC mode) enables ACPI to use PIC Interrupt 396 * Link Devices to move the PIRQs around to minimize sharing. 397 * 398 * "acpi_irq_nobalance" (default in PIC mode) tells ACPI not to move any PIC IRQs 399 * that the BIOS has already set to active. This is necessary because 400 * ACPI has no automatic means of knowing what ISA IRQs are used. Note that 401 * if the BIOS doesn't set a Link Device active, ACPI needs to program it 402 * even if acpi_irq_nobalance is set. 403 * 404 * A tables of penalties avoids directing PCI interrupts to well known 405 * ISA IRQs. Boot params are available to over-ride the default table: 406 * 407 * List interrupts that are free for PCI use. 408 * acpi_irq_pci=n[,m] 409 * 410 * List interrupts that should not be used for PCI: 411 * acpi_irq_isa=n[,m] 412 * 413 * Note that PCI IRQ routers have a list of possible IRQs, 414 * which may not include the IRQs this table says are available. 415 * 416 * Since this heuristic can't tell the difference between a link 417 * that no device will attach to, vs. a link which may be shared 418 * by multiple active devices -- it is not optimal. 419 * 420 * If interrupt performance is that important, get an IO-APIC system 421 * with a pin dedicated to each device. Or for that matter, an MSI 422 * enabled system. 423 */ 424 425 #define ACPI_MAX_ISA_IRQS 16 426 427 #define PIRQ_PENALTY_PCI_POSSIBLE (16*16) 428 #define PIRQ_PENALTY_PCI_USING (16*16*16) 429 #define PIRQ_PENALTY_ISA_TYPICAL (16*16*16*16) 430 #define PIRQ_PENALTY_ISA_USED (16*16*16*16*16) 431 #define PIRQ_PENALTY_ISA_ALWAYS (16*16*16*16*16*16) 432 433 static int acpi_isa_irq_penalty[ACPI_MAX_ISA_IRQS] = { 434 PIRQ_PENALTY_ISA_ALWAYS, /* IRQ0 timer */ 435 PIRQ_PENALTY_ISA_ALWAYS, /* IRQ1 keyboard */ 436 PIRQ_PENALTY_ISA_ALWAYS, /* IRQ2 cascade */ 437 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ3 serial */ 438 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ4 serial */ 439 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ5 sometimes SoundBlaster */ 440 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ6 */ 441 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ7 parallel, spurious */ 442 PIRQ_PENALTY_ISA_TYPICAL, /* IRQ8 rtc, sometimes */ 443 0, /* IRQ9 PCI, often acpi */ 444 0, /* IRQ10 PCI */ 445 0, /* IRQ11 PCI */ 446 PIRQ_PENALTY_ISA_USED, /* IRQ12 mouse */ 447 PIRQ_PENALTY_ISA_USED, /* IRQ13 fpe, sometimes */ 448 PIRQ_PENALTY_ISA_USED, /* IRQ14 ide0 */ 449 PIRQ_PENALTY_ISA_USED, /* IRQ15 ide1 */ 450 /* >IRQ15 */ 451 }; 452 453 static int acpi_irq_pci_sharing_penalty(int irq) 454 { 455 struct acpi_pci_link *link; 456 int penalty = 0; 457 int i; 458 459 list_for_each_entry(link, &acpi_link_list, list) { 460 /* 461 * If a link is active, penalize its IRQ heavily 462 * so we try to choose a different IRQ. 463 */ 464 if (link->irq.active && link->irq.active == irq) 465 penalty += PIRQ_PENALTY_PCI_USING; 466 467 /* 468 * penalize the IRQs PCI might use, but not as severely. 469 */ 470 for (i = 0; i < link->irq.possible_count; i++) 471 if (link->irq.possible[i] == irq) 472 penalty += PIRQ_PENALTY_PCI_POSSIBLE / 473 link->irq.possible_count; 474 } 475 476 return penalty; 477 } 478 479 static int acpi_irq_get_penalty(int irq) 480 { 481 int penalty = 0; 482 483 if (irq == sci_irq) 484 penalty += sci_penalty; 485 486 if (irq < ACPI_MAX_ISA_IRQS) 487 return penalty + acpi_isa_irq_penalty[irq]; 488 489 return penalty + acpi_irq_pci_sharing_penalty(irq); 490 } 491 492 int __init acpi_irq_penalty_init(void) 493 { 494 struct acpi_pci_link *link; 495 int i; 496 497 /* 498 * Update penalties to facilitate IRQ balancing. 499 */ 500 list_for_each_entry(link, &acpi_link_list, list) { 501 502 /* 503 * reflect the possible and active irqs in the penalty table -- 504 * useful for breaking ties. 505 */ 506 if (link->irq.possible_count) { 507 int penalty = 508 PIRQ_PENALTY_PCI_POSSIBLE / 509 link->irq.possible_count; 510 511 for (i = 0; i < link->irq.possible_count; i++) { 512 if (link->irq.possible[i] < ACPI_MAX_ISA_IRQS) 513 acpi_isa_irq_penalty[link->irq. 514 possible[i]] += 515 penalty; 516 } 517 518 } else if (link->irq.active && 519 (link->irq.active < ACPI_MAX_ISA_IRQS)) { 520 acpi_isa_irq_penalty[link->irq.active] += 521 PIRQ_PENALTY_PCI_POSSIBLE; 522 } 523 } 524 525 return 0; 526 } 527 528 static int acpi_irq_balance = -1; /* 0: static, 1: balance */ 529 530 static int acpi_pci_link_allocate(struct acpi_pci_link *link) 531 { 532 acpi_handle handle = link->device->handle; 533 int irq; 534 int i; 535 536 if (link->irq.initialized) { 537 if (link->refcnt == 0) 538 /* This means the link is disabled but initialized */ 539 acpi_pci_link_set(link, link->irq.active); 540 return 0; 541 } 542 543 /* 544 * search for active IRQ in list of possible IRQs. 545 */ 546 for (i = 0; i < link->irq.possible_count; ++i) { 547 if (link->irq.active == link->irq.possible[i]) 548 break; 549 } 550 /* 551 * forget active IRQ that is not in possible list 552 */ 553 if (i == link->irq.possible_count) { 554 if (acpi_strict) 555 acpi_handle_warn(handle, "_CRS %d not found in _PRS\n", 556 link->irq.active); 557 link->irq.active = 0; 558 } 559 560 /* 561 * if active found, use it; else pick entry from end of possible list. 562 */ 563 if (link->irq.active) 564 irq = link->irq.active; 565 else 566 irq = link->irq.possible[link->irq.possible_count - 1]; 567 568 if (acpi_irq_balance || !link->irq.active) { 569 /* 570 * Select the best IRQ. This is done in reverse to promote 571 * the use of IRQs 9, 10, 11, and >15. 572 */ 573 for (i = (link->irq.possible_count - 1); i >= 0; i--) { 574 if (acpi_irq_get_penalty(irq) > 575 acpi_irq_get_penalty(link->irq.possible[i])) 576 irq = link->irq.possible[i]; 577 } 578 } 579 if (acpi_irq_get_penalty(irq) >= PIRQ_PENALTY_ISA_ALWAYS) { 580 acpi_handle_err(handle, 581 "No IRQ available. Try pci=noacpi or acpi=off\n"); 582 return -ENODEV; 583 } 584 585 /* Attempt to enable the link device at this IRQ. */ 586 if (acpi_pci_link_set(link, irq)) { 587 acpi_handle_err(handle, 588 "Unable to set IRQ. Try pci=noacpi or acpi=off\n"); 589 return -ENODEV; 590 } else { 591 if (link->irq.active < ACPI_MAX_ISA_IRQS) 592 acpi_isa_irq_penalty[link->irq.active] += 593 PIRQ_PENALTY_PCI_USING; 594 595 acpi_handle_info(handle, "Enabled at IRQ %d\n", 596 link->irq.active); 597 } 598 599 link->irq.initialized = 1; 600 return 0; 601 } 602 603 /* 604 * acpi_pci_link_allocate_irq 605 * success: return IRQ >= 0 606 * failure: return -1 607 */ 608 int acpi_pci_link_allocate_irq(acpi_handle handle, int index, int *triggering, 609 int *polarity, char **name) 610 { 611 int result; 612 struct acpi_device *device; 613 struct acpi_pci_link *link; 614 615 result = acpi_bus_get_device(handle, &device); 616 if (result) { 617 acpi_handle_err(handle, "Invalid link device\n"); 618 return -1; 619 } 620 621 link = acpi_driver_data(device); 622 if (!link) { 623 acpi_handle_err(handle, "Invalid link context\n"); 624 return -1; 625 } 626 627 /* TBD: Support multiple index (IRQ) entries per Link Device */ 628 if (index) { 629 acpi_handle_err(handle, "Invalid index %d\n", index); 630 return -1; 631 } 632 633 mutex_lock(&acpi_link_lock); 634 if (acpi_pci_link_allocate(link)) { 635 mutex_unlock(&acpi_link_lock); 636 return -1; 637 } 638 639 if (!link->irq.active) { 640 mutex_unlock(&acpi_link_lock); 641 acpi_handle_err(handle, "Link active IRQ is 0!\n"); 642 return -1; 643 } 644 link->refcnt++; 645 mutex_unlock(&acpi_link_lock); 646 647 if (triggering) 648 *triggering = link->irq.triggering; 649 if (polarity) 650 *polarity = link->irq.polarity; 651 if (name) 652 *name = acpi_device_bid(link->device); 653 acpi_handle_debug(handle, "Link is referenced\n"); 654 return link->irq.active; 655 } 656 657 /* 658 * We don't change link's irq information here. After it is reenabled, we 659 * continue use the info 660 */ 661 int acpi_pci_link_free_irq(acpi_handle handle) 662 { 663 struct acpi_device *device; 664 struct acpi_pci_link *link; 665 acpi_status result; 666 667 result = acpi_bus_get_device(handle, &device); 668 if (result) { 669 acpi_handle_err(handle, "Invalid link device\n"); 670 return -1; 671 } 672 673 link = acpi_driver_data(device); 674 if (!link) { 675 acpi_handle_err(handle, "Invalid link context\n"); 676 return -1; 677 } 678 679 mutex_lock(&acpi_link_lock); 680 if (!link->irq.initialized) { 681 mutex_unlock(&acpi_link_lock); 682 acpi_handle_err(handle, "Link isn't initialized\n"); 683 return -1; 684 } 685 #ifdef FUTURE_USE 686 /* 687 * The Link reference count allows us to _DISable an unused link 688 * and suspend time, and set it again on resume. 689 * However, 2.6.12 still has irq_router.resume 690 * which blindly restores the link state. 691 * So we disable the reference count method 692 * to prevent duplicate acpi_pci_link_set() 693 * which would harm some systems 694 */ 695 link->refcnt--; 696 #endif 697 acpi_handle_debug(handle, "Link is dereferenced\n"); 698 699 if (link->refcnt == 0) 700 acpi_evaluate_object(link->device->handle, "_DIS", NULL, NULL); 701 702 mutex_unlock(&acpi_link_lock); 703 return link->irq.active; 704 } 705 706 /* -------------------------------------------------------------------------- 707 Driver Interface 708 -------------------------------------------------------------------------- */ 709 710 static int acpi_pci_link_add(struct acpi_device *device, 711 const struct acpi_device_id *not_used) 712 { 713 acpi_handle handle = device->handle; 714 struct acpi_pci_link *link; 715 int result; 716 int i; 717 718 link = kzalloc(sizeof(struct acpi_pci_link), GFP_KERNEL); 719 if (!link) 720 return -ENOMEM; 721 722 link->device = device; 723 strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME); 724 strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS); 725 device->driver_data = link; 726 727 mutex_lock(&acpi_link_lock); 728 result = acpi_pci_link_get_possible(link); 729 if (result) 730 goto end; 731 732 /* query and set link->irq.active */ 733 acpi_pci_link_get_current(link); 734 735 pr_info("Interrupt link %s configured for IRQ %d\n", 736 acpi_device_bid(device), link->irq.active); 737 738 for (i = 0; i < link->irq.possible_count; i++) { 739 if (link->irq.active != link->irq.possible[i]) 740 acpi_handle_debug(handle, "Possible IRQ %d\n", 741 link->irq.possible[i]); 742 } 743 744 if (!link->device->status.enabled) 745 pr_info("Interrupt link %s disabled\n", acpi_device_bid(device)); 746 747 list_add_tail(&link->list, &acpi_link_list); 748 749 end: 750 /* disable all links -- to be activated on use */ 751 acpi_evaluate_object(handle, "_DIS", NULL, NULL); 752 mutex_unlock(&acpi_link_lock); 753 754 if (result) 755 kfree(link); 756 757 return result < 0 ? result : 1; 758 } 759 760 static int acpi_pci_link_resume(struct acpi_pci_link *link) 761 { 762 if (link->refcnt && link->irq.active && link->irq.initialized) 763 return (acpi_pci_link_set(link, link->irq.active)); 764 765 return 0; 766 } 767 768 static void irqrouter_resume(void) 769 { 770 struct acpi_pci_link *link; 771 772 list_for_each_entry(link, &acpi_link_list, list) { 773 acpi_pci_link_resume(link); 774 } 775 } 776 777 static void acpi_pci_link_remove(struct acpi_device *device) 778 { 779 struct acpi_pci_link *link; 780 781 link = acpi_driver_data(device); 782 783 mutex_lock(&acpi_link_lock); 784 list_del(&link->list); 785 mutex_unlock(&acpi_link_lock); 786 787 kfree(link); 788 } 789 790 /* 791 * modify acpi_isa_irq_penalty[] from cmdline 792 */ 793 static int __init acpi_irq_penalty_update(char *str, int used) 794 { 795 int i; 796 797 for (i = 0; i < 16; i++) { 798 int retval; 799 int irq; 800 int new_penalty; 801 802 retval = get_option(&str, &irq); 803 804 if (!retval) 805 break; /* no number found */ 806 807 /* see if this is a ISA IRQ */ 808 if ((irq < 0) || (irq >= ACPI_MAX_ISA_IRQS)) 809 continue; 810 811 if (used) 812 new_penalty = acpi_isa_irq_penalty[irq] + 813 PIRQ_PENALTY_ISA_USED; 814 else 815 new_penalty = 0; 816 817 acpi_isa_irq_penalty[irq] = new_penalty; 818 if (retval != 2) /* no next number */ 819 break; 820 } 821 return 1; 822 } 823 824 /* 825 * We'd like PNP to call this routine for the 826 * single ISA_USED value for each legacy device. 827 * But instead it calls us with each POSSIBLE setting. 828 * There is no ISA_POSSIBLE weight, so we simply use 829 * the (small) PCI_USING penalty. 830 */ 831 void acpi_penalize_isa_irq(int irq, int active) 832 { 833 if ((irq >= 0) && (irq < ARRAY_SIZE(acpi_isa_irq_penalty))) 834 acpi_isa_irq_penalty[irq] += 835 (active ? PIRQ_PENALTY_ISA_USED : PIRQ_PENALTY_PCI_USING); 836 } 837 838 bool acpi_isa_irq_available(int irq) 839 { 840 return irq >= 0 && (irq >= ARRAY_SIZE(acpi_isa_irq_penalty) || 841 acpi_irq_get_penalty(irq) < PIRQ_PENALTY_ISA_ALWAYS); 842 } 843 844 void acpi_penalize_sci_irq(int irq, int trigger, int polarity) 845 { 846 sci_irq = irq; 847 848 if (trigger == ACPI_MADT_TRIGGER_LEVEL && 849 polarity == ACPI_MADT_POLARITY_ACTIVE_LOW) 850 sci_penalty = PIRQ_PENALTY_PCI_USING; 851 else 852 sci_penalty = PIRQ_PENALTY_ISA_ALWAYS; 853 } 854 855 /* 856 * Over-ride default table to reserve additional IRQs for use by ISA 857 * e.g. acpi_irq_isa=5 858 * Useful for telling ACPI how not to interfere with your ISA sound card. 859 */ 860 static int __init acpi_irq_isa(char *str) 861 { 862 return acpi_irq_penalty_update(str, 1); 863 } 864 865 __setup("acpi_irq_isa=", acpi_irq_isa); 866 867 /* 868 * Over-ride default table to free additional IRQs for use by PCI 869 * e.g. acpi_irq_pci=7,15 870 * Used for acpi_irq_balance to free up IRQs to reduce PCI IRQ sharing. 871 */ 872 static int __init acpi_irq_pci(char *str) 873 { 874 return acpi_irq_penalty_update(str, 0); 875 } 876 877 __setup("acpi_irq_pci=", acpi_irq_pci); 878 879 static int __init acpi_irq_nobalance_set(char *str) 880 { 881 acpi_irq_balance = 0; 882 return 1; 883 } 884 885 __setup("acpi_irq_nobalance", acpi_irq_nobalance_set); 886 887 static int __init acpi_irq_balance_set(char *str) 888 { 889 acpi_irq_balance = 1; 890 return 1; 891 } 892 893 __setup("acpi_irq_balance", acpi_irq_balance_set); 894 895 static struct syscore_ops irqrouter_syscore_ops = { 896 .resume = irqrouter_resume, 897 }; 898 899 void __init acpi_pci_link_init(void) 900 { 901 if (acpi_noirq) 902 return; 903 904 if (acpi_irq_balance == -1) { 905 /* no command line switch: enable balancing in IOAPIC mode */ 906 if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC) 907 acpi_irq_balance = 1; 908 else 909 acpi_irq_balance = 0; 910 } 911 register_syscore_ops(&irqrouter_syscore_ops); 912 acpi_scan_add_handler(&pci_link_handler); 913 } 914