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