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