Index: sys/dev/bktr/bktr_os.c =================================================================== --- sys/dev/bktr/bktr_os.c +++ sys/dev/bktr/bktr_os.c @@ -211,23 +211,17 @@ static int bktr_shutdown( device_t dev ); static void bktr_intr(void *arg) { common_bktr_intr(arg); } -static struct bktr_dev { - uint16_t vendorid; - uint16_t deviceid; - uint8_t rev; - const char *description; -} bktr_devs[] = { - {PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT848, 0x12, - "BrookTree 848A"}, - {PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT848, 0, - "BrookTree 848"}, - {PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT849, 0, - "BrookTree 849A"}, - {PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT878, 0, - "BrookTree 878"}, - {PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT879, 0, - "BrookTree 879"}, - {0, 0, 0, NULL}, +struct pci_device_table bktr_devs[] = { + {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT848), PCI_REVID(0x12), + PCI_DESCR("BrookTree 848A")}, + {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT848), + PCI_DESCR("BrookTree 848")}, + {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT849), + PCI_DESCR("BrookTree 849A")}, + {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT878), + PCI_DESCR("BrookTree 878")}, + {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT879), + PCI_DESCR("BrookTree 879")} }; static device_method_t bktr_methods[] = { @@ -293,8 +287,7 @@ MODULE_DEPEND(bktr, smbus, SMBUS_MINVER, SMBUS_MODVER, SMBUS_MAXVER); #endif DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0); -MODULE_PNP_INFO("U16:vendor;U16:device", pci, bktr, bktr_devs, - sizeof(bktr_devs[0]), nitems(bktr_devs) - 1); +PCI_PNP_INFO(bktr_devs); MODULE_DEPEND(bktr, bktr_mem, 1,1,1); MODULE_VERSION(bktr, 1); @@ -305,38 +298,13 @@ static int bktr_probe( device_t dev ) { - unsigned int type = pci_get_devid(dev); - unsigned int rev = pci_get_revid(dev); - const struct bktr_dev *bktd; - uint16_t vid; - uint16_t did; - size_t i; - - vid = PCI_VENDOR(type); - did = PCI_PRODUCT(type); - - // XXX merge conflicts. Need to convert to PCI_MATCH instead. - if (BKTR_PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE) - { - switch (BKTR_PCI_PRODUCT(type)) { - case PCI_PRODUCT_BROOKTREE_BT848: - if (rev == 0x12) - device_set_desc(dev, "BrookTree 848A"); - else - device_set_desc(dev, "BrookTree 848"); - return BUS_PROBE_DEFAULT; - case PCI_PRODUCT_BROOKTREE_BT849: - device_set_desc(dev, "BrookTree 849A"); - return BUS_PROBE_DEFAULT; - case PCI_PRODUCT_BROOKTREE_BT878: - device_set_desc(dev, "BrookTree 878"); - return BUS_PROBE_DEFAULT; - case PCI_PRODUCT_BROOKTREE_BT879: - device_set_desc(dev, "BrookTree 879"); - return BUS_PROBE_DEFAULT; - } - } - return ENXIO; + const struct pci_device_table *bktd; + + bktd = PCI_MATCH(dev, bktr_devs); + if (bktd == NULL) + return (ENXIO); + device_set_desc(dev, bktd->descr); + return (BUS_PROBE_DEFAULT); } Index: sys/dev/de/if_de.c =================================================================== --- sys/dev/de/if_de.c +++ sys/dev/de/if_de.c @@ -161,19 +161,19 @@ static void tulip_dma_map_rxbuf(void *, bus_dma_segment_t *, int, bus_size_t, int); -static struct de_dev { - uint16_t vendorid; - uint16_t deviceid; - uint8_t revid; - const char *description; -} de_devs[] = { - {DEC_VENDORID, CHIPID_21040, 0, "Digital 21040 Ethernet"}, - {DEC_VENDORID, CHIPID_21041, 0, "Digital 21041 Ethernet"}, - {DEC_VENDORID, CHIPID_21140, 0, "Digital 21140 Fast Ethernet"}, - {DEC_VENDORID, CHIPID_21140, 0x20, "Digital 21140A Fast Ethernet"}, - {DEC_VENDORID, CHIPID_21142, 0, "Digital 21142 Fast Ethernet"}, - {DEC_VENDORID, CHIPID_21142, 0x20, "Digital 21143 Fast Ethernet"}, - {0, 0, 0, 0}, +struct pci_device_table de_devs[] = { + {PCI_DEV(DEC_VENDORID, CHIPID_21040), PCI_REVID(0), + PCI_DESCR("Digital 21040 Ethernet")}, + {PCI_DEV(DEC_VENDORID, CHIPID_21041), PCI_REVID(0), + PCI_DESCR("Digital 21041 Ethernet")}, + {PCI_DEV(DEC_VENDORID, CHIPID_21140), PCI_REVID(0), + PCI_DESCR("Digital 21140 Fast Ethernet")}, + {PCI_DEV(DEC_VENDORID, CHIPID_21140), PCI_REVID(0x20), + PCI_DESCR("Digital 21140A Fast Ethernet")}, + {PCI_DEV(DEC_VENDORID, CHIPID_21142), PCI_REVID(0), + PCI_DESCR("Digital 21142 Fast Ethernet")}, + {PCI_DEV(DEC_VENDORID, CHIPID_21142), PCI_REVID(0x20), + PCI_DESCR("Digital 21143 Fast Ethernet")} }; static void @@ -4685,17 +4685,10 @@ static int tulip_pci_probe(device_t dev) { - const char *name = NULL; - const struct de_dev *ded; + const struct pci_device_table *ded; uint16_t vid; - uint16_t did; - uint8_t revid; - size_t i; - vid = pci_get_vendor(dev); - did = pci_get_device(dev); - revid = pci_get_revid(dev); - + vid = pci_get_vendor(dev); if (vid != DEC_VENDORID) return ENXIO; @@ -4705,19 +4698,12 @@ */ if (pci_get_subvendor(dev) == 0x1376) return ENXIO; - - for (i = 0; i < nitems(de_devs); i++) { - ded = &de_devs[i]; - if ((ded->deviceid == did) && - ((revid >= ded->revid) || (ded->revid == 0))) { - name = ded->description; - } - } - if (name) { - device_set_desc(dev, name); - return BUS_PROBE_LOW_PRIORITY; - } - return ENXIO; + + ded = PCI_MATCH(dev, de_devs); + if (ded == NULL) + return (ENXIO); + device_set_desc(dev, ded->descr); + return (BUS_PROBE_LOW_PRIORITY); } static int @@ -4919,8 +4905,7 @@ static devclass_t tulip_devclass; DRIVER_MODULE(de, pci, tulip_pci_driver, tulip_devclass, 0, 0); -MODULE_PNP_INFO("U16:vendor;U16:device", pci, de, de_devs, - sizeof(de_devs[0]), nitems(de_devs) - 1); +PCI_PNP_INFO(de_devs); #ifdef DDB void tulip_dumpring(int unit, int ring); Index: sys/dev/dpt/dpt_pci.c =================================================================== --- sys/dev/dpt/dpt_pci.c +++ sys/dev/dpt/dpt_pci.c @@ -64,7 +64,7 @@ struct pci_device_table dpt_devs[] = { {PCI_DEV(DPT_VENDOR_ID, DPT_DEVICE_ID), - PCI_DESCR("DPT Caching SCSI RAID Controller")}, + PCI_DESCR("DPT Caching SCSI RAID Controller")} }; static int @@ -75,7 +75,7 @@ dpd = PCI_MATCH(dev, dpt_devs); if (dpd == NULL) return (ENXIO); - device_set_desc(dev, dpd->description); + device_set_desc(dev, dpd->descr); return (BUS_PROBE_DEFAULT); } Index: sys/dev/esp/esp_pci.c =================================================================== --- sys/dev/esp/esp_pci.c +++ sys/dev/esp/esp_pci.c @@ -96,6 +96,8 @@ #include #define PCI_DEVICE_ID_AMD53C974 0x20201022 +#define PCI_DEVICEID_AMD53C974 0x2020 +#define PCI_VENDOR_ID_AMD 0x1022 struct esp_pci_softc { struct ncr53c9x_softc sc_ncr53c9x; /* glue to MI code */ @@ -141,12 +143,9 @@ static int esp_pci_suspend(device_t); static int esp_pci_resume(device_t); -static struct esp_dev { - uint32_t deviceid; - const char *description; -} esp_devs[] = { - {PCI_DEVICE_ID_AMD53C974, "AMD Am53C974 Fast-SCSI"}, - {0, NULL}, +struct pci_device_table esp_devs[] = { + {PCI_DEV(PCI_VENDOR_ID_AMD, PCI_DEVICEID_AMD53C974), + PCI_DESCR("AMD Am53C974 Fast-SCSI")} }; static device_method_t esp_pci_methods[] = { @@ -166,8 +165,7 @@ }; DRIVER_MODULE(esp, pci, esp_pci_driver, esp_devclass, 0, 0); -MODULE_PNP_INFO("U32:device", pci, esp, esp_devs, - sizeof(esp_devs[0]), nitems(esp_devs) - 1); +PCI_PNP_INFO(esp_devs); MODULE_DEPEND(esp, pci, 1, 1, 1); /* @@ -202,20 +200,13 @@ static int esp_pci_probe(device_t dev) { - const struct esp_dev *esd; - uint32_t did; - size_t i; - did = pci_get_devid(dev); - - for(i=0; ideviceid){ - device_set_desc(dev, esd->description); - return BUS_PROBE_DEFAULT; - } - } + const struct pci_device_table *esd; - return (ENXIO); + esd = PCI_MATCH(dev, esp_devs); + if (esd == NULL) + return (ENXIO); + device_set_desc(dev, esd->descr); + return (BUS_PROBE_DEFAULT); } /* Index: sys/dev/iir/iir_pci.c =================================================================== --- sys/dev/iir/iir_pci.c +++ sys/dev/iir/iir_pci.c @@ -141,14 +141,11 @@ void gdt_mpr_set_sema0(struct gdt_softc *); int gdt_mpr_test_busy(struct gdt_softc *); -static struct iir_pci_dev { - uint16_t vendorid; - uint16_t deviceid; - const char *description; -} iir_pci_devs[] = { - {INTEL_VENDOR_ID_IIR, INTEL_DEVICE_ID_IIR, "Intel Integrated RAID Controller"}, - {GDT_VENDOR_ID, GDT_DEVICE_ID_NEWRX, "ICP Disk Array Controller"}, - {0, 0, NULL}, +struct pci_device_table iir_pci_devs[] = { + {PCI_DEV(INTEL_VENDOR_ID_IIR, INTEL_DEVICE_ID_IIR), + PCI_DESCR("Intel Integrated RAID Controller")}, + {PCI_DEV(GDT_VENDOR_ID, GDT_DEVICE_ID_NEWRX), + PCI_DESCR("ICP Disk Array Controller")} }; static device_method_t iir_pci_methods[] = { @@ -169,18 +166,16 @@ static devclass_t iir_devclass; DRIVER_MODULE(iir, pci, iir_pci_driver, iir_devclass, 0, 0); -MODULE_PNP_INFO("U16:vendor;U16:device;D:#", pci, iir, iir_pci_devs, - sizeof(iir_pci_devs[0]), nitems(iir_pci_devs) - 1); +PCI_PNP_INFO(iir_pci_devs); MODULE_DEPEND(iir, pci, 1, 1, 1); MODULE_DEPEND(iir, cam, 1, 1, 1); static int iir_pci_probe(device_t dev) { - const struct iir_pci_dev *iird; + const struct pci_device_table *iird; uint16_t did; uint16_t vid; - size_t i; vid = pci_get_vendor(dev); did = pci_get_device(dev); @@ -191,16 +186,12 @@ return (BUS_PROBE_DEFAULT); } else { - for (i = 0; i < nitems(iir_pci_devs) - 1; i++) { - iird = &iir_pci_devs[i]; - if (vid == iird->vendorid && - did == iird->deviceid) { - device_set_desc(dev, iird->description); - return (BUS_PROBE_DEFAULT); - } - } + iird = PCI_MATCH(dev, iir_pci_devs); + if (iird == NULL) + return (ENXIO); + device_set_desc(dev, iird->descr); + return (BUS_PROBE_DEFAULT); } - return (ENXIO); } Index: sys/dev/imcsmb/imcsmb_pci.c =================================================================== --- sys/dev/imcsmb/imcsmb_pci.c +++ sys/dev/imcsmb/imcsmb_pci.c @@ -128,24 +128,19 @@ }, }; -static struct imcsmb_pci_device { - uint16_t vendorid; - uint16_t deviceid; - char *name; -} imcsmb_pci_devices[] = { - {PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_SBX, - "Intel Sandybridge Xeon iMC 0 SMBus controllers" }, - {PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_IBX, - "Intel Ivybridge Xeon iMC 0 SMBus controllers" }, - {PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_HSX, - "Intel Haswell Xeon iMC 0 SMBus controllers" }, - {PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC1_HSX, - "Intel Haswell Xeon iMC 1 SMBus controllers" }, - {PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_BDX, - "Intel Broadwell Xeon iMC 0 SMBus controllers" }, - {PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC1_BDX, - "Intel Broadwell Xeon iMC 1 SMBus controllers" }, - {0, 0, NULL}, +struct pci_device_table imcsmb_pci_devs[] = { + {PCI_DEV(PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_SBX), + PCI_DESCR("Intel Sandybridge Xeon iMC 0 SMBus controllers")}, + {PCI_DEV(PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_IBX), + PCI_DESCR("Intel Ivybridge Xeon iMC 0 SMBus controllers")}, + {PCI_DEV(PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_HSX), + PCI_DESCR("Intel Haswell Xeon iMC 0 SMBus controllers")}, + {PCI_DEV(PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC1_HSX), + PCI_DESCR("Intel Haswell Xeon iMC 1 SMBus controllers")}, + {PCI_DEV(PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC0_BDX), + PCI_DESCR("Intel Broadwell Xeon iMC 0 SMBus controllers")}, + {PCI_DEV(PCI_VENDOR_INTEL, IMCSMB_PCI_DEV_ID_IMC1_BDX), + PCI_DESCR("Intel Broadwell Xeon iMC 1 SMBus controllers")} }; /* Device methods. */ @@ -236,29 +231,13 @@ static int imcsmb_pci_probe(device_t dev) { - struct imcsmb_pci_device *pci_device; - int rc; - uint16_t pci_dev_id; - - rc = ENXIO; - - if (pci_get_vendor(dev) != PCI_VENDOR_INTEL) { - goto out; - } - - pci_dev_id = pci_get_device(dev); - for (pci_device = imcsmb_pci_devices; - pci_device->name != NULL; - pci_device++) { - if (pci_dev_id == pci_device->deviceid) { - device_set_desc(dev, pci_device->name); - rc = BUS_PROBE_DEFAULT; - goto out; - } - } - -out: - return (rc); + const struct pci_device_table *imcsd; + + imcsd = PCI_MATCH(dev, imcsmb_pci_devs); + if (imcsd == NULL) + return (ENXIO); + device_set_desc(dev, imcsd->descr); + return (BUS_PROBE_DEFAULT); } /** @@ -340,8 +319,7 @@ }; DRIVER_MODULE(imcsmb_pci, pci, imcsmb_pci_driver, imcsmb_pci_devclass, 0, 0); -MODULE_PNP_INFO("U16:vendor;U16:device;D:#", pci, imcsmb_pci, imcsmb_pci_devices, - sizeof(imcsmb_pci_devices[0]), nitems(imcsmb_pci_devices) - 1); +PCI_PNP_INFO(imcsmb_pci_devs); MODULE_DEPEND(imcsmb_pci, pci, 1, 1, 1); MODULE_VERSION(imcsmb_pci, 1); Index: sys/dev/ips/ips_pci.c =================================================================== --- sys/dev/ips/ips_pci.c +++ sys/dev/ips/ips_pci.c @@ -40,34 +40,24 @@ static int ips_pci_free(ips_softc_t *sc); static void ips_intrhook(void *arg); -static struct ips_pci_dev { - uint16_t vendorid; - uint16_t deviceid; - const char *description; -} ips_pci_devs[] = { - {IPS_VENDOR_ID, IPS_MORPHEUS_DEVICE_ID, "IBM ServeRAID Adapter"}, - {IPS_VENDOR_ID, IPS_COPPERHEAD_DEVICE_ID, "IBM ServeRAID Adapter"}, - {IPS_VENDOR_ID_ADAPTEC, IPS_MARCO_DEVICE_ID, "Adaptec ServeRAID Adapter"}, - {0,0,0}, +struct pci_device_table ips_pci_devs[] = { + {PCI_DEV(IPS_VENDOR_ID, IPS_MORPHEUS_DEVICE_ID), + PCI_DESCR("IBM ServeRAID Adapter")}, + {PCI_DEV(IPS_VENDOR_ID, IPS_COPPERHEAD_DEVICE_ID), + PCI_DESCR("IBM ServeRAID Adapter")}, + {PCI_DEV(IPS_VENDOR_ID_ADAPTEC, IPS_MARCO_DEVICE_ID), + PCI_DESCR("Adaptec ServeRAID Adapter")} }; static int ips_pci_probe(device_t dev) { - const struct ips_pci_dev *ipsd; - u_int16_t vid; - u_int16_t did; - size_t i; - - vid = pci_get_vendor(dev); - did = pci_get_device(dev); - for (i = 0; i < nitems(ips_pci_devs) - 1; i++) { - ipsd = &ips_pci_devs[i]; - if ((vid == ipsd->vendorid) && (did == ipsd->deviceid)) { - device_set_desc(dev, ipsd->description); - return (BUS_PROBE_DEFAULT); - } - } - return (ENXIO); + const struct pci_device_table *ipsd; + + ipsd = PCI_MATCH(dev, ips_pci_devs); + if (ipsd == NULL) + return (ENXIO); + device_set_desc(dev, ipsd->descr); + return (BUS_PROBE_DEFAULT); } static int ips_pci_attach(device_t dev) @@ -232,5 +222,4 @@ static devclass_t ips_devclass; DRIVER_MODULE(ips, pci, ips_pci_driver, ips_devclass, 0, 0); -MODULE_PNP_INFO("U16:vendor;U16:device;D:#", pci, ips, ips_pci_devs, - sizeof(ips_pci_devs[0]), nitems(ips_pci_devs) - 1); +PCI_PNP_INFO(ips_pci_devs); Index: sys/dev/ismt/ismt.c =================================================================== --- sys/dev/ismt/ismt.c +++ sys/dev/ismt/ismt.c @@ -717,33 +717,30 @@ #define ID_INTEL_S1200_SMT0 0x0c598086 #define ID_INTEL_S1200_SMT1 0x0c5a8086 #define ID_INTEL_C2000_SMT 0x1f158086 - -static struct ismt_dev { - uint32_t devid; - const char *description; -} ismt_devs[] = { - {ID_INTEL_S1200_SMT0, "Atom Processor S1200 SMBus 2.0 Controller 0"}, - {ID_INTEL_S1200_SMT1, "Atom Processor S1200 SMBus 2.0 Controller 1"}, - {ID_INTEL_C2000_SMT, "Atom Processor C2000 SMBus 2.0"}, - {0, NULL}, +#define INTEL_VENDORID 0x8086 +#define DID_INTEL_S1200_SMT0 0x0c59 +#define DID_INTEL_S1200_SMT1 0x0c5a +#define DID_INTEL_C2000_SMT 0x1f15 + +struct pci_device_table ismt_devs[] = { + {PCI_DEV(INTEL_VENDORID, DID_INTEL_S1200_SMT0), + PCI_DESCR("Atom Processor S1200 SMBus 2.0 Controller 0")}, + {PCI_DEV(INTEL_VENDORID, DID_INTEL_S1200_SMT1), + PCI_DESCR("Atom Processor S1200 SMBus 2.0 Controller 1")}, + {PCI_DEV(INTEL_VENDORID, DID_INTEL_C2000_SMT), + PCI_DESCR("Atom Processor C2000 SMBus 2.0")} }; static int ismt_probe(device_t dev) { - uint32_t did; - size_t i; - - did = pci_get_devid(dev); - const struct ismt_dev *ismtd; - for (i = 0; i < nitems(ismt_devs) - 1; i++) { - ismtd = &ismt_devs[i]; - if (did == ismtd->devid) { - device_set_desc(dev, ismtd->description); - return (BUS_PROBE_DEFAULT); - } - } - return (ENXIO); + const struct pci_device_table *ismtd; + + ismtd = PCI_MATCH(dev, ismt_devs); + if (ismtd == NULL) + return (ENXIO); + device_set_desc(dev, ismtd->descr); + return (BUS_PROBE_DEFAULT); } /* Device methods */ @@ -776,8 +773,7 @@ static devclass_t ismt_pci_devclass; DRIVER_MODULE(ismt, pci, ismt_pci_driver, ismt_pci_devclass, 0, 0); -MODULE_PNP_INFO("W32:vendor/device;D:#", pci, ismt, ismt_devs, - sizeof(ismt_devs[0]), nitems(ismt_devs) - 1); +PCI_PNP_INFO(ismt_devs); DRIVER_MODULE(smbus, ismt, smbus_driver, smbus_devclass, 0, 0); MODULE_DEPEND(ismt, pci, 1, 1, 1); Index: sys/dev/iwm/if_iwm.c =================================================================== --- sys/dev/iwm/if_iwm.c +++ sys/dev/iwm/if_iwm.c @@ -5711,22 +5711,45 @@ {PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_8260_2, &iwm8260_cfg }, {PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_8265_1, &iwm8265_cfg }, {0, 0, NULL}, + }; + +struct pci_device_table iwm_devs[] = { + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_3160_1), + PCI_DESCR("Intel(R) Dual Band Wireless AC 3165")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_3160_2), + PCI_DESCR("Intel(R) Dual Band Wireless AC 3165")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_3165_1), + PCI_DESCR("Intel(R) Dual Band Wireless AC 3165")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_3165_2), + PCI_DESCR("Intel(R) Dual Band Wireless AC 3165")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_3168_1), + PCI_DESCR("Intel(R) Dual Band Wireless AC 3168")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_7260_1), + PCI_DESCR("Intel(R) Dual Band Wireless AC 7260")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_7260_2), + PCI_DESCR("Intel(R) Dual Band Wireless AC 7260")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_7265_1), + PCI_DESCR("Intel(R) Dual Band Wireless AC 7265")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_7265_2), + PCI_DESCR("Intel(R) Dual Band Wireless AC 7265")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_8260_1), + PCI_DESCR("Intel(R) Dual Band Wireless AC 8260")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_8260_2), + PCI_DESCR("Intel(R) Dual Band Wireless AC 8260")}, + {PCI_DEV(PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_WL_8265_1), + PCI_DESCR("Intel(R) Dual Band Wireless AC 8265")}, }; static int iwm_probe(device_t dev) { - int i; - - for (i = 0; i < nitems(iwm_devices); i++) { - if (pci_get_vendor(dev) == PCI_VENDOR_INTEL && - pci_get_device(dev) == iwm_devices[i].device) { - device_set_desc(dev, iwm_devices[i].cfg->name); - return (BUS_PROBE_DEFAULT); - } - } + const struct pci_device_table *iwmd; - return (ENXIO); + iwmd = PCI_MATCH(dev, iwm_devs); + if (iwmd == NULL) + return (ENXIO); + device_set_desc(dev, iwmd->descr); + return (BUS_PROBE_DEFAULT); } static int @@ -6462,8 +6485,7 @@ static devclass_t iwm_devclass; DRIVER_MODULE(iwm, pci, iwm_pci_driver, iwm_devclass, NULL, NULL); -MODULE_PNP_INFO("U16:vendor;U16:device", pci, iwm, iwm_devices, - sizeof(iwm_devices[0]), nitems(iwm_devices) - 1); +PCI_PNP_INFO(iwm_devices); MODULE_DEPEND(iwm, firmware, 1, 1, 1); MODULE_DEPEND(iwm, pci, 1, 1, 1); MODULE_DEPEND(iwm, wlan, 1, 1, 1); Index: sys/dev/pci/fixup_pci.c =================================================================== --- sys/dev/pci/fixup_pci.c +++ sys/dev/pci/fixup_pci.c @@ -55,13 +55,11 @@ static void fixwsc_natoma(device_t dev); static void fixc1_nforce2(device_t dev); -static struct fixup_pci_dev { - uint32_t devid; - const char *description; -} fixup_pci_devs[] = { - {0x12378086, "Intel 82440FX (Natoma)"}, - {0x01e010de, "nVidia nForce2"}, - {0, 0}, +struct pci_device_table fixup_pci_devs[] = { + {PCI_DEV(0x8086, 0x1237), + PCI_DESCR("Intel 82440FX (Natoma)")}, + {PCI_DEV(0x10de, 0x01e0), + PCI_DESCR("nVidia nForce2")} }; static device_method_t fixup_pci_methods[] = { @@ -80,24 +78,18 @@ static devclass_t fixup_pci_devclass; DRIVER_MODULE(fixup_pci, pci, fixup_pci_driver, fixup_pci_devclass, 0, 0); -MODULE_PNP_INFO("W32:vendor/device;D:#", pci, fixup_pci, fixup_pci_devs, - sizeof(fixup_pci_devs[0]), nitems(fixup_pci_devs) - 1); +PCI_PNP_INFO(fixup_pci_devs); static int fixup_pci_probe(device_t dev) { - const struct fixup_pci_dev *fixd; - uint32_t devid; - size_t i; - - devid = pci_get_devid(dev); - for (i = 0; i < nitems(fixup_pci_devs); i++) { - fixd = &fixup_pci_devs[i]; - if(fixd->devid == devid) { - fixwsc_natoma(dev); - } - } - return(ENXIO); + const struct pci_device_table *fixd; + + fixd = PCI_MATCH(dev, fixup_pci_devs); + if (fixd == NULL) + return (ENXIO); + device_set_desc(dev, fixd->descr); + return (BUS_PROBE_DEFAULT); } static void Index: sys/dev/pci/ignore_pci.c =================================================================== --- sys/dev/pci/ignore_pci.c +++ sys/dev/pci/ignore_pci.c @@ -43,12 +43,9 @@ #include static int ignore_pci_probe(device_t dev); -static struct ignore_pci_dev { - uint32_t devid; - const char *description; -} ignore_pci_devs[] = { - {0x10001042, "ignored"}, - {0, 0}, +struct pci_device_table ignore_pci_devs[] = { + {PCI_DEV(0x1042, 0x1000), + PCI_DESCR("ignored")} }; static device_method_t ignore_pci_methods[] = { @@ -67,17 +64,16 @@ static devclass_t ignore_pci_devclass; DRIVER_MODULE(ignore_pci, pci, ignore_pci_driver, ignore_pci_devclass, 0, 0); -MODULE_PNP_INFO("U32:vendor/device", pci, ignore_pci, ignore_pci_devs, - sizeof(ignore_pci_devs[0]), nitems(ignore_pci_devs) - 1); +PCI_PNP_INFO(ignore_pci_devs); static int ignore_pci_probe(device_t dev) { - switch (pci_get_devid(dev)) { - case 0x10001042ul: /* SMC 37C665 */ - device_set_desc(dev, "ignored"); - device_quiet(dev); - return(-10000); - } - return(ENXIO); + const struct pci_device_table *ignd; + + ignd = PCI_MATCH(dev, ignore_pci_devs); + if (ignd == NULL) + return (ENXIO); + device_set_desc(dev, ignd->descr); + return (BUS_PROBE_DEFAULT); } Index: sys/powerpc/powermac/grackle.c =================================================================== --- sys/powerpc/powermac/grackle.c +++ sys/powerpc/powermac/grackle.c @@ -61,6 +61,9 @@ #include "pcib_if.h" +#define PCI_VENDOR_ID_MOTOROLA 0x1057 +#define PCI_DEVICE_ID_MPC106 0x0002 + /* * Device interface. */ @@ -83,12 +86,9 @@ static void grackle_disable_config(struct grackle_softc *); static int badaddr(void *, size_t); -static struct grackle_hb_dev { - uint32_t deviceid; - const char *description; -} grackle_hb_devs[] = { - {0x00021057, "Grackle Host to PCI bridge"}, - {0, NULL}, +struct pci_device_table grackle_hb_devs[] = { + {PCI_DEV(PCI_VENDOR_ID_MOTOROLA, PCI_DEVICE_ID_MPC106), + PCI_DESCR("MPC106 (Grackle) Host-PCI bridge")} }; /* @@ -115,17 +115,20 @@ grackle_probe(device_t dev) { const char *type, *compatible; + const struct pci_device_table grcd; type = ofw_bus_get_type(dev); compatible = ofw_bus_get_compat(dev); + grcd = PCI_MATCH(dev, grackle_hb_devs); if (type == NULL || compatible == NULL) return (ENXIO); if (strcmp(type, "pci") != 0 || strcmp(compatible, "grackle") != 0) return (ENXIO); - - device_set_desc(dev, "MPC106 (Grackle) Host-PCI bridge"); + if (grcd == NULL) + return (ENXIO); + device_set_desc(dev, grcd->descr); return (0); } @@ -338,5 +341,4 @@ static devclass_t grackle_hb_devclass; DRIVER_MODULE(grackle_hb, pci, grackle_hb_driver, grackle_hb_devclass, 0, 0); -MODULE_PNP_INFO("U32:device", pci, grackle_hb, grackle_hb_devs, - sizeof(grackle_hb_devs[0]), nitems(grackle_hb_devs) - 1); +PCI_PNP_INFO(grackle_hb_devs);