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