sys/dev/acpica5/acpi_pcib.c

   1 /*-
   2  * Copyright (c) 2000 Michael Smith
   3  * Copyright (c) 2000 BSDi
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/sys/dev/acpica/acpi_pcib.c,v 1.43 2004/05/06 02:18:58 njl Exp $
  28  * $DragonFly: src/sys/dev/acpica5/acpi_pcib.c,v 1.3 2006/12/22 23:26:14 swildner Exp $
  29  */
  30
  31 #include "opt_acpi.h"
  32 #include <sys/param.h>
  33 #include <sys/bus.h>
  34 #include <sys/malloc.h>
  35 #include <sys/kernel.h>
  36
  37 #include "acpi.h"
  38 #include "acpivar.h"
  39 #include "acpi_pcibvar.h"
  40
  41 #include <bus/pci/pcivar.h>
  42 #include "pcib_if.h"
  43
  44 /* Hooks for the ACPI CA debugging infrastructure. */
  45 #define _COMPONENT      ACPI_BUS
  46 ACPI_MODULE_NAME("PCI")
  47
  48 int
  49 acpi_pcib_attach(device_t dev, ACPI_BUFFER *prt, int busno)
  50 {
  51     device_t                    child;
  52     ACPI_STATUS                 status;
  53
  54     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
  55
  56     /*
  57      * Don't attach if we're not really there.
  58      *
  59      * XXX: This isn't entirely correct since we may be a PCI bus
  60      * on a hot-plug docking station, etc.
  61      */
  62     if (!acpi_DeviceIsPresent(dev))
  63         return_VALUE(ENXIO);
  64
  65     /*
  66      * Get the PCI interrupt routing table for this bus.  If we can't
  67      * get it, this is not an error but may reduce functionality.
  68      */
  69     prt->Length = ACPI_ALLOCATE_BUFFER;
  70     status = AcpiGetIrqRoutingTable(acpi_get_handle(dev), prt);
  71     if (ACPI_FAILURE(status))
  72         device_printf(dev,
  73             "could not get PCI interrupt routing table for %s - %s\n",
  74             acpi_name(acpi_get_handle(dev)), AcpiFormatException(status));
  75
  76     /*
  77      * Attach the PCI bus proper.
  78      */
  79     if ((child = device_add_child(dev, "pci", busno)) == NULL) {
  80         device_printf(device_get_parent(dev), "couldn't attach pci bus\n");
  81         return_VALUE(ENXIO);
  82     }
  83
  84     /*
  85      * Now go scan the bus.
  86      */
  87     acpi_pci_link_config(dev, prt, busno);
  88
  89     return_VALUE (bus_generic_attach(dev));
  90 }
  91
  92 int
  93 acpi_pcib_resume(device_t dev, ACPI_BUFFER *prt, int busno)
  94 {
  95     acpi_pci_link_resume(dev, prt, busno);
  96     return (bus_generic_resume(dev));
  97 }
  98
  99 /*
 100  * Route an interrupt for a child of the bridge.
 101  *
 102  * XXX clean up error messages
 103  *
 104  * XXX this function is somewhat bulky
 105  */
 106 int
 107 acpi_pcib_route_interrupt(device_t pcib, device_t dev, int pin,
 108     ACPI_BUFFER *prtbuf)
 109 {
 110     ACPI_PCI_ROUTING_TABLE      *prt;
 111     ACPI_HANDLE                 lnkdev;
 112     ACPI_BUFFER                 crsbuf, prsbuf, buf;
 113     ACPI_RESOURCE               *crsres, *prsres, resbuf;
 114     ACPI_DEVICE_INFO            *devinfo;
 115     ACPI_STATUS                 status;
 116     UINT32                      NumberOfInterrupts;
 117     UINT32                      *Interrupts;
 118     u_int8_t                    *prtp;
 119     int                         interrupt;
 120     int                         i;
 121
 122     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 123
 124     buf.Pointer = NULL;
 125     crsbuf.Pointer = NULL;
 126     prsbuf.Pointer = NULL;
 127     interrupt = 255;
 128
 129     /* ACPI numbers pins 0-3, not 1-4 like the BIOS. */
 130     pin--;
 131
 132     /* We failed to retrieve the routing table. */
 133     prtp = prtbuf->Pointer;
 134     if (prtp == NULL)
 135         goto out;
 136
 137     /* Scan the table to look for this device. */
 138     for (;;) {
 139         prt = (ACPI_PCI_ROUTING_TABLE *)prtp;
 140
 141         /* We hit the end of the table. */
 142         if (prt->Length == 0)
 143             goto out;
 144
 145         /*
 146          * Compare the slot number (high word of Address) and pin number
 147          * (note that ACPI uses 0 for INTA) to check for a match.
 148          *
 149          * Note that the low word of the Address field (function number)
 150          * is required by the specification to be 0xffff.  We don't risk
 151          * checking it here.
 152          */
 153         if (((prt->Address & 0xffff0000) >> 16) == pci_get_slot(dev) &&
 154             prt->Pin == pin) {
 155             if (bootverbose)
 156                 device_printf(pcib, "matched entry for %d.%d.INT%c (src %s)\n",
 157                               pci_get_bus(dev), pci_get_slot(dev), 'A' + pin,
 158                               prt->Source);
 159             break;
 160         }
 161
 162         /* Skip to the next entry. */
 163         prtp += prt->Length;
 164     }
 165
 166     /*
 167      * If source is empty/NULL, the source index is the global IRQ number.
 168      */
 169     if (prt->Source == NULL || prt->Source[0] == '\0') {
 170         if (bootverbose)
 171             device_printf(pcib, "device is hardwired to IRQ %d\n",
 172                           prt->SourceIndex);
 173         interrupt = prt->SourceIndex;
 174         goto out;
 175     }
 176
 177     /*
 178      * We have to find the source device (PCI interrupt link device).
 179      */
 180     if (ACPI_FAILURE(AcpiGetHandle(ACPI_ROOT_OBJECT, prt->Source, &lnkdev))) {
 181         device_printf(pcib, "couldn't find PCI interrupt link device %s\n",
 182                       prt->Source);
 183         goto out;
 184     }
 185
 186     /*
 187      * Verify that this is a PCI link device and that it's present.
 188      */
 189     buf.Length = ACPI_ALLOCATE_BUFFER;
 190     if (ACPI_FAILURE(AcpiGetObjectInfo(lnkdev, &buf))) {
 191         device_printf(pcib, "couldn't validate PCI interrupt link device %s\n",
 192                       prt->Source);
 193         goto out;
 194     }
 195     devinfo = (ACPI_DEVICE_INFO *)buf.Pointer;
 196     if ((devinfo->Valid & ACPI_VALID_HID) == 0 ||
 197         strcmp("PNP0C0F", devinfo->HardwareId.Value) != 0) {
 198         device_printf(pcib, "PCI interrupt link %s has invalid _HID (%s)\n",
 199                       prt->Source, devinfo->HardwareId.Value);
 200         goto out;
 201     }
 202     if ((devinfo->Valid & ACPI_VALID_STA) != 0 &&
 203         (devinfo->CurrentStatus & 0x9) != 0x9) {
 204         device_printf(pcib, "PCI interrupt link device %s not present\n",
 205                       prt->Source);
 206         goto out;
 207     }
 208
 209     /*
 210      * Get the current and possible resources for the interrupt link device.
 211      * If we fail to get the current resources, this is a fatal error.
 212      */
 213     crsbuf.Length = ACPI_ALLOCATE_BUFFER;
 214     if (ACPI_FAILURE(status = AcpiGetCurrentResources(lnkdev, &crsbuf))) {
 215         device_printf(pcib, "PCI interrupt link device _CRS failed - %s\n",
 216                       AcpiFormatException(status));
 217         goto out;
 218     }
 219     prsbuf.Length = ACPI_ALLOCATE_BUFFER;
 220     if (ACPI_FAILURE(status = AcpiGetPossibleResources(lnkdev, &prsbuf))) {
 221         device_printf(pcib, "PCI interrupt link device _PRS failed - %s\n",
 222                       AcpiFormatException(status));
 223     }
 224     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "got %ld bytes for %s._CRS\n",
 225                      (long)crsbuf.Length, acpi_name(lnkdev)));
 226     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "got %ld bytes for %s._PRS\n",
 227                      (long)prsbuf.Length, acpi_name(lnkdev)));
 228
 229     /*
 230      * The interrupt may already be routed, so check _CRS first.  We don't
 231      * check the 'decoding' bit in the _STA result, since there's nothing in
 232      * the spec that mandates it be set, however some BIOS' will set it if
 233      * the decode is active.
 234      *
 235      * The Source Index points to the particular resource entry we're
 236      * interested in.
 237      */
 238     if (ACPI_FAILURE(acpi_FindIndexedResource(&crsbuf, prt->SourceIndex,
 239         &crsres))) {
 240         device_printf(pcib, "_CRS buffer corrupt, cannot route interrupt\n");
 241         goto out;
 242     }
 243
 244     /* Type-check the resource we've found. */
 245     if (crsres->Id != ACPI_RSTYPE_IRQ && crsres->Id != ACPI_RSTYPE_EXT_IRQ) {
 246         device_printf(pcib, "_CRS resource entry has unsupported type %d\n",
 247                       crsres->Id);
 248         goto out;
 249     }
 250
 251     /* Set variables based on resource type. */
 252     if (crsres->Id == ACPI_RSTYPE_IRQ) {
 253         NumberOfInterrupts = crsres->Data.Irq.NumberOfInterrupts;
 254         Interrupts = crsres->Data.Irq.Interrupts;
 255     } else {
 256         NumberOfInterrupts = crsres->Data.ExtendedIrq.NumberOfInterrupts;
 257         Interrupts = crsres->Data.ExtendedIrq.Interrupts;
 258     }
 259
 260     /* If there's more than one interrupt, this is an error. */
 261     if (NumberOfInterrupts > 1) {
 262         device_printf(pcib, "device has too many interrupts (%d)\n",
 263                       NumberOfInterrupts);
 264         goto out;
 265     }
 266
 267     /*
 268      * If there's only one interrupt, and it's not zero, then it's already
 269      * routed.
 270      *
 271      * Note that we could also check the 'decoding' bit in _STA, but can't
 272      * depend on it since it's not part of the spec.
 273      *
 274      * XXX check ASL examples to see if this is an acceptable set of tests
 275      */
 276     if (NumberOfInterrupts == 1 && Interrupts[0] != 0) {
 277         device_printf(pcib, "slot %d INT%c is routed to irq %d\n",
 278                       pci_get_slot(dev), 'A' + pin, Interrupts[0]);
 279         interrupt = Interrupts[0];
 280         goto out;
 281     }
 282
 283     /*
 284      * There isn't an interrupt, so we have to look at _PRS to get one.
 285      * Get the set of allowed interrupts from the _PRS resource indexed
 286      * by SourceIndex.
 287      */
 288     if (prsbuf.Pointer == NULL) {
 289         device_printf(pcib, "no routed irq and no _PRS on irq link device\n");
 290         goto out;
 291     }
 292
 293     /*
 294      * Search through the _PRS resources, looking for an IRQ or extended
 295      * IRQ resource.  Skip dependent function resources for now.  In the
 296      * future, we might use these for priority but this is good enough for
 297      * now until BIOS vendors actually mean something by using them.
 298      */
 299     prsres = NULL;
 300     for (i = prt->SourceIndex; prsres == NULL; i++) {
 301         if (ACPI_FAILURE(acpi_FindIndexedResource(&prsbuf, i, &prsres))) {
 302             device_printf(pcib, "_PRS lacks IRQ resource, routing failed\n");
 303             goto out;
 304         }
 305         switch (prsres->Id) {
 306         case ACPI_RSTYPE_IRQ:
 307             NumberOfInterrupts = prsres->Data.Irq.NumberOfInterrupts;
 308             Interrupts = prsres->Data.Irq.Interrupts;
 309             break;
 310         case ACPI_RSTYPE_EXT_IRQ:
 311             NumberOfInterrupts = prsres->Data.ExtendedIrq.NumberOfInterrupts;
 312             Interrupts = prsres->Data.ExtendedIrq.Interrupts;
 313             break;
 314         case ACPI_RSTYPE_START_DPF:
 315             prsres = NULL;
 316             continue;
 317         default:
 318             device_printf(pcib, "_PRS has invalid type %d\n", prsres->Id);
 319             goto out;
 320         }
 321     }
 322
 323     /* There has to be at least one interrupt available. */
 324     if (NumberOfInterrupts < 1) {
 325         device_printf(pcib, "device has no interrupts\n");
 326         goto out;
 327     }
 328
 329     /*
 330      * Pick an interrupt to use.  Note that a more scientific approach than
 331      * just taking the first one available would be desirable.
 332      *
 333      * The PCI BIOS $PIR table offers "preferred PCI interrupts", but ACPI
 334      * doesn't seem to offer a similar mechanism, so picking a "good"
 335      * interrupt here is a difficult task.
 336      *
 337      * Build a resource buffer and pass it to AcpiSetCurrentResources to
 338      * route the new interrupt.
 339      */
 340     device_printf(pcib, "possible interrupts:");
 341     for (i = 0; i < NumberOfInterrupts; i++)
 342         kprintf("  %d", Interrupts[i]);
 343     kprintf("\n");
 344
 345     /* This should never happen. */
 346     if (crsbuf.Pointer != NULL)
 347         AcpiOsFree(crsbuf.Pointer);
 348
 349     /* XXX Data.Irq and Data.ExtendedIrq are implicitly structure-copied. */
 350     crsbuf.Pointer = NULL;
 351     if (prsres->Id == ACPI_RSTYPE_IRQ) {
 352         resbuf.Id = ACPI_RSTYPE_IRQ;
 353         resbuf.Length = ACPI_SIZEOF_RESOURCE(ACPI_RESOURCE_IRQ);
 354         resbuf.Data.Irq = prsres->Data.Irq;
 355         resbuf.Data.Irq.NumberOfInterrupts = 1;
 356         resbuf.Data.Irq.Interrupts[0] = Interrupts[0];
 357     } else {
 358         resbuf.Id = ACPI_RSTYPE_EXT_IRQ;
 359         resbuf.Length = ACPI_SIZEOF_RESOURCE(ACPI_RESOURCE_EXT_IRQ);
 360         resbuf.Data.ExtendedIrq = prsres->Data.ExtendedIrq;
 361         resbuf.Data.ExtendedIrq.NumberOfInterrupts = 1;
 362         resbuf.Data.ExtendedIrq.Interrupts[0] = Interrupts[0];
 363     }
 364     if (ACPI_FAILURE(status = acpi_AppendBufferResource(&crsbuf, &resbuf))) {
 365         device_printf(pcib, "buf append failed for interrupt %d via %s - %s\n",
 366                       Interrupts[0], acpi_name(lnkdev),
 367                       AcpiFormatException(status));
 368         goto out;
 369     }
 370     /* XXX Figure out how this is happening when the append succeeds. */
 371     if (crsbuf.Pointer == NULL) {
 372         device_printf(pcib, "_CRS buf NULL after append?\n");
 373         goto out;
 374     }
 375     if (ACPI_FAILURE(status = AcpiSetCurrentResources(lnkdev, &crsbuf))) {
 376         device_printf(pcib, "_SRS failed for interrupt %d via %s - %s\n",
 377                       Interrupts[0], acpi_name(lnkdev),
 378                       AcpiFormatException(status));
 379         goto out;
 380     }
 381
 382     /* Return the interrupt we just routed. */
 383     device_printf(pcib, "slot %d INT%c routed to irq %d via %s\n",
 384                   pci_get_slot(dev), 'A' + pin, Interrupts[0],
 385                   acpi_name(lnkdev));
 386     interrupt = Interrupts[0];
 387
 388 out:
 389     if (crsbuf.Pointer != NULL)
 390         AcpiOsFree(crsbuf.Pointer);
 391     if (prsbuf.Pointer != NULL)
 392         AcpiOsFree(prsbuf.Pointer);
 393     if (buf.Pointer != NULL)
 394         AcpiOsFree(buf.Pointer);
 395
 396     /* XXX APIC_IO interrupt mapping? */
 397     return_VALUE (interrupt);
 398 }