D16233.id45188.diff
No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

D16233.id45188.diff
View Options

	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_REVID(0),
	+ PCI_DESCR("BrookTree 848")},
	+ {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT849), PCI_REVID(0),
	+ PCI_DESCR("BrookTree 849A")},
	+ {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT878), PCI_REVID(0),
	+ PCI_DESCR("BrookTree 878")},
	+ {PCI_DEV(PCI_VENDOR_BROOKTREE, PCI_PRODUCT_BROOKTREE_BT879), PCI_REVID(0),
	+ 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 <dev/esp/am53c974reg.h>

	#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; i<nitems(esp_devs) - 1; i++) {
	- esd = &esp_devs[i];
	- if(did == esd->deviceid){
	- 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 <dev/pci/pcivar.h>

	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);

File Metadata

Mime Type: text/plain
Expires: Mon, Oct 27, 12:45 AM (1 m, 33 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 24260869
Default Alt Text: D16233.id45188.diff (23 KB)

D16233.id45188.diffNo OneTemporaryActions

D16233.id45188.diffView Options

File Metadata

Event Timeline

D16233.id45188.diff
No OneTemporary
Actions

D16233.id45188.diff
View Options