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 int __init acpi_irq_penalty_init(void) 521 { 522 struct acpi_pci_link *link; 523 int i; 524 525 /* 526 * Update penalties to facilitate IRQ balancing. 527 */ 528 list_for_each_entry(link, &acpi_link_list, list) { 529 530 /* 531 * reflect the possible and active irqs in the penalty table -- 532 * useful for breaking ties. 533 */ 534 if (link->irq.possible_count) { 535 int penalty = 536 PIRQ_PENALTY_PCI_POSSIBLE / 537 link->irq.possible_count; 538 539 for (i = 0; i < link->irq.possible_count; i++) { 540 if (link->irq.possible[i] < ACPI_MAX_ISA_IRQS) 541 acpi_isa_irq_penalty[link->irq. 542 possible[i]] += 543 penalty; 544 } 545 546 } else if (link->irq.active && 547 (link->irq.active < ACPI_MAX_ISA_IRQS)) { 548 acpi_isa_irq_penalty[link->irq.active] += 549 PIRQ_PENALTY_PCI_POSSIBLE; 550 } 551 } 552 553 return 0; 554 } 555 556 static int acpi_irq_balance = -1; /* 0: static, 1: balance */ 557 558 static int acpi_pci_link_allocate(struct acpi_pci_link *link) 559 { 560 int irq; 561 int i; 562 563 if (link->irq.initialized) { 564 if (link->refcnt == 0) 565 /* This means the link is disabled but initialized */ 566 acpi_pci_link_set(link, link->irq.active); 567 return 0; 568 } 569 570 /* 571 * search for active IRQ in list of possible IRQs. 572 */ 573 for (i = 0; i < link->irq.possible_count; ++i) { 574 if (link->irq.active == link->irq.possible[i]) 575 break; 576 } 577 /* 578 * forget active IRQ that is not in possible list 579 */ 580 if (i == link->irq.possible_count) { 581 if (acpi_strict) 582 printk(KERN_WARNING PREFIX "_CRS %d not found" 583 " in _PRS\n", link->irq.active); 584 link->irq.active = 0; 585 } 586 587 /* 588 * if active found, use it; else pick entry from end of possible list. 589 */ 590 if (link->irq.active) 591 irq = link->irq.active; 592 else 593 irq = link->irq.possible[link->irq.possible_count - 1]; 594 595 if (acpi_irq_balance || !link->irq.active) { 596 /* 597 * Select the best IRQ. This is done in reverse to promote 598 * the use of IRQs 9, 10, 11, and >15. 599 */ 600 for (i = (link->irq.possible_count - 1); i >= 0; i--) { 601 if (acpi_irq_get_penalty(irq) > 602 acpi_irq_get_penalty(link->irq.possible[i])) 603 irq = link->irq.possible[i]; 604 } 605 } 606 if (acpi_irq_get_penalty(irq) >= PIRQ_PENALTY_ISA_ALWAYS) { 607 printk(KERN_ERR PREFIX "No IRQ available for %s [%s]. " 608 "Try pci=noacpi or acpi=off\n", 609 acpi_device_name(link->device), 610 acpi_device_bid(link->device)); 611 return -ENODEV; 612 } 613 614 /* Attempt to enable the link device at this IRQ. */ 615 if (acpi_pci_link_set(link, irq)) { 616 printk(KERN_ERR PREFIX "Unable to set IRQ for %s [%s]. " 617 "Try pci=noacpi or acpi=off\n", 618 acpi_device_name(link->device), 619 acpi_device_bid(link->device)); 620 return -ENODEV; 621 } else { 622 printk(KERN_WARNING PREFIX "%s [%s] enabled at IRQ %d\n", 623 acpi_device_name(link->device), 624 acpi_device_bid(link->device), link->irq.active); 625 } 626 627 link->irq.initialized = 1; 628 return 0; 629 } 630 631 /* 632 * acpi_pci_link_allocate_irq 633 * success: return IRQ >= 0 634 * failure: return -1 635 */ 636 int acpi_pci_link_allocate_irq(acpi_handle handle, int index, int *triggering, 637 int *polarity, char **name) 638 { 639 int result; 640 struct acpi_device *device; 641 struct acpi_pci_link *link; 642 643 result = acpi_bus_get_device(handle, &device); 644 if (result) { 645 printk(KERN_ERR PREFIX "Invalid link device\n"); 646 return -1; 647 } 648 649 link = acpi_driver_data(device); 650 if (!link) { 651 printk(KERN_ERR PREFIX "Invalid link context\n"); 652 return -1; 653 } 654 655 /* TBD: Support multiple index (IRQ) entries per Link Device */ 656 if (index) { 657 printk(KERN_ERR PREFIX "Invalid index %d\n", index); 658 return -1; 659 } 660 661 mutex_lock(&acpi_link_lock); 662 if (acpi_pci_link_allocate(link)) { 663 mutex_unlock(&acpi_link_lock); 664 return -1; 665 } 666 667 if (!link->irq.active) { 668 mutex_unlock(&acpi_link_lock); 669 printk(KERN_ERR PREFIX "Link active IRQ is 0!\n"); 670 return -1; 671 } 672 link->refcnt++; 673 mutex_unlock(&acpi_link_lock); 674 675 if (triggering) 676 *triggering = link->irq.triggering; 677 if (polarity) 678 *polarity = link->irq.polarity; 679 if (name) 680 *name = acpi_device_bid(link->device); 681 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 682 "Link %s is referenced\n", 683 acpi_device_bid(link->device))); 684 return (link->irq.active); 685 } 686 687 /* 688 * We don't change link's irq information here. After it is reenabled, we 689 * continue use the info 690 */ 691 int acpi_pci_link_free_irq(acpi_handle handle) 692 { 693 struct acpi_device *device; 694 struct acpi_pci_link *link; 695 acpi_status result; 696 697 result = acpi_bus_get_device(handle, &device); 698 if (result) { 699 printk(KERN_ERR PREFIX "Invalid link device\n"); 700 return -1; 701 } 702 703 link = acpi_driver_data(device); 704 if (!link) { 705 printk(KERN_ERR PREFIX "Invalid link context\n"); 706 return -1; 707 } 708 709 mutex_lock(&acpi_link_lock); 710 if (!link->irq.initialized) { 711 mutex_unlock(&acpi_link_lock); 712 printk(KERN_ERR PREFIX "Link isn't initialized\n"); 713 return -1; 714 } 715 #ifdef FUTURE_USE 716 /* 717 * The Link reference count allows us to _DISable an unused link 718 * and suspend time, and set it again on resume. 719 * However, 2.6.12 still has irq_router.resume 720 * which blindly restores the link state. 721 * So we disable the reference count method 722 * to prevent duplicate acpi_pci_link_set() 723 * which would harm some systems 724 */ 725 link->refcnt--; 726 #endif 727 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 728 "Link %s is dereferenced\n", 729 acpi_device_bid(link->device))); 730 731 if (link->refcnt == 0) 732 acpi_evaluate_object(link->device->handle, "_DIS", NULL, NULL); 733 734 mutex_unlock(&acpi_link_lock); 735 return (link->irq.active); 736 } 737 738 /* -------------------------------------------------------------------------- 739 Driver Interface 740 -------------------------------------------------------------------------- */ 741 742 static int acpi_pci_link_add(struct acpi_device *device, 743 const struct acpi_device_id *not_used) 744 { 745 int result; 746 struct acpi_pci_link *link; 747 int i; 748 int found = 0; 749 750 link = kzalloc(sizeof(struct acpi_pci_link), GFP_KERNEL); 751 if (!link) 752 return -ENOMEM; 753 754 link->device = device; 755 strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME); 756 strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS); 757 device->driver_data = link; 758 759 mutex_lock(&acpi_link_lock); 760 result = acpi_pci_link_get_possible(link); 761 if (result) 762 goto end; 763 764 /* query and set link->irq.active */ 765 acpi_pci_link_get_current(link); 766 767 printk(KERN_INFO PREFIX "%s [%s] (IRQs", acpi_device_name(device), 768 acpi_device_bid(device)); 769 for (i = 0; i < link->irq.possible_count; i++) { 770 if (link->irq.active == link->irq.possible[i]) { 771 printk(KERN_CONT " *%d", link->irq.possible[i]); 772 found = 1; 773 } else 774 printk(KERN_CONT " %d", link->irq.possible[i]); 775 } 776 777 printk(KERN_CONT ")"); 778 779 if (!found) 780 printk(KERN_CONT " *%d", link->irq.active); 781 782 if (!link->device->status.enabled) 783 printk(KERN_CONT ", disabled."); 784 785 printk(KERN_CONT "\n"); 786 787 list_add_tail(&link->list, &acpi_link_list); 788 789 end: 790 /* disable all links -- to be activated on use */ 791 acpi_evaluate_object(device->handle, "_DIS", NULL, NULL); 792 mutex_unlock(&acpi_link_lock); 793 794 if (result) 795 kfree(link); 796 797 return result < 0 ? result : 1; 798 } 799 800 static int acpi_pci_link_resume(struct acpi_pci_link *link) 801 { 802 if (link->refcnt && link->irq.active && link->irq.initialized) 803 return (acpi_pci_link_set(link, link->irq.active)); 804 805 return 0; 806 } 807 808 static void irqrouter_resume(void) 809 { 810 struct acpi_pci_link *link; 811 812 list_for_each_entry(link, &acpi_link_list, list) { 813 acpi_pci_link_resume(link); 814 } 815 } 816 817 static void acpi_pci_link_remove(struct acpi_device *device) 818 { 819 struct acpi_pci_link *link; 820 821 link = acpi_driver_data(device); 822 823 mutex_lock(&acpi_link_lock); 824 list_del(&link->list); 825 mutex_unlock(&acpi_link_lock); 826 827 kfree(link); 828 } 829 830 /* 831 * modify acpi_isa_irq_penalty[] from cmdline 832 */ 833 static int __init acpi_irq_penalty_update(char *str, int used) 834 { 835 int i; 836 837 for (i = 0; i < 16; i++) { 838 int retval; 839 int irq; 840 int new_penalty; 841 842 retval = get_option(&str, &irq); 843 844 if (!retval) 845 break; /* no number found */ 846 847 /* see if this is a ISA IRQ */ 848 if ((irq < 0) || (irq >= ACPI_MAX_ISA_IRQS)) 849 continue; 850 851 if (used) 852 new_penalty = acpi_irq_get_penalty(irq) + 853 PIRQ_PENALTY_ISA_USED; 854 else 855 new_penalty = 0; 856 857 acpi_isa_irq_penalty[irq] = new_penalty; 858 if (retval != 2) /* no next number */ 859 break; 860 } 861 return 1; 862 } 863 864 /* 865 * We'd like PNP to call this routine for the 866 * single ISA_USED value for each legacy device. 867 * But instead it calls us with each POSSIBLE setting. 868 * There is no ISA_POSSIBLE weight, so we simply use 869 * the (small) PCI_USING penalty. 870 */ 871 void acpi_penalize_isa_irq(int irq, int active) 872 { 873 if ((irq >= 0) && (irq < ARRAY_SIZE(acpi_isa_irq_penalty))) 874 acpi_isa_irq_penalty[irq] = acpi_irq_get_penalty(irq) + 875 (active ? PIRQ_PENALTY_ISA_USED : PIRQ_PENALTY_PCI_USING); 876 } 877 878 bool acpi_isa_irq_available(int irq) 879 { 880 return irq >= 0 && (irq >= ARRAY_SIZE(acpi_isa_irq_penalty) || 881 acpi_irq_get_penalty(irq) < PIRQ_PENALTY_ISA_ALWAYS); 882 } 883 884 /* 885 * Over-ride default table to reserve additional IRQs for use by ISA 886 * e.g. acpi_irq_isa=5 887 * Useful for telling ACPI how not to interfere with your ISA sound card. 888 */ 889 static int __init acpi_irq_isa(char *str) 890 { 891 return acpi_irq_penalty_update(str, 1); 892 } 893 894 __setup("acpi_irq_isa=", acpi_irq_isa); 895 896 /* 897 * Over-ride default table to free additional IRQs for use by PCI 898 * e.g. acpi_irq_pci=7,15 899 * Used for acpi_irq_balance to free up IRQs to reduce PCI IRQ sharing. 900 */ 901 static int __init acpi_irq_pci(char *str) 902 { 903 return acpi_irq_penalty_update(str, 0); 904 } 905 906 __setup("acpi_irq_pci=", acpi_irq_pci); 907 908 static int __init acpi_irq_nobalance_set(char *str) 909 { 910 acpi_irq_balance = 0; 911 return 1; 912 } 913 914 __setup("acpi_irq_nobalance", acpi_irq_nobalance_set); 915 916 static int __init acpi_irq_balance_set(char *str) 917 { 918 acpi_irq_balance = 1; 919 return 1; 920 } 921 922 __setup("acpi_irq_balance", acpi_irq_balance_set); 923 924 static struct syscore_ops irqrouter_syscore_ops = { 925 .resume = irqrouter_resume, 926 }; 927 928 void __init acpi_pci_link_init(void) 929 { 930 if (acpi_noirq) 931 return; 932 933 if (acpi_irq_balance == -1) { 934 /* no command line switch: enable balancing in IOAPIC mode */ 935 if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC) 936 acpi_irq_balance = 1; 937 else 938 acpi_irq_balance = 0; 939 } 940 register_syscore_ops(&irqrouter_syscore_ops); 941 acpi_scan_add_handler(&pci_link_handler); 942 } 943