git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/pci_link.c

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