sys/bus/pci/pci.c

   1 /*-
   2  * Copyright (c) 1997, Stefan Esser <se@kfreebsd.org>
   3  * Copyright (c) 2000, Michael Smith <msmith@kfreebsd.org>
   4  * Copyright (c) 2000, BSDi
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions, and the following
  12  *    disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/dev/pci/pci.c,v 1.355.2.9.2.1 2009/04/15 03:14:26 kensmith Exp $
  29  */
  30
  31 #include "opt_bus.h"
  32 #include "opt_compat_oldpci.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/malloc.h>
  37 #include <sys/module.h>
  38 #include <sys/linker.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/conf.h>
  41 #include <sys/kernel.h>
  42 #include <sys/queue.h>
  43 #include <sys/sysctl.h>
  44 #include <sys/endian.h>
  45
  46 #ifdef APIC_IO
  47 #include <machine/smp.h>
  48 #endif
  49
  50 #include <vm/vm.h>
  51 #include <vm/pmap.h>
  52 #include <vm/vm_extern.h>
  53
  54 #include <sys/bus.h>
  55 #include <sys/rman.h>
  56 #include <sys/device.h>
  57
  58 #include <sys/pciio.h>
  59 #include <bus/pci/pcireg.h>
  60 #include <bus/pci/pcivar.h>
  61 #include <bus/pci/pci_private.h>
  62
  63 #include "pcib_if.h"
  64 #include "pci_if.h"
  65
  66 #ifdef __HAVE_ACPI
  67 #include <contrib/dev/acpica/acpi.h>
  68 #include "acpi_if.h"
  69 #else
  70 #define ACPI_PWR_FOR_SLEEP(x, y, z)
  71 #endif
  72
  73 extern struct dev_ops pcic_ops; /* XXX */
  74
  75 typedef void    (*pci_read_cap_t)(device_t, int, int, pcicfgregs *);
  76
  77 static uint32_t         pci_mapbase(unsigned mapreg);
  78 static const char       *pci_maptype(unsigned mapreg);
  79 static int              pci_mapsize(unsigned testval);
  80 static int              pci_maprange(unsigned mapreg);
  81 static void             pci_fixancient(pcicfgregs *cfg);
  82
  83 static int              pci_porten(device_t pcib, int b, int s, int f);
  84 static int              pci_memen(device_t pcib, int b, int s, int f);
  85 static void             pci_assign_interrupt(device_t bus, device_t dev,
  86                             int force_route);
  87 static int              pci_add_map(device_t pcib, device_t bus, device_t dev,
  88                             int b, int s, int f, int reg,
  89                             struct resource_list *rl, int force, int prefetch);
  90 static int              pci_probe(device_t dev);
  91 static int              pci_attach(device_t dev);
  92 static void             pci_child_detached(device_t, device_t);
  93 static void             pci_load_vendor_data(void);
  94 static int              pci_describe_parse_line(char **ptr, int *vendor,
  95                             int *device, char **desc);
  96 static char             *pci_describe_device(device_t dev);
  97 static int              pci_modevent(module_t mod, int what, void *arg);
  98 static void             pci_hdrtypedata(device_t pcib, int b, int s, int f,
  99                             pcicfgregs *cfg);
 100 static void             pci_read_capabilities(device_t pcib, pcicfgregs *cfg);
 101 static int              pci_read_vpd_reg(device_t pcib, pcicfgregs *cfg,
 102                             int reg, uint32_t *data);
 103 #if 0
 104 static int              pci_write_vpd_reg(device_t pcib, pcicfgregs *cfg,
 105                             int reg, uint32_t data);
 106 #endif
 107 static void             pci_read_vpd(device_t pcib, pcicfgregs *cfg);
 108 static void             pci_disable_msi(device_t dev);
 109 static void             pci_enable_msi(device_t dev, uint64_t address,
 110                             uint16_t data);
 111 static void             pci_enable_msix(device_t dev, u_int index,
 112                             uint64_t address, uint32_t data);
 113 static void             pci_mask_msix(device_t dev, u_int index);
 114 static void             pci_unmask_msix(device_t dev, u_int index);
 115 static int              pci_msi_blacklisted(void);
 116 static void             pci_resume_msi(device_t dev);
 117 static void             pci_resume_msix(device_t dev);
 118 static int              pcie_slotimpl(const pcicfgregs *);
 119 static void             pci_print_verbose_expr(const pcicfgregs *);
 120
 121 static void             pci_read_cap_pmgt(device_t, int, int, pcicfgregs *);
 122 static void             pci_read_cap_ht(device_t, int, int, pcicfgregs *);
 123 static void             pci_read_cap_msi(device_t, int, int, pcicfgregs *);
 124 static void             pci_read_cap_msix(device_t, int, int, pcicfgregs *);
 125 static void             pci_read_cap_vpd(device_t, int, int, pcicfgregs *);
 126 static void             pci_read_cap_subvendor(device_t, int, int,
 127                             pcicfgregs *);
 128 static void             pci_read_cap_pcix(device_t, int, int, pcicfgregs *);
 129 static void             pci_read_cap_express(device_t, int, int, pcicfgregs *);
 130
 131 static device_method_t pci_methods[] = {
 132         /* Device interface */
 133         DEVMETHOD(device_probe,         pci_probe),
 134         DEVMETHOD(device_attach,        pci_attach),
 135         DEVMETHOD(device_detach,        bus_generic_detach),
 136         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 137         DEVMETHOD(device_suspend,       pci_suspend),
 138         DEVMETHOD(device_resume,        pci_resume),
 139
 140         /* Bus interface */
 141         DEVMETHOD(bus_print_child,      pci_print_child),
 142         DEVMETHOD(bus_probe_nomatch,    pci_probe_nomatch),
 143         DEVMETHOD(bus_read_ivar,        pci_read_ivar),
 144         DEVMETHOD(bus_write_ivar,       pci_write_ivar),
 145         DEVMETHOD(bus_driver_added,     pci_driver_added),
 146         DEVMETHOD(bus_child_detached,   pci_child_detached),
 147         DEVMETHOD(bus_setup_intr,       pci_setup_intr),
 148         DEVMETHOD(bus_teardown_intr,    pci_teardown_intr),
 149
 150         DEVMETHOD(bus_get_resource_list,pci_get_resource_list),
 151         DEVMETHOD(bus_set_resource,     bus_generic_rl_set_resource),
 152         DEVMETHOD(bus_get_resource,     bus_generic_rl_get_resource),
 153         DEVMETHOD(bus_delete_resource,  pci_delete_resource),
 154         DEVMETHOD(bus_alloc_resource,   pci_alloc_resource),
 155         DEVMETHOD(bus_release_resource, bus_generic_rl_release_resource),
 156         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 157         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 158         DEVMETHOD(bus_child_pnpinfo_str, pci_child_pnpinfo_str_method),
 159         DEVMETHOD(bus_child_location_str, pci_child_location_str_method),
 160
 161         /* PCI interface */
 162         DEVMETHOD(pci_read_config,      pci_read_config_method),
 163         DEVMETHOD(pci_write_config,     pci_write_config_method),
 164         DEVMETHOD(pci_enable_busmaster, pci_enable_busmaster_method),
 165         DEVMETHOD(pci_disable_busmaster, pci_disable_busmaster_method),
 166         DEVMETHOD(pci_enable_io,        pci_enable_io_method),
 167         DEVMETHOD(pci_disable_io,       pci_disable_io_method),
 168         DEVMETHOD(pci_get_vpd_ident,    pci_get_vpd_ident_method),
 169         DEVMETHOD(pci_get_vpd_readonly, pci_get_vpd_readonly_method),
 170         DEVMETHOD(pci_get_powerstate,   pci_get_powerstate_method),
 171         DEVMETHOD(pci_set_powerstate,   pci_set_powerstate_method),
 172         DEVMETHOD(pci_assign_interrupt, pci_assign_interrupt_method),
 173         DEVMETHOD(pci_find_extcap,      pci_find_extcap_method),
 174         DEVMETHOD(pci_alloc_msi,        pci_alloc_msi_method),
 175         DEVMETHOD(pci_alloc_msix,       pci_alloc_msix_method),
 176         DEVMETHOD(pci_remap_msix,       pci_remap_msix_method),
 177         DEVMETHOD(pci_release_msi,      pci_release_msi_method),
 178         DEVMETHOD(pci_msi_count,        pci_msi_count_method),
 179         DEVMETHOD(pci_msix_count,       pci_msix_count_method),
 180
 181         { 0, 0 }
 182 };
 183
 184 DEFINE_CLASS_0(pci, pci_driver, pci_methods, 0);
 185
 186 static devclass_t pci_devclass;
 187 DRIVER_MODULE(pci, pcib, pci_driver, pci_devclass, pci_modevent, 0);
 188 MODULE_VERSION(pci, 1);
 189
 190 static char     *pci_vendordata;
 191 static size_t   pci_vendordata_size;
 192
 193
 194 static const struct pci_read_cap {
 195         int             cap;
 196         pci_read_cap_t  read_cap;
 197 } pci_read_caps[] = {
 198         { PCIY_PMG,             pci_read_cap_pmgt },
 199         { PCIY_HT,              pci_read_cap_ht },
 200         { PCIY_MSI,             pci_read_cap_msi },
 201         { PCIY_MSIX,            pci_read_cap_msix },
 202         { PCIY_VPD,             pci_read_cap_vpd },
 203         { PCIY_SUBVENDOR,       pci_read_cap_subvendor },
 204         { PCIY_PCIX,            pci_read_cap_pcix },
 205         { PCIY_EXPRESS,         pci_read_cap_express },
 206         { 0, NULL } /* required last entry */
 207 };
 208
 209 struct pci_quirk {
 210         uint32_t devid; /* Vendor/device of the card */
 211         int     type;
 212 #define PCI_QUIRK_MAP_REG       1 /* PCI map register in weird place */
 213 #define PCI_QUIRK_DISABLE_MSI   2 /* MSI/MSI-X doesn't work */
 214         int     arg1;
 215         int     arg2;
 216 };
 217
 218 struct pci_quirk pci_quirks[] = {
 219         /* The Intel 82371AB and 82443MX has a map register at offset 0x90. */
 220         { 0x71138086, PCI_QUIRK_MAP_REG,        0x90,    0 },
 221         { 0x719b8086, PCI_QUIRK_MAP_REG,        0x90,    0 },
 222         /* As does the Serverworks OSB4 (the SMBus mapping register) */
 223         { 0x02001166, PCI_QUIRK_MAP_REG,        0x90,    0 },
 224
 225         /*
 226          * MSI doesn't work with the ServerWorks CNB20-HE Host Bridge
 227          * or the CMIC-SL (AKA ServerWorks GC_LE).
 228          */
 229         { 0x00141166, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 230         { 0x00171166, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 231
 232         /*
 233          * MSI doesn't work on earlier Intel chipsets including
 234          * E7500, E7501, E7505, 845, 865, 875/E7210, and 855.
 235          */
 236         { 0x25408086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 237         { 0x254c8086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 238         { 0x25508086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 239         { 0x25608086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 240         { 0x25708086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 241         { 0x25788086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 242         { 0x35808086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 243
 244         /*
 245          * MSI doesn't work with devices behind the AMD 8131 HT-PCIX
 246          * bridge.
 247          */
 248         { 0x74501022, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 249
 250         { 0 }
 251 };
 252
 253 /* map register information */
 254 #define PCI_MAPMEM      0x01    /* memory map */
 255 #define PCI_MAPMEMP     0x02    /* prefetchable memory map */
 256 #define PCI_MAPPORT     0x04    /* port map */
 257
 258 struct devlist pci_devq;
 259 uint32_t pci_generation;
 260 uint32_t pci_numdevs = 0;
 261 static int pcie_chipset, pcix_chipset;
 262
 263 /* sysctl vars */
 264 SYSCTL_NODE(_hw, OID_AUTO, pci, CTLFLAG_RD, 0, "PCI bus tuning parameters");
 265
 266 static int pci_enable_io_modes = 1;
 267 TUNABLE_INT("hw.pci.enable_io_modes", &pci_enable_io_modes);
 268 SYSCTL_INT(_hw_pci, OID_AUTO, enable_io_modes, CTLFLAG_RW,
 269     &pci_enable_io_modes, 1,
 270     "Enable I/O and memory bits in the config register.  Some BIOSes do not\n\
 271 enable these bits correctly.  We'd like to do this all the time, but there\n\
 272 are some peripherals that this causes problems with.");
 273
 274 static int pci_do_power_nodriver = 0;
 275 TUNABLE_INT("hw.pci.do_power_nodriver", &pci_do_power_nodriver);
 276 SYSCTL_INT(_hw_pci, OID_AUTO, do_power_nodriver, CTLFLAG_RW,
 277     &pci_do_power_nodriver, 0,
 278   "Place a function into D3 state when no driver attaches to it.  0 means\n\
 279 disable.  1 means conservatively place devices into D3 state.  2 means\n\
 280 aggressively place devices into D3 state.  3 means put absolutely everything\n\
 281 in D3 state.");
 282
 283 static int pci_do_power_resume = 1;
 284 TUNABLE_INT("hw.pci.do_power_resume", &pci_do_power_resume);
 285 SYSCTL_INT(_hw_pci, OID_AUTO, do_power_resume, CTLFLAG_RW,
 286     &pci_do_power_resume, 1,
 287   "Transition from D3 -> D0 on resume.");
 288
 289 static int pci_do_msi = 1;
 290 TUNABLE_INT("hw.pci.enable_msi", &pci_do_msi);
 291 SYSCTL_INT(_hw_pci, OID_AUTO, enable_msi, CTLFLAG_RW, &pci_do_msi, 1,
 292     "Enable support for MSI interrupts");
 293
 294 static int pci_do_msix = 1;
 295 TUNABLE_INT("hw.pci.enable_msix", &pci_do_msix);
 296 SYSCTL_INT(_hw_pci, OID_AUTO, enable_msix, CTLFLAG_RW, &pci_do_msix, 1,
 297     "Enable support for MSI-X interrupts");
 298
 299 static int pci_honor_msi_blacklist = 1;
 300 TUNABLE_INT("hw.pci.honor_msi_blacklist", &pci_honor_msi_blacklist);
 301 SYSCTL_INT(_hw_pci, OID_AUTO, honor_msi_blacklist, CTLFLAG_RD,
 302     &pci_honor_msi_blacklist, 1, "Honor chipset blacklist for MSI");
 303
 304 /* Find a device_t by bus/slot/function in domain 0 */
 305
 306 device_t
 307 pci_find_bsf(uint8_t bus, uint8_t slot, uint8_t func)
 308 {
 309
 310         return (pci_find_dbsf(0, bus, slot, func));
 311 }
 312
 313 /* Find a device_t by domain/bus/slot/function */
 314
 315 device_t
 316 pci_find_dbsf(uint32_t domain, uint8_t bus, uint8_t slot, uint8_t func)
 317 {
 318         struct pci_devinfo *dinfo;
 319
 320         STAILQ_FOREACH(dinfo, &pci_devq, pci_links) {
 321                 if ((dinfo->cfg.domain == domain) &&
 322                     (dinfo->cfg.bus == bus) &&
 323                     (dinfo->cfg.slot == slot) &&
 324                     (dinfo->cfg.func == func)) {
 325                         return (dinfo->cfg.dev);
 326                 }
 327         }
 328
 329         return (NULL);
 330 }
 331
 332 /* Find a device_t by vendor/device ID */
 333
 334 device_t
 335 pci_find_device(uint16_t vendor, uint16_t device)
 336 {
 337         struct pci_devinfo *dinfo;
 338
 339         STAILQ_FOREACH(dinfo, &pci_devq, pci_links) {
 340                 if ((dinfo->cfg.vendor == vendor) &&
 341                     (dinfo->cfg.device == device)) {
 342                         return (dinfo->cfg.dev);
 343                 }
 344         }
 345
 346         return (NULL);
 347 }
 348
 349 /* return base address of memory or port map */
 350
 351 static uint32_t
 352 pci_mapbase(uint32_t mapreg)
 353 {
 354
 355         if (PCI_BAR_MEM(mapreg))
 356                 return (mapreg & PCIM_BAR_MEM_BASE);
 357         else
 358                 return (mapreg & PCIM_BAR_IO_BASE);
 359 }
 360
 361 /* return map type of memory or port map */
 362
 363 static const char *
 364 pci_maptype(unsigned mapreg)
 365 {
 366
 367         if (PCI_BAR_IO(mapreg))
 368                 return ("I/O Port");
 369         if (mapreg & PCIM_BAR_MEM_PREFETCH)
 370                 return ("Prefetchable Memory");
 371         return ("Memory");
 372 }
 373
 374 /* return log2 of map size decoded for memory or port map */
 375
 376 static int
 377 pci_mapsize(uint32_t testval)
 378 {
 379         int ln2size;
 380
 381         testval = pci_mapbase(testval);
 382         ln2size = 0;
 383         if (testval != 0) {
 384                 while ((testval & 1) == 0)
 385                 {
 386                         ln2size++;
 387                         testval >>= 1;
 388                 }
 389         }
 390         return (ln2size);
 391 }
 392
 393 /* return log2 of address range supported by map register */
 394
 395 static int
 396 pci_maprange(unsigned mapreg)
 397 {
 398         int ln2range = 0;
 399
 400         if (PCI_BAR_IO(mapreg))
 401                 ln2range = 32;
 402         else
 403                 switch (mapreg & PCIM_BAR_MEM_TYPE) {
 404                 case PCIM_BAR_MEM_32:
 405                         ln2range = 32;
 406                         break;
 407                 case PCIM_BAR_MEM_1MB:
 408                         ln2range = 20;
 409                         break;
 410                 case PCIM_BAR_MEM_64:
 411                         ln2range = 64;
 412                         break;
 413                 }
 414         return (ln2range);
 415 }
 416
 417 /* adjust some values from PCI 1.0 devices to match 2.0 standards ... */
 418
 419 static void
 420 pci_fixancient(pcicfgregs *cfg)
 421 {
 422         if (cfg->hdrtype != 0)
 423                 return;
 424
 425         /* PCI to PCI bridges use header type 1 */
 426         if (cfg->baseclass == PCIC_BRIDGE && cfg->subclass == PCIS_BRIDGE_PCI)
 427                 cfg->hdrtype = 1;
 428 }
 429
 430 /* extract header type specific config data */
 431
 432 static void
 433 pci_hdrtypedata(device_t pcib, int b, int s, int f, pcicfgregs *cfg)
 434 {
 435 #define REG(n, w)       PCIB_READ_CONFIG(pcib, b, s, f, n, w)
 436         switch (cfg->hdrtype) {
 437         case 0:
 438                 cfg->subvendor      = REG(PCIR_SUBVEND_0, 2);
 439                 cfg->subdevice      = REG(PCIR_SUBDEV_0, 2);
 440                 cfg->nummaps        = PCI_MAXMAPS_0;
 441                 break;
 442         case 1:
 443                 cfg->nummaps        = PCI_MAXMAPS_1;
 444 #ifdef COMPAT_OLDPCI
 445                 cfg->secondarybus   = REG(PCIR_SECBUS_1, 1);
 446 #endif
 447                 break;
 448         case 2:
 449                 cfg->subvendor      = REG(PCIR_SUBVEND_2, 2);
 450                 cfg->subdevice      = REG(PCIR_SUBDEV_2, 2);
 451                 cfg->nummaps        = PCI_MAXMAPS_2;
 452 #ifdef COMPAT_OLDPCI
 453                 cfg->secondarybus   = REG(PCIR_SECBUS_2, 1);
 454 #endif
 455                 break;
 456         }
 457 #undef REG
 458 }
 459
 460 /* read configuration header into pcicfgregs structure */
 461 struct pci_devinfo *
 462 pci_read_device(device_t pcib, int d, int b, int s, int f, size_t size)
 463 {
 464 #define REG(n, w)       PCIB_READ_CONFIG(pcib, b, s, f, n, w)
 465         pcicfgregs *cfg = NULL;
 466         struct pci_devinfo *devlist_entry;
 467         struct devlist *devlist_head;
 468
 469         devlist_head = &pci_devq;
 470
 471         devlist_entry = NULL;
 472
 473         if (REG(PCIR_DEVVENDOR, 4) != -1) {
 474                 devlist_entry = kmalloc(size, M_DEVBUF, M_WAITOK | M_ZERO);
 475
 476                 cfg = &devlist_entry->cfg;
 477
 478                 cfg->domain             = d;
 479                 cfg->bus                = b;
 480                 cfg->slot               = s;
 481                 cfg->func               = f;
 482                 cfg->vendor             = REG(PCIR_VENDOR, 2);
 483                 cfg->device             = REG(PCIR_DEVICE, 2);
 484                 cfg->cmdreg             = REG(PCIR_COMMAND, 2);
 485                 cfg->statreg            = REG(PCIR_STATUS, 2);
 486                 cfg->baseclass          = REG(PCIR_CLASS, 1);
 487                 cfg->subclass           = REG(PCIR_SUBCLASS, 1);
 488                 cfg->progif             = REG(PCIR_PROGIF, 1);
 489                 cfg->revid              = REG(PCIR_REVID, 1);
 490                 cfg->hdrtype            = REG(PCIR_HDRTYPE, 1);
 491                 cfg->cachelnsz          = REG(PCIR_CACHELNSZ, 1);
 492                 cfg->lattimer           = REG(PCIR_LATTIMER, 1);
 493                 cfg->intpin             = REG(PCIR_INTPIN, 1);
 494                 cfg->intline            = REG(PCIR_INTLINE, 1);
 495
 496 #ifdef APIC_IO
 497                 /*
 498                  * If using the APIC the intpin is probably wrong, since it
 499                  * is often setup by the BIOS with the PIC in mind.
 500                  */
 501                 if (cfg->intpin != 0) {
 502                         int airq;
 503
 504                         airq = pci_apic_irq(cfg->bus, cfg->slot, cfg->intpin);
 505                         if (airq >= 0) {
 506                                 /* PCI specific entry found in MP table */
 507                                 if (airq != cfg->intline) {
 508                                         undirect_pci_irq(cfg->intline);
 509                                         cfg->intline = airq;
 510                                 }
 511                         } else {
 512                                 /*
 513                                  * PCI interrupts might be redirected to the
 514                                  * ISA bus according to some MP tables. Use the
 515                                  * same methods as used by the ISA devices
 516                                  * devices to find the proper IOAPIC int pin.
 517                                  */
 518                                 airq = isa_apic_irq(cfg->intline);
 519                                 if ((airq >= 0) && (airq != cfg->intline)) {
 520                                         /* XXX: undirect_pci_irq() ? */
 521                                         undirect_isa_irq(cfg->intline);
 522                                         cfg->intline = airq;
 523                                 }
 524                         }
 525                 }
 526 #endif /* APIC_IO */
 527
 528                 cfg->mingnt             = REG(PCIR_MINGNT, 1);
 529                 cfg->maxlat             = REG(PCIR_MAXLAT, 1);
 530
 531                 cfg->mfdev              = (cfg->hdrtype & PCIM_MFDEV) != 0;
 532                 cfg->hdrtype            &= ~PCIM_MFDEV;
 533
 534                 pci_fixancient(cfg);
 535                 pci_hdrtypedata(pcib, b, s, f, cfg);
 536
 537                 pci_read_capabilities(pcib, cfg);
 538
 539                 STAILQ_INSERT_TAIL(devlist_head, devlist_entry, pci_links);
 540
 541                 devlist_entry->conf.pc_sel.pc_domain = cfg->domain;
 542                 devlist_entry->conf.pc_sel.pc_bus = cfg->bus;
 543                 devlist_entry->conf.pc_sel.pc_dev = cfg->slot;
 544                 devlist_entry->conf.pc_sel.pc_func = cfg->func;
 545                 devlist_entry->conf.pc_hdr = cfg->hdrtype;
 546
 547                 devlist_entry->conf.pc_subvendor = cfg->subvendor;
 548                 devlist_entry->conf.pc_subdevice = cfg->subdevice;
 549                 devlist_entry->conf.pc_vendor = cfg->vendor;
 550                 devlist_entry->conf.pc_device = cfg->device;
 551
 552                 devlist_entry->conf.pc_class = cfg->baseclass;
 553                 devlist_entry->conf.pc_subclass = cfg->subclass;
 554                 devlist_entry->conf.pc_progif = cfg->progif;
 555                 devlist_entry->conf.pc_revid = cfg->revid;
 556
 557                 pci_numdevs++;
 558                 pci_generation++;
 559         }
 560         return (devlist_entry);
 561 #undef REG
 562 }
 563
 564 static int
 565 pci_fixup_nextptr(int *nextptr0)
 566 {
 567         int nextptr = *nextptr0;
 568
 569         /* "Next pointer" is only one byte */
 570         KASSERT(nextptr <= 0xff, ("Illegal next pointer %d\n", nextptr));
 571
 572         if (nextptr & 0x3) {
 573                 /*
 574                  * PCI local bus spec 3.0:
 575                  *
 576                  * "... The bottom two bits of all pointers are reserved
 577                  *  and must be implemented as 00b although software must
 578                  *  mask them to allow for future uses of these bits ..."
 579                  */
 580                 if (bootverbose) {
 581                         kprintf("Illegal PCI extended capability "
 582                                 "offset, fixup 0x%02x -> 0x%02x\n",
 583                                 nextptr, nextptr & ~0x3);
 584                 }
 585                 nextptr &= ~0x3;
 586         }
 587         *nextptr0 = nextptr;
 588
 589         if (nextptr < 0x40) {
 590                 if (nextptr != 0) {
 591                         kprintf("Illegal PCI extended capability "
 592                                 "offset 0x%02x", nextptr);
 593                 }
 594                 return 0;
 595         }
 596         return 1;
 597 }
 598
 599 static void
 600 pci_read_cap_pmgt(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 601 {
 602 #define REG(n, w)       \
 603         PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 604
 605         struct pcicfg_pp *pp = &cfg->pp;
 606
 607         if (pp->pp_cap)
 608                 return;
 609
 610         pp->pp_cap = REG(ptr + PCIR_POWER_CAP, 2);
 611         pp->pp_status = ptr + PCIR_POWER_STATUS;
 612         pp->pp_pmcsr = ptr + PCIR_POWER_PMCSR;
 613
 614         if ((nextptr - ptr) > PCIR_POWER_DATA) {
 615                 /*
 616                  * XXX
 617                  * We should write to data_select and read back from
 618                  * data_scale to determine whether data register is
 619                  * implemented.
 620                  */
 621 #ifdef foo
 622                 pp->pp_data = ptr + PCIR_POWER_DATA;
 623 #else
 624                 pp->pp_data = 0;
 625 #endif
 626         }
 627
 628 #undef REG
 629 }
 630
 631 static void
 632 pci_read_cap_ht(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 633 {
 634 #ifdef notyet
 635 #if defined(__i386__) || defined(__amd64__)
 636
 637 #define REG(n, w)       \
 638         PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 639
 640         struct pcicfg_ht *ht = &cfg->ht;
 641         uint64_t addr;
 642         uint32_t val;
 643
 644         /* Determine HT-specific capability type. */
 645         val = REG(ptr + PCIR_HT_COMMAND, 2);
 646
 647         if ((val & PCIM_HTCMD_CAP_MASK) != PCIM_HTCAP_MSI_MAPPING)
 648                 return;
 649
 650         if (!(val & PCIM_HTCMD_MSI_FIXED)) {
 651                 /* Sanity check the mapping window. */
 652                 addr = REG(ptr + PCIR_HTMSI_ADDRESS_HI, 4);
 653                 addr <<= 32;
 654                 addr |= REG(ptr + PCIR_HTMSI_ADDRESS_LO, 4);
 655                 if (addr != MSI_INTEL_ADDR_BASE) {
 656                         device_printf(pcib, "HT Bridge at pci%d:%d:%d:%d "
 657                                 "has non-default MSI window 0x%llx\n",
 658                                 cfg->domain, cfg->bus, cfg->slot, cfg->func,
 659                                 (long long)addr);
 660                 }
 661         } else {
 662                 addr = MSI_INTEL_ADDR_BASE;
 663         }
 664
 665         ht->ht_msimap = ptr;
 666         ht->ht_msictrl = val;
 667         ht->ht_msiaddr = addr;
 668
 669 #undef REG
 670
 671 #endif  /* __i386__ || __amd64__ */
 672 #endif  /* notyet */
 673 }
 674
 675 static void
 676 pci_read_cap_msi(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 677 {
 678 #define REG(n, w)       \
 679         PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 680
 681         struct pcicfg_msi *msi = &cfg->msi;
 682
 683         msi->msi_location = ptr;
 684         msi->msi_ctrl = REG(ptr + PCIR_MSI_CTRL, 2);
 685         msi->msi_msgnum = 1 << ((msi->msi_ctrl & PCIM_MSICTRL_MMC_MASK) >> 1);
 686
 687 #undef REG
 688 }
 689
 690 static void
 691 pci_read_cap_msix(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 692 {
 693 #define REG(n, w)       \
 694         PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 695
 696         struct pcicfg_msix *msix = &cfg->msix;
 697         uint32_t val;
 698
 699         msix->msix_location = ptr;
 700         msix->msix_ctrl = REG(ptr + PCIR_MSIX_CTRL, 2);
 701         msix->msix_msgnum = (msix->msix_ctrl & PCIM_MSIXCTRL_TABLE_SIZE) + 1;
 702
 703         val = REG(ptr + PCIR_MSIX_TABLE, 4);
 704         msix->msix_table_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 705         msix->msix_table_offset = val & ~PCIM_MSIX_BIR_MASK;
 706
 707         val = REG(ptr + PCIR_MSIX_PBA, 4);
 708         msix->msix_pba_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 709         msix->msix_pba_offset = val & ~PCIM_MSIX_BIR_MASK;
 710
 711 #undef REG
 712 }
 713
 714 static void
 715 pci_read_cap_vpd(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 716 {
 717         cfg->vpd.vpd_reg = ptr;
 718 }
 719
 720 static void
 721 pci_read_cap_subvendor(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 722 {
 723 #define REG(n, w)       \
 724         PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 725
 726         /* Should always be true. */
 727         if ((cfg->hdrtype & PCIM_HDRTYPE) == 1) {
 728                 uint32_t val;
 729
 730                 val = REG(ptr + PCIR_SUBVENDCAP_ID, 4);
 731                 cfg->subvendor = val & 0xffff;
 732                 cfg->subdevice = val >> 16;
 733         }
 734
 735 #undef REG
 736 }
 737
 738 static void
 739 pci_read_cap_pcix(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 740 {
 741         /*
 742          * Assume we have a PCI-X chipset if we have
 743          * at least one PCI-PCI bridge with a PCI-X
 744          * capability.  Note that some systems with
 745          * PCI-express or HT chipsets might match on
 746          * this check as well.
 747          */
 748         if ((cfg->hdrtype & PCIM_HDRTYPE) == 1)
 749                 pcix_chipset = 1;
 750
 751         cfg->pcix.pcix_ptr = ptr;
 752 }
 753
 754 static int
 755 pcie_slotimpl(const pcicfgregs *cfg)
 756 {
 757         const struct pcicfg_expr *expr = &cfg->expr;
 758         uint16_t port_type;
 759
 760         /*
 761          * Only version 1 can be parsed currently
 762          */
 763         if ((expr->expr_cap & PCIEM_CAP_VER_MASK) != PCIEM_CAP_VER_1)
 764                 return 0;
 765
 766         /*
 767          * - Slot implemented bit is meaningful iff current port is
 768          *   root port or down stream port.
 769          * - Testing for root port or down stream port is meanningful
 770          *   iff PCI configure has type 1 header.
 771          */
 772
 773         if (cfg->hdrtype != 1)
 774                 return 0;
 775
 776         port_type = expr->expr_cap & PCIEM_CAP_PORT_TYPE;
 777         if (port_type != PCIE_ROOT_PORT && port_type != PCIE_DOWN_STREAM_PORT)
 778                 return 0;
 779
 780         if (!(expr->expr_cap & PCIEM_CAP_SLOT_IMPL))
 781                 return 0;
 782
 783         return 1;
 784 }
 785
 786 static void
 787 pci_read_cap_express(device_t pcib, int ptr, int nextptr, pcicfgregs *cfg)
 788 {
 789 #define REG(n, w)       \
 790         PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 791
 792         struct pcicfg_expr *expr = &cfg->expr;
 793
 794         /*
 795          * Assume we have a PCI-express chipset if we have
 796          * at least one PCI-express device.
 797          */
 798         pcie_chipset = 1;
 799
 800         expr->expr_ptr = ptr;
 801         expr->expr_cap = REG(ptr + PCIER_CAPABILITY, 2);
 802
 803         /*
 804          * Only version 1 can be parsed currently
 805          */
 806         if ((expr->expr_cap & PCIEM_CAP_VER_MASK) != PCIEM_CAP_VER_1)
 807                 return;
 808
 809         /*
 810          * Read slot capabilities.  Slot capabilities exists iff
 811          * current port's slot is implemented
 812          */
 813         if (pcie_slotimpl(cfg))
 814                 expr->expr_slotcap = REG(ptr + PCIER_SLOTCAP, 4);
 815
 816 #undef REG
 817 }
 818
 819 static void
 820 pci_read_capabilities(device_t pcib, pcicfgregs *cfg)
 821 {
 822 #define REG(n, w)       PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 823 #define WREG(n, v, w)   PCIB_WRITE_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, v, w)
 824
 825         uint32_t val;
 826         int nextptr, ptrptr;
 827
 828         if ((REG(PCIR_STATUS, 2) & PCIM_STATUS_CAPPRESENT) == 0) {
 829                 /* No capabilities */
 830                 return;
 831         }
 832
 833         switch (cfg->hdrtype & PCIM_HDRTYPE) {
 834         case 0:
 835         case 1:
 836                 ptrptr = PCIR_CAP_PTR;
 837                 break;
 838         case 2:
 839                 ptrptr = PCIR_CAP_PTR_2;        /* cardbus capabilities ptr */
 840                 break;
 841         default:
 842                 return;                         /* no capabilities support */
 843         }
 844         nextptr = REG(ptrptr, 1);       /* sanity check? */
 845
 846         /*
 847          * Read capability entries.
 848          */
 849         while (pci_fixup_nextptr(&nextptr)) {
 850                 const struct pci_read_cap *rc;
 851                 int ptr = nextptr;
 852
 853                 /* Find the next entry */
 854                 nextptr = REG(ptr + PCICAP_NEXTPTR, 1);
 855
 856                 /* Process this entry */
 857                 val = REG(ptr + PCICAP_ID, 1);
 858                 for (rc = pci_read_caps; rc->read_cap != NULL; ++rc) {
 859                         if (rc->cap == val) {
 860                                 rc->read_cap(pcib, ptr, nextptr, cfg);
 861                                 break;
 862                         }
 863                 }
 864         }
 865 /* REG and WREG use carry through to next functions */
 866 }
 867
 868 /*
 869  * PCI Vital Product Data
 870  */
 871
 872 #define PCI_VPD_TIMEOUT         1000000
 873
 874 static int
 875 pci_read_vpd_reg(device_t pcib, pcicfgregs *cfg, int reg, uint32_t *data)
 876 {
 877         int count = PCI_VPD_TIMEOUT;
 878
 879         KASSERT((reg & 3) == 0, ("VPD register must by 4 byte aligned"));
 880
 881         WREG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, reg, 2);
 882
 883         while ((REG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, 2) & 0x8000) != 0x8000) {
 884                 if (--count < 0)
 885                         return (ENXIO);
 886                 DELAY(1);       /* limit looping */
 887         }
 888         *data = (REG(cfg->vpd.vpd_reg + PCIR_VPD_DATA, 4));
 889
 890         return (0);
 891 }
 892
 893 #if 0
 894 static int
 895 pci_write_vpd_reg(device_t pcib, pcicfgregs *cfg, int reg, uint32_t data)
 896 {
 897         int count = PCI_VPD_TIMEOUT;
 898
 899         KASSERT((reg & 3) == 0, ("VPD register must by 4 byte aligned"));
 900
 901         WREG(cfg->vpd.vpd_reg + PCIR_VPD_DATA, data, 4);
 902         WREG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, reg | 0x8000, 2);
 903         while ((REG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, 2) & 0x8000) == 0x8000) {
 904                 if (--count < 0)
 905                         return (ENXIO);
 906                 DELAY(1);       /* limit looping */
 907         }
 908
 909         return (0);
 910 }
 911 #endif
 912
 913 #undef PCI_VPD_TIMEOUT
 914
 915 struct vpd_readstate {
 916         device_t        pcib;
 917         pcicfgregs      *cfg;
 918         uint32_t        val;
 919         int             bytesinval;
 920         int             off;
 921         uint8_t         cksum;
 922 };
 923
 924 static int
 925 vpd_nextbyte(struct vpd_readstate *vrs, uint8_t *data)
 926 {
 927         uint32_t reg;
 928         uint8_t byte;
 929
 930         if (vrs->bytesinval == 0) {
 931                 if (pci_read_vpd_reg(vrs->pcib, vrs->cfg, vrs->off, &reg))
 932                         return (ENXIO);
 933                 vrs->val = le32toh(reg);
 934                 vrs->off += 4;
 935                 byte = vrs->val & 0xff;
 936                 vrs->bytesinval = 3;
 937         } else {
 938                 vrs->val = vrs->val >> 8;
 939                 byte = vrs->val & 0xff;
 940                 vrs->bytesinval--;
 941         }
 942
 943         vrs->cksum += byte;
 944         *data = byte;
 945         return (0);
 946 }
 947
 948 int
 949 pcie_slot_implemented(device_t dev)
 950 {
 951         struct pci_devinfo *dinfo = device_get_ivars(dev);
 952
 953         return pcie_slotimpl(&dinfo->cfg);
 954 }
 955
 956 void
 957 pcie_set_max_readrq(device_t dev, uint16_t rqsize)
 958 {
 959         uint8_t expr_ptr;
 960         uint16_t val;
 961
 962         rqsize &= PCIEM_DEVCTL_MAX_READRQ_MASK;
 963         if (rqsize > PCIEM_DEVCTL_MAX_READRQ_4096) {
 964                 panic("%s: invalid max read request size 0x%02x\n",
 965                       device_get_nameunit(dev), rqsize);
 966         }
 967
 968         expr_ptr = pci_get_pciecap_ptr(dev);
 969         if (!expr_ptr)
 970                 panic("%s: not PCIe device\n", device_get_nameunit(dev));
 971
 972         val = pci_read_config(dev, expr_ptr + PCIER_DEVCTRL, 2);
 973         if ((val & PCIEM_DEVCTL_MAX_READRQ_MASK) != rqsize) {
 974                 if (bootverbose)
 975                         device_printf(dev, "adjust device control 0x%04x", val);
 976
 977                 val &= ~PCIEM_DEVCTL_MAX_READRQ_MASK;
 978                 val |= rqsize;
 979                 pci_write_config(dev, expr_ptr + PCIER_DEVCTRL, val, 2);
 980
 981                 if (bootverbose)
 982                         kprintf(" -> 0x%04x\n", val);
 983         }
 984 }
 985
 986 static void
 987 pci_read_vpd(device_t pcib, pcicfgregs *cfg)
 988 {
 989         struct vpd_readstate vrs;
 990         int state;
 991         int name;
 992         int remain;
 993         int i;
 994         int alloc, off;         /* alloc/off for RO/W arrays */
 995         int cksumvalid;
 996         int dflen;
 997         uint8_t byte;
 998         uint8_t byte2;
 999
1000         /* init vpd reader */
1001         vrs.bytesinval = 0;
1002         vrs.off = 0;
1003         vrs.pcib = pcib;
1004         vrs.cfg = cfg;
1005         vrs.cksum = 0;
1006
1007         state = 0;
1008         name = remain = i = 0;  /* shut up stupid gcc */
1009         alloc = off = 0;        /* shut up stupid gcc */
1010         dflen = 0;              /* shut up stupid gcc */
1011         cksumvalid = -1;
1012         while (state >= 0) {
1013                 if (vpd_nextbyte(&vrs, &byte)) {
1014                         state = -2;
1015                         break;
1016                 }
1017 #if 0
1018                 kprintf("vpd: val: %#x, off: %d, bytesinval: %d, byte: %#hhx, " \
1019                     "state: %d, remain: %d, name: %#x, i: %d\n", vrs.val,
1020                     vrs.off, vrs.bytesinval, byte, state, remain, name, i);
1021 #endif
1022                 switch (state) {
1023                 case 0:         /* item name */
1024                         if (byte & 0x80) {
1025                                 if (vpd_nextbyte(&vrs, &byte2)) {
1026                                         state = -2;
1027                                         break;
1028                                 }
1029                                 remain = byte2;
1030                                 if (vpd_nextbyte(&vrs, &byte2)) {
1031                                         state = -2;
1032                                         break;
1033                                 }
1034                                 remain |= byte2 << 8;
1035                                 if (remain > (0x7f*4 - vrs.off)) {
1036                                         state = -1;
1037                                         kprintf(
1038                             "pci%d:%d:%d:%d: invalid VPD data, remain %#x\n",
1039                                             cfg->domain, cfg->bus, cfg->slot,
1040                                             cfg->func, remain);
1041                                 }
1042                                 name = byte & 0x7f;
1043                         } else {
1044                                 remain = byte & 0x7;
1045                                 name = (byte >> 3) & 0xf;
1046                         }
1047                         switch (name) {
1048                         case 0x2:       /* String */
1049                                 cfg->vpd.vpd_ident = kmalloc(remain + 1,
1050                                     M_DEVBUF, M_WAITOK);
1051                                 i = 0;
1052                                 state = 1;
1053                                 break;
1054                         case 0xf:       /* End */
1055                                 state = -1;
1056                                 break;
1057                         case 0x10:      /* VPD-R */
1058                                 alloc = 8;
1059                                 off = 0;
1060                                 cfg->vpd.vpd_ros = kmalloc(alloc *
1061                                     sizeof(*cfg->vpd.vpd_ros), M_DEVBUF,
1062                                     M_WAITOK | M_ZERO);
1063                                 state = 2;
1064                                 break;
1065                         case 0x11:      /* VPD-W */
1066                                 alloc = 8;
1067                                 off = 0;
1068                                 cfg->vpd.vpd_w = kmalloc(alloc *
1069                                     sizeof(*cfg->vpd.vpd_w), M_DEVBUF,
1070                                     M_WAITOK | M_ZERO);
1071                                 state = 5;
1072                                 break;
1073                         default:        /* Invalid data, abort */
1074                                 state = -1;
1075                                 break;
1076                         }
1077                         break;
1078
1079                 case 1: /* Identifier String */
1080                         cfg->vpd.vpd_ident[i++] = byte;
1081                         remain--;
1082                         if (remain == 0)  {
1083                                 cfg->vpd.vpd_ident[i] = '\0';
1084                                 state = 0;
1085                         }
1086                         break;
1087
1088                 case 2: /* VPD-R Keyword Header */
1089                         if (off == alloc) {
1090                                 cfg->vpd.vpd_ros = krealloc(cfg->vpd.vpd_ros,
1091                                     (alloc *= 2) * sizeof(*cfg->vpd.vpd_ros),
1092                                     M_DEVBUF, M_WAITOK | M_ZERO);
1093                         }
1094                         cfg->vpd.vpd_ros[off].keyword[0] = byte;
1095                         if (vpd_nextbyte(&vrs, &byte2)) {
1096                                 state = -2;
1097                                 break;
1098                         }
1099                         cfg->vpd.vpd_ros[off].keyword[1] = byte2;
1100                         if (vpd_nextbyte(&vrs, &byte2)) {
1101                                 state = -2;
1102                                 break;
1103                         }
1104                         dflen = byte2;
1105                         if (dflen == 0 &&
1106                             strncmp(cfg->vpd.vpd_ros[off].keyword, "RV",
1107                             2) == 0) {
1108                                 /*
1109                                  * if this happens, we can't trust the rest
1110                                  * of the VPD.
1111                                  */
1112                                 kprintf(
1113                                     "pci%d:%d:%d:%d: bad keyword length: %d\n",
1114                                     cfg->domain, cfg->bus, cfg->slot,
1115                                     cfg->func, dflen);
1116                                 cksumvalid = 0;
1117                                 state = -1;
1118                                 break;
1119                         } else if (dflen == 0) {
1120                                 cfg->vpd.vpd_ros[off].value = kmalloc(1 *
1121                                     sizeof(*cfg->vpd.vpd_ros[off].value),
1122                                     M_DEVBUF, M_WAITOK);
1123                                 cfg->vpd.vpd_ros[off].value[0] = '\x00';
1124                         } else
1125                                 cfg->vpd.vpd_ros[off].value = kmalloc(
1126                                     (dflen + 1) *
1127                                     sizeof(*cfg->vpd.vpd_ros[off].value),
1128                                     M_DEVBUF, M_WAITOK);
1129                         remain -= 3;
1130                         i = 0;
1131                         /* keep in sync w/ state 3's transistions */
1132                         if (dflen == 0 && remain == 0)
1133                                 state = 0;
1134                         else if (dflen == 0)
1135                                 state = 2;
1136                         else
1137                                 state = 3;
1138                         break;
1139
1140                 case 3: /* VPD-R Keyword Value */
1141                         cfg->vpd.vpd_ros[off].value[i++] = byte;
1142                         if (strncmp(cfg->vpd.vpd_ros[off].keyword,
1143                             "RV", 2) == 0 && cksumvalid == -1) {
1144                                 if (vrs.cksum == 0)
1145                                         cksumvalid = 1;
1146                                 else {
1147                                         if (bootverbose)
1148                                                 kprintf(
1149                                 "pci%d:%d:%d:%d: bad VPD cksum, remain %hhu\n",
1150                                                     cfg->domain, cfg->bus,
1151                                                     cfg->slot, cfg->func,
1152                                                     vrs.cksum);
1153                                         cksumvalid = 0;
1154                                         state = -1;
1155                                         break;
1156                                 }
1157                         }
1158                         dflen--;
1159                         remain--;
1160                         /* keep in sync w/ state 2's transistions */
1161                         if (dflen == 0)
1162                                 cfg->vpd.vpd_ros[off++].value[i++] = '\0';
1163                         if (dflen == 0 && remain == 0) {
1164                                 cfg->vpd.vpd_rocnt = off;
1165                                 cfg->vpd.vpd_ros = krealloc(cfg->vpd.vpd_ros,
1166                                     off * sizeof(*cfg->vpd.vpd_ros),
1167                                     M_DEVBUF, M_WAITOK | M_ZERO);
1168                                 state = 0;
1169                         } else if (dflen == 0)
1170                                 state = 2;
1171                         break;
1172
1173                 case 4:
1174                         remain--;
1175                         if (remain == 0)
1176                                 state = 0;
1177                         break;
1178
1179                 case 5: /* VPD-W Keyword Header */
1180                         if (off == alloc) {
1181                                 cfg->vpd.vpd_w = krealloc(cfg->vpd.vpd_w,
1182                                     (alloc *= 2) * sizeof(*cfg->vpd.vpd_w),
1183                                     M_DEVBUF, M_WAITOK | M_ZERO);
1184                         }
1185                         cfg->vpd.vpd_w[off].keyword[0] = byte;
1186                         if (vpd_nextbyte(&vrs, &byte2)) {
1187                                 state = -2;
1188                                 break;
1189                         }
1190                         cfg->vpd.vpd_w[off].keyword[1] = byte2;
1191                         if (vpd_nextbyte(&vrs, &byte2)) {
1192                                 state = -2;
1193                                 break;
1194                         }
1195                         cfg->vpd.vpd_w[off].len = dflen = byte2;
1196                         cfg->vpd.vpd_w[off].start = vrs.off - vrs.bytesinval;
1197                         cfg->vpd.vpd_w[off].value = kmalloc((dflen + 1) *
1198                             sizeof(*cfg->vpd.vpd_w[off].value),
1199                             M_DEVBUF, M_WAITOK);
1200                         remain -= 3;
1201                         i = 0;
1202                         /* keep in sync w/ state 6's transistions */
1203                         if (dflen == 0 && remain == 0)
1204                                 state = 0;
1205                         else if (dflen == 0)
1206                                 state = 5;
1207                         else
1208                                 state = 6;
1209                         break;
1210
1211                 case 6: /* VPD-W Keyword Value */
1212                         cfg->vpd.vpd_w[off].value[i++] = byte;
1213                         dflen--;
1214                         remain--;
1215                         /* keep in sync w/ state 5's transistions */
1216                         if (dflen == 0)
1217                                 cfg->vpd.vpd_w[off++].value[i++] = '\0';
1218                         if (dflen == 0 && remain == 0) {
1219                                 cfg->vpd.vpd_wcnt = off;
1220                                 cfg->vpd.vpd_w = krealloc(cfg->vpd.vpd_w,
1221                                     off * sizeof(*cfg->vpd.vpd_w),
1222                                     M_DEVBUF, M_WAITOK | M_ZERO);
1223                                 state = 0;
1224                         } else if (dflen == 0)
1225                                 state = 5;
1226                         break;
1227
1228                 default:
1229                         kprintf("pci%d:%d:%d:%d: invalid state: %d\n",
1230                             cfg->domain, cfg->bus, cfg->slot, cfg->func,
1231                             state);
1232                         state = -1;
1233                         break;
1234                 }
1235         }
1236
1237         if (cksumvalid == 0 || state < -1) {
1238                 /* read-only data bad, clean up */
1239                 if (cfg->vpd.vpd_ros != NULL) {
1240                         for (off = 0; cfg->vpd.vpd_ros[off].value; off++)
1241                                 kfree(cfg->vpd.vpd_ros[off].value, M_DEVBUF);
1242                         kfree(cfg->vpd.vpd_ros, M_DEVBUF);
1243                         cfg->vpd.vpd_ros = NULL;
1244                 }
1245         }
1246         if (state < -1) {
1247                 /* I/O error, clean up */
1248                 kprintf("pci%d:%d:%d:%d: failed to read VPD data.\n",
1249                     cfg->domain, cfg->bus, cfg->slot, cfg->func);
1250                 if (cfg->vpd.vpd_ident != NULL) {
1251                         kfree(cfg->vpd.vpd_ident, M_DEVBUF);
1252                         cfg->vpd.vpd_ident = NULL;
1253                 }
1254                 if (cfg->vpd.vpd_w != NULL) {
1255                         for (off = 0; cfg->vpd.vpd_w[off].value; off++)
1256                                 kfree(cfg->vpd.vpd_w[off].value, M_DEVBUF);
1257                         kfree(cfg->vpd.vpd_w, M_DEVBUF);
1258                         cfg->vpd.vpd_w = NULL;
1259                 }
1260         }
1261         cfg->vpd.vpd_cached = 1;
1262 #undef REG
1263 #undef WREG
1264 }
1265
1266 int
1267 pci_get_vpd_ident_method(device_t dev, device_t child, const char **identptr)
1268 {
1269         struct pci_devinfo *dinfo = device_get_ivars(child);
1270         pcicfgregs *cfg = &dinfo->cfg;
1271
1272         if (!cfg->vpd.vpd_cached && cfg->vpd.vpd_reg != 0)
1273                 pci_read_vpd(device_get_parent(dev), cfg);
1274
1275         *identptr = cfg->vpd.vpd_ident;
1276
1277         if (*identptr == NULL)
1278                 return (ENXIO);
1279
1280         return (0);
1281 }
1282
1283 int
1284 pci_get_vpd_readonly_method(device_t dev, device_t child, const char *kw,
1285         const char **vptr)
1286 {
1287         struct pci_devinfo *dinfo = device_get_ivars(child);
1288         pcicfgregs *cfg = &dinfo->cfg;
1289         int i;
1290
1291         if (!cfg->vpd.vpd_cached && cfg->vpd.vpd_reg != 0)
1292                 pci_read_vpd(device_get_parent(dev), cfg);
1293
1294         for (i = 0; i < cfg->vpd.vpd_rocnt; i++)
1295                 if (memcmp(kw, cfg->vpd.vpd_ros[i].keyword,
1296                     sizeof(cfg->vpd.vpd_ros[i].keyword)) == 0) {
1297                         *vptr = cfg->vpd.vpd_ros[i].value;
1298                 }
1299
1300         if (i != cfg->vpd.vpd_rocnt)
1301                 return (0);
1302
1303         *vptr = NULL;
1304         return (ENXIO);
1305 }
1306
1307 /*
1308  * Return the offset in configuration space of the requested extended
1309  * capability entry or 0 if the specified capability was not found.
1310  */
1311 int
1312 pci_find_extcap_method(device_t dev, device_t child, int capability,
1313     int *capreg)
1314 {
1315         struct pci_devinfo *dinfo = device_get_ivars(child);
1316         pcicfgregs *cfg = &dinfo->cfg;
1317         u_int32_t status;
1318         u_int8_t ptr;
1319
1320         /*
1321          * Check the CAP_LIST bit of the PCI status register first.
1322          */
1323         status = pci_read_config(child, PCIR_STATUS, 2);
1324         if (!(status & PCIM_STATUS_CAPPRESENT))
1325                 return (ENXIO);
1326
1327         /*
1328          * Determine the start pointer of the capabilities list.
1329          */
1330         switch (cfg->hdrtype & PCIM_HDRTYPE) {
1331         case 0:
1332         case 1:
1333                 ptr = PCIR_CAP_PTR;
1334                 break;
1335         case 2:
1336                 ptr = PCIR_CAP_PTR_2;
1337                 break;
1338         default:
1339                 /* XXX: panic? */
1340                 return (ENXIO);         /* no extended capabilities support */
1341         }
1342         ptr = pci_read_config(child, ptr, 1);
1343
1344         /*
1345          * Traverse the capabilities list.
1346          */
1347         while (ptr != 0) {
1348                 if (pci_read_config(child, ptr + PCICAP_ID, 1) == capability) {
1349                         if (capreg != NULL)
1350                                 *capreg = ptr;
1351                         return (0);
1352                 }
1353                 ptr = pci_read_config(child, ptr + PCICAP_NEXTPTR, 1);
1354         }
1355
1356         return (ENOENT);
1357 }
1358
1359 /*
1360  * Support for MSI-X message interrupts.
1361  */
1362 void
1363 pci_enable_msix(device_t dev, u_int index, uint64_t address, uint32_t data)
1364 {
1365         struct pci_devinfo *dinfo = device_get_ivars(dev);
1366         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1367         uint32_t offset;
1368
1369         KASSERT(msix->msix_table_len > index, ("bogus index"));
1370         offset = msix->msix_table_offset + index * 16;
1371         bus_write_4(msix->msix_table_res, offset, address & 0xffffffff);
1372         bus_write_4(msix->msix_table_res, offset + 4, address >> 32);
1373         bus_write_4(msix->msix_table_res, offset + 8, data);
1374
1375         /* Enable MSI -> HT mapping. */
1376         pci_ht_map_msi(dev, address);
1377 }
1378
1379 void
1380 pci_mask_msix(device_t dev, u_int index)
1381 {
1382         struct pci_devinfo *dinfo = device_get_ivars(dev);
1383         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1384         uint32_t offset, val;
1385
1386         KASSERT(msix->msix_msgnum > index, ("bogus index"));
1387         offset = msix->msix_table_offset + index * 16 + 12;
1388         val = bus_read_4(msix->msix_table_res, offset);
1389         if (!(val & PCIM_MSIX_VCTRL_MASK)) {
1390                 val |= PCIM_MSIX_VCTRL_MASK;
1391                 bus_write_4(msix->msix_table_res, offset, val);
1392         }
1393 }
1394
1395 void
1396 pci_unmask_msix(device_t dev, u_int index)
1397 {
1398         struct pci_devinfo *dinfo = device_get_ivars(dev);
1399         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1400         uint32_t offset, val;
1401
1402         KASSERT(msix->msix_table_len > index, ("bogus index"));
1403         offset = msix->msix_table_offset + index * 16 + 12;
1404         val = bus_read_4(msix->msix_table_res, offset);
1405         if (val & PCIM_MSIX_VCTRL_MASK) {
1406                 val &= ~PCIM_MSIX_VCTRL_MASK;
1407                 bus_write_4(msix->msix_table_res, offset, val);
1408         }
1409 }
1410
1411 int
1412 pci_pending_msix(device_t dev, u_int index)
1413 {
1414         struct pci_devinfo *dinfo = device_get_ivars(dev);
1415         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1416         uint32_t offset, bit;
1417
1418         KASSERT(msix->msix_table_len > index, ("bogus index"));
1419         offset = msix->msix_pba_offset + (index / 32) * 4;
1420         bit = 1 << index % 32;
1421         return (bus_read_4(msix->msix_pba_res, offset) & bit);
1422 }
1423
1424 /*
1425  * Restore MSI-X registers and table during resume.  If MSI-X is
1426  * enabled then walk the virtual table to restore the actual MSI-X
1427  * table.
1428  */
1429 static void
1430 pci_resume_msix(device_t dev)
1431 {
1432         struct pci_devinfo *dinfo = device_get_ivars(dev);
1433         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1434         struct msix_table_entry *mte;
1435         struct msix_vector *mv;
1436         int i;
1437
1438         if (msix->msix_alloc > 0) {
1439                 /* First, mask all vectors. */
1440                 for (i = 0; i < msix->msix_msgnum; i++)
1441                         pci_mask_msix(dev, i);
1442
1443                 /* Second, program any messages with at least one handler. */
1444                 for (i = 0; i < msix->msix_table_len; i++) {
1445                         mte = &msix->msix_table[i];
1446                         if (mte->mte_vector == 0 || mte->mte_handlers == 0)
1447                                 continue;
1448                         mv = &msix->msix_vectors[mte->mte_vector - 1];
1449                         pci_enable_msix(dev, i, mv->mv_address, mv->mv_data);
1450                         pci_unmask_msix(dev, i);
1451                 }
1452         }
1453         pci_write_config(dev, msix->msix_location + PCIR_MSIX_CTRL,
1454             msix->msix_ctrl, 2);
1455 }
1456
1457 /*
1458  * Attempt to allocate *count MSI-X messages.  The actual number allocated is
1459  * returned in *count.  After this function returns, each message will be
1460  * available to the driver as SYS_RES_IRQ resources starting at rid 1.
1461  */
1462 int
1463 pci_alloc_msix_method(device_t dev, device_t child, int *count)
1464 {
1465         struct pci_devinfo *dinfo = device_get_ivars(child);
1466         pcicfgregs *cfg = &dinfo->cfg;
1467         struct resource_list_entry *rle;
1468         int actual, error, i, irq, max;
1469
1470         /* Don't let count == 0 get us into trouble. */
1471         if (*count == 0)
1472                 return (EINVAL);
1473
1474         /* If rid 0 is allocated, then fail. */
1475         rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 0);
1476         if (rle != NULL && rle->res != NULL)
1477                 return (ENXIO);
1478
1479         /* Already have allocated messages? */
1480         if (cfg->msi.msi_alloc != 0 || cfg->msix.msix_alloc != 0)
1481                 return (ENXIO);
1482
1483         /* If MSI is blacklisted for this system, fail. */
1484         if (pci_msi_blacklisted())
1485                 return (ENXIO);
1486
1487         /* MSI-X capability present? */
1488         if (cfg->msix.msix_location == 0 || !pci_do_msix)
1489                 return (ENODEV);
1490
1491         /* Make sure the appropriate BARs are mapped. */
1492         rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY,
1493             cfg->msix.msix_table_bar);
1494         if (rle == NULL || rle->res == NULL ||
1495             !(rman_get_flags(rle->res) & RF_ACTIVE))
1496                 return (ENXIO);
1497         cfg->msix.msix_table_res = rle->res;
1498         if (cfg->msix.msix_pba_bar != cfg->msix.msix_table_bar) {
1499                 rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY,
1500                     cfg->msix.msix_pba_bar);
1501                 if (rle == NULL || rle->res == NULL ||
1502                     !(rman_get_flags(rle->res) & RF_ACTIVE))
1503                         return (ENXIO);
1504         }
1505         cfg->msix.msix_pba_res = rle->res;
1506
1507         if (bootverbose)
1508                 device_printf(child,
1509                     "attempting to allocate %d MSI-X vectors (%d supported)\n",
1510                     *count, cfg->msix.msix_msgnum);
1511         max = min(*count, cfg->msix.msix_msgnum);
1512         for (i = 0; i < max; i++) {
1513                 /* Allocate a message. */
1514                 error = PCIB_ALLOC_MSIX(device_get_parent(dev), child, &irq);
1515                 if (error)
1516                         break;
1517                 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i + 1, irq,
1518                     irq, 1);
1519         }
1520         actual = i;
1521
1522         if (bootverbose) {
1523                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 1);
1524                 if (actual == 1)
1525                         device_printf(child, "using IRQ %lu for MSI-X\n",
1526                             rle->start);
1527                 else {
1528                         int run;
1529
1530                         /*
1531                          * Be fancy and try to print contiguous runs of
1532                          * IRQ values as ranges.  'irq' is the previous IRQ.
1533                          * 'run' is true if we are in a range.
1534                          */
1535                         device_printf(child, "using IRQs %lu", rle->start);
1536                         irq = rle->start;
1537                         run = 0;
1538                         for (i = 1; i < actual; i++) {
1539                                 rle = resource_list_find(&dinfo->resources,
1540                                     SYS_RES_IRQ, i + 1);
1541
1542                                 /* Still in a run? */
1543                                 if (rle->start == irq + 1) {
1544                                         run = 1;
1545                                         irq++;
1546                                         continue;
1547                                 }
1548
1549                                 /* Finish previous range. */
1550                                 if (run) {
1551                                         kprintf("-%d", irq);
1552                                         run = 0;
1553                                 }
1554
1555                                 /* Start new range. */
1556                                 kprintf(",%lu", rle->start);
1557                                 irq = rle->start;
1558                         }
1559
1560                         /* Unfinished range? */
1561                         if (run)
1562                                 kprintf("-%d", irq);
1563                         kprintf(" for MSI-X\n");
1564                 }
1565         }
1566
1567         /* Mask all vectors. */
1568         for (i = 0; i < cfg->msix.msix_msgnum; i++)
1569                 pci_mask_msix(child, i);
1570
1571         /* Allocate and initialize vector data and virtual table. */
1572         cfg->msix.msix_vectors = kmalloc(sizeof(struct msix_vector) * actual,
1573             M_DEVBUF, M_WAITOK | M_ZERO);
1574         cfg->msix.msix_table = kmalloc(sizeof(struct msix_table_entry) * actual,
1575             M_DEVBUF, M_WAITOK | M_ZERO);
1576         for (i = 0; i < actual; i++) {
1577                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
1578                 cfg->msix.msix_vectors[i].mv_irq = rle->start;
1579                 cfg->msix.msix_table[i].mte_vector = i + 1;
1580         }
1581
1582         /* Update control register to enable MSI-X. */
1583         cfg->msix.msix_ctrl |= PCIM_MSIXCTRL_MSIX_ENABLE;
1584         pci_write_config(child, cfg->msix.msix_location + PCIR_MSIX_CTRL,
1585             cfg->msix.msix_ctrl, 2);
1586
1587         /* Update counts of alloc'd messages. */
1588         cfg->msix.msix_alloc = actual;
1589         cfg->msix.msix_table_len = actual;
1590         *count = actual;
1591         return (0);
1592 }
1593
1594 /*
1595  * By default, pci_alloc_msix() will assign the allocated IRQ
1596  * resources consecutively to the first N messages in the MSI-X table.
1597  * However, device drivers may want to use different layouts if they
1598  * either receive fewer messages than they asked for, or they wish to
1599  * populate the MSI-X table sparsely.  This method allows the driver
1600  * to specify what layout it wants.  It must be called after a
1601  * successful pci_alloc_msix() but before any of the associated
1602  * SYS_RES_IRQ resources are allocated via bus_alloc_resource().
1603  *
1604  * The 'vectors' array contains 'count' message vectors.  The array
1605  * maps directly to the MSI-X table in that index 0 in the array
1606  * specifies the vector for the first message in the MSI-X table, etc.
1607  * The vector value in each array index can either be 0 to indicate
1608  * that no vector should be assigned to a message slot, or it can be a
1609  * number from 1 to N (where N is the count returned from a
1610  * succcessful call to pci_alloc_msix()) to indicate which message
1611  * vector (IRQ) to be used for the corresponding message.
1612  *
1613  * On successful return, each message with a non-zero vector will have
1614  * an associated SYS_RES_IRQ whose rid is equal to the array index +
1615  * 1.  Additionally, if any of the IRQs allocated via the previous
1616  * call to pci_alloc_msix() are not used in the mapping, those IRQs
1617  * will be kfreed back to the system automatically.
1618  *
1619  * For example, suppose a driver has a MSI-X table with 6 messages and
1620  * asks for 6 messages, but pci_alloc_msix() only returns a count of
1621  * 3.  Call the three vectors allocated by pci_alloc_msix() A, B, and
1622  * C.  After the call to pci_alloc_msix(), the device will be setup to
1623  * have an MSI-X table of ABC--- (where - means no vector assigned).
1624  * If the driver ten passes a vector array of { 1, 0, 1, 2, 0, 2 },
1625  * then the MSI-X table will look like A-AB-B, and the 'C' vector will
1626  * be kfreed back to the system.  This device will also have valid
1627  * SYS_RES_IRQ rids of 1, 3, 4, and 6.
1628  *
1629  * In any case, the SYS_RES_IRQ rid X will always map to the message
1630  * at MSI-X table index X - 1 and will only be valid if a vector is
1631  * assigned to that table entry.
1632  */
1633 int
1634 pci_remap_msix_method(device_t dev, device_t child, int count,
1635     const u_int *vectors)
1636 {
1637         struct pci_devinfo *dinfo = device_get_ivars(child);
1638         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1639         struct resource_list_entry *rle;
1640         int i, irq, j, *used;
1641
1642         /*
1643          * Have to have at least one message in the table but the
1644          * table can't be bigger than the actual MSI-X table in the
1645          * device.
1646          */
1647         if (count == 0 || count > msix->msix_msgnum)
1648                 return (EINVAL);
1649
1650         /* Sanity check the vectors. */
1651         for (i = 0; i < count; i++)
1652                 if (vectors[i] > msix->msix_alloc)
1653                         return (EINVAL);
1654
1655         /*
1656          * Make sure there aren't any holes in the vectors to be used.
1657          * It's a big pain to support it, and it doesn't really make
1658          * sense anyway.  Also, at least one vector must be used.
1659          */
1660         used = kmalloc(sizeof(int) * msix->msix_alloc, M_DEVBUF, M_WAITOK |
1661             M_ZERO);
1662         for (i = 0; i < count; i++)
1663                 if (vectors[i] != 0)
1664                         used[vectors[i] - 1] = 1;
1665         for (i = 0; i < msix->msix_alloc - 1; i++)
1666                 if (used[i] == 0 && used[i + 1] == 1) {
1667                         kfree(used, M_DEVBUF);
1668                         return (EINVAL);
1669                 }
1670         if (used[0] != 1) {
1671                 kfree(used, M_DEVBUF);
1672                 return (EINVAL);
1673         }
1674
1675         /* Make sure none of the resources are allocated. */
1676         for (i = 0; i < msix->msix_table_len; i++) {
1677                 if (msix->msix_table[i].mte_vector == 0)
1678                         continue;
1679                 if (msix->msix_table[i].mte_handlers > 0)
1680                         return (EBUSY);
1681                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
1682                 KASSERT(rle != NULL, ("missing resource"));
1683                 if (rle->res != NULL)
1684                         return (EBUSY);
1685         }
1686
1687         /* Free the existing resource list entries. */
1688         for (i = 0; i < msix->msix_table_len; i++) {
1689                 if (msix->msix_table[i].mte_vector == 0)
1690                         continue;
1691                 resource_list_delete(&dinfo->resources, SYS_RES_IRQ, i + 1);
1692         }
1693
1694         /*
1695          * Build the new virtual table keeping track of which vectors are
1696          * used.
1697          */
1698         kfree(msix->msix_table, M_DEVBUF);
1699         msix->msix_table = kmalloc(sizeof(struct msix_table_entry) * count,
1700             M_DEVBUF, M_WAITOK | M_ZERO);
1701         for (i = 0; i < count; i++)
1702                 msix->msix_table[i].mte_vector = vectors[i];
1703         msix->msix_table_len = count;
1704
1705         /* Free any unused IRQs and resize the vectors array if necessary. */
1706         j = msix->msix_alloc - 1;
1707         if (used[j] == 0) {
1708                 struct msix_vector *vec;
1709
1710                 while (used[j] == 0) {
1711                         PCIB_RELEASE_MSIX(device_get_parent(dev), child,
1712                             msix->msix_vectors[j].mv_irq);
1713                         j--;
1714                 }
1715                 vec = kmalloc(sizeof(struct msix_vector) * (j + 1), M_DEVBUF,
1716                     M_WAITOK);
1717                 bcopy(msix->msix_vectors, vec, sizeof(struct msix_vector) *
1718                     (j + 1));
1719                 kfree(msix->msix_vectors, M_DEVBUF);
1720                 msix->msix_vectors = vec;
1721                 msix->msix_alloc = j + 1;
1722         }
1723         kfree(used, M_DEVBUF);
1724
1725         /* Map the IRQs onto the rids. */
1726         for (i = 0; i < count; i++) {
1727                 if (vectors[i] == 0)
1728                         continue;
1729                 irq = msix->msix_vectors[vectors[i]].mv_irq;
1730                 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i + 1, irq,
1731                     irq, 1);
1732         }
1733
1734         if (bootverbose) {
1735                 device_printf(child, "Remapped MSI-X IRQs as: ");
1736                 for (i = 0; i < count; i++) {
1737                         if (i != 0)
1738                                 kprintf(", ");
1739                         if (vectors[i] == 0)
1740                                 kprintf("---");
1741                         else
1742                                 kprintf("%d",
1743                                     msix->msix_vectors[vectors[i]].mv_irq);
1744                 }
1745                 kprintf("\n");
1746         }
1747
1748         return (0);
1749 }
1750
1751 static int
1752 pci_release_msix(device_t dev, device_t child)
1753 {
1754         struct pci_devinfo *dinfo = device_get_ivars(child);
1755         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1756         struct resource_list_entry *rle;
1757         int i;
1758
1759         /* Do we have any messages to release? */
1760         if (msix->msix_alloc == 0)
1761                 return (ENODEV);
1762
1763         /* Make sure none of the resources are allocated. */
1764         for (i = 0; i < msix->msix_table_len; i++) {
1765                 if (msix->msix_table[i].mte_vector == 0)
1766                         continue;
1767                 if (msix->msix_table[i].mte_handlers > 0)
1768                         return (EBUSY);
1769                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
1770                 KASSERT(rle != NULL, ("missing resource"));
1771                 if (rle->res != NULL)
1772                         return (EBUSY);
1773         }
1774
1775         /* Update control register to disable MSI-X. */
1776         msix->msix_ctrl &= ~PCIM_MSIXCTRL_MSIX_ENABLE;
1777         pci_write_config(child, msix->msix_location + PCIR_MSIX_CTRL,
1778             msix->msix_ctrl, 2);
1779
1780         /* Free the resource list entries. */
1781         for (i = 0; i < msix->msix_table_len; i++) {
1782                 if (msix->msix_table[i].mte_vector == 0)
1783                         continue;
1784                 resource_list_delete(&dinfo->resources, SYS_RES_IRQ, i + 1);
1785         }
1786         kfree(msix->msix_table, M_DEVBUF);
1787         msix->msix_table_len = 0;
1788
1789         /* Release the IRQs. */
1790         for (i = 0; i < msix->msix_alloc; i++)
1791                 PCIB_RELEASE_MSIX(device_get_parent(dev), child,
1792                     msix->msix_vectors[i].mv_irq);
1793         kfree(msix->msix_vectors, M_DEVBUF);
1794         msix->msix_alloc = 0;
1795         return (0);
1796 }
1797
1798 /*
1799  * Return the max supported MSI-X messages this device supports.
1800  * Basically, assuming the MD code can alloc messages, this function
1801  * should return the maximum value that pci_alloc_msix() can return.
1802  * Thus, it is subject to the tunables, etc.
1803  */
1804 int
1805 pci_msix_count_method(device_t dev, device_t child)
1806 {
1807         struct pci_devinfo *dinfo = device_get_ivars(child);
1808         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1809
1810         if (pci_do_msix && msix->msix_location != 0)
1811                 return (msix->msix_msgnum);
1812         return (0);
1813 }
1814
1815 /*
1816  * HyperTransport MSI mapping control
1817  */
1818 void
1819 pci_ht_map_msi(device_t dev, uint64_t addr)
1820 {
1821         struct pci_devinfo *dinfo = device_get_ivars(dev);
1822         struct pcicfg_ht *ht = &dinfo->cfg.ht;
1823
1824         if (!ht->ht_msimap)
1825                 return;
1826
1827         if (addr && !(ht->ht_msictrl & PCIM_HTCMD_MSI_ENABLE) &&
1828             ht->ht_msiaddr >> 20 == addr >> 20) {
1829                 /* Enable MSI -> HT mapping. */
1830                 ht->ht_msictrl |= PCIM_HTCMD_MSI_ENABLE;
1831                 pci_write_config(dev, ht->ht_msimap + PCIR_HT_COMMAND,
1832                     ht->ht_msictrl, 2);
1833         }
1834
1835         if (!addr && ht->ht_msictrl & PCIM_HTCMD_MSI_ENABLE) {
1836                 /* Disable MSI -> HT mapping. */
1837                 ht->ht_msictrl &= ~PCIM_HTCMD_MSI_ENABLE;
1838                 pci_write_config(dev, ht->ht_msimap + PCIR_HT_COMMAND,
1839                     ht->ht_msictrl, 2);
1840         }
1841 }
1842
1843 /*
1844  * Support for MSI message signalled interrupts.
1845  */
1846 void
1847 pci_enable_msi(device_t dev, uint64_t address, uint16_t data)
1848 {
1849         struct pci_devinfo *dinfo = device_get_ivars(dev);
1850         struct pcicfg_msi *msi = &dinfo->cfg.msi;
1851
1852         /* Write data and address values. */
1853         pci_write_config(dev, msi->msi_location + PCIR_MSI_ADDR,
1854             address & 0xffffffff, 4);
1855         if (msi->msi_ctrl & PCIM_MSICTRL_64BIT) {
1856                 pci_write_config(dev, msi->msi_location + PCIR_MSI_ADDR_HIGH,
1857                     address >> 32, 4);
1858                 pci_write_config(dev, msi->msi_location + PCIR_MSI_DATA_64BIT,
1859                     data, 2);
1860         } else
1861                 pci_write_config(dev, msi->msi_location + PCIR_MSI_DATA, data,
1862                     2);
1863
1864         /* Enable MSI in the control register. */
1865         msi->msi_ctrl |= PCIM_MSICTRL_MSI_ENABLE;
1866         pci_write_config(dev, msi->msi_location + PCIR_MSI_CTRL, msi->msi_ctrl,
1867             2);
1868
1869         /* Enable MSI -> HT mapping. */
1870         pci_ht_map_msi(dev, address);
1871 }
1872
1873 void
1874 pci_disable_msi(device_t dev)
1875 {
1876         struct pci_devinfo *dinfo = device_get_ivars(dev);
1877         struct pcicfg_msi *msi = &dinfo->cfg.msi;
1878
1879         /* Disable MSI -> HT mapping. */
1880         pci_ht_map_msi(dev, 0);
1881
1882         /* Disable MSI in the control register. */
1883         msi->msi_ctrl &= ~PCIM_MSICTRL_MSI_ENABLE;
1884         pci_write_config(dev, msi->msi_location + PCIR_MSI_CTRL, msi->msi_ctrl,
1885             2);
1886 }
1887
1888 /*
1889  * Restore MSI registers during resume.  If MSI is enabled then
1890  * restore the data and address registers in addition to the control
1891  * register.
1892  */
1893 static void
1894 pci_resume_msi(device_t dev)
1895 {
1896         struct pci_devinfo *dinfo = device_get_ivars(dev);
1897         struct pcicfg_msi *msi = &dinfo->cfg.msi;
1898         uint64_t address;
1899         uint16_t data;
1900
1901         if (msi->msi_ctrl & PCIM_MSICTRL_MSI_ENABLE) {
1902                 address = msi->msi_addr;
1903                 data = msi->msi_data;
1904                 pci_write_config(dev, msi->msi_location + PCIR_MSI_ADDR,
1905                     address & 0xffffffff, 4);
1906                 if (msi->msi_ctrl & PCIM_MSICTRL_64BIT) {
1907                         pci_write_config(dev, msi->msi_location +
1908                             PCIR_MSI_ADDR_HIGH, address >> 32, 4);
1909                         pci_write_config(dev, msi->msi_location +
1910                             PCIR_MSI_DATA_64BIT, data, 2);
1911                 } else
1912                         pci_write_config(dev, msi->msi_location + PCIR_MSI_DATA,
1913                             data, 2);
1914         }
1915         pci_write_config(dev, msi->msi_location + PCIR_MSI_CTRL, msi->msi_ctrl,
1916             2);
1917 }
1918
1919 int
1920 pci_remap_msi_irq(device_t dev, u_int irq)
1921 {
1922         struct pci_devinfo *dinfo = device_get_ivars(dev);
1923         pcicfgregs *cfg = &dinfo->cfg;
1924         struct resource_list_entry *rle;
1925         struct msix_table_entry *mte;
1926         struct msix_vector *mv;
1927         device_t bus;
1928         uint64_t addr;
1929         uint32_t data;
1930         int error, i, j;
1931
1932         bus = device_get_parent(dev);
1933
1934         /*
1935          * Handle MSI first.  We try to find this IRQ among our list
1936          * of MSI IRQs.  If we find it, we request updated address and
1937          * data registers and apply the results.
1938          */
1939         if (cfg->msi.msi_alloc > 0) {
1940
1941                 /* If we don't have any active handlers, nothing to do. */
1942                 if (cfg->msi.msi_handlers == 0)
1943                         return (0);
1944                 for (i = 0; i < cfg->msi.msi_alloc; i++) {
1945                         rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ,
1946                             i + 1);
1947                         if (rle->start == irq) {
1948                                 error = PCIB_MAP_MSI(device_get_parent(bus),
1949                                     dev, irq, &addr, &data);
1950                                 if (error)
1951                                         return (error);
1952                                 pci_disable_msi(dev);
1953                                 dinfo->cfg.msi.msi_addr = addr;
1954                                 dinfo->cfg.msi.msi_data = data;
1955                                 pci_enable_msi(dev, addr, data);
1956                                 return (0);
1957                         }
1958                 }
1959                 return (ENOENT);
1960         }
1961
1962         /*
1963          * For MSI-X, we check to see if we have this IRQ.  If we do,
1964          * we request the updated mapping info.  If that works, we go
1965          * through all the slots that use this IRQ and update them.
1966          */
1967         if (cfg->msix.msix_alloc > 0) {
1968                 for (i = 0; i < cfg->msix.msix_alloc; i++) {
1969                         mv = &cfg->msix.msix_vectors[i];
1970                         if (mv->mv_irq == irq) {
1971                                 error = PCIB_MAP_MSI(device_get_parent(bus),
1972                                     dev, irq, &addr, &data);
1973                                 if (error)
1974                                         return (error);
1975                                 mv->mv_address = addr;
1976                                 mv->mv_data = data;
1977                                 for (j = 0; j < cfg->msix.msix_table_len; j++) {
1978                                         mte = &cfg->msix.msix_table[j];
1979                                         if (mte->mte_vector != i + 1)
1980                                                 continue;
1981                                         if (mte->mte_handlers == 0)
1982                                                 continue;
1983                                         pci_mask_msix(dev, j);
1984                                         pci_enable_msix(dev, j, addr, data);
1985                                         pci_unmask_msix(dev, j);
1986                                 }
1987                         }
1988                 }
1989                 return (ENOENT);
1990         }
1991
1992         return (ENOENT);
1993 }
1994
1995 /*
1996  * Returns true if the specified device is blacklisted because MSI
1997  * doesn't work.
1998  */
1999 int
2000 pci_msi_device_blacklisted(device_t dev)
2001 {
2002         struct pci_quirk *q;
2003
2004         if (!pci_honor_msi_blacklist)
2005                 return (0);
2006
2007         for (q = &pci_quirks[0]; q->devid; q++) {
2008                 if (q->devid == pci_get_devid(dev) &&
2009                     q->type == PCI_QUIRK_DISABLE_MSI)
2010                         return (1);
2011         }
2012         return (0);
2013 }
2014
2015 /*
2016  * Determine if MSI is blacklisted globally on this sytem.  Currently,
2017  * we just check for blacklisted chipsets as represented by the
2018  * host-PCI bridge at device 0:0:0.  In the future, it may become
2019  * necessary to check other system attributes, such as the kenv values
2020  * that give the motherboard manufacturer and model number.
2021  */
2022 static int
2023 pci_msi_blacklisted(void)
2024 {
2025         device_t dev;
2026
2027         if (!pci_honor_msi_blacklist)
2028                 return (0);
2029
2030         /* Blacklist all non-PCI-express and non-PCI-X chipsets. */
2031         if (!(pcie_chipset || pcix_chipset))
2032                 return (1);
2033
2034         dev = pci_find_bsf(0, 0, 0);
2035         if (dev != NULL)
2036                 return (pci_msi_device_blacklisted(dev));
2037         return (0);
2038 }
2039
2040 /*
2041  * Attempt to allocate *count MSI messages.  The actual number allocated is
2042  * returned in *count.  After this function returns, each message will be
2043  * available to the driver as SYS_RES_IRQ resources starting at a rid 1.
2044  */
2045 int
2046 pci_alloc_msi_method(device_t dev, device_t child, int *count)
2047 {
2048         struct pci_devinfo *dinfo = device_get_ivars(child);
2049         pcicfgregs *cfg = &dinfo->cfg;
2050         struct resource_list_entry *rle;
2051         int actual, error, i, irqs[32];
2052         uint16_t ctrl;
2053
2054         /* Don't let count == 0 get us into trouble. */
2055         if (*count == 0)
2056                 return (EINVAL);
2057
2058         /* If rid 0 is allocated, then fail. */
2059         rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 0);
2060         if (rle != NULL && rle->res != NULL)
2061                 return (ENXIO);
2062
2063         /* Already have allocated messages? */
2064         if (cfg->msi.msi_alloc != 0 || cfg->msix.msix_alloc != 0)
2065                 return (ENXIO);
2066
2067         /* If MSI is blacklisted for this system, fail. */
2068         if (pci_msi_blacklisted())
2069                 return (ENXIO);
2070
2071         /* MSI capability present? */
2072         if (cfg->msi.msi_location == 0 || !pci_do_msi)
2073                 return (ENODEV);
2074
2075         if (bootverbose)
2076                 device_printf(child,
2077                     "attempting to allocate %d MSI vectors (%d supported)\n",
2078                     *count, cfg->msi.msi_msgnum);
2079
2080         /* Don't ask for more than the device supports. */
2081         actual = min(*count, cfg->msi.msi_msgnum);
2082
2083         /* Don't ask for more than 32 messages. */
2084         actual = min(actual, 32);
2085
2086         /* MSI requires power of 2 number of messages. */
2087         if (!powerof2(actual))
2088                 return (EINVAL);
2089
2090         for (;;) {
2091                 /* Try to allocate N messages. */
2092                 error = PCIB_ALLOC_MSI(device_get_parent(dev), child, actual,
2093                     cfg->msi.msi_msgnum, irqs);
2094                 if (error == 0)
2095                         break;
2096                 if (actual == 1)
2097                         return (error);
2098
2099                 /* Try N / 2. */
2100                 actual >>= 1;
2101         }
2102
2103         /*
2104          * We now have N actual messages mapped onto SYS_RES_IRQ
2105          * resources in the irqs[] array, so add new resources
2106          * starting at rid 1.
2107          */
2108         for (i = 0; i < actual; i++)
2109                 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i + 1,
2110                     irqs[i], irqs[i], 1);
2111
2112         if (bootverbose) {
2113                 if (actual == 1)
2114                         device_printf(child, "using IRQ %d for MSI\n", irqs[0]);
2115                 else {
2116                         int run;
2117
2118                         /*
2119                          * Be fancy and try to print contiguous runs
2120                          * of IRQ values as ranges.  'run' is true if
2121                          * we are in a range.
2122                          */
2123                         device_printf(child, "using IRQs %d", irqs[0]);
2124                         run = 0;
2125                         for (i = 1; i < actual; i++) {
2126
2127                                 /* Still in a run? */
2128                                 if (irqs[i] == irqs[i - 1] + 1) {
2129                                         run = 1;
2130                                         continue;
2131                                 }
2132
2133                                 /* Finish previous range. */
2134                                 if (run) {
2135                                         kprintf("-%d", irqs[i - 1]);
2136                                         run = 0;
2137                                 }
2138
2139                                 /* Start new range. */
2140                                 kprintf(",%d", irqs[i]);
2141                         }
2142
2143                         /* Unfinished range? */
2144                         if (run)
2145                                 kprintf("-%d", irqs[actual - 1]);
2146                         kprintf(" for MSI\n");
2147                 }
2148         }
2149
2150         /* Update control register with actual count. */
2151         ctrl = cfg->msi.msi_ctrl;
2152         ctrl &= ~PCIM_MSICTRL_MME_MASK;
2153         ctrl |= (ffs(actual) - 1) << 4;
2154         cfg->msi.msi_ctrl = ctrl;
2155         pci_write_config(child, cfg->msi.msi_location + PCIR_MSI_CTRL, ctrl, 2);
2156
2157         /* Update counts of alloc'd messages. */
2158         cfg->msi.msi_alloc = actual;
2159         cfg->msi.msi_handlers = 0;
2160         *count = actual;
2161         return (0);
2162 }
2163
2164 /* Release the MSI messages associated with this device. */
2165 int
2166 pci_release_msi_method(device_t dev, device_t child)
2167 {
2168         struct pci_devinfo *dinfo = device_get_ivars(child);
2169         struct pcicfg_msi *msi = &dinfo->cfg.msi;
2170         struct resource_list_entry *rle;
2171         int error, i, irqs[32];
2172
2173         /* Try MSI-X first. */
2174         error = pci_release_msix(dev, child);
2175         if (error != ENODEV)
2176                 return (error);
2177
2178         /* Do we have any messages to release? */
2179         if (msi->msi_alloc == 0)
2180                 return (ENODEV);
2181         KASSERT(msi->msi_alloc <= 32, ("more than 32 alloc'd messages"));
2182
2183         /* Make sure none of the resources are allocated. */
2184         if (msi->msi_handlers > 0)
2185                 return (EBUSY);
2186         for (i = 0; i < msi->msi_alloc; i++) {
2187                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
2188                 KASSERT(rle != NULL, ("missing MSI resource"));
2189                 if (rle->res != NULL)
2190                         return (EBUSY);
2191                 irqs[i] = rle->start;
2192         }
2193
2194         /* Update control register with 0 count. */
2195         KASSERT(!(msi->msi_ctrl & PCIM_MSICTRL_MSI_ENABLE),
2196             ("%s: MSI still enabled", __func__));
2197         msi->msi_ctrl &= ~PCIM_MSICTRL_MME_MASK;
2198         pci_write_config(child, msi->msi_location + PCIR_MSI_CTRL,
2199             msi->msi_ctrl, 2);
2200
2201         /* Release the messages. */
2202         PCIB_RELEASE_MSI(device_get_parent(dev), child, msi->msi_alloc, irqs);
2203         for (i = 0; i < msi->msi_alloc; i++)
2204                 resource_list_delete(&dinfo->resources, SYS_RES_IRQ, i + 1);
2205
2206         /* Update alloc count. */
2207         msi->msi_alloc = 0;
2208         msi->msi_addr = 0;
2209         msi->msi_data = 0;
2210         return (0);
2211 }
2212
2213 /*
2214  * Return the max supported MSI messages this device supports.
2215  * Basically, assuming the MD code can alloc messages, this function
2216  * should return the maximum value that pci_alloc_msi() can return.
2217  * Thus, it is subject to the tunables, etc.
2218  */
2219 int
2220 pci_msi_count_method(device_t dev, device_t child)
2221 {
2222         struct pci_devinfo *dinfo = device_get_ivars(child);
2223         struct pcicfg_msi *msi = &dinfo->cfg.msi;
2224
2225         if (pci_do_msi && msi->msi_location != 0)
2226                 return (msi->msi_msgnum);
2227         return (0);
2228 }
2229
2230 /* kfree pcicfgregs structure and all depending data structures */
2231
2232 int
2233 pci_freecfg(struct pci_devinfo *dinfo)
2234 {
2235         struct devlist *devlist_head;
2236         int i;
2237
2238         devlist_head = &pci_devq;
2239
2240         if (dinfo->cfg.vpd.vpd_reg) {
2241                 kfree(dinfo->cfg.vpd.vpd_ident, M_DEVBUF);
2242                 for (i = 0; i < dinfo->cfg.vpd.vpd_rocnt; i++)
2243                         kfree(dinfo->cfg.vpd.vpd_ros[i].value, M_DEVBUF);
2244                 kfree(dinfo->cfg.vpd.vpd_ros, M_DEVBUF);
2245                 for (i = 0; i < dinfo->cfg.vpd.vpd_wcnt; i++)
2246                         kfree(dinfo->cfg.vpd.vpd_w[i].value, M_DEVBUF);
2247                 kfree(dinfo->cfg.vpd.vpd_w, M_DEVBUF);
2248         }
2249         STAILQ_REMOVE(devlist_head, dinfo, pci_devinfo, pci_links);
2250         kfree(dinfo, M_DEVBUF);
2251
2252         /* increment the generation count */
2253         pci_generation++;
2254
2255         /* we're losing one device */
2256         pci_numdevs--;
2257         return (0);
2258 }
2259
2260 /*
2261  * PCI power manangement
2262  */
2263 int
2264 pci_set_powerstate_method(device_t dev, device_t child, int state)
2265 {
2266         struct pci_devinfo *dinfo = device_get_ivars(child);
2267         pcicfgregs *cfg = &dinfo->cfg;
2268         uint16_t status;
2269         int result, oldstate, highest, delay;
2270
2271         if (cfg->pp.pp_cap == 0)
2272                 return (EOPNOTSUPP);
2273
2274         /*
2275          * Optimize a no state change request away.  While it would be OK to
2276          * write to the hardware in theory, some devices have shown odd
2277          * behavior when going from D3 -> D3.
2278          */
2279         oldstate = pci_get_powerstate(child);
2280         if (oldstate == state)
2281                 return (0);
2282
2283         /*
2284          * The PCI power management specification states that after a state
2285          * transition between PCI power states, system software must
2286          * guarantee a minimal delay before the function accesses the device.
2287          * Compute the worst case delay that we need to guarantee before we
2288          * access the device.  Many devices will be responsive much more
2289          * quickly than this delay, but there are some that don't respond
2290          * instantly to state changes.  Transitions to/from D3 state require
2291          * 10ms, while D2 requires 200us, and D0/1 require none.  The delay
2292          * is done below with DELAY rather than a sleeper function because
2293          * this function can be called from contexts where we cannot sleep.
2294          */
2295         highest = (oldstate > state) ? oldstate : state;
2296         if (highest == PCI_POWERSTATE_D3)
2297             delay = 10000;
2298         else if (highest == PCI_POWERSTATE_D2)
2299             delay = 200;
2300         else
2301             delay = 0;
2302         status = PCI_READ_CONFIG(dev, child, cfg->pp.pp_status, 2)
2303             & ~PCIM_PSTAT_DMASK;
2304         result = 0;
2305         switch (state) {
2306         case PCI_POWERSTATE_D0:
2307                 status |= PCIM_PSTAT_D0;
2308                 break;
2309         case PCI_POWERSTATE_D1:
2310                 if ((cfg->pp.pp_cap & PCIM_PCAP_D1SUPP) == 0)
2311                         return (EOPNOTSUPP);
2312                 status |= PCIM_PSTAT_D1;
2313                 break;
2314         case PCI_POWERSTATE_D2:
2315                 if ((cfg->pp.pp_cap & PCIM_PCAP_D2SUPP) == 0)
2316                         return (EOPNOTSUPP);
2317                 status |= PCIM_PSTAT_D2;
2318                 break;
2319         case PCI_POWERSTATE_D3:
2320                 status |= PCIM_PSTAT_D3;
2321                 break;
2322         default:
2323                 return (EINVAL);
2324         }
2325
2326         if (bootverbose)
2327                 kprintf(
2328                     "pci%d:%d:%d:%d: Transition from D%d to D%d\n",
2329                     dinfo->cfg.domain, dinfo->cfg.bus, dinfo->cfg.slot,
2330                     dinfo->cfg.func, oldstate, state);
2331
2332         PCI_WRITE_CONFIG(dev, child, cfg->pp.pp_status, status, 2);
2333         if (delay)
2334                 DELAY(delay);
2335         return (0);
2336 }
2337
2338 int
2339 pci_get_powerstate_method(device_t dev, device_t child)
2340 {
2341         struct pci_devinfo *dinfo = device_get_ivars(child);
2342         pcicfgregs *cfg = &dinfo->cfg;
2343         uint16_t status;
2344         int result;
2345
2346         if (cfg->pp.pp_cap != 0) {
2347                 status = PCI_READ_CONFIG(dev, child, cfg->pp.pp_status, 2);
2348                 switch (status & PCIM_PSTAT_DMASK) {
2349                 case PCIM_PSTAT_D0:
2350                         result = PCI_POWERSTATE_D0;
2351                         break;
2352                 case PCIM_PSTAT_D1:
2353                         result = PCI_POWERSTATE_D1;
2354                         break;
2355                 case PCIM_PSTAT_D2:
2356                         result = PCI_POWERSTATE_D2;
2357                         break;
2358                 case PCIM_PSTAT_D3:
2359                         result = PCI_POWERSTATE_D3;
2360                         break;
2361                 default:
2362                         result = PCI_POWERSTATE_UNKNOWN;
2363                         break;
2364                 }
2365         } else {
2366                 /* No support, device is always at D0 */
2367                 result = PCI_POWERSTATE_D0;
2368         }
2369         return (result);
2370 }
2371
2372 /*
2373  * Some convenience functions for PCI device drivers.
2374  */
2375
2376 static __inline void
2377 pci_set_command_bit(device_t dev, device_t child, uint16_t bit)
2378 {
2379         uint16_t        command;
2380
2381         command = PCI_READ_CONFIG(dev, child, PCIR_COMMAND, 2);
2382         command |= bit;
2383         PCI_WRITE_CONFIG(dev, child, PCIR_COMMAND, command, 2);
2384 }
2385
2386 static __inline void
2387 pci_clear_command_bit(device_t dev, device_t child, uint16_t bit)
2388 {
2389         uint16_t        command;
2390
2391         command = PCI_READ_CONFIG(dev, child, PCIR_COMMAND, 2);
2392         command &= ~bit;
2393         PCI_WRITE_CONFIG(dev, child, PCIR_COMMAND, command, 2);
2394 }
2395
2396 int
2397 pci_enable_busmaster_method(device_t dev, device_t child)
2398 {
2399         pci_set_command_bit(dev, child, PCIM_CMD_BUSMASTEREN);
2400         return (0);
2401 }
2402
2403 int
2404 pci_disable_busmaster_method(device_t dev, device_t child)
2405 {
2406         pci_clear_command_bit(dev, child, PCIM_CMD_BUSMASTEREN);
2407         return (0);
2408 }
2409
2410 int
2411 pci_enable_io_method(device_t dev, device_t child, int space)
2412 {
2413         uint16_t command;
2414         uint16_t bit;
2415         char *error;
2416
2417         bit = 0;
2418         error = NULL;
2419
2420         switch(space) {
2421         case SYS_RES_IOPORT:
2422                 bit = PCIM_CMD_PORTEN;
2423                 error = "port";
2424                 break;
2425         case SYS_RES_MEMORY:
2426                 bit = PCIM_CMD_MEMEN;
2427                 error = "memory";
2428                 break;
2429         default:
2430                 return (EINVAL);
2431         }
2432         pci_set_command_bit(dev, child, bit);
2433         /* Some devices seem to need a brief stall here, what do to? */
2434         command = PCI_READ_CONFIG(dev, child, PCIR_COMMAND, 2);
2435         if (command & bit)
2436                 return (0);
2437         device_printf(child, "failed to enable %s mapping!\n", error);
2438         return (ENXIO);
2439 }
2440
2441 int
2442 pci_disable_io_method(device_t dev, device_t child, int space)
2443 {
2444         uint16_t command;
2445         uint16_t bit;
2446         char *error;
2447
2448         bit = 0;
2449         error = NULL;
2450
2451         switch(space) {
2452         case SYS_RES_IOPORT:
2453                 bit = PCIM_CMD_PORTEN;
2454                 error = "port";
2455                 break;
2456         case SYS_RES_MEMORY:
2457                 bit = PCIM_CMD_MEMEN;
2458                 error = "memory";
2459                 break;
2460         default:
2461                 return (EINVAL);
2462         }
2463         pci_clear_command_bit(dev, child, bit);
2464         command = PCI_READ_CONFIG(dev, child, PCIR_COMMAND, 2);
2465         if (command & bit) {
2466                 device_printf(child, "failed to disable %s mapping!\n", error);
2467                 return (ENXIO);
2468         }
2469         return (0);
2470 }
2471
2472 /*
2473  * New style pci driver.  Parent device is either a pci-host-bridge or a
2474  * pci-pci-bridge.  Both kinds are represented by instances of pcib.
2475  */
2476
2477 void
2478 pci_print_verbose(struct pci_devinfo *dinfo)
2479 {
2480
2481         if (bootverbose) {
2482                 pcicfgregs *cfg = &dinfo->cfg;
2483
2484                 kprintf("found->\tvendor=0x%04x, dev=0x%04x, revid=0x%02x\n",
2485                     cfg->vendor, cfg->device, cfg->revid);
2486                 kprintf("\tdomain=%d, bus=%d, slot=%d, func=%d\n",
2487                     cfg->domain, cfg->bus, cfg->slot, cfg->func);
2488                 kprintf("\tclass=%02x-%02x-%02x, hdrtype=0x%02x, mfdev=%d\n",
2489                     cfg->baseclass, cfg->subclass, cfg->progif, cfg->hdrtype,
2490                     cfg->mfdev);
2491                 kprintf("\tcmdreg=0x%04x, statreg=0x%04x, cachelnsz=%d (dwords)\n",
2492                     cfg->cmdreg, cfg->statreg, cfg->cachelnsz);
2493                 kprintf("\tlattimer=0x%02x (%d ns), mingnt=0x%02x (%d ns), maxlat=0x%02x (%d ns)\n",
2494                     cfg->lattimer, cfg->lattimer * 30, cfg->mingnt,
2495                     cfg->mingnt * 250, cfg->maxlat, cfg->maxlat * 250);
2496                 if (cfg->intpin > 0)
2497                         kprintf("\tintpin=%c, irq=%d\n",
2498                             cfg->intpin +'a' -1, cfg->intline);
2499                 if (cfg->pp.pp_cap) {
2500                         uint16_t status;
2501
2502                         status = pci_read_config(cfg->dev, cfg->pp.pp_status, 2);
2503                         kprintf("\tpowerspec %d  supports D0%s%s D3  current D%d\n",
2504                             cfg->pp.pp_cap & PCIM_PCAP_SPEC,
2505                             cfg->pp.pp_cap & PCIM_PCAP_D1SUPP ? " D1" : "",
2506                             cfg->pp.pp_cap & PCIM_PCAP_D2SUPP ? " D2" : "",
2507                             status & PCIM_PSTAT_DMASK);
2508                 }
2509                 if (cfg->msi.msi_location) {
2510                         int ctrl;
2511
2512                         ctrl = cfg->msi.msi_ctrl;
2513                         kprintf("\tMSI supports %d message%s%s%s\n",
2514                             cfg->msi.msi_msgnum,
2515                             (cfg->msi.msi_msgnum == 1) ? "" : "s",
2516                             (ctrl & PCIM_MSICTRL_64BIT) ? ", 64 bit" : "",
2517                             (ctrl & PCIM_MSICTRL_VECTOR) ? ", vector masks":"");
2518                 }
2519                 if (cfg->msix.msix_location) {
2520                         kprintf("\tMSI-X supports %d message%s ",
2521                             cfg->msix.msix_msgnum,
2522                             (cfg->msix.msix_msgnum == 1) ? "" : "s");
2523                         if (cfg->msix.msix_table_bar == cfg->msix.msix_pba_bar)
2524                                 kprintf("in map 0x%x\n",
2525                                     cfg->msix.msix_table_bar);
2526                         else
2527                                 kprintf("in maps 0x%x and 0x%x\n",
2528                                     cfg->msix.msix_table_bar,
2529                                     cfg->msix.msix_pba_bar);
2530                 }
2531                 pci_print_verbose_expr(cfg);
2532         }
2533 }
2534
2535 static void
2536 pci_print_verbose_expr(const pcicfgregs *cfg)
2537 {
2538         const struct pcicfg_expr *expr = &cfg->expr;
2539         const char *port_name;
2540         uint16_t port_type;
2541
2542         if (!bootverbose)
2543                 return;
2544
2545         if (expr->expr_ptr == 0) /* No PCI Express capability */
2546                 return;
2547
2548         kprintf("\tPCI Express ver.%d cap=0x%04x",
2549                 expr->expr_cap & PCIEM_CAP_VER_MASK, expr->expr_cap);
2550         if ((expr->expr_cap & PCIEM_CAP_VER_MASK) != PCIEM_CAP_VER_1)
2551                 goto back;
2552
2553         port_type = expr->expr_cap & PCIEM_CAP_PORT_TYPE;
2554
2555         switch (port_type) {
2556         case PCIE_END_POINT:
2557                 port_name = "DEVICE";
2558                 break;
2559         case PCIE_LEG_END_POINT:
2560                 port_name = "LEGDEV";
2561                 break;
2562         case PCIE_ROOT_PORT:
2563                 port_name = "ROOT";
2564                 break;
2565         case PCIE_UP_STREAM_PORT:
2566                 port_name = "UPSTREAM";
2567                 break;
2568         case PCIE_DOWN_STREAM_PORT:
2569                 port_name = "DOWNSTRM";
2570                 break;
2571         case PCIE_PCIE2PCI_BRIDGE:
2572                 port_name = "PCIE2PCI";
2573                 break;
2574         case PCIE_PCI2PCIE_BRIDGE:
2575                 port_name = "PCI2PCIE";
2576                 break;
2577         default:
2578                 port_name = NULL;
2579                 break;
2580         }
2581         if ((port_type == PCIE_ROOT_PORT ||
2582              port_type == PCIE_DOWN_STREAM_PORT) &&
2583             !(expr->expr_cap & PCIEM_CAP_SLOT_IMPL))
2584                 port_name = NULL;
2585         if (port_name != NULL)
2586                 kprintf("[%s]", port_name);
2587
2588         if (pcie_slotimpl(cfg)) {
2589                 kprintf(", slotcap=0x%08x", expr->expr_slotcap);
2590                 if (expr->expr_slotcap & PCIEM_SLTCAP_HP_CAP)
2591                         kprintf("[HOTPLUG]");
2592         }
2593 back:
2594         kprintf("\n");
2595 }
2596
2597 static int
2598 pci_porten(device_t pcib, int b, int s, int f)
2599 {
2600         return (PCIB_READ_CONFIG(pcib, b, s, f, PCIR_COMMAND, 2)
2601                 & PCIM_CMD_PORTEN) != 0;
2602 }
2603
2604 static int
2605 pci_memen(device_t pcib, int b, int s, int f)
2606 {
2607         return (PCIB_READ_CONFIG(pcib, b, s, f, PCIR_COMMAND, 2)
2608                 & PCIM_CMD_MEMEN) != 0;
2609 }
2610
2611 /*
2612  * Add a resource based on a pci map register. Return 1 if the map
2613  * register is a 32bit map register or 2 if it is a 64bit register.
2614  */
2615 static int
2616 pci_add_map(device_t pcib, device_t bus, device_t dev,
2617     int b, int s, int f, int reg, struct resource_list *rl, int force,
2618     int prefetch)
2619 {
2620         uint32_t map;
2621         pci_addr_t base;
2622         pci_addr_t start, end, count;
2623         uint8_t ln2size;
2624         uint8_t ln2range;
2625         uint32_t testval;
2626         uint16_t cmd;
2627         int type;
2628         int barlen;
2629         struct resource *res;
2630
2631         map = PCIB_READ_CONFIG(pcib, b, s, f, reg, 4);
2632         PCIB_WRITE_CONFIG(pcib, b, s, f, reg, 0xffffffff, 4);
2633         testval = PCIB_READ_CONFIG(pcib, b, s, f, reg, 4);
2634         PCIB_WRITE_CONFIG(pcib, b, s, f, reg, map, 4);
2635
2636         if (PCI_BAR_MEM(map)) {
2637                 type = SYS_RES_MEMORY;
2638                 if (map & PCIM_BAR_MEM_PREFETCH)
2639                         prefetch = 1;
2640         } else
2641                 type = SYS_RES_IOPORT;
2642         ln2size = pci_mapsize(testval);
2643         ln2range = pci_maprange(testval);
2644         base = pci_mapbase(map);
2645         barlen = ln2range == 64 ? 2 : 1;
2646
2647         /*
2648          * For I/O registers, if bottom bit is set, and the next bit up
2649          * isn't clear, we know we have a BAR that doesn't conform to the
2650          * spec, so ignore it.  Also, sanity check the size of the data
2651          * areas to the type of memory involved.  Memory must be at least
2652          * 16 bytes in size, while I/O ranges must be at least 4.
2653          */
2654         if (PCI_BAR_IO(testval) && (testval & PCIM_BAR_IO_RESERVED) != 0)
2655                 return (barlen);
2656         if ((type == SYS_RES_MEMORY && ln2size < 4) ||
2657             (type == SYS_RES_IOPORT && ln2size < 2))
2658                 return (barlen);
2659
2660         if (ln2range == 64)
2661                 /* Read the other half of a 64bit map register */
2662                 base |= (uint64_t) PCIB_READ_CONFIG(pcib, b, s, f, reg + 4, 4) << 32;
2663         if (bootverbose) {
2664                 kprintf("\tmap[%02x]: type %s, range %2d, base %#jx, size %2d",
2665                     reg, pci_maptype(map), ln2range, (uintmax_t)base, ln2size);
2666                 if (type == SYS_RES_IOPORT && !pci_porten(pcib, b, s, f))
2667                         kprintf(", port disabled\n");
2668                 else if (type == SYS_RES_MEMORY && !pci_memen(pcib, b, s, f))
2669                         kprintf(", memory disabled\n");
2670                 else
2671                         kprintf(", enabled\n");
2672         }
2673
2674         /*
2675          * If base is 0, then we have problems.  It is best to ignore
2676          * such entries for the moment.  These will be allocated later if
2677          * the driver specifically requests them.  However, some
2678          * removable busses look better when all resources are allocated,
2679          * so allow '0' to be overriden.
2680          *
2681          * Similarly treat maps whose values is the same as the test value
2682          * read back.  These maps have had all f's written to them by the
2683          * BIOS in an attempt to disable the resources.
2684          */
2685         if (!force && (base == 0 || map == testval))
2686                 return (barlen);
2687         if ((u_long)base != base) {
2688                 device_printf(bus,
2689                     "pci%d:%d:%d:%d bar %#x too many address bits",
2690                     pci_get_domain(dev), b, s, f, reg);
2691                 return (barlen);
2692         }
2693
2694         /*
2695          * This code theoretically does the right thing, but has
2696          * undesirable side effects in some cases where peripherals
2697          * respond oddly to having these bits enabled.  Let the user
2698          * be able to turn them off (since pci_enable_io_modes is 1 by
2699          * default).
2700          */
2701         if (pci_enable_io_modes) {
2702                 /* Turn on resources that have been left off by a lazy BIOS */
2703                 if (type == SYS_RES_IOPORT && !pci_porten(pcib, b, s, f)) {
2704                         cmd = PCIB_READ_CONFIG(pcib, b, s, f, PCIR_COMMAND, 2);
2705                         cmd |= PCIM_CMD_PORTEN;
2706                         PCIB_WRITE_CONFIG(pcib, b, s, f, PCIR_COMMAND, cmd, 2);
2707                 }
2708                 if (type == SYS_RES_MEMORY && !pci_memen(pcib, b, s, f)) {
2709                         cmd = PCIB_READ_CONFIG(pcib, b, s, f, PCIR_COMMAND, 2);
2710                         cmd |= PCIM_CMD_MEMEN;
2711                         PCIB_WRITE_CONFIG(pcib, b, s, f, PCIR_COMMAND, cmd, 2);
2712                 }
2713         } else {
2714                 if (type == SYS_RES_IOPORT && !pci_porten(pcib, b, s, f))
2715                         return (barlen);
2716                 if (type == SYS_RES_MEMORY && !pci_memen(pcib, b, s, f))
2717                         return (barlen);
2718         }
2719
2720         count = 1 << ln2size;
2721         if (base == 0 || base == pci_mapbase(testval)) {
2722                 start = 0;      /* Let the parent decide. */
2723                 end = ~0ULL;
2724         } else {
2725                 start = base;
2726                 end = base + (1 << ln2size) - 1;
2727         }
2728         resource_list_add(rl, type, reg, start, end, count);
2729
2730         /*
2731          * Try to allocate the resource for this BAR from our parent
2732          * so that this resource range is already reserved.  The
2733          * driver for this device will later inherit this resource in
2734          * pci_alloc_resource().
2735          */
2736         res = resource_list_alloc(rl, bus, dev, type, &reg, start, end, count,
2737             prefetch ? RF_PREFETCHABLE : 0);
2738         if (res == NULL) {
2739                 /*
2740                  * If the allocation fails, delete the resource list
2741                  * entry to force pci_alloc_resource() to allocate
2742                  * resources from the parent.
2743                  */
2744                 resource_list_delete(rl, type, reg);
2745 #ifdef PCI_BAR_CLEAR
2746                 /* Clear the BAR */
2747                 start = 0;
2748 #else   /* !PCI_BAR_CLEAR */
2749                 /*
2750                  * Don't clear BAR here.  Some BIOS lists HPET as a
2751                  * PCI function, clearing the BAR causes HPET timer
2752                  * stop ticking.
2753                  */
2754                 if (bootverbose) {
2755                         kprintf("pci:%d:%d:%d: resource reservation failed "
2756                                 "%#llx - %#llx\n", b, s, f, start, end);
2757                 }
2758                 return (barlen);
2759 #endif  /* PCI_BAR_CLEAR */
2760         } else {
2761                 start = rman_get_start(res);
2762         }
2763         pci_write_config(dev, reg, start, 4);
2764         if (ln2range == 64)
2765                 pci_write_config(dev, reg + 4, start >> 32, 4);
2766         return (barlen);
2767 }
2768
2769 /*
2770  * For ATA devices we need to decide early what addressing mode to use.
2771  * Legacy demands that the primary and secondary ATA ports sits on the
2772  * same addresses that old ISA hardware did. This dictates that we use
2773  * those addresses and ignore the BAR's if we cannot set PCI native
2774  * addressing mode.
2775  */
2776 static void
2777 pci_ata_maps(device_t pcib, device_t bus, device_t dev, int b,
2778     int s, int f, struct resource_list *rl, int force, uint32_t prefetchmask)
2779 {
2780         int rid, type, progif;
2781 #if 0
2782         /* if this device supports PCI native addressing use it */
2783         progif = pci_read_config(dev, PCIR_PROGIF, 1);
2784         if ((progif & 0x8a) == 0x8a) {
2785                 if (pci_mapbase(pci_read_config(dev, PCIR_BAR(0), 4)) &&
2786                     pci_mapbase(pci_read_config(dev, PCIR_BAR(2), 4))) {
2787                         kprintf("Trying ATA native PCI addressing mode\n");
2788                         pci_write_config(dev, PCIR_PROGIF, progif | 0x05, 1);
2789                 }
2790         }
2791 #endif
2792         progif = pci_read_config(dev, PCIR_PROGIF, 1);
2793         type = SYS_RES_IOPORT;
2794         if (progif & PCIP_STORAGE_IDE_MODEPRIM) {
2795                 pci_add_map(pcib, bus, dev, b, s, f, PCIR_BAR(0), rl, force,
2796                     prefetchmask & (1 << 0));
2797                 pci_add_map(pcib, bus, dev, b, s, f, PCIR_BAR(1), rl, force,
2798                     prefetchmask & (1 << 1));
2799         } else {
2800                 rid = PCIR_BAR(0);
2801                 resource_list_add(rl, type, rid, 0x1f0, 0x1f7, 8);
2802                 resource_list_alloc(rl, bus, dev, type, &rid, 0x1f0, 0x1f7, 8,
2803                     0);
2804                 rid = PCIR_BAR(1);
2805                 resource_list_add(rl, type, rid, 0x3f6, 0x3f6, 1);
2806                 resource_list_alloc(rl, bus, dev, type, &rid, 0x3f6, 0x3f6, 1,
2807                     0);
2808         }
2809         if (progif & PCIP_STORAGE_IDE_MODESEC) {
2810                 pci_add_map(pcib, bus, dev, b, s, f, PCIR_BAR(2), rl, force,
2811                     prefetchmask & (1 << 2));
2812                 pci_add_map(pcib, bus, dev, b, s, f, PCIR_BAR(3), rl, force,
2813                     prefetchmask & (1 << 3));
2814         } else {
2815                 rid = PCIR_BAR(2);
2816                 resource_list_add(rl, type, rid, 0x170, 0x177, 8);
2817                 resource_list_alloc(rl, bus, dev, type, &rid, 0x170, 0x177, 8,
2818                     0);
2819                 rid = PCIR_BAR(3);
2820                 resource_list_add(rl, type, rid, 0x376, 0x376, 1);
2821                 resource_list_alloc(rl, bus, dev, type, &rid, 0x376, 0x376, 1,
2822                     0);
2823         }
2824         pci_add_map(pcib, bus, dev, b, s, f, PCIR_BAR(4), rl, force,
2825             prefetchmask & (1 << 4));
2826         pci_add_map(pcib, bus, dev, b, s, f, PCIR_BAR(5), rl, force,
2827             prefetchmask & (1 << 5));
2828 }
2829
2830 static void
2831 pci_assign_interrupt(device_t bus, device_t dev, int force_route)
2832 {
2833         struct pci_devinfo *dinfo = device_get_ivars(dev);
2834         pcicfgregs *cfg = &dinfo->cfg;
2835         char tunable_name[64];
2836         int irq;
2837
2838         /* Has to have an intpin to have an interrupt. */
2839         if (cfg->intpin == 0)
2840                 return;
2841
2842         /* Let the user override the IRQ with a tunable. */
2843         irq = PCI_INVALID_IRQ;
2844         ksnprintf(tunable_name, sizeof(tunable_name),
2845             "hw.pci%d.%d.%d.INT%c.irq",
2846             cfg->domain, cfg->bus, cfg->slot, cfg->intpin + 'A' - 1);
2847         if (TUNABLE_INT_FETCH(tunable_name, &irq) && (irq >= 255 || irq <= 0))
2848                 irq = PCI_INVALID_IRQ;
2849
2850         /*
2851          * If we didn't get an IRQ via the tunable, then we either use the
2852          * IRQ value in the intline register or we ask the bus to route an
2853          * interrupt for us.  If force_route is true, then we only use the
2854          * value in the intline register if the bus was unable to assign an
2855          * IRQ.
2856          */
2857         if (!PCI_INTERRUPT_VALID(irq)) {
2858                 if (!PCI_INTERRUPT_VALID(cfg->intline) || force_route)
2859                         irq = PCI_ASSIGN_INTERRUPT(bus, dev);
2860                 if (!PCI_INTERRUPT_VALID(irq))
2861                         irq = cfg->intline;
2862         }
2863
2864         /* If after all that we don't have an IRQ, just bail. */
2865         if (!PCI_INTERRUPT_VALID(irq))
2866                 return;
2867
2868         /* Update the config register if it changed. */
2869         if (irq != cfg->intline) {
2870                 cfg->intline = irq;
2871                 pci_write_config(dev, PCIR_INTLINE, irq, 1);
2872         }
2873
2874         /* Add this IRQ as rid 0 interrupt resource. */
2875         resource_list_add(&dinfo->resources, SYS_RES_IRQ, 0, irq, irq, 1);
2876 }
2877
2878 void
2879 pci_add_resources(device_t pcib, device_t bus, device_t dev, int force, uint32_t prefetchmask)
2880 {
2881         struct pci_devinfo *dinfo = device_get_ivars(dev);
2882         pcicfgregs *cfg = &dinfo->cfg;
2883         struct resource_list *rl = &dinfo->resources;
2884         struct pci_quirk *q;
2885         int b, i, f, s;
2886
2887         b = cfg->bus;
2888         s = cfg->slot;
2889         f = cfg->func;
2890
2891         /* ATA devices needs special map treatment */
2892         if ((pci_get_class(dev) == PCIC_STORAGE) &&
2893             (pci_get_subclass(dev) == PCIS_STORAGE_IDE) &&
2894             ((pci_get_progif(dev) & PCIP_STORAGE_IDE_MASTERDEV) ||
2895              (!pci_read_config(dev, PCIR_BAR(0), 4) &&
2896               !pci_read_config(dev, PCIR_BAR(2), 4))) )
2897                 pci_ata_maps(pcib, bus, dev, b, s, f, rl, force, prefetchmask);
2898         else
2899                 for (i = 0; i < cfg->nummaps;)
2900                         i += pci_add_map(pcib, bus, dev, b, s, f, PCIR_BAR(i),
2901                             rl, force, prefetchmask & (1 << i));
2902
2903         /*
2904          * Add additional, quirked resources.
2905          */
2906         for (q = &pci_quirks[0]; q->devid; q++) {
2907                 if (q->devid == ((cfg->device << 16) | cfg->vendor)
2908                     && q->type == PCI_QUIRK_MAP_REG)
2909                         pci_add_map(pcib, bus, dev, b, s, f, q->arg1, rl,
2910                           force, 0);
2911         }
2912
2913         if (cfg->intpin > 0 && PCI_INTERRUPT_VALID(cfg->intline)) {
2914 #ifdef __PCI_REROUTE_INTERRUPT
2915                 /*
2916                  * Try to re-route interrupts. Sometimes the BIOS or
2917                  * firmware may leave bogus values in these registers.
2918                  * If the re-route fails, then just stick with what we
2919                  * have.
2920                  */
2921                 pci_assign_interrupt(bus, dev, 1);
2922 #else
2923                 pci_assign_interrupt(bus, dev, 0);
2924 #endif
2925         }
2926 }
2927
2928 void
2929 pci_add_children(device_t dev, int domain, int busno, size_t dinfo_size)
2930 {
2931 #define REG(n, w)       PCIB_READ_CONFIG(pcib, busno, s, f, n, w)
2932         device_t pcib = device_get_parent(dev);
2933         struct pci_devinfo *dinfo;
2934         int maxslots;
2935         int s, f, pcifunchigh;
2936         uint8_t hdrtype;
2937
2938         KASSERT(dinfo_size >= sizeof(struct pci_devinfo),
2939             ("dinfo_size too small"));
2940         maxslots = PCIB_MAXSLOTS(pcib);
2941         for (s = 0; s <= maxslots; s++) {
2942                 pcifunchigh = 0;
2943                 f = 0;
2944                 DELAY(1);
2945                 hdrtype = REG(PCIR_HDRTYPE, 1);
2946                 if ((hdrtype & PCIM_HDRTYPE) > PCI_MAXHDRTYPE)
2947                         continue;
2948                 if (hdrtype & PCIM_MFDEV)
2949                         pcifunchigh = PCI_FUNCMAX;
2950                 for (f = 0; f <= pcifunchigh; f++) {
2951                         dinfo = pci_read_device(pcib, domain, busno, s, f,
2952                             dinfo_size);
2953                         if (dinfo != NULL) {
2954                                 pci_add_child(dev, dinfo);
2955                         }
2956                 }
2957         }
2958 #undef REG
2959 }
2960
2961 void
2962 pci_add_child(device_t bus, struct pci_devinfo *dinfo)
2963 {
2964         device_t pcib;
2965
2966         pcib = device_get_parent(bus);
2967         dinfo->cfg.dev = device_add_child(bus, NULL, -1);
2968         device_set_ivars(dinfo->cfg.dev, dinfo);
2969         resource_list_init(&dinfo->resources);
2970         pci_cfg_save(dinfo->cfg.dev, dinfo, 0);
2971         pci_cfg_restore(dinfo->cfg.dev, dinfo);
2972         pci_print_verbose(dinfo);
2973         pci_add_resources(pcib, bus, dinfo->cfg.dev, 0, 0);
2974 }
2975
2976 static int
2977 pci_probe(device_t dev)
2978 {
2979         device_set_desc(dev, "PCI bus");
2980
2981         /* Allow other subclasses to override this driver. */
2982         return (-1000);
2983 }
2984
2985 static int
2986 pci_attach(device_t dev)
2987 {
2988         int busno, domain;
2989
2990         /*
2991          * Since there can be multiple independantly numbered PCI
2992          * busses on systems with multiple PCI domains, we can't use
2993          * the unit number to decide which bus we are probing. We ask
2994          * the parent pcib what our domain and bus numbers are.
2995          */
2996         domain = pcib_get_domain(dev);
2997         busno = pcib_get_bus(dev);
2998         if (bootverbose)
2999                 device_printf(dev, "domain=%d, physical bus=%d\n",
3000                     domain, busno);
3001
3002         pci_add_children(dev, domain, busno, sizeof(struct pci_devinfo));
3003
3004         return (bus_generic_attach(dev));
3005 }
3006
3007 int
3008 pci_suspend(device_t dev)
3009 {
3010         int dstate, error, i, numdevs;
3011         device_t acpi_dev, child, *devlist;
3012         struct pci_devinfo *dinfo;
3013
3014         /*
3015          * Save the PCI configuration space for each child and set the
3016          * device in the appropriate power state for this sleep state.
3017          */
3018         acpi_dev = NULL;
3019         if (pci_do_power_resume)
3020                 acpi_dev = devclass_get_device(devclass_find("acpi"), 0);
3021         device_get_children(dev, &devlist, &numdevs);
3022         for (i = 0; i < numdevs; i++) {
3023                 child = devlist[i];
3024                 dinfo = (struct pci_devinfo *) device_get_ivars(child);
3025                 pci_cfg_save(child, dinfo, 0);
3026         }
3027
3028         /* Suspend devices before potentially powering them down. */
3029         error = bus_generic_suspend(dev);
3030         if (error) {
3031                 kfree(devlist, M_TEMP);
3032                 return (error);
3033         }
3034
3035         /*
3036          * Always set the device to D3.  If ACPI suggests a different
3037          * power state, use it instead.  If ACPI is not present, the
3038          * firmware is responsible for managing device power.  Skip
3039          * children who aren't attached since they are powered down
3040          * separately.  Only manage type 0 devices for now.
3041          */
3042         for (i = 0; acpi_dev && i < numdevs; i++) {
3043                 child = devlist[i];
3044                 dinfo = (struct pci_devinfo *) device_get_ivars(child);
3045                 if (device_is_attached(child) && dinfo->cfg.hdrtype == 0) {
3046                         dstate = PCI_POWERSTATE_D3;
3047                         ACPI_PWR_FOR_SLEEP(acpi_dev, child, &dstate);
3048                         pci_set_powerstate(child, dstate);
3049                 }
3050         }
3051         kfree(devlist, M_TEMP);
3052         return (0);
3053 }
3054
3055 int
3056 pci_resume(device_t dev)
3057 {
3058         int i, numdevs;
3059         device_t acpi_dev, child, *devlist;
3060         struct pci_devinfo *dinfo;
3061
3062         /*
3063          * Set each child to D0 and restore its PCI configuration space.
3064          */
3065         acpi_dev = NULL;
3066         if (pci_do_power_resume)
3067                 acpi_dev = devclass_get_device(devclass_find("acpi"), 0);
3068         device_get_children(dev, &devlist, &numdevs);
3069         for (i = 0; i < numdevs; i++) {
3070                 /*
3071                  * Notify ACPI we're going to D0 but ignore the result.  If
3072                  * ACPI is not present, the firmware is responsible for
3073                  * managing device power.  Only manage type 0 devices for now.
3074                  */
3075                 child = devlist[i];
3076                 dinfo = (struct pci_devinfo *) device_get_ivars(child);
3077                 if (acpi_dev && device_is_attached(child) &&
3078                     dinfo->cfg.hdrtype == 0) {
3079                         ACPI_PWR_FOR_SLEEP(acpi_dev, child, NULL);
3080                         pci_set_powerstate(child, PCI_POWERSTATE_D0);
3081                 }
3082
3083                 /* Now the device is powered up, restore its config space. */
3084                 pci_cfg_restore(child, dinfo);
3085         }
3086         kfree(devlist, M_TEMP);
3087         return (bus_generic_resume(dev));
3088 }
3089
3090 static void
3091 pci_load_vendor_data(void)
3092 {
3093         caddr_t vendordata, info;
3094
3095         if ((vendordata = preload_search_by_type("pci_vendor_data")) != NULL) {
3096                 info = preload_search_info(vendordata, MODINFO_ADDR);
3097                 pci_vendordata = *(char **)info;
3098                 info = preload_search_info(vendordata, MODINFO_SIZE);
3099                 pci_vendordata_size = *(size_t *)info;
3100                 /* terminate the database */
3101                 pci_vendordata[pci_vendordata_size] = '\n';
3102         }
3103 }
3104
3105 void
3106 pci_driver_added(device_t dev, driver_t *driver)
3107 {
3108         int numdevs;
3109         device_t *devlist;
3110         device_t child;
3111         struct pci_devinfo *dinfo;
3112         int i;
3113
3114         if (bootverbose)
3115                 device_printf(dev, "driver added\n");
3116         DEVICE_IDENTIFY(driver, dev);
3117         device_get_children(dev, &devlist, &numdevs);
3118         for (i = 0; i < numdevs; i++) {
3119                 child = devlist[i];
3120                 if (device_get_state(child) != DS_NOTPRESENT)
3121                         continue;
3122                 dinfo = device_get_ivars(child);
3123                 pci_print_verbose(dinfo);
3124                 if (bootverbose)
3125                         kprintf("pci%d:%d:%d:%d: reprobing on driver added\n",
3126                             dinfo->cfg.domain, dinfo->cfg.bus, dinfo->cfg.slot,
3127                             dinfo->cfg.func);
3128                 pci_cfg_restore(child, dinfo);
3129                 if (device_probe_and_attach(child) != 0)
3130                         pci_cfg_save(child, dinfo, 1);
3131         }
3132         kfree(devlist, M_TEMP);
3133 }
3134
3135 static void
3136 pci_child_detached(device_t parent __unused, device_t child)
3137 {
3138         /* Turn child's power off */
3139         pci_cfg_save(child, device_get_ivars(child), 1);
3140 }
3141
3142 int
3143 pci_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
3144     driver_intr_t *intr, void *arg, void **cookiep, lwkt_serialize_t serializer)
3145 {
3146 #ifdef MSI
3147         struct pci_devinfo *dinfo;
3148         struct msix_table_entry *mte;
3149         struct msix_vector *mv;
3150         uint64_t addr;
3151         uint32_t data;
3152         int rid;
3153 #endif
3154         int error;
3155         void *cookie;
3156         error = bus_generic_setup_intr(dev, child, irq, flags, intr,
3157             arg, &cookie, serializer);
3158         if (error)
3159                 return (error);
3160
3161         /* If this is not a direct child, just bail out. */
3162         if (device_get_parent(child) != dev) {
3163                 *cookiep = cookie;
3164                 return(0);
3165         }
3166
3167         pci_clear_command_bit(dev, child, PCIM_CMD_INTxDIS);
3168 #ifdef MSI
3169         rid = rman_get_rid(irq);
3170         if (rid == 0) {
3171                 /* Make sure that INTx is enabled */
3172                 pci_clear_command_bit(dev, child, PCIM_CMD_INTxDIS);
3173         } else {
3174                 /*
3175                  * Check to see if the interrupt is MSI or MSI-X.
3176                  * Ask our parent to map the MSI and give
3177                  * us the address and data register values.
3178                  * If we fail for some reason, teardown the
3179                  * interrupt handler.
3180                  */
3181                 dinfo = device_get_ivars(child);
3182                 if (dinfo->cfg.msi.msi_alloc > 0) {
3183                         if (dinfo->cfg.msi.msi_addr == 0) {
3184                                 KASSERT(dinfo->cfg.msi.msi_handlers == 0,
3185                             ("MSI has handlers, but vectors not mapped"));
3186                                 error = PCIB_MAP_MSI(device_get_parent(dev),
3187                                     child, rman_get_start(irq), &addr, &data);
3188                                 if (error)
3189                                         goto bad;
3190                                 dinfo->cfg.msi.msi_addr = addr;
3191                                 dinfo->cfg.msi.msi_data = data;
3192                                 pci_enable_msi(child, addr, data);
3193                         }
3194                         dinfo->cfg.msi.msi_handlers++;
3195                 } else {
3196                         KASSERT(dinfo->cfg.msix.msix_alloc > 0,
3197                             ("No MSI or MSI-X interrupts allocated"));
3198                         KASSERT(rid <= dinfo->cfg.msix.msix_table_len,
3199                             ("MSI-X index too high"));
3200                         mte = &dinfo->cfg.msix.msix_table[rid - 1];
3201                         KASSERT(mte->mte_vector != 0, ("no message vector"));
3202                         mv = &dinfo->cfg.msix.msix_vectors[mte->mte_vector - 1];
3203                         KASSERT(mv->mv_irq == rman_get_start(irq),
3204                             ("IRQ mismatch"));
3205                         if (mv->mv_address == 0) {
3206                                 KASSERT(mte->mte_handlers == 0,
3207                     ("MSI-X table entry has handlers, but vector not mapped"));
3208                                 error = PCIB_MAP_MSI(device_get_parent(dev),
3209                                     child, rman_get_start(irq), &addr, &data);
3210                                 if (error)
3211                                         goto bad;
3212                                 mv->mv_address = addr;
3213                                 mv->mv_data = data;
3214                         }
3215                         if (mte->mte_handlers == 0) {
3216                                 pci_enable_msix(child, rid - 1, mv->mv_address,
3217                                     mv->mv_data);
3218                                 pci_unmask_msix(child, rid - 1);
3219                         }
3220                         mte->mte_handlers++;
3221                 }
3222
3223                 /* Make sure that INTx is disabled if we are using MSI/MSIX */
3224                 pci_set_command_bit(dev, child, PCIM_CMD_INTxDIS);
3225         bad:
3226                 if (error) {
3227                         (void)bus_generic_teardown_intr(dev, child, irq,
3228                             cookie);
3229                         return (error);
3230                 }
3231         }
3232 #endif
3233         *cookiep = cookie;
3234         return (0);
3235 }
3236
3237 int
3238 pci_teardown_intr(device_t dev, device_t child, struct resource *irq,
3239     void *cookie)
3240 {
3241 #ifdef MSI
3242         struct msix_table_entry *mte;
3243         struct resource_list_entry *rle;
3244         struct pci_devinfo *dinfo;
3245         int rid;
3246 #endif
3247         int error;
3248
3249         if (irq == NULL || !(rman_get_flags(irq) & RF_ACTIVE))
3250                 return (EINVAL);
3251
3252         /* If this isn't a direct child, just bail out */
3253         if (device_get_parent(child) != dev)
3254                 return(bus_generic_teardown_intr(dev, child, irq, cookie));
3255
3256         pci_set_command_bit(dev, child, PCIM_CMD_INTxDIS);
3257 #ifdef MSI
3258         rid = rman_get_rid(irq);
3259         if (rid == 0) {
3260                 /* Mask INTx */
3261                 pci_set_command_bit(dev, child, PCIM_CMD_INTxDIS);
3262         } else {
3263                 /*
3264                  * Check to see if the interrupt is MSI or MSI-X.  If so,
3265                  * decrement the appropriate handlers count and mask the
3266                  * MSI-X message, or disable MSI messages if the count
3267                  * drops to 0.
3268                  */
3269                 dinfo = device_get_ivars(child);
3270                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, rid);
3271                 if (rle->res != irq)
3272                         return (EINVAL);
3273                 if (dinfo->cfg.msi.msi_alloc > 0) {
3274                         KASSERT(rid <= dinfo->cfg.msi.msi_alloc,
3275                             ("MSI-X index too high"));
3276                         if (dinfo->cfg.msi.msi_handlers == 0)
3277                                 return (EINVAL);
3278                         dinfo->cfg.msi.msi_handlers--;
3279                         if (dinfo->cfg.msi.msi_handlers == 0)
3280                                 pci_disable_msi(child);
3281                 } else {
3282                         KASSERT(dinfo->cfg.msix.msix_alloc > 0,
3283                             ("No MSI or MSI-X interrupts allocated"));
3284                         KASSERT(rid <= dinfo->cfg.msix.msix_table_len,
3285                             ("MSI-X index too high"));
3286                         mte = &dinfo->cfg.msix.msix_table[rid - 1];
3287                         if (mte->mte_handlers == 0)
3288                                 return (EINVAL);
3289                         mte->mte_handlers--;
3290                         if (mte->mte_handlers == 0)
3291                                 pci_mask_msix(child, rid - 1);
3292                 }
3293         }
3294         error = bus_generic_teardown_intr(dev, child, irq, cookie);
3295         if (rid > 0)
3296                 KASSERT(error == 0,
3297                     ("%s: generic teardown failed for MSI/MSI-X", __func__));
3298 #endif
3299         error = bus_generic_teardown_intr(dev, child, irq, cookie);
3300         return (error);
3301 }
3302
3303 int
3304 pci_print_child(device_t dev, device_t child)
3305 {
3306         struct pci_devinfo *dinfo;
3307         struct resource_list *rl;
3308         int retval = 0;
3309
3310         dinfo = device_get_ivars(child);
3311         rl = &dinfo->resources;
3312
3313         retval += bus_print_child_header(dev, child);
3314
3315         retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx");
3316         retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#lx");
3317         retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld");
3318         if (device_get_flags(dev))
3319                 retval += kprintf(" flags %#x", device_get_flags(dev));
3320
3321         retval += kprintf(" at device %d.%d", pci_get_slot(child),
3322             pci_get_function(child));
3323
3324         retval += bus_print_child_footer(dev, child);
3325
3326         return (retval);
3327 }
3328
3329 static struct
3330 {
3331         int     class;
3332         int     subclass;
3333         char    *desc;
3334 } pci_nomatch_tab[] = {
3335         {PCIC_OLD,              -1,                     "old"},
3336         {PCIC_OLD,              PCIS_OLD_NONVGA,        "non-VGA display device"},
3337         {PCIC_OLD,              PCIS_OLD_VGA,           "VGA-compatible display device"},
3338         {PCIC_STORAGE,          -1,                     "mass storage"},
3339         {PCIC_STORAGE,          PCIS_STORAGE_SCSI,      "SCSI"},
3340         {PCIC_STORAGE,          PCIS_STORAGE_IDE,       "ATA"},
3341         {PCIC_STORAGE,          PCIS_STORAGE_FLOPPY,    "floppy disk"},
3342         {PCIC_STORAGE,          PCIS_STORAGE_IPI,       "IPI"},
3343         {PCIC_STORAGE,          PCIS_STORAGE_RAID,      "RAID"},
3344         {PCIC_STORAGE,          PCIS_STORAGE_ATA_ADMA,  "ATA (ADMA)"},
3345         {PCIC_STORAGE,          PCIS_STORAGE_SATA,      "SATA"},
3346         {PCIC_STORAGE,          PCIS_STORAGE_SAS,       "SAS"},
3347         {PCIC_NETWORK,          -1,                     "network"},
3348         {PCIC_NETWORK,          PCIS_NETWORK_ETHERNET,  "ethernet"},
3349         {PCIC_NETWORK,          PCIS_NETWORK_TOKENRING, "token ring"},
3350         {PCIC_NETWORK,          PCIS_NETWORK_FDDI,      "fddi"},
3351         {PCIC_NETWORK,          PCIS_NETWORK_ATM,       "ATM"},
3352         {PCIC_NETWORK,          PCIS_NETWORK_ISDN,      "ISDN"},
3353         {PCIC_DISPLAY,          -1,                     "display"},
3354         {PCIC_DISPLAY,          PCIS_DISPLAY_VGA,       "VGA"},
3355         {PCIC_DISPLAY,          PCIS_DISPLAY_XGA,       "XGA"},
3356         {PCIC_DISPLAY,          PCIS_DISPLAY_3D,        "3D"},
3357         {PCIC_MULTIMEDIA,       -1,                     "multimedia"},
3358         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_VIDEO,  "video"},
3359         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_AUDIO,  "audio"},
3360         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_TELE,   "telephony"},
3361         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_HDA,    "HDA"},
3362         {PCIC_MEMORY,           -1,                     "memory"},
3363         {PCIC_MEMORY,           PCIS_MEMORY_RAM,        "RAM"},
3364         {PCIC_MEMORY,           PCIS_MEMORY_FLASH,      "flash"},
3365         {PCIC_BRIDGE,           -1,                     "bridge"},
3366         {PCIC_BRIDGE,           PCIS_BRIDGE_HOST,       "HOST-PCI"},
3367         {PCIC_BRIDGE,           PCIS_BRIDGE_ISA,        "PCI-ISA"},
3368         {PCIC_BRIDGE,           PCIS_BRIDGE_EISA,       "PCI-EISA"},
3369         {PCIC_BRIDGE,           PCIS_BRIDGE_MCA,        "PCI-MCA"},
3370         {PCIC_BRIDGE,           PCIS_BRIDGE_PCI,        "PCI-PCI"},
3371         {PCIC_BRIDGE,           PCIS_BRIDGE_PCMCIA,     "PCI-PCMCIA"},
3372         {PCIC_BRIDGE,           PCIS_BRIDGE_NUBUS,      "PCI-NuBus"},
3373         {PCIC_BRIDGE,           PCIS_BRIDGE_CARDBUS,    "PCI-CardBus"},
3374         {PCIC_BRIDGE,           PCIS_BRIDGE_RACEWAY,    "PCI-RACEway"},
3375         {PCIC_SIMPLECOMM,       -1,                     "simple comms"},
3376         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_UART,   "UART"},        /* could detect 16550 */
3377         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_PAR,    "parallel port"},
3378         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_MULSER, "multiport serial"},
3379         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_MODEM,  "generic modem"},
3380         {PCIC_BASEPERIPH,       -1,                     "base peripheral"},
3381         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_PIC,    "interrupt controller"},
3382         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_DMA,    "DMA controller"},
3383         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_TIMER,  "timer"},
3384         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_RTC,    "realtime clock"},
3385         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_PCIHOT, "PCI hot-plug controller"},
3386         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_SDHC,   "SD host controller"},
3387         {PCIC_INPUTDEV,         -1,                     "input device"},
3388         {PCIC_INPUTDEV,         PCIS_INPUTDEV_KEYBOARD, "keyboard"},
3389         {PCIC_INPUTDEV,         PCIS_INPUTDEV_DIGITIZER,"digitizer"},
3390         {PCIC_INPUTDEV,         PCIS_INPUTDEV_MOUSE,    "mouse"},
3391         {PCIC_INPUTDEV,         PCIS_INPUTDEV_SCANNER,  "scanner"},
3392         {PCIC_INPUTDEV,         PCIS_INPUTDEV_GAMEPORT, "gameport"},
3393         {PCIC_DOCKING,          -1,                     "docking station"},
3394         {PCIC_PROCESSOR,        -1,                     "processor"},
3395         {PCIC_SERIALBUS,        -1,                     "serial bus"},
3396         {PCIC_SERIALBUS,        PCIS_SERIALBUS_FW,      "FireWire"},
3397         {PCIC_SERIALBUS,        PCIS_SERIALBUS_ACCESS,  "AccessBus"},
3398         {PCIC_SERIALBUS,        PCIS_SERIALBUS_SSA,     "SSA"},
3399         {PCIC_SERIALBUS,        PCIS_SERIALBUS_USB,     "USB"},
3400         {PCIC_SERIALBUS,        PCIS_SERIALBUS_FC,      "Fibre Channel"},
3401         {PCIC_SERIALBUS,        PCIS_SERIALBUS_SMBUS,   "SMBus"},
3402         {PCIC_WIRELESS,         -1,                     "wireless controller"},
3403         {PCIC_WIRELESS,         PCIS_WIRELESS_IRDA,     "iRDA"},
3404         {PCIC_WIRELESS,         PCIS_WIRELESS_IR,       "IR"},
3405         {PCIC_WIRELESS,         PCIS_WIRELESS_RF,       "RF"},
3406         {PCIC_INTELLIIO,        -1,                     "intelligent I/O controller"},
3407         {PCIC_INTELLIIO,        PCIS_INTELLIIO_I2O,     "I2O"},
3408         {PCIC_SATCOM,           -1,                     "satellite communication"},
3409         {PCIC_SATCOM,           PCIS_SATCOM_TV,         "sat TV"},
3410         {PCIC_SATCOM,           PCIS_SATCOM_AUDIO,      "sat audio"},
3411         {PCIC_SATCOM,           PCIS_SATCOM_VOICE,      "sat voice"},
3412         {PCIC_SATCOM,           PCIS_SATCOM_DATA,       "sat data"},
3413         {PCIC_CRYPTO,           -1,                     "encrypt/decrypt"},
3414         {PCIC_CRYPTO,           PCIS_CRYPTO_NETCOMP,    "network/computer crypto"},
3415         {PCIC_CRYPTO,           PCIS_CRYPTO_ENTERTAIN,  "entertainment crypto"},
3416         {PCIC_DASP,             -1,                     "dasp"},
3417         {PCIC_DASP,             PCIS_DASP_DPIO,         "DPIO module"},
3418         {0, 0,          NULL}
3419 };
3420
3421 void
3422 pci_probe_nomatch(device_t dev, device_t child)
3423 {
3424         int     i;
3425         char    *cp, *scp, *device;
3426
3427         /*
3428          * Look for a listing for this device in a loaded device database.
3429          */
3430         if ((device = pci_describe_device(child)) != NULL) {
3431                 device_printf(dev, "<%s>", device);
3432                 kfree(device, M_DEVBUF);
3433         } else {
3434                 /*
3435                  * Scan the class/subclass descriptions for a general
3436                  * description.
3437                  */
3438                 cp = "unknown";
3439                 scp = NULL;
3440                 for (i = 0; pci_nomatch_tab[i].desc != NULL; i++) {
3441                         if (pci_nomatch_tab[i].class == pci_get_class(child)) {
3442                                 if (pci_nomatch_tab[i].subclass == -1) {
3443                                         cp = pci_nomatch_tab[i].desc;
3444                                 } else if (pci_nomatch_tab[i].subclass ==
3445                                     pci_get_subclass(child)) {
3446                                         scp = pci_nomatch_tab[i].desc;
3447                                 }
3448                         }
3449                 }
3450                 device_printf(dev, "<%s%s%s>",
3451                     cp ? cp : "",
3452                     ((cp != NULL) && (scp != NULL)) ? ", " : "",
3453                     scp ? scp : "");
3454         }
3455         kprintf(" at device %d.%d (no driver attached)\n",
3456             pci_get_slot(child), pci_get_function(child));
3457         pci_cfg_save(child, (struct pci_devinfo *)device_get_ivars(child), 1);
3458         return;
3459 }
3460
3461 /*
3462  * Parse the PCI device database, if loaded, and return a pointer to a
3463  * description of the device.
3464  *
3465  * The database is flat text formatted as follows:
3466  *
3467  * Any line not in a valid format is ignored.
3468  * Lines are terminated with newline '\n' characters.
3469  *
3470  * A VENDOR line consists of the 4 digit (hex) vendor code, a TAB, then
3471  * the vendor name.
3472  *
3473  * A DEVICE line is entered immediately below the corresponding VENDOR ID.
3474  * - devices cannot be listed without a corresponding VENDOR line.
3475  * A DEVICE line consists of a TAB, the 4 digit (hex) device code,
3476  * another TAB, then the device name.
3477  */
3478
3479 /*
3480  * Assuming (ptr) points to the beginning of a line in the database,
3481  * return the vendor or device and description of the next entry.
3482  * The value of (vendor) or (device) inappropriate for the entry type
3483  * is set to -1.  Returns nonzero at the end of the database.
3484  *
3485  * Note that this is slightly unrobust in the face of corrupt data;
3486  * we attempt to safeguard against this by spamming the end of the
3487  * database with a newline when we initialise.
3488  */
3489 static int
3490 pci_describe_parse_line(char **ptr, int *vendor, int *device, char **desc)
3491 {
3492         char    *cp = *ptr;
3493         int     left;
3494
3495         *device = -1;
3496         *vendor = -1;
3497         **desc = '\0';
3498         for (;;) {
3499                 left = pci_vendordata_size - (cp - pci_vendordata);
3500                 if (left <= 0) {
3501                         *ptr = cp;
3502                         return(1);
3503                 }
3504
3505                 /* vendor entry? */
3506                 if (*cp != '\t' &&
3507                     ksscanf(cp, "%x\t%80[^\n]", vendor, *desc) == 2)
3508                         break;
3509                 /* device entry? */
3510                 if (*cp == '\t' &&
3511                     ksscanf(cp, "%x\t%80[^\n]", device, *desc) == 2)
3512                         break;
3513
3514                 /* skip to next line */
3515                 while (*cp != '\n' && left > 0) {
3516                         cp++;
3517                         left--;
3518                 }
3519                 if (*cp == '\n') {
3520                         cp++;
3521                         left--;
3522                 }
3523         }
3524         /* skip to next line */
3525         while (*cp != '\n' && left > 0) {
3526                 cp++;
3527                 left--;
3528         }
3529         if (*cp == '\n' && left > 0)
3530                 cp++;
3531         *ptr = cp;
3532         return(0);
3533 }
3534
3535 static char *
3536 pci_describe_device(device_t dev)
3537 {
3538         int     vendor, device;
3539         char    *desc, *vp, *dp, *line;
3540
3541         desc = vp = dp = NULL;
3542
3543         /*
3544          * If we have no vendor data, we can't do anything.
3545          */
3546         if (pci_vendordata == NULL)
3547                 goto out;
3548
3549         /*
3550          * Scan the vendor data looking for this device
3551          */
3552         line = pci_vendordata;
3553         if ((vp = kmalloc(80, M_DEVBUF, M_NOWAIT)) == NULL)
3554                 goto out;
3555         for (;;) {
3556                 if (pci_describe_parse_line(&line, &vendor, &device, &vp))
3557                         goto out;
3558                 if (vendor == pci_get_vendor(dev))
3559                         break;
3560         }
3561         if ((dp = kmalloc(80, M_DEVBUF, M_NOWAIT)) == NULL)
3562                 goto out;
3563         for (;;) {
3564                 if (pci_describe_parse_line(&line, &vendor, &device, &dp)) {
3565                         *dp = 0;
3566                         break;
3567                 }
3568                 if (vendor != -1) {
3569                         *dp = 0;
3570                         break;
3571                 }
3572                 if (device == pci_get_device(dev))
3573                         break;
3574         }
3575         if (dp[0] == '\0')
3576                 ksnprintf(dp, 80, "0x%x", pci_get_device(dev));
3577         if ((desc = kmalloc(strlen(vp) + strlen(dp) + 3, M_DEVBUF, M_NOWAIT)) !=
3578             NULL)
3579                 ksprintf(desc, "%s, %s", vp, dp);
3580  out:
3581         if (vp != NULL)
3582                 kfree(vp, M_DEVBUF);
3583         if (dp != NULL)
3584                 kfree(dp, M_DEVBUF);
3585         return(desc);
3586 }
3587
3588 int
3589 pci_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
3590 {
3591         struct pci_devinfo *dinfo;
3592         pcicfgregs *cfg;
3593
3594         dinfo = device_get_ivars(child);
3595         cfg = &dinfo->cfg;
3596
3597         switch (which) {
3598         case PCI_IVAR_ETHADDR:
3599                 /*
3600                  * The generic accessor doesn't deal with failure, so
3601                  * we set the return value, then return an error.
3602                  */
3603                 *((uint8_t **) result) = NULL;
3604                 return (EINVAL);
3605         case PCI_IVAR_SUBVENDOR:
3606                 *result = cfg->subvendor;
3607                 break;
3608         case PCI_IVAR_SUBDEVICE:
3609                 *result = cfg->subdevice;
3610                 break;
3611         case PCI_IVAR_VENDOR:
3612                 *result = cfg->vendor;
3613                 break;
3614         case PCI_IVAR_DEVICE:
3615                 *result = cfg->device;
3616                 break;
3617         case PCI_IVAR_DEVID:
3618                 *result = (cfg->device << 16) | cfg->vendor;
3619                 break;
3620         case PCI_IVAR_CLASS:
3621                 *result = cfg->baseclass;
3622                 break;
3623         case PCI_IVAR_SUBCLASS:
3624                 *result = cfg->subclass;
3625                 break;
3626         case PCI_IVAR_PROGIF:
3627                 *result = cfg->progif;
3628                 break;
3629         case PCI_IVAR_REVID:
3630                 *result = cfg->revid;
3631                 break;
3632         case PCI_IVAR_INTPIN:
3633                 *result = cfg->intpin;
3634                 break;
3635         case PCI_IVAR_IRQ:
3636                 *result = cfg->intline;
3637                 break;
3638         case PCI_IVAR_DOMAIN:
3639                 *result = cfg->domain;
3640                 break;
3641         case PCI_IVAR_BUS:
3642                 *result = cfg->bus;
3643                 break;
3644         case PCI_IVAR_SLOT:
3645                 *result = cfg->slot;
3646                 break;
3647         case PCI_IVAR_FUNCTION:
3648                 *result = cfg->func;
3649                 break;
3650         case PCI_IVAR_CMDREG:
3651                 *result = cfg->cmdreg;
3652                 break;
3653         case PCI_IVAR_CACHELNSZ:
3654                 *result = cfg->cachelnsz;
3655                 break;
3656         case PCI_IVAR_MINGNT:
3657                 *result = cfg->mingnt;
3658                 break;
3659         case PCI_IVAR_MAXLAT:
3660                 *result = cfg->maxlat;
3661                 break;
3662         case PCI_IVAR_LATTIMER:
3663                 *result = cfg->lattimer;
3664                 break;
3665         case PCI_IVAR_PCIXCAP_PTR:
3666                 *result = cfg->pcix.pcix_ptr;
3667                 break;
3668         case PCI_IVAR_PCIECAP_PTR:
3669                 *result = cfg->expr.expr_ptr;
3670                 break;
3671         case PCI_IVAR_VPDCAP_PTR:
3672                 *result = cfg->vpd.vpd_reg;
3673                 break;
3674         default:
3675                 return (ENOENT);
3676         }
3677         return (0);
3678 }
3679
3680 int
3681 pci_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
3682 {
3683         struct pci_devinfo *dinfo;
3684
3685         dinfo = device_get_ivars(child);
3686
3687         switch (which) {
3688         case PCI_IVAR_INTPIN:
3689                 dinfo->cfg.intpin = value;
3690                 return (0);
3691         case PCI_IVAR_ETHADDR:
3692         case PCI_IVAR_SUBVENDOR:
3693         case PCI_IVAR_SUBDEVICE:
3694         case PCI_IVAR_VENDOR:
3695         case PCI_IVAR_DEVICE:
3696         case PCI_IVAR_DEVID:
3697         case PCI_IVAR_CLASS:
3698         case PCI_IVAR_SUBCLASS:
3699         case PCI_IVAR_PROGIF:
3700         case PCI_IVAR_REVID:
3701         case PCI_IVAR_IRQ:
3702         case PCI_IVAR_DOMAIN:
3703         case PCI_IVAR_BUS:
3704         case PCI_IVAR_SLOT:
3705         case PCI_IVAR_FUNCTION:
3706                 return (EINVAL);        /* disallow for now */
3707
3708         default:
3709                 return (ENOENT);
3710         }
3711 }
3712 #ifdef notyet
3713 #include "opt_ddb.h"
3714 #ifdef DDB
3715 #include <ddb/ddb.h>
3716 #include <sys/cons.h>
3717
3718 /*
3719  * List resources based on pci map registers, used for within ddb
3720  */
3721
3722 DB_SHOW_COMMAND(pciregs, db_pci_dump)
3723 {
3724         struct pci_devinfo *dinfo;
3725         struct devlist *devlist_head;
3726         struct pci_conf *p;
3727         const char *name;
3728         int i, error, none_count;
3729
3730         none_count = 0;
3731         /* get the head of the device queue */
3732         devlist_head = &pci_devq;
3733
3734         /*
3735          * Go through the list of devices and print out devices
3736          */
3737         for (error = 0, i = 0,
3738              dinfo = STAILQ_FIRST(devlist_head);
3739              (dinfo != NULL) && (error == 0) && (i < pci_numdevs) && !db_pager_quit;
3740              dinfo = STAILQ_NEXT(dinfo, pci_links), i++) {
3741
3742                 /* Populate pd_name and pd_unit */
3743                 name = NULL;
3744                 if (dinfo->cfg.dev)
3745                         name = device_get_name(dinfo->cfg.dev);
3746
3747                 p = &dinfo->conf;
3748                 db_kprintf("%s%d@pci%d:%d:%d:%d:\tclass=0x%06x card=0x%08x "
3749                         "chip=0x%08x rev=0x%02x hdr=0x%02x\n",
3750                         (name && *name) ? name : "none",
3751                         (name && *name) ? (int)device_get_unit(dinfo->cfg.dev) :
3752                         none_count++,
3753                         p->pc_sel.pc_domain, p->pc_sel.pc_bus, p->pc_sel.pc_dev,
3754                         p->pc_sel.pc_func, (p->pc_class << 16) |
3755                         (p->pc_subclass << 8) | p->pc_progif,
3756                         (p->pc_subdevice << 16) | p->pc_subvendor,
3757                         (p->pc_device << 16) | p->pc_vendor,
3758                         p->pc_revid, p->pc_hdr);
3759         }
3760 }
3761 #endif /* DDB */
3762 #endif
3763
3764 static struct resource *
3765 pci_alloc_map(device_t dev, device_t child, int type, int *rid,
3766     u_long start, u_long end, u_long count, u_int flags)
3767 {
3768         struct pci_devinfo *dinfo = device_get_ivars(child);
3769         struct resource_list *rl = &dinfo->resources;
3770         struct resource_list_entry *rle;
3771         struct resource *res;
3772         pci_addr_t map, testval;
3773         int mapsize;
3774
3775         /*
3776          * Weed out the bogons, and figure out how large the BAR/map
3777          * is.  Bars that read back 0 here are bogus and unimplemented.
3778          * Note: atapci in legacy mode are special and handled elsewhere
3779          * in the code.  If you have a atapci device in legacy mode and
3780          * it fails here, that other code is broken.
3781          */
3782         res = NULL;
3783         map = pci_read_config(child, *rid, 4);
3784         pci_write_config(child, *rid, 0xffffffff, 4);
3785         testval = pci_read_config(child, *rid, 4);
3786         if (pci_maprange(testval) == 64)
3787                 map |= (pci_addr_t)pci_read_config(child, *rid + 4, 4) << 32;
3788         if (pci_mapbase(testval) == 0)
3789                 goto out;
3790
3791         /*
3792          * Restore the original value of the BAR.  We may have reprogrammed
3793          * the BAR of the low-level console device and when booting verbose,
3794          * we need the console device addressable.
3795          */
3796         pci_write_config(child, *rid, map, 4);
3797
3798         if (PCI_BAR_MEM(testval)) {
3799                 if (type != SYS_RES_MEMORY) {
3800                         if (bootverbose)
3801                                 device_printf(dev,
3802                                     "child %s requested type %d for rid %#x,"
3803                                     " but the BAR says it is an memio\n",
3804                                     device_get_nameunit(child), type, *rid);
3805                         goto out;
3806                 }
3807         } else {
3808                 if (type != SYS_RES_IOPORT) {
3809                         if (bootverbose)
3810                                 device_printf(dev,
3811                                     "child %s requested type %d for rid %#x,"
3812                                     " but the BAR says it is an ioport\n",
3813                                     device_get_nameunit(child), type, *rid);
3814                         goto out;
3815                 }
3816         }
3817         /*
3818          * For real BARs, we need to override the size that
3819          * the driver requests, because that's what the BAR
3820          * actually uses and we would otherwise have a
3821          * situation where we might allocate the excess to
3822          * another driver, which won't work.
3823          */
3824         mapsize = pci_mapsize(testval);
3825         count = 1UL << mapsize;
3826         if (RF_ALIGNMENT(flags) < mapsize)
3827                 flags = (flags & ~RF_ALIGNMENT_MASK) | RF_ALIGNMENT_LOG2(mapsize);
3828         if (PCI_BAR_MEM(testval) && (testval & PCIM_BAR_MEM_PREFETCH))
3829                 flags |= RF_PREFETCHABLE;
3830
3831         /*
3832          * Allocate enough resource, and then write back the
3833          * appropriate bar for that resource.
3834          */
3835         res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child, type, rid,
3836             start, end, count, flags);
3837         if (res == NULL) {
3838                 device_printf(child,
3839                     "%#lx bytes of rid %#x res %d failed (%#lx, %#lx).\n",
3840                     count, *rid, type, start, end);
3841                 goto out;
3842         }
3843         resource_list_add(rl, type, *rid, start, end, count);
3844         rle = resource_list_find(rl, type, *rid);
3845         if (rle == NULL)
3846                 panic("pci_alloc_map: unexpectedly can't find resource.");
3847         rle->res = res;
3848         rle->start = rman_get_start(res);
3849         rle->end = rman_get_end(res);
3850         rle->count = count;
3851         if (bootverbose)
3852                 device_printf(child,
3853                     "Lazy allocation of %#lx bytes rid %#x type %d at %#lx\n",
3854                     count, *rid, type, rman_get_start(res));
3855         map = rman_get_start(res);
3856 out:;
3857         pci_write_config(child, *rid, map, 4);
3858         if (pci_maprange(testval) == 64)
3859                 pci_write_config(child, *rid + 4, map >> 32, 4);
3860         return (res);
3861 }
3862
3863
3864 struct resource *
3865 pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
3866                    u_long start, u_long end, u_long count, u_int flags)
3867 {
3868         struct pci_devinfo *dinfo = device_get_ivars(child);
3869         struct resource_list *rl = &dinfo->resources;
3870         struct resource_list_entry *rle;
3871         pcicfgregs *cfg = &dinfo->cfg;
3872
3873         /*
3874          * Perform lazy resource allocation
3875          */
3876         if (device_get_parent(child) == dev) {
3877                 switch (type) {
3878                 case SYS_RES_IRQ:
3879                         /*
3880                          * Can't alloc legacy interrupt once MSI messages
3881                          * have been allocated.
3882                          */
3883 #ifdef MSI
3884                         if (*rid == 0 && (cfg->msi.msi_alloc > 0 ||
3885                             cfg->msix.msix_alloc > 0))
3886                                 return (NULL);
3887 #endif
3888                         /*
3889                          * If the child device doesn't have an
3890                          * interrupt routed and is deserving of an
3891                          * interrupt, try to assign it one.
3892                          */
3893                         if (*rid == 0 && !PCI_INTERRUPT_VALID(cfg->intline) &&
3894                             (cfg->intpin != 0))
3895                                 pci_assign_interrupt(dev, child, 0);
3896                         break;
3897                 case SYS_RES_IOPORT:
3898                 case SYS_RES_MEMORY:
3899                         if (*rid < PCIR_BAR(cfg->nummaps)) {
3900                                 /*
3901                                  * Enable the I/O mode.  We should
3902                                  * also be assigning resources too
3903                                  * when none are present.  The
3904                                  * resource_list_alloc kind of sorta does
3905                                  * this...
3906                                  */
3907                                 if (PCI_ENABLE_IO(dev, child, type))
3908                                         return (NULL);
3909                         }
3910                         rle = resource_list_find(rl, type, *rid);
3911                         if (rle == NULL)
3912                                 return (pci_alloc_map(dev, child, type, rid,
3913                                     start, end, count, flags));
3914                         break;
3915                 }
3916                 /*
3917                  * If we've already allocated the resource, then
3918                  * return it now.  But first we may need to activate
3919                  * it, since we don't allocate the resource as active
3920                  * above.  Normally this would be done down in the
3921                  * nexus, but since we short-circuit that path we have
3922                  * to do its job here.  Not sure if we should kfree the
3923                  * resource if it fails to activate.
3924                  */
3925                 rle = resource_list_find(rl, type, *rid);
3926                 if (rle != NULL && rle->res != NULL) {
3927                         if (bootverbose)
3928                                 device_printf(child,
3929                             "Reserved %#lx bytes for rid %#x type %d at %#lx\n",
3930                                     rman_get_size(rle->res), *rid, type,
3931                                     rman_get_start(rle->res));
3932                         if ((flags & RF_ACTIVE) &&
3933                             bus_generic_activate_resource(dev, child, type,
3934                             *rid, rle->res) != 0)
3935                                 return (NULL);
3936                         return (rle->res);
3937                 }
3938         }
3939         return (resource_list_alloc(rl, dev, child, type, rid,
3940             start, end, count, flags));
3941 }
3942
3943 void
3944 pci_delete_resource(device_t dev, device_t child, int type, int rid)
3945 {
3946         struct pci_devinfo *dinfo;
3947         struct resource_list *rl;
3948         struct resource_list_entry *rle;
3949
3950         if (device_get_parent(child) != dev)
3951                 return;
3952
3953         dinfo = device_get_ivars(child);
3954         rl = &dinfo->resources;
3955         rle = resource_list_find(rl, type, rid);
3956         if (rle) {
3957                 if (rle->res) {
3958                         if (rman_get_device(rle->res) != dev ||
3959                             rman_get_flags(rle->res) & RF_ACTIVE) {
3960                                 device_printf(dev, "delete_resource: "
3961                                     "Resource still owned by child, oops. "
3962                                     "(type=%d, rid=%d, addr=%lx)\n",
3963                                     rle->type, rle->rid,
3964                                     rman_get_start(rle->res));
3965                                 return;
3966                         }
3967                         bus_release_resource(dev, type, rid, rle->res);
3968                 }
3969                 resource_list_delete(rl, type, rid);
3970         }
3971         /*
3972          * Why do we turn off the PCI configuration BAR when we delete a
3973          * resource? -- imp
3974          */
3975         pci_write_config(child, rid, 0, 4);
3976         BUS_DELETE_RESOURCE(device_get_parent(dev), child, type, rid);
3977 }
3978
3979 struct resource_list *
3980 pci_get_resource_list (device_t dev, device_t child)
3981 {
3982         struct pci_devinfo *dinfo = device_get_ivars(child);
3983
3984         if (dinfo == NULL)
3985                 return (NULL);
3986
3987         return (&dinfo->resources);
3988 }
3989
3990 uint32_t
3991 pci_read_config_method(device_t dev, device_t child, int reg, int width)
3992 {
3993         struct pci_devinfo *dinfo = device_get_ivars(child);
3994         pcicfgregs *cfg = &dinfo->cfg;
3995
3996         return (PCIB_READ_CONFIG(device_get_parent(dev),
3997             cfg->bus, cfg->slot, cfg->func, reg, width));
3998 }
3999
4000 void
4001 pci_write_config_method(device_t dev, device_t child, int reg,
4002     uint32_t val, int width)
4003 {
4004         struct pci_devinfo *dinfo = device_get_ivars(child);
4005         pcicfgregs *cfg = &dinfo->cfg;
4006
4007         PCIB_WRITE_CONFIG(device_get_parent(dev),
4008             cfg->bus, cfg->slot, cfg->func, reg, val, width);
4009 }
4010
4011 int
4012 pci_child_location_str_method(device_t dev, device_t child, char *buf,
4013     size_t buflen)
4014 {
4015
4016         ksnprintf(buf, buflen, "slot=%d function=%d", pci_get_slot(child),
4017             pci_get_function(child));
4018         return (0);
4019 }
4020
4021 int
4022 pci_child_pnpinfo_str_method(device_t dev, device_t child, char *buf,
4023     size_t buflen)
4024 {
4025         struct pci_devinfo *dinfo;
4026         pcicfgregs *cfg;
4027
4028         dinfo = device_get_ivars(child);
4029         cfg = &dinfo->cfg;
4030         ksnprintf(buf, buflen, "vendor=0x%04x device=0x%04x subvendor=0x%04x "
4031             "subdevice=0x%04x class=0x%02x%02x%02x", cfg->vendor, cfg->device,
4032             cfg->subvendor, cfg->subdevice, cfg->baseclass, cfg->subclass,
4033             cfg->progif);
4034         return (0);
4035 }
4036
4037 int
4038 pci_assign_interrupt_method(device_t dev, device_t child)
4039 {
4040         struct pci_devinfo *dinfo = device_get_ivars(child);
4041         pcicfgregs *cfg = &dinfo->cfg;
4042
4043         return (PCIB_ROUTE_INTERRUPT(device_get_parent(dev), child,
4044             cfg->intpin));
4045 }
4046
4047 static int
4048 pci_modevent(module_t mod, int what, void *arg)
4049 {
4050         static struct cdev *pci_cdev;
4051
4052         switch (what) {
4053         case MOD_LOAD:
4054                 STAILQ_INIT(&pci_devq);
4055                 pci_generation = 0;
4056                 dev_ops_add(&pcic_ops, -1, 0);
4057                 pci_cdev = make_dev(&pcic_ops, 0, UID_ROOT, GID_WHEEL, 0644,
4058                     "pci%d", 0);
4059                 pci_load_vendor_data();
4060                 break;
4061
4062         case MOD_UNLOAD:
4063                 destroy_dev(pci_cdev);
4064                 break;
4065         }
4066
4067         return (0);
4068 }
4069
4070 void
4071 pci_cfg_restore(device_t dev, struct pci_devinfo *dinfo)
4072 {
4073         int i;
4074
4075         /*
4076          * Only do header type 0 devices.  Type 1 devices are bridges,
4077          * which we know need special treatment.  Type 2 devices are
4078          * cardbus bridges which also require special treatment.
4079          * Other types are unknown, and we err on the side of safety
4080          * by ignoring them.
4081          */
4082         if (dinfo->cfg.hdrtype != 0)
4083                 return;
4084
4085         /*
4086          * Restore the device to full power mode.  We must do this
4087          * before we restore the registers because moving from D3 to
4088          * D0 will cause the chip's BARs and some other registers to
4089          * be reset to some unknown power on reset values.  Cut down
4090          * the noise on boot by doing nothing if we are already in
4091          * state D0.
4092          */
4093         if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0) {
4094                 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
4095         }
4096         for (i = 0; i < dinfo->cfg.nummaps; i++)
4097                 pci_write_config(dev, PCIR_BAR(i), dinfo->cfg.bar[i], 4);
4098         pci_write_config(dev, PCIR_BIOS, dinfo->cfg.bios, 4);
4099         pci_write_config(dev, PCIR_COMMAND, dinfo->cfg.cmdreg, 2);
4100         pci_write_config(dev, PCIR_INTLINE, dinfo->cfg.intline, 1);
4101         pci_write_config(dev, PCIR_INTPIN, dinfo->cfg.intpin, 1);
4102         pci_write_config(dev, PCIR_MINGNT, dinfo->cfg.mingnt, 1);
4103         pci_write_config(dev, PCIR_MAXLAT, dinfo->cfg.maxlat, 1);
4104         pci_write_config(dev, PCIR_CACHELNSZ, dinfo->cfg.cachelnsz, 1);
4105         pci_write_config(dev, PCIR_LATTIMER, dinfo->cfg.lattimer, 1);
4106         pci_write_config(dev, PCIR_PROGIF, dinfo->cfg.progif, 1);
4107         pci_write_config(dev, PCIR_REVID, dinfo->cfg.revid, 1);
4108
4109         /* Restore MSI and MSI-X configurations if they are present. */
4110         if (dinfo->cfg.msi.msi_location != 0)
4111                 pci_resume_msi(dev);
4112         if (dinfo->cfg.msix.msix_location != 0)
4113                 pci_resume_msix(dev);
4114 }
4115
4116 void
4117 pci_cfg_save(device_t dev, struct pci_devinfo *dinfo, int setstate)
4118 {
4119         int i;
4120         uint32_t cls;
4121         int ps;
4122
4123         /*
4124          * Only do header type 0 devices.  Type 1 devices are bridges, which
4125          * we know need special treatment.  Type 2 devices are cardbus bridges
4126          * which also require special treatment.  Other types are unknown, and
4127          * we err on the side of safety by ignoring them.  Powering down
4128          * bridges should not be undertaken lightly.
4129          */
4130         if (dinfo->cfg.hdrtype != 0)
4131                 return;
4132         for (i = 0; i < dinfo->cfg.nummaps; i++)
4133                 dinfo->cfg.bar[i] = pci_read_config(dev, PCIR_BAR(i), 4);
4134         dinfo->cfg.bios = pci_read_config(dev, PCIR_BIOS, 4);
4135
4136         /*
4137          * Some drivers apparently write to these registers w/o updating our
4138          * cached copy.  No harm happens if we update the copy, so do so here
4139          * so we can restore them.  The COMMAND register is modified by the
4140          * bus w/o updating the cache.  This should represent the normally
4141          * writable portion of the 'defined' part of type 0 headers.  In
4142          * theory we also need to save/restore the PCI capability structures
4143          * we know about, but apart from power we don't know any that are
4144          * writable.
4145          */
4146         dinfo->cfg.subvendor = pci_read_config(dev, PCIR_SUBVEND_0, 2);
4147         dinfo->cfg.subdevice = pci_read_config(dev, PCIR_SUBDEV_0, 2);
4148         dinfo->cfg.vendor = pci_read_config(dev, PCIR_VENDOR, 2);
4149         dinfo->cfg.device = pci_read_config(dev, PCIR_DEVICE, 2);
4150         dinfo->cfg.cmdreg = pci_read_config(dev, PCIR_COMMAND, 2);
4151         dinfo->cfg.intline = pci_read_config(dev, PCIR_INTLINE, 1);
4152         dinfo->cfg.intpin = pci_read_config(dev, PCIR_INTPIN, 1);
4153         dinfo->cfg.mingnt = pci_read_config(dev, PCIR_MINGNT, 1);
4154         dinfo->cfg.maxlat = pci_read_config(dev, PCIR_MAXLAT, 1);
4155         dinfo->cfg.cachelnsz = pci_read_config(dev, PCIR_CACHELNSZ, 1);
4156         dinfo->cfg.lattimer = pci_read_config(dev, PCIR_LATTIMER, 1);
4157         dinfo->cfg.baseclass = pci_read_config(dev, PCIR_CLASS, 1);
4158         dinfo->cfg.subclass = pci_read_config(dev, PCIR_SUBCLASS, 1);
4159         dinfo->cfg.progif = pci_read_config(dev, PCIR_PROGIF, 1);
4160         dinfo->cfg.revid = pci_read_config(dev, PCIR_REVID, 1);
4161
4162         /*
4163          * don't set the state for display devices, base peripherals and
4164          * memory devices since bad things happen when they are powered down.
4165          * We should (a) have drivers that can easily detach and (b) use
4166          * generic drivers for these devices so that some device actually
4167          * attaches.  We need to make sure that when we implement (a) we don't
4168          * power the device down on a reattach.
4169          */
4170         cls = pci_get_class(dev);
4171         if (!setstate)
4172                 return;
4173         switch (pci_do_power_nodriver)
4174         {
4175                 case 0:         /* NO powerdown at all */
4176                         return;
4177                 case 1:         /* Conservative about what to power down */
4178                         if (cls == PCIC_STORAGE)
4179                                 return;
4180                         /*FALLTHROUGH*/
4181                 case 2:         /* Agressive about what to power down */
4182                         if (cls == PCIC_DISPLAY || cls == PCIC_MEMORY ||
4183                             cls == PCIC_BASEPERIPH)
4184                                 return;
4185                         /*FALLTHROUGH*/
4186                 case 3:         /* Power down everything */
4187                         break;
4188         }
4189         /*
4190          * PCI spec says we can only go into D3 state from D0 state.
4191          * Transition from D[12] into D0 before going to D3 state.
4192          */
4193         ps = pci_get_powerstate(dev);
4194         if (ps != PCI_POWERSTATE_D0 && ps != PCI_POWERSTATE_D3)
4195                 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
4196         if (pci_get_powerstate(dev) != PCI_POWERSTATE_D3)
4197                 pci_set_powerstate(dev, PCI_POWERSTATE_D3);
4198 }
4199
4200 #ifdef COMPAT_OLDPCI
4201
4202 /*
4203  * Locate the parent of a PCI device by scanning the PCI devlist
4204  * and return the entry for the parent.
4205  * For devices on PCI Bus 0 (the host bus), this is the PCI Host.
4206  * For devices on secondary PCI busses, this is that bus' PCI-PCI Bridge.
4207  */
4208 pcicfgregs *
4209 pci_devlist_get_parent(pcicfgregs *cfg)
4210 {
4211         struct devlist *devlist_head;
4212         struct pci_devinfo *dinfo;
4213         pcicfgregs *bridge_cfg;
4214         int i;
4215
4216         dinfo = STAILQ_FIRST(devlist_head = &pci_devq);
4217
4218         /* If the device is on PCI bus 0, look for the host */
4219         if (cfg->bus == 0) {
4220                 for (i = 0; (dinfo != NULL) && (i < pci_numdevs);
4221                 dinfo = STAILQ_NEXT(dinfo, pci_links), i++) {
4222                         bridge_cfg = &dinfo->cfg;
4223                         if (bridge_cfg->baseclass == PCIC_BRIDGE
4224                                 && bridge_cfg->subclass == PCIS_BRIDGE_HOST
4225                                 && bridge_cfg->bus == cfg->bus) {
4226                                 return bridge_cfg;
4227                         }
4228                 }
4229         }
4230
4231         /* If the device is not on PCI bus 0, look for the PCI-PCI bridge */
4232         if (cfg->bus > 0) {
4233                 for (i = 0; (dinfo != NULL) && (i < pci_numdevs);
4234                 dinfo = STAILQ_NEXT(dinfo, pci_links), i++) {
4235                         bridge_cfg = &dinfo->cfg;
4236                         if (bridge_cfg->baseclass == PCIC_BRIDGE
4237                                 && bridge_cfg->subclass == PCIS_BRIDGE_PCI
4238                                 && bridge_cfg->secondarybus == cfg->bus) {
4239                                 return bridge_cfg;
4240                         }
4241                 }
4242         }
4243
4244         return NULL;
4245 }
4246
4247 #endif  /* COMPAT_OLDPCI */