D44131.diff
No OneTemporary
Actions

Size

67 KB

Referenced Files

None

Subscribers

None

D44131.diff
View Options

	diff --git a/share/man/man9/bus_release_resource.9 b/share/man/man9/bus_release_resource.9
	--- a/share/man/man9/bus_release_resource.9
	+++ b/share/man/man9/bus_release_resource.9
	@@ -40,7 +40,7 @@
	.In sys/rman.h
	.In machine/resource.h
	.Ft int
	-.Fn bus_release_resource "device_t dev" "int type" "int rid" "struct resource *r"
	+.Fn bus_release_resource "device_t dev" "struct resource *r"
	.Sh DESCRIPTION
	Free a resource allocated by
	.Xr bus_alloc_resource 9 .
	@@ -53,20 +53,6 @@
	.Fa dev
	is the device that owns the resource.
	.It
	-.Fa type
	-is the type of resource that is released.
	-It must be of the same type you allocated it as before.
	-See
	-.Xr bus_alloc_resource 9
	-for valid types.
	-.It
	-.Fa rid
	-is the resource ID of the resource.
	-The
	-.Fa rid
	-value must be the same as the one returned by
	-.Xr bus_alloc_resource 9 .
	-.It
	.Fa r
	is the pointer to
	.Va struct resource ,
	@@ -88,12 +74,10 @@
	bus_teardown_intr(dev, foosoftc->irqres, foosoftc->irqid);

	/* release IRQ resource */
	- bus_release_resource(dev, SYS_RES_IRQ, foosoftc->irqid,
	- foosoftc->irqres);
	+ bus_release_resource(dev, foosoftc->irqres);

	/* release I/O port resource */
	- bus_release_resource(dev, SYS_RES_IOPORT, foosoftc->portid,
	- foosoftc->portres);
	+ bus_release_resource(dev, foosoftc->portres);
	.Ed
	.Sh SEE ALSO
	.Xr bus_alloc_resource 9 ,
	diff --git a/sys/arm/mv/mv_pci.c b/sys/arm/mv/mv_pci.c
	--- a/sys/arm/mv/mv_pci.c
	+++ b/sys/arm/mv/mv_pci.c
	@@ -347,8 +347,7 @@
	rman_res_t, rman_res_t, rman_res_t, u_int);
	static int mv_pcib_adjust_resource(device_t, device_t, struct resource *,
	rman_res_t, rman_res_t);
	-static int mv_pcib_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int mv_pcib_release_resource(device_t, device_t, struct resource *);
	static int mv_pcib_activate_resource(device_t, device_t, struct resource *);
	static int mv_pcib_deactivate_resource(device_t, device_t, struct resource *);
	static int mv_pcib_map_resource(device_t, device_t, struct resource *,
	@@ -962,25 +961,22 @@
	}

	static int
	-mv_pcib_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *res)
	+mv_pcib_release_resource(device_t dev, device_t child, struct resource *res)
	{
	#ifdef PCI_RES_BUS
	struct mv_pcib_softc *sc = device_get_softc(dev);
	#endif

	- switch (type) {
	+ switch (rman_get_type(res)) {
	case SYS_RES_IOPORT:
	case SYS_RES_MEMORY:
	- return (bus_generic_rman_release_resource(dev, child, type,
	- rid, res));
	+ return (bus_generic_rman_release_resource(dev, child, res));
	#ifdef PCI_RES_BUS
	case PCI_RES_BUS:
	- return (pci_domain_release_bus(sc->ap_segment, child, rid, res));
	+ return (pci_domain_release_bus(sc->ap_segment, child, res));
	#endif
	default:
	- return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
	- type, rid, res));
	+ return (bus_generic_release_resource(dev, child, res));
	}
	}

	diff --git a/sys/arm64/cavium/thunder_pcie_fdt.c b/sys/arm64/cavium/thunder_pcie_fdt.c
	--- a/sys/arm64/cavium/thunder_pcie_fdt.c
	+++ b/sys/arm64/cavium/thunder_pcie_fdt.c
	@@ -57,7 +57,7 @@
	static struct resource * thunder_pcie_fdt_alloc_resource(device_t, device_t,
	int, int *, rman_res_t, rman_res_t, rman_res_t, u_int);
	static int thunder_pcie_fdt_release_resource(device_t, device_t,
	- int, int, struct resource*);
	+ struct resource*);
	#endif
	static int thunder_pcie_fdt_attach(device_t);
	static int thunder_pcie_fdt_probe(device_t);
	@@ -288,14 +288,14 @@
	}

	static int
	-thunder_pcie_fdt_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *res)
	+thunder_pcie_fdt_release_resource(device_t dev, device_t child,
	+ struct resource *res)
	{

	if ((int)ofw_bus_get_node(child) <= 0)
	- return (pci_host_generic_core_release_resource(dev, child, type,
	- rid, res));
	+ return (pci_host_generic_core_release_resource(dev, child,
	+ res));

	- return (bus_generic_release_resource(dev, child, type, rid, res));
	+ return (bus_generic_release_resource(dev, child, res));
	}
	#endif
	diff --git a/sys/arm64/cavium/thunder_pcie_pem.c b/sys/arm64/cavium/thunder_pcie_pem.c
	--- a/sys/arm64/cavium/thunder_pcie_pem.c
	+++ b/sys/arm64/cavium/thunder_pcie_pem.c
	@@ -149,8 +149,7 @@
	int);
	static int thunder_pem_read_ivar(device_t, device_t, int, uintptr_t *);
	static void thunder_pem_release_all(device_t);
	-static int thunder_pem_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int thunder_pem_release_resource(device_t, device_t, struct resource *);
	static struct rman * thunder_pem_get_rman(device_t, int, u_int);
	static void thunder_pem_slix_s2m_regx_acc_modify(struct thunder_pem_softc *,
	int, int);
	@@ -716,28 +715,25 @@
	}

	static int
	-thunder_pem_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *res)
	+thunder_pem_release_resource(device_t dev, device_t child, struct resource *res)
	{
	device_t parent_dev;
	#if defined(NEW_PCIB) && defined(PCI_RES_BUS)
	struct thunder_pem_softc *sc = device_get_softc(dev);
	#endif

	- switch (type) {
	+ switch (rman_get_type(res)) {
	#if defined(NEW_PCIB) && defined(PCI_RES_BUS)
	case PCI_RES_BUS:
	- return (pci_domain_release_bus(sc->id, child, rid, res));
	+ return (pci_domain_release_bus(sc->id, child, res));
	#endif
	case SYS_RES_MEMORY:
	case SYS_RES_IOPORT:
	- return (bus_generic_rman_release_resource(dev, child, type,
	- rid, res));
	+ return (bus_generic_rman_release_resource(dev, child, res));
	default:
	/* Find parent device. On ThunderX we know an exact path. */
	parent_dev = device_get_parent(device_get_parent(dev));
	- return (BUS_RELEASE_RESOURCE(parent_dev, child,
	- type, rid, res));
	+ return (BUS_RELEASE_RESOURCE(parent_dev, child, res));
	}
	}

	diff --git a/sys/dev/acpica/acpi.c b/sys/dev/acpica/acpi.c
	--- a/sys/dev/acpica/acpi.c
	+++ b/sys/dev/acpica/acpi.c
	@@ -1580,17 +1580,16 @@
	}

	static int
	-acpi_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	+acpi_release_resource(device_t bus, device_t child, struct resource *r)
	{
	/*
	* If this resource belongs to one of our internal managers,
	* deactivate it and release it to the local pool.
	*/
	if (acpi_is_resource_managed(bus, r))
	- return (bus_generic_rman_release_resource(bus, child, type, rid, r));
	+ return (bus_generic_rman_release_resource(bus, child, r));

	- return (bus_generic_rl_release_resource(bus, child, type, rid, r));
	+ return (bus_generic_rl_release_resource(bus, child, r));
	}

	static void
	diff --git a/sys/dev/acpica/acpi_pcib_acpi.c b/sys/dev/acpica/acpi_pcib_acpi.c
	--- a/sys/dev/acpica/acpi_pcib_acpi.c
	+++ b/sys/dev/acpica/acpi_pcib_acpi.c
	@@ -101,8 +101,7 @@
	rman_res_t start, rman_res_t end);
	#ifdef PCI_RES_BUS
	static int acpi_pcib_acpi_release_resource(device_t dev,
	- device_t child, int type, int rid,
	- struct resource *r);
	+ device_t child, struct resource *r);
	static int acpi_pcib_acpi_activate_resource(device_t dev,
	device_t child, struct resource *r);
	static int acpi_pcib_acpi_deactivate_resource(device_t dev,
	@@ -516,7 +515,7 @@
	return (ENXIO);
	}
	sc->ap_bus = rman_get_start(bus_res);
	- pci_domain_release_bus(sc->ap_segment, dev, rid, bus_res);
	+ pci_domain_release_bus(sc->ap_segment, dev, bus_res);
	}
	} else {
	/*
	@@ -759,15 +758,15 @@

	#ifdef PCI_RES_BUS
	int
	-acpi_pcib_acpi_release_resource(device_t dev, device_t child, int type, int rid,
	+acpi_pcib_acpi_release_resource(device_t dev, device_t child,
	struct resource *r)
	{
	struct acpi_hpcib_softc *sc;

	sc = device_get_softc(dev);
	- if (type == PCI_RES_BUS)
	- return (pci_domain_release_bus(sc->ap_segment, child, rid, r));
	- return (bus_generic_release_resource(dev, child, type, rid, r));
	+ if (rman_get_type(r) == PCI_RES_BUS)
	+ return (pci_domain_release_bus(sc->ap_segment, child, r));
	+ return (bus_generic_release_resource(dev, child, r));
	}

	int
	diff --git a/sys/dev/agp/agp_i810.c b/sys/dev/agp/agp_i810.c
	--- a/sys/dev/agp/agp_i810.c
	+++ b/sys/dev/agp/agp_i810.c
	@@ -2053,8 +2053,8 @@
	return;
	BUS_DEACTIVATE_RESOURCE(device_get_parent(vga), dev,
	sc->sc_flush_page_res);
	- BUS_RELEASE_RESOURCE(device_get_parent(vga), dev, SYS_RES_MEMORY,
	- sc->sc_flush_page_rid, sc->sc_flush_page_res);
	+ BUS_RELEASE_RESOURCE(device_get_parent(vga), dev,
	+ sc->sc_flush_page_res);
	}

	static int
	diff --git a/sys/dev/ahci/ahci.h b/sys/dev/ahci/ahci.h
	--- a/sys/dev/ahci/ahci.h
	+++ b/sys/dev/ahci/ahci.h
	@@ -656,8 +656,7 @@
	int ahci_print_child(device_t dev, device_t child);
	struct resource ahci_alloc_resource(device_t dev, device_t child, int type, int rid,
	rman_res_t start, rman_res_t end, rman_res_t count, u_int flags);
	-int ahci_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r);
	+int ahci_release_resource(device_t dev, device_t child, struct resource *r);
	int ahci_setup_intr(device_t dev, device_t child, struct resource *irq,
	int flags, driver_filter_t filter, driver_intr_t function,
	void argument, void *cookiep);
	diff --git a/sys/dev/ahci/ahci.c b/sys/dev/ahci/ahci.c
	--- a/sys/dev/ahci/ahci.c
	+++ b/sys/dev/ahci/ahci.c
	@@ -640,16 +640,15 @@
	}

	int
	-ahci_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+ahci_release_resource(device_t dev, device_t child, struct resource *r)
	{

	- switch (type) {
	+ switch (rman_get_type(r)) {
	case SYS_RES_MEMORY:
	rman_release_resource(r);
	return (0);
	case SYS_RES_IRQ:
	- if (rid != ATA_IRQ_RID)
	+ if (rman_get_rid(r) != ATA_IRQ_RID)
	return (ENOENT);
	return (0);
	}
	diff --git a/sys/dev/ata/ata-pci.h b/sys/dev/ata/ata-pci.h
	--- a/sys/dev/ata/ata-pci.h
	+++ b/sys/dev/ata/ata-pci.h
	@@ -538,7 +538,7 @@
	int ata_pci_print_child(device_t dev, device_t child);
	int ata_pci_child_location(device_t dev, device_t child, struct sbuf *sb);
	struct resource * ata_pci_alloc_resource(device_t dev, device_t child, int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags);
	-int ata_pci_release_resource(device_t dev, device_t child, int type, int rid, struct resource *r);
	+int ata_pci_release_resource(device_t dev, device_t child, struct resource *r);
	int ata_pci_setup_intr(device_t dev, device_t child, struct resource irq, int flags, driver_filter_t filter, driver_intr_t function, void argument, void **cookiep);
	int ata_pci_teardown_intr(device_t dev, device_t child, struct resource irq, void cookie);
	int ata_pci_ch_attach(device_t dev);
	diff --git a/sys/dev/ata/ata-pci.c b/sys/dev/ata/ata-pci.c
	--- a/sys/dev/ata/ata-pci.c
	+++ b/sys/dev/ata/ata-pci.c
	@@ -273,24 +273,20 @@
	}

	int
	-ata_pci_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+ata_pci_release_resource(device_t dev, device_t child, struct resource *r)
	{
	+ int rid = rman_get_rid(r);
	+ int type = rman_get_type(r);

	if (device_get_devclass(child) == ata_devclass) {
	struct ata_pci_controller *controller = device_get_softc(dev);
	- int unit = ((struct ata_channel *)device_get_softc(child))->unit;

	if (type == SYS_RES_IOPORT) {
	switch (rid) {
	case ATA_IOADDR_RID:
	- return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
	- SYS_RES_IOPORT,
	- PCIR_BAR(0) + (unit << 3), r);
	case ATA_CTLADDR_RID:
	return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
	- SYS_RES_IOPORT,
	- PCIR_BAR(1) + (unit << 3), r);
	+ r);
	default:
	return ENOENT;
	}
	@@ -300,7 +296,7 @@
	return ENOENT;
	if (controller->legacy) {
	return BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
	- SYS_RES_IRQ, rid, r);
	+ r);
	} else
	return 0;
	}
	@@ -311,7 +307,7 @@
	return (0);
	} else {
	return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
	- type, rid, r));
	+ r));
	}
	}
	return (EINVAL);
	diff --git a/sys/dev/atkbdc/atkbdc_isa.c b/sys/dev/atkbdc/atkbdc_isa.c
	--- a/sys/dev/atkbdc/atkbdc_isa.c
	+++ b/sys/dev/atkbdc/atkbdc_isa.c
	@@ -53,7 +53,7 @@
	int type, int *rid, rman_res_t start, rman_res_t end,
	rman_res_t count, u_int flags);
	static int atkbdc_isa_release_resource(device_t dev, device_t child,
	- int type, int rid, struct resource *r);
	+ struct resource *r);

	static device_method_t atkbdc_isa_methods[] = {
	DEVMETHOD(device_probe, atkbdc_isa_probe),
	@@ -306,15 +306,14 @@
	}

	static int
	-atkbdc_isa_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+atkbdc_isa_release_resource(device_t dev, device_t child, struct resource *r)
	{
	atkbdc_softc_t *sc;

	sc = (atkbdc_softc_t *)device_get_softc(dev);
	- if (type == SYS_RES_IRQ && rid == KBDC_RID_KBD && r == sc->irq)
	+ if (r == sc->irq)
	return (0);
	- return (bus_generic_rl_release_resource(dev, child, type, rid, r));
	+ return (bus_generic_rl_release_resource(dev, child, r));
	}

	DRIVER_MODULE(atkbdc, isa, atkbdc_isa_driver, 0, 0);
	diff --git a/sys/dev/bhnd/bhnd_subr.c b/sys/dev/bhnd/bhnd_subr.c
	--- a/sys/dev/bhnd/bhnd_subr.c
	+++ b/sys/dev/bhnd/bhnd_subr.c
	@@ -2241,7 +2241,7 @@

	failed:
	if (res != NULL)
	- BUS_RELEASE_RESOURCE(dev, child, type, *rid, res);
	+ BUS_RELEASE_RESOURCE(dev, child, res);

	free(br, M_BHND);
	return (NULL);
	@@ -2259,7 +2259,7 @@
	{
	int error;

	- if ((error = BUS_RELEASE_RESOURCE(dev, child, type, rid, r->res)))
	+ if ((error = BUS_RELEASE_RESOURCE(dev, child, r->res)))
	return (error);

	free(r, M_BHND);
	diff --git a/sys/dev/bhnd/bhndb/bhndb.c b/sys/dev/bhnd/bhndb/bhndb.c
	--- a/sys/dev/bhnd/bhndb/bhndb.c
	+++ b/sys/dev/bhnd/bhndb/bhndb.c
	@@ -1034,8 +1034,7 @@
	* Default bhndb(4) implementation of BUS_RELEASE_RESOURCE().
	*/
	static int
	-bhndb_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+bhndb_release_resource(device_t dev, device_t child, struct resource *r)
	{
	struct bhndb_softc *sc;
	struct resource_list_entry *rle;
	@@ -1047,9 +1046,9 @@

	/* Delegate to our parent device's bus if the requested resource type
	* isn't handled locally. */
	- if (bhndb_get_rman(sc, child, type) == NULL) {
	+ if (bhndb_get_rman(sc, child, rman_get_type(r)) == NULL) {
	return (BUS_RELEASE_RESOURCE(device_get_parent(sc->parent_dev),
	- child, type, rid, r));
	+ child, r));
	}

	/* Deactivate resources */
	@@ -1065,7 +1064,7 @@
	if (!passthrough) {
	/* Clean resource list entry */
	rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child),
	- type, rid);
	+ rman_get_type(r), rman_get_rid(r));
	if (rle != NULL)
	rle->res = NULL;
	}
	diff --git a/sys/dev/bhnd/cores/chipc/chipc.c b/sys/dev/bhnd/cores/chipc/chipc.c
	--- a/sys/dev/bhnd/cores/chipc/chipc.c
	+++ b/sys/dev/bhnd/cores/chipc/chipc.c
	@@ -873,8 +873,7 @@
	}

	static int
	-chipc_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+chipc_release_resource(device_t dev, device_t child, struct resource *r)
	{
	struct chipc_softc *sc;
	struct chipc_region *cr;
	@@ -885,10 +884,9 @@
	sc = device_get_softc(dev);

	/* Handled by parent bus? */
	- rm = chipc_get_rman(dev, type, rman_get_flags(r));
	+ rm = chipc_get_rman(dev, rman_get_type(r), rman_get_flags(r));
	if (rm == NULL \|\| !rman_is_region_manager(r, rm)) {
	- return (bus_generic_rl_release_resource(dev, child, type, rid,
	- r));
	+ return (bus_generic_rl_release_resource(dev, child, r));
	}

	/* Locate the mapping region */
	@@ -897,7 +895,7 @@
	return (EINVAL);

	/* Deactivate resources */
	- error = bus_generic_rman_release_resource(dev, child, type, rid, r);
	+ error = bus_generic_rman_release_resource(dev, child, r);
	if (error != 0)
	return (error);

	@@ -905,7 +903,8 @@
	chipc_release_region(sc, cr, RF_ALLOCATED);

	/* Clear reference from the resource list entry if exists */
	- rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child), type, rid);
	+ rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child),
	+ rman_get_type(r), rman_get_rid(r));
	if (rle != NULL)
	rle->res = NULL;

	diff --git a/sys/dev/bhnd/cores/usb/bhnd_usb.c b/sys/dev/bhnd/cores/usb/bhnd_usb.c
	--- a/sys/dev/bhnd/cores/usb/bhnd_usb.c
	+++ b/sys/dev/bhnd/cores/usb/bhnd_usb.c
	@@ -69,8 +69,7 @@
	rman_res_t start, rman_res_t end,
	rman_res_t count, u_int flags);
	static int bhnd_usb_release_resource(device_t dev,
	- device_t child, int type, int rid,
	- struct resource *r);
	+ device_t child, struct resource *r);

	static struct resource_list * bhnd_usb_get_reslist(device_t dev,
	device_t child);
	@@ -311,8 +310,8 @@
	}

	static int
	-bhnd_usb_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *r)
	+bhnd_usb_release_resource(device_t dev, device_t child,
	+ struct resource *r)
	{
	struct bhnd_usb_softc *sc;
	struct resource_list_entry *rle;
	@@ -325,18 +324,17 @@
	/* Delegate to our parent device's bus if the requested resource type
	* isn't handled locally. */
	if (type != SYS_RES_MEMORY) {
	- return (bus_generic_rl_release_resource(dev, child, type, rid,
	- r));
	+ return (bus_generic_rl_release_resource(dev, child, r));
	}

	- error = bus_generic_rman_release_resource(dev, child, type, rid, r);
	+ error = bus_generic_rman_release_resource(dev, child, r);
	if (error != 0)
	return (error);

	if (!passthrough) {
	/* Clean resource list entry */
	rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child),
	- type, rid);
	+ rman_get_type(r), rman_get_rid(r));
	if (rle != NULL)
	rle->res = NULL;
	}
	diff --git a/sys/dev/dpaa/fman.h b/sys/dev/dpaa/fman.h
	--- a/sys/dev/dpaa/fman.h
	+++ b/sys/dev/dpaa/fman.h
	@@ -57,8 +57,7 @@
	int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags);
	int fman_activate_resource(device_t bus, device_t child,
	struct resource *res);
	-int fman_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *res);
	+int fman_release_resource(device_t bus, device_t child, struct resource *res);
	int fman_attach(device_t dev);
	int fman_detach(device_t dev);
	int fman_suspend(device_t dev);
	diff --git a/sys/dev/dpaa/fman.c b/sys/dev/dpaa/fman.c
	--- a/sys/dev/dpaa/fman.c
	+++ b/sys/dev/dpaa/fman.c
	@@ -116,8 +116,7 @@
	}

	int
	-fman_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *res)
	+fman_release_resource(device_t bus, device_t child, struct resource *res)
	{
	struct resource_list *rl;
	struct resource_list_entry *rle;
	@@ -125,9 +124,9 @@

	passthrough = (device_get_parent(child) != bus);
	rl = BUS_GET_RESOURCE_LIST(bus, child);
	- if (type != SYS_RES_IRQ) {
	+ if (rman_get_type(res) != SYS_RES_IRQ) {
	if ((rman_get_flags(res) & RF_ACTIVE) != 0 ){
	- rv = bus_deactivate_resource(child, type, rid, res);
	+ rv = bus_deactivate_resource(child, res);
	if (rv != 0)
	return (rv);
	}
	@@ -135,7 +134,8 @@
	if (rv != 0)
	return (rv);
	if (!passthrough) {
	- rle = resource_list_find(rl, type, rid);
	+ rle = resource_list_find(rl, rman_get_type(res),
	+ rman_get_rid(res));
	KASSERT(rle != NULL,
	("%s: resource entry not found!", __func__));
	KASSERT(rle->res != NULL,
	@@ -144,7 +144,7 @@
	}
	return (0);
	}
	- return (resource_list_release(rl, bus, child, type, rid, res));
	+ return (resource_list_release(rl, bus, child, res));
	}

	struct resource *
	diff --git a/sys/dev/dpaa2/dpaa2_mc.h b/sys/dev/dpaa2/dpaa2_mc.h
	--- a/sys/dev/dpaa2/dpaa2_mc.h
	+++ b/sys/dev/dpaa2/dpaa2_mc.h
	@@ -185,8 +185,8 @@
	u_int flags);
	int dpaa2_mc_adjust_resource(device_t mcdev, device_t child,
	struct resource *r, rman_res_t start, rman_res_t end);
	-int dpaa2_mc_release_resource(device_t mcdev, device_t child, int type,
	- int rid, struct resource *r);
	+int dpaa2_mc_release_resource(device_t mcdev, device_t child,
	+ struct resource *r);
	int dpaa2_mc_activate_resource(device_t mcdev, device_t child,
	struct resource *r);
	int dpaa2_mc_deactivate_resource(device_t mcdev, device_t child,
	diff --git a/sys/dev/dpaa2/dpaa2_mc.c b/sys/dev/dpaa2/dpaa2_mc.c
	--- a/sys/dev/dpaa2/dpaa2_mc.c
	+++ b/sys/dev/dpaa2/dpaa2_mc.c
	@@ -356,16 +356,14 @@
	}

	int
	-dpaa2_mc_release_resource(device_t mcdev, device_t child, int type, int rid,
	- struct resource *r)
	+dpaa2_mc_release_resource(device_t mcdev, device_t child, struct resource *r)
	{
	struct rman *rm;

	- rm = dpaa2_mc_rman(mcdev, type, rman_get_flags(r));
	+ rm = dpaa2_mc_rman(mcdev, rman_get_type(r), rman_get_flags(r));
	if (rm)
	- return (bus_generic_rman_release_resource(mcdev, child, type,
	- rid, r));
	- return (bus_generic_release_resource(mcdev, child, type, rid, r));
	+ return (bus_generic_rman_release_resource(mcdev, child, r));
	+ return (bus_generic_release_resource(mcdev, child, r));
	}

	int
	diff --git a/sys/dev/dpaa2/dpaa2_rc.c b/sys/dev/dpaa2/dpaa2_rc.c
	--- a/sys/dev/dpaa2/dpaa2_rc.c
	+++ b/sys/dev/dpaa2/dpaa2_rc.c
	@@ -263,19 +263,18 @@
	}

	static int
	-dpaa2_rc_release_resource(device_t rcdev, device_t child, int type, int rid,
	- struct resource *r)
	+dpaa2_rc_release_resource(device_t rcdev, device_t child, struct resource *r)
	{
	struct resource_list *rl;
	struct dpaa2_devinfo *dinfo;

	if (device_get_parent(child) != rcdev)
	return (BUS_RELEASE_RESOURCE(device_get_parent(rcdev), child,
	- type, rid, r));
	+ r));

	dinfo = device_get_ivars(child);
	rl = &dinfo->resources;
	- return (resource_list_release(rl, rcdev, child, type, rid, r));
	+ return (resource_list_release(rl, rcdev, child, r));
	}

	static void
	diff --git a/sys/dev/fdt/simplebus.c b/sys/dev/fdt/simplebus.c
	--- a/sys/dev/fdt/simplebus.c
	+++ b/sys/dev/fdt/simplebus.c
	@@ -46,8 +46,6 @@
	static int simplebus_probe(device_t dev);
	static struct resource *simplebus_alloc_resource(device_t, device_t, int,
	int *, rman_res_t, rman_res_t, rman_res_t, u_int);
	-static int simplebus_release_resource(device_t bus, device_t child,
	- int type, int rid, struct resource *r);
	static void simplebus_probe_nomatch(device_t bus, device_t child);
	static int simplebus_print_child(device_t bus, device_t child);
	static device_t simplebus_add_child(device_t dev, u_int order,
	@@ -85,7 +83,7 @@
	DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
	DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
	DEVMETHOD(bus_alloc_resource, simplebus_alloc_resource),
	- DEVMETHOD(bus_release_resource, simplebus_release_resource),
	+ DEVMETHOD(bus_release_resource, bus_generic_release_resource),
	DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
	DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
	DEVMETHOD(bus_adjust_resource, bus_generic_adjust_resource),
	@@ -485,16 +483,6 @@
	count, flags));
	}

	-static int
	-simplebus_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	-{
	-
	- if (type == SYS_RES_IOPORT)
	- type = SYS_RES_MEMORY;
	- return (bus_generic_release_resource(bus, child, type, rid, r));
	-}
	-
	static int
	simplebus_print_res(struct simplebus_devinfo *di)
	{
	diff --git a/sys/dev/hyperv/pcib/vmbus_pcib.c b/sys/dev/hyperv/pcib/vmbus_pcib.c
	--- a/sys/dev/hyperv/pcib/vmbus_pcib.c
	+++ b/sys/dev/hyperv/pcib/vmbus_pcib.c
	@@ -1724,19 +1724,18 @@
	}

	static int
	-vmbus_pcib_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+vmbus_pcib_release_resource(device_t dev, device_t child, struct resource *r)
	{
	struct vmbus_pcib_softc *sc = device_get_softc(dev);

	- if (type == PCI_RES_BUS)
	- return (pci_domain_release_bus(sc->hbus->pci_domain, child,
	- rid, r));
	-
	- if (type == SYS_RES_IOPORT)
	+ switch (rman_get_type(r)) {
	+ case PCI_RES_BUS:
	+ return (pci_domain_release_bus(sc->hbus->pci_domain, child, r));
	+ case SYS_RES_IOPORT:
	return (EINVAL);
	-
	- return (bus_generic_release_resource(dev, child, type, rid, r));
	+ default:
	+ return (bus_generic_release_resource(dev, child, r));
	+ }
	}

	static int
	diff --git a/sys/dev/mvs/mvs_pci.c b/sys/dev/mvs/mvs_pci.c
	--- a/sys/dev/mvs/mvs_pci.c
	+++ b/sys/dev/mvs/mvs_pci.c
	@@ -422,16 +422,15 @@
	}

	static int
	-mvs_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+mvs_release_resource(device_t dev, device_t child, struct resource *r)
	{

	- switch (type) {
	+ switch (rman_get_type(r)) {
	case SYS_RES_MEMORY:
	rman_release_resource(r);
	return (0);
	case SYS_RES_IRQ:
	- if (rid != ATA_IRQ_RID)
	+ if (rman_get_rid(r) != ATA_IRQ_RID)
	return ENOENT;
	return (0);
	}
	diff --git a/sys/dev/mvs/mvs_soc.c b/sys/dev/mvs/mvs_soc.c
	--- a/sys/dev/mvs/mvs_soc.c
	+++ b/sys/dev/mvs/mvs_soc.c
	@@ -366,11 +366,10 @@
	}

	static int
	-mvs_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+mvs_release_resource(device_t dev, device_t child, struct resource *r)
	{

	- switch (type) {
	+ switch (rman_get_type(r)) {
	case SYS_RES_MEMORY:
	rman_release_resource(r);
	return (0);
	diff --git a/sys/dev/ofw/ofw_pcib.c b/sys/dev/ofw/ofw_pcib.c
	--- a/sys/dev/ofw/ofw_pcib.c
	+++ b/sys/dev/ofw/ofw_pcib.c
	@@ -67,8 +67,7 @@
	static struct rman *ofw_pcib_get_rman(device_t, int, u_int);
	static struct resource * ofw_pcib_alloc_resource(device_t, device_t,
	int, int *, rman_res_t, rman_res_t, rman_res_t, u_int);
	-static int ofw_pcib_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int ofw_pcib_release_resource(device_t, device_t, struct resource *);
	static int ofw_pcib_activate_resource(device_t, device_t, struct resource *);
	static int ofw_pcib_deactivate_resource(device_t, device_t, struct resource *);
	static int ofw_pcib_adjust_resource(device_t, device_t,
	@@ -444,27 +443,23 @@
	}

	static int
	-ofw_pcib_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *res)
	+ofw_pcib_release_resource(device_t bus, device_t child, struct resource *res)
	{
	#if defined(NEW_PCIB) && defined(PCI_RES_BUS)
	struct ofw_pci_softc *sc;

	sc = device_get_softc(bus);
	#endif
	- switch (type) {
	+ switch (rman_get_type(res)) {
	#if defined(NEW_PCIB) && defined(PCI_RES_BUS)
	case PCI_RES_BUS:
	- return (pci_domain_release_bus(sc->sc_pci_domain, child, rid,
	- res));
	+ return (pci_domain_release_bus(sc->sc_pci_domain, child, res));
	#endif
	case SYS_RES_MEMORY:
	case SYS_RES_IOPORT:
	- return (bus_generic_rman_release_resource(bus, child, type, rid,
	- res));
	+ return (bus_generic_rman_release_resource(bus, child, res));
	default:
	- return (bus_generic_release_resource(bus, child, type, rid,
	- res));
	+ return (bus_generic_release_resource(bus, child, res));
	}
	}

	diff --git a/sys/dev/ofw/ofwbus.c b/sys/dev/ofw/ofwbus.c
	--- a/sys/dev/ofw/ofwbus.c
	+++ b/sys/dev/ofw/ofwbus.c
	@@ -170,8 +170,7 @@
	}

	static int
	-ofwbus_release_resource(device_t bus, device_t child, int type,
	- int rid, struct resource *r)
	+ofwbus_release_resource(device_t bus, device_t child, struct resource *r)
	{
	struct resource_list_entry *rle;
	bool passthrough;
	@@ -180,11 +179,11 @@
	if (!passthrough) {
	/* Clean resource list entry */
	rle = resource_list_find(BUS_GET_RESOURCE_LIST(bus, child),
	- type, rid);
	+ rman_get_type(r), rman_get_rid(r));
	if (rle != NULL)
	rle->res = NULL;
	}

	/* Let nexus handle the release. */
	- return (bus_generic_release_resource(bus, child, type, rid, r));
	+ return (bus_generic_release_resource(bus, child, r));
	}
	diff --git a/sys/dev/pccbb/pccbb.c b/sys/dev/pccbb/pccbb.c
	--- a/sys/dev/pccbb/pccbb.c
	+++ b/sys/dev/pccbb/pccbb.c
	@@ -162,7 +162,7 @@
	device_t child, int type, int *rid, rman_res_t start,
	rman_res_t end, rman_res_t count, u_int flags);
	static int cbb_cardbus_release_resource(device_t brdev, device_t child,
	- int type, int rid, struct resource *res);
	+ struct resource *res);
	static int cbb_cardbus_power_enable_socket(device_t brdev,
	device_t child);
	static int cbb_cardbus_power_disable_socket(device_t brdev,
	@@ -1263,20 +1263,20 @@
	}

	static int
	-cbb_cardbus_release_resource(device_t brdev, device_t child, int type,
	- int rid, struct resource *res)
	+cbb_cardbus_release_resource(device_t brdev, device_t child,
	+ struct resource *res)
	{
	struct cbb_softc *sc = device_get_softc(brdev);
	int error;

	if (rman_get_flags(res) & RF_ACTIVE) {
	- error = bus_deactivate_resource(child, type, rid, res);
	+ error = bus_deactivate_resource(child, res);
	if (error != 0)
	return (error);
	}
	cbb_remove_res(sc, res);
	return (BUS_RELEASE_RESOURCE(device_get_parent(brdev), child,
	- type, rid, res));
	+ res));
	}

	/************************************************************************/
	@@ -1424,20 +1424,20 @@
	}

	static int
	-cbb_pcic_release_resource(device_t brdev, device_t child, int type,
	- int rid, struct resource *res)
	+cbb_pcic_release_resource(device_t brdev, device_t child,
	+ struct resource *res)
	{
	struct cbb_softc *sc = device_get_softc(brdev);
	int error;

	if (rman_get_flags(res) & RF_ACTIVE) {
	- error = bus_deactivate_resource(child, type, rid, res);
	+ error = bus_deactivate_resource(child, res);
	if (error != 0)
	return (error);
	}
	cbb_remove_res(sc, res);
	return (BUS_RELEASE_RESOURCE(device_get_parent(brdev), child,
	- type, rid, res));
	+ res));
	}

	/************************************************************************/
	@@ -1519,17 +1519,14 @@
	}

	int
	-cbb_release_resource(device_t brdev, device_t child, int type, int rid,
	- struct resource *r)
	+cbb_release_resource(device_t brdev, device_t child, struct resource *r)
	{
	struct cbb_softc *sc = device_get_softc(brdev);

	if (sc->flags & CBB_16BIT_CARD)
	- return (cbb_pcic_release_resource(brdev, child, type,
	- rid, r));
	+ return (cbb_pcic_release_resource(brdev, child, r));
	else
	- return (cbb_cardbus_release_resource(brdev, child, type,
	- rid, r));
	+ return (cbb_cardbus_release_resource(brdev, child, r));
	}

	int
	diff --git a/sys/dev/pccbb/pccbb_pci.c b/sys/dev/pccbb/pccbb_pci.c
	--- a/sys/dev/pccbb/pccbb_pci.c
	+++ b/sys/dev/pccbb/pccbb_pci.c
	@@ -818,24 +818,23 @@
	}

	static int
	-cbb_pci_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	+cbb_pci_release_resource(device_t bus, device_t child, struct resource *r)
	{
	struct cbb_softc *sc;
	int error;

	sc = device_get_softc(bus);
	- if (type == PCI_RES_BUS) {
	+ if (rman_get_type(r) == PCI_RES_BUS) {
	if (!rman_is_region_manager(r, &sc->bus.rman))
	return (EINVAL);
	if (rman_get_flags(r) & RF_ACTIVE) {
	- error = bus_deactivate_resource(child, type, rid, r);
	+ error = bus_deactivate_resource(child, r);
	if (error)
	return (error);
	}
	return (rman_release_resource(r));
	}
	- return (cbb_release_resource(bus, child, type, rid, r));
	+ return (cbb_release_resource(bus, child, r));
	}
	#endif

	diff --git a/sys/dev/pccbb/pccbbvar.h b/sys/dev/pccbb/pccbbvar.h
	--- a/sys/dev/pccbb/pccbbvar.h
	+++ b/sys/dev/pccbb/pccbbvar.h
	@@ -130,7 +130,7 @@
	int cbb_read_ivar(device_t brdev, device_t child, int which,
	uintptr_t *result);
	int cbb_release_resource(device_t brdev, device_t child,
	- int type, int rid, struct resource *r);
	+ struct resource *r);
	int cbb_setup_intr(device_t dev, device_t child, struct resource *irq,
	int flags, driver_filter_t filt, driver_intr_t intr, void *arg,
	void **cookiep);
	diff --git a/sys/dev/pci/hostb_pci.c b/sys/dev/pci/hostb_pci.c
	--- a/sys/dev/pci/hostb_pci.c
	+++ b/sys/dev/pci/hostb_pci.c
	@@ -106,11 +106,10 @@
	}

	static int
	-pci_hostb_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+pci_hostb_release_resource(device_t dev, device_t child, struct resource *r)
	{

	- return (bus_release_resource(dev, type, rid, r));
	+ return (bus_release_resource(dev, r));
	}

	/* PCI interface. */
	diff --git a/sys/dev/pci/isa_pci.c b/sys/dev/pci/isa_pci.c
	--- a/sys/dev/pci/isa_pci.c
	+++ b/sys/dev/pci/isa_pci.c
	@@ -55,7 +55,7 @@
	device_t child, int type, int *rid, rman_res_t start, rman_res_t end,
	rman_res_t count, u_int flags);
	static int isab_pci_release_resource(device_t dev, device_t child,
	- int type, int rid, struct resource *r);
	+ struct resource *r);

	static device_method_t isab_methods[] = {
	/* Device interface */
	@@ -199,23 +199,22 @@
	}

	static int
	-isab_pci_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+isab_pci_release_resource(device_t dev, device_t child, struct resource *r)
	{
	struct isab_pci_softc *sc;
	int bar, error;

	if (device_get_parent(child) != dev)
	- return bus_generic_release_resource(dev, child, type, rid, r);
	+ return bus_generic_release_resource(dev, child, r);

	- switch (type) {
	+ switch (rman_get_type(r)) {
	case SYS_RES_MEMORY:
	case SYS_RES_IOPORT:
	/*
	* For BARs, we release the resource from the PCI bus
	* when the last child reference goes away.
	*/
	- bar = PCI_RID2BAR(rid);
	+ bar = PCI_RID2BAR(rman_get_rid(r));
	if (bar < 0 \|\| bar > PCIR_MAX_BAR_0)
	return (EINVAL);
	sc = device_get_softc(dev);
	@@ -229,7 +228,7 @@
	}
	KASSERT(sc->isab_pci_res[bar].ip_refs > 0,
	("isa_pci resource reference count underflow"));
	- error = bus_release_resource(dev, type, rid, r);
	+ error = bus_release_resource(dev, r);
	if (error == 0) {
	sc->isab_pci_res[bar].ip_res = NULL;
	sc->isab_pci_res[bar].ip_refs = 0;
	@@ -237,6 +236,5 @@
	return (error);
	}

	- return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, type,
	- rid, r));
	+ return (bus_generic_release_resource(dev, child, r));
	}
	diff --git a/sys/dev/pci/pci.c b/sys/dev/pci/pci.c
	--- a/sys/dev/pci/pci.c
	+++ b/sys/dev/pci/pci.c
	@@ -5636,29 +5636,26 @@
	}

	int
	-pci_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+pci_release_resource(device_t dev, device_t child, struct resource *r)
	{
	struct pci_devinfo *dinfo;
	struct resource_list *rl;
	pcicfgregs *cfg __unused;

	if (device_get_parent(child) != dev)
	- return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
	- type, rid, r));
	+ return (bus_generic_release_resource(dev, child, r));

	dinfo = device_get_ivars(child);
	cfg = &dinfo->cfg;

	#ifdef PCI_IOV
	if (cfg->flags & PCICFG_VF) {
	- switch (type) {
	+ switch (rman_get_type(r)) {
	/* VFs can't have I/O BARs. */
	case SYS_RES_IOPORT:
	return (EDOOFUS);
	case SYS_RES_MEMORY:
	- return (pci_vf_release_mem_resource(dev, child, rid,
	- r));
	+ return (pci_vf_release_mem_resource(dev, child, r));
	}

	/* Fall through for other types of resource allocations. */
	@@ -5671,19 +5668,19 @@
	* those allocations just pass the request up the tree.
	*/
	if (cfg->hdrtype == PCIM_HDRTYPE_BRIDGE &&
	- (type == SYS_RES_IOPORT \|\| type == SYS_RES_MEMORY)) {
	- switch (rid) {
	+ (rman_get_type(r) == SYS_RES_IOPORT \|\|
	+ rman_get_type(r) == SYS_RES_MEMORY)) {
	+ switch (rman_get_rid(r)) {
	case PCIR_IOBASEL_1:
	case PCIR_MEMBASE_1:
	case PCIR_PMBASEL_1:
	- return (bus_generic_release_resource(dev, child, type,
	- rid, r));
	+ return (bus_generic_release_resource(dev, child, r));
	}
	}
	#endif

	rl = &dinfo->resources;
	- return (resource_list_release(rl, dev, child, type, rid, r));
	+ return (resource_list_release(rl, dev, child, r));
	}

	int
	diff --git a/sys/dev/pci/pci_host_generic.h b/sys/dev/pci/pci_host_generic.h
	--- a/sys/dev/pci/pci_host_generic.h
	+++ b/sys/dev/pci/pci_host_generic.h
	@@ -95,7 +95,7 @@
	int pci_host_generic_core_detach(device_t);
	struct resource *pci_host_generic_core_alloc_resource(device_t, device_t, int,
	int *, rman_res_t, rman_res_t, rman_res_t, u_int);
	-int pci_host_generic_core_release_resource(device_t, device_t, int, int,
	+int pci_host_generic_core_release_resource(device_t, device_t,
	struct resource *);

	#endif /* __PCI_HOST_GENERIC_H_ */
	diff --git a/sys/dev/pci/pci_host_generic.c b/sys/dev/pci/pci_host_generic.c
	--- a/sys/dev/pci/pci_host_generic.c
	+++ b/sys/dev/pci/pci_host_generic.c
	@@ -428,26 +428,24 @@
	}

	int
	-pci_host_generic_core_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *res)
	+pci_host_generic_core_release_resource(device_t dev, device_t child,
	+ struct resource *res)
	{
	#if defined(NEW_PCIB) && defined(PCI_RES_BUS)
	struct generic_pcie_core_softc *sc;

	sc = device_get_softc(dev);
	#endif
	- switch (type) {
	+ switch (rman_get_type(res)) {
	#if defined(NEW_PCIB) && defined(PCI_RES_BUS)
	case PCI_RES_BUS:
	- return (pci_domain_release_bus(sc->ecam, child, rid, res));
	+ return (pci_domain_release_bus(sc->ecam, child, res));
	#endif
	case SYS_RES_IOPORT:
	case SYS_RES_MEMORY:
	- return (bus_generic_rman_release_resource(dev, child, type, rid,
	- res));
	+ return (bus_generic_rman_release_resource(dev, child, res));
	default:
	- return (bus_generic_release_resource(dev, child, type, rid,
	- res));
	+ return (bus_generic_release_resource(dev, child, res));
	}
	}

	diff --git a/sys/dev/pci/pci_iov.c b/sys/dev/pci/pci_iov.c
	--- a/sys/dev/pci/pci_iov.c
	+++ b/sys/dev/pci/pci_iov.c
	@@ -778,9 +778,7 @@

	for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
	if (iov->iov_bar[i].res != NULL) {
	- pci_release_resource(bus, dev, SYS_RES_MEMORY,
	- iov->iov_pos + PCIR_SRIOV_BAR(i),
	- iov->iov_bar[i].res);
	+ pci_release_resource(bus, dev, iov->iov_bar[i].res);
	pci_delete_resource(bus, dev, SYS_RES_MEMORY,
	iov->iov_pos + PCIR_SRIOV_BAR(i));
	iov->iov_bar[i].res = NULL;
	@@ -890,9 +888,7 @@

	for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
	if (iov->iov_bar[i].res != NULL) {
	- pci_release_resource(bus, dev, SYS_RES_MEMORY,
	- iov->iov_pos + PCIR_SRIOV_BAR(i),
	- iov->iov_bar[i].res);
	+ pci_release_resource(bus, dev, iov->iov_bar[i].res);
	pci_delete_resource(bus, dev, SYS_RES_MEMORY,
	iov->iov_pos + PCIR_SRIOV_BAR(i));
	iov->iov_bar[i].res = NULL;
	@@ -1066,21 +1062,21 @@
	}

	int
	-pci_vf_release_mem_resource(device_t dev, device_t child, int rid,
	- struct resource *r)
	+pci_vf_release_mem_resource(device_t dev, device_t child, struct resource *r)
	{
	struct pci_devinfo *dinfo;
	struct resource_list_entry *rle;
	- int error;
	+ int error, rid;

	dinfo = device_get_ivars(child);

	if (rman_get_flags(r) & RF_ACTIVE) {
	- error = bus_deactivate_resource(child, SYS_RES_MEMORY, rid, r);
	+ error = bus_deactivate_resource(child, r);
	if (error != 0)
	return (error);
	}

	+ rid = rman_get_rid(r);
	rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY, rid);
	if (rle != NULL) {
	rle->res = NULL;
	diff --git a/sys/dev/pci/pci_pci.c b/sys/dev/pci/pci_pci.c
	--- a/sys/dev/pci/pci_pci.c
	+++ b/sys/dev/pci/pci_pci.c
	@@ -2440,8 +2440,7 @@
	}

	static int
	-pcib_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+pcib_release_resource(device_t dev, device_t child, struct resource *r)
	{
	struct pcib_softc *sc;
	int error;
	@@ -2449,13 +2448,13 @@
	sc = device_get_softc(dev);
	if (pcib_is_resource_managed(sc, r)) {
	if (rman_get_flags(r) & RF_ACTIVE) {
	- error = bus_deactivate_resource(child, type, rid, r);
	+ error = bus_deactivate_resource(child, r);
	if (error)
	return (error);
	}
	return (rman_release_resource(r));
	}
	- return (bus_generic_release_resource(dev, child, type, rid, r));
	+ return (bus_generic_release_resource(dev, child, r));
	}

	static int
	diff --git a/sys/dev/pci/pci_private.h b/sys/dev/pci/pci_private.h
	--- a/sys/dev/pci/pci_private.h
	+++ b/sys/dev/pci/pci_private.h
	@@ -117,8 +117,8 @@
	struct resource *pci_alloc_resource(device_t dev, device_t child,
	int type, int *rid, rman_res_t start, rman_res_t end,
	rman_res_t count, u_int flags);
	-int pci_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *r);
	+int pci_release_resource(device_t dev, device_t child,
	+ struct resource *r);
	int pci_activate_resource(device_t dev, device_t child,
	struct resource *r);
	int pci_deactivate_resource(device_t dev, device_t child,
	@@ -183,5 +183,5 @@
	int *rid, rman_res_t start, rman_res_t end,
	rman_res_t count, u_int flags);
	int pci_vf_release_mem_resource(device_t dev, device_t child,
	- int rid, struct resource *r);
	+ struct resource *r);
	#endif /* _PCI_PRIVATE_H_ */
	diff --git a/sys/dev/pci/pci_subr.c b/sys/dev/pci/pci_subr.c
	--- a/sys/dev/pci/pci_subr.c
	+++ b/sys/dev/pci/pci_subr.c
	@@ -366,7 +366,7 @@
	}

	int
	-pci_domain_release_bus(int domain, device_t dev, int rid, struct resource *r)
	+pci_domain_release_bus(int domain, device_t dev, struct resource *r)
	{
	#ifdef INVARIANTS
	struct pci_domain *d;
	diff --git a/sys/dev/pci/pcib_private.h b/sys/dev/pci/pcib_private.h
	--- a/sys/dev/pci/pcib_private.h
	+++ b/sys/dev/pci/pcib_private.h
	@@ -158,7 +158,7 @@
	rman_res_t start, rman_res_t end, rman_res_t count, u_int flags);
	int pci_domain_adjust_bus(int domain, device_t dev,
	struct resource *r, rman_res_t start, rman_res_t end);
	-int pci_domain_release_bus(int domain, device_t dev, int rid,
	+int pci_domain_release_bus(int domain, device_t dev,
	struct resource *r);
	int pci_domain_activate_bus(int domain, device_t dev,
	struct resource *r);
	diff --git a/sys/dev/pci/vga_pci.c b/sys/dev/pci/vga_pci.c
	--- a/sys/dev/pci/vga_pci.c
	+++ b/sys/dev/pci/vga_pci.c
	@@ -69,8 +69,8 @@
	static struct resource *vga_pci_alloc_resource(device_t dev, device_t child,
	int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count,
	u_int flags);
	-static int vga_pci_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *r);
	+static int vga_pci_release_resource(device_t dev, device_t child,
	+ struct resource *r);

	int vga_pci_default_unit = -1;
	SYSCTL_INT(_hw_pci, OID_AUTO, default_vgapci_unit, CTLFLAG_RDTUN,
	@@ -241,8 +241,7 @@
	rom_addr \|= rman_get_start(res) \| 0x1;
	pci_write_config(dev, rid, rom_addr, 4);
	vr = lookup_res(device_get_softc(dev), rid);
	- vga_pci_release_resource(dev, NULL, SYS_RES_MEMORY, rid,
	- vr->vr_res);
	+ vga_pci_release_resource(dev, NULL, vr->vr_res);

	/*
	* re-allocate
	@@ -265,8 +264,7 @@
	return (__DEVOLATILE(void *, bios));
	device_printf(dev, "ROM mapping failed\n");
	vr = lookup_res(device_get_softc(dev), rid);
	- vga_pci_release_resource(dev, NULL, SYS_RES_MEMORY, rid,
	- vr->vr_res);
	+ vga_pci_release_resource(dev, NULL, vr->vr_res);
	return (NULL);
	}

	@@ -309,8 +307,7 @@
	KASSERT(vr->vr_res != NULL, ("vga_pci_unmap_bios: bios not mapped"));
	KASSERT(rman_get_virtual(vr->vr_res) == bios,
	("vga_pci_unmap_bios: mismatch"));
	- vga_pci_release_resource(dev, NULL, SYS_RES_MEMORY, rid,
	- vr->vr_res);
	+ vga_pci_release_resource(dev, NULL, vr->vr_res);
	}

	int
	@@ -478,20 +475,19 @@
	}

	static int
	-vga_pci_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+vga_pci_release_resource(device_t dev, device_t child, struct resource *r)
	{
	struct vga_resource *vr;
	int error;

	- switch (type) {
	+ switch (rman_get_type(r)) {
	case SYS_RES_MEMORY:
	case SYS_RES_IOPORT:
	/*
	* For BARs, we release the resource from the PCI bus
	* when the last child reference goes away.
	*/
	- vr = lookup_res(device_get_softc(dev), rid);
	+ vr = lookup_res(device_get_softc(dev), rman_get_rid(r));
	if (vr == NULL)
	return (EINVAL);
	if (vr->vr_res == NULL)
	@@ -503,7 +499,7 @@
	}
	KASSERT(vr->vr_refs > 0,
	("vga_pci resource reference count underflow"));
	- error = bus_release_resource(dev, type, rid, r);
	+ error = bus_release_resource(dev, r);
	if (error == 0) {
	vr->vr_res = NULL;
	vr->vr_refs = 0;
	@@ -511,7 +507,7 @@
	return (error);
	}

	- return (bus_release_resource(dev, type, rid, r));
	+ return (bus_release_resource(dev, r));
	}

	/* PCI interface. */
	diff --git a/sys/dev/ppc/ppc.c b/sys/dev/ppc/ppc.c
	--- a/sys/dev/ppc/ppc.c
	+++ b/sys/dev/ppc/ppc.c
	@@ -1976,22 +1976,12 @@
	}

	int
	-ppc_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	+ppc_release_resource(device_t bus, device_t child, struct resource *r)
	{
	-#ifdef INVARIANTS
	struct ppc_data *ppc = DEVTOSOFTC(bus);
	-#endif

	- switch (type) {
	- case SYS_RES_IRQ:
	- if (rid == 0) {
	- KASSERT(r == ppc->res_irq,
	- ("ppc child IRQ resource mismatch"));
	- return (0);
	- }
	- break;
	- }
	+ if (r == ppc->res_irq)
	+ return (0);
	return (EINVAL);
	}

	diff --git a/sys/dev/ppc/ppcvar.h b/sys/dev/ppc/ppcvar.h
	--- a/sys/dev/ppc/ppcvar.h
	+++ b/sys/dev/ppc/ppcvar.h
	@@ -42,8 +42,7 @@

	struct resource *ppc_alloc_resource(device_t bus, device_t child, int type,
	int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags);
	-int ppc_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r);
	+int ppc_release_resource(device_t bus, device_t child, struct resource *r);
	int ppc_reset_epp(device_t);
	int ppc_ecp_sync(device_t);
	int ppc_setmode(device_t, int);
	diff --git a/sys/dev/puc/puc.c b/sys/dev/puc/puc.c
	--- a/sys/dev/puc/puc.c
	+++ b/sys/dev/puc/puc.c
	@@ -526,8 +526,7 @@
	}

	int
	-puc_bus_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *res)
	+puc_bus_release_resource(device_t dev, device_t child, struct resource *res)
	{
	struct puc_port *port;
	device_t originator;
	@@ -542,18 +541,13 @@
	port = device_get_ivars(child);
	KASSERT(port != NULL, ("%s %d", __func__, __LINE__));

	- if (rid != 0 \|\| res == NULL)
	+ if (res == NULL)
	return (EINVAL);

	- if (type == port->p_bar->b_type) {
	- if (res != port->p_rres)
	- return (EINVAL);
	- } else if (type == SYS_RES_IRQ) {
	- if (res != port->p_ires)
	- return (EINVAL);
	+ if (res == port->p_ires) {
	if (port->p_hasintr)
	return (EBUSY);
	- } else
	+ } else if (res != port->p_rres)
	return (EINVAL);

	if (rman_get_device(res) != originator)
	diff --git a/sys/dev/puc/puc_bfe.h b/sys/dev/puc/puc_bfe.h
	--- a/sys/dev/puc/puc_bfe.h
	+++ b/sys/dev/puc/puc_bfe.h
	@@ -89,7 +89,7 @@
	int puc_bus_get_resource(device_t, device_t, int, int, rman_res_t , rman_res_t );
	int puc_bus_print_child(device_t, device_t);
	int puc_bus_read_ivar(device_t, device_t, int, uintptr_t *);
	-int puc_bus_release_resource(device_t, device_t, int, int, struct resource *);
	+int puc_bus_release_resource(device_t, device_t, struct resource *);
	int puc_bus_setup_intr(device_t, device_t, struct resource *, int,
	driver_filter_t , driver_intr_t , void , void *);
	int puc_bus_teardown_intr(device_t, device_t, struct resource , void );
	diff --git a/sys/dev/quicc/quicc_bfe.h b/sys/dev/quicc/quicc_bfe.h
	--- a/sys/dev/quicc/quicc_bfe.h
	+++ b/sys/dev/quicc/quicc_bfe.h
	@@ -64,7 +64,7 @@
	int quicc_bus_get_resource(device_t, device_t, int, int,
	rman_res_t , rman_res_t );
	int quicc_bus_read_ivar(device_t, device_t, int, uintptr_t *);
	-int quicc_bus_release_resource(device_t, device_t, int, int, struct resource *);
	+int quicc_bus_release_resource(device_t, device_t, struct resource *);
	int quicc_bus_setup_intr(device_t, device_t, struct resource *, int,
	driver_filter_t , void ()(void ), void , void **);
	int quicc_bus_teardown_intr(device_t, device_t, struct resource , void );
	diff --git a/sys/dev/quicc/quicc_core.c b/sys/dev/quicc/quicc_core.c
	--- a/sys/dev/quicc/quicc_core.c
	+++ b/sys/dev/quicc/quicc_core.c
	@@ -333,8 +333,7 @@
	}

	int
	-quicc_bus_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *res)
	+quicc_bus_release_resource(device_t dev, device_t child, struct resource *res)
	{
	struct quicc_device *qd;
	struct resource_list_entry *rle;
	@@ -343,7 +342,8 @@
	return (EINVAL);

	qd = device_get_ivars(child);
	- rle = resource_list_find(&qd->qd_rlist, type, rid);
	+ rle = resource_list_find(&qd->qd_rlist, rman_get_type(res),
	+ rman_get_rid(res));
	return ((rle == NULL) ? EINVAL : 0);
	}

	diff --git a/sys/dev/scc/scc_bfe.h b/sys/dev/scc/scc_bfe.h
	--- a/sys/dev/scc/scc_bfe.h
	+++ b/sys/dev/scc/scc_bfe.h
	@@ -145,7 +145,7 @@
	rman_res_t, rman_res_t, rman_res_t, u_int);
	int scc_bus_get_resource(device_t, device_t, int, int, rman_res_t , rman_res_t );
	int scc_bus_read_ivar(device_t, device_t, int, uintptr_t *);
	-int scc_bus_release_resource(device_t, device_t, int, int, struct resource *);
	+int scc_bus_release_resource(device_t, device_t, struct resource *);
	int scc_bus_setup_intr(device_t, device_t, struct resource *, int,
	driver_filter_t , void ()(void ), void , void **);
	int scc_bus_teardown_intr(device_t, device_t, struct resource , void );
	diff --git a/sys/dev/scc/scc_core.c b/sys/dev/scc/scc_core.c
	--- a/sys/dev/scc/scc_core.c
	+++ b/sys/dev/scc/scc_core.c
	@@ -495,8 +495,7 @@
	}

	int
	-scc_bus_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *res)
	+scc_bus_release_resource(device_t dev, device_t child, struct resource *res)
	{
	struct resource_list_entry *rle;
	struct scc_chan *ch;
	@@ -507,7 +506,8 @@

	m = device_get_ivars(child);
	ch = m->m_chan;
	- rle = resource_list_find(&ch->ch_rlist, type, rid);
	+ rle = resource_list_find(&ch->ch_rlist, rman_get_type(res),
	+ rman_get_rid(res));
	return ((rle == NULL) ? EINVAL : 0);
	}

	diff --git a/sys/dev/siis/siis.c b/sys/dev/siis/siis.c
	--- a/sys/dev/siis/siis.c
	+++ b/sys/dev/siis/siis.c
	@@ -346,16 +346,15 @@
	}

	static int
	-siis_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+siis_release_resource(device_t dev, device_t child, struct resource *r)
	{

	- switch (type) {
	+ switch (rman_get_type(r)) {
	case SYS_RES_MEMORY:
	rman_release_resource(r);
	return (0);
	case SYS_RES_IRQ:
	- if (rid != ATA_IRQ_RID)
	+ if (rman_get_rid(r) != ATA_IRQ_RID)
	return ENOENT;
	return (0);
	}
	diff --git a/sys/dev/sound/pci/csa.c b/sys/dev/sound/pci/csa.c
	--- a/sys/dev/sound/pci/csa.c
	+++ b/sys/dev/sound/pci/csa.c
	@@ -83,8 +83,7 @@
	static struct resource csa_alloc_resource(device_t bus, device_t child, int type, int rid,
	rman_res_t start, rman_res_t end,
	rman_res_t count, u_int flags);
	-static int csa_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r);
	+static int csa_release_resource(device_t bus, device_t child, struct resource *r);
	static int csa_setup_intr(device_t bus, device_t child,
	struct resource *irq, int flags,
	driver_filter_t *filter,
	@@ -430,8 +429,7 @@
	}

	static int
	-csa_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	+csa_release_resource(device_t bus, device_t child, struct resource *r)
	{
	return (0);
	}
	diff --git a/sys/dev/sound/pci/fm801.c b/sys/dev/sound/pci/fm801.c
	--- a/sys/dev/sound/pci/fm801.c
	+++ b/sys/dev/sound/pci/fm801.c
	@@ -728,8 +728,7 @@
	}

	static int
	-fm801_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	+fm801_release_resource(device_t bus, device_t child, struct resource *r)
	{
	return (0);
	}
	diff --git a/sys/dev/vmd/vmd.c b/sys/dev/vmd/vmd.c
	--- a/sys/dev/vmd/vmd.c
	+++ b/sys/dev/vmd/vmd.c
	@@ -480,15 +480,13 @@
	}

	static int
	-vmd_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+vmd_release_resource(device_t dev, device_t child, struct resource *r)
	{

	- if (type == SYS_RES_IRQ) {
	- return (bus_generic_release_resource(dev, child, type, rid,
	- r));
	+ if (rman_get_type(r) == SYS_RES_IRQ) {
	+ return (bus_generic_release_resource(dev, child, r));
	}
	- return (bus_generic_rman_release_resource(dev, child, type, rid, r));
	+ return (bus_generic_rman_release_resource(dev, child, r));
	}

	static int
	diff --git a/sys/isa/isa_common.h b/sys/isa/isa_common.h
	--- a/sys/isa/isa_common.h
	+++ b/sys/isa/isa_common.h
	@@ -72,6 +72,6 @@
	int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count,
	u_int flags);
	extern int isa_release_resource(device_t bus, device_t child,
	- int type, int rid, struct resource *r);
	+ struct resource *r);

	extern driver_t isa_driver;
	diff --git a/sys/isa/isa_common.c b/sys/isa/isa_common.c
	--- a/sys/isa/isa_common.c
	+++ b/sys/isa/isa_common.c
	@@ -909,8 +909,6 @@
	STAILQ_FOREACH(rle, &idev->id_resources, link) {
	if (rle->res)
	resource_list_release(rl, dev, child,
	- rle->type,
	- rle->rid,
	rle->res);
	}

	diff --git a/sys/kern/bus_if.m b/sys/kern/bus_if.m
	--- a/sys/kern/bus_if.m
	+++ b/sys/kern/bus_if.m
	@@ -427,15 +427,11 @@
	*
	* @param _dev the parent device of @p _child
	* @param _child the device which allocated the resource
	- * @param _type the type of resource
	- * @param _rid the resource identifier
	* @param _r the resource to release
	*/
	METHOD int release_resource {
	device_t _dev;
	device_t _child;
	- int _type;
	- int _rid;
	struct resource *_res;
	};

	diff --git a/sys/kern/subr_bus.c b/sys/kern/subr_bus.c
	--- a/sys/kern/subr_bus.c
	+++ b/sys/kern/subr_bus.c
	@@ -3133,8 +3133,6 @@
	* @param rl the resource list which was allocated from
	* @param bus the parent device of @p child
	* @param child the device which is requesting a release
	- * @param type the type of resource to release
	- * @param rid the resource identifier
	* @param res the resource to release
	*
	* @retval 0 success
	@@ -3143,7 +3141,7 @@
	*/
	int
	resource_list_release(struct resource_list *rl, device_t bus, device_t child,
	- int type, int rid, struct resource *res)
	+ struct resource *res)
	{
	struct resource_list_entry *rle = NULL;
	int passthrough = (device_get_parent(child) != bus);
	@@ -3151,10 +3149,10 @@

	if (passthrough) {
	return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
	- type, rid, res));
	+ res));
	}

	- rle = resource_list_find(rl, type, rid);
	+ rle = resource_list_find(rl, rman_get_type(res), rman_get_rid(res));

	if (!rle)
	panic("resource_list_release: can't find resource");
	@@ -3163,8 +3161,7 @@
	if (rle->flags & RLE_RESERVED) {
	if (rle->flags & RLE_ALLOCATED) {
	if (rman_get_flags(res) & RF_ACTIVE) {
	- error = bus_deactivate_resource(child, type,
	- rid, res);
	+ error = bus_deactivate_resource(child, res);
	if (error)
	return (error);
	}
	@@ -3174,8 +3171,7 @@
	return (EINVAL);
	}

	- error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
	- type, rid, res);
	+ error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, res);
	if (error)
	return (error);

	@@ -3215,8 +3211,7 @@
	RLE_RESERVED)
	continue;
	retval = EBUSY;
	- error = resource_list_release(rl, bus, child, type,
	- rman_get_rid(rle->res), rle->res);
	+ error = resource_list_release(rl, bus, child, rle->res);
	if (error != 0)
	device_printf(bus,
	"Failed to release active resource: %d\n", error);
	@@ -3260,7 +3255,7 @@
	if (rle->flags & RLE_ALLOCATED)
	return (EBUSY);
	rle->flags &= ~RLE_RESERVED;
	- return (resource_list_release(rl, bus, child, type, rid, rle->res));
	+ return (resource_list_release(rl, bus, child, rle->res));
	}

	/**
	@@ -3928,13 +3923,11 @@
	* BUS_RELEASE_RESOURCE() method of the parent of @p dev.
	*/
	int
	-bus_generic_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+bus_generic_release_resource(device_t dev, device_t child, struct resource *r)
	{
	/* Propagate up the bus hierarchy until someone handles it. */
	if (dev->parent)
	- return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid,
	- r));
	+ return (BUS_RELEASE_RESOURCE(dev->parent, child, r));
	return (EINVAL);
	}

	@@ -4180,20 +4173,19 @@
	* BUS_GET_RESOURCE_LIST() to find a suitable resource list.
	*/
	int
	-bus_generic_rl_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *r)
	+bus_generic_rl_release_resource(device_t dev, device_t child,
	+ struct resource *r)
	{
	struct resource_list * rl = NULL;

	if (device_get_parent(child) != dev)
	- return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
	- type, rid, r));
	+ return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, r));

	rl = BUS_GET_RESOURCE_LIST(dev, child);
	if (!rl)
	return (EINVAL);

	- return (resource_list_release(rl, dev, child, type, rid, r));
	+ return (resource_list_release(rl, dev, child, r));
	}

	/**
	@@ -4284,8 +4276,8 @@
	* allocated by bus_generic_rman_alloc_resource.
	*/
	int
	-bus_generic_rman_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *r)
	+bus_generic_rman_release_resource(device_t dev, device_t child,
	+ struct resource *r)
	{
	#ifdef INVARIANTS
	struct rman *rm;
	@@ -4293,13 +4285,13 @@
	int error;

	#ifdef INVARIANTS
	- rm = BUS_GET_RMAN(dev, type, rman_get_flags(r));
	+ rm = BUS_GET_RMAN(dev, rman_get_type(r), rman_get_flags(r));
	KASSERT(rman_is_region_manager(r, rm),
	("%s: rman %p doesn't match for resource %p", __func__, rm, r));
	#endif

	if (rman_get_flags(r) & RF_ACTIVE) {
	- error = bus_deactivate_resource(child, type, rid, r);
	+ error = bus_deactivate_resource(child, r);
	if (error != 0)
	return (error);
	}
	@@ -4653,21 +4645,20 @@
	* parent of @p dev.
	*/
	int
	-bus_release_resource(device_t dev, int type, int rid, struct resource *r)
	+bus_release_resource(device_t dev, struct resource *r)
	{
	int rv;

	if (dev->parent == NULL)
	return (EINVAL);
	- rv = BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r);
	+ rv = BUS_RELEASE_RESOURCE(dev->parent, dev, r);
	return (rv);
	}

	int
	-bus_release_resource_new(device_t dev, struct resource *r)
	+bus_release_resource_old(device_t dev, int type, int rid, struct resource *r)
	{
	- return (bus_release_resource(dev, rman_get_type(r), rman_get_rid(r),
	- r));
	+ return (bus_release_resource(dev, r));
	}

	/**
	diff --git a/sys/powerpc/mpc85xx/isa.c b/sys/powerpc/mpc85xx/isa.c
	--- a/sys/powerpc/mpc85xx/isa.c
	+++ b/sys/powerpc/mpc85xx/isa.c
	@@ -73,11 +73,10 @@
	}

	int
	-isa_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	+isa_release_resource(device_t bus, device_t child, struct resource *r)
	{
	struct isa_device* idev = DEVTOISA(child);
	struct resource_list *rl = &idev->id_resources;

	- return (resource_list_release(rl, bus, child, type, rid, r));
	+ return (resource_list_release(rl, bus, child, r));
	}
	diff --git a/sys/powerpc/mpc85xx/lbc.c b/sys/powerpc/mpc85xx/lbc.c
	--- a/sys/powerpc/mpc85xx/lbc.c
	+++ b/sys/powerpc/mpc85xx/lbc.c
	@@ -83,8 +83,7 @@
	static int lbc_adjust_resource(device_t, device_t, struct resource *,
	rman_res_t, rman_res_t);
	static int lbc_print_child(device_t, device_t);
	-static int lbc_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int lbc_release_resource(device_t, device_t, struct resource *);
	static const struct ofw_bus_devinfo *lbc_get_devinfo(device_t, device_t);

	/*
	@@ -776,18 +775,13 @@
	}

	static int
	-lbc_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *res)
	+lbc_release_resource(device_t dev, device_t child, struct resource *res)
	{
	- switch (type) {
	- case SYS_RES_IOPORT:
	- type = SYS_RES_MEMORY;
	- /* FALLTHROUGH */
	+ switch (rman_get_type(res)) {
	case SYS_RES_MEMORY:
	- return (bus_generic_rman_release_resource(dev, child, type,
	- rid, res));
	+ return (bus_generic_rman_release_resource(dev, child, res));
	case SYS_RES_IRQ:
	- return (bus_generic_release_resource(dev, child, type, rid, res));
	+ return (bus_generic_release_resource(dev, child, res));
	default:
	return (EINVAL);
	}
	diff --git a/sys/powerpc/powermac/macio.c b/sys/powerpc/powermac/macio.c
	--- a/sys/powerpc/powermac/macio.c
	+++ b/sys/powerpc/powermac/macio.c
	@@ -88,8 +88,7 @@
	rman_res_t, rman_res_t);
	static int macio_activate_resource(device_t, device_t, struct resource *);
	static int macio_deactivate_resource(device_t, device_t, struct resource *);
	-static int macio_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int macio_release_resource(device_t, device_t, struct resource *);
	static int macio_map_resource(device_t, device_t, struct resource *,
	struct resource_map_request *,
	struct resource_map *);
	@@ -610,17 +609,14 @@
	}

	static int
	-macio_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *res)
	+macio_release_resource(device_t bus, device_t child, struct resource *res)
	{
	- switch (type) {
	+ switch (rman_get_type(res)) {
	case SYS_RES_IOPORT:
	case SYS_RES_MEMORY:
	- return (bus_generic_rman_release_resource(bus, child, type, rid,
	- res));
	+ return (bus_generic_rman_release_resource(bus, child, res));
	case SYS_RES_IRQ:
	- return (bus_generic_rl_release_resource(bus, child, type, rid,
	- res));
	+ return (bus_generic_rl_release_resource(bus, child, res));
	default:
	return (EINVAL);
	}
	diff --git a/sys/powerpc/powermac/uninorth.c b/sys/powerpc/powermac/uninorth.c
	--- a/sys/powerpc/powermac/uninorth.c
	+++ b/sys/powerpc/powermac/uninorth.c
	@@ -87,8 +87,7 @@
	struct resource_map *);
	static int unin_chip_unmap_resource(device_t, device_t, struct resource *,
	struct resource_map *);
	-static int unin_chip_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int unin_chip_release_resource(device_t, device_t, struct resource *);
	static struct resource_list *unin_chip_get_resource_list (device_t, device_t);

	/*
	@@ -570,17 +569,14 @@
	}

	static int
	-unin_chip_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *res)
	+unin_chip_release_resource(device_t bus, device_t child, struct resource *res)
	{
	- switch (type) {
	+ switch (rman_get_type(res)) {
	case SYS_RES_IOPORT:
	case SYS_RES_MEMORY:
	- return (bus_generic_rman_release_resource(bus, child, type, rid,
	- res));
	+ return (bus_generic_rman_release_resource(bus, child, res));
	case SYS_RES_IRQ:
	- return (bus_generic_rl_release_resource(bus, child, type, rid,
	- res));
	+ return (bus_generic_rl_release_resource(bus, child, res));
	default:
	return (EINVAL);
	}
	diff --git a/sys/powerpc/psim/ata_iobus.c b/sys/powerpc/psim/ata_iobus.c
	--- a/sys/powerpc/psim/ata_iobus.c
	+++ b/sys/powerpc/psim/ata_iobus.c
	@@ -61,8 +61,7 @@
	struct resource ata_iobus_alloc_resource(device_t, device_t, int, int ,
	rman_res_t, rman_res_t, rman_res_t,
	u_int);
	-static int ata_iobus_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int ata_iobus_release_resource(device_t, device_t, struct resource *);

	static device_method_t ata_iobus_methods[] = {
	/* Device interface */
	@@ -192,8 +191,7 @@
	}

	static int
	-ata_iobus_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+ata_iobus_release_resource(device_t dev, device_t child, struct resource *r)
	{
	/* no hotplug... */
	return (0);
	diff --git a/sys/powerpc/psim/iobus.c b/sys/powerpc/psim/iobus.c
	--- a/sys/powerpc/psim/iobus.c
	+++ b/sys/powerpc/psim/iobus.c
	@@ -83,8 +83,7 @@
	struct resource_map *);
	static int iobus_unmap_resource(device_t, device_t, struct resource *,
	struct resource_map *);
	-static int iobus_release_resource(device_t, device_t, int, int,
	- struct resource *);
	+static int iobus_release_resource(device_t, device_t, struct resource *);

	/*
	* Bus interface definition
	@@ -357,17 +356,15 @@
	}

	static int
	-iobus_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *res)
	+iobus_release_resource(device_t bus, device_t child, struct resource *res)
	{

	- switch (type) {
	+ switch (rman_get_type(res)) {
	case SYS_RES_MEMORY:
	case SYS_RES_IOPORT:
	- return (bus_generic_rman_release_resource(bus, child, type, rid,
	- res));
	+ return (bus_generic_rman_release_resource(bus, child, res));
	case SYS_RES_IRQ:
	- return (bus_generic_release_resource(bus, child, type, rid, res));
	+ return (bus_generic_release_resource(bus, child, res));
	default:
	return (EINVAL);
	}
	diff --git a/sys/sys/bus.h b/sys/sys/bus.h
	--- a/sys/sys/bus.h
	+++ b/sys/sys/bus.h
	@@ -396,7 +396,7 @@
	rman_res_t count, u_int flags);
	int resource_list_release(struct resource_list *rl,
	device_t bus, device_t child,
	- int type, int rid, struct resource *res);
	+ struct resource *res);
	int resource_list_release_active(struct resource_list *rl,
	device_t bus, device_t child,
	int type);
	@@ -481,7 +481,7 @@
	int bus_generic_read_ivar(device_t dev, device_t child, int which,
	uintptr_t *result);
	int bus_generic_release_resource(device_t bus, device_t child,
	- int type, int rid, struct resource *r);
	+ struct resource *r);
	int bus_generic_resume(device_t dev);
	int bus_generic_resume_child(device_t dev, device_t child);
	int bus_generic_setup_intr(device_t dev, device_t child,
	@@ -497,8 +497,7 @@
	rman_res_t *);
	int bus_generic_rl_set_resource (device_t, device_t, int, int, rman_res_t,
	rman_res_t);
	-int bus_generic_rl_release_resource (device_t, device_t, int, int,
	- struct resource *);
	+int bus_generic_rl_release_resource (device_t, device_t, struct resource *);
	struct resource *
	bus_generic_rman_alloc_resource(device_t dev, device_t child, int type,
	int *rid, rman_res_t start,
	@@ -508,7 +507,6 @@
	struct resource *r, rman_res_t start,
	rman_res_t end);
	int bus_generic_rman_release_resource(device_t dev, device_t child,
	- int type, int rid,
	struct resource *r);
	int bus_generic_rman_activate_resource(device_t dev, device_t child,
	struct resource *r);
	@@ -571,8 +569,7 @@
	bus_dma_tag_t bus_get_dma_tag(device_t dev);
	bus_space_tag_t bus_get_bus_tag(device_t dev);
	int bus_get_domain(device_t dev, int *domain);
	-int bus_release_resource(device_t dev, int type, int rid,
	- struct resource *r);
	+int bus_release_resource(device_t dev, struct resource *r);
	int bus_free_resource(device_t dev, int type, struct resource *r);
	int bus_setup_intr(device_t dev, struct resource *r, int flags,
	driver_filter_t filter, driver_intr_t handler,
	@@ -621,7 +618,8 @@
	struct resource_map *map);
	int bus_unmap_resource_old(device_t dev, int type, struct resource *r,
	struct resource_map *map);
	-int bus_release_resource_new(device_t dev, struct resource *r);
	+int bus_release_resource_old(device_t dev, int type, int rid,
	+ struct resource *r);

	#define _BUS_API_MACRO(_1, _2, _3, _4, _5, NAME, ...) NAME

	@@ -646,8 +644,8 @@
	bus_unmap_resource)(__VA_ARGS__)

	#define bus_release_resource(...) \
	- _BUS_API_MACRO(__VA_ARGS__, INVALID, bus_release_resource, \
	- INVALID, bus_release_resource_new)(__VA_ARGS__)
	+ _BUS_API_MACRO(__VA_ARGS__, INVALID, bus_release_resource_old, \
	+ INVALID, bus_release_resource)(__VA_ARGS__)

	/*
	* Access functions for device.
	diff --git a/sys/x86/include/legacyvar.h b/sys/x86/include/legacyvar.h
	--- a/sys/x86/include/legacyvar.h
	+++ b/sys/x86/include/legacyvar.h
	@@ -60,8 +60,8 @@
	u_int flags);
	int legacy_pcib_adjust_resource(device_t dev, device_t child,
	struct resource *r, rman_res_t start, rman_res_t end);
	-int legacy_pcib_release_resource(device_t dev, device_t child, int type,
	- int rid, struct resource *r);
	+int legacy_pcib_release_resource(device_t dev, device_t child,
	+ struct resource *r);
	int legacy_pcib_activate_resource(device_t dev, device_t child,
	struct resource *r);
	int legacy_pcib_deactivate_resource(device_t dev, device_t child,
	diff --git a/sys/x86/isa/isa.c b/sys/x86/isa/isa.c
	--- a/sys/x86/isa/isa.c
	+++ b/sys/x86/isa/isa.c
	@@ -130,13 +130,12 @@
	}

	int
	-isa_release_resource(device_t bus, device_t child, int type, int rid,
	- struct resource *r)
	+isa_release_resource(device_t bus, device_t child, struct resource *r)
	{
	struct isa_device* idev = DEVTOISA(child);
	struct resource_list *rl = &idev->id_resources;

	- return resource_list_release(rl, bus, child, type, rid, r);
	+ return resource_list_release(rl, bus, child, r);
	}

	/*
	diff --git a/sys/x86/pci/pci_bus.c b/sys/x86/pci/pci_bus.c
	--- a/sys/x86/pci/pci_bus.c
	+++ b/sys/x86/pci/pci_bus.c
	@@ -617,13 +617,12 @@
	}

	int
	-legacy_pcib_release_resource(device_t dev, device_t child, int type, int rid,
	- struct resource *r)
	+legacy_pcib_release_resource(device_t dev, device_t child, struct resource *r)
	{

	- if (type == PCI_RES_BUS)
	- return (pci_domain_release_bus(0, child, rid, r));
	- return (bus_generic_release_resource(dev, child, type, rid, r));
	+ if (rman_get_type(r) == PCI_RES_BUS)
	+ return (pci_domain_release_bus(0, child, r));
	+ return (bus_generic_release_resource(dev, child, r));
	}

	int

File Metadata

Mime Type: text/plain
Expires: Mon, Apr 28, 6:43 PM (10 h, 54 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 17832636
Default Alt Text: D44131.diff (67 KB)

D44131.diffNo OneTemporaryActions

D44131.diffView Options

File Metadata

Event Timeline

D44131.diff
No OneTemporary
Actions

D44131.diff
View Options