sys/dev/pci/pci.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1997, Stefan Esser <se@freebsd.org>
   5  * Copyright (c) 2000, Michael Smith <msmith@freebsd.org>
   6  * Copyright (c) 2000, BSDi
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice unmodified, this list of conditions, and the following
  14  *    disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include "opt_bus.h"
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/malloc.h>
  39 #include <sys/module.h>
  40 #include <sys/limits.h>
  41 #include <sys/linker.h>
  42 #include <sys/fcntl.h>
  43 #include <sys/conf.h>
  44 #include <sys/kernel.h>
  45 #include <sys/queue.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/endian.h>
  48
  49 #include <vm/vm.h>
  50 #include <vm/pmap.h>
  51 #include <vm/vm_extern.h>
  52
  53 #include <sys/bus.h>
  54 #include <machine/bus.h>
  55 #include <sys/rman.h>
  56 #include <machine/resource.h>
  57 #include <machine/stdarg.h>
  58
  59 #if defined(__i386__) || defined(__amd64__) || defined(__powerpc__)
  60 #include <machine/intr_machdep.h>
  61 #endif
  62
  63 #include <sys/pciio.h>
  64 #include <dev/pci/pcireg.h>
  65 #include <dev/pci/pcivar.h>
  66 #include <dev/pci/pci_private.h>
  67
  68 #ifdef PCI_IOV
  69 #include <sys/nv.h>
  70 #include <dev/pci/pci_iov_private.h>
  71 #endif
  72
  73 #include <dev/usb/controller/xhcireg.h>
  74 #include <dev/usb/controller/ehcireg.h>
  75 #include <dev/usb/controller/ohcireg.h>
  76 #include <dev/usb/controller/uhcireg.h>
  77
  78 #include "pcib_if.h"
  79 #include "pci_if.h"
  80
  81 #define PCIR_IS_BIOS(cfg, reg)                                          \
  82         (((cfg)->hdrtype == PCIM_HDRTYPE_NORMAL && reg == PCIR_BIOS) || \
  83          ((cfg)->hdrtype == PCIM_HDRTYPE_BRIDGE && reg == PCIR_BIOS_1))
  84
  85 static int              pci_has_quirk(uint32_t devid, int quirk);
  86 static pci_addr_t       pci_mapbase(uint64_t mapreg);
  87 static const char       *pci_maptype(uint64_t mapreg);
  88 static int              pci_maprange(uint64_t mapreg);
  89 static pci_addr_t       pci_rombase(uint64_t mapreg);
  90 static int              pci_romsize(uint64_t testval);
  91 static void             pci_fixancient(pcicfgregs *cfg);
  92 static int              pci_printf(pcicfgregs *cfg, const char *fmt, ...);
  93
  94 static int              pci_porten(device_t dev);
  95 static int              pci_memen(device_t dev);
  96 static void             pci_assign_interrupt(device_t bus, device_t dev,
  97                             int force_route);
  98 static int              pci_add_map(device_t bus, device_t dev, int reg,
  99                             struct resource_list *rl, int force, int prefetch);
 100 static int              pci_probe(device_t dev);
 101 static void             pci_load_vendor_data(void);
 102 static int              pci_describe_parse_line(char **ptr, int *vendor,
 103                             int *device, char **desc);
 104 static char             *pci_describe_device(device_t dev);
 105 static int              pci_modevent(module_t mod, int what, void *arg);
 106 static void             pci_hdrtypedata(device_t pcib, int b, int s, int f,
 107                             pcicfgregs *cfg);
 108 static void             pci_read_cap(device_t pcib, pcicfgregs *cfg);
 109 static int              pci_read_vpd_reg(device_t pcib, pcicfgregs *cfg,
 110                             int reg, uint32_t *data);
 111 #if 0
 112 static int              pci_write_vpd_reg(device_t pcib, pcicfgregs *cfg,
 113                             int reg, uint32_t data);
 114 #endif
 115 static void             pci_read_vpd(device_t pcib, pcicfgregs *cfg);
 116 static void             pci_mask_msix(device_t dev, u_int index);
 117 static void             pci_unmask_msix(device_t dev, u_int index);
 118 static int              pci_msi_blacklisted(void);
 119 static int              pci_msix_blacklisted(void);
 120 static void             pci_resume_msi(device_t dev);
 121 static void             pci_resume_msix(device_t dev);
 122 static int              pci_remap_intr_method(device_t bus, device_t dev,
 123                             u_int irq);
 124 static void             pci_hint_device_unit(device_t acdev, device_t child,
 125                             const char *name, int *unitp);
 126 static int              pci_reset_post(device_t dev, device_t child);
 127 static int              pci_reset_prepare(device_t dev, device_t child);
 128 static int              pci_reset_child(device_t dev, device_t child,
 129                             int flags);
 130
 131 static int              pci_get_id_method(device_t dev, device_t child,
 132                             enum pci_id_type type, uintptr_t *rid);
 133
 134 static struct pci_devinfo * pci_fill_devinfo(device_t pcib, device_t bus, int d,
 135     int b, int s, int f, uint16_t vid, uint16_t did);
 136
 137 static device_method_t pci_methods[] = {
 138         /* Device interface */
 139         DEVMETHOD(device_probe,         pci_probe),
 140         DEVMETHOD(device_attach,        pci_attach),
 141         DEVMETHOD(device_detach,        pci_detach),
 142         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 143         DEVMETHOD(device_suspend,       bus_generic_suspend),
 144         DEVMETHOD(device_resume,        pci_resume),
 145
 146         /* Bus interface */
 147         DEVMETHOD(bus_print_child,      pci_print_child),
 148         DEVMETHOD(bus_probe_nomatch,    pci_probe_nomatch),
 149         DEVMETHOD(bus_read_ivar,        pci_read_ivar),
 150         DEVMETHOD(bus_write_ivar,       pci_write_ivar),
 151         DEVMETHOD(bus_driver_added,     pci_driver_added),
 152         DEVMETHOD(bus_setup_intr,       pci_setup_intr),
 153         DEVMETHOD(bus_teardown_intr,    pci_teardown_intr),
 154         DEVMETHOD(bus_reset_prepare,    pci_reset_prepare),
 155         DEVMETHOD(bus_reset_post,       pci_reset_post),
 156         DEVMETHOD(bus_reset_child,      pci_reset_child),
 157
 158         DEVMETHOD(bus_get_dma_tag,      pci_get_dma_tag),
 159         DEVMETHOD(bus_get_resource_list,pci_get_resource_list),
 160         DEVMETHOD(bus_set_resource,     bus_generic_rl_set_resource),
 161         DEVMETHOD(bus_get_resource,     bus_generic_rl_get_resource),
 162         DEVMETHOD(bus_delete_resource,  pci_delete_resource),
 163         DEVMETHOD(bus_alloc_resource,   pci_alloc_resource),
 164         DEVMETHOD(bus_adjust_resource,  bus_generic_adjust_resource),
 165         DEVMETHOD(bus_release_resource, pci_release_resource),
 166         DEVMETHOD(bus_activate_resource, pci_activate_resource),
 167         DEVMETHOD(bus_deactivate_resource, pci_deactivate_resource),
 168         DEVMETHOD(bus_child_deleted,    pci_child_deleted),
 169         DEVMETHOD(bus_child_detached,   pci_child_detached),
 170         DEVMETHOD(bus_child_pnpinfo_str, pci_child_pnpinfo_str_method),
 171         DEVMETHOD(bus_child_location_str, pci_child_location_str_method),
 172         DEVMETHOD(bus_hint_device_unit, pci_hint_device_unit),
 173         DEVMETHOD(bus_remap_intr,       pci_remap_intr_method),
 174         DEVMETHOD(bus_suspend_child,    pci_suspend_child),
 175         DEVMETHOD(bus_resume_child,     pci_resume_child),
 176         DEVMETHOD(bus_rescan,           pci_rescan_method),
 177
 178         /* PCI interface */
 179         DEVMETHOD(pci_read_config,      pci_read_config_method),
 180         DEVMETHOD(pci_write_config,     pci_write_config_method),
 181         DEVMETHOD(pci_enable_busmaster, pci_enable_busmaster_method),
 182         DEVMETHOD(pci_disable_busmaster, pci_disable_busmaster_method),
 183         DEVMETHOD(pci_enable_io,        pci_enable_io_method),
 184         DEVMETHOD(pci_disable_io,       pci_disable_io_method),
 185         DEVMETHOD(pci_get_vpd_ident,    pci_get_vpd_ident_method),
 186         DEVMETHOD(pci_get_vpd_readonly, pci_get_vpd_readonly_method),
 187         DEVMETHOD(pci_get_powerstate,   pci_get_powerstate_method),
 188         DEVMETHOD(pci_set_powerstate,   pci_set_powerstate_method),
 189         DEVMETHOD(pci_assign_interrupt, pci_assign_interrupt_method),
 190         DEVMETHOD(pci_find_cap,         pci_find_cap_method),
 191         DEVMETHOD(pci_find_next_cap,    pci_find_next_cap_method),
 192         DEVMETHOD(pci_find_extcap,      pci_find_extcap_method),
 193         DEVMETHOD(pci_find_next_extcap, pci_find_next_extcap_method),
 194         DEVMETHOD(pci_find_htcap,       pci_find_htcap_method),
 195         DEVMETHOD(pci_find_next_htcap,  pci_find_next_htcap_method),
 196         DEVMETHOD(pci_alloc_msi,        pci_alloc_msi_method),
 197         DEVMETHOD(pci_alloc_msix,       pci_alloc_msix_method),
 198         DEVMETHOD(pci_enable_msi,       pci_enable_msi_method),
 199         DEVMETHOD(pci_enable_msix,      pci_enable_msix_method),
 200         DEVMETHOD(pci_disable_msi,      pci_disable_msi_method),
 201         DEVMETHOD(pci_remap_msix,       pci_remap_msix_method),
 202         DEVMETHOD(pci_release_msi,      pci_release_msi_method),
 203         DEVMETHOD(pci_msi_count,        pci_msi_count_method),
 204         DEVMETHOD(pci_msix_count,       pci_msix_count_method),
 205         DEVMETHOD(pci_msix_pba_bar,     pci_msix_pba_bar_method),
 206         DEVMETHOD(pci_msix_table_bar,   pci_msix_table_bar_method),
 207         DEVMETHOD(pci_get_id,           pci_get_id_method),
 208         DEVMETHOD(pci_alloc_devinfo,    pci_alloc_devinfo_method),
 209         DEVMETHOD(pci_child_added,      pci_child_added_method),
 210 #ifdef PCI_IOV
 211         DEVMETHOD(pci_iov_attach,       pci_iov_attach_method),
 212         DEVMETHOD(pci_iov_detach,       pci_iov_detach_method),
 213         DEVMETHOD(pci_create_iov_child, pci_create_iov_child_method),
 214 #endif
 215
 216         DEVMETHOD_END
 217 };
 218
 219 DEFINE_CLASS_0(pci, pci_driver, pci_methods, sizeof(struct pci_softc));
 220
 221 static devclass_t pci_devclass;
 222 DRIVER_MODULE(pci, pcib, pci_driver, pci_devclass, pci_modevent, NULL);
 223 MODULE_VERSION(pci, 1);
 224
 225 static char     *pci_vendordata;
 226 static size_t   pci_vendordata_size;
 227
 228 struct pci_quirk {
 229         uint32_t devid; /* Vendor/device of the card */
 230         int     type;
 231 #define PCI_QUIRK_MAP_REG       1 /* PCI map register in weird place */
 232 #define PCI_QUIRK_DISABLE_MSI   2 /* Neither MSI nor MSI-X work */
 233 #define PCI_QUIRK_ENABLE_MSI_VM 3 /* Older chipset in VM where MSI works */
 234 #define PCI_QUIRK_UNMAP_REG     4 /* Ignore PCI map register */
 235 #define PCI_QUIRK_DISABLE_MSIX  5 /* MSI-X doesn't work */
 236 #define PCI_QUIRK_MSI_INTX_BUG  6 /* PCIM_CMD_INTxDIS disables MSI */
 237 #define PCI_QUIRK_REALLOC_BAR   7 /* Can't allocate memory at the default address */
 238         int     arg1;
 239         int     arg2;
 240 };
 241
 242 static const struct pci_quirk pci_quirks[] = {
 243         /* The Intel 82371AB and 82443MX have a map register at offset 0x90. */
 244         { 0x71138086, PCI_QUIRK_MAP_REG,        0x90,    0 },
 245         { 0x719b8086, PCI_QUIRK_MAP_REG,        0x90,    0 },
 246         /* As does the Serverworks OSB4 (the SMBus mapping register) */
 247         { 0x02001166, PCI_QUIRK_MAP_REG,        0x90,    0 },
 248
 249         /*
 250          * MSI doesn't work with the ServerWorks CNB20-HE Host Bridge
 251          * or the CMIC-SL (AKA ServerWorks GC_LE).
 252          */
 253         { 0x00141166, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 254         { 0x00171166, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 255
 256         /*
 257          * MSI doesn't work on earlier Intel chipsets including
 258          * E7500, E7501, E7505, 845, 865, 875/E7210, and 855.
 259          */
 260         { 0x25408086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 261         { 0x254c8086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 262         { 0x25508086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 263         { 0x25608086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 264         { 0x25708086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 265         { 0x25788086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 266         { 0x35808086, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 267
 268         /*
 269          * MSI doesn't work with devices behind the AMD 8131 HT-PCIX
 270          * bridge.
 271          */
 272         { 0x74501022, PCI_QUIRK_DISABLE_MSI,    0,      0 },
 273
 274         /*
 275          * MSI-X allocation doesn't work properly for devices passed through
 276          * by VMware up to at least ESXi 5.1.
 277          */
 278         { 0x079015ad, PCI_QUIRK_DISABLE_MSIX,   0,      0 }, /* PCI/PCI-X */
 279         { 0x07a015ad, PCI_QUIRK_DISABLE_MSIX,   0,      0 }, /* PCIe */
 280
 281         /*
 282          * Some virtualization environments emulate an older chipset
 283          * but support MSI just fine.  QEMU uses the Intel 82440.
 284          */
 285         { 0x12378086, PCI_QUIRK_ENABLE_MSI_VM,  0,      0 },
 286
 287         /*
 288          * HPET MMIO base address may appear in Bar1 for AMD SB600 SMBus
 289          * controller depending on SoftPciRst register (PM_IO 0x55 [7]).
 290          * It prevents us from attaching hpet(4) when the bit is unset.
 291          * Note this quirk only affects SB600 revision A13 and earlier.
 292          * For SB600 A21 and later, firmware must set the bit to hide it.
 293          * For SB700 and later, it is unused and hardcoded to zero.
 294          */
 295         { 0x43851002, PCI_QUIRK_UNMAP_REG,      0x14,   0 },
 296
 297         /*
 298          * Atheros AR8161/AR8162/E2200/E2400/E2500 Ethernet controllers have
 299          * a bug that MSI interrupt does not assert if PCIM_CMD_INTxDIS bit
 300          * of the command register is set.
 301          */
 302         { 0x10911969, PCI_QUIRK_MSI_INTX_BUG,   0,      0 },
 303         { 0xE0911969, PCI_QUIRK_MSI_INTX_BUG,   0,      0 },
 304         { 0xE0A11969, PCI_QUIRK_MSI_INTX_BUG,   0,      0 },
 305         { 0xE0B11969, PCI_QUIRK_MSI_INTX_BUG,   0,      0 },
 306         { 0x10901969, PCI_QUIRK_MSI_INTX_BUG,   0,      0 },
 307
 308         /*
 309          * Broadcom BCM5714(S)/BCM5715(S)/BCM5780(S) Ethernet MACs don't
 310          * issue MSI interrupts with PCIM_CMD_INTxDIS set either.
 311          */
 312         { 0x166814e4, PCI_QUIRK_MSI_INTX_BUG,   0,      0 }, /* BCM5714 */
 313         { 0x166914e4, PCI_QUIRK_MSI_INTX_BUG,   0,      0 }, /* BCM5714S */
 314         { 0x166a14e4, PCI_QUIRK_MSI_INTX_BUG,   0,      0 }, /* BCM5780 */
 315         { 0x166b14e4, PCI_QUIRK_MSI_INTX_BUG,   0,      0 }, /* BCM5780S */
 316         { 0x167814e4, PCI_QUIRK_MSI_INTX_BUG,   0,      0 }, /* BCM5715 */
 317         { 0x167914e4, PCI_QUIRK_MSI_INTX_BUG,   0,      0 }, /* BCM5715S */
 318
 319         /*
 320          * HPE Gen 10 VGA has a memory range that can't be allocated in the
 321          * expected place.
 322          */
 323         { 0x98741002, PCI_QUIRK_REALLOC_BAR,    0,      0 },
 324
 325         { 0 }
 326 };
 327
 328 /* map register information */
 329 #define PCI_MAPMEM      0x01    /* memory map */
 330 #define PCI_MAPMEMP     0x02    /* prefetchable memory map */
 331 #define PCI_MAPPORT     0x04    /* port map */
 332
 333 struct devlist pci_devq;
 334 uint32_t pci_generation;
 335 uint32_t pci_numdevs = 0;
 336 static int pcie_chipset, pcix_chipset;
 337
 338 /* sysctl vars */
 339 SYSCTL_NODE(_hw, OID_AUTO, pci, CTLFLAG_RD, 0, "PCI bus tuning parameters");
 340
 341 static int pci_enable_io_modes = 1;
 342 SYSCTL_INT(_hw_pci, OID_AUTO, enable_io_modes, CTLFLAG_RWTUN,
 343     &pci_enable_io_modes, 1,
 344     "Enable I/O and memory bits in the config register.  Some BIOSes do not"
 345     " enable these bits correctly.  We'd like to do this all the time, but"
 346     " there are some peripherals that this causes problems with.");
 347
 348 static int pci_do_realloc_bars = 0;
 349 SYSCTL_INT(_hw_pci, OID_AUTO, realloc_bars, CTLFLAG_RWTUN,
 350     &pci_do_realloc_bars, 0,
 351     "Attempt to allocate a new range for any BARs whose original "
 352     "firmware-assigned ranges fail to allocate during the initial device scan.");
 353
 354 static int pci_do_power_nodriver = 0;
 355 SYSCTL_INT(_hw_pci, OID_AUTO, do_power_nodriver, CTLFLAG_RWTUN,
 356     &pci_do_power_nodriver, 0,
 357     "Place a function into D3 state when no driver attaches to it.  0 means"
 358     " disable.  1 means conservatively place devices into D3 state.  2 means"
 359     " aggressively place devices into D3 state.  3 means put absolutely"
 360     " everything in D3 state.");
 361
 362 int pci_do_power_resume = 1;
 363 SYSCTL_INT(_hw_pci, OID_AUTO, do_power_resume, CTLFLAG_RWTUN,
 364     &pci_do_power_resume, 1,
 365   "Transition from D3 -> D0 on resume.");
 366
 367 int pci_do_power_suspend = 1;
 368 SYSCTL_INT(_hw_pci, OID_AUTO, do_power_suspend, CTLFLAG_RWTUN,
 369     &pci_do_power_suspend, 1,
 370   "Transition from D0 -> D3 on suspend.");
 371
 372 static int pci_do_msi = 1;
 373 SYSCTL_INT(_hw_pci, OID_AUTO, enable_msi, CTLFLAG_RWTUN, &pci_do_msi, 1,
 374     "Enable support for MSI interrupts");
 375
 376 static int pci_do_msix = 1;
 377 SYSCTL_INT(_hw_pci, OID_AUTO, enable_msix, CTLFLAG_RWTUN, &pci_do_msix, 1,
 378     "Enable support for MSI-X interrupts");
 379
 380 static int pci_msix_rewrite_table = 0;
 381 SYSCTL_INT(_hw_pci, OID_AUTO, msix_rewrite_table, CTLFLAG_RWTUN,
 382     &pci_msix_rewrite_table, 0,
 383     "Rewrite entire MSI-X table when updating MSI-X entries");
 384
 385 static int pci_honor_msi_blacklist = 1;
 386 SYSCTL_INT(_hw_pci, OID_AUTO, honor_msi_blacklist, CTLFLAG_RDTUN,
 387     &pci_honor_msi_blacklist, 1, "Honor chipset blacklist for MSI/MSI-X");
 388
 389 #if defined(__i386__) || defined(__amd64__)
 390 static int pci_usb_takeover = 1;
 391 #else
 392 static int pci_usb_takeover = 0;
 393 #endif
 394 SYSCTL_INT(_hw_pci, OID_AUTO, usb_early_takeover, CTLFLAG_RDTUN,
 395     &pci_usb_takeover, 1,
 396     "Enable early takeover of USB controllers. Disable this if you depend on"
 397     " BIOS emulation of USB devices, that is you use USB devices (like"
 398     " keyboard or mouse) but do not load USB drivers");
 399
 400 static int pci_clear_bars;
 401 SYSCTL_INT(_hw_pci, OID_AUTO, clear_bars, CTLFLAG_RDTUN, &pci_clear_bars, 0,
 402     "Ignore firmware-assigned resources for BARs.");
 403
 404 #if defined(NEW_PCIB) && defined(PCI_RES_BUS)
 405 static int pci_clear_buses;
 406 SYSCTL_INT(_hw_pci, OID_AUTO, clear_buses, CTLFLAG_RDTUN, &pci_clear_buses, 0,
 407     "Ignore firmware-assigned bus numbers.");
 408 #endif
 409
 410 static int pci_enable_ari = 1;
 411 SYSCTL_INT(_hw_pci, OID_AUTO, enable_ari, CTLFLAG_RDTUN, &pci_enable_ari,
 412     0, "Enable support for PCIe Alternative RID Interpretation");
 413
 414 int pci_enable_aspm = 1;
 415 SYSCTL_INT(_hw_pci, OID_AUTO, enable_aspm, CTLFLAG_RDTUN, &pci_enable_aspm,
 416     0, "Enable support for PCIe Active State Power Management");
 417
 418 static int pci_clear_aer_on_attach = 0;
 419 SYSCTL_INT(_hw_pci, OID_AUTO, clear_aer_on_attach, CTLFLAG_RWTUN,
 420     &pci_clear_aer_on_attach, 0,
 421     "Clear port and device AER state on driver attach");
 422
 423 static int
 424 pci_has_quirk(uint32_t devid, int quirk)
 425 {
 426         const struct pci_quirk *q;
 427
 428         for (q = &pci_quirks[0]; q->devid; q++) {
 429                 if (q->devid == devid && q->type == quirk)
 430                         return (1);
 431         }
 432         return (0);
 433 }
 434
 435 /* Find a device_t by bus/slot/function in domain 0 */
 436
 437 device_t
 438 pci_find_bsf(uint8_t bus, uint8_t slot, uint8_t func)
 439 {
 440
 441         return (pci_find_dbsf(0, bus, slot, func));
 442 }
 443
 444 /* Find a device_t by domain/bus/slot/function */
 445
 446 device_t
 447 pci_find_dbsf(uint32_t domain, uint8_t bus, uint8_t slot, uint8_t func)
 448 {
 449         struct pci_devinfo *dinfo;
 450
 451         STAILQ_FOREACH(dinfo, &pci_devq, pci_links) {
 452                 if ((dinfo->cfg.domain == domain) &&
 453                     (dinfo->cfg.bus == bus) &&
 454                     (dinfo->cfg.slot == slot) &&
 455                     (dinfo->cfg.func == func)) {
 456                         return (dinfo->cfg.dev);
 457                 }
 458         }
 459
 460         return (NULL);
 461 }
 462
 463 /* Find a device_t by vendor/device ID */
 464
 465 device_t
 466 pci_find_device(uint16_t vendor, uint16_t device)
 467 {
 468         struct pci_devinfo *dinfo;
 469
 470         STAILQ_FOREACH(dinfo, &pci_devq, pci_links) {
 471                 if ((dinfo->cfg.vendor == vendor) &&
 472                     (dinfo->cfg.device == device)) {
 473                         return (dinfo->cfg.dev);
 474                 }
 475         }
 476
 477         return (NULL);
 478 }
 479
 480 device_t
 481 pci_find_class(uint8_t class, uint8_t subclass)
 482 {
 483         struct pci_devinfo *dinfo;
 484
 485         STAILQ_FOREACH(dinfo, &pci_devq, pci_links) {
 486                 if (dinfo->cfg.baseclass == class &&
 487                     dinfo->cfg.subclass == subclass) {
 488                         return (dinfo->cfg.dev);
 489                 }
 490         }
 491
 492         return (NULL);
 493 }
 494
 495 static int
 496 pci_printf(pcicfgregs *cfg, const char *fmt, ...)
 497 {
 498         va_list ap;
 499         int retval;
 500
 501         retval = printf("pci%d:%d:%d:%d: ", cfg->domain, cfg->bus, cfg->slot,
 502             cfg->func);
 503         va_start(ap, fmt);
 504         retval += vprintf(fmt, ap);
 505         va_end(ap);
 506         return (retval);
 507 }
 508
 509 /* return base address of memory or port map */
 510
 511 static pci_addr_t
 512 pci_mapbase(uint64_t mapreg)
 513 {
 514
 515         if (PCI_BAR_MEM(mapreg))
 516                 return (mapreg & PCIM_BAR_MEM_BASE);
 517         else
 518                 return (mapreg & PCIM_BAR_IO_BASE);
 519 }
 520
 521 /* return map type of memory or port map */
 522
 523 static const char *
 524 pci_maptype(uint64_t mapreg)
 525 {
 526
 527         if (PCI_BAR_IO(mapreg))
 528                 return ("I/O Port");
 529         if (mapreg & PCIM_BAR_MEM_PREFETCH)
 530                 return ("Prefetchable Memory");
 531         return ("Memory");
 532 }
 533
 534 /* return log2 of map size decoded for memory or port map */
 535
 536 int
 537 pci_mapsize(uint64_t testval)
 538 {
 539         int ln2size;
 540
 541         testval = pci_mapbase(testval);
 542         ln2size = 0;
 543         if (testval != 0) {
 544                 while ((testval & 1) == 0)
 545                 {
 546                         ln2size++;
 547                         testval >>= 1;
 548                 }
 549         }
 550         return (ln2size);
 551 }
 552
 553 /* return base address of device ROM */
 554
 555 static pci_addr_t
 556 pci_rombase(uint64_t mapreg)
 557 {
 558
 559         return (mapreg & PCIM_BIOS_ADDR_MASK);
 560 }
 561
 562 /* return log2 of map size decided for device ROM */
 563
 564 static int
 565 pci_romsize(uint64_t testval)
 566 {
 567         int ln2size;
 568
 569         testval = pci_rombase(testval);
 570         ln2size = 0;
 571         if (testval != 0) {
 572                 while ((testval & 1) == 0)
 573                 {
 574                         ln2size++;
 575                         testval >>= 1;
 576                 }
 577         }
 578         return (ln2size);
 579 }
 580
 581 /* return log2 of address range supported by map register */
 582
 583 static int
 584 pci_maprange(uint64_t mapreg)
 585 {
 586         int ln2range = 0;
 587
 588         if (PCI_BAR_IO(mapreg))
 589                 ln2range = 32;
 590         else
 591                 switch (mapreg & PCIM_BAR_MEM_TYPE) {
 592                 case PCIM_BAR_MEM_32:
 593                         ln2range = 32;
 594                         break;
 595                 case PCIM_BAR_MEM_1MB:
 596                         ln2range = 20;
 597                         break;
 598                 case PCIM_BAR_MEM_64:
 599                         ln2range = 64;
 600                         break;
 601                 }
 602         return (ln2range);
 603 }
 604
 605 /* adjust some values from PCI 1.0 devices to match 2.0 standards ... */
 606
 607 static void
 608 pci_fixancient(pcicfgregs *cfg)
 609 {
 610         if ((cfg->hdrtype & PCIM_HDRTYPE) != PCIM_HDRTYPE_NORMAL)
 611                 return;
 612
 613         /* PCI to PCI bridges use header type 1 */
 614         if (cfg->baseclass == PCIC_BRIDGE && cfg->subclass == PCIS_BRIDGE_PCI)
 615                 cfg->hdrtype = PCIM_HDRTYPE_BRIDGE;
 616 }
 617
 618 /* extract header type specific config data */
 619
 620 static void
 621 pci_hdrtypedata(device_t pcib, int b, int s, int f, pcicfgregs *cfg)
 622 {
 623 #define REG(n, w)       PCIB_READ_CONFIG(pcib, b, s, f, n, w)
 624         switch (cfg->hdrtype & PCIM_HDRTYPE) {
 625         case PCIM_HDRTYPE_NORMAL:
 626                 cfg->subvendor      = REG(PCIR_SUBVEND_0, 2);
 627                 cfg->subdevice      = REG(PCIR_SUBDEV_0, 2);
 628                 cfg->mingnt         = REG(PCIR_MINGNT, 1);
 629                 cfg->maxlat         = REG(PCIR_MAXLAT, 1);
 630                 cfg->nummaps        = PCI_MAXMAPS_0;
 631                 break;
 632         case PCIM_HDRTYPE_BRIDGE:
 633                 cfg->bridge.br_seclat = REG(PCIR_SECLAT_1, 1);
 634                 cfg->bridge.br_subbus = REG(PCIR_SUBBUS_1, 1);
 635                 cfg->bridge.br_secbus = REG(PCIR_SECBUS_1, 1);
 636                 cfg->bridge.br_pribus = REG(PCIR_PRIBUS_1, 1);
 637                 cfg->bridge.br_control = REG(PCIR_BRIDGECTL_1, 2);
 638                 cfg->nummaps        = PCI_MAXMAPS_1;
 639                 break;
 640         case PCIM_HDRTYPE_CARDBUS:
 641                 cfg->bridge.br_seclat = REG(PCIR_SECLAT_2, 1);
 642                 cfg->bridge.br_subbus = REG(PCIR_SUBBUS_2, 1);
 643                 cfg->bridge.br_secbus = REG(PCIR_SECBUS_2, 1);
 644                 cfg->bridge.br_pribus = REG(PCIR_PRIBUS_2, 1);
 645                 cfg->bridge.br_control = REG(PCIR_BRIDGECTL_2, 2);
 646                 cfg->subvendor      = REG(PCIR_SUBVEND_2, 2);
 647                 cfg->subdevice      = REG(PCIR_SUBDEV_2, 2);
 648                 cfg->nummaps        = PCI_MAXMAPS_2;
 649                 break;
 650         }
 651 #undef REG
 652 }
 653
 654 /* read configuration header into pcicfgregs structure */
 655 struct pci_devinfo *
 656 pci_read_device(device_t pcib, device_t bus, int d, int b, int s, int f)
 657 {
 658 #define REG(n, w)       PCIB_READ_CONFIG(pcib, b, s, f, n, w)
 659         uint16_t vid, did;
 660
 661         vid = REG(PCIR_VENDOR, 2);
 662         did = REG(PCIR_DEVICE, 2);
 663         if (vid != 0xffff)
 664                 return (pci_fill_devinfo(pcib, bus, d, b, s, f, vid, did));
 665
 666         return (NULL);
 667 }
 668
 669 struct pci_devinfo *
 670 pci_alloc_devinfo_method(device_t dev)
 671 {
 672
 673         return (malloc(sizeof(struct pci_devinfo), M_DEVBUF,
 674             M_WAITOK | M_ZERO));
 675 }
 676
 677 static struct pci_devinfo *
 678 pci_fill_devinfo(device_t pcib, device_t bus, int d, int b, int s, int f,
 679     uint16_t vid, uint16_t did)
 680 {
 681         struct pci_devinfo *devlist_entry;
 682         pcicfgregs *cfg;
 683
 684         devlist_entry = PCI_ALLOC_DEVINFO(bus);
 685
 686         cfg = &devlist_entry->cfg;
 687
 688         cfg->domain             = d;
 689         cfg->bus                = b;
 690         cfg->slot               = s;
 691         cfg->func               = f;
 692         cfg->vendor             = vid;
 693         cfg->device             = did;
 694         cfg->cmdreg             = REG(PCIR_COMMAND, 2);
 695         cfg->statreg            = REG(PCIR_STATUS, 2);
 696         cfg->baseclass          = REG(PCIR_CLASS, 1);
 697         cfg->subclass           = REG(PCIR_SUBCLASS, 1);
 698         cfg->progif             = REG(PCIR_PROGIF, 1);
 699         cfg->revid              = REG(PCIR_REVID, 1);
 700         cfg->hdrtype            = REG(PCIR_HDRTYPE, 1);
 701         cfg->cachelnsz          = REG(PCIR_CACHELNSZ, 1);
 702         cfg->lattimer           = REG(PCIR_LATTIMER, 1);
 703         cfg->intpin             = REG(PCIR_INTPIN, 1);
 704         cfg->intline            = REG(PCIR_INTLINE, 1);
 705
 706         cfg->mfdev              = (cfg->hdrtype & PCIM_MFDEV) != 0;
 707         cfg->hdrtype            &= ~PCIM_MFDEV;
 708         STAILQ_INIT(&cfg->maps);
 709
 710         cfg->iov                = NULL;
 711
 712         pci_fixancient(cfg);
 713         pci_hdrtypedata(pcib, b, s, f, cfg);
 714
 715         if (REG(PCIR_STATUS, 2) & PCIM_STATUS_CAPPRESENT)
 716                 pci_read_cap(pcib, cfg);
 717
 718         STAILQ_INSERT_TAIL(&pci_devq, devlist_entry, pci_links);
 719
 720         devlist_entry->conf.pc_sel.pc_domain = cfg->domain;
 721         devlist_entry->conf.pc_sel.pc_bus = cfg->bus;
 722         devlist_entry->conf.pc_sel.pc_dev = cfg->slot;
 723         devlist_entry->conf.pc_sel.pc_func = cfg->func;
 724         devlist_entry->conf.pc_hdr = cfg->hdrtype;
 725
 726         devlist_entry->conf.pc_subvendor = cfg->subvendor;
 727         devlist_entry->conf.pc_subdevice = cfg->subdevice;
 728         devlist_entry->conf.pc_vendor = cfg->vendor;
 729         devlist_entry->conf.pc_device = cfg->device;
 730
 731         devlist_entry->conf.pc_class = cfg->baseclass;
 732         devlist_entry->conf.pc_subclass = cfg->subclass;
 733         devlist_entry->conf.pc_progif = cfg->progif;
 734         devlist_entry->conf.pc_revid = cfg->revid;
 735
 736         pci_numdevs++;
 737         pci_generation++;
 738
 739         return (devlist_entry);
 740 }
 741 #undef REG
 742
 743 static void
 744 pci_ea_fill_info(device_t pcib, pcicfgregs *cfg)
 745 {
 746 #define REG(n, w)       PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, \
 747     cfg->ea.ea_location + (n), w)
 748         int num_ent;
 749         int ptr;
 750         int a, b;
 751         uint32_t val;
 752         int ent_size;
 753         uint32_t dw[4];
 754         uint64_t base, max_offset;
 755         struct pci_ea_entry *eae;
 756
 757         if (cfg->ea.ea_location == 0)
 758                 return;
 759
 760         STAILQ_INIT(&cfg->ea.ea_entries);
 761
 762         /* Determine the number of entries */
 763         num_ent = REG(PCIR_EA_NUM_ENT, 2);
 764         num_ent &= PCIM_EA_NUM_ENT_MASK;
 765
 766         /* Find the first entry to care of */
 767         ptr = PCIR_EA_FIRST_ENT;
 768
 769         /* Skip DWORD 2 for type 1 functions */
 770         if ((cfg->hdrtype & PCIM_HDRTYPE) == PCIM_HDRTYPE_BRIDGE)
 771                 ptr += 4;
 772
 773         for (a = 0; a < num_ent; a++) {
 774
 775                 eae = malloc(sizeof(*eae), M_DEVBUF, M_WAITOK | M_ZERO);
 776                 eae->eae_cfg_offset = cfg->ea.ea_location + ptr;
 777
 778                 /* Read a number of dwords in the entry */
 779                 val = REG(ptr, 4);
 780                 ptr += 4;
 781                 ent_size = (val & PCIM_EA_ES);
 782
 783                 for (b = 0; b < ent_size; b++) {
 784                         dw[b] = REG(ptr, 4);
 785                         ptr += 4;
 786                 }
 787
 788                 eae->eae_flags = val;
 789                 eae->eae_bei = (PCIM_EA_BEI & val) >> PCIM_EA_BEI_OFFSET;
 790
 791                 base = dw[0] & PCIM_EA_FIELD_MASK;
 792                 max_offset = dw[1] | ~PCIM_EA_FIELD_MASK;
 793                 b = 2;
 794                 if (((dw[0] & PCIM_EA_IS_64) != 0) && (b < ent_size)) {
 795                         base |= (uint64_t)dw[b] << 32UL;
 796                         b++;
 797                 }
 798                 if (((dw[1] & PCIM_EA_IS_64) != 0)
 799                     && (b < ent_size)) {
 800                         max_offset |= (uint64_t)dw[b] << 32UL;
 801                         b++;
 802                 }
 803
 804                 eae->eae_base = base;
 805                 eae->eae_max_offset = max_offset;
 806
 807                 STAILQ_INSERT_TAIL(&cfg->ea.ea_entries, eae, eae_link);
 808
 809                 if (bootverbose) {
 810                         printf("PCI(EA) dev %04x:%04x, bei %d, flags #%x, base #%jx, max_offset #%jx\n",
 811                             cfg->vendor, cfg->device, eae->eae_bei, eae->eae_flags,
 812                             (uintmax_t)eae->eae_base, (uintmax_t)eae->eae_max_offset);
 813                 }
 814         }
 815 }
 816 #undef REG
 817
 818 static void
 819 pci_read_cap(device_t pcib, pcicfgregs *cfg)
 820 {
 821 #define REG(n, w)       PCIB_READ_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, w)
 822 #define WREG(n, v, w)   PCIB_WRITE_CONFIG(pcib, cfg->bus, cfg->slot, cfg->func, n, v, w)
 823 #if defined(__i386__) || defined(__amd64__) || defined(__powerpc__)
 824         uint64_t addr;
 825 #endif
 826         uint32_t val;
 827         int     ptr, nextptr, ptrptr;
 828
 829         switch (cfg->hdrtype & PCIM_HDRTYPE) {
 830         case PCIM_HDRTYPE_NORMAL:
 831         case PCIM_HDRTYPE_BRIDGE:
 832                 ptrptr = PCIR_CAP_PTR;
 833                 break;
 834         case PCIM_HDRTYPE_CARDBUS:
 835                 ptrptr = PCIR_CAP_PTR_2;        /* cardbus capabilities ptr */
 836                 break;
 837         default:
 838                 return;         /* no extended capabilities support */
 839         }
 840         nextptr = REG(ptrptr, 1);       /* sanity check? */
 841
 842         /*
 843          * Read capability entries.
 844          */
 845         while (nextptr != 0) {
 846                 /* Sanity check */
 847                 if (nextptr > 255) {
 848                         printf("illegal PCI extended capability offset %d\n",
 849                             nextptr);
 850                         return;
 851                 }
 852                 /* Find the next entry */
 853                 ptr = nextptr;
 854                 nextptr = REG(ptr + PCICAP_NEXTPTR, 1);
 855
 856                 /* Process this entry */
 857                 switch (REG(ptr + PCICAP_ID, 1)) {
 858                 case PCIY_PMG:          /* PCI power management */
 859                         if (cfg->pp.pp_cap == 0) {
 860                                 cfg->pp.pp_cap = REG(ptr + PCIR_POWER_CAP, 2);
 861                                 cfg->pp.pp_status = ptr + PCIR_POWER_STATUS;
 862                                 cfg->pp.pp_bse = ptr + PCIR_POWER_BSE;
 863                                 if ((nextptr - ptr) > PCIR_POWER_DATA)
 864                                         cfg->pp.pp_data = ptr + PCIR_POWER_DATA;
 865                         }
 866                         break;
 867                 case PCIY_HT:           /* HyperTransport */
 868                         /* Determine HT-specific capability type. */
 869                         val = REG(ptr + PCIR_HT_COMMAND, 2);
 870
 871                         if ((val & 0xe000) == PCIM_HTCAP_SLAVE)
 872                                 cfg->ht.ht_slave = ptr;
 873
 874 #if defined(__i386__) || defined(__amd64__) || defined(__powerpc__)
 875                         switch (val & PCIM_HTCMD_CAP_MASK) {
 876                         case PCIM_HTCAP_MSI_MAPPING:
 877                                 if (!(val & PCIM_HTCMD_MSI_FIXED)) {
 878                                         /* Sanity check the mapping window. */
 879                                         addr = REG(ptr + PCIR_HTMSI_ADDRESS_HI,
 880                                             4);
 881                                         addr <<= 32;
 882                                         addr |= REG(ptr + PCIR_HTMSI_ADDRESS_LO,
 883                                             4);
 884                                         if (addr != MSI_INTEL_ADDR_BASE)
 885                                                 device_printf(pcib,
 886             "HT device at pci%d:%d:%d:%d has non-default MSI window 0x%llx\n",
 887                                                     cfg->domain, cfg->bus,
 888                                                     cfg->slot, cfg->func,
 889                                                     (long long)addr);
 890                                 } else
 891                                         addr = MSI_INTEL_ADDR_BASE;
 892
 893                                 cfg->ht.ht_msimap = ptr;
 894                                 cfg->ht.ht_msictrl = val;
 895                                 cfg->ht.ht_msiaddr = addr;
 896                                 break;
 897                         }
 898 #endif
 899                         break;
 900                 case PCIY_MSI:          /* PCI MSI */
 901                         cfg->msi.msi_location = ptr;
 902                         cfg->msi.msi_ctrl = REG(ptr + PCIR_MSI_CTRL, 2);
 903                         cfg->msi.msi_msgnum = 1 << ((cfg->msi.msi_ctrl &
 904                                                      PCIM_MSICTRL_MMC_MASK)>>1);
 905                         break;
 906                 case PCIY_MSIX:         /* PCI MSI-X */
 907                         cfg->msix.msix_location = ptr;
 908                         cfg->msix.msix_ctrl = REG(ptr + PCIR_MSIX_CTRL, 2);
 909                         cfg->msix.msix_msgnum = (cfg->msix.msix_ctrl &
 910                             PCIM_MSIXCTRL_TABLE_SIZE) + 1;
 911                         val = REG(ptr + PCIR_MSIX_TABLE, 4);
 912                         cfg->msix.msix_table_bar = PCIR_BAR(val &
 913                             PCIM_MSIX_BIR_MASK);
 914                         cfg->msix.msix_table_offset = val & ~PCIM_MSIX_BIR_MASK;
 915                         val = REG(ptr + PCIR_MSIX_PBA, 4);
 916                         cfg->msix.msix_pba_bar = PCIR_BAR(val &
 917                             PCIM_MSIX_BIR_MASK);
 918                         cfg->msix.msix_pba_offset = val & ~PCIM_MSIX_BIR_MASK;
 919                         break;
 920                 case PCIY_VPD:          /* PCI Vital Product Data */
 921                         cfg->vpd.vpd_reg = ptr;
 922                         break;
 923                 case PCIY_SUBVENDOR:
 924                         /* Should always be true. */
 925                         if ((cfg->hdrtype & PCIM_HDRTYPE) ==
 926                             PCIM_HDRTYPE_BRIDGE) {
 927                                 val = REG(ptr + PCIR_SUBVENDCAP_ID, 4);
 928                                 cfg->subvendor = val & 0xffff;
 929                                 cfg->subdevice = val >> 16;
 930                         }
 931                         break;
 932                 case PCIY_PCIX:         /* PCI-X */
 933                         /*
 934                          * Assume we have a PCI-X chipset if we have
 935                          * at least one PCI-PCI bridge with a PCI-X
 936                          * capability.  Note that some systems with
 937                          * PCI-express or HT chipsets might match on
 938                          * this check as well.
 939                          */
 940                         if ((cfg->hdrtype & PCIM_HDRTYPE) ==
 941                             PCIM_HDRTYPE_BRIDGE)
 942                                 pcix_chipset = 1;
 943                         cfg->pcix.pcix_location = ptr;
 944                         break;
 945                 case PCIY_EXPRESS:      /* PCI-express */
 946                         /*
 947                          * Assume we have a PCI-express chipset if we have
 948                          * at least one PCI-express device.
 949                          */
 950                         pcie_chipset = 1;
 951                         cfg->pcie.pcie_location = ptr;
 952                         val = REG(ptr + PCIER_FLAGS, 2);
 953                         cfg->pcie.pcie_type = val & PCIEM_FLAGS_TYPE;
 954                         break;
 955                 case PCIY_EA:           /* Enhanced Allocation */
 956                         cfg->ea.ea_location = ptr;
 957                         pci_ea_fill_info(pcib, cfg);
 958                         break;
 959                 default:
 960                         break;
 961                 }
 962         }
 963
 964 #if defined(__powerpc__)
 965         /*
 966          * Enable the MSI mapping window for all HyperTransport
 967          * slaves.  PCI-PCI bridges have their windows enabled via
 968          * PCIB_MAP_MSI().
 969          */
 970         if (cfg->ht.ht_slave != 0 && cfg->ht.ht_msimap != 0 &&
 971             !(cfg->ht.ht_msictrl & PCIM_HTCMD_MSI_ENABLE)) {
 972                 device_printf(pcib,
 973             "Enabling MSI window for HyperTransport slave at pci%d:%d:%d:%d\n",
 974                     cfg->domain, cfg->bus, cfg->slot, cfg->func);
 975                  cfg->ht.ht_msictrl |= PCIM_HTCMD_MSI_ENABLE;
 976                  WREG(cfg->ht.ht_msimap + PCIR_HT_COMMAND, cfg->ht.ht_msictrl,
 977                      2);
 978         }
 979 #endif
 980 /* REG and WREG use carry through to next functions */
 981 }
 982
 983 /*
 984  * PCI Vital Product Data
 985  */
 986
 987 #define PCI_VPD_TIMEOUT         1000000
 988
 989 static int
 990 pci_read_vpd_reg(device_t pcib, pcicfgregs *cfg, int reg, uint32_t *data)
 991 {
 992         int count = PCI_VPD_TIMEOUT;
 993
 994         KASSERT((reg & 3) == 0, ("VPD register must by 4 byte aligned"));
 995
 996         WREG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, reg, 2);
 997
 998         while ((REG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, 2) & 0x8000) != 0x8000) {
 999                 if (--count < 0)
1000                         return (ENXIO);
1001                 DELAY(1);       /* limit looping */
1002         }
1003         *data = (REG(cfg->vpd.vpd_reg + PCIR_VPD_DATA, 4));
1004
1005         return (0);
1006 }
1007
1008 #if 0
1009 static int
1010 pci_write_vpd_reg(device_t pcib, pcicfgregs *cfg, int reg, uint32_t data)
1011 {
1012         int count = PCI_VPD_TIMEOUT;
1013
1014         KASSERT((reg & 3) == 0, ("VPD register must by 4 byte aligned"));
1015
1016         WREG(cfg->vpd.vpd_reg + PCIR_VPD_DATA, data, 4);
1017         WREG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, reg | 0x8000, 2);
1018         while ((REG(cfg->vpd.vpd_reg + PCIR_VPD_ADDR, 2) & 0x8000) == 0x8000) {
1019                 if (--count < 0)
1020                         return (ENXIO);
1021                 DELAY(1);       /* limit looping */
1022         }
1023
1024         return (0);
1025 }
1026 #endif
1027
1028 #undef PCI_VPD_TIMEOUT
1029
1030 struct vpd_readstate {
1031         device_t        pcib;
1032         pcicfgregs      *cfg;
1033         uint32_t        val;
1034         int             bytesinval;
1035         int             off;
1036         uint8_t         cksum;
1037 };
1038
1039 static int
1040 vpd_nextbyte(struct vpd_readstate *vrs, uint8_t *data)
1041 {
1042         uint32_t reg;
1043         uint8_t byte;
1044
1045         if (vrs->bytesinval == 0) {
1046                 if (pci_read_vpd_reg(vrs->pcib, vrs->cfg, vrs->off, &reg))
1047                         return (ENXIO);
1048                 vrs->val = le32toh(reg);
1049                 vrs->off += 4;
1050                 byte = vrs->val & 0xff;
1051                 vrs->bytesinval = 3;
1052         } else {
1053                 vrs->val = vrs->val >> 8;
1054                 byte = vrs->val & 0xff;
1055                 vrs->bytesinval--;
1056         }
1057
1058         vrs->cksum += byte;
1059         *data = byte;
1060         return (0);
1061 }
1062
1063 static void
1064 pci_read_vpd(device_t pcib, pcicfgregs *cfg)
1065 {
1066         struct vpd_readstate vrs;
1067         int state;
1068         int name;
1069         int remain;
1070         int i;
1071         int alloc, off;         /* alloc/off for RO/W arrays */
1072         int cksumvalid;
1073         int dflen;
1074         uint8_t byte;
1075         uint8_t byte2;
1076
1077         /* init vpd reader */
1078         vrs.bytesinval = 0;
1079         vrs.off = 0;
1080         vrs.pcib = pcib;
1081         vrs.cfg = cfg;
1082         vrs.cksum = 0;
1083
1084         state = 0;
1085         name = remain = i = 0;  /* shut up stupid gcc */
1086         alloc = off = 0;        /* shut up stupid gcc */
1087         dflen = 0;              /* shut up stupid gcc */
1088         cksumvalid = -1;
1089         while (state >= 0) {
1090                 if (vpd_nextbyte(&vrs, &byte)) {
1091                         state = -2;
1092                         break;
1093                 }
1094 #if 0
1095                 printf("vpd: val: %#x, off: %d, bytesinval: %d, byte: %#hhx, " \
1096                     "state: %d, remain: %d, name: %#x, i: %d\n", vrs.val,
1097                     vrs.off, vrs.bytesinval, byte, state, remain, name, i);
1098 #endif
1099                 switch (state) {
1100                 case 0:         /* item name */
1101                         if (byte & 0x80) {
1102                                 if (vpd_nextbyte(&vrs, &byte2)) {
1103                                         state = -2;
1104                                         break;
1105                                 }
1106                                 remain = byte2;
1107                                 if (vpd_nextbyte(&vrs, &byte2)) {
1108                                         state = -2;
1109                                         break;
1110                                 }
1111                                 remain |= byte2 << 8;
1112                                 name = byte & 0x7f;
1113                         } else {
1114                                 remain = byte & 0x7;
1115                                 name = (byte >> 3) & 0xf;
1116                         }
1117                         if (vrs.off + remain - vrs.bytesinval > 0x8000) {
1118                                 pci_printf(cfg,
1119                                     "VPD data overflow, remain %#x\n", remain);
1120                                 state = -1;
1121                                 break;
1122                         }
1123                         switch (name) {
1124                         case 0x2:       /* String */
1125                                 cfg->vpd.vpd_ident = malloc(remain + 1,
1126                                     M_DEVBUF, M_WAITOK);
1127                                 i = 0;
1128                                 state = 1;
1129                                 break;
1130                         case 0xf:       /* End */
1131                                 state = -1;
1132                                 break;
1133                         case 0x10:      /* VPD-R */
1134                                 alloc = 8;
1135                                 off = 0;
1136                                 cfg->vpd.vpd_ros = malloc(alloc *
1137                                     sizeof(*cfg->vpd.vpd_ros), M_DEVBUF,
1138                                     M_WAITOK | M_ZERO);
1139                                 state = 2;
1140                                 break;
1141                         case 0x11:      /* VPD-W */
1142                                 alloc = 8;
1143                                 off = 0;
1144                                 cfg->vpd.vpd_w = malloc(alloc *
1145                                     sizeof(*cfg->vpd.vpd_w), M_DEVBUF,
1146                                     M_WAITOK | M_ZERO);
1147                                 state = 5;
1148                                 break;
1149                         default:        /* Invalid data, abort */
1150                                 state = -1;
1151                                 break;
1152                         }
1153                         break;
1154
1155                 case 1: /* Identifier String */
1156                         cfg->vpd.vpd_ident[i++] = byte;
1157                         remain--;
1158                         if (remain == 0)  {
1159                                 cfg->vpd.vpd_ident[i] = '\0';
1160                                 state = 0;
1161                         }
1162                         break;
1163
1164                 case 2: /* VPD-R Keyword Header */
1165                         if (off == alloc) {
1166                                 cfg->vpd.vpd_ros = reallocf(cfg->vpd.vpd_ros,
1167                                     (alloc *= 2) * sizeof(*cfg->vpd.vpd_ros),
1168                                     M_DEVBUF, M_WAITOK | M_ZERO);
1169                         }
1170                         cfg->vpd.vpd_ros[off].keyword[0] = byte;
1171                         if (vpd_nextbyte(&vrs, &byte2)) {
1172                                 state = -2;
1173                                 break;
1174                         }
1175                         cfg->vpd.vpd_ros[off].keyword[1] = byte2;
1176                         if (vpd_nextbyte(&vrs, &byte2)) {
1177                                 state = -2;
1178                                 break;
1179                         }
1180                         cfg->vpd.vpd_ros[off].len = dflen = byte2;
1181                         if (dflen == 0 &&
1182                             strncmp(cfg->vpd.vpd_ros[off].keyword, "RV",
1183                             2) == 0) {
1184                                 /*
1185                                  * if this happens, we can't trust the rest
1186                                  * of the VPD.
1187                                  */
1188                                 pci_printf(cfg, "bad keyword length: %d\n",
1189                                     dflen);
1190                                 cksumvalid = 0;
1191                                 state = -1;
1192                                 break;
1193                         } else if (dflen == 0) {
1194                                 cfg->vpd.vpd_ros[off].value = malloc(1 *
1195                                     sizeof(*cfg->vpd.vpd_ros[off].value),
1196                                     M_DEVBUF, M_WAITOK);
1197                                 cfg->vpd.vpd_ros[off].value[0] = '\x00';
1198                         } else
1199                                 cfg->vpd.vpd_ros[off].value = malloc(
1200                                     (dflen + 1) *
1201                                     sizeof(*cfg->vpd.vpd_ros[off].value),
1202                                     M_DEVBUF, M_WAITOK);
1203                         remain -= 3;
1204                         i = 0;
1205                         /* keep in sync w/ state 3's transistions */
1206                         if (dflen == 0 && remain == 0)
1207                                 state = 0;
1208                         else if (dflen == 0)
1209                                 state = 2;
1210                         else
1211                                 state = 3;
1212                         break;
1213
1214                 case 3: /* VPD-R Keyword Value */
1215                         cfg->vpd.vpd_ros[off].value[i++] = byte;
1216                         if (strncmp(cfg->vpd.vpd_ros[off].keyword,
1217                             "RV", 2) == 0 && cksumvalid == -1) {
1218                                 if (vrs.cksum == 0)
1219                                         cksumvalid = 1;
1220                                 else {
1221                                         if (bootverbose)
1222                                                 pci_printf(cfg,
1223                                             "bad VPD cksum, remain %hhu\n",
1224                                                     vrs.cksum);
1225                                         cksumvalid = 0;
1226                                         state = -1;
1227                                         break;
1228                                 }
1229                         }
1230                         dflen--;
1231                         remain--;
1232                         /* keep in sync w/ state 2's transistions */
1233                         if (dflen == 0)
1234                                 cfg->vpd.vpd_ros[off++].value[i++] = '\0';
1235                         if (dflen == 0 && remain == 0) {
1236                                 cfg->vpd.vpd_rocnt = off;
1237                                 cfg->vpd.vpd_ros = reallocf(cfg->vpd.vpd_ros,
1238                                     off * sizeof(*cfg->vpd.vpd_ros),
1239                                     M_DEVBUF, M_WAITOK | M_ZERO);
1240                                 state = 0;
1241                         } else if (dflen == 0)
1242                                 state = 2;
1243                         break;
1244
1245                 case 4:
1246                         remain--;
1247                         if (remain == 0)
1248                                 state = 0;
1249                         break;
1250
1251                 case 5: /* VPD-W Keyword Header */
1252                         if (off == alloc) {
1253                                 cfg->vpd.vpd_w = reallocf(cfg->vpd.vpd_w,
1254                                     (alloc *= 2) * sizeof(*cfg->vpd.vpd_w),
1255                                     M_DEVBUF, M_WAITOK | M_ZERO);
1256                         }
1257                         cfg->vpd.vpd_w[off].keyword[0] = byte;
1258                         if (vpd_nextbyte(&vrs, &byte2)) {
1259                                 state = -2;
1260                                 break;
1261                         }
1262                         cfg->vpd.vpd_w[off].keyword[1] = byte2;
1263                         if (vpd_nextbyte(&vrs, &byte2)) {
1264                                 state = -2;
1265                                 break;
1266                         }
1267                         cfg->vpd.vpd_w[off].len = dflen = byte2;
1268                         cfg->vpd.vpd_w[off].start = vrs.off - vrs.bytesinval;
1269                         cfg->vpd.vpd_w[off].value = malloc((dflen + 1) *
1270                             sizeof(*cfg->vpd.vpd_w[off].value),
1271                             M_DEVBUF, M_WAITOK);
1272                         remain -= 3;
1273                         i = 0;
1274                         /* keep in sync w/ state 6's transistions */
1275                         if (dflen == 0 && remain == 0)
1276                                 state = 0;
1277                         else if (dflen == 0)
1278                                 state = 5;
1279                         else
1280                                 state = 6;
1281                         break;
1282
1283                 case 6: /* VPD-W Keyword Value */
1284                         cfg->vpd.vpd_w[off].value[i++] = byte;
1285                         dflen--;
1286                         remain--;
1287                         /* keep in sync w/ state 5's transistions */
1288                         if (dflen == 0)
1289                                 cfg->vpd.vpd_w[off++].value[i++] = '\0';
1290                         if (dflen == 0 && remain == 0) {
1291                                 cfg->vpd.vpd_wcnt = off;
1292                                 cfg->vpd.vpd_w = reallocf(cfg->vpd.vpd_w,
1293                                     off * sizeof(*cfg->vpd.vpd_w),
1294                                     M_DEVBUF, M_WAITOK | M_ZERO);
1295                                 state = 0;
1296                         } else if (dflen == 0)
1297                                 state = 5;
1298                         break;
1299
1300                 default:
1301                         pci_printf(cfg, "invalid state: %d\n", state);
1302                         state = -1;
1303                         break;
1304                 }
1305         }
1306
1307         if (cksumvalid == 0 || state < -1) {
1308                 /* read-only data bad, clean up */
1309                 if (cfg->vpd.vpd_ros != NULL) {
1310                         for (off = 0; cfg->vpd.vpd_ros[off].value; off++)
1311                                 free(cfg->vpd.vpd_ros[off].value, M_DEVBUF);
1312                         free(cfg->vpd.vpd_ros, M_DEVBUF);
1313                         cfg->vpd.vpd_ros = NULL;
1314                 }
1315         }
1316         if (state < -1) {
1317                 /* I/O error, clean up */
1318                 pci_printf(cfg, "failed to read VPD data.\n");
1319                 if (cfg->vpd.vpd_ident != NULL) {
1320                         free(cfg->vpd.vpd_ident, M_DEVBUF);
1321                         cfg->vpd.vpd_ident = NULL;
1322                 }
1323                 if (cfg->vpd.vpd_w != NULL) {
1324                         for (off = 0; cfg->vpd.vpd_w[off].value; off++)
1325                                 free(cfg->vpd.vpd_w[off].value, M_DEVBUF);
1326                         free(cfg->vpd.vpd_w, M_DEVBUF);
1327                         cfg->vpd.vpd_w = NULL;
1328                 }
1329         }
1330         cfg->vpd.vpd_cached = 1;
1331 #undef REG
1332 #undef WREG
1333 }
1334
1335 int
1336 pci_get_vpd_ident_method(device_t dev, device_t child, const char **identptr)
1337 {
1338         struct pci_devinfo *dinfo = device_get_ivars(child);
1339         pcicfgregs *cfg = &dinfo->cfg;
1340
1341         if (!cfg->vpd.vpd_cached && cfg->vpd.vpd_reg != 0)
1342                 pci_read_vpd(device_get_parent(dev), cfg);
1343
1344         *identptr = cfg->vpd.vpd_ident;
1345
1346         if (*identptr == NULL)
1347                 return (ENXIO);
1348
1349         return (0);
1350 }
1351
1352 int
1353 pci_get_vpd_readonly_method(device_t dev, device_t child, const char *kw,
1354         const char **vptr)
1355 {
1356         struct pci_devinfo *dinfo = device_get_ivars(child);
1357         pcicfgregs *cfg = &dinfo->cfg;
1358         int i;
1359
1360         if (!cfg->vpd.vpd_cached && cfg->vpd.vpd_reg != 0)
1361                 pci_read_vpd(device_get_parent(dev), cfg);
1362
1363         for (i = 0; i < cfg->vpd.vpd_rocnt; i++)
1364                 if (memcmp(kw, cfg->vpd.vpd_ros[i].keyword,
1365                     sizeof(cfg->vpd.vpd_ros[i].keyword)) == 0) {
1366                         *vptr = cfg->vpd.vpd_ros[i].value;
1367                         return (0);
1368                 }
1369
1370         *vptr = NULL;
1371         return (ENXIO);
1372 }
1373
1374 struct pcicfg_vpd *
1375 pci_fetch_vpd_list(device_t dev)
1376 {
1377         struct pci_devinfo *dinfo = device_get_ivars(dev);
1378         pcicfgregs *cfg = &dinfo->cfg;
1379
1380         if (!cfg->vpd.vpd_cached && cfg->vpd.vpd_reg != 0)
1381                 pci_read_vpd(device_get_parent(device_get_parent(dev)), cfg);
1382         return (&cfg->vpd);
1383 }
1384
1385 /*
1386  * Find the requested HyperTransport capability and return the offset
1387  * in configuration space via the pointer provided.  The function
1388  * returns 0 on success and an error code otherwise.
1389  */
1390 int
1391 pci_find_htcap_method(device_t dev, device_t child, int capability, int *capreg)
1392 {
1393         int ptr, error;
1394         uint16_t val;
1395
1396         error = pci_find_cap(child, PCIY_HT, &ptr);
1397         if (error)
1398                 return (error);
1399
1400         /*
1401          * Traverse the capabilities list checking each HT capability
1402          * to see if it matches the requested HT capability.
1403          */
1404         for (;;) {
1405                 val = pci_read_config(child, ptr + PCIR_HT_COMMAND, 2);
1406                 if (capability == PCIM_HTCAP_SLAVE ||
1407                     capability == PCIM_HTCAP_HOST)
1408                         val &= 0xe000;
1409                 else
1410                         val &= PCIM_HTCMD_CAP_MASK;
1411                 if (val == capability) {
1412                         if (capreg != NULL)
1413                                 *capreg = ptr;
1414                         return (0);
1415                 }
1416
1417                 /* Skip to the next HT capability. */
1418                 if (pci_find_next_cap(child, PCIY_HT, ptr, &ptr) != 0)
1419                         break;
1420         }
1421
1422         return (ENOENT);
1423 }
1424
1425 /*
1426  * Find the next requested HyperTransport capability after start and return
1427  * the offset in configuration space via the pointer provided.  The function
1428  * returns 0 on success and an error code otherwise.
1429  */
1430 int
1431 pci_find_next_htcap_method(device_t dev, device_t child, int capability,
1432     int start, int *capreg)
1433 {
1434         int ptr;
1435         uint16_t val;
1436
1437         KASSERT(pci_read_config(child, start + PCICAP_ID, 1) == PCIY_HT,
1438             ("start capability is not HyperTransport capability"));
1439         ptr = start;
1440
1441         /*
1442          * Traverse the capabilities list checking each HT capability
1443          * to see if it matches the requested HT capability.
1444          */
1445         for (;;) {
1446                 /* Skip to the next HT capability. */
1447                 if (pci_find_next_cap(child, PCIY_HT, ptr, &ptr) != 0)
1448                         break;
1449
1450                 val = pci_read_config(child, ptr + PCIR_HT_COMMAND, 2);
1451                 if (capability == PCIM_HTCAP_SLAVE ||
1452                     capability == PCIM_HTCAP_HOST)
1453                         val &= 0xe000;
1454                 else
1455                         val &= PCIM_HTCMD_CAP_MASK;
1456                 if (val == capability) {
1457                         if (capreg != NULL)
1458                                 *capreg = ptr;
1459                         return (0);
1460                 }
1461         }
1462
1463         return (ENOENT);
1464 }
1465
1466 /*
1467  * Find the requested capability and return the offset in
1468  * configuration space via the pointer provided.  The function returns
1469  * 0 on success and an error code otherwise.
1470  */
1471 int
1472 pci_find_cap_method(device_t dev, device_t child, int capability,
1473     int *capreg)
1474 {
1475         struct pci_devinfo *dinfo = device_get_ivars(child);
1476         pcicfgregs *cfg = &dinfo->cfg;
1477         uint32_t status;
1478         uint8_t ptr;
1479
1480         /*
1481          * Check the CAP_LIST bit of the PCI status register first.
1482          */
1483         status = pci_read_config(child, PCIR_STATUS, 2);
1484         if (!(status & PCIM_STATUS_CAPPRESENT))
1485                 return (ENXIO);
1486
1487         /*
1488          * Determine the start pointer of the capabilities list.
1489          */
1490         switch (cfg->hdrtype & PCIM_HDRTYPE) {
1491         case PCIM_HDRTYPE_NORMAL:
1492         case PCIM_HDRTYPE_BRIDGE:
1493                 ptr = PCIR_CAP_PTR;
1494                 break;
1495         case PCIM_HDRTYPE_CARDBUS:
1496                 ptr = PCIR_CAP_PTR_2;
1497                 break;
1498         default:
1499                 /* XXX: panic? */
1500                 return (ENXIO);         /* no extended capabilities support */
1501         }
1502         ptr = pci_read_config(child, ptr, 1);
1503
1504         /*
1505          * Traverse the capabilities list.
1506          */
1507         while (ptr != 0) {
1508                 if (pci_read_config(child, ptr + PCICAP_ID, 1) == capability) {
1509                         if (capreg != NULL)
1510                                 *capreg = ptr;
1511                         return (0);
1512                 }
1513                 ptr = pci_read_config(child, ptr + PCICAP_NEXTPTR, 1);
1514         }
1515
1516         return (ENOENT);
1517 }
1518
1519 /*
1520  * Find the next requested capability after start and return the offset in
1521  * configuration space via the pointer provided.  The function returns
1522  * 0 on success and an error code otherwise.
1523  */
1524 int
1525 pci_find_next_cap_method(device_t dev, device_t child, int capability,
1526     int start, int *capreg)
1527 {
1528         uint8_t ptr;
1529
1530         KASSERT(pci_read_config(child, start + PCICAP_ID, 1) == capability,
1531             ("start capability is not expected capability"));
1532
1533         ptr = pci_read_config(child, start + PCICAP_NEXTPTR, 1);
1534         while (ptr != 0) {
1535                 if (pci_read_config(child, ptr + PCICAP_ID, 1) == capability) {
1536                         if (capreg != NULL)
1537                                 *capreg = ptr;
1538                         return (0);
1539                 }
1540                 ptr = pci_read_config(child, ptr + PCICAP_NEXTPTR, 1);
1541         }
1542
1543         return (ENOENT);
1544 }
1545
1546 /*
1547  * Find the requested extended capability and return the offset in
1548  * configuration space via the pointer provided.  The function returns
1549  * 0 on success and an error code otherwise.
1550  */
1551 int
1552 pci_find_extcap_method(device_t dev, device_t child, int capability,
1553     int *capreg)
1554 {
1555         struct pci_devinfo *dinfo = device_get_ivars(child);
1556         pcicfgregs *cfg = &dinfo->cfg;
1557         uint32_t ecap;
1558         uint16_t ptr;
1559
1560         /* Only supported for PCI-express devices. */
1561         if (cfg->pcie.pcie_location == 0)
1562                 return (ENXIO);
1563
1564         ptr = PCIR_EXTCAP;
1565         ecap = pci_read_config(child, ptr, 4);
1566         if (ecap == 0xffffffff || ecap == 0)
1567                 return (ENOENT);
1568         for (;;) {
1569                 if (PCI_EXTCAP_ID(ecap) == capability) {
1570                         if (capreg != NULL)
1571                                 *capreg = ptr;
1572                         return (0);
1573                 }
1574                 ptr = PCI_EXTCAP_NEXTPTR(ecap);
1575                 if (ptr == 0)
1576                         break;
1577                 ecap = pci_read_config(child, ptr, 4);
1578         }
1579
1580         return (ENOENT);
1581 }
1582
1583 /*
1584  * Find the next requested extended capability after start and return the
1585  * offset in configuration space via the pointer provided.  The function
1586  * returns 0 on success and an error code otherwise.
1587  */
1588 int
1589 pci_find_next_extcap_method(device_t dev, device_t child, int capability,
1590     int start, int *capreg)
1591 {
1592         struct pci_devinfo *dinfo = device_get_ivars(child);
1593         pcicfgregs *cfg = &dinfo->cfg;
1594         uint32_t ecap;
1595         uint16_t ptr;
1596
1597         /* Only supported for PCI-express devices. */
1598         if (cfg->pcie.pcie_location == 0)
1599                 return (ENXIO);
1600
1601         ecap = pci_read_config(child, start, 4);
1602         KASSERT(PCI_EXTCAP_ID(ecap) == capability,
1603             ("start extended capability is not expected capability"));
1604         ptr = PCI_EXTCAP_NEXTPTR(ecap);
1605         while (ptr != 0) {
1606                 ecap = pci_read_config(child, ptr, 4);
1607                 if (PCI_EXTCAP_ID(ecap) == capability) {
1608                         if (capreg != NULL)
1609                                 *capreg = ptr;
1610                         return (0);
1611                 }
1612                 ptr = PCI_EXTCAP_NEXTPTR(ecap);
1613         }
1614
1615         return (ENOENT);
1616 }
1617
1618 /*
1619  * Support for MSI-X message interrupts.
1620  */
1621 static void
1622 pci_write_msix_entry(device_t dev, u_int index, uint64_t address, uint32_t data)
1623 {
1624         struct pci_devinfo *dinfo = device_get_ivars(dev);
1625         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1626         uint32_t offset;
1627
1628         KASSERT(msix->msix_table_len > index, ("bogus index"));
1629         offset = msix->msix_table_offset + index * 16;
1630         bus_write_4(msix->msix_table_res, offset, address & 0xffffffff);
1631         bus_write_4(msix->msix_table_res, offset + 4, address >> 32);
1632         bus_write_4(msix->msix_table_res, offset + 8, data);
1633 }
1634
1635 void
1636 pci_enable_msix_method(device_t dev, device_t child, u_int index,
1637     uint64_t address, uint32_t data)
1638 {
1639
1640         if (pci_msix_rewrite_table) {
1641                 struct pci_devinfo *dinfo = device_get_ivars(child);
1642                 struct pcicfg_msix *msix = &dinfo->cfg.msix;
1643
1644                 /*
1645                  * Some VM hosts require MSIX to be disabled in the
1646                  * control register before updating the MSIX table
1647                  * entries are allowed. It is not enough to only
1648                  * disable MSIX while updating a single entry. MSIX
1649                  * must be disabled while updating all entries in the
1650                  * table.
1651                  */
1652                 pci_write_config(child,
1653                     msix->msix_location + PCIR_MSIX_CTRL,
1654                     msix->msix_ctrl & ~PCIM_MSIXCTRL_MSIX_ENABLE, 2);
1655                 pci_resume_msix(child);
1656         } else
1657                 pci_write_msix_entry(child, index, address, data);
1658
1659         /* Enable MSI -> HT mapping. */
1660         pci_ht_map_msi(child, address);
1661 }
1662
1663 void
1664 pci_mask_msix(device_t dev, u_int index)
1665 {
1666         struct pci_devinfo *dinfo = device_get_ivars(dev);
1667         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1668         uint32_t offset, val;
1669
1670         KASSERT(msix->msix_msgnum > index, ("bogus index"));
1671         offset = msix->msix_table_offset + index * 16 + 12;
1672         val = bus_read_4(msix->msix_table_res, offset);
1673         val |= PCIM_MSIX_VCTRL_MASK;
1674
1675         /*
1676          * Some devices (e.g. Samsung PM961) do not support reads of this
1677          * register, so always write the new value.
1678          */
1679         bus_write_4(msix->msix_table_res, offset, val);
1680 }
1681
1682 void
1683 pci_unmask_msix(device_t dev, u_int index)
1684 {
1685         struct pci_devinfo *dinfo = device_get_ivars(dev);
1686         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1687         uint32_t offset, val;
1688
1689         KASSERT(msix->msix_table_len > index, ("bogus index"));
1690         offset = msix->msix_table_offset + index * 16 + 12;
1691         val = bus_read_4(msix->msix_table_res, offset);
1692         val &= ~PCIM_MSIX_VCTRL_MASK;
1693
1694         /*
1695          * Some devices (e.g. Samsung PM961) do not support reads of this
1696          * register, so always write the new value.
1697          */
1698         bus_write_4(msix->msix_table_res, offset, val);
1699 }
1700
1701 int
1702 pci_pending_msix(device_t dev, u_int index)
1703 {
1704         struct pci_devinfo *dinfo = device_get_ivars(dev);
1705         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1706         uint32_t offset, bit;
1707
1708         KASSERT(msix->msix_table_len > index, ("bogus index"));
1709         offset = msix->msix_pba_offset + (index / 32) * 4;
1710         bit = 1 << index % 32;
1711         return (bus_read_4(msix->msix_pba_res, offset) & bit);
1712 }
1713
1714 /*
1715  * Restore MSI-X registers and table during resume.  If MSI-X is
1716  * enabled then walk the virtual table to restore the actual MSI-X
1717  * table.
1718  */
1719 static void
1720 pci_resume_msix(device_t dev)
1721 {
1722         struct pci_devinfo *dinfo = device_get_ivars(dev);
1723         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1724         struct msix_table_entry *mte;
1725         struct msix_vector *mv;
1726         int i;
1727
1728         if (msix->msix_alloc > 0) {
1729                 /* First, mask all vectors. */
1730                 for (i = 0; i < msix->msix_msgnum; i++)
1731                         pci_mask_msix(dev, i);
1732
1733                 /* Second, program any messages with at least one handler. */
1734                 for (i = 0; i < msix->msix_table_len; i++) {
1735                         mte = &msix->msix_table[i];
1736                         if (mte->mte_vector == 0 || mte->mte_handlers == 0)
1737                                 continue;
1738                         mv = &msix->msix_vectors[mte->mte_vector - 1];
1739                         pci_write_msix_entry(dev, i, mv->mv_address,
1740                             mv->mv_data);
1741                         pci_unmask_msix(dev, i);
1742                 }
1743         }
1744         pci_write_config(dev, msix->msix_location + PCIR_MSIX_CTRL,
1745             msix->msix_ctrl, 2);
1746 }
1747
1748 /*
1749  * Attempt to allocate *count MSI-X messages.  The actual number allocated is
1750  * returned in *count.  After this function returns, each message will be
1751  * available to the driver as SYS_RES_IRQ resources starting at rid 1.
1752  */
1753 int
1754 pci_alloc_msix_method(device_t dev, device_t child, int *count)
1755 {
1756         struct pci_devinfo *dinfo = device_get_ivars(child);
1757         pcicfgregs *cfg = &dinfo->cfg;
1758         struct resource_list_entry *rle;
1759         int actual, error, i, irq, max;
1760
1761         /* Don't let count == 0 get us into trouble. */
1762         if (*count == 0)
1763                 return (EINVAL);
1764
1765         /* If rid 0 is allocated, then fail. */
1766         rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 0);
1767         if (rle != NULL && rle->res != NULL)
1768                 return (ENXIO);
1769
1770         /* Already have allocated messages? */
1771         if (cfg->msi.msi_alloc != 0 || cfg->msix.msix_alloc != 0)
1772                 return (ENXIO);
1773
1774         /* If MSI-X is blacklisted for this system, fail. */
1775         if (pci_msix_blacklisted())
1776                 return (ENXIO);
1777
1778         /* MSI-X capability present? */
1779         if (cfg->msix.msix_location == 0 || !pci_do_msix)
1780                 return (ENODEV);
1781
1782         /* Make sure the appropriate BARs are mapped. */
1783         rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY,
1784             cfg->msix.msix_table_bar);
1785         if (rle == NULL || rle->res == NULL ||
1786             !(rman_get_flags(rle->res) & RF_ACTIVE))
1787                 return (ENXIO);
1788         cfg->msix.msix_table_res = rle->res;
1789         if (cfg->msix.msix_pba_bar != cfg->msix.msix_table_bar) {
1790                 rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY,
1791                     cfg->msix.msix_pba_bar);
1792                 if (rle == NULL || rle->res == NULL ||
1793                     !(rman_get_flags(rle->res) & RF_ACTIVE))
1794                         return (ENXIO);
1795         }
1796         cfg->msix.msix_pba_res = rle->res;
1797
1798         if (bootverbose)
1799                 device_printf(child,
1800                     "attempting to allocate %d MSI-X vectors (%d supported)\n",
1801                     *count, cfg->msix.msix_msgnum);
1802         max = min(*count, cfg->msix.msix_msgnum);
1803         for (i = 0; i < max; i++) {
1804                 /* Allocate a message. */
1805                 error = PCIB_ALLOC_MSIX(device_get_parent(dev), child, &irq);
1806                 if (error) {
1807                         if (i == 0)
1808                                 return (error);
1809                         break;
1810                 }
1811                 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i + 1, irq,
1812                     irq, 1);
1813         }
1814         actual = i;
1815
1816         if (bootverbose) {
1817                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 1);
1818                 if (actual == 1)
1819                         device_printf(child, "using IRQ %ju for MSI-X\n",
1820                             rle->start);
1821                 else {
1822                         int run;
1823
1824                         /*
1825                          * Be fancy and try to print contiguous runs of
1826                          * IRQ values as ranges.  'irq' is the previous IRQ.
1827                          * 'run' is true if we are in a range.
1828                          */
1829                         device_printf(child, "using IRQs %ju", rle->start);
1830                         irq = rle->start;
1831                         run = 0;
1832                         for (i = 1; i < actual; i++) {
1833                                 rle = resource_list_find(&dinfo->resources,
1834                                     SYS_RES_IRQ, i + 1);
1835
1836                                 /* Still in a run? */
1837                                 if (rle->start == irq + 1) {
1838                                         run = 1;
1839                                         irq++;
1840                                         continue;
1841                                 }
1842
1843                                 /* Finish previous range. */
1844                                 if (run) {
1845                                         printf("-%d", irq);
1846                                         run = 0;
1847                                 }
1848
1849                                 /* Start new range. */
1850                                 printf(",%ju", rle->start);
1851                                 irq = rle->start;
1852                         }
1853
1854                         /* Unfinished range? */
1855                         if (run)
1856                                 printf("-%d", irq);
1857                         printf(" for MSI-X\n");
1858                 }
1859         }
1860
1861         /* Mask all vectors. */
1862         for (i = 0; i < cfg->msix.msix_msgnum; i++)
1863                 pci_mask_msix(child, i);
1864
1865         /* Allocate and initialize vector data and virtual table. */
1866         cfg->msix.msix_vectors = malloc(sizeof(struct msix_vector) * actual,
1867             M_DEVBUF, M_WAITOK | M_ZERO);
1868         cfg->msix.msix_table = malloc(sizeof(struct msix_table_entry) * actual,
1869             M_DEVBUF, M_WAITOK | M_ZERO);
1870         for (i = 0; i < actual; i++) {
1871                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
1872                 cfg->msix.msix_vectors[i].mv_irq = rle->start;
1873                 cfg->msix.msix_table[i].mte_vector = i + 1;
1874         }
1875
1876         /* Update control register to enable MSI-X. */
1877         cfg->msix.msix_ctrl |= PCIM_MSIXCTRL_MSIX_ENABLE;
1878         pci_write_config(child, cfg->msix.msix_location + PCIR_MSIX_CTRL,
1879             cfg->msix.msix_ctrl, 2);
1880
1881         /* Update counts of alloc'd messages. */
1882         cfg->msix.msix_alloc = actual;
1883         cfg->msix.msix_table_len = actual;
1884         *count = actual;
1885         return (0);
1886 }
1887
1888 /*
1889  * By default, pci_alloc_msix() will assign the allocated IRQ
1890  * resources consecutively to the first N messages in the MSI-X table.
1891  * However, device drivers may want to use different layouts if they
1892  * either receive fewer messages than they asked for, or they wish to
1893  * populate the MSI-X table sparsely.  This method allows the driver
1894  * to specify what layout it wants.  It must be called after a
1895  * successful pci_alloc_msix() but before any of the associated
1896  * SYS_RES_IRQ resources are allocated via bus_alloc_resource().
1897  *
1898  * The 'vectors' array contains 'count' message vectors.  The array
1899  * maps directly to the MSI-X table in that index 0 in the array
1900  * specifies the vector for the first message in the MSI-X table, etc.
1901  * The vector value in each array index can either be 0 to indicate
1902  * that no vector should be assigned to a message slot, or it can be a
1903  * number from 1 to N (where N is the count returned from a
1904  * succcessful call to pci_alloc_msix()) to indicate which message
1905  * vector (IRQ) to be used for the corresponding message.
1906  *
1907  * On successful return, each message with a non-zero vector will have
1908  * an associated SYS_RES_IRQ whose rid is equal to the array index +
1909  * 1.  Additionally, if any of the IRQs allocated via the previous
1910  * call to pci_alloc_msix() are not used in the mapping, those IRQs
1911  * will be freed back to the system automatically.
1912  *
1913  * For example, suppose a driver has a MSI-X table with 6 messages and
1914  * asks for 6 messages, but pci_alloc_msix() only returns a count of
1915  * 3.  Call the three vectors allocated by pci_alloc_msix() A, B, and
1916  * C.  After the call to pci_alloc_msix(), the device will be setup to
1917  * have an MSI-X table of ABC--- (where - means no vector assigned).
1918  * If the driver then passes a vector array of { 1, 0, 1, 2, 0, 2 },
1919  * then the MSI-X table will look like A-AB-B, and the 'C' vector will
1920  * be freed back to the system.  This device will also have valid
1921  * SYS_RES_IRQ rids of 1, 3, 4, and 6.
1922  *
1923  * In any case, the SYS_RES_IRQ rid X will always map to the message
1924  * at MSI-X table index X - 1 and will only be valid if a vector is
1925  * assigned to that table entry.
1926  */
1927 int
1928 pci_remap_msix_method(device_t dev, device_t child, int count,
1929     const u_int *vectors)
1930 {
1931         struct pci_devinfo *dinfo = device_get_ivars(child);
1932         struct pcicfg_msix *msix = &dinfo->cfg.msix;
1933         struct resource_list_entry *rle;
1934         int i, irq, j, *used;
1935
1936         /*
1937          * Have to have at least one message in the table but the
1938          * table can't be bigger than the actual MSI-X table in the
1939          * device.
1940          */
1941         if (count == 0 || count > msix->msix_msgnum)
1942                 return (EINVAL);
1943
1944         /* Sanity check the vectors. */
1945         for (i = 0; i < count; i++)
1946                 if (vectors[i] > msix->msix_alloc)
1947                         return (EINVAL);
1948
1949         /*
1950          * Make sure there aren't any holes in the vectors to be used.
1951          * It's a big pain to support it, and it doesn't really make
1952          * sense anyway.  Also, at least one vector must be used.
1953          */
1954         used = malloc(sizeof(int) * msix->msix_alloc, M_DEVBUF, M_WAITOK |
1955             M_ZERO);
1956         for (i = 0; i < count; i++)
1957                 if (vectors[i] != 0)
1958                         used[vectors[i] - 1] = 1;
1959         for (i = 0; i < msix->msix_alloc - 1; i++)
1960                 if (used[i] == 0 && used[i + 1] == 1) {
1961                         free(used, M_DEVBUF);
1962                         return (EINVAL);
1963                 }
1964         if (used[0] != 1) {
1965                 free(used, M_DEVBUF);
1966                 return (EINVAL);
1967         }
1968
1969         /* Make sure none of the resources are allocated. */
1970         for (i = 0; i < msix->msix_table_len; i++) {
1971                 if (msix->msix_table[i].mte_vector == 0)
1972                         continue;
1973                 if (msix->msix_table[i].mte_handlers > 0) {
1974                         free(used, M_DEVBUF);
1975                         return (EBUSY);
1976                 }
1977                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
1978                 KASSERT(rle != NULL, ("missing resource"));
1979                 if (rle->res != NULL) {
1980                         free(used, M_DEVBUF);
1981                         return (EBUSY);
1982                 }
1983         }
1984
1985         /* Free the existing resource list entries. */
1986         for (i = 0; i < msix->msix_table_len; i++) {
1987                 if (msix->msix_table[i].mte_vector == 0)
1988                         continue;
1989                 resource_list_delete(&dinfo->resources, SYS_RES_IRQ, i + 1);
1990         }
1991
1992         /*
1993          * Build the new virtual table keeping track of which vectors are
1994          * used.
1995          */
1996         free(msix->msix_table, M_DEVBUF);
1997         msix->msix_table = malloc(sizeof(struct msix_table_entry) * count,
1998             M_DEVBUF, M_WAITOK | M_ZERO);
1999         for (i = 0; i < count; i++)
2000                 msix->msix_table[i].mte_vector = vectors[i];
2001         msix->msix_table_len = count;
2002
2003         /* Free any unused IRQs and resize the vectors array if necessary. */
2004         j = msix->msix_alloc - 1;
2005         if (used[j] == 0) {
2006                 struct msix_vector *vec;
2007
2008                 while (used[j] == 0) {
2009                         PCIB_RELEASE_MSIX(device_get_parent(dev), child,
2010                             msix->msix_vectors[j].mv_irq);
2011                         j--;
2012                 }
2013                 vec = malloc(sizeof(struct msix_vector) * (j + 1), M_DEVBUF,
2014                     M_WAITOK);
2015                 bcopy(msix->msix_vectors, vec, sizeof(struct msix_vector) *
2016                     (j + 1));
2017                 free(msix->msix_vectors, M_DEVBUF);
2018                 msix->msix_vectors = vec;
2019                 msix->msix_alloc = j + 1;
2020         }
2021         free(used, M_DEVBUF);
2022
2023         /* Map the IRQs onto the rids. */
2024         for (i = 0; i < count; i++) {
2025                 if (vectors[i] == 0)
2026                         continue;
2027                 irq = msix->msix_vectors[vectors[i] - 1].mv_irq;
2028                 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i + 1, irq,
2029                     irq, 1);
2030         }
2031
2032         if (bootverbose) {
2033                 device_printf(child, "Remapped MSI-X IRQs as: ");
2034                 for (i = 0; i < count; i++) {
2035                         if (i != 0)
2036                                 printf(", ");
2037                         if (vectors[i] == 0)
2038                                 printf("---");
2039                         else
2040                                 printf("%d",
2041                                     msix->msix_vectors[vectors[i] - 1].mv_irq);
2042                 }
2043                 printf("\n");
2044         }
2045
2046         return (0);
2047 }
2048
2049 static int
2050 pci_release_msix(device_t dev, device_t child)
2051 {
2052         struct pci_devinfo *dinfo = device_get_ivars(child);
2053         struct pcicfg_msix *msix = &dinfo->cfg.msix;
2054         struct resource_list_entry *rle;
2055         int i;
2056
2057         /* Do we have any messages to release? */
2058         if (msix->msix_alloc == 0)
2059                 return (ENODEV);
2060
2061         /* Make sure none of the resources are allocated. */
2062         for (i = 0; i < msix->msix_table_len; i++) {
2063                 if (msix->msix_table[i].mte_vector == 0)
2064                         continue;
2065                 if (msix->msix_table[i].mte_handlers > 0)
2066                         return (EBUSY);
2067                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
2068                 KASSERT(rle != NULL, ("missing resource"));
2069                 if (rle->res != NULL)
2070                         return (EBUSY);
2071         }
2072
2073         /* Update control register to disable MSI-X. */
2074         msix->msix_ctrl &= ~PCIM_MSIXCTRL_MSIX_ENABLE;
2075         pci_write_config(child, msix->msix_location + PCIR_MSIX_CTRL,
2076             msix->msix_ctrl, 2);
2077
2078         /* Free the resource list entries. */
2079         for (i = 0; i < msix->msix_table_len; i++) {
2080                 if (msix->msix_table[i].mte_vector == 0)
2081                         continue;
2082                 resource_list_delete(&dinfo->resources, SYS_RES_IRQ, i + 1);
2083         }
2084         free(msix->msix_table, M_DEVBUF);
2085         msix->msix_table_len = 0;
2086
2087         /* Release the IRQs. */
2088         for (i = 0; i < msix->msix_alloc; i++)
2089                 PCIB_RELEASE_MSIX(device_get_parent(dev), child,
2090                     msix->msix_vectors[i].mv_irq);
2091         free(msix->msix_vectors, M_DEVBUF);
2092         msix->msix_alloc = 0;
2093         return (0);
2094 }
2095
2096 /*
2097  * Return the max supported MSI-X messages this device supports.
2098  * Basically, assuming the MD code can alloc messages, this function
2099  * should return the maximum value that pci_alloc_msix() can return.
2100  * Thus, it is subject to the tunables, etc.
2101  */
2102 int
2103 pci_msix_count_method(device_t dev, device_t child)
2104 {
2105         struct pci_devinfo *dinfo = device_get_ivars(child);
2106         struct pcicfg_msix *msix = &dinfo->cfg.msix;
2107
2108         if (pci_do_msix && msix->msix_location != 0)
2109                 return (msix->msix_msgnum);
2110         return (0);
2111 }
2112
2113 int
2114 pci_msix_pba_bar_method(device_t dev, device_t child)
2115 {
2116         struct pci_devinfo *dinfo = device_get_ivars(child);
2117         struct pcicfg_msix *msix = &dinfo->cfg.msix;
2118
2119         if (pci_do_msix && msix->msix_location != 0)
2120                 return (msix->msix_pba_bar);
2121         return (-1);
2122 }
2123
2124 int
2125 pci_msix_table_bar_method(device_t dev, device_t child)
2126 {
2127         struct pci_devinfo *dinfo = device_get_ivars(child);
2128         struct pcicfg_msix *msix = &dinfo->cfg.msix;
2129
2130         if (pci_do_msix && msix->msix_location != 0)
2131                 return (msix->msix_table_bar);
2132         return (-1);
2133 }
2134
2135 /*
2136  * HyperTransport MSI mapping control
2137  */
2138 void
2139 pci_ht_map_msi(device_t dev, uint64_t addr)
2140 {
2141         struct pci_devinfo *dinfo = device_get_ivars(dev);
2142         struct pcicfg_ht *ht = &dinfo->cfg.ht;
2143
2144         if (!ht->ht_msimap)
2145                 return;
2146
2147         if (addr && !(ht->ht_msictrl & PCIM_HTCMD_MSI_ENABLE) &&
2148             ht->ht_msiaddr >> 20 == addr >> 20) {
2149                 /* Enable MSI -> HT mapping. */
2150                 ht->ht_msictrl |= PCIM_HTCMD_MSI_ENABLE;
2151                 pci_write_config(dev, ht->ht_msimap + PCIR_HT_COMMAND,
2152                     ht->ht_msictrl, 2);
2153         }
2154
2155         if (!addr && ht->ht_msictrl & PCIM_HTCMD_MSI_ENABLE) {
2156                 /* Disable MSI -> HT mapping. */
2157                 ht->ht_msictrl &= ~PCIM_HTCMD_MSI_ENABLE;
2158                 pci_write_config(dev, ht->ht_msimap + PCIR_HT_COMMAND,
2159                     ht->ht_msictrl, 2);
2160         }
2161 }
2162
2163 int
2164 pci_get_max_payload(device_t dev)
2165 {
2166         struct pci_devinfo *dinfo = device_get_ivars(dev);
2167         int cap;
2168         uint16_t val;
2169
2170         cap = dinfo->cfg.pcie.pcie_location;
2171         if (cap == 0)
2172                 return (0);
2173         val = pci_read_config(dev, cap + PCIER_DEVICE_CTL, 2);
2174         val &= PCIEM_CTL_MAX_PAYLOAD;
2175         val >>= 5;
2176         return (1 << (val + 7));
2177 }
2178
2179 int
2180 pci_get_max_read_req(device_t dev)
2181 {
2182         struct pci_devinfo *dinfo = device_get_ivars(dev);
2183         int cap;
2184         uint16_t val;
2185
2186         cap = dinfo->cfg.pcie.pcie_location;
2187         if (cap == 0)
2188                 return (0);
2189         val = pci_read_config(dev, cap + PCIER_DEVICE_CTL, 2);
2190         val &= PCIEM_CTL_MAX_READ_REQUEST;
2191         val >>= 12;
2192         return (1 << (val + 7));
2193 }
2194
2195 int
2196 pci_set_max_read_req(device_t dev, int size)
2197 {
2198         struct pci_devinfo *dinfo = device_get_ivars(dev);
2199         int cap;
2200         uint16_t val;
2201
2202         cap = dinfo->cfg.pcie.pcie_location;
2203         if (cap == 0)
2204                 return (0);
2205         if (size < 128)
2206                 size = 128;
2207         if (size > 4096)
2208                 size = 4096;
2209         size = (1 << (fls(size) - 1));
2210         val = pci_read_config(dev, cap + PCIER_DEVICE_CTL, 2);
2211         val &= ~PCIEM_CTL_MAX_READ_REQUEST;
2212         val |= (fls(size) - 8) << 12;
2213         pci_write_config(dev, cap + PCIER_DEVICE_CTL, val, 2);
2214         return (size);
2215 }
2216
2217 uint32_t
2218 pcie_read_config(device_t dev, int reg, int width)
2219 {
2220         struct pci_devinfo *dinfo = device_get_ivars(dev);
2221         int cap;
2222
2223         cap = dinfo->cfg.pcie.pcie_location;
2224         if (cap == 0) {
2225                 if (width == 2)
2226                         return (0xffff);
2227                 return (0xffffffff);
2228         }
2229
2230         return (pci_read_config(dev, cap + reg, width));
2231 }
2232
2233 void
2234 pcie_write_config(device_t dev, int reg, uint32_t value, int width)
2235 {
2236         struct pci_devinfo *dinfo = device_get_ivars(dev);
2237         int cap;
2238
2239         cap = dinfo->cfg.pcie.pcie_location;
2240         if (cap == 0)
2241                 return;
2242         pci_write_config(dev, cap + reg, value, width);
2243 }
2244
2245 /*
2246  * Adjusts a PCI-e capability register by clearing the bits in mask
2247  * and setting the bits in (value & mask).  Bits not set in mask are
2248  * not adjusted.
2249  *
2250  * Returns the old value on success or all ones on failure.
2251  */
2252 uint32_t
2253 pcie_adjust_config(device_t dev, int reg, uint32_t mask, uint32_t value,
2254     int width)
2255 {
2256         struct pci_devinfo *dinfo = device_get_ivars(dev);
2257         uint32_t old, new;
2258         int cap;
2259
2260         cap = dinfo->cfg.pcie.pcie_location;
2261         if (cap == 0) {
2262                 if (width == 2)
2263                         return (0xffff);
2264                 return (0xffffffff);
2265         }
2266
2267         old = pci_read_config(dev, cap + reg, width);
2268         new = old & ~mask;
2269         new |= (value & mask);
2270         pci_write_config(dev, cap + reg, new, width);
2271         return (old);
2272 }
2273
2274 /*
2275  * Support for MSI message signalled interrupts.
2276  */
2277 void
2278 pci_enable_msi_method(device_t dev, device_t child, uint64_t address,
2279     uint16_t data)
2280 {
2281         struct pci_devinfo *dinfo = device_get_ivars(child);
2282         struct pcicfg_msi *msi = &dinfo->cfg.msi;
2283
2284         /* Write data and address values. */
2285         pci_write_config(child, msi->msi_location + PCIR_MSI_ADDR,
2286             address & 0xffffffff, 4);
2287         if (msi->msi_ctrl & PCIM_MSICTRL_64BIT) {
2288                 pci_write_config(child, msi->msi_location + PCIR_MSI_ADDR_HIGH,
2289                     address >> 32, 4);
2290                 pci_write_config(child, msi->msi_location + PCIR_MSI_DATA_64BIT,
2291                     data, 2);
2292         } else
2293                 pci_write_config(child, msi->msi_location + PCIR_MSI_DATA, data,
2294                     2);
2295
2296         /* Enable MSI in the control register. */
2297         msi->msi_ctrl |= PCIM_MSICTRL_MSI_ENABLE;
2298         pci_write_config(child, msi->msi_location + PCIR_MSI_CTRL,
2299             msi->msi_ctrl, 2);
2300
2301         /* Enable MSI -> HT mapping. */
2302         pci_ht_map_msi(child, address);
2303 }
2304
2305 void
2306 pci_disable_msi_method(device_t dev, device_t child)
2307 {
2308         struct pci_devinfo *dinfo = device_get_ivars(child);
2309         struct pcicfg_msi *msi = &dinfo->cfg.msi;
2310
2311         /* Disable MSI -> HT mapping. */
2312         pci_ht_map_msi(child, 0);
2313
2314         /* Disable MSI in the control register. */
2315         msi->msi_ctrl &= ~PCIM_MSICTRL_MSI_ENABLE;
2316         pci_write_config(child, msi->msi_location + PCIR_MSI_CTRL,
2317             msi->msi_ctrl, 2);
2318 }
2319
2320 /*
2321  * Restore MSI registers during resume.  If MSI is enabled then
2322  * restore the data and address registers in addition to the control
2323  * register.
2324  */
2325 static void
2326 pci_resume_msi(device_t dev)
2327 {
2328         struct pci_devinfo *dinfo = device_get_ivars(dev);
2329         struct pcicfg_msi *msi = &dinfo->cfg.msi;
2330         uint64_t address;
2331         uint16_t data;
2332
2333         if (msi->msi_ctrl & PCIM_MSICTRL_MSI_ENABLE) {
2334                 address = msi->msi_addr;
2335                 data = msi->msi_data;
2336                 pci_write_config(dev, msi->msi_location + PCIR_MSI_ADDR,
2337                     address & 0xffffffff, 4);
2338                 if (msi->msi_ctrl & PCIM_MSICTRL_64BIT) {
2339                         pci_write_config(dev, msi->msi_location +
2340                             PCIR_MSI_ADDR_HIGH, address >> 32, 4);
2341                         pci_write_config(dev, msi->msi_location +
2342                             PCIR_MSI_DATA_64BIT, data, 2);
2343                 } else
2344                         pci_write_config(dev, msi->msi_location + PCIR_MSI_DATA,
2345                             data, 2);
2346         }
2347         pci_write_config(dev, msi->msi_location + PCIR_MSI_CTRL, msi->msi_ctrl,
2348             2);
2349 }
2350
2351 static int
2352 pci_remap_intr_method(device_t bus, device_t dev, u_int irq)
2353 {
2354         struct pci_devinfo *dinfo = device_get_ivars(dev);
2355         pcicfgregs *cfg = &dinfo->cfg;
2356         struct resource_list_entry *rle;
2357         struct msix_table_entry *mte;
2358         struct msix_vector *mv;
2359         uint64_t addr;
2360         uint32_t data;
2361         int error, i, j;
2362
2363         /*
2364          * Handle MSI first.  We try to find this IRQ among our list
2365          * of MSI IRQs.  If we find it, we request updated address and
2366          * data registers and apply the results.
2367          */
2368         if (cfg->msi.msi_alloc > 0) {
2369
2370                 /* If we don't have any active handlers, nothing to do. */
2371                 if (cfg->msi.msi_handlers == 0)
2372                         return (0);
2373                 for (i = 0; i < cfg->msi.msi_alloc; i++) {
2374                         rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ,
2375                             i + 1);
2376                         if (rle->start == irq) {
2377                                 error = PCIB_MAP_MSI(device_get_parent(bus),
2378                                     dev, irq, &addr, &data);
2379                                 if (error)
2380                                         return (error);
2381                                 pci_disable_msi(dev);
2382                                 dinfo->cfg.msi.msi_addr = addr;
2383                                 dinfo->cfg.msi.msi_data = data;
2384                                 pci_enable_msi(dev, addr, data);
2385                                 return (0);
2386                         }
2387                 }
2388                 return (ENOENT);
2389         }
2390
2391         /*
2392          * For MSI-X, we check to see if we have this IRQ.  If we do,
2393          * we request the updated mapping info.  If that works, we go
2394          * through all the slots that use this IRQ and update them.
2395          */
2396         if (cfg->msix.msix_alloc > 0) {
2397                 for (i = 0; i < cfg->msix.msix_alloc; i++) {
2398                         mv = &cfg->msix.msix_vectors[i];
2399                         if (mv->mv_irq == irq) {
2400                                 error = PCIB_MAP_MSI(device_get_parent(bus),
2401                                     dev, irq, &addr, &data);
2402                                 if (error)
2403                                         return (error);
2404                                 mv->mv_address = addr;
2405                                 mv->mv_data = data;
2406                                 for (j = 0; j < cfg->msix.msix_table_len; j++) {
2407                                         mte = &cfg->msix.msix_table[j];
2408                                         if (mte->mte_vector != i + 1)
2409                                                 continue;
2410                                         if (mte->mte_handlers == 0)
2411                                                 continue;
2412                                         pci_mask_msix(dev, j);
2413                                         pci_enable_msix(dev, j, addr, data);
2414                                         pci_unmask_msix(dev, j);
2415                                 }
2416                         }
2417                 }
2418                 return (ENOENT);
2419         }
2420
2421         return (ENOENT);
2422 }
2423
2424 /*
2425  * Returns true if the specified device is blacklisted because MSI
2426  * doesn't work.
2427  */
2428 int
2429 pci_msi_device_blacklisted(device_t dev)
2430 {
2431
2432         if (!pci_honor_msi_blacklist)
2433                 return (0);
2434
2435         return (pci_has_quirk(pci_get_devid(dev), PCI_QUIRK_DISABLE_MSI));
2436 }
2437
2438 /*
2439  * Determine if MSI is blacklisted globally on this system.  Currently,
2440  * we just check for blacklisted chipsets as represented by the
2441  * host-PCI bridge at device 0:0:0.  In the future, it may become
2442  * necessary to check other system attributes, such as the kenv values
2443  * that give the motherboard manufacturer and model number.
2444  */
2445 static int
2446 pci_msi_blacklisted(void)
2447 {
2448         device_t dev;
2449
2450         if (!pci_honor_msi_blacklist)
2451                 return (0);
2452
2453         /* Blacklist all non-PCI-express and non-PCI-X chipsets. */
2454         if (!(pcie_chipset || pcix_chipset)) {
2455                 if (vm_guest != VM_GUEST_NO) {
2456                         /*
2457                          * Whitelist older chipsets in virtual
2458                          * machines known to support MSI.
2459                          */
2460                         dev = pci_find_bsf(0, 0, 0);
2461                         if (dev != NULL)
2462                                 return (!pci_has_quirk(pci_get_devid(dev),
2463                                         PCI_QUIRK_ENABLE_MSI_VM));
2464                 }
2465                 return (1);
2466         }
2467
2468         dev = pci_find_bsf(0, 0, 0);
2469         if (dev != NULL)
2470                 return (pci_msi_device_blacklisted(dev));
2471         return (0);
2472 }
2473
2474 /*
2475  * Returns true if the specified device is blacklisted because MSI-X
2476  * doesn't work.  Note that this assumes that if MSI doesn't work,
2477  * MSI-X doesn't either.
2478  */
2479 int
2480 pci_msix_device_blacklisted(device_t dev)
2481 {
2482
2483         if (!pci_honor_msi_blacklist)
2484                 return (0);
2485
2486         if (pci_has_quirk(pci_get_devid(dev), PCI_QUIRK_DISABLE_MSIX))
2487                 return (1);
2488
2489         return (pci_msi_device_blacklisted(dev));
2490 }
2491
2492 /*
2493  * Determine if MSI-X is blacklisted globally on this system.  If MSI
2494  * is blacklisted, assume that MSI-X is as well.  Check for additional
2495  * chipsets where MSI works but MSI-X does not.
2496  */
2497 static int
2498 pci_msix_blacklisted(void)
2499 {
2500         device_t dev;
2501
2502         if (!pci_honor_msi_blacklist)
2503                 return (0);
2504
2505         dev = pci_find_bsf(0, 0, 0);
2506         if (dev != NULL && pci_has_quirk(pci_get_devid(dev),
2507             PCI_QUIRK_DISABLE_MSIX))
2508                 return (1);
2509
2510         return (pci_msi_blacklisted());
2511 }
2512
2513 /*
2514  * Attempt to allocate *count MSI messages.  The actual number allocated is
2515  * returned in *count.  After this function returns, each message will be
2516  * available to the driver as SYS_RES_IRQ resources starting at a rid 1.
2517  */
2518 int
2519 pci_alloc_msi_method(device_t dev, device_t child, int *count)
2520 {
2521         struct pci_devinfo *dinfo = device_get_ivars(child);
2522         pcicfgregs *cfg = &dinfo->cfg;
2523         struct resource_list_entry *rle;
2524         int actual, error, i, irqs[32];
2525         uint16_t ctrl;
2526
2527         /* Don't let count == 0 get us into trouble. */
2528         if (*count == 0)
2529                 return (EINVAL);
2530
2531         /* If rid 0 is allocated, then fail. */
2532         rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 0);
2533         if (rle != NULL && rle->res != NULL)
2534                 return (ENXIO);
2535
2536         /* Already have allocated messages? */
2537         if (cfg->msi.msi_alloc != 0 || cfg->msix.msix_alloc != 0)
2538                 return (ENXIO);
2539
2540         /* If MSI is blacklisted for this system, fail. */
2541         if (pci_msi_blacklisted())
2542                 return (ENXIO);
2543
2544         /* MSI capability present? */
2545         if (cfg->msi.msi_location == 0 || !pci_do_msi)
2546                 return (ENODEV);
2547
2548         if (bootverbose)
2549                 device_printf(child,
2550                     "attempting to allocate %d MSI vectors (%d supported)\n",
2551                     *count, cfg->msi.msi_msgnum);
2552
2553         /* Don't ask for more than the device supports. */
2554         actual = min(*count, cfg->msi.msi_msgnum);
2555
2556         /* Don't ask for more than 32 messages. */
2557         actual = min(actual, 32);
2558
2559         /* MSI requires power of 2 number of messages. */
2560         if (!powerof2(actual))
2561                 return (EINVAL);
2562
2563         for (;;) {
2564                 /* Try to allocate N messages. */
2565                 error = PCIB_ALLOC_MSI(device_get_parent(dev), child, actual,
2566                     actual, irqs);
2567                 if (error == 0)
2568                         break;
2569                 if (actual == 1)
2570                         return (error);
2571
2572                 /* Try N / 2. */
2573                 actual >>= 1;
2574         }
2575
2576         /*
2577          * We now have N actual messages mapped onto SYS_RES_IRQ
2578          * resources in the irqs[] array, so add new resources
2579          * starting at rid 1.
2580          */
2581         for (i = 0; i < actual; i++)
2582                 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i + 1,
2583                     irqs[i], irqs[i], 1);
2584
2585         if (bootverbose) {
2586                 if (actual == 1)
2587                         device_printf(child, "using IRQ %d for MSI\n", irqs[0]);
2588                 else {
2589                         int run;
2590
2591                         /*
2592                          * Be fancy and try to print contiguous runs
2593                          * of IRQ values as ranges.  'run' is true if
2594                          * we are in a range.
2595                          */
2596                         device_printf(child, "using IRQs %d", irqs[0]);
2597                         run = 0;
2598                         for (i = 1; i < actual; i++) {
2599
2600                                 /* Still in a run? */
2601                                 if (irqs[i] == irqs[i - 1] + 1) {
2602                                         run = 1;
2603                                         continue;
2604                                 }
2605
2606                                 /* Finish previous range. */
2607                                 if (run) {
2608                                         printf("-%d", irqs[i - 1]);
2609                                         run = 0;
2610                                 }
2611
2612                                 /* Start new range. */
2613                                 printf(",%d", irqs[i]);
2614                         }
2615
2616                         /* Unfinished range? */
2617                         if (run)
2618                                 printf("-%d", irqs[actual - 1]);
2619                         printf(" for MSI\n");
2620                 }
2621         }
2622
2623         /* Update control register with actual count. */
2624         ctrl = cfg->msi.msi_ctrl;
2625         ctrl &= ~PCIM_MSICTRL_MME_MASK;
2626         ctrl |= (ffs(actual) - 1) << 4;
2627         cfg->msi.msi_ctrl = ctrl;
2628         pci_write_config(child, cfg->msi.msi_location + PCIR_MSI_CTRL, ctrl, 2);
2629
2630         /* Update counts of alloc'd messages. */
2631         cfg->msi.msi_alloc = actual;
2632         cfg->msi.msi_handlers = 0;
2633         *count = actual;
2634         return (0);
2635 }
2636
2637 /* Release the MSI messages associated with this device. */
2638 int
2639 pci_release_msi_method(device_t dev, device_t child)
2640 {
2641         struct pci_devinfo *dinfo = device_get_ivars(child);
2642         struct pcicfg_msi *msi = &dinfo->cfg.msi;
2643         struct resource_list_entry *rle;
2644         int error, i, irqs[32];
2645
2646         /* Try MSI-X first. */
2647         error = pci_release_msix(dev, child);
2648         if (error != ENODEV)
2649                 return (error);
2650
2651         /* Do we have any messages to release? */
2652         if (msi->msi_alloc == 0)
2653                 return (ENODEV);
2654         KASSERT(msi->msi_alloc <= 32, ("more than 32 alloc'd messages"));
2655
2656         /* Make sure none of the resources are allocated. */
2657         if (msi->msi_handlers > 0)
2658                 return (EBUSY);
2659         for (i = 0; i < msi->msi_alloc; i++) {
2660                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, i + 1);
2661                 KASSERT(rle != NULL, ("missing MSI resource"));
2662                 if (rle->res != NULL)
2663                         return (EBUSY);
2664                 irqs[i] = rle->start;
2665         }
2666
2667         /* Update control register with 0 count. */
2668         KASSERT(!(msi->msi_ctrl & PCIM_MSICTRL_MSI_ENABLE),
2669             ("%s: MSI still enabled", __func__));
2670         msi->msi_ctrl &= ~PCIM_MSICTRL_MME_MASK;
2671         pci_write_config(child, msi->msi_location + PCIR_MSI_CTRL,
2672             msi->msi_ctrl, 2);
2673
2674         /* Release the messages. */
2675         PCIB_RELEASE_MSI(device_get_parent(dev), child, msi->msi_alloc, irqs);
2676         for (i = 0; i < msi->msi_alloc; i++)
2677                 resource_list_delete(&dinfo->resources, SYS_RES_IRQ, i + 1);
2678
2679         /* Update alloc count. */
2680         msi->msi_alloc = 0;
2681         msi->msi_addr = 0;
2682         msi->msi_data = 0;
2683         return (0);
2684 }
2685
2686 /*
2687  * Return the max supported MSI messages this device supports.
2688  * Basically, assuming the MD code can alloc messages, this function
2689  * should return the maximum value that pci_alloc_msi() can return.
2690  * Thus, it is subject to the tunables, etc.
2691  */
2692 int
2693 pci_msi_count_method(device_t dev, device_t child)
2694 {
2695         struct pci_devinfo *dinfo = device_get_ivars(child);
2696         struct pcicfg_msi *msi = &dinfo->cfg.msi;
2697
2698         if (pci_do_msi && msi->msi_location != 0)
2699                 return (msi->msi_msgnum);
2700         return (0);
2701 }
2702
2703 /* free pcicfgregs structure and all depending data structures */
2704
2705 int
2706 pci_freecfg(struct pci_devinfo *dinfo)
2707 {
2708         struct devlist *devlist_head;
2709         struct pci_map *pm, *next;
2710         int i;
2711
2712         devlist_head = &pci_devq;
2713
2714         if (dinfo->cfg.vpd.vpd_reg) {
2715                 free(dinfo->cfg.vpd.vpd_ident, M_DEVBUF);
2716                 for (i = 0; i < dinfo->cfg.vpd.vpd_rocnt; i++)
2717                         free(dinfo->cfg.vpd.vpd_ros[i].value, M_DEVBUF);
2718                 free(dinfo->cfg.vpd.vpd_ros, M_DEVBUF);
2719                 for (i = 0; i < dinfo->cfg.vpd.vpd_wcnt; i++)
2720                         free(dinfo->cfg.vpd.vpd_w[i].value, M_DEVBUF);
2721                 free(dinfo->cfg.vpd.vpd_w, M_DEVBUF);
2722         }
2723         STAILQ_FOREACH_SAFE(pm, &dinfo->cfg.maps, pm_link, next) {
2724                 free(pm, M_DEVBUF);
2725         }
2726         STAILQ_REMOVE(devlist_head, dinfo, pci_devinfo, pci_links);
2727         free(dinfo, M_DEVBUF);
2728
2729         /* increment the generation count */
2730         pci_generation++;
2731
2732         /* we're losing one device */
2733         pci_numdevs--;
2734         return (0);
2735 }
2736
2737 /*
2738  * PCI power manangement
2739  */
2740 int
2741 pci_set_powerstate_method(device_t dev, device_t child, int state)
2742 {
2743         struct pci_devinfo *dinfo = device_get_ivars(child);
2744         pcicfgregs *cfg = &dinfo->cfg;
2745         uint16_t status;
2746         int oldstate, highest, delay;
2747
2748         if (cfg->pp.pp_cap == 0)
2749                 return (EOPNOTSUPP);
2750
2751         /*
2752          * Optimize a no state change request away.  While it would be OK to
2753          * write to the hardware in theory, some devices have shown odd
2754          * behavior when going from D3 -> D3.
2755          */
2756         oldstate = pci_get_powerstate(child);
2757         if (oldstate == state)
2758                 return (0);
2759
2760         /*
2761          * The PCI power management specification states that after a state
2762          * transition between PCI power states, system software must
2763          * guarantee a minimal delay before the function accesses the device.
2764          * Compute the worst case delay that we need to guarantee before we
2765          * access the device.  Many devices will be responsive much more
2766          * quickly than this delay, but there are some that don't respond
2767          * instantly to state changes.  Transitions to/from D3 state require
2768          * 10ms, while D2 requires 200us, and D0/1 require none.  The delay
2769          * is done below with DELAY rather than a sleeper function because
2770          * this function can be called from contexts where we cannot sleep.
2771          */
2772         highest = (oldstate > state) ? oldstate : state;
2773         if (highest == PCI_POWERSTATE_D3)
2774             delay = 10000;
2775         else if (highest == PCI_POWERSTATE_D2)
2776             delay = 200;
2777         else
2778             delay = 0;
2779         status = PCI_READ_CONFIG(dev, child, cfg->pp.pp_status, 2)
2780             & ~PCIM_PSTAT_DMASK;
2781         switch (state) {
2782         case PCI_POWERSTATE_D0:
2783                 status |= PCIM_PSTAT_D0;
2784                 break;
2785         case PCI_POWERSTATE_D1:
2786                 if ((cfg->pp.pp_cap & PCIM_PCAP_D1SUPP) == 0)
2787                         return (EOPNOTSUPP);
2788                 status |= PCIM_PSTAT_D1;
2789                 break;
2790         case PCI_POWERSTATE_D2:
2791                 if ((cfg->pp.pp_cap & PCIM_PCAP_D2SUPP) == 0)
2792                         return (EOPNOTSUPP);
2793                 status |= PCIM_PSTAT_D2;
2794                 break;
2795         case PCI_POWERSTATE_D3:
2796                 status |= PCIM_PSTAT_D3;
2797                 break;
2798         default:
2799                 return (EINVAL);
2800         }
2801
2802         if (bootverbose)
2803                 pci_printf(cfg, "Transition from D%d to D%d\n", oldstate,
2804                     state);
2805
2806         PCI_WRITE_CONFIG(dev, child, cfg->pp.pp_status, status, 2);
2807         if (delay)
2808                 DELAY(delay);
2809         return (0);
2810 }
2811
2812 int
2813 pci_get_powerstate_method(device_t dev, device_t child)
2814 {
2815         struct pci_devinfo *dinfo = device_get_ivars(child);
2816         pcicfgregs *cfg = &dinfo->cfg;
2817         uint16_t status;
2818         int result;
2819
2820         if (cfg->pp.pp_cap != 0) {
2821                 status = PCI_READ_CONFIG(dev, child, cfg->pp.pp_status, 2);
2822                 switch (status & PCIM_PSTAT_DMASK) {
2823                 case PCIM_PSTAT_D0:
2824                         result = PCI_POWERSTATE_D0;
2825                         break;
2826                 case PCIM_PSTAT_D1:
2827                         result = PCI_POWERSTATE_D1;
2828                         break;
2829                 case PCIM_PSTAT_D2:
2830                         result = PCI_POWERSTATE_D2;
2831                         break;
2832                 case PCIM_PSTAT_D3:
2833                         result = PCI_POWERSTATE_D3;
2834                         break;
2835                 default:
2836                         result = PCI_POWERSTATE_UNKNOWN;
2837                         break;
2838                 }
2839         } else {
2840                 /* No support, device is always at D0 */
2841                 result = PCI_POWERSTATE_D0;
2842         }
2843         return (result);
2844 }
2845
2846 /*
2847  * Some convenience functions for PCI device drivers.
2848  */
2849
2850 static __inline void
2851 pci_set_command_bit(device_t dev, device_t child, uint16_t bit)
2852 {
2853         uint16_t        command;
2854
2855         command = PCI_READ_CONFIG(dev, child, PCIR_COMMAND, 2);
2856         command |= bit;
2857         PCI_WRITE_CONFIG(dev, child, PCIR_COMMAND, command, 2);
2858 }
2859
2860 static __inline void
2861 pci_clear_command_bit(device_t dev, device_t child, uint16_t bit)
2862 {
2863         uint16_t        command;
2864
2865         command = PCI_READ_CONFIG(dev, child, PCIR_COMMAND, 2);
2866         command &= ~bit;
2867         PCI_WRITE_CONFIG(dev, child, PCIR_COMMAND, command, 2);
2868 }
2869
2870 int
2871 pci_enable_busmaster_method(device_t dev, device_t child)
2872 {
2873         pci_set_command_bit(dev, child, PCIM_CMD_BUSMASTEREN);
2874         return (0);
2875 }
2876
2877 int
2878 pci_disable_busmaster_method(device_t dev, device_t child)
2879 {
2880         pci_clear_command_bit(dev, child, PCIM_CMD_BUSMASTEREN);
2881         return (0);
2882 }
2883
2884 int
2885 pci_enable_io_method(device_t dev, device_t child, int space)
2886 {
2887         uint16_t bit;
2888
2889         switch(space) {
2890         case SYS_RES_IOPORT:
2891                 bit = PCIM_CMD_PORTEN;
2892                 break;
2893         case SYS_RES_MEMORY:
2894                 bit = PCIM_CMD_MEMEN;
2895                 break;
2896         default:
2897                 return (EINVAL);
2898         }
2899         pci_set_command_bit(dev, child, bit);
2900         return (0);
2901 }
2902
2903 int
2904 pci_disable_io_method(device_t dev, device_t child, int space)
2905 {
2906         uint16_t bit;
2907
2908         switch(space) {
2909         case SYS_RES_IOPORT:
2910                 bit = PCIM_CMD_PORTEN;
2911                 break;
2912         case SYS_RES_MEMORY:
2913                 bit = PCIM_CMD_MEMEN;
2914                 break;
2915         default:
2916                 return (EINVAL);
2917         }
2918         pci_clear_command_bit(dev, child, bit);
2919         return (0);
2920 }
2921
2922 /*
2923  * New style pci driver.  Parent device is either a pci-host-bridge or a
2924  * pci-pci-bridge.  Both kinds are represented by instances of pcib.
2925  */
2926
2927 void
2928 pci_print_verbose(struct pci_devinfo *dinfo)
2929 {
2930
2931         if (bootverbose) {
2932                 pcicfgregs *cfg = &dinfo->cfg;
2933
2934                 printf("found->\tvendor=0x%04x, dev=0x%04x, revid=0x%02x\n",
2935                     cfg->vendor, cfg->device, cfg->revid);
2936                 printf("\tdomain=%d, bus=%d, slot=%d, func=%d\n",
2937                     cfg->domain, cfg->bus, cfg->slot, cfg->func);
2938                 printf("\tclass=%02x-%02x-%02x, hdrtype=0x%02x, mfdev=%d\n",
2939                     cfg->baseclass, cfg->subclass, cfg->progif, cfg->hdrtype,
2940                     cfg->mfdev);
2941                 printf("\tcmdreg=0x%04x, statreg=0x%04x, cachelnsz=%d (dwords)\n",
2942                     cfg->cmdreg, cfg->statreg, cfg->cachelnsz);
2943                 printf("\tlattimer=0x%02x (%d ns), mingnt=0x%02x (%d ns), maxlat=0x%02x (%d ns)\n",
2944                     cfg->lattimer, cfg->lattimer * 30, cfg->mingnt,
2945                     cfg->mingnt * 250, cfg->maxlat, cfg->maxlat * 250);
2946                 if (cfg->intpin > 0)
2947                         printf("\tintpin=%c, irq=%d\n",
2948                             cfg->intpin +'a' -1, cfg->intline);
2949                 if (cfg->pp.pp_cap) {
2950                         uint16_t status;
2951
2952                         status = pci_read_config(cfg->dev, cfg->pp.pp_status, 2);
2953                         printf("\tpowerspec %d  supports D0%s%s D3  current D%d\n",
2954                             cfg->pp.pp_cap & PCIM_PCAP_SPEC,
2955                             cfg->pp.pp_cap & PCIM_PCAP_D1SUPP ? " D1" : "",
2956                             cfg->pp.pp_cap & PCIM_PCAP_D2SUPP ? " D2" : "",
2957                             status & PCIM_PSTAT_DMASK);
2958                 }
2959                 if (cfg->msi.msi_location) {
2960                         int ctrl;
2961
2962                         ctrl = cfg->msi.msi_ctrl;
2963                         printf("\tMSI supports %d message%s%s%s\n",
2964                             cfg->msi.msi_msgnum,
2965                             (cfg->msi.msi_msgnum == 1) ? "" : "s",
2966                             (ctrl & PCIM_MSICTRL_64BIT) ? ", 64 bit" : "",
2967                             (ctrl & PCIM_MSICTRL_VECTOR) ? ", vector masks":"");
2968                 }
2969                 if (cfg->msix.msix_location) {
2970                         printf("\tMSI-X supports %d message%s ",
2971                             cfg->msix.msix_msgnum,
2972                             (cfg->msix.msix_msgnum == 1) ? "" : "s");
2973                         if (cfg->msix.msix_table_bar == cfg->msix.msix_pba_bar)
2974                                 printf("in map 0x%x\n",
2975                                     cfg->msix.msix_table_bar);
2976                         else
2977                                 printf("in maps 0x%x and 0x%x\n",
2978                                     cfg->msix.msix_table_bar,
2979                                     cfg->msix.msix_pba_bar);
2980                 }
2981         }
2982 }
2983
2984 static int
2985 pci_porten(device_t dev)
2986 {
2987         return (pci_read_config(dev, PCIR_COMMAND, 2) & PCIM_CMD_PORTEN) != 0;
2988 }
2989
2990 static int
2991 pci_memen(device_t dev)
2992 {
2993         return (pci_read_config(dev, PCIR_COMMAND, 2) & PCIM_CMD_MEMEN) != 0;
2994 }
2995
2996 void
2997 pci_read_bar(device_t dev, int reg, pci_addr_t *mapp, pci_addr_t *testvalp,
2998     int *bar64)
2999 {
3000         struct pci_devinfo *dinfo;
3001         pci_addr_t map, testval;
3002         int ln2range;
3003         uint16_t cmd;
3004
3005         /*
3006          * The device ROM BAR is special.  It is always a 32-bit
3007          * memory BAR.  Bit 0 is special and should not be set when
3008          * sizing the BAR.
3009          */
3010         dinfo = device_get_ivars(dev);
3011         if (PCIR_IS_BIOS(&dinfo->cfg, reg)) {
3012                 map = pci_read_config(dev, reg, 4);
3013                 pci_write_config(dev, reg, 0xfffffffe, 4);
3014                 testval = pci_read_config(dev, reg, 4);
3015                 pci_write_config(dev, reg, map, 4);
3016                 *mapp = map;
3017                 *testvalp = testval;
3018                 if (bar64 != NULL)
3019                         *bar64 = 0;
3020                 return;
3021         }
3022
3023         map = pci_read_config(dev, reg, 4);
3024         ln2range = pci_maprange(map);
3025         if (ln2range == 64)
3026                 map |= (pci_addr_t)pci_read_config(dev, reg + 4, 4) << 32;
3027
3028         /*
3029          * Disable decoding via the command register before
3030          * determining the BAR's length since we will be placing it in
3031          * a weird state.
3032          */
3033         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
3034         pci_write_config(dev, PCIR_COMMAND,
3035             cmd & ~(PCI_BAR_MEM(map) ? PCIM_CMD_MEMEN : PCIM_CMD_PORTEN), 2);
3036
3037         /*
3038          * Determine the BAR's length by writing all 1's.  The bottom
3039          * log_2(size) bits of the BAR will stick as 0 when we read
3040          * the value back.
3041          *
3042          * NB: according to the PCI Local Bus Specification, rev. 3.0:
3043          * "Software writes 0FFFFFFFFh to both registers, reads them back,
3044          * and combines the result into a 64-bit value." (section 6.2.5.1)
3045          *
3046          * Writes to both registers must be performed before attempting to
3047          * read back the size value.
3048          */
3049         testval = 0;
3050         pci_write_config(dev, reg, 0xffffffff, 4);
3051         if (ln2range == 64) {
3052                 pci_write_config(dev, reg + 4, 0xffffffff, 4);
3053                 testval |= (pci_addr_t)pci_read_config(dev, reg + 4, 4) << 32;
3054         }
3055         testval |= pci_read_config(dev, reg, 4);
3056
3057         /*
3058          * Restore the original value of the BAR.  We may have reprogrammed
3059          * the BAR of the low-level console device and when booting verbose,
3060          * we need the console device addressable.
3061          */
3062         pci_write_config(dev, reg, map, 4);
3063         if (ln2range == 64)
3064                 pci_write_config(dev, reg + 4, map >> 32, 4);
3065         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
3066
3067         *mapp = map;
3068         *testvalp = testval;
3069         if (bar64 != NULL)
3070                 *bar64 = (ln2range == 64);
3071 }
3072
3073 static void
3074 pci_write_bar(device_t dev, struct pci_map *pm, pci_addr_t base)
3075 {
3076         struct pci_devinfo *dinfo;
3077         int ln2range;
3078
3079         /* The device ROM BAR is always a 32-bit memory BAR. */
3080         dinfo = device_get_ivars(dev);
3081         if (PCIR_IS_BIOS(&dinfo->cfg, pm->pm_reg))
3082                 ln2range = 32;
3083         else
3084                 ln2range = pci_maprange(pm->pm_value);
3085         pci_write_config(dev, pm->pm_reg, base, 4);
3086         if (ln2range == 64)
3087                 pci_write_config(dev, pm->pm_reg + 4, base >> 32, 4);
3088         pm->pm_value = pci_read_config(dev, pm->pm_reg, 4);
3089         if (ln2range == 64)
3090                 pm->pm_value |= (pci_addr_t)pci_read_config(dev,
3091                     pm->pm_reg + 4, 4) << 32;
3092 }
3093
3094 struct pci_map *
3095 pci_find_bar(device_t dev, int reg)
3096 {
3097         struct pci_devinfo *dinfo;
3098         struct pci_map *pm;
3099
3100         dinfo = device_get_ivars(dev);
3101         STAILQ_FOREACH(pm, &dinfo->cfg.maps, pm_link) {
3102                 if (pm->pm_reg == reg)
3103                         return (pm);
3104         }
3105         return (NULL);
3106 }
3107
3108 int
3109 pci_bar_enabled(device_t dev, struct pci_map *pm)
3110 {
3111         struct pci_devinfo *dinfo;
3112         uint16_t cmd;
3113
3114         dinfo = device_get_ivars(dev);
3115         if (PCIR_IS_BIOS(&dinfo->cfg, pm->pm_reg) &&
3116             !(pm->pm_value & PCIM_BIOS_ENABLE))
3117                 return (0);
3118         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
3119         if (PCIR_IS_BIOS(&dinfo->cfg, pm->pm_reg) || PCI_BAR_MEM(pm->pm_value))
3120                 return ((cmd & PCIM_CMD_MEMEN) != 0);
3121         else
3122                 return ((cmd & PCIM_CMD_PORTEN) != 0);
3123 }
3124
3125 struct pci_map *
3126 pci_add_bar(device_t dev, int reg, pci_addr_t value, pci_addr_t size)
3127 {
3128         struct pci_devinfo *dinfo;
3129         struct pci_map *pm, *prev;
3130
3131         dinfo = device_get_ivars(dev);
3132         pm = malloc(sizeof(*pm), M_DEVBUF, M_WAITOK | M_ZERO);
3133         pm->pm_reg = reg;
3134         pm->pm_value = value;
3135         pm->pm_size = size;
3136         STAILQ_FOREACH(prev, &dinfo->cfg.maps, pm_link) {
3137                 KASSERT(prev->pm_reg != pm->pm_reg, ("duplicate map %02x",
3138                     reg));
3139                 if (STAILQ_NEXT(prev, pm_link) == NULL ||
3140                     STAILQ_NEXT(prev, pm_link)->pm_reg > pm->pm_reg)
3141                         break;
3142         }
3143         if (prev != NULL)
3144                 STAILQ_INSERT_AFTER(&dinfo->cfg.maps, prev, pm, pm_link);
3145         else
3146                 STAILQ_INSERT_TAIL(&dinfo->cfg.maps, pm, pm_link);
3147         return (pm);
3148 }
3149
3150 static void
3151 pci_restore_bars(device_t dev)
3152 {
3153         struct pci_devinfo *dinfo;
3154         struct pci_map *pm;
3155         int ln2range;
3156
3157         dinfo = device_get_ivars(dev);
3158         STAILQ_FOREACH(pm, &dinfo->cfg.maps, pm_link) {
3159                 if (PCIR_IS_BIOS(&dinfo->cfg, pm->pm_reg))
3160                         ln2range = 32;
3161                 else
3162                         ln2range = pci_maprange(pm->pm_value);
3163                 pci_write_config(dev, pm->pm_reg, pm->pm_value, 4);
3164                 if (ln2range == 64)
3165                         pci_write_config(dev, pm->pm_reg + 4,
3166                             pm->pm_value >> 32, 4);
3167         }
3168 }
3169
3170 /*
3171  * Add a resource based on a pci map register. Return 1 if the map
3172  * register is a 32bit map register or 2 if it is a 64bit register.
3173  */
3174 static int
3175 pci_add_map(device_t bus, device_t dev, int reg, struct resource_list *rl,
3176     int force, int prefetch)
3177 {
3178         struct pci_map *pm;
3179         pci_addr_t base, map, testval;
3180         pci_addr_t start, end, count;
3181         int barlen, basezero, flags, maprange, mapsize, type;
3182         uint16_t cmd;
3183         struct resource *res;
3184
3185         /*
3186          * The BAR may already exist if the device is a CardBus card
3187          * whose CIS is stored in this BAR.
3188          */
3189         pm = pci_find_bar(dev, reg);
3190         if (pm != NULL) {
3191                 maprange = pci_maprange(pm->pm_value);
3192                 barlen = maprange == 64 ? 2 : 1;
3193                 return (barlen);
3194         }
3195
3196         pci_read_bar(dev, reg, &map, &testval, NULL);
3197         if (PCI_BAR_MEM(map)) {
3198                 type = SYS_RES_MEMORY;
3199                 if (map & PCIM_BAR_MEM_PREFETCH)
3200                         prefetch = 1;
3201         } else
3202                 type = SYS_RES_IOPORT;
3203         mapsize = pci_mapsize(testval);
3204         base = pci_mapbase(map);
3205 #ifdef __PCI_BAR_ZERO_VALID
3206         basezero = 0;
3207 #else
3208         basezero = base == 0;
3209 #endif
3210         maprange = pci_maprange(map);
3211         barlen = maprange == 64 ? 2 : 1;
3212
3213         /*
3214          * For I/O registers, if bottom bit is set, and the next bit up
3215          * isn't clear, we know we have a BAR that doesn't conform to the
3216          * spec, so ignore it.  Also, sanity check the size of the data
3217          * areas to the type of memory involved.  Memory must be at least
3218          * 16 bytes in size, while I/O ranges must be at least 4.
3219          */
3220         if (PCI_BAR_IO(testval) && (testval & PCIM_BAR_IO_RESERVED) != 0)
3221                 return (barlen);
3222         if ((type == SYS_RES_MEMORY && mapsize < 4) ||
3223             (type == SYS_RES_IOPORT && mapsize < 2))
3224                 return (barlen);
3225
3226         /* Save a record of this BAR. */
3227         pm = pci_add_bar(dev, reg, map, mapsize);
3228         if (bootverbose) {
3229                 printf("\tmap[%02x]: type %s, range %2d, base %#jx, size %2d",
3230                     reg, pci_maptype(map), maprange, (uintmax_t)base, mapsize);
3231                 if (type == SYS_RES_IOPORT && !pci_porten(dev))
3232                         printf(", port disabled\n");
3233                 else if (type == SYS_RES_MEMORY && !pci_memen(dev))
3234                         printf(", memory disabled\n");
3235                 else
3236                         printf(", enabled\n");
3237         }
3238
3239         /*
3240          * If base is 0, then we have problems if this architecture does
3241          * not allow that.  It is best to ignore such entries for the
3242          * moment.  These will be allocated later if the driver specifically
3243          * requests them.  However, some removable buses look better when
3244          * all resources are allocated, so allow '0' to be overriden.
3245          *
3246          * Similarly treat maps whose values is the same as the test value
3247          * read back.  These maps have had all f's written to them by the
3248          * BIOS in an attempt to disable the resources.
3249          */
3250         if (!force && (basezero || map == testval))
3251                 return (barlen);
3252         if ((u_long)base != base) {
3253                 device_printf(bus,
3254                     "pci%d:%d:%d:%d bar %#x too many address bits",
3255                     pci_get_domain(dev), pci_get_bus(dev), pci_get_slot(dev),
3256                     pci_get_function(dev), reg);
3257                 return (barlen);
3258         }
3259
3260         /*
3261          * This code theoretically does the right thing, but has
3262          * undesirable side effects in some cases where peripherals
3263          * respond oddly to having these bits enabled.  Let the user
3264          * be able to turn them off (since pci_enable_io_modes is 1 by
3265          * default).
3266          */
3267         if (pci_enable_io_modes) {
3268                 /* Turn on resources that have been left off by a lazy BIOS */
3269                 if (type == SYS_RES_IOPORT && !pci_porten(dev)) {
3270                         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
3271                         cmd |= PCIM_CMD_PORTEN;
3272                         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
3273                 }
3274                 if (type == SYS_RES_MEMORY && !pci_memen(dev)) {
3275                         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
3276                         cmd |= PCIM_CMD_MEMEN;
3277                         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
3278                 }
3279         } else {
3280                 if (type == SYS_RES_IOPORT && !pci_porten(dev))
3281                         return (barlen);
3282                 if (type == SYS_RES_MEMORY && !pci_memen(dev))
3283                         return (barlen);
3284         }
3285
3286         count = (pci_addr_t)1 << mapsize;
3287         flags = RF_ALIGNMENT_LOG2(mapsize);
3288         if (prefetch)
3289                 flags |= RF_PREFETCHABLE;
3290         if (basezero || base == pci_mapbase(testval) || pci_clear_bars) {
3291                 start = 0;      /* Let the parent decide. */
3292                 end = ~0;
3293         } else {
3294                 start = base;
3295                 end = base + count - 1;
3296         }
3297         resource_list_add(rl, type, reg, start, end, count);
3298
3299         /*
3300          * Try to allocate the resource for this BAR from our parent
3301          * so that this resource range is already reserved.  The
3302          * driver for this device will later inherit this resource in
3303          * pci_alloc_resource().
3304          */
3305         res = resource_list_reserve(rl, bus, dev, type, &reg, start, end, count,
3306             flags);
3307         if ((pci_do_realloc_bars
3308                 || pci_has_quirk(pci_get_devid(dev), PCI_QUIRK_REALLOC_BAR))
3309             && res == NULL && (start != 0 || end != ~0)) {
3310                 /*
3311                  * If the allocation fails, try to allocate a resource for
3312                  * this BAR using any available range.  The firmware felt
3313                  * it was important enough to assign a resource, so don't
3314                  * disable decoding if we can help it.
3315                  */
3316                 resource_list_delete(rl, type, reg);
3317                 resource_list_add(rl, type, reg, 0, ~0, count);
3318                 res = resource_list_reserve(rl, bus, dev, type, &reg, 0, ~0,
3319                     count, flags);
3320         }
3321         if (res == NULL) {
3322                 /*
3323                  * If the allocation fails, delete the resource list entry
3324                  * and disable decoding for this device.
3325                  *
3326                  * If the driver requests this resource in the future,
3327                  * pci_reserve_map() will try to allocate a fresh
3328                  * resource range.
3329                  */
3330                 resource_list_delete(rl, type, reg);
3331                 pci_disable_io(dev, type);
3332                 if (bootverbose)
3333                         device_printf(bus,
3334                             "pci%d:%d:%d:%d bar %#x failed to allocate\n",
3335                             pci_get_domain(dev), pci_get_bus(dev),
3336                             pci_get_slot(dev), pci_get_function(dev), reg);
3337         } else {
3338                 start = rman_get_start(res);
3339                 pci_write_bar(dev, pm, start);
3340         }
3341         return (barlen);
3342 }
3343
3344 /*
3345  * For ATA devices we need to decide early what addressing mode to use.
3346  * Legacy demands that the primary and secondary ATA ports sits on the
3347  * same addresses that old ISA hardware did. This dictates that we use
3348  * those addresses and ignore the BAR's if we cannot set PCI native
3349  * addressing mode.
3350  */
3351 static void
3352 pci_ata_maps(device_t bus, device_t dev, struct resource_list *rl, int force,
3353     uint32_t prefetchmask)
3354 {
3355         int rid, type, progif;
3356 #if 0
3357         /* if this device supports PCI native addressing use it */
3358         progif = pci_read_config(dev, PCIR_PROGIF, 1);
3359         if ((progif & 0x8a) == 0x8a) {
3360                 if (pci_mapbase(pci_read_config(dev, PCIR_BAR(0), 4)) &&
3361                     pci_mapbase(pci_read_config(dev, PCIR_BAR(2), 4))) {
3362                         printf("Trying ATA native PCI addressing mode\n");
3363                         pci_write_config(dev, PCIR_PROGIF, progif | 0x05, 1);
3364                 }
3365         }
3366 #endif
3367         progif = pci_read_config(dev, PCIR_PROGIF, 1);
3368         type = SYS_RES_IOPORT;
3369         if (progif & PCIP_STORAGE_IDE_MODEPRIM) {
3370                 pci_add_map(bus, dev, PCIR_BAR(0), rl, force,
3371                     prefetchmask & (1 << 0));
3372                 pci_add_map(bus, dev, PCIR_BAR(1), rl, force,
3373                     prefetchmask & (1 << 1));
3374         } else {
3375                 rid = PCIR_BAR(0);
3376                 resource_list_add(rl, type, rid, 0x1f0, 0x1f7, 8);
3377                 (void)resource_list_reserve(rl, bus, dev, type, &rid, 0x1f0,
3378                     0x1f7, 8, 0);
3379                 rid = PCIR_BAR(1);
3380                 resource_list_add(rl, type, rid, 0x3f6, 0x3f6, 1);
3381                 (void)resource_list_reserve(rl, bus, dev, type, &rid, 0x3f6,
3382                     0x3f6, 1, 0);
3383         }
3384         if (progif & PCIP_STORAGE_IDE_MODESEC) {
3385                 pci_add_map(bus, dev, PCIR_BAR(2), rl, force,
3386                     prefetchmask & (1 << 2));
3387                 pci_add_map(bus, dev, PCIR_BAR(3), rl, force,
3388                     prefetchmask & (1 << 3));
3389         } else {
3390                 rid = PCIR_BAR(2);
3391                 resource_list_add(rl, type, rid, 0x170, 0x177, 8);
3392                 (void)resource_list_reserve(rl, bus, dev, type, &rid, 0x170,
3393                     0x177, 8, 0);
3394                 rid = PCIR_BAR(3);
3395                 resource_list_add(rl, type, rid, 0x376, 0x376, 1);
3396                 (void)resource_list_reserve(rl, bus, dev, type, &rid, 0x376,
3397                     0x376, 1, 0);
3398         }
3399         pci_add_map(bus, dev, PCIR_BAR(4), rl, force,
3400             prefetchmask & (1 << 4));
3401         pci_add_map(bus, dev, PCIR_BAR(5), rl, force,
3402             prefetchmask & (1 << 5));
3403 }
3404
3405 static void
3406 pci_assign_interrupt(device_t bus, device_t dev, int force_route)
3407 {
3408         struct pci_devinfo *dinfo = device_get_ivars(dev);
3409         pcicfgregs *cfg = &dinfo->cfg;
3410         char tunable_name[64];
3411         int irq;
3412
3413         /* Has to have an intpin to have an interrupt. */
3414         if (cfg->intpin == 0)
3415                 return;
3416
3417         /* Let the user override the IRQ with a tunable. */
3418         irq = PCI_INVALID_IRQ;
3419         snprintf(tunable_name, sizeof(tunable_name),
3420             "hw.pci%d.%d.%d.INT%c.irq",
3421             cfg->domain, cfg->bus, cfg->slot, cfg->intpin + 'A' - 1);
3422         if (TUNABLE_INT_FETCH(tunable_name, &irq) && (irq >= 255 || irq <= 0))
3423                 irq = PCI_INVALID_IRQ;
3424
3425         /*
3426          * If we didn't get an IRQ via the tunable, then we either use the
3427          * IRQ value in the intline register or we ask the bus to route an
3428          * interrupt for us.  If force_route is true, then we only use the
3429          * value in the intline register if the bus was unable to assign an
3430          * IRQ.
3431          */
3432         if (!PCI_INTERRUPT_VALID(irq)) {
3433                 if (!PCI_INTERRUPT_VALID(cfg->intline) || force_route)
3434                         irq = PCI_ASSIGN_INTERRUPT(bus, dev);
3435                 if (!PCI_INTERRUPT_VALID(irq))
3436                         irq = cfg->intline;
3437         }
3438
3439         /* If after all that we don't have an IRQ, just bail. */
3440         if (!PCI_INTERRUPT_VALID(irq))
3441                 return;
3442
3443         /* Update the config register if it changed. */
3444         if (irq != cfg->intline) {
3445                 cfg->intline = irq;
3446                 pci_write_config(dev, PCIR_INTLINE, irq, 1);
3447         }
3448
3449         /* Add this IRQ as rid 0 interrupt resource. */
3450         resource_list_add(&dinfo->resources, SYS_RES_IRQ, 0, irq, irq, 1);
3451 }
3452
3453 /* Perform early OHCI takeover from SMM. */
3454 static void
3455 ohci_early_takeover(device_t self)
3456 {
3457         struct resource *res;
3458         uint32_t ctl;
3459         int rid;
3460         int i;
3461
3462         rid = PCIR_BAR(0);
3463         res = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, RF_ACTIVE);
3464         if (res == NULL)
3465                 return;
3466
3467         ctl = bus_read_4(res, OHCI_CONTROL);
3468         if (ctl & OHCI_IR) {
3469                 if (bootverbose)
3470                         printf("ohci early: "
3471                             "SMM active, request owner change\n");
3472                 bus_write_4(res, OHCI_COMMAND_STATUS, OHCI_OCR);
3473                 for (i = 0; (i < 100) && (ctl & OHCI_IR); i++) {
3474                         DELAY(1000);
3475                         ctl = bus_read_4(res, OHCI_CONTROL);
3476                 }
3477                 if (ctl & OHCI_IR) {
3478                         if (bootverbose)
3479                                 printf("ohci early: "
3480                                     "SMM does not respond, resetting\n");
3481                         bus_write_4(res, OHCI_CONTROL, OHCI_HCFS_RESET);
3482                 }
3483                 /* Disable interrupts */
3484                 bus_write_4(res, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS);
3485         }
3486
3487         bus_release_resource(self, SYS_RES_MEMORY, rid, res);
3488 }
3489
3490 /* Perform early UHCI takeover from SMM. */
3491 static void
3492 uhci_early_takeover(device_t self)
3493 {
3494         struct resource *res;
3495         int rid;
3496
3497         /*
3498          * Set the PIRQD enable bit and switch off all the others. We don't
3499          * want legacy support to interfere with us XXX Does this also mean
3500          * that the BIOS won't touch the keyboard anymore if it is connected
3501          * to the ports of the root hub?
3502          */
3503         pci_write_config(self, PCI_LEGSUP, PCI_LEGSUP_USBPIRQDEN, 2);
3504
3505         /* Disable interrupts */
3506         rid = PCI_UHCI_BASE_REG;
3507         res = bus_alloc_resource_any(self, SYS_RES_IOPORT, &rid, RF_ACTIVE);
3508         if (res != NULL) {
3509                 bus_write_2(res, UHCI_INTR, 0);
3510                 bus_release_resource(self, SYS_RES_IOPORT, rid, res);
3511         }
3512 }
3513
3514 /* Perform early EHCI takeover from SMM. */
3515 static void
3516 ehci_early_takeover(device_t self)
3517 {
3518         struct resource *res;
3519         uint32_t cparams;
3520         uint32_t eec;
3521         uint8_t eecp;
3522         uint8_t bios_sem;
3523         uint8_t offs;
3524         int rid;
3525         int i;
3526
3527         rid = PCIR_BAR(0);
3528         res = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, RF_ACTIVE);
3529         if (res == NULL)
3530                 return;
3531
3532         cparams = bus_read_4(res, EHCI_HCCPARAMS);
3533
3534         /* Synchronise with the BIOS if it owns the controller. */
3535         for (eecp = EHCI_HCC_EECP(cparams); eecp != 0;
3536             eecp = EHCI_EECP_NEXT(eec)) {
3537                 eec = pci_read_config(self, eecp, 4);
3538                 if (EHCI_EECP_ID(eec) != EHCI_EC_LEGSUP) {
3539                         continue;
3540                 }
3541                 bios_sem = pci_read_config(self, eecp +
3542                     EHCI_LEGSUP_BIOS_SEM, 1);
3543                 if (bios_sem == 0) {
3544                         continue;
3545                 }
3546                 if (bootverbose)
3547                         printf("ehci early: "
3548                             "SMM active, request owner change\n");
3549
3550                 pci_write_config(self, eecp + EHCI_LEGSUP_OS_SEM, 1, 1);
3551
3552                 for (i = 0; (i < 100) && (bios_sem != 0); i++) {
3553                         DELAY(1000);
3554                         bios_sem = pci_read_config(self, eecp +
3555                             EHCI_LEGSUP_BIOS_SEM, 1);
3556                 }
3557
3558                 if (bios_sem != 0) {
3559                         if (bootverbose)
3560                                 printf("ehci early: "
3561                                     "SMM does not respond\n");
3562                 }
3563                 /* Disable interrupts */
3564                 offs = EHCI_CAPLENGTH(bus_read_4(res, EHCI_CAPLEN_HCIVERSION));
3565                 bus_write_4(res, offs + EHCI_USBINTR, 0);
3566         }
3567         bus_release_resource(self, SYS_RES_MEMORY, rid, res);
3568 }
3569
3570 /* Perform early XHCI takeover from SMM. */
3571 static void
3572 xhci_early_takeover(device_t self)
3573 {
3574         struct resource *res;
3575         uint32_t cparams;
3576         uint32_t eec;
3577         uint8_t eecp;
3578         uint8_t bios_sem;
3579         uint8_t offs;
3580         int rid;
3581         int i;
3582
3583         rid = PCIR_BAR(0);
3584         res = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, RF_ACTIVE);
3585         if (res == NULL)
3586                 return;
3587
3588         cparams = bus_read_4(res, XHCI_HCSPARAMS0);
3589
3590         eec = -1;
3591
3592         /* Synchronise with the BIOS if it owns the controller. */
3593         for (eecp = XHCI_HCS0_XECP(cparams) << 2; eecp != 0 && XHCI_XECP_NEXT(eec);
3594             eecp += XHCI_XECP_NEXT(eec) << 2) {
3595                 eec = bus_read_4(res, eecp);
3596
3597                 if (XHCI_XECP_ID(eec) != XHCI_ID_USB_LEGACY)
3598                         continue;
3599
3600                 bios_sem = bus_read_1(res, eecp + XHCI_XECP_BIOS_SEM);
3601                 if (bios_sem == 0)
3602                         continue;
3603
3604                 if (bootverbose)
3605                         printf("xhci early: "
3606                             "SMM active, request owner change\n");
3607
3608                 bus_write_1(res, eecp + XHCI_XECP_OS_SEM, 1);
3609
3610                 /* wait a maximum of 5 second */
3611
3612                 for (i = 0; (i < 5000) && (bios_sem != 0); i++) {
3613                         DELAY(1000);
3614                         bios_sem = bus_read_1(res, eecp +
3615                             XHCI_XECP_BIOS_SEM);
3616                 }
3617
3618                 if (bios_sem != 0) {
3619                         if (bootverbose)
3620                                 printf("xhci early: "
3621                                     "SMM does not respond\n");
3622                 }
3623
3624                 /* Disable interrupts */
3625                 offs = bus_read_1(res, XHCI_CAPLENGTH);
3626                 bus_write_4(res, offs + XHCI_USBCMD, 0);
3627                 bus_read_4(res, offs + XHCI_USBSTS);
3628         }
3629         bus_release_resource(self, SYS_RES_MEMORY, rid, res);
3630 }
3631
3632 #if defined(NEW_PCIB) && defined(PCI_RES_BUS)
3633 static void
3634 pci_reserve_secbus(device_t bus, device_t dev, pcicfgregs *cfg,
3635     struct resource_list *rl)
3636 {
3637         struct resource *res;
3638         char *cp;
3639         rman_res_t start, end, count;
3640         int rid, sec_bus, sec_reg, sub_bus, sub_reg, sup_bus;
3641
3642         switch (cfg->hdrtype & PCIM_HDRTYPE) {
3643         case PCIM_HDRTYPE_BRIDGE:
3644                 sec_reg = PCIR_SECBUS_1;
3645                 sub_reg = PCIR_SUBBUS_1;
3646                 break;
3647         case PCIM_HDRTYPE_CARDBUS:
3648                 sec_reg = PCIR_SECBUS_2;
3649                 sub_reg = PCIR_SUBBUS_2;
3650                 break;
3651         default:
3652                 return;
3653         }
3654
3655         /*
3656          * If the existing bus range is valid, attempt to reserve it
3657          * from our parent.  If this fails for any reason, clear the
3658          * secbus and subbus registers.
3659          *
3660          * XXX: Should we reset sub_bus to sec_bus if it is < sec_bus?
3661          * This would at least preserve the existing sec_bus if it is
3662          * valid.
3663          */
3664         sec_bus = PCI_READ_CONFIG(bus, dev, sec_reg, 1);
3665         sub_bus = PCI_READ_CONFIG(bus, dev, sub_reg, 1);
3666
3667         /* Quirk handling. */
3668         switch (pci_get_devid(dev)) {
3669         case 0x12258086:                /* Intel 82454KX/GX (Orion) */
3670                 sup_bus = pci_read_config(dev, 0x41, 1);
3671                 if (sup_bus != 0xff) {
3672                         sec_bus = sup_bus + 1;
3673                         sub_bus = sup_bus + 1;
3674                         PCI_WRITE_CONFIG(bus, dev, sec_reg, sec_bus, 1);
3675                         PCI_WRITE_CONFIG(bus, dev, sub_reg, sub_bus, 1);
3676                 }
3677                 break;
3678
3679         case 0x00dd10de:
3680                 /* Compaq R3000 BIOS sets wrong subordinate bus number. */
3681                 if ((cp = kern_getenv("smbios.planar.maker")) == NULL)
3682                         break;
3683                 if (strncmp(cp, "Compal", 6) != 0) {
3684                         freeenv(cp);
3685                         break;
3686                 }
3687                 freeenv(cp);
3688                 if ((cp = kern_getenv("smbios.planar.product")) == NULL)
3689                         break;
3690                 if (strncmp(cp, "08A0", 4) != 0) {
3691                         freeenv(cp);
3692                         break;
3693                 }
3694                 freeenv(cp);
3695                 if (sub_bus < 0xa) {
3696                         sub_bus = 0xa;
3697                         PCI_WRITE_CONFIG(bus, dev, sub_reg, sub_bus, 1);
3698                 }
3699                 break;
3700         }
3701
3702         if (bootverbose)
3703                 printf("\tsecbus=%d, subbus=%d\n", sec_bus, sub_bus);
3704         if (sec_bus > 0 && sub_bus >= sec_bus) {
3705                 start = sec_bus;
3706                 end = sub_bus;
3707                 count = end - start + 1;
3708
3709                 resource_list_add(rl, PCI_RES_BUS, 0, 0, ~0, count);
3710
3711                 /*
3712                  * If requested, clear secondary bus registers in
3713                  * bridge devices to force a complete renumbering
3714                  * rather than reserving the existing range.  However,
3715                  * preserve the existing size.
3716                  */
3717                 if (pci_clear_buses)
3718                         goto clear;
3719
3720                 rid = 0;
3721                 res = resource_list_reserve(rl, bus, dev, PCI_RES_BUS, &rid,
3722                     start, end, count, 0);
3723                 if (res != NULL)
3724                         return;
3725
3726                 if (bootverbose)
3727                         device_printf(bus,
3728                             "pci%d:%d:%d:%d secbus failed to allocate\n",
3729                             pci_get_domain(dev), pci_get_bus(dev),
3730                             pci_get_slot(dev), pci_get_function(dev));
3731         }
3732
3733 clear:
3734         PCI_WRITE_CONFIG(bus, dev, sec_reg, 0, 1);
3735         PCI_WRITE_CONFIG(bus, dev, sub_reg, 0, 1);
3736 }
3737
3738 static struct resource *
3739 pci_alloc_secbus(device_t dev, device_t child, int *rid, rman_res_t start,
3740     rman_res_t end, rman_res_t count, u_int flags)
3741 {
3742         struct pci_devinfo *dinfo;
3743         pcicfgregs *cfg;
3744         struct resource_list *rl;
3745         struct resource *res;
3746         int sec_reg, sub_reg;
3747
3748         dinfo = device_get_ivars(child);
3749         cfg = &dinfo->cfg;
3750         rl = &dinfo->resources;
3751         switch (cfg->hdrtype & PCIM_HDRTYPE) {
3752         case PCIM_HDRTYPE_BRIDGE:
3753                 sec_reg = PCIR_SECBUS_1;
3754                 sub_reg = PCIR_SUBBUS_1;
3755                 break;
3756         case PCIM_HDRTYPE_CARDBUS:
3757                 sec_reg = PCIR_SECBUS_2;
3758                 sub_reg = PCIR_SUBBUS_2;
3759                 break;
3760         default:
3761                 return (NULL);
3762         }
3763
3764         if (*rid != 0)
3765                 return (NULL);
3766
3767         if (resource_list_find(rl, PCI_RES_BUS, *rid) == NULL)
3768                 resource_list_add(rl, PCI_RES_BUS, *rid, start, end, count);
3769         if (!resource_list_reserved(rl, PCI_RES_BUS, *rid)) {
3770                 res = resource_list_reserve(rl, dev, child, PCI_RES_BUS, rid,
3771                     start, end, count, flags & ~RF_ACTIVE);
3772                 if (res == NULL) {
3773                         resource_list_delete(rl, PCI_RES_BUS, *rid);
3774                         device_printf(child, "allocating %ju bus%s failed\n",
3775                             count, count == 1 ? "" : "es");
3776                         return (NULL);
3777                 }
3778                 if (bootverbose)
3779                         device_printf(child,
3780                             "Lazy allocation of %ju bus%s at %ju\n", count,
3781                             count == 1 ? "" : "es", rman_get_start(res));
3782                 PCI_WRITE_CONFIG(dev, child, sec_reg, rman_get_start(res), 1);
3783                 PCI_WRITE_CONFIG(dev, child, sub_reg, rman_get_end(res), 1);
3784         }
3785         return (resource_list_alloc(rl, dev, child, PCI_RES_BUS, rid, start,
3786             end, count, flags));
3787 }
3788 #endif
3789
3790 static int
3791 pci_ea_bei_to_rid(device_t dev, int bei)
3792 {
3793 #ifdef PCI_IOV
3794         struct pci_devinfo *dinfo;
3795         int iov_pos;
3796         struct pcicfg_iov *iov;
3797
3798         dinfo = device_get_ivars(dev);
3799         iov = dinfo->cfg.iov;
3800         if (iov != NULL)
3801                 iov_pos = iov->iov_pos;
3802         else
3803                 iov_pos = 0;
3804 #endif
3805
3806         /* Check if matches BAR */
3807         if ((bei >= PCIM_EA_BEI_BAR_0) &&
3808             (bei <= PCIM_EA_BEI_BAR_5))
3809                 return (PCIR_BAR(bei));
3810
3811         /* Check ROM */
3812         if (bei == PCIM_EA_BEI_ROM)
3813                 return (PCIR_BIOS);
3814
3815 #ifdef PCI_IOV
3816         /* Check if matches VF_BAR */
3817         if ((iov != NULL) && (bei >= PCIM_EA_BEI_VF_BAR_0) &&
3818             (bei <= PCIM_EA_BEI_VF_BAR_5))
3819                 return (PCIR_SRIOV_BAR(bei - PCIM_EA_BEI_VF_BAR_0) +
3820                     iov_pos);
3821 #endif
3822
3823         return (-1);
3824 }
3825
3826 int
3827 pci_ea_is_enabled(device_t dev, int rid)
3828 {
3829         struct pci_ea_entry *ea;
3830         struct pci_devinfo *dinfo;
3831
3832         dinfo = device_get_ivars(dev);
3833
3834         STAILQ_FOREACH(ea, &dinfo->cfg.ea.ea_entries, eae_link) {
3835                 if (pci_ea_bei_to_rid(dev, ea->eae_bei) == rid)
3836                         return ((ea->eae_flags & PCIM_EA_ENABLE) > 0);
3837         }
3838
3839         return (0);
3840 }
3841
3842 void
3843 pci_add_resources_ea(device_t bus, device_t dev, int alloc_iov)
3844 {
3845         struct pci_ea_entry *ea;
3846         struct pci_devinfo *dinfo;
3847         pci_addr_t start, end, count;
3848         struct resource_list *rl;
3849         int type, flags, rid;
3850         struct resource *res;
3851         uint32_t tmp;
3852 #ifdef PCI_IOV
3853         struct pcicfg_iov *iov;
3854 #endif
3855
3856         dinfo = device_get_ivars(dev);
3857         rl = &dinfo->resources;
3858         flags = 0;
3859
3860 #ifdef PCI_IOV
3861         iov = dinfo->cfg.iov;
3862 #endif
3863
3864         if (dinfo->cfg.ea.ea_location == 0)
3865                 return;
3866
3867         STAILQ_FOREACH(ea, &dinfo->cfg.ea.ea_entries, eae_link) {
3868
3869                 /*
3870                  * TODO: Ignore EA-BAR if is not enabled.
3871                  *   Currently the EA implementation supports
3872                  *   only situation, where EA structure contains
3873                  *   predefined entries. In case they are not enabled
3874                  *   leave them unallocated and proceed with
3875                  *   a legacy-BAR mechanism.
3876                  */
3877                 if ((ea->eae_flags & PCIM_EA_ENABLE) == 0)
3878                         continue;
3879
3880                 switch ((ea->eae_flags & PCIM_EA_PP) >> PCIM_EA_PP_OFFSET) {
3881                 case PCIM_EA_P_MEM_PREFETCH:
3882                 case PCIM_EA_P_VF_MEM_PREFETCH:
3883                         flags = RF_PREFETCHABLE;
3884                         /* FALLTHROUGH */
3885                 case PCIM_EA_P_VF_MEM:
3886                 case PCIM_EA_P_MEM:
3887                         type = SYS_RES_MEMORY;
3888                         break;
3889                 case PCIM_EA_P_IO:
3890                         type = SYS_RES_IOPORT;
3891                         break;
3892                 default:
3893                         continue;
3894                 }
3895
3896                 if (alloc_iov != 0) {
3897 #ifdef PCI_IOV
3898                         /* Allocating IOV, confirm BEI matches */
3899                         if ((ea->eae_bei < PCIM_EA_BEI_VF_BAR_0) ||
3900                             (ea->eae_bei > PCIM_EA_BEI_VF_BAR_5))
3901                                 continue;
3902 #else
3903                         continue;
3904 #endif
3905                 } else {
3906                         /* Allocating BAR, confirm BEI matches */
3907                         if (((ea->eae_bei < PCIM_EA_BEI_BAR_0) ||
3908                             (ea->eae_bei > PCIM_EA_BEI_BAR_5)) &&
3909                             (ea->eae_bei != PCIM_EA_BEI_ROM))
3910                                 continue;
3911                 }
3912
3913                 rid = pci_ea_bei_to_rid(dev, ea->eae_bei);
3914                 if (rid < 0)
3915                         continue;
3916
3917                 /* Skip resources already allocated by EA */
3918                 if ((resource_list_find(rl, SYS_RES_MEMORY, rid) != NULL) ||
3919                     (resource_list_find(rl, SYS_RES_IOPORT, rid) != NULL))
3920                         continue;
3921
3922                 start = ea->eae_base;
3923                 count = ea->eae_max_offset + 1;
3924 #ifdef PCI_IOV
3925                 if (iov != NULL)
3926                         count = count * iov->iov_num_vfs;
3927 #endif
3928                 end = start + count - 1;
3929                 if (count == 0)
3930                         continue;
3931
3932                 resource_list_add(rl, type, rid, start, end, count);
3933                 res = resource_list_reserve(rl, bus, dev, type, &rid, start, end, count,
3934                     flags);
3935                 if (res == NULL) {
3936                         resource_list_delete(rl, type, rid);
3937
3938                         /*
3939                          * Failed to allocate using EA, disable entry.
3940                          * Another attempt to allocation will be performed
3941                          * further, but this time using legacy BAR registers
3942                          */
3943                         tmp = pci_read_config(dev, ea->eae_cfg_offset, 4);
3944                         tmp &= ~PCIM_EA_ENABLE;
3945                         pci_write_config(dev, ea->eae_cfg_offset, tmp, 4);
3946
3947                         /*
3948                          * Disabling entry might fail in case it is hardwired.
3949                          * Read flags again to match current status.
3950                          */
3951                         ea->eae_flags = pci_read_config(dev, ea->eae_cfg_offset, 4);
3952
3953                         continue;
3954                 }
3955
3956                 /* As per specification, fill BAR with zeros */
3957                 pci_write_config(dev, rid, 0, 4);
3958         }
3959 }
3960
3961 void
3962 pci_add_resources(device_t bus, device_t dev, int force, uint32_t prefetchmask)
3963 {
3964         struct pci_devinfo *dinfo;
3965         pcicfgregs *cfg;
3966         struct resource_list *rl;
3967         const struct pci_quirk *q;
3968         uint32_t devid;
3969         int i;
3970
3971         dinfo = device_get_ivars(dev);
3972         cfg = &dinfo->cfg;
3973         rl = &dinfo->resources;
3974         devid = (cfg->device << 16) | cfg->vendor;
3975
3976         /* Allocate resources using Enhanced Allocation */
3977         pci_add_resources_ea(bus, dev, 0);
3978
3979         /* ATA devices needs special map treatment */
3980         if ((pci_get_class(dev) == PCIC_STORAGE) &&
3981             (pci_get_subclass(dev) == PCIS_STORAGE_IDE) &&
3982             ((pci_get_progif(dev) & PCIP_STORAGE_IDE_MASTERDEV) ||
3983              (!pci_read_config(dev, PCIR_BAR(0), 4) &&
3984               !pci_read_config(dev, PCIR_BAR(2), 4))) )
3985                 pci_ata_maps(bus, dev, rl, force, prefetchmask);
3986         else
3987                 for (i = 0; i < cfg->nummaps;) {
3988                         /* Skip resources already managed by EA */
3989                         if ((resource_list_find(rl, SYS_RES_MEMORY, PCIR_BAR(i)) != NULL) ||
3990                             (resource_list_find(rl, SYS_RES_IOPORT, PCIR_BAR(i)) != NULL) ||
3991                             pci_ea_is_enabled(dev, PCIR_BAR(i))) {
3992                                 i++;
3993                                 continue;
3994                         }
3995
3996                         /*
3997                          * Skip quirked resources.
3998                          */
3999                         for (q = &pci_quirks[0]; q->devid != 0; q++)
4000                                 if (q->devid == devid &&
4001                                     q->type == PCI_QUIRK_UNMAP_REG &&
4002                                     q->arg1 == PCIR_BAR(i))
4003                                         break;
4004                         if (q->devid != 0) {
4005                                 i++;
4006                                 continue;
4007                         }
4008                         i += pci_add_map(bus, dev, PCIR_BAR(i), rl, force,
4009                             prefetchmask & (1 << i));
4010                 }
4011
4012         /*
4013          * Add additional, quirked resources.
4014          */
4015         for (q = &pci_quirks[0]; q->devid != 0; q++)
4016                 if (q->devid == devid && q->type == PCI_QUIRK_MAP_REG)
4017                         pci_add_map(bus, dev, q->arg1, rl, force, 0);
4018
4019         if (cfg->intpin > 0 && PCI_INTERRUPT_VALID(cfg->intline)) {
4020 #ifdef __PCI_REROUTE_INTERRUPT
4021                 /*
4022                  * Try to re-route interrupts. Sometimes the BIOS or
4023                  * firmware may leave bogus values in these registers.
4024                  * If the re-route fails, then just stick with what we
4025                  * have.
4026                  */
4027                 pci_assign_interrupt(bus, dev, 1);
4028 #else
4029                 pci_assign_interrupt(bus, dev, 0);
4030 #endif
4031         }
4032
4033         if (pci_usb_takeover && pci_get_class(dev) == PCIC_SERIALBUS &&
4034             pci_get_subclass(dev) == PCIS_SERIALBUS_USB) {
4035                 if (pci_get_progif(dev) == PCIP_SERIALBUS_USB_XHCI)
4036                         xhci_early_takeover(dev);
4037                 else if (pci_get_progif(dev) == PCIP_SERIALBUS_USB_EHCI)
4038                         ehci_early_takeover(dev);
4039                 else if (pci_get_progif(dev) == PCIP_SERIALBUS_USB_OHCI)
4040                         ohci_early_takeover(dev);
4041                 else if (pci_get_progif(dev) == PCIP_SERIALBUS_USB_UHCI)
4042                         uhci_early_takeover(dev);
4043         }
4044
4045 #if defined(NEW_PCIB) && defined(PCI_RES_BUS)
4046         /*
4047          * Reserve resources for secondary bus ranges behind bridge
4048          * devices.
4049          */
4050         pci_reserve_secbus(bus, dev, cfg, rl);
4051 #endif
4052 }
4053
4054 static struct pci_devinfo *
4055 pci_identify_function(device_t pcib, device_t dev, int domain, int busno,
4056     int slot, int func)
4057 {
4058         struct pci_devinfo *dinfo;
4059
4060         dinfo = pci_read_device(pcib, dev, domain, busno, slot, func);
4061         if (dinfo != NULL)
4062                 pci_add_child(dev, dinfo);
4063
4064         return (dinfo);
4065 }
4066
4067 void
4068 pci_add_children(device_t dev, int domain, int busno)
4069 {
4070 #define REG(n, w)       PCIB_READ_CONFIG(pcib, busno, s, f, n, w)
4071         device_t pcib = device_get_parent(dev);
4072         struct pci_devinfo *dinfo;
4073         int maxslots;
4074         int s, f, pcifunchigh;
4075         uint8_t hdrtype;
4076         int first_func;
4077
4078         /*
4079          * Try to detect a device at slot 0, function 0.  If it exists, try to
4080          * enable ARI.  We must enable ARI before detecting the rest of the
4081          * functions on this bus as ARI changes the set of slots and functions
4082          * that are legal on this bus.
4083          */
4084         dinfo = pci_identify_function(pcib, dev, domain, busno, 0, 0);
4085         if (dinfo != NULL && pci_enable_ari)
4086                 PCIB_TRY_ENABLE_ARI(pcib, dinfo->cfg.dev);
4087
4088         /*
4089          * Start looking for new devices on slot 0 at function 1 because we
4090          * just identified the device at slot 0, function 0.
4091          */
4092         first_func = 1;
4093
4094         maxslots = PCIB_MAXSLOTS(pcib);
4095         for (s = 0; s <= maxslots; s++, first_func = 0) {
4096                 pcifunchigh = 0;
4097                 f = 0;
4098                 DELAY(1);
4099                 hdrtype = REG(PCIR_HDRTYPE, 1);
4100                 if ((hdrtype & PCIM_HDRTYPE) > PCI_MAXHDRTYPE)
4101                         continue;
4102                 if (hdrtype & PCIM_MFDEV)
4103                         pcifunchigh = PCIB_MAXFUNCS(pcib);
4104                 for (f = first_func; f <= pcifunchigh; f++)
4105                         pci_identify_function(pcib, dev, domain, busno, s, f);
4106         }
4107 #undef REG
4108 }
4109
4110 int
4111 pci_rescan_method(device_t dev)
4112 {
4113 #define REG(n, w)       PCIB_READ_CONFIG(pcib, busno, s, f, n, w)
4114         device_t pcib = device_get_parent(dev);
4115         device_t child, *devlist, *unchanged;
4116         int devcount, error, i, j, maxslots, oldcount;
4117         int busno, domain, s, f, pcifunchigh;
4118         uint8_t hdrtype;
4119
4120         /* No need to check for ARI on a rescan. */
4121         error = device_get_children(dev, &devlist, &devcount);
4122         if (error)
4123                 return (error);
4124         if (devcount != 0) {
4125                 unchanged = malloc(devcount * sizeof(device_t), M_TEMP,
4126                     M_NOWAIT | M_ZERO);
4127                 if (unchanged == NULL) {
4128                         free(devlist, M_TEMP);
4129                         return (ENOMEM);
4130                 }
4131         } else
4132                 unchanged = NULL;
4133
4134         domain = pcib_get_domain(dev);
4135         busno = pcib_get_bus(dev);
4136         maxslots = PCIB_MAXSLOTS(pcib);
4137         for (s = 0; s <= maxslots; s++) {
4138                 /* If function 0 is not present, skip to the next slot. */
4139                 f = 0;
4140                 if (REG(PCIR_VENDOR, 2) == 0xffff)
4141                         continue;
4142                 pcifunchigh = 0;
4143                 hdrtype = REG(PCIR_HDRTYPE, 1);
4144                 if ((hdrtype & PCIM_HDRTYPE) > PCI_MAXHDRTYPE)
4145                         continue;
4146                 if (hdrtype & PCIM_MFDEV)
4147                         pcifunchigh = PCIB_MAXFUNCS(pcib);
4148                 for (f = 0; f <= pcifunchigh; f++) {
4149                         if (REG(PCIR_VENDOR, 2) == 0xffff)
4150                                 continue;
4151
4152                         /*
4153                          * Found a valid function.  Check if a
4154                          * device_t for this device already exists.
4155                          */
4156                         for (i = 0; i < devcount; i++) {
4157                                 child = devlist[i];
4158                                 if (child == NULL)
4159                                         continue;
4160                                 if (pci_get_slot(child) == s &&
4161                                     pci_get_function(child) == f) {
4162                                         unchanged[i] = child;
4163                                         goto next_func;
4164                                 }
4165                         }
4166
4167                         pci_identify_function(pcib, dev, domain, busno, s, f);
4168                 next_func:;
4169                 }
4170         }
4171
4172         /* Remove devices that are no longer present. */
4173         for (i = 0; i < devcount; i++) {
4174                 if (unchanged[i] != NULL)
4175                         continue;
4176                 device_delete_child(dev, devlist[i]);
4177         }
4178
4179         free(devlist, M_TEMP);
4180         oldcount = devcount;
4181
4182         /* Try to attach the devices just added. */
4183         error = device_get_children(dev, &devlist, &devcount);
4184         if (error) {
4185                 free(unchanged, M_TEMP);
4186                 return (error);
4187         }
4188
4189         for (i = 0; i < devcount; i++) {
4190                 for (j = 0; j < oldcount; j++) {
4191                         if (devlist[i] == unchanged[j])
4192                                 goto next_device;
4193                 }
4194
4195                 device_probe_and_attach(devlist[i]);
4196         next_device:;
4197         }
4198
4199         free(unchanged, M_TEMP);
4200         free(devlist, M_TEMP);
4201         return (0);
4202 #undef REG
4203 }
4204
4205 #ifdef PCI_IOV
4206 device_t
4207 pci_add_iov_child(device_t bus, device_t pf, uint16_t rid, uint16_t vid,
4208     uint16_t did)
4209 {
4210         struct pci_devinfo *vf_dinfo;
4211         device_t pcib;
4212         int busno, slot, func;
4213
4214         pcib = device_get_parent(bus);
4215
4216         PCIB_DECODE_RID(pcib, rid, &busno, &slot, &func);
4217
4218         vf_dinfo = pci_fill_devinfo(pcib, bus, pci_get_domain(pcib), busno,
4219             slot, func, vid, did);
4220
4221         vf_dinfo->cfg.flags |= PCICFG_VF;
4222         pci_add_child(bus, vf_dinfo);
4223
4224         return (vf_dinfo->cfg.dev);
4225 }
4226
4227 device_t
4228 pci_create_iov_child_method(device_t bus, device_t pf, uint16_t rid,
4229     uint16_t vid, uint16_t did)
4230 {
4231
4232         return (pci_add_iov_child(bus, pf, rid, vid, did));
4233 }
4234 #endif
4235
4236 static void
4237 pci_add_child_clear_aer(device_t dev, struct pci_devinfo *dinfo)
4238 {
4239         int aer;
4240         uint32_t r;
4241         uint16_t r2;
4242
4243         if (dinfo->cfg.pcie.pcie_location != 0 &&
4244             dinfo->cfg.pcie.pcie_type == PCIEM_TYPE_ROOT_PORT) {
4245                 r2 = pci_read_config(dev, dinfo->cfg.pcie.pcie_location +
4246                     PCIER_ROOT_CTL, 2);
4247                 r2 &= ~(PCIEM_ROOT_CTL_SERR_CORR |
4248                     PCIEM_ROOT_CTL_SERR_NONFATAL | PCIEM_ROOT_CTL_SERR_FATAL);
4249                 pci_write_config(dev, dinfo->cfg.pcie.pcie_location +
4250                     PCIER_ROOT_CTL, r2, 2);
4251         }
4252         if (pci_find_extcap(dev, PCIZ_AER, &aer) == 0) {
4253                 r = pci_read_config(dev, aer + PCIR_AER_UC_STATUS, 4);
4254                 pci_write_config(dev, aer + PCIR_AER_UC_STATUS, r, 4);
4255                 if (r != 0 && bootverbose) {
4256                         pci_printf(&dinfo->cfg,
4257                             "clearing AER UC 0x%08x -> 0x%08x\n",
4258                             r, pci_read_config(dev, aer + PCIR_AER_UC_STATUS,
4259                             4));
4260                 }
4261
4262                 r = pci_read_config(dev, aer + PCIR_AER_UC_MASK, 4);
4263                 r &= ~(PCIM_AER_UC_TRAINING_ERROR |
4264                     PCIM_AER_UC_DL_PROTOCOL_ERROR |
4265                     PCIM_AER_UC_SURPRISE_LINK_DOWN |
4266                     PCIM_AER_UC_POISONED_TLP |
4267                     PCIM_AER_UC_FC_PROTOCOL_ERROR |
4268                     PCIM_AER_UC_COMPLETION_TIMEOUT |
4269                     PCIM_AER_UC_COMPLETER_ABORT |
4270                     PCIM_AER_UC_UNEXPECTED_COMPLETION |
4271                     PCIM_AER_UC_RECEIVER_OVERFLOW |
4272                     PCIM_AER_UC_MALFORMED_TLP |
4273                     PCIM_AER_UC_ECRC_ERROR |
4274                     PCIM_AER_UC_UNSUPPORTED_REQUEST |
4275                     PCIM_AER_UC_ACS_VIOLATION |
4276                     PCIM_AER_UC_INTERNAL_ERROR |
4277                     PCIM_AER_UC_MC_BLOCKED_TLP |
4278                     PCIM_AER_UC_ATOMIC_EGRESS_BLK |
4279                     PCIM_AER_UC_TLP_PREFIX_BLOCKED);
4280                 pci_write_config(dev, aer + PCIR_AER_UC_MASK, r, 4);
4281
4282                 r = pci_read_config(dev, aer + PCIR_AER_COR_STATUS, 4);
4283                 pci_write_config(dev, aer + PCIR_AER_COR_STATUS, r, 4);
4284                 if (r != 0 && bootverbose) {
4285                         pci_printf(&dinfo->cfg,
4286                             "clearing AER COR 0x%08x -> 0x%08x\n",
4287                             r, pci_read_config(dev, aer + PCIR_AER_COR_STATUS,
4288                             4));
4289                 }
4290
4291                 r = pci_read_config(dev, aer + PCIR_AER_COR_MASK, 4);
4292                 r &= ~(PCIM_AER_COR_RECEIVER_ERROR |
4293                     PCIM_AER_COR_BAD_TLP |
4294                     PCIM_AER_COR_BAD_DLLP |
4295                     PCIM_AER_COR_REPLAY_ROLLOVER |
4296                     PCIM_AER_COR_REPLAY_TIMEOUT |
4297                     PCIM_AER_COR_ADVISORY_NF_ERROR |
4298                     PCIM_AER_COR_INTERNAL_ERROR |
4299                     PCIM_AER_COR_HEADER_LOG_OVFLOW);
4300                 pci_write_config(dev, aer + PCIR_AER_COR_MASK, r, 4);
4301
4302                 r = pci_read_config(dev, dinfo->cfg.pcie.pcie_location +
4303                     PCIER_DEVICE_CTL, 2);
4304                 r |=  PCIEM_CTL_COR_ENABLE | PCIEM_CTL_NFER_ENABLE |
4305                     PCIEM_CTL_FER_ENABLE | PCIEM_CTL_URR_ENABLE;
4306                 pci_write_config(dev, dinfo->cfg.pcie.pcie_location +
4307                     PCIER_DEVICE_CTL, r, 2);
4308         }
4309 }
4310
4311 void
4312 pci_add_child(device_t bus, struct pci_devinfo *dinfo)
4313 {
4314         device_t dev;
4315
4316         dinfo->cfg.dev = dev = device_add_child(bus, NULL, -1);
4317         device_set_ivars(dev, dinfo);
4318         resource_list_init(&dinfo->resources);
4319         pci_cfg_save(dev, dinfo, 0);
4320         pci_cfg_restore(dev, dinfo);
4321         pci_print_verbose(dinfo);
4322         pci_add_resources(bus, dev, 0, 0);
4323         pci_child_added(dinfo->cfg.dev);
4324
4325         if (pci_clear_aer_on_attach)
4326                 pci_add_child_clear_aer(dev, dinfo);
4327
4328         EVENTHANDLER_INVOKE(pci_add_device, dinfo->cfg.dev);
4329 }
4330
4331 void
4332 pci_child_added_method(device_t dev, device_t child)
4333 {
4334
4335 }
4336
4337 static int
4338 pci_probe(device_t dev)
4339 {
4340
4341         device_set_desc(dev, "PCI bus");
4342
4343         /* Allow other subclasses to override this driver. */
4344         return (BUS_PROBE_GENERIC);
4345 }
4346
4347 int
4348 pci_attach_common(device_t dev)
4349 {
4350         struct pci_softc *sc;
4351         int busno, domain;
4352 #ifdef PCI_RES_BUS
4353         int rid;
4354 #endif
4355
4356         sc = device_get_softc(dev);
4357         domain = pcib_get_domain(dev);
4358         busno = pcib_get_bus(dev);
4359 #ifdef PCI_RES_BUS
4360         rid = 0;
4361         sc->sc_bus = bus_alloc_resource(dev, PCI_RES_BUS, &rid, busno, busno,
4362             1, 0);
4363         if (sc->sc_bus == NULL) {
4364                 device_printf(dev, "failed to allocate bus number\n");
4365                 return (ENXIO);
4366         }
4367 #endif
4368         if (bootverbose)
4369                 device_printf(dev, "domain=%d, physical bus=%d\n",
4370                     domain, busno);
4371         sc->sc_dma_tag = bus_get_dma_tag(dev);
4372         return (0);
4373 }
4374
4375 int
4376 pci_attach(device_t dev)
4377 {
4378         int busno, domain, error;
4379
4380         error = pci_attach_common(dev);
4381         if (error)
4382                 return (error);
4383
4384         /*
4385          * Since there can be multiple independently numbered PCI
4386          * buses on systems with multiple PCI domains, we can't use
4387          * the unit number to decide which bus we are probing. We ask
4388          * the parent pcib what our domain and bus numbers are.
4389          */
4390         domain = pcib_get_domain(dev);
4391         busno = pcib_get_bus(dev);
4392         pci_add_children(dev, domain, busno);
4393         return (bus_generic_attach(dev));
4394 }
4395
4396 int
4397 pci_detach(device_t dev)
4398 {
4399 #ifdef PCI_RES_BUS
4400         struct pci_softc *sc;
4401 #endif
4402         int error;
4403
4404         error = bus_generic_detach(dev);
4405         if (error)
4406                 return (error);
4407 #ifdef PCI_RES_BUS
4408         sc = device_get_softc(dev);
4409         error = bus_release_resource(dev, PCI_RES_BUS, 0, sc->sc_bus);
4410         if (error)
4411                 return (error);
4412 #endif
4413         return (device_delete_children(dev));
4414 }
4415
4416 static void
4417 pci_hint_device_unit(device_t dev, device_t child, const char *name, int *unitp)
4418 {
4419         int line, unit;
4420         const char *at;
4421         char me1[24], me2[32];
4422         uint8_t b, s, f;
4423         uint32_t d;
4424
4425         d = pci_get_domain(child);
4426         b = pci_get_bus(child);
4427         s = pci_get_slot(child);
4428         f = pci_get_function(child);
4429         snprintf(me1, sizeof(me1), "pci%u:%u:%u", b, s, f);
4430         snprintf(me2, sizeof(me2), "pci%u:%u:%u:%u", d, b, s, f);
4431         line = 0;
4432         while (resource_find_dev(&line, name, &unit, "at", NULL) == 0) {
4433                 resource_string_value(name, unit, "at", &at);
4434                 if (strcmp(at, me1) != 0 && strcmp(at, me2) != 0)
4435                         continue; /* No match, try next candidate */
4436                 *unitp = unit;
4437                 return;
4438         }
4439 }
4440
4441 static void
4442 pci_set_power_child(device_t dev, device_t child, int state)
4443 {
4444         device_t pcib;
4445         int dstate;
4446
4447         /*
4448          * Set the device to the given state.  If the firmware suggests
4449          * a different power state, use it instead.  If power management
4450          * is not present, the firmware is responsible for managing
4451          * device power.  Skip children who aren't attached since they
4452          * are handled separately.
4453          */
4454         pcib = device_get_parent(dev);
4455         dstate = state;
4456         if (device_is_attached(child) &&
4457             PCIB_POWER_FOR_SLEEP(pcib, child, &dstate) == 0)
4458                 pci_set_powerstate(child, dstate);
4459 }
4460
4461 int
4462 pci_suspend_child(device_t dev, device_t child)
4463 {
4464         struct pci_devinfo *dinfo;
4465         struct resource_list_entry *rle;
4466         int error;
4467
4468         dinfo = device_get_ivars(child);
4469
4470         /*
4471          * Save the PCI configuration space for the child and set the
4472          * device in the appropriate power state for this sleep state.
4473          */
4474         pci_cfg_save(child, dinfo, 0);
4475
4476         /* Suspend devices before potentially powering them down. */
4477         error = bus_generic_suspend_child(dev, child);
4478
4479         if (error)
4480                 return (error);
4481
4482         if (pci_do_power_suspend) {
4483                 /*
4484                  * Make sure this device's interrupt handler is not invoked
4485                  * in the case the device uses a shared interrupt that can
4486                  * be raised by some other device.
4487                  * This is applicable only to regular (legacy) PCI interrupts
4488                  * as MSI/MSI-X interrupts are never shared.
4489                  */
4490                 rle = resource_list_find(&dinfo->resources,
4491                     SYS_RES_IRQ, 0);
4492                 if (rle != NULL && rle->res != NULL)
4493                         (void)bus_suspend_intr(child, rle->res);
4494                 pci_set_power_child(dev, child, PCI_POWERSTATE_D3);
4495         }
4496
4497         return (0);
4498 }
4499
4500 int
4501 pci_resume_child(device_t dev, device_t child)
4502 {
4503         struct pci_devinfo *dinfo;
4504         struct resource_list_entry *rle;
4505
4506         if (pci_do_power_resume)
4507                 pci_set_power_child(dev, child, PCI_POWERSTATE_D0);
4508
4509         dinfo = device_get_ivars(child);
4510         pci_cfg_restore(child, dinfo);
4511         if (!device_is_attached(child))
4512                 pci_cfg_save(child, dinfo, 1);
4513
4514         bus_generic_resume_child(dev, child);
4515
4516         /*
4517          * Allow interrupts only after fully resuming the driver and hardware.
4518          */
4519         if (pci_do_power_suspend) {
4520                 /* See pci_suspend_child for details. */
4521                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 0);
4522                 if (rle != NULL && rle->res != NULL)
4523                         (void)bus_resume_intr(child, rle->res);
4524         }
4525
4526         return (0);
4527 }
4528
4529 int
4530 pci_resume(device_t dev)
4531 {
4532         device_t child, *devlist;
4533         int error, i, numdevs;
4534
4535         if ((error = device_get_children(dev, &devlist, &numdevs)) != 0)
4536                 return (error);
4537
4538         /*
4539          * Resume critical devices first, then everything else later.
4540          */
4541         for (i = 0; i < numdevs; i++) {
4542                 child = devlist[i];
4543                 switch (pci_get_class(child)) {
4544                 case PCIC_DISPLAY:
4545                 case PCIC_MEMORY:
4546                 case PCIC_BRIDGE:
4547                 case PCIC_BASEPERIPH:
4548                         BUS_RESUME_CHILD(dev, child);
4549                         break;
4550                 }
4551         }
4552         for (i = 0; i < numdevs; i++) {
4553                 child = devlist[i];
4554                 switch (pci_get_class(child)) {
4555                 case PCIC_DISPLAY:
4556                 case PCIC_MEMORY:
4557                 case PCIC_BRIDGE:
4558                 case PCIC_BASEPERIPH:
4559                         break;
4560                 default:
4561                         BUS_RESUME_CHILD(dev, child);
4562                 }
4563         }
4564         free(devlist, M_TEMP);
4565         return (0);
4566 }
4567
4568 static void
4569 pci_load_vendor_data(void)
4570 {
4571         caddr_t data;
4572         void *ptr;
4573         size_t sz;
4574
4575         data = preload_search_by_type("pci_vendor_data");
4576         if (data != NULL) {
4577                 ptr = preload_fetch_addr(data);
4578                 sz = preload_fetch_size(data);
4579                 if (ptr != NULL && sz != 0) {
4580                         pci_vendordata = ptr;
4581                         pci_vendordata_size = sz;
4582                         /* terminate the database */
4583                         pci_vendordata[pci_vendordata_size] = '\n';
4584                 }
4585         }
4586 }
4587
4588 void
4589 pci_driver_added(device_t dev, driver_t *driver)
4590 {
4591         int numdevs;
4592         device_t *devlist;
4593         device_t child;
4594         struct pci_devinfo *dinfo;
4595         int i;
4596
4597         if (bootverbose)
4598                 device_printf(dev, "driver added\n");
4599         DEVICE_IDENTIFY(driver, dev);
4600         if (device_get_children(dev, &devlist, &numdevs) != 0)
4601                 return;
4602         for (i = 0; i < numdevs; i++) {
4603                 child = devlist[i];
4604                 if (device_get_state(child) != DS_NOTPRESENT)
4605                         continue;
4606                 dinfo = device_get_ivars(child);
4607                 pci_print_verbose(dinfo);
4608                 if (bootverbose)
4609                         pci_printf(&dinfo->cfg, "reprobing on driver added\n");
4610                 pci_cfg_restore(child, dinfo);
4611                 if (device_probe_and_attach(child) != 0)
4612                         pci_child_detached(dev, child);
4613         }
4614         free(devlist, M_TEMP);
4615 }
4616
4617 int
4618 pci_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
4619     driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)
4620 {
4621         struct pci_devinfo *dinfo;
4622         struct msix_table_entry *mte;
4623         struct msix_vector *mv;
4624         uint64_t addr;
4625         uint32_t data;
4626         void *cookie;
4627         int error, rid;
4628
4629         error = bus_generic_setup_intr(dev, child, irq, flags, filter, intr,
4630             arg, &cookie);
4631         if (error)
4632                 return (error);
4633
4634         /* If this is not a direct child, just bail out. */
4635         if (device_get_parent(child) != dev) {
4636                 *cookiep = cookie;
4637                 return(0);
4638         }
4639
4640         rid = rman_get_rid(irq);
4641         if (rid == 0) {
4642                 /* Make sure that INTx is enabled */
4643                 pci_clear_command_bit(dev, child, PCIM_CMD_INTxDIS);
4644         } else {
4645                 /*
4646                  * Check to see if the interrupt is MSI or MSI-X.
4647                  * Ask our parent to map the MSI and give
4648                  * us the address and data register values.
4649                  * If we fail for some reason, teardown the
4650                  * interrupt handler.
4651                  */
4652                 dinfo = device_get_ivars(child);
4653                 if (dinfo->cfg.msi.msi_alloc > 0) {
4654                         if (dinfo->cfg.msi.msi_addr == 0) {
4655                                 KASSERT(dinfo->cfg.msi.msi_handlers == 0,
4656                             ("MSI has handlers, but vectors not mapped"));
4657                                 error = PCIB_MAP_MSI(device_get_parent(dev),
4658                                     child, rman_get_start(irq), &addr, &data);
4659                                 if (error)
4660                                         goto bad;
4661                                 dinfo->cfg.msi.msi_addr = addr;
4662                                 dinfo->cfg.msi.msi_data = data;
4663                         }
4664                         if (dinfo->cfg.msi.msi_handlers == 0)
4665                                 pci_enable_msi(child, dinfo->cfg.msi.msi_addr,
4666                                     dinfo->cfg.msi.msi_data);
4667                         dinfo->cfg.msi.msi_handlers++;
4668                 } else {
4669                         KASSERT(dinfo->cfg.msix.msix_alloc > 0,
4670                             ("No MSI or MSI-X interrupts allocated"));
4671                         KASSERT(rid <= dinfo->cfg.msix.msix_table_len,
4672                             ("MSI-X index too high"));
4673                         mte = &dinfo->cfg.msix.msix_table[rid - 1];
4674                         KASSERT(mte->mte_vector != 0, ("no message vector"));
4675                         mv = &dinfo->cfg.msix.msix_vectors[mte->mte_vector - 1];
4676                         KASSERT(mv->mv_irq == rman_get_start(irq),
4677                             ("IRQ mismatch"));
4678                         if (mv->mv_address == 0) {
4679                                 KASSERT(mte->mte_handlers == 0,
4680                     ("MSI-X table entry has handlers, but vector not mapped"));
4681                                 error = PCIB_MAP_MSI(device_get_parent(dev),
4682                                     child, rman_get_start(irq), &addr, &data);
4683                                 if (error)
4684                                         goto bad;
4685                                 mv->mv_address = addr;
4686                                 mv->mv_data = data;
4687                         }
4688
4689                         /*
4690                          * The MSIX table entry must be made valid by
4691                          * incrementing the mte_handlers before
4692                          * calling pci_enable_msix() and
4693                          * pci_resume_msix(). Else the MSIX rewrite
4694                          * table quirk will not work as expected.
4695                          */
4696                         mte->mte_handlers++;
4697                         if (mte->mte_handlers == 1) {
4698                                 pci_enable_msix(child, rid - 1, mv->mv_address,
4699                                     mv->mv_data);
4700                                 pci_unmask_msix(child, rid - 1);
4701                         }
4702                 }
4703
4704                 /*
4705                  * Make sure that INTx is disabled if we are using MSI/MSI-X,
4706                  * unless the device is affected by PCI_QUIRK_MSI_INTX_BUG,
4707                  * in which case we "enable" INTx so MSI/MSI-X actually works.
4708                  */
4709                 if (!pci_has_quirk(pci_get_devid(child),
4710                     PCI_QUIRK_MSI_INTX_BUG))
4711                         pci_set_command_bit(dev, child, PCIM_CMD_INTxDIS);
4712                 else
4713                         pci_clear_command_bit(dev, child, PCIM_CMD_INTxDIS);
4714         bad:
4715                 if (error) {
4716                         (void)bus_generic_teardown_intr(dev, child, irq,
4717                             cookie);
4718                         return (error);
4719                 }
4720         }
4721         *cookiep = cookie;
4722         return (0);
4723 }
4724
4725 int
4726 pci_teardown_intr(device_t dev, device_t child, struct resource *irq,
4727     void *cookie)
4728 {
4729         struct msix_table_entry *mte;
4730         struct resource_list_entry *rle;
4731         struct pci_devinfo *dinfo;
4732         int error, rid;
4733
4734         if (irq == NULL || !(rman_get_flags(irq) & RF_ACTIVE))
4735                 return (EINVAL);
4736
4737         /* If this isn't a direct child, just bail out */
4738         if (device_get_parent(child) != dev)
4739                 return(bus_generic_teardown_intr(dev, child, irq, cookie));
4740
4741         rid = rman_get_rid(irq);
4742         if (rid == 0) {
4743                 /* Mask INTx */
4744                 pci_set_command_bit(dev, child, PCIM_CMD_INTxDIS);
4745         } else {
4746                 /*
4747                  * Check to see if the interrupt is MSI or MSI-X.  If so,
4748                  * decrement the appropriate handlers count and mask the
4749                  * MSI-X message, or disable MSI messages if the count
4750                  * drops to 0.
4751                  */
4752                 dinfo = device_get_ivars(child);
4753                 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, rid);
4754                 if (rle->res != irq)
4755                         return (EINVAL);
4756                 if (dinfo->cfg.msi.msi_alloc > 0) {
4757                         KASSERT(rid <= dinfo->cfg.msi.msi_alloc,
4758                             ("MSI-X index too high"));
4759                         if (dinfo->cfg.msi.msi_handlers == 0)
4760                                 return (EINVAL);
4761                         dinfo->cfg.msi.msi_handlers--;
4762                         if (dinfo->cfg.msi.msi_handlers == 0)
4763                                 pci_disable_msi(child);
4764                 } else {
4765                         KASSERT(dinfo->cfg.msix.msix_alloc > 0,
4766                             ("No MSI or MSI-X interrupts allocated"));
4767                         KASSERT(rid <= dinfo->cfg.msix.msix_table_len,
4768                             ("MSI-X index too high"));
4769                         mte = &dinfo->cfg.msix.msix_table[rid - 1];
4770                         if (mte->mte_handlers == 0)
4771                                 return (EINVAL);
4772                         mte->mte_handlers--;
4773                         if (mte->mte_handlers == 0)
4774                                 pci_mask_msix(child, rid - 1);
4775                 }
4776         }
4777         error = bus_generic_teardown_intr(dev, child, irq, cookie);
4778         if (rid > 0)
4779                 KASSERT(error == 0,
4780                     ("%s: generic teardown failed for MSI/MSI-X", __func__));
4781         return (error);
4782 }
4783
4784 int
4785 pci_print_child(device_t dev, device_t child)
4786 {
4787         struct pci_devinfo *dinfo;
4788         struct resource_list *rl;
4789         int retval = 0;
4790
4791         dinfo = device_get_ivars(child);
4792         rl = &dinfo->resources;
4793
4794         retval += bus_print_child_header(dev, child);
4795
4796         retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#jx");
4797         retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#jx");
4798         retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%jd");
4799         if (device_get_flags(dev))
4800                 retval += printf(" flags %#x", device_get_flags(dev));
4801
4802         retval += printf(" at device %d.%d", pci_get_slot(child),
4803             pci_get_function(child));
4804
4805         retval += bus_print_child_domain(dev, child);
4806         retval += bus_print_child_footer(dev, child);
4807
4808         return (retval);
4809 }
4810
4811 static const struct
4812 {
4813         int             class;
4814         int             subclass;
4815         int             report; /* 0 = bootverbose, 1 = always */
4816         const char      *desc;
4817 } pci_nomatch_tab[] = {
4818         {PCIC_OLD,              -1,                     1, "old"},
4819         {PCIC_OLD,              PCIS_OLD_NONVGA,        1, "non-VGA display device"},
4820         {PCIC_OLD,              PCIS_OLD_VGA,           1, "VGA-compatible display device"},
4821         {PCIC_STORAGE,          -1,                     1, "mass storage"},
4822         {PCIC_STORAGE,          PCIS_STORAGE_SCSI,      1, "SCSI"},
4823         {PCIC_STORAGE,          PCIS_STORAGE_IDE,       1, "ATA"},
4824         {PCIC_STORAGE,          PCIS_STORAGE_FLOPPY,    1, "floppy disk"},
4825         {PCIC_STORAGE,          PCIS_STORAGE_IPI,       1, "IPI"},
4826         {PCIC_STORAGE,          PCIS_STORAGE_RAID,      1, "RAID"},
4827         {PCIC_STORAGE,          PCIS_STORAGE_ATA_ADMA,  1, "ATA (ADMA)"},
4828         {PCIC_STORAGE,          PCIS_STORAGE_SATA,      1, "SATA"},
4829         {PCIC_STORAGE,          PCIS_STORAGE_SAS,       1, "SAS"},
4830         {PCIC_STORAGE,          PCIS_STORAGE_NVM,       1, "NVM"},
4831         {PCIC_NETWORK,          -1,                     1, "network"},
4832         {PCIC_NETWORK,          PCIS_NETWORK_ETHERNET,  1, "ethernet"},
4833         {PCIC_NETWORK,          PCIS_NETWORK_TOKENRING, 1, "token ring"},
4834         {PCIC_NETWORK,          PCIS_NETWORK_FDDI,      1, "fddi"},
4835         {PCIC_NETWORK,          PCIS_NETWORK_ATM,       1, "ATM"},
4836         {PCIC_NETWORK,          PCIS_NETWORK_ISDN,      1, "ISDN"},
4837         {PCIC_DISPLAY,          -1,                     1, "display"},
4838         {PCIC_DISPLAY,          PCIS_DISPLAY_VGA,       1, "VGA"},
4839         {PCIC_DISPLAY,          PCIS_DISPLAY_XGA,       1, "XGA"},
4840         {PCIC_DISPLAY,          PCIS_DISPLAY_3D,        1, "3D"},
4841         {PCIC_MULTIMEDIA,       -1,                     1, "multimedia"},
4842         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_VIDEO,  1, "video"},
4843         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_AUDIO,  1, "audio"},
4844         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_TELE,   1, "telephony"},
4845         {PCIC_MULTIMEDIA,       PCIS_MULTIMEDIA_HDA,    1, "HDA"},
4846         {PCIC_MEMORY,           -1,                     1, "memory"},
4847         {PCIC_MEMORY,           PCIS_MEMORY_RAM,        1, "RAM"},
4848         {PCIC_MEMORY,           PCIS_MEMORY_FLASH,      1, "flash"},
4849         {PCIC_BRIDGE,           -1,                     1, "bridge"},
4850         {PCIC_BRIDGE,           PCIS_BRIDGE_HOST,       1, "HOST-PCI"},
4851         {PCIC_BRIDGE,           PCIS_BRIDGE_ISA,        1, "PCI-ISA"},
4852         {PCIC_BRIDGE,           PCIS_BRIDGE_EISA,       1, "PCI-EISA"},
4853         {PCIC_BRIDGE,           PCIS_BRIDGE_MCA,        1, "PCI-MCA"},
4854         {PCIC_BRIDGE,           PCIS_BRIDGE_PCI,        1, "PCI-PCI"},
4855         {PCIC_BRIDGE,           PCIS_BRIDGE_PCMCIA,     1, "PCI-PCMCIA"},
4856         {PCIC_BRIDGE,           PCIS_BRIDGE_NUBUS,      1, "PCI-NuBus"},
4857         {PCIC_BRIDGE,           PCIS_BRIDGE_CARDBUS,    1, "PCI-CardBus"},
4858         {PCIC_BRIDGE,           PCIS_BRIDGE_RACEWAY,    1, "PCI-RACEway"},
4859         {PCIC_SIMPLECOMM,       -1,                     1, "simple comms"},
4860         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_UART,   1, "UART"},     /* could detect 16550 */
4861         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_PAR,    1, "parallel port"},
4862         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_MULSER, 1, "multiport serial"},
4863         {PCIC_SIMPLECOMM,       PCIS_SIMPLECOMM_MODEM,  1, "generic modem"},
4864         {PCIC_BASEPERIPH,       -1,                     0, "base peripheral"},
4865         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_PIC,    1, "interrupt controller"},
4866         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_DMA,    1, "DMA controller"},
4867         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_TIMER,  1, "timer"},
4868         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_RTC,    1, "realtime clock"},
4869         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_PCIHOT, 1, "PCI hot-plug controller"},
4870         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_SDHC,   1, "SD host controller"},
4871         {PCIC_BASEPERIPH,       PCIS_BASEPERIPH_IOMMU,  1, "IOMMU"},
4872         {PCIC_INPUTDEV,         -1,                     1, "input device"},
4873         {PCIC_INPUTDEV,         PCIS_INPUTDEV_KEYBOARD, 1, "keyboard"},
4874         {PCIC_INPUTDEV,         PCIS_INPUTDEV_DIGITIZER,1, "digitizer"},
4875         {PCIC_INPUTDEV,         PCIS_INPUTDEV_MOUSE,    1, "mouse"},
4876         {PCIC_INPUTDEV,         PCIS_INPUTDEV_SCANNER,  1, "scanner"},
4877         {PCIC_INPUTDEV,         PCIS_INPUTDEV_GAMEPORT, 1, "gameport"},
4878         {PCIC_DOCKING,          -1,                     1, "docking station"},
4879         {PCIC_PROCESSOR,        -1,                     1, "processor"},
4880         {PCIC_SERIALBUS,        -1,                     1, "serial bus"},
4881         {PCIC_SERIALBUS,        PCIS_SERIALBUS_FW,      1, "FireWire"},
4882         {PCIC_SERIALBUS,        PCIS_SERIALBUS_ACCESS,  1, "AccessBus"},
4883         {PCIC_SERIALBUS,        PCIS_SERIALBUS_SSA,     1, "SSA"},
4884         {PCIC_SERIALBUS,        PCIS_SERIALBUS_USB,     1, "USB"},
4885         {PCIC_SERIALBUS,        PCIS_SERIALBUS_FC,      1, "Fibre Channel"},
4886         {PCIC_SERIALBUS,        PCIS_SERIALBUS_SMBUS,   0, "SMBus"},
4887         {PCIC_WIRELESS,         -1,                     1, "wireless controller"},
4888         {PCIC_WIRELESS,         PCIS_WIRELESS_IRDA,     1, "iRDA"},
4889         {PCIC_WIRELESS,         PCIS_WIRELESS_IR,       1, "IR"},
4890         {PCIC_WIRELESS,         PCIS_WIRELESS_RF,       1, "RF"},
4891         {PCIC_INTELLIIO,        -1,                     1, "intelligent I/O controller"},
4892         {PCIC_INTELLIIO,        PCIS_INTELLIIO_I2O,     1, "I2O"},
4893         {PCIC_SATCOM,           -1,                     1, "satellite communication"},
4894         {PCIC_SATCOM,           PCIS_SATCOM_TV,         1, "sat TV"},
4895         {PCIC_SATCOM,           PCIS_SATCOM_AUDIO,      1, "sat audio"},
4896         {PCIC_SATCOM,           PCIS_SATCOM_VOICE,      1, "sat voice"},
4897         {PCIC_SATCOM,           PCIS_SATCOM_DATA,       1, "sat data"},
4898         {PCIC_CRYPTO,           -1,                     1, "encrypt/decrypt"},
4899         {PCIC_CRYPTO,           PCIS_CRYPTO_NETCOMP,    1, "network/computer crypto"},
4900         {PCIC_CRYPTO,           PCIS_CRYPTO_ENTERTAIN,  1, "entertainment crypto"},
4901         {PCIC_DASP,             -1,                     0, "dasp"},
4902         {PCIC_DASP,             PCIS_DASP_DPIO,         1, "DPIO module"},
4903         {PCIC_DASP,             PCIS_DASP_PERFCNTRS,    1, "performance counters"},
4904         {PCIC_DASP,             PCIS_DASP_COMM_SYNC,    1, "communication synchronizer"},
4905         {PCIC_DASP,             PCIS_DASP_MGMT_CARD,    1, "signal processing management"},
4906         {0, 0, 0,               NULL}
4907 };
4908
4909 void
4910 pci_probe_nomatch(device_t dev, device_t child)
4911 {
4912         int i, report;
4913         const char *cp, *scp;
4914         char *device;
4915
4916         /*
4917          * Look for a listing for this device in a loaded device database.
4918          */
4919         report = 1;
4920         if ((device = pci_describe_device(child)) != NULL) {
4921                 device_printf(dev, "<%s>", device);
4922                 free(device, M_DEVBUF);
4923         } else {
4924                 /*
4925                  * Scan the class/subclass descriptions for a general
4926                  * description.
4927                  */
4928                 cp = "unknown";
4929                 scp = NULL;
4930                 for (i = 0; pci_nomatch_tab[i].desc != NULL; i++) {
4931                         if (pci_nomatch_tab[i].class == pci_get_class(child)) {
4932                                 if (pci_nomatch_tab[i].subclass == -1) {
4933                                         cp = pci_nomatch_tab[i].desc;
4934                                         report = pci_nomatch_tab[i].report;
4935                                 } else if (pci_nomatch_tab[i].subclass ==
4936                                     pci_get_subclass(child)) {
4937                                         scp = pci_nomatch_tab[i].desc;
4938                                         report = pci_nomatch_tab[i].report;
4939                                 }
4940                         }
4941                 }
4942                 if (report || bootverbose) {
4943                         device_printf(dev, "<%s%s%s>",
4944                             cp ? cp : "",
4945                             ((cp != NULL) && (scp != NULL)) ? ", " : "",
4946                             scp ? scp : "");
4947                 }
4948         }
4949         if (report || bootverbose) {
4950                 printf(" at device %d.%d (no driver attached)\n",
4951                     pci_get_slot(child), pci_get_function(child));
4952         }
4953         pci_cfg_save(child, device_get_ivars(child), 1);
4954 }
4955
4956 void
4957 pci_child_detached(device_t dev, device_t child)
4958 {
4959         struct pci_devinfo *dinfo;
4960         struct resource_list *rl;
4961
4962         dinfo = device_get_ivars(child);
4963         rl = &dinfo->resources;
4964
4965         /*
4966          * Have to deallocate IRQs before releasing any MSI messages and
4967          * have to release MSI messages before deallocating any memory
4968          * BARs.
4969          */
4970         if (resource_list_release_active(rl, dev, child, SYS_RES_IRQ) != 0)
4971                 pci_printf(&dinfo->cfg, "Device leaked IRQ resources\n");
4972         if (dinfo->cfg.msi.msi_alloc != 0 || dinfo->cfg.msix.msix_alloc != 0) {
4973                 pci_printf(&dinfo->cfg, "Device leaked MSI vectors\n");
4974                 (void)pci_release_msi(child);
4975         }
4976         if (resource_list_release_active(rl, dev, child, SYS_RES_MEMORY) != 0)
4977                 pci_printf(&dinfo->cfg, "Device leaked memory resources\n");
4978         if (resource_list_release_active(rl, dev, child, SYS_RES_IOPORT) != 0)
4979                 pci_printf(&dinfo->cfg, "Device leaked I/O resources\n");
4980 #ifdef PCI_RES_BUS
4981         if (resource_list_release_active(rl, dev, child, PCI_RES_BUS) != 0)
4982                 pci_printf(&dinfo->cfg, "Device leaked PCI bus numbers\n");
4983 #endif
4984
4985         pci_cfg_save(child, dinfo, 1);
4986 }
4987
4988 /*
4989  * Parse the PCI device database, if loaded, and return a pointer to a
4990  * description of the device.
4991  *
4992  * The database is flat text formatted as follows:
4993  *
4994  * Any line not in a valid format is ignored.
4995  * Lines are terminated with newline '\n' characters.
4996  *
4997  * A VENDOR line consists of the 4 digit (hex) vendor code, a TAB, then
4998  * the vendor name.
4999  *
5000  * A DEVICE line is entered immediately below the corresponding VENDOR ID.
5001  * - devices cannot be listed without a corresponding VENDOR line.
5002  * A DEVICE line consists of a TAB, the 4 digit (hex) device code,
5003  * another TAB, then the device name.
5004  */
5005
5006 /*
5007  * Assuming (ptr) points to the beginning of a line in the database,
5008  * return the vendor or device and description of the next entry.
5009  * The value of (vendor) or (device) inappropriate for the entry type
5010  * is set to -1.  Returns nonzero at the end of the database.
5011  *
5012  * Note that this is slightly unrobust in the face of corrupt data;
5013  * we attempt to safeguard against this by spamming the end of the
5014  * database with a newline when we initialise.
5015  */
5016 static int
5017 pci_describe_parse_line(char **ptr, int *vendor, int *device, char **desc)
5018 {
5019         char    *cp = *ptr;
5020         int     left;
5021
5022         *device = -1;
5023         *vendor = -1;
5024         **desc = '\0';
5025         for (;;) {
5026                 left = pci_vendordata_size - (cp - pci_vendordata);
5027                 if (left <= 0) {
5028                         *ptr = cp;
5029                         return(1);
5030                 }
5031
5032                 /* vendor entry? */
5033                 if (*cp != '\t' &&
5034                     sscanf(cp, "%x\t%80[^\n]", vendor, *desc) == 2)
5035                         break;
5036                 /* device entry? */
5037                 if (*cp == '\t' &&
5038                     sscanf(cp, "%x\t%80[^\n]", device, *desc) == 2)
5039                         break;
5040
5041                 /* skip to next line */
5042                 while (*cp != '\n' && left > 0) {
5043                         cp++;
5044                         left--;
5045                 }
5046                 if (*cp == '\n') {
5047                         cp++;
5048                         left--;
5049                 }
5050         }
5051         /* skip to next line */
5052         while (*cp != '\n' && left > 0) {
5053                 cp++;
5054                 left--;
5055         }
5056         if (*cp == '\n' && left > 0)
5057                 cp++;
5058         *ptr = cp;
5059         return(0);
5060 }
5061
5062 static char *
5063 pci_describe_device(device_t dev)
5064 {
5065         int     vendor, device;
5066         char    *desc, *vp, *dp, *line;
5067
5068         desc = vp = dp = NULL;
5069
5070         /*
5071          * If we have no vendor data, we can't do anything.
5072          */
5073         if (pci_vendordata == NULL)
5074                 goto out;
5075
5076         /*
5077          * Scan the vendor data looking for this device
5078          */
5079         line = pci_vendordata;
5080         if ((vp = malloc(80, M_DEVBUF, M_NOWAIT)) == NULL)
5081                 goto out;
5082         for (;;) {
5083                 if (pci_describe_parse_line(&line, &vendor, &device, &vp))
5084                         goto out;
5085                 if (vendor == pci_get_vendor(dev))
5086                         break;
5087         }
5088         if ((dp = malloc(80, M_DEVBUF, M_NOWAIT)) == NULL)
5089                 goto out;
5090         for (;;) {
5091                 if (pci_describe_parse_line(&line, &vendor, &device, &dp)) {
5092                         *dp = 0;
5093                         break;
5094                 }
5095                 if (vendor != -1) {
5096                         *dp = 0;
5097                         break;
5098                 }
5099                 if (device == pci_get_device(dev))
5100                         break;
5101         }
5102         if (dp[0] == '\0')
5103                 snprintf(dp, 80, "0x%x", pci_get_device(dev));
5104         if ((desc = malloc(strlen(vp) + strlen(dp) + 3, M_DEVBUF, M_NOWAIT)) !=
5105             NULL)
5106                 sprintf(desc, "%s, %s", vp, dp);
5107 out:
5108         if (vp != NULL)
5109                 free(vp, M_DEVBUF);
5110         if (dp != NULL)
5111                 free(dp, M_DEVBUF);
5112         return(desc);
5113 }
5114
5115 int
5116 pci_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
5117 {
5118         struct pci_devinfo *dinfo;
5119         pcicfgregs *cfg;
5120
5121         dinfo = device_get_ivars(child);
5122         cfg = &dinfo->cfg;
5123
5124         switch (which) {
5125         case PCI_IVAR_ETHADDR:
5126                 /*
5127                  * The generic accessor doesn't deal with failure, so
5128                  * we set the return value, then return an error.
5129                  */
5130                 *((uint8_t **) result) = NULL;
5131                 return (EINVAL);
5132         case PCI_IVAR_SUBVENDOR:
5133                 *result = cfg->subvendor;
5134                 break;
5135         case PCI_IVAR_SUBDEVICE:
5136                 *result = cfg->subdevice;
5137                 break;
5138         case PCI_IVAR_VENDOR:
5139                 *result = cfg->vendor;
5140                 break;
5141         case PCI_IVAR_DEVICE:
5142                 *result = cfg->device;
5143                 break;
5144         case PCI_IVAR_DEVID:
5145                 *result = (cfg->device << 16) | cfg->vendor;
5146                 break;
5147         case PCI_IVAR_CLASS:
5148                 *result = cfg->baseclass;
5149                 break;
5150         case PCI_IVAR_SUBCLASS:
5151                 *result = cfg->subclass;
5152                 break;
5153         case PCI_IVAR_PROGIF:
5154                 *result = cfg->progif;
5155                 break;
5156         case PCI_IVAR_REVID:
5157                 *result = cfg->revid;
5158                 break;
5159         case PCI_IVAR_INTPIN:
5160                 *result = cfg->intpin;
5161                 break;
5162         case PCI_IVAR_IRQ:
5163                 *result = cfg->intline;
5164                 break;
5165         case PCI_IVAR_DOMAIN:
5166                 *result = cfg->domain;
5167                 break;
5168         case PCI_IVAR_BUS:
5169                 *result = cfg->bus;
5170                 break;
5171         case PCI_IVAR_SLOT:
5172                 *result = cfg->slot;
5173                 break;
5174         case PCI_IVAR_FUNCTION:
5175                 *result = cfg->func;
5176                 break;
5177         case PCI_IVAR_CMDREG:
5178                 *result = cfg->cmdreg;
5179                 break;
5180         case PCI_IVAR_CACHELNSZ:
5181                 *result = cfg->cachelnsz;
5182                 break;
5183         case PCI_IVAR_MINGNT:
5184                 if (cfg->hdrtype != PCIM_HDRTYPE_NORMAL) {
5185                         *result = -1;
5186                         return (EINVAL);
5187                 }
5188                 *result = cfg->mingnt;
5189                 break;
5190         case PCI_IVAR_MAXLAT:
5191                 if (cfg->hdrtype != PCIM_HDRTYPE_NORMAL) {
5192                         *result = -1;
5193                         return (EINVAL);
5194                 }
5195                 *result = cfg->maxlat;
5196                 break;
5197         case PCI_IVAR_LATTIMER:
5198                 *result = cfg->lattimer;
5199                 break;
5200         default:
5201                 return (ENOENT);
5202         }
5203         return (0);
5204 }
5205
5206 int
5207 pci_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
5208 {
5209         struct pci_devinfo *dinfo;
5210
5211         dinfo = device_get_ivars(child);
5212
5213         switch (which) {
5214         case PCI_IVAR_INTPIN:
5215                 dinfo->cfg.intpin = value;
5216                 return (0);
5217         case PCI_IVAR_ETHADDR:
5218         case PCI_IVAR_SUBVENDOR:
5219         case PCI_IVAR_SUBDEVICE:
5220         case PCI_IVAR_VENDOR:
5221         case PCI_IVAR_DEVICE:
5222         case PCI_IVAR_DEVID:
5223         case PCI_IVAR_CLASS:
5224         case PCI_IVAR_SUBCLASS:
5225         case PCI_IVAR_PROGIF:
5226         case PCI_IVAR_REVID:
5227         case PCI_IVAR_IRQ:
5228         case PCI_IVAR_DOMAIN:
5229         case PCI_IVAR_BUS:
5230         case PCI_IVAR_SLOT:
5231         case PCI_IVAR_FUNCTION:
5232                 return (EINVAL);        /* disallow for now */
5233
5234         default:
5235                 return (ENOENT);
5236         }
5237 }
5238
5239 #include "opt_ddb.h"
5240 #ifdef DDB
5241 #include <ddb/ddb.h>
5242 #include <sys/cons.h>
5243
5244 /*
5245  * List resources based on pci map registers, used for within ddb
5246  */
5247
5248 DB_SHOW_COMMAND(pciregs, db_pci_dump)
5249 {
5250         struct pci_devinfo *dinfo;
5251         struct devlist *devlist_head;
5252         struct pci_conf *p;
5253         const char *name;
5254         int i, error, none_count;
5255
5256         none_count = 0;
5257         /* get the head of the device queue */
5258         devlist_head = &pci_devq;
5259
5260         /*
5261          * Go through the list of devices and print out devices
5262          */
5263         for (error = 0, i = 0,
5264              dinfo = STAILQ_FIRST(devlist_head);
5265              (dinfo != NULL) && (error == 0) && (i < pci_numdevs) && !db_pager_quit;
5266              dinfo = STAILQ_NEXT(dinfo, pci_links), i++) {
5267
5268                 /* Populate pd_name and pd_unit */
5269                 name = NULL;
5270                 if (dinfo->cfg.dev)
5271                         name = device_get_name(dinfo->cfg.dev);
5272
5273                 p = &dinfo->conf;
5274                 db_printf("%s%d@pci%d:%d:%d:%d:\tclass=0x%06x card=0x%08x "
5275                         "chip=0x%08x rev=0x%02x hdr=0x%02x\n",
5276                         (name && *name) ? name : "none",
5277                         (name && *name) ? (int)device_get_unit(dinfo->cfg.dev) :
5278                         none_count++,
5279                         p->pc_sel.pc_domain, p->pc_sel.pc_bus, p->pc_sel.pc_dev,
5280                         p->pc_sel.pc_func, (p->pc_class << 16) |
5281                         (p->pc_subclass << 8) | p->pc_progif,
5282                         (p->pc_subdevice << 16) | p->pc_subvendor,
5283                         (p->pc_device << 16) | p->pc_vendor,
5284                         p->pc_revid, p->pc_hdr);
5285         }
5286 }
5287 #endif /* DDB */
5288
5289 static struct resource *
5290 pci_reserve_map(device_t dev, device_t child, int type, int *rid,
5291     rman_res_t start, rman_res_t end, rman_res_t count, u_int num,
5292     u_int flags)
5293 {
5294         struct pci_devinfo *dinfo = device_get_ivars(child);
5295         struct resource_list *rl = &dinfo->resources;
5296         struct resource *res;
5297         struct pci_map *pm;
5298         uint16_t cmd;
5299         pci_addr_t map, testval;
5300         int mapsize;
5301
5302         res = NULL;
5303
5304         /* If rid is managed by EA, ignore it */
5305         if (pci_ea_is_enabled(child, *rid))
5306                 goto out;
5307
5308         pm = pci_find_bar(child, *rid);
5309         if (pm != NULL) {
5310                 /* This is a BAR that we failed to allocate earlier. */
5311                 mapsize = pm->pm_size;
5312                 map = pm->pm_value;
5313         } else {
5314                 /*
5315                  * Weed out the bogons, and figure out how large the
5316                  * BAR/map is.  BARs that read back 0 here are bogus
5317                  * and unimplemented.  Note: atapci in legacy mode are
5318                  * special and handled elsewhere in the code.  If you
5319                  * have a atapci device in legacy mode and it fails
5320                  * here, that other code is broken.
5321                  */
5322                 pci_read_bar(child, *rid, &map, &testval, NULL);
5323
5324                 /*
5325                  * Determine the size of the BAR and ignore BARs with a size
5326                  * of 0.  Device ROM BARs use a different mask value.
5327                  */
5328                 if (PCIR_IS_BIOS(&dinfo->cfg, *rid))
5329                         mapsize = pci_romsize(testval);
5330                 else
5331                         mapsize = pci_mapsize(testval);
5332                 if (mapsize == 0)
5333                         goto out;
5334                 pm = pci_add_bar(child, *rid, map, mapsize);
5335         }
5336
5337         if (PCI_BAR_MEM(map) || PCIR_IS_BIOS(&dinfo->cfg, *rid)) {
5338                 if (type != SYS_RES_MEMORY) {
5339                         if (bootverbose)
5340                                 device_printf(dev,
5341                                     "child %s requested type %d for rid %#x,"
5342                                     " but the BAR says it is an memio\n",
5343                                     device_get_nameunit(child), type, *rid);
5344                         goto out;
5345                 }
5346         } else {
5347                 if (type != SYS_RES_IOPORT) {
5348                         if (bootverbose)
5349                                 device_printf(dev,
5350                                     "child %s requested type %d for rid %#x,"
5351                                     " but the BAR says it is an ioport\n",
5352                                     device_get_nameunit(child), type, *rid);
5353                         goto out;
5354                 }
5355         }
5356
5357         /*
5358          * For real BARs, we need to override the size that
5359          * the driver requests, because that's what the BAR
5360          * actually uses and we would otherwise have a
5361          * situation where we might allocate the excess to
5362          * another driver, which won't work.
5363          */
5364         count = ((pci_addr_t)1 << mapsize) * num;
5365         if (RF_ALIGNMENT(flags) < mapsize)
5366                 flags = (flags & ~RF_ALIGNMENT_MASK) | RF_ALIGNMENT_LOG2(mapsize);
5367         if (PCI_BAR_MEM(map) && (map & PCIM_BAR_MEM_PREFETCH))
5368                 flags |= RF_PREFETCHABLE;
5369
5370         /*
5371          * Allocate enough resource, and then write back the
5372          * appropriate BAR for that resource.
5373          */
5374         resource_list_add(rl, type, *rid, start, end, count);
5375         res = resource_list_reserve(rl, dev, child, type, rid, start, end,
5376             count, flags & ~RF_ACTIVE);
5377         if (res == NULL) {
5378                 resource_list_delete(rl, type, *rid);
5379                 device_printf(child,
5380                     "%#jx bytes of rid %#x res %d failed (%#jx, %#jx).\n",
5381                     count, *rid, type, start, end);
5382                 goto out;
5383         }
5384         if (bootverbose)
5385                 device_printf(child,
5386                     "Lazy allocation of %#jx bytes rid %#x type %d at %#jx\n",
5387                     count, *rid, type, rman_get_start(res));
5388
5389         /* Disable decoding via the CMD register before updating the BAR */
5390         cmd = pci_read_config(child, PCIR_COMMAND, 2);
5391         pci_write_config(child, PCIR_COMMAND,
5392             cmd & ~(PCI_BAR_MEM(map) ? PCIM_CMD_MEMEN : PCIM_CMD_PORTEN), 2);
5393
5394         map = rman_get_start(res);
5395         pci_write_bar(child, pm, map);
5396
5397         /* Restore the original value of the CMD register */
5398         pci_write_config(child, PCIR_COMMAND, cmd, 2);
5399 out:
5400         return (res);
5401 }
5402
5403 struct resource *
5404 pci_alloc_multi_resource(device_t dev, device_t child, int type, int *rid,
5405     rman_res_t start, rman_res_t end, rman_res_t count, u_long num,
5406     u_int flags)
5407 {
5408         struct pci_devinfo *dinfo;
5409         struct resource_list *rl;
5410         struct resource_list_entry *rle;
5411         struct resource *res;
5412         pcicfgregs *cfg;
5413
5414         /*
5415          * Perform lazy resource allocation
5416          */
5417         dinfo = device_get_ivars(child);
5418         rl = &dinfo->resources;
5419         cfg = &dinfo->cfg;
5420         switch (type) {
5421 #if defined(NEW_PCIB) && defined(PCI_RES_BUS)
5422         case PCI_RES_BUS:
5423                 return (pci_alloc_secbus(dev, child, rid, start, end, count,
5424                     flags));
5425 #endif
5426         case SYS_RES_IRQ:
5427                 /*
5428                  * Can't alloc legacy interrupt once MSI messages have
5429                  * been allocated.
5430                  */
5431                 if (*rid == 0 && (cfg->msi.msi_alloc > 0 ||
5432                     cfg->msix.msix_alloc > 0))
5433                         return (NULL);
5434
5435                 /*
5436                  * If the child device doesn't have an interrupt
5437                  * routed and is deserving of an interrupt, try to
5438                  * assign it one.
5439                  */
5440                 if (*rid == 0 && !PCI_INTERRUPT_VALID(cfg->intline) &&
5441                     (cfg->intpin != 0))
5442                         pci_assign_interrupt(dev, child, 0);
5443                 break;
5444         case SYS_RES_IOPORT:
5445         case SYS_RES_MEMORY:
5446 #ifdef NEW_PCIB
5447                 /*
5448                  * PCI-PCI bridge I/O window resources are not BARs.
5449                  * For those allocations just pass the request up the
5450                  * tree.
5451                  */
5452                 if (cfg->hdrtype == PCIM_HDRTYPE_BRIDGE) {
5453                         switch (*rid) {
5454                         case PCIR_IOBASEL_1:
5455                         case PCIR_MEMBASE_1:
5456                         case PCIR_PMBASEL_1:
5457                                 /*
5458                                  * XXX: Should we bother creating a resource
5459                                  * list entry?
5460                                  */
5461                                 return (bus_generic_alloc_resource(dev, child,
5462                                     type, rid, start, end, count, flags));
5463                         }
5464                 }
5465 #endif
5466                 /* Reserve resources for this BAR if needed. */
5467                 rle = resource_list_find(rl, type, *rid);
5468                 if (rle == NULL) {
5469                         res = pci_reserve_map(dev, child, type, rid, start, end,
5470                             count, num, flags);
5471                         if (res == NULL)
5472                                 return (NULL);
5473                 }
5474         }
5475         return (resource_list_alloc(rl, dev, child, type, rid,
5476             start, end, count, flags));
5477 }
5478
5479 struct resource *
5480 pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
5481     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
5482 {
5483 #ifdef PCI_IOV
5484         struct pci_devinfo *dinfo;
5485 #endif
5486
5487         if (device_get_parent(child) != dev)
5488                 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
5489                     type, rid, start, end, count, flags));
5490
5491 #ifdef PCI_IOV
5492         dinfo = device_get_ivars(child);
5493         if (dinfo->cfg.flags & PCICFG_VF) {
5494                 switch (type) {
5495                 /* VFs can't have I/O BARs. */
5496                 case SYS_RES_IOPORT:
5497                         return (NULL);
5498                 case SYS_RES_MEMORY:
5499                         return (pci_vf_alloc_mem_resource(dev, child, rid,
5500                             start, end, count, flags));
5501                 }
5502
5503                 /* Fall through for other types of resource allocations. */
5504         }
5505 #endif
5506
5507         return (pci_alloc_multi_resource(dev, child, type, rid, start, end,
5508             count, 1, flags));
5509 }
5510
5511 int
5512 pci_release_resource(device_t dev, device_t child, int type, int rid,
5513     struct resource *r)
5514 {
5515         struct pci_devinfo *dinfo;
5516         struct resource_list *rl;
5517         pcicfgregs *cfg;
5518
5519         if (device_get_parent(child) != dev)
5520                 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
5521                     type, rid, r));
5522
5523         dinfo = device_get_ivars(child);
5524         cfg = &dinfo->cfg;
5525
5526 #ifdef PCI_IOV
5527         if (dinfo->cfg.flags & PCICFG_VF) {
5528                 switch (type) {
5529                 /* VFs can't have I/O BARs. */
5530                 case SYS_RES_IOPORT:
5531                         return (EDOOFUS);
5532                 case SYS_RES_MEMORY:
5533                         return (pci_vf_release_mem_resource(dev, child, rid,
5534                             r));
5535                 }
5536
5537                 /* Fall through for other types of resource allocations. */
5538         }
5539 #endif
5540
5541 #ifdef NEW_PCIB
5542         /*
5543          * PCI-PCI bridge I/O window resources are not BARs.  For
5544          * those allocations just pass the request up the tree.
5545          */
5546         if (cfg->hdrtype == PCIM_HDRTYPE_BRIDGE &&
5547             (type == SYS_RES_IOPORT || type == SYS_RES_MEMORY)) {
5548                 switch (rid) {
5549                 case PCIR_IOBASEL_1:
5550                 case PCIR_MEMBASE_1:
5551                 case PCIR_PMBASEL_1:
5552                         return (bus_generic_release_resource(dev, child, type,
5553                             rid, r));
5554                 }
5555         }
5556 #endif
5557
5558         rl = &dinfo->resources;
5559         return (resource_list_release(rl, dev, child, type, rid, r));
5560 }
5561
5562 int
5563 pci_activate_resource(device_t dev, device_t child, int type, int rid,
5564     struct resource *r)
5565 {
5566         struct pci_devinfo *dinfo;
5567         int error;
5568
5569         error = bus_generic_activate_resource(dev, child, type, rid, r);
5570         if (error)
5571                 return (error);
5572
5573         /* Enable decoding in the command register when activating BARs. */
5574         if (device_get_parent(child) == dev) {
5575                 /* Device ROMs need their decoding explicitly enabled. */
5576                 dinfo = device_get_ivars(child);
5577                 if (type == SYS_RES_MEMORY && PCIR_IS_BIOS(&dinfo->cfg, rid))
5578                         pci_write_bar(child, pci_find_bar(child, rid),
5579                             rman_get_start(r) | PCIM_BIOS_ENABLE);
5580                 switch (type) {
5581                 case SYS_RES_IOPORT:
5582                 case SYS_RES_MEMORY:
5583                         error = PCI_ENABLE_IO(dev, child, type);
5584                         break;
5585                 }
5586         }
5587         return (error);
5588 }
5589
5590 int
5591 pci_deactivate_resource(device_t dev, device_t child, int type,
5592     int rid, struct resource *r)
5593 {
5594         struct pci_devinfo *dinfo;
5595         int error;
5596
5597         error = bus_generic_deactivate_resource(dev, child, type, rid, r);
5598         if (error)
5599                 return (error);
5600
5601         /* Disable decoding for device ROMs. */
5602         if (device_get_parent(child) == dev) {
5603                 dinfo = device_get_ivars(child);
5604                 if (type == SYS_RES_MEMORY && PCIR_IS_BIOS(&dinfo->cfg, rid))
5605                         pci_write_bar(child, pci_find_bar(child, rid),
5606                             rman_get_start(r));
5607         }
5608         return (0);
5609 }
5610
5611 void
5612 pci_child_deleted(device_t dev, device_t child)
5613 {
5614         struct resource_list_entry *rle;
5615         struct resource_list *rl;
5616         struct pci_devinfo *dinfo;
5617
5618         dinfo = device_get_ivars(child);
5619         rl = &dinfo->resources;
5620
5621         EVENTHANDLER_INVOKE(pci_delete_device, child);
5622
5623         /* Turn off access to resources we're about to free */
5624         if (bus_child_present(child) != 0) {
5625                 pci_write_config(child, PCIR_COMMAND, pci_read_config(child,
5626                     PCIR_COMMAND, 2) & ~(PCIM_CMD_MEMEN | PCIM_CMD_PORTEN), 2);
5627
5628                 pci_disable_busmaster(child);
5629         }
5630
5631         /* Free all allocated resources */
5632         STAILQ_FOREACH(rle, rl, link) {
5633                 if (rle->res) {
5634                         if (rman_get_flags(rle->res) & RF_ACTIVE ||
5635                             resource_list_busy(rl, rle->type, rle->rid)) {
5636                                 pci_printf(&dinfo->cfg,
5637                                     "Resource still owned, oops. "
5638                                     "(type=%d, rid=%d, addr=%lx)\n",
5639                                     rle->type, rle->rid,
5640                                     rman_get_start(rle->res));
5641                                 bus_release_resource(child, rle->type, rle->rid,
5642                                     rle->res);
5643                         }
5644                         resource_list_unreserve(rl, dev, child, rle->type,
5645                             rle->rid);
5646                 }
5647         }
5648         resource_list_free(rl);
5649
5650         pci_freecfg(dinfo);
5651 }
5652
5653 void
5654 pci_delete_resource(device_t dev, device_t child, int type, int rid)
5655 {
5656         struct pci_devinfo *dinfo;
5657         struct resource_list *rl;
5658         struct resource_list_entry *rle;
5659
5660         if (device_get_parent(child) != dev)
5661                 return;
5662
5663         dinfo = device_get_ivars(child);
5664         rl = &dinfo->resources;
5665         rle = resource_list_find(rl, type, rid);
5666         if (rle == NULL)
5667                 return;
5668
5669         if (rle->res) {
5670                 if (rman_get_flags(rle->res) & RF_ACTIVE ||
5671                     resource_list_busy(rl, type, rid)) {
5672                         device_printf(dev, "delete_resource: "
5673                             "Resource still owned by child, oops. "
5674                             "(type=%d, rid=%d, addr=%jx)\n",
5675                             type, rid, rman_get_start(rle->res));
5676                         return;
5677                 }
5678                 resource_list_unreserve(rl, dev, child, type, rid);
5679         }
5680         resource_list_delete(rl, type, rid);
5681 }
5682
5683 struct resource_list *
5684 pci_get_resource_list (device_t dev, device_t child)
5685 {
5686         struct pci_devinfo *dinfo = device_get_ivars(child);
5687
5688         return (&dinfo->resources);
5689 }
5690
5691 bus_dma_tag_t
5692 pci_get_dma_tag(device_t bus, device_t dev)
5693 {
5694         struct pci_softc *sc = device_get_softc(bus);
5695
5696         return (sc->sc_dma_tag);
5697 }
5698
5699 uint32_t
5700 pci_read_config_method(device_t dev, device_t child, int reg, int width)
5701 {
5702         struct pci_devinfo *dinfo = device_get_ivars(child);
5703         pcicfgregs *cfg = &dinfo->cfg;
5704
5705 #ifdef PCI_IOV
5706         /*
5707          * SR-IOV VFs don't implement the VID or DID registers, so we have to
5708          * emulate them here.
5709          */
5710         if (cfg->flags & PCICFG_VF) {
5711                 if (reg == PCIR_VENDOR) {
5712                         switch (width) {
5713                         case 4:
5714                                 return (cfg->device << 16 | cfg->vendor);
5715                         case 2:
5716                                 return (cfg->vendor);
5717                         case 1:
5718                                 return (cfg->vendor & 0xff);
5719                         default:
5720                                 return (0xffffffff);
5721                         }
5722                 } else if (reg == PCIR_DEVICE) {
5723                         switch (width) {
5724                         /* Note that an unaligned 4-byte read is an error. */
5725                         case 2:
5726                                 return (cfg->device);
5727                         case 1:
5728                                 return (cfg->device & 0xff);
5729                         default:
5730                                 return (0xffffffff);
5731                         }
5732                 }
5733         }
5734 #endif
5735
5736         return (PCIB_READ_CONFIG(device_get_parent(dev),
5737             cfg->bus, cfg->slot, cfg->func, reg, width));
5738 }
5739
5740 void
5741 pci_write_config_method(device_t dev, device_t child, int reg,
5742     uint32_t val, int width)
5743 {
5744         struct pci_devinfo *dinfo = device_get_ivars(child);
5745         pcicfgregs *cfg = &dinfo->cfg;
5746
5747         PCIB_WRITE_CONFIG(device_get_parent(dev),
5748             cfg->bus, cfg->slot, cfg->func, reg, val, width);
5749 }
5750
5751 int
5752 pci_child_location_str_method(device_t dev, device_t child, char *buf,
5753     size_t buflen)
5754 {
5755
5756         snprintf(buf, buflen, "slot=%d function=%d dbsf=pci%d:%d:%d:%d",
5757             pci_get_slot(child), pci_get_function(child), pci_get_domain(child),
5758             pci_get_bus(child), pci_get_slot(child), pci_get_function(child));
5759         return (0);
5760 }
5761
5762 int
5763 pci_child_pnpinfo_str_method(device_t dev, device_t child, char *buf,
5764     size_t buflen)
5765 {
5766         struct pci_devinfo *dinfo;
5767         pcicfgregs *cfg;
5768
5769         dinfo = device_get_ivars(child);
5770         cfg = &dinfo->cfg;
5771         snprintf(buf, buflen, "vendor=0x%04x device=0x%04x subvendor=0x%04x "
5772             "subdevice=0x%04x class=0x%02x%02x%02x", cfg->vendor, cfg->device,
5773             cfg->subvendor, cfg->subdevice, cfg->baseclass, cfg->subclass,
5774             cfg->progif);
5775         return (0);
5776 }
5777
5778 int
5779 pci_assign_interrupt_method(device_t dev, device_t child)
5780 {
5781         struct pci_devinfo *dinfo = device_get_ivars(child);
5782         pcicfgregs *cfg = &dinfo->cfg;
5783
5784         return (PCIB_ROUTE_INTERRUPT(device_get_parent(dev), child,
5785             cfg->intpin));
5786 }
5787
5788 static void
5789 pci_lookup(void *arg, const char *name, device_t *dev)
5790 {
5791         long val;
5792         char *end;
5793         int domain, bus, slot, func;
5794
5795         if (*dev != NULL)
5796                 return;
5797
5798         /*
5799          * Accept pciconf-style selectors of either pciD:B:S:F or
5800          * pciB:S:F.  In the latter case, the domain is assumed to
5801          * be zero.
5802          */
5803         if (strncmp(name, "pci", 3) != 0)
5804                 return;
5805         val = strtol(name + 3, &end, 10);
5806         if (val < 0 || val > INT_MAX || *end != ':')
5807                 return;
5808         domain = val;
5809         val = strtol(end + 1, &end, 10);
5810         if (val < 0 || val > INT_MAX || *end != ':')
5811                 return;
5812         bus = val;
5813         val = strtol(end + 1, &end, 10);
5814         if (val < 0 || val > INT_MAX)
5815                 return;
5816         slot = val;
5817         if (*end == ':') {
5818                 val = strtol(end + 1, &end, 10);
5819                 if (val < 0 || val > INT_MAX || *end != '\0')
5820                         return;
5821                 func = val;
5822         } else if (*end == '\0') {
5823                 func = slot;
5824                 slot = bus;
5825                 bus = domain;
5826                 domain = 0;
5827         } else
5828                 return;
5829
5830         if (domain > PCI_DOMAINMAX || bus > PCI_BUSMAX || slot > PCI_SLOTMAX ||
5831             func > PCIE_ARI_FUNCMAX || (slot != 0 && func > PCI_FUNCMAX))
5832                 return;
5833
5834         *dev = pci_find_dbsf(domain, bus, slot, func);
5835 }
5836
5837 static int
5838 pci_modevent(module_t mod, int what, void *arg)
5839 {
5840         static struct cdev *pci_cdev;
5841         static eventhandler_tag tag;
5842
5843         switch (what) {
5844         case MOD_LOAD:
5845                 STAILQ_INIT(&pci_devq);
5846                 pci_generation = 0;
5847                 pci_cdev = make_dev(&pcicdev, 0, UID_ROOT, GID_WHEEL, 0644,
5848                     "pci");
5849                 pci_load_vendor_data();
5850                 tag = EVENTHANDLER_REGISTER(dev_lookup, pci_lookup, NULL,
5851                     1000);
5852                 break;
5853
5854         case MOD_UNLOAD:
5855                 if (tag != NULL)
5856                         EVENTHANDLER_DEREGISTER(dev_lookup, tag);
5857                 destroy_dev(pci_cdev);
5858                 break;
5859         }
5860
5861         return (0);
5862 }
5863
5864 static void
5865 pci_cfg_restore_pcie(device_t dev, struct pci_devinfo *dinfo)
5866 {
5867 #define WREG(n, v)      pci_write_config(dev, pos + (n), (v), 2)
5868         struct pcicfg_pcie *cfg;
5869         int version, pos;
5870
5871         cfg = &dinfo->cfg.pcie;
5872         pos = cfg->pcie_location;
5873
5874         version = cfg->pcie_flags & PCIEM_FLAGS_VERSION;
5875
5876         WREG(PCIER_DEVICE_CTL, cfg->pcie_device_ctl);
5877
5878         if (version > 1 || cfg->pcie_type == PCIEM_TYPE_ROOT_PORT ||
5879             cfg->pcie_type == PCIEM_TYPE_ENDPOINT ||
5880             cfg->pcie_type == PCIEM_TYPE_LEGACY_ENDPOINT)
5881                 WREG(PCIER_LINK_CTL, cfg->pcie_link_ctl);
5882
5883         if (version > 1 || (cfg->pcie_type == PCIEM_TYPE_ROOT_PORT ||
5884             (cfg->pcie_type == PCIEM_TYPE_DOWNSTREAM_PORT &&
5885              (cfg->pcie_flags & PCIEM_FLAGS_SLOT))))
5886                 WREG(PCIER_SLOT_CTL, cfg->pcie_slot_ctl);
5887
5888         if (version > 1 || cfg->pcie_type == PCIEM_TYPE_ROOT_PORT ||
5889             cfg->pcie_type == PCIEM_TYPE_ROOT_EC)
5890                 WREG(PCIER_ROOT_CTL, cfg->pcie_root_ctl);
5891
5892         if (version > 1) {
5893                 WREG(PCIER_DEVICE_CTL2, cfg->pcie_device_ctl2);
5894                 WREG(PCIER_LINK_CTL2, cfg->pcie_link_ctl2);
5895                 WREG(PCIER_SLOT_CTL2, cfg->pcie_slot_ctl2);
5896         }
5897 #undef WREG
5898 }
5899
5900 static void
5901 pci_cfg_restore_pcix(device_t dev, struct pci_devinfo *dinfo)
5902 {
5903         pci_write_config(dev, dinfo->cfg.pcix.pcix_location + PCIXR_COMMAND,
5904             dinfo->cfg.pcix.pcix_command,  2);
5905 }
5906
5907 void
5908 pci_cfg_restore(device_t dev, struct pci_devinfo *dinfo)
5909 {
5910
5911         /*
5912          * Restore the device to full power mode.  We must do this
5913          * before we restore the registers because moving from D3 to
5914          * D0 will cause the chip's BARs and some other registers to
5915          * be reset to some unknown power on reset values.  Cut down
5916          * the noise on boot by doing nothing if we are already in
5917          * state D0.
5918          */
5919         if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0)
5920                 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
5921         pci_write_config(dev, PCIR_INTLINE, dinfo->cfg.intline, 1);
5922         pci_write_config(dev, PCIR_INTPIN, dinfo->cfg.intpin, 1);
5923         pci_write_config(dev, PCIR_CACHELNSZ, dinfo->cfg.cachelnsz, 1);
5924         pci_write_config(dev, PCIR_LATTIMER, dinfo->cfg.lattimer, 1);
5925         pci_write_config(dev, PCIR_PROGIF, dinfo->cfg.progif, 1);
5926         pci_write_config(dev, PCIR_REVID, dinfo->cfg.revid, 1);
5927         switch (dinfo->cfg.hdrtype & PCIM_HDRTYPE) {
5928         case PCIM_HDRTYPE_NORMAL:
5929                 pci_write_config(dev, PCIR_MINGNT, dinfo->cfg.mingnt, 1);
5930                 pci_write_config(dev, PCIR_MAXLAT, dinfo->cfg.maxlat, 1);
5931                 break;
5932         case PCIM_HDRTYPE_BRIDGE:
5933                 pci_write_config(dev, PCIR_SECLAT_1,
5934                     dinfo->cfg.bridge.br_seclat, 1);
5935                 pci_write_config(dev, PCIR_SUBBUS_1,
5936                     dinfo->cfg.bridge.br_subbus, 1);
5937                 pci_write_config(dev, PCIR_SECBUS_1,
5938                     dinfo->cfg.bridge.br_secbus, 1);
5939                 pci_write_config(dev, PCIR_PRIBUS_1,
5940                     dinfo->cfg.bridge.br_pribus, 1);
5941                 pci_write_config(dev, PCIR_BRIDGECTL_1,
5942                     dinfo->cfg.bridge.br_control, 2);
5943                 break;
5944         case PCIM_HDRTYPE_CARDBUS:
5945                 pci_write_config(dev, PCIR_SECLAT_2,
5946                     dinfo->cfg.bridge.br_seclat, 1);
5947                 pci_write_config(dev, PCIR_SUBBUS_2,
5948                     dinfo->cfg.bridge.br_subbus, 1);
5949                 pci_write_config(dev, PCIR_SECBUS_2,
5950                     dinfo->cfg.bridge.br_secbus, 1);
5951                 pci_write_config(dev, PCIR_PRIBUS_2,
5952                     dinfo->cfg.bridge.br_pribus, 1);
5953                 pci_write_config(dev, PCIR_BRIDGECTL_2,
5954                     dinfo->cfg.bridge.br_control, 2);
5955                 break;
5956         }
5957         pci_restore_bars(dev);
5958
5959         if ((dinfo->cfg.hdrtype & PCIM_HDRTYPE) != PCIM_HDRTYPE_BRIDGE)
5960                 pci_write_config(dev, PCIR_COMMAND, dinfo->cfg.cmdreg, 2);
5961
5962         /*
5963          * Restore extended capabilities for PCI-Express and PCI-X
5964          */
5965         if (dinfo->cfg.pcie.pcie_location != 0)
5966                 pci_cfg_restore_pcie(dev, dinfo);
5967         if (dinfo->cfg.pcix.pcix_location != 0)
5968                 pci_cfg_restore_pcix(dev, dinfo);
5969
5970         /* Restore MSI and MSI-X configurations if they are present. */
5971         if (dinfo->cfg.msi.msi_location != 0)
5972                 pci_resume_msi(dev);
5973         if (dinfo->cfg.msix.msix_location != 0)
5974                 pci_resume_msix(dev);
5975
5976 #ifdef PCI_IOV
5977         if (dinfo->cfg.iov != NULL)
5978                 pci_iov_cfg_restore(dev, dinfo);
5979 #endif
5980 }
5981
5982 static void
5983 pci_cfg_save_pcie(device_t dev, struct pci_devinfo *dinfo)
5984 {
5985 #define RREG(n) pci_read_config(dev, pos + (n), 2)
5986         struct pcicfg_pcie *cfg;
5987         int version, pos;
5988
5989         cfg = &dinfo->cfg.pcie;
5990         pos = cfg->pcie_location;
5991
5992         cfg->pcie_flags = RREG(PCIER_FLAGS);
5993
5994         version = cfg->pcie_flags & PCIEM_FLAGS_VERSION;
5995
5996         cfg->pcie_device_ctl = RREG(PCIER_DEVICE_CTL);
5997
5998         if (version > 1 || cfg->pcie_type == PCIEM_TYPE_ROOT_PORT ||
5999             cfg->pcie_type == PCIEM_TYPE_ENDPOINT ||
6000             cfg->pcie_type == PCIEM_TYPE_LEGACY_ENDPOINT)
6001                 cfg->pcie_link_ctl = RREG(PCIER_LINK_CTL);
6002
6003         if (version > 1 || (cfg->pcie_type == PCIEM_TYPE_ROOT_PORT ||
6004             (cfg->pcie_type == PCIEM_TYPE_DOWNSTREAM_PORT &&
6005              (cfg->pcie_flags & PCIEM_FLAGS_SLOT))))
6006                 cfg->pcie_slot_ctl = RREG(PCIER_SLOT_CTL);
6007
6008         if (version > 1 || cfg->pcie_type == PCIEM_TYPE_ROOT_PORT ||
6009             cfg->pcie_type == PCIEM_TYPE_ROOT_EC)
6010                 cfg->pcie_root_ctl = RREG(PCIER_ROOT_CTL);
6011
6012         if (version > 1) {
6013                 cfg->pcie_device_ctl2 = RREG(PCIER_DEVICE_CTL2);
6014                 cfg->pcie_link_ctl2 = RREG(PCIER_LINK_CTL2);
6015                 cfg->pcie_slot_ctl2 = RREG(PCIER_SLOT_CTL2);
6016         }
6017 #undef RREG
6018 }
6019
6020 static void
6021 pci_cfg_save_pcix(device_t dev, struct pci_devinfo *dinfo)
6022 {
6023         dinfo->cfg.pcix.pcix_command = pci_read_config(dev,
6024             dinfo->cfg.pcix.pcix_location + PCIXR_COMMAND, 2);
6025 }
6026
6027 void
6028 pci_cfg_save(device_t dev, struct pci_devinfo *dinfo, int setstate)
6029 {
6030         uint32_t cls;
6031         int ps;
6032
6033         /*
6034          * Some drivers apparently write to these registers w/o updating our
6035          * cached copy.  No harm happens if we update the copy, so do so here
6036          * so we can restore them.  The COMMAND register is modified by the
6037          * bus w/o updating the cache.  This should represent the normally
6038          * writable portion of the 'defined' part of type 0/1/2 headers.
6039          */
6040         dinfo->cfg.vendor = pci_read_config(dev, PCIR_VENDOR, 2);
6041         dinfo->cfg.device = pci_read_config(dev, PCIR_DEVICE, 2);
6042         dinfo->cfg.cmdreg = pci_read_config(dev, PCIR_COMMAND, 2);
6043         dinfo->cfg.intline = pci_read_config(dev, PCIR_INTLINE, 1);
6044         dinfo->cfg.intpin = pci_read_config(dev, PCIR_INTPIN, 1);
6045         dinfo->cfg.cachelnsz = pci_read_config(dev, PCIR_CACHELNSZ, 1);
6046         dinfo->cfg.lattimer = pci_read_config(dev, PCIR_LATTIMER, 1);
6047         dinfo->cfg.baseclass = pci_read_config(dev, PCIR_CLASS, 1);
6048         dinfo->cfg.subclass = pci_read_config(dev, PCIR_SUBCLASS, 1);
6049         dinfo->cfg.progif = pci_read_config(dev, PCIR_PROGIF, 1);
6050         dinfo->cfg.revid = pci_read_config(dev, PCIR_REVID, 1);
6051         switch (dinfo->cfg.hdrtype & PCIM_HDRTYPE) {
6052         case PCIM_HDRTYPE_NORMAL:
6053                 dinfo->cfg.subvendor = pci_read_config(dev, PCIR_SUBVEND_0, 2);
6054                 dinfo->cfg.subdevice = pci_read_config(dev, PCIR_SUBDEV_0, 2);
6055                 dinfo->cfg.mingnt = pci_read_config(dev, PCIR_MINGNT, 1);
6056                 dinfo->cfg.maxlat = pci_read_config(dev, PCIR_MAXLAT, 1);
6057                 break;
6058         case PCIM_HDRTYPE_BRIDGE:
6059                 dinfo->cfg.bridge.br_seclat = pci_read_config(dev,
6060                     PCIR_SECLAT_1, 1);
6061                 dinfo->cfg.bridge.br_subbus = pci_read_config(dev,
6062                     PCIR_SUBBUS_1, 1);
6063                 dinfo->cfg.bridge.br_secbus = pci_read_config(dev,
6064                     PCIR_SECBUS_1, 1);
6065                 dinfo->cfg.bridge.br_pribus = pci_read_config(dev,
6066                     PCIR_PRIBUS_1, 1);
6067                 dinfo->cfg.bridge.br_control = pci_read_config(dev,
6068                     PCIR_BRIDGECTL_1, 2);
6069                 break;
6070         case PCIM_HDRTYPE_CARDBUS:
6071                 dinfo->cfg.bridge.br_seclat = pci_read_config(dev,
6072                     PCIR_SECLAT_2, 1);
6073                 dinfo->cfg.bridge.br_subbus = pci_read_config(dev,
6074                     PCIR_SUBBUS_2, 1);
6075                 dinfo->cfg.bridge.br_secbus = pci_read_config(dev,
6076                     PCIR_SECBUS_2, 1);
6077                 dinfo->cfg.bridge.br_pribus = pci_read_config(dev,
6078                     PCIR_PRIBUS_2, 1);
6079                 dinfo->cfg.bridge.br_control = pci_read_config(dev,
6080                     PCIR_BRIDGECTL_2, 2);
6081                 dinfo->cfg.subvendor = pci_read_config(dev, PCIR_SUBVEND_2, 2);
6082                 dinfo->cfg.subdevice = pci_read_config(dev, PCIR_SUBDEV_2, 2);
6083                 break;
6084         }
6085
6086         if (dinfo->cfg.pcie.pcie_location != 0)
6087                 pci_cfg_save_pcie(dev, dinfo);
6088
6089         if (dinfo->cfg.pcix.pcix_location != 0)
6090                 pci_cfg_save_pcix(dev, dinfo);
6091
6092 #ifdef PCI_IOV
6093         if (dinfo->cfg.iov != NULL)
6094                 pci_iov_cfg_save(dev, dinfo);
6095 #endif
6096
6097         /*
6098          * don't set the state for display devices, base peripherals and
6099          * memory devices since bad things happen when they are powered down.
6100          * We should (a) have drivers that can easily detach and (b) use
6101          * generic drivers for these devices so that some device actually
6102          * attaches.  We need to make sure that when we implement (a) we don't
6103          * power the device down on a reattach.
6104          */
6105         cls = pci_get_class(dev);
6106         if (!setstate)
6107                 return;
6108         switch (pci_do_power_nodriver)
6109         {
6110                 case 0:         /* NO powerdown at all */
6111                         return;
6112                 case 1:         /* Conservative about what to power down */
6113                         if (cls == PCIC_STORAGE)
6114                                 return;
6115                         /*FALLTHROUGH*/
6116                 case 2:         /* Aggressive about what to power down */
6117                         if (cls == PCIC_DISPLAY || cls == PCIC_MEMORY ||
6118                             cls == PCIC_BASEPERIPH)
6119                                 return;
6120                         /*FALLTHROUGH*/
6121                 case 3:         /* Power down everything */
6122                         break;
6123         }
6124         /*
6125          * PCI spec says we can only go into D3 state from D0 state.
6126          * Transition from D[12] into D0 before going to D3 state.
6127          */
6128         ps = pci_get_powerstate(dev);
6129         if (ps != PCI_POWERSTATE_D0 && ps != PCI_POWERSTATE_D3)
6130                 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
6131         if (pci_get_powerstate(dev) != PCI_POWERSTATE_D3)
6132                 pci_set_powerstate(dev, PCI_POWERSTATE_D3);
6133 }
6134
6135 /* Wrapper APIs suitable for device driver use. */
6136 void
6137 pci_save_state(device_t dev)
6138 {
6139         struct pci_devinfo *dinfo;
6140
6141         dinfo = device_get_ivars(dev);
6142         pci_cfg_save(dev, dinfo, 0);
6143 }
6144
6145 void
6146 pci_restore_state(device_t dev)
6147 {
6148         struct pci_devinfo *dinfo;
6149
6150         dinfo = device_get_ivars(dev);
6151         pci_cfg_restore(dev, dinfo);
6152 }
6153
6154 static int
6155 pci_get_id_method(device_t dev, device_t child, enum pci_id_type type,
6156     uintptr_t *id)
6157 {
6158
6159         return (PCIB_GET_ID(device_get_parent(dev), child, type, id));
6160 }
6161
6162 /* Find the upstream port of a given PCI device in a root complex. */
6163 device_t
6164 pci_find_pcie_root_port(device_t dev)
6165 {
6166         struct pci_devinfo *dinfo;
6167         devclass_t pci_class;
6168         device_t pcib, bus;
6169
6170         pci_class = devclass_find("pci");
6171         KASSERT(device_get_devclass(device_get_parent(dev)) == pci_class,
6172             ("%s: non-pci device %s", __func__, device_get_nameunit(dev)));
6173
6174         /*
6175          * Walk the bridge hierarchy until we find a PCI-e root
6176          * port or a non-PCI device.
6177          */
6178         for (;;) {
6179                 bus = device_get_parent(dev);
6180                 KASSERT(bus != NULL, ("%s: null parent of %s", __func__,
6181                     device_get_nameunit(dev)));
6182
6183                 pcib = device_get_parent(bus);
6184                 KASSERT(pcib != NULL, ("%s: null bridge of %s", __func__,
6185                     device_get_nameunit(bus)));
6186
6187                 /*
6188                  * pcib's parent must be a PCI bus for this to be a
6189                  * PCI-PCI bridge.
6190                  */
6191                 if (device_get_devclass(device_get_parent(pcib)) != pci_class)
6192                         return (NULL);
6193
6194                 dinfo = device_get_ivars(pcib);
6195                 if (dinfo->cfg.pcie.pcie_location != 0 &&
6196                     dinfo->cfg.pcie.pcie_type == PCIEM_TYPE_ROOT_PORT)
6197                         return (pcib);
6198
6199                 dev = pcib;
6200         }
6201 }
6202
6203 /*
6204  * Wait for pending transactions to complete on a PCI-express function.
6205  *
6206  * The maximum delay is specified in milliseconds in max_delay.  Note
6207  * that this function may sleep.
6208  *
6209  * Returns true if the function is idle and false if the timeout is
6210  * exceeded.  If dev is not a PCI-express function, this returns true.
6211  */
6212 bool
6213 pcie_wait_for_pending_transactions(device_t dev, u_int max_delay)
6214 {
6215         struct pci_devinfo *dinfo = device_get_ivars(dev);
6216         uint16_t sta;
6217         int cap;
6218
6219         cap = dinfo->cfg.pcie.pcie_location;
6220         if (cap == 0)
6221                 return (true);
6222
6223         sta = pci_read_config(dev, cap + PCIER_DEVICE_STA, 2);
6224         while (sta & PCIEM_STA_TRANSACTION_PND) {
6225                 if (max_delay == 0)
6226                         return (false);
6227
6228                 /* Poll once every 100 milliseconds up to the timeout. */
6229                 if (max_delay > 100) {
6230                         pause_sbt("pcietp", 100 * SBT_1MS, 0, C_HARDCLOCK);
6231                         max_delay -= 100;
6232                 } else {
6233                         pause_sbt("pcietp", max_delay * SBT_1MS, 0,
6234                             C_HARDCLOCK);
6235                         max_delay = 0;
6236                 }
6237                 sta = pci_read_config(dev, cap + PCIER_DEVICE_STA, 2);
6238         }
6239
6240         return (true);
6241 }
6242
6243 /*
6244  * Determine the maximum Completion Timeout in microseconds.
6245  *
6246  * For non-PCI-express functions this returns 0.
6247  */
6248 int
6249 pcie_get_max_completion_timeout(device_t dev)
6250 {
6251         struct pci_devinfo *dinfo = device_get_ivars(dev);
6252         int cap;
6253
6254         cap = dinfo->cfg.pcie.pcie_location;
6255         if (cap == 0)
6256                 return (0);
6257
6258         /*
6259          * Functions using the 1.x spec use the default timeout range of
6260          * 50 microseconds to 50 milliseconds.  Functions that do not
6261          * support programmable timeouts also use this range.
6262          */
6263         if ((dinfo->cfg.pcie.pcie_flags & PCIEM_FLAGS_VERSION) < 2 ||
6264             (pci_read_config(dev, cap + PCIER_DEVICE_CAP2, 4) &
6265             PCIEM_CAP2_COMP_TIMO_RANGES) == 0)
6266                 return (50 * 1000);
6267
6268         switch (pci_read_config(dev, cap + PCIER_DEVICE_CTL2, 2) &
6269             PCIEM_CTL2_COMP_TIMO_VAL) {
6270         case PCIEM_CTL2_COMP_TIMO_100US:
6271                 return (100);
6272         case PCIEM_CTL2_COMP_TIMO_10MS:
6273                 return (10 * 1000);
6274         case PCIEM_CTL2_COMP_TIMO_55MS:
6275                 return (55 * 1000);
6276         case PCIEM_CTL2_COMP_TIMO_210MS:
6277                 return (210 * 1000);
6278         case PCIEM_CTL2_COMP_TIMO_900MS:
6279                 return (900 * 1000);
6280         case PCIEM_CTL2_COMP_TIMO_3500MS:
6281                 return (3500 * 1000);
6282         case PCIEM_CTL2_COMP_TIMO_13S:
6283                 return (13 * 1000 * 1000);
6284         case PCIEM_CTL2_COMP_TIMO_64S:
6285                 return (64 * 1000 * 1000);
6286         default:
6287                 return (50 * 1000);
6288         }
6289 }
6290
6291 void
6292 pcie_apei_error(device_t dev, int sev, uint8_t *aerp)
6293 {
6294         struct pci_devinfo *dinfo = device_get_ivars(dev);
6295         const char *s;
6296         int aer;
6297         uint32_t r, r1;
6298         uint16_t rs;
6299
6300         if (sev == PCIEM_STA_CORRECTABLE_ERROR)
6301                 s = "Correctable";
6302         else if (sev == PCIEM_STA_NON_FATAL_ERROR)
6303                 s = "Uncorrectable (Non-Fatal)";
6304         else
6305                 s = "Uncorrectable (Fatal)";
6306         device_printf(dev, "%s PCIe error reported by APEI\n", s);
6307         if (aerp) {
6308                 if (sev == PCIEM_STA_CORRECTABLE_ERROR) {
6309                         r = le32dec(aerp + PCIR_AER_COR_STATUS);
6310                         r1 = le32dec(aerp + PCIR_AER_COR_MASK);
6311                 } else {
6312                         r = le32dec(aerp + PCIR_AER_UC_STATUS);
6313                         r1 = le32dec(aerp + PCIR_AER_UC_MASK);
6314                 }
6315                 device_printf(dev, "status 0x%08x mask 0x%08x", r, r1);
6316                 if (sev != PCIEM_STA_CORRECTABLE_ERROR) {
6317                         r = le32dec(aerp + PCIR_AER_UC_SEVERITY);
6318                         rs = le16dec(aerp + PCIR_AER_CAP_CONTROL);
6319                         printf(" severity 0x%08x first %d\n",
6320                             r, rs & 0x1f);
6321                 } else
6322                         printf("\n");
6323         }
6324
6325         /* As kind of recovery just report and clear the error statuses. */
6326         if (pci_find_extcap(dev, PCIZ_AER, &aer) == 0) {
6327                 r = pci_read_config(dev, aer + PCIR_AER_UC_STATUS, 4);
6328                 if (r != 0) {
6329                         pci_write_config(dev, aer + PCIR_AER_UC_STATUS, r, 4);
6330                         device_printf(dev, "Clearing UC AER errors 0x%08x\n", r);
6331                 }
6332
6333                 r = pci_read_config(dev, aer + PCIR_AER_COR_STATUS, 4);
6334                 if (r != 0) {
6335                         pci_write_config(dev, aer + PCIR_AER_COR_STATUS, r, 4);
6336                         device_printf(dev, "Clearing COR AER errors 0x%08x\n", r);
6337                 }
6338         }
6339         if (dinfo->cfg.pcie.pcie_location != 0) {
6340                 rs = pci_read_config(dev, dinfo->cfg.pcie.pcie_location +
6341                     PCIER_DEVICE_STA, 2);
6342                 if ((rs & (PCIEM_STA_CORRECTABLE_ERROR |
6343                     PCIEM_STA_NON_FATAL_ERROR | PCIEM_STA_FATAL_ERROR |
6344                     PCIEM_STA_UNSUPPORTED_REQ)) != 0) {
6345                         pci_write_config(dev, dinfo->cfg.pcie.pcie_location +
6346                             PCIER_DEVICE_STA, rs, 2);
6347                         device_printf(dev, "Clearing PCIe errors 0x%04x\n", rs);
6348                 }
6349         }
6350 }
6351
6352 /*
6353  * Perform a Function Level Reset (FLR) on a device.
6354  *
6355  * This function first waits for any pending transactions to complete
6356  * within the timeout specified by max_delay.  If transactions are
6357  * still pending, the function will return false without attempting a
6358  * reset.
6359  *
6360  * If dev is not a PCI-express function or does not support FLR, this
6361  * function returns false.
6362  *
6363  * Note that no registers are saved or restored.  The caller is
6364  * responsible for saving and restoring any registers including
6365  * PCI-standard registers via pci_save_state() and
6366  * pci_restore_state().
6367  */
6368 bool
6369 pcie_flr(device_t dev, u_int max_delay, bool force)
6370 {
6371         struct pci_devinfo *dinfo = device_get_ivars(dev);
6372         uint16_t cmd, ctl;
6373         int compl_delay;
6374         int cap;
6375
6376         cap = dinfo->cfg.pcie.pcie_location;
6377         if (cap == 0)
6378                 return (false);
6379
6380         if (!(pci_read_config(dev, cap + PCIER_DEVICE_CAP, 4) & PCIEM_CAP_FLR))
6381                 return (false);
6382
6383         /*
6384          * Disable busmastering to prevent generation of new
6385          * transactions while waiting for the device to go idle.  If
6386          * the idle timeout fails, the command register is restored
6387          * which will re-enable busmastering.
6388          */
6389         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
6390         pci_write_config(dev, PCIR_COMMAND, cmd & ~(PCIM_CMD_BUSMASTEREN), 2);
6391         if (!pcie_wait_for_pending_transactions(dev, max_delay)) {
6392                 if (!force) {
6393                         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
6394                         return (false);
6395                 }
6396                 pci_printf(&dinfo->cfg,
6397                     "Resetting with transactions pending after %d ms\n",
6398                     max_delay);
6399
6400                 /*
6401                  * Extend the post-FLR delay to cover the maximum
6402                  * Completion Timeout delay of anything in flight
6403                  * during the FLR delay.  Enforce a minimum delay of
6404                  * at least 10ms.
6405                  */
6406                 compl_delay = pcie_get_max_completion_timeout(dev) / 1000;
6407                 if (compl_delay < 10)
6408                         compl_delay = 10;
6409         } else
6410                 compl_delay = 0;
6411
6412         /* Initiate the reset. */
6413         ctl = pci_read_config(dev, cap + PCIER_DEVICE_CTL, 2);
6414         pci_write_config(dev, cap + PCIER_DEVICE_CTL, ctl |
6415             PCIEM_CTL_INITIATE_FLR, 2);
6416
6417         /* Wait for 100ms. */
6418         pause_sbt("pcieflr", (100 + compl_delay) * SBT_1MS, 0, C_HARDCLOCK);
6419
6420         if (pci_read_config(dev, cap + PCIER_DEVICE_STA, 2) &
6421             PCIEM_STA_TRANSACTION_PND)
6422                 pci_printf(&dinfo->cfg, "Transactions pending after FLR!\n");
6423         return (true);
6424 }
6425
6426 /*
6427  * Attempt a power-management reset by cycling the device in/out of D3
6428  * state.  PCI spec says we can only go into D3 state from D0 state.
6429  * Transition from D[12] into D0 before going to D3 state.
6430  */
6431 int
6432 pci_power_reset(device_t dev)
6433 {
6434         int ps;
6435
6436         ps = pci_get_powerstate(dev);
6437         if (ps != PCI_POWERSTATE_D0 && ps != PCI_POWERSTATE_D3)
6438                 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
6439         pci_set_powerstate(dev, PCI_POWERSTATE_D3);
6440         pci_set_powerstate(dev, ps);
6441         return (0);
6442 }
6443
6444 /*
6445  * Try link drop and retrain of the downstream port of upstream
6446  * switch, for PCIe.  According to the PCIe 3.0 spec 6.6.1, this must
6447  * cause Conventional Hot reset of the device in the slot.
6448  * Alternative, for PCIe, could be the secondary bus reset initiatied
6449  * on the upstream switch PCIR_BRIDGECTL_1, bit 6.
6450  */
6451 int
6452 pcie_link_reset(device_t port, int pcie_location)
6453 {
6454         uint16_t v;
6455
6456         v = pci_read_config(port, pcie_location + PCIER_LINK_CTL, 2);
6457         v |= PCIEM_LINK_CTL_LINK_DIS;
6458         pci_write_config(port, pcie_location + PCIER_LINK_CTL, v, 2);
6459         pause_sbt("pcier1", mstosbt(20), 0, 0);
6460         v &= ~PCIEM_LINK_CTL_LINK_DIS;
6461         v |= PCIEM_LINK_CTL_RETRAIN_LINK;
6462         pci_write_config(port, pcie_location + PCIER_LINK_CTL, v, 2);
6463         pause_sbt("pcier2", mstosbt(100), 0, 0); /* 100 ms */
6464         v = pci_read_config(port, pcie_location + PCIER_LINK_STA, 2);
6465         return ((v & PCIEM_LINK_STA_TRAINING) != 0 ? ETIMEDOUT : 0);
6466 }
6467
6468 static int
6469 pci_reset_post(device_t dev, device_t child)
6470 {
6471
6472         if (dev == device_get_parent(child))
6473                 pci_restore_state(child);
6474         return (0);
6475 }
6476
6477 static int
6478 pci_reset_prepare(device_t dev, device_t child)
6479 {
6480
6481         if (dev == device_get_parent(child))
6482                 pci_save_state(child);
6483         return (0);
6484 }
6485
6486 static int
6487 pci_reset_child(device_t dev, device_t child, int flags)
6488 {
6489         int error;
6490
6491         if (dev == NULL || device_get_parent(child) != dev)
6492                 return (0);
6493         if ((flags & DEVF_RESET_DETACH) != 0) {
6494                 error = device_get_state(child) == DS_ATTACHED ?
6495                     device_detach(child) : 0;
6496         } else {
6497                 error = BUS_SUSPEND_CHILD(dev, child);
6498         }
6499         if (error == 0) {
6500                 if (!pcie_flr(child, 1000, false)) {
6501                         error = BUS_RESET_PREPARE(dev, child);
6502                         if (error == 0)
6503                                 pci_power_reset(child);
6504                         BUS_RESET_POST(dev, child);
6505                 }
6506                 if ((flags & DEVF_RESET_DETACH) != 0)
6507                         device_probe_and_attach(child);
6508                 else
6509                         BUS_RESUME_CHILD(dev, child);
6510         }
6511         return (error);
6512 }
6513
6514 const struct pci_device_table *
6515 pci_match_device(device_t child, const struct pci_device_table *id, size_t nelt)
6516 {
6517         bool match;
6518         uint16_t vendor, device, subvendor, subdevice, class, subclass, revid;
6519
6520         vendor = pci_get_vendor(child);
6521         device = pci_get_device(child);
6522         subvendor = pci_get_subvendor(child);
6523         subdevice = pci_get_subdevice(child);
6524         class = pci_get_class(child);
6525         subclass = pci_get_subclass(child);
6526         revid = pci_get_revid(child);
6527         while (nelt-- > 0) {
6528                 match = true;
6529                 if (id->match_flag_vendor)
6530                         match &= vendor == id->vendor;
6531                 if (id->match_flag_device)
6532                         match &= device == id->device;
6533                 if (id->match_flag_subvendor)
6534                         match &= subvendor == id->subvendor;
6535                 if (id->match_flag_subdevice)
6536                         match &= subdevice == id->subdevice;
6537                 if (id->match_flag_class)
6538                         match &= class == id->class_id;
6539                 if (id->match_flag_subclass)
6540                         match &= subclass == id->subclass;
6541                 if (id->match_flag_revid)
6542                         match &= revid == id->revid;
6543                 if (match)
6544                         return (id);
6545                 id++;
6546         }
6547         return (NULL);
6548 }
6549
6550 static void
6551 pci_print_faulted_dev_name(const struct pci_devinfo *dinfo)
6552 {
6553         const char *dev_name;
6554         device_t dev;
6555
6556         dev = dinfo->cfg.dev;
6557         printf("pci%d:%d:%d:%d", dinfo->cfg.domain, dinfo->cfg.bus,
6558             dinfo->cfg.slot, dinfo->cfg.func);
6559         dev_name = device_get_name(dev);
6560         if (dev_name != NULL)
6561                 printf(" (%s%d)", dev_name, device_get_unit(dev));
6562 }
6563
6564 void
6565 pci_print_faulted_dev(void)
6566 {
6567         struct pci_devinfo *dinfo;
6568         device_t dev;
6569         int aer, i;
6570         uint32_t r1, r2;
6571         uint16_t status;
6572
6573         STAILQ_FOREACH(dinfo, &pci_devq, pci_links) {
6574                 dev = dinfo->cfg.dev;
6575                 status = pci_read_config(dev, PCIR_STATUS, 2);
6576                 status &= PCIM_STATUS_MDPERR | PCIM_STATUS_STABORT |
6577                     PCIM_STATUS_RTABORT | PCIM_STATUS_RMABORT |
6578                     PCIM_STATUS_SERR | PCIM_STATUS_PERR;
6579                 if (status != 0) {
6580                         pci_print_faulted_dev_name(dinfo);
6581                         printf(" error 0x%04x\n", status);
6582                 }
6583                 if (dinfo->cfg.pcie.pcie_location != 0) {
6584                         status = pci_read_config(dev,
6585                             dinfo->cfg.pcie.pcie_location +
6586                             PCIER_DEVICE_STA, 2);
6587                         if ((status & (PCIEM_STA_CORRECTABLE_ERROR |
6588                             PCIEM_STA_NON_FATAL_ERROR | PCIEM_STA_FATAL_ERROR |
6589                             PCIEM_STA_UNSUPPORTED_REQ)) != 0) {
6590                                 pci_print_faulted_dev_name(dinfo);
6591                                 printf(" PCIe DEVCTL 0x%04x DEVSTA 0x%04x\n",
6592                                     pci_read_config(dev,
6593                                     dinfo->cfg.pcie.pcie_location +
6594                                     PCIER_DEVICE_CTL, 2),
6595                                     status);
6596                         }
6597                 }
6598                 if (pci_find_extcap(dev, PCIZ_AER, &aer) == 0) {
6599                         r1 = pci_read_config(dev, aer + PCIR_AER_UC_STATUS, 4);
6600                         r2 = pci_read_config(dev, aer + PCIR_AER_COR_STATUS, 4);
6601                         if (r1 != 0 || r2 != 0) {
6602                                 pci_print_faulted_dev_name(dinfo);
6603                                 printf(" AER UC 0x%08x Mask 0x%08x Svr 0x%08x\n"
6604                                     "  COR 0x%08x Mask 0x%08x Ctl 0x%08x\n",
6605                                     r1, pci_read_config(dev, aer +
6606                                     PCIR_AER_UC_MASK, 4),
6607                                     pci_read_config(dev, aer +
6608                                     PCIR_AER_UC_SEVERITY, 4),
6609                                     r2, pci_read_config(dev, aer +
6610                                     PCIR_AER_COR_MASK, 4),
6611                                     pci_read_config(dev, aer +
6612                                     PCIR_AER_CAP_CONTROL, 4));
6613                                 for (i = 0; i < 4; i++) {
6614                                         r1 = pci_read_config(dev, aer +
6615                                             PCIR_AER_HEADER_LOG + i * 4, 4);
6616                                         printf("    HL%d: 0x%08x\n", i, r1);
6617                                 }
6618                         }
6619                 }
6620         }
6621 }
6622
6623 #ifdef DDB
6624 DB_SHOW_COMMAND(pcierr, pci_print_faulted_dev_db)
6625 {
6626
6627         pci_print_faulted_dev();
6628 }
6629
6630 static void
6631 db_clear_pcie_errors(const struct pci_devinfo *dinfo)
6632 {
6633         device_t dev;
6634         int aer;
6635         uint32_t r;
6636
6637         dev = dinfo->cfg.dev;
6638         r = pci_read_config(dev, dinfo->cfg.pcie.pcie_location +
6639             PCIER_DEVICE_STA, 2);
6640         pci_write_config(dev, dinfo->cfg.pcie.pcie_location +
6641             PCIER_DEVICE_STA, r, 2);
6642
6643         if (pci_find_extcap(dev, PCIZ_AER, &aer) != 0)
6644                 return;
6645         r = pci_read_config(dev, aer + PCIR_AER_UC_STATUS, 4);
6646         if (r != 0)
6647                 pci_write_config(dev, aer + PCIR_AER_UC_STATUS, r, 4);
6648         r = pci_read_config(dev, aer + PCIR_AER_COR_STATUS, 4);
6649         if (r != 0)
6650                 pci_write_config(dev, aer + PCIR_AER_COR_STATUS, r, 4);
6651 }
6652
6653 DB_COMMAND(pci_clearerr, db_pci_clearerr)
6654 {
6655         struct pci_devinfo *dinfo;
6656         device_t dev;
6657         uint16_t status, status1;
6658
6659         STAILQ_FOREACH(dinfo, &pci_devq, pci_links) {
6660                 dev = dinfo->cfg.dev;
6661                 status1 = status = pci_read_config(dev, PCIR_STATUS, 2);
6662                 status1 &= PCIM_STATUS_MDPERR | PCIM_STATUS_STABORT |
6663                     PCIM_STATUS_RTABORT | PCIM_STATUS_RMABORT |
6664                     PCIM_STATUS_SERR | PCIM_STATUS_PERR;
6665                 if (status1 != 0) {
6666                         status &= ~status1;
6667                         pci_write_config(dev, PCIR_STATUS, status, 2);
6668                 }
6669                 if (dinfo->cfg.pcie.pcie_location != 0)
6670                         db_clear_pcie_errors(dinfo);
6671         }
6672 }
6673 #endif