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