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