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