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