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