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