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