drivers/acpi/pci_irq.c

   1 /*
   2  *  pci_irq.c - ACPI PCI Interrupt Routing ($Revision: 11 $)
   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  *  (c) Copyright 2008 Hewlett-Packard Development Company, L.P.
   8  *      Bjorn Helgaas <bjorn.helgaas@hp.com>
   9  *
  10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or (at
  15  *  your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful, but
  18  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  *  General Public License for more details.
  21  *
  22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23  */
  24
  25
  26 #include <linux/dmi.h>
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/init.h>
  30 #include <linux/types.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/pm.h>
  33 #include <linux/pci.h>
  34 #include <linux/acpi.h>
  35 #include <linux/slab.h>
  36 #include <linux/interrupt.h>
  37
  38 #define PREFIX "ACPI: "
  39
  40 #define _COMPONENT              ACPI_PCI_COMPONENT
  41 ACPI_MODULE_NAME("pci_irq");
  42
  43 struct acpi_prt_entry {
  44         struct acpi_pci_id      id;
  45         u8                      pin;
  46         acpi_handle             link;
  47         u32                     index;          /* GSI, or link _CRS index */
  48 };
  49
  50 static inline char pin_name(int pin)
  51 {
  52         return 'A' + pin - 1;
  53 }
  54
  55 /* --------------------------------------------------------------------------
  56                          PCI IRQ Routing Table (PRT) Support
  57    -------------------------------------------------------------------------- */
  58
  59 /* http://bugzilla.kernel.org/show_bug.cgi?id=4773 */
  60 static const struct dmi_system_id medion_md9580[] = {
  61         {
  62                 .ident = "Medion MD9580-F laptop",
  63                 .matches = {
  64                         DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
  65                         DMI_MATCH(DMI_PRODUCT_NAME, "A555"),
  66                 },
  67         },
  68         { }
  69 };
  70
  71 /* http://bugzilla.kernel.org/show_bug.cgi?id=5044 */
  72 static const struct dmi_system_id dell_optiplex[] = {
  73         {
  74                 .ident = "Dell Optiplex GX1",
  75                 .matches = {
  76                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
  77                         DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex GX1 600S+"),
  78                 },
  79         },
  80         { }
  81 };
  82
  83 /* http://bugzilla.kernel.org/show_bug.cgi?id=10138 */
  84 static const struct dmi_system_id hp_t5710[] = {
  85         {
  86                 .ident = "HP t5710",
  87                 .matches = {
  88                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
  89                         DMI_MATCH(DMI_PRODUCT_NAME, "hp t5000 series"),
  90                         DMI_MATCH(DMI_BOARD_NAME, "098Ch"),
  91                 },
  92         },
  93         { }
  94 };
  95
  96 struct prt_quirk {
  97         const struct dmi_system_id *system;
  98         unsigned int            segment;
  99         unsigned int            bus;
 100         unsigned int            device;
 101         unsigned char           pin;
 102         const char              *source;        /* according to BIOS */
 103         const char              *actual_source;
 104 };
 105
 106 #define PCI_INTX_PIN(c)         (c - 'A' + 1)
 107
 108 /*
 109  * These systems have incorrect _PRT entries.  The BIOS claims the PCI
 110  * interrupt at the listed segment/bus/device/pin is connected to the first
 111  * link device, but it is actually connected to the second.
 112  */
 113 static const struct prt_quirk prt_quirks[] = {
 114         { medion_md9580, 0, 0, 9, PCI_INTX_PIN('A'),
 115                 "\\_SB_.PCI0.ISA_.LNKA",
 116                 "\\_SB_.PCI0.ISA_.LNKB"},
 117         { dell_optiplex, 0, 0, 0xd, PCI_INTX_PIN('A'),
 118                 "\\_SB_.LNKB",
 119                 "\\_SB_.LNKA"},
 120         { hp_t5710, 0, 0, 1, PCI_INTX_PIN('A'),
 121                 "\\_SB_.PCI0.LNK1",
 122                 "\\_SB_.PCI0.LNK3"},
 123 };
 124
 125 static void do_prt_fixups(struct acpi_prt_entry *entry,
 126                           struct acpi_pci_routing_table *prt)
 127 {
 128         int i;
 129         const struct prt_quirk *quirk;
 130
 131         for (i = 0; i < ARRAY_SIZE(prt_quirks); i++) {
 132                 quirk = &prt_quirks[i];
 133
 134                 /* All current quirks involve link devices, not GSIs */
 135                 if (dmi_check_system(quirk->system) &&
 136                     entry->id.segment == quirk->segment &&
 137                     entry->id.bus == quirk->bus &&
 138                     entry->id.device == quirk->device &&
 139                     entry->pin == quirk->pin &&
 140                     !strcmp(prt->source, quirk->source) &&
 141                     strlen(prt->source) >= strlen(quirk->actual_source)) {
 142                         printk(KERN_WARNING PREFIX "firmware reports "
 143                                 "%04x:%02x:%02x PCI INT %c connected to %s; "
 144                                 "changing to %s\n",
 145                                 entry->id.segment, entry->id.bus,
 146                                 entry->id.device, pin_name(entry->pin),
 147                                 prt->source, quirk->actual_source);
 148                         strcpy(prt->source, quirk->actual_source);
 149                 }
 150         }
 151 }
 152
 153 static int acpi_pci_irq_check_entry(acpi_handle handle, struct pci_dev *dev,
 154                                   int pin, struct acpi_pci_routing_table *prt,
 155                                   struct acpi_prt_entry **entry_ptr)
 156 {
 157         int segment = pci_domain_nr(dev->bus);
 158         int bus = dev->bus->number;
 159         int device = pci_ari_enabled(dev->bus) ? 0 : PCI_SLOT(dev->devfn);
 160         struct acpi_prt_entry *entry;
 161
 162         if (((prt->address >> 16) & 0xffff) != device ||
 163             prt->pin + 1 != pin)
 164                 return -ENODEV;
 165
 166         entry = kzalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
 167         if (!entry)
 168                 return -ENOMEM;
 169
 170         /*
 171          * Note that the _PRT uses 0=INTA, 1=INTB, etc, while PCI uses
 172          * 1=INTA, 2=INTB.  We use the PCI encoding throughout, so convert
 173          * it here.
 174          */
 175         entry->id.segment = segment;
 176         entry->id.bus = bus;
 177         entry->id.device = (prt->address >> 16) & 0xFFFF;
 178         entry->pin = prt->pin + 1;
 179
 180         do_prt_fixups(entry, prt);
 181
 182         entry->index = prt->source_index;
 183
 184         /*
 185          * Type 1: Dynamic
 186          * ---------------
 187          * The 'source' field specifies the PCI interrupt link device used to
 188          * configure the IRQ assigned to this slot|dev|pin.  The 'source_index'
 189          * indicates which resource descriptor in the resource template (of
 190          * the link device) this interrupt is allocated from.
 191          *
 192          * NOTE: Don't query the Link Device for IRQ information at this time
 193          *       because Link Device enumeration may not have occurred yet
 194          *       (e.g. exists somewhere 'below' this _PRT entry in the ACPI
 195          *       namespace).
 196          */
 197         if (prt->source[0])
 198                 acpi_get_handle(handle, prt->source, &entry->link);
 199
 200         /*
 201          * Type 2: Static
 202          * --------------
 203          * The 'source' field is NULL, and the 'source_index' field specifies
 204          * the IRQ value, which is hardwired to specific interrupt inputs on
 205          * the interrupt controller.
 206          */
 207
 208         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INFO,
 209                               "      %04x:%02x:%02x[%c] -> %s[%d]\n",
 210                               entry->id.segment, entry->id.bus,
 211                               entry->id.device, pin_name(entry->pin),
 212                               prt->source, entry->index));
 213
 214         *entry_ptr = entry;
 215
 216         return 0;
 217 }
 218
 219 static int acpi_pci_irq_find_prt_entry(struct pci_dev *dev,
 220                           int pin, struct acpi_prt_entry **entry_ptr)
 221 {
 222         acpi_status status;
 223         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 224         struct acpi_pci_routing_table *entry;
 225         acpi_handle handle = NULL;
 226
 227         if (dev->bus->bridge)
 228                 handle = ACPI_HANDLE(dev->bus->bridge);
 229
 230         if (!handle)
 231                 return -ENODEV;
 232
 233         /* 'handle' is the _PRT's parent (root bridge or PCI-PCI bridge) */
 234         status = acpi_get_irq_routing_table(handle, &buffer);
 235         if (ACPI_FAILURE(status)) {
 236                 kfree(buffer.pointer);
 237                 return -ENODEV;
 238         }
 239
 240         entry = buffer.pointer;
 241         while (entry && (entry->length > 0)) {
 242                 if (!acpi_pci_irq_check_entry(handle, dev, pin,
 243                                                  entry, entry_ptr))
 244                         break;
 245                 entry = (struct acpi_pci_routing_table *)
 246                     ((unsigned long)entry + entry->length);
 247         }
 248
 249         kfree(buffer.pointer);
 250         return 0;
 251 }
 252
 253 /* --------------------------------------------------------------------------
 254                           PCI Interrupt Routing Support
 255    -------------------------------------------------------------------------- */
 256 #ifdef CONFIG_X86_IO_APIC
 257 extern int noioapicquirk;
 258 extern int noioapicreroute;
 259
 260 static int bridge_has_boot_interrupt_variant(struct pci_bus *bus)
 261 {
 262         struct pci_bus *bus_it;
 263
 264         for (bus_it = bus ; bus_it ; bus_it = bus_it->parent) {
 265                 if (!bus_it->self)
 266                         return 0;
 267                 if (bus_it->self->irq_reroute_variant)
 268                         return bus_it->self->irq_reroute_variant;
 269         }
 270         return 0;
 271 }
 272
 273 /*
 274  * Some chipsets (e.g. Intel 6700PXH) generate a legacy INTx when the IRQ
 275  * entry in the chipset's IO-APIC is masked (as, e.g. the RT kernel does
 276  * during interrupt handling). When this INTx generation cannot be disabled,
 277  * we reroute these interrupts to their legacy equivalent to get rid of
 278  * spurious interrupts.
 279  */
 280 static int acpi_reroute_boot_interrupt(struct pci_dev *dev,
 281                                        struct acpi_prt_entry *entry)
 282 {
 283         if (noioapicquirk || noioapicreroute) {
 284                 return 0;
 285         } else {
 286                 switch (bridge_has_boot_interrupt_variant(dev->bus)) {
 287                 case 0:
 288                         /* no rerouting necessary */
 289                         return 0;
 290                 case INTEL_IRQ_REROUTE_VARIANT:
 291                         /*
 292                          * Remap according to INTx routing table in 6700PXH
 293                          * specs, intel order number 302628-002, section
 294                          * 2.15.2. Other chipsets (80332, ...) have the same
 295                          * mapping and are handled here as well.
 296                          */
 297                         dev_info(&dev->dev, "PCI IRQ %d -> rerouted to legacy "
 298                                  "IRQ %d\n", entry->index,
 299                                  (entry->index % 4) + 16);
 300                         entry->index = (entry->index % 4) + 16;
 301                         return 1;
 302                 default:
 303                         dev_warn(&dev->dev, "Cannot reroute IRQ %d to legacy "
 304                                  "IRQ: unknown mapping\n", entry->index);
 305                         return -1;
 306                 }
 307         }
 308 }
 309 #endif /* CONFIG_X86_IO_APIC */
 310
 311 static struct acpi_prt_entry *acpi_pci_irq_lookup(struct pci_dev *dev, int pin)
 312 {
 313         struct acpi_prt_entry *entry = NULL;
 314         struct pci_dev *bridge;
 315         u8 bridge_pin, orig_pin = pin;
 316         int ret;
 317
 318         ret = acpi_pci_irq_find_prt_entry(dev, pin, &entry);
 319         if (!ret && entry) {
 320 #ifdef CONFIG_X86_IO_APIC
 321                 acpi_reroute_boot_interrupt(dev, entry);
 322 #endif /* CONFIG_X86_IO_APIC */
 323                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %s[%c] _PRT entry\n",
 324                                   pci_name(dev), pin_name(pin)));
 325                 return entry;
 326         }
 327
 328         /*
 329          * Attempt to derive an IRQ for this device from a parent bridge's
 330          * PCI interrupt routing entry (eg. yenta bridge and add-in card bridge).
 331          */
 332         bridge = dev->bus->self;
 333         while (bridge) {
 334                 pin = pci_swizzle_interrupt_pin(dev, pin);
 335
 336                 if ((bridge->class >> 8) == PCI_CLASS_BRIDGE_CARDBUS) {
 337                         /* PC card has the same IRQ as its cardbridge */
 338                         bridge_pin = bridge->pin;
 339                         if (!bridge_pin) {
 340                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 341                                                   "No interrupt pin configured for device %s\n",
 342                                                   pci_name(bridge)));
 343                                 return NULL;
 344                         }
 345                         pin = bridge_pin;
 346                 }
 347
 348                 ret = acpi_pci_irq_find_prt_entry(bridge, pin, &entry);
 349                 if (!ret && entry) {
 350                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 351                                          "Derived GSI for %s INT %c from %s\n",
 352                                          pci_name(dev), pin_name(orig_pin),
 353                                          pci_name(bridge)));
 354                         return entry;
 355                 }
 356
 357                 dev = bridge;
 358                 bridge = dev->bus->self;
 359         }
 360
 361         dev_warn(&dev->dev, "can't derive routing for PCI INT %c\n",
 362                  pin_name(orig_pin));
 363         return NULL;
 364 }
 365
 366 #if IS_ENABLED(CONFIG_ISA) || IS_ENABLED(CONFIG_EISA)
 367 static int acpi_isa_register_gsi(struct pci_dev *dev)
 368 {
 369         u32 dev_gsi;
 370
 371         /* Interrupt Line values above 0xF are forbidden */
 372         if (dev->irq > 0 && (dev->irq <= 0xF) &&
 373             acpi_isa_irq_available(dev->irq) &&
 374             (acpi_isa_irq_to_gsi(dev->irq, &dev_gsi) == 0)) {
 375                 dev_warn(&dev->dev, "PCI INT %c: no GSI - using ISA IRQ %d\n",
 376                          pin_name(dev->pin), dev->irq);
 377                 acpi_register_gsi(&dev->dev, dev_gsi,
 378                                   ACPI_LEVEL_SENSITIVE,
 379                                   ACPI_ACTIVE_LOW);
 380                 return 0;
 381         }
 382         return -EINVAL;
 383 }
 384 #else
 385 static inline int acpi_isa_register_gsi(struct pci_dev *dev)
 386 {
 387         return -ENODEV;
 388 }
 389 #endif
 390
 391 static inline bool acpi_pci_irq_valid(struct pci_dev *dev, u8 pin)
 392 {
 393 #ifdef CONFIG_X86
 394         /*
 395          * On x86 irq line 0xff means "unknown" or "no connection"
 396          * (PCI 3.0, Section 6.2.4, footnote on page 223).
 397          */
 398         if (dev->irq == 0xff) {
 399                 dev->irq = IRQ_NOTCONNECTED;
 400                 dev_warn(&dev->dev, "PCI INT %c: not connected\n",
 401                          pin_name(pin));
 402                 return false;
 403         }
 404 #endif
 405         return true;
 406 }
 407
 408 int acpi_pci_irq_enable(struct pci_dev *dev)
 409 {
 410         struct acpi_prt_entry *entry;
 411         int gsi;
 412         u8 pin;
 413         int triggering = ACPI_LEVEL_SENSITIVE;
 414         /*
 415          * On ARM systems with the GIC interrupt model, level interrupts
 416          * are always polarity high by specification; PCI legacy
 417          * IRQs lines are inverted before reaching the interrupt
 418          * controller and must therefore be considered active high
 419          * as default.
 420          */
 421         int polarity = acpi_irq_model == ACPI_IRQ_MODEL_GIC ?
 422                                       ACPI_ACTIVE_HIGH : ACPI_ACTIVE_LOW;
 423         char *link = NULL;
 424         char link_desc[16];
 425         int rc;
 426
 427         pin = dev->pin;
 428         if (!pin) {
 429                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 430                                   "No interrupt pin configured for device %s\n",
 431                                   pci_name(dev)));
 432                 return 0;
 433         }
 434
 435         if (dev->irq_managed && dev->irq > 0)
 436                 return 0;
 437
 438         entry = acpi_pci_irq_lookup(dev, pin);
 439         if (!entry) {
 440                 /*
 441                  * IDE legacy mode controller IRQs are magic. Why do compat
 442                  * extensions always make such a nasty mess.
 443                  */
 444                 if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE &&
 445                                 (dev->class & 0x05) == 0)
 446                         return 0;
 447         }
 448
 449         if (entry) {
 450                 if (entry->link)
 451                         gsi = acpi_pci_link_allocate_irq(entry->link,
 452                                                          entry->index,
 453                                                          &triggering, &polarity,
 454                                                          &link);
 455                 else
 456                         gsi = entry->index;
 457         } else
 458                 gsi = -1;
 459
 460         if (gsi < 0) {
 461                 /*
 462                  * No IRQ known to the ACPI subsystem - maybe the BIOS /
 463                  * driver reported one, then use it. Exit in any case.
 464                  */
 465                 if (!acpi_pci_irq_valid(dev, pin))
 466                         return 0;
 467
 468                 if (acpi_isa_register_gsi(dev))
 469                         dev_warn(&dev->dev, "PCI INT %c: no GSI\n",
 470                                  pin_name(pin));
 471
 472                 kfree(entry);
 473                 return 0;
 474         }
 475
 476         rc = acpi_register_gsi(&dev->dev, gsi, triggering, polarity);
 477         if (rc < 0) {
 478                 dev_warn(&dev->dev, "PCI INT %c: failed to register GSI\n",
 479                          pin_name(pin));
 480                 kfree(entry);
 481                 return rc;
 482         }
 483         dev->irq = rc;
 484         dev->irq_managed = 1;
 485
 486         if (link)
 487                 snprintf(link_desc, sizeof(link_desc), " -> Link[%s]", link);
 488         else
 489                 link_desc[0] = '\0';
 490
 491         dev_dbg(&dev->dev, "PCI INT %c%s -> GSI %u (%s, %s) -> IRQ %d\n",
 492                 pin_name(pin), link_desc, gsi,
 493                 (triggering == ACPI_LEVEL_SENSITIVE) ? "level" : "edge",
 494                 (polarity == ACPI_ACTIVE_LOW) ? "low" : "high", dev->irq);
 495
 496         kfree(entry);
 497         return 0;
 498 }
 499
 500 void acpi_pci_irq_disable(struct pci_dev *dev)
 501 {
 502         struct acpi_prt_entry *entry;
 503         int gsi;
 504         u8 pin;
 505
 506         pin = dev->pin;
 507         if (!pin || !dev->irq_managed || dev->irq <= 0)
 508                 return;
 509
 510         /* Keep IOAPIC pin configuration when suspending */
 511         if (dev->dev.power.is_prepared)
 512                 return;
 513 #ifdef  CONFIG_PM
 514         if (dev->dev.power.runtime_status == RPM_SUSPENDING)
 515                 return;
 516 #endif
 517
 518         entry = acpi_pci_irq_lookup(dev, pin);
 519         if (!entry)
 520                 return;
 521
 522         if (entry->link)
 523                 gsi = acpi_pci_link_free_irq(entry->link);
 524         else
 525                 gsi = entry->index;
 526
 527         kfree(entry);
 528
 529         /*
 530          * TBD: It might be worth clearing dev->irq by magic constant
 531          * (e.g. PCI_UNDEFINED_IRQ).
 532          */
 533
 534         dev_dbg(&dev->dev, "PCI INT %c disabled\n", pin_name(pin));
 535         if (gsi >= 0) {
 536                 acpi_unregister_gsi(gsi);
 537                 dev->irq_managed = 0;
 538         }
 539 }