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