new-bus: Remove the 'rid' and 'type' arguments from BUS_RELEASE_RESOURCE

The public bus_release_resource() API still accepts both forms, but
the internal kobj method no longer passes the arguments.
Implementations which need the rid or type now use rman_get_rid() or
rman_get_type() to fetch the value from the allocated resource.

Reviewed by:	imp
Differential Revision:	https://reviews.freebsd.org/D44131

share/man/man9/bus_release_resource.9

@@ -26,7 +26,7 @@
 .\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 .\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 .\"
-.Dd May 18, 2000
+.Dd March 13, 2024
 .Dt BUS_RELEASE_RESOURCE 9
 .Os
 .Sh NAME
@@ -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 @@ for IRQs).
 .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 @@ The kernel will panic, if it cannot release the resource.
 	bus_teardown_intr(dev, foosoftc->irqres, foosoftc->irqid);
 
 	/* release IRQ resource */
-	bus_release_resource(dev, SYS_RES_IRQ, foosoftc->irqid,
+	bus_release_resource(dev, foosoftc->irqres);
-		foosoftc->irqres);
 
 	/* release I/O port resource */
-	bus_release_resource(dev, SYS_RES_IOPORT, foosoftc->portid,
+	bus_release_resource(dev, foosoftc->portres);
-		foosoftc->portres);
 .Ed
 .Sh SEE ALSO
 .Xr bus_alloc_resource 9 ,

sys/arm/mv/mv_pci.c

@@ -347,8 +347,7 @@ static struct resource *mv_pcib_alloc_resource(device_t, device_t, int, int *,
     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,
+static int mv_pcib_release_resource(device_t, device_t, struct resource *);
-    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 @@ mv_pcib_adjust_resource(device_t dev, device_t child,
 }
 
 static int
-mv_pcib_release_resource(device_t dev, device_t child, int type, int rid,
+mv_pcib_release_resource(device_t dev, device_t child, struct resource *res)
-    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,
+		return (bus_generic_rman_release_resource(dev, child, res));
-		    rid, 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,
+		return (bus_generic_release_resource(dev, child, res));
-		    type, rid, res));
 	}
 }
 

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 @@ thunder_pcie_fdt_alloc_resource(device_t dev, device_t child, int type,
 }
 
 static int
-thunder_pcie_fdt_release_resource(device_t dev, device_t child, int type,
+thunder_pcie_fdt_release_resource(device_t dev, device_t child,
-    int rid, struct resource *res)
+    struct resource *res)
 {
 
 	if ((int)ofw_bus_get_node(child) <= 0)
-		return (pci_host_generic_core_release_resource(dev, child, type,
+		return (pci_host_generic_core_release_resource(dev, child,
-		    rid, res));
+		    res));
 
-	return (bus_generic_release_resource(dev, child, type, rid, res));
+	return (bus_generic_release_resource(dev, child, res));
 }
 #endif

sys/arm64/cavium/thunder_pcie_pem.c

@@ -149,8 +149,7 @@ static uint32_t thunder_pem_read_config(device_t, u_int, u_int, u_int, u_int,
     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,
+static int thunder_pem_release_resource(device_t, device_t, struct resource *);
-    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 @@ thunder_pem_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-thunder_pem_release_resource(device_t dev, device_t child, int type, int rid,
+thunder_pem_release_resource(device_t dev, device_t child, struct resource *res)
-    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,
+		return (bus_generic_rman_release_resource(dev, child, res));
-		    rid, 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,
+		return (BUS_RELEASE_RESOURCE(parent_dev, child, res));
-		    type, rid, res));
 	}
 }
 

sys/dev/acpica/acpi.c

@@ -1580,17 +1580,16 @@ acpi_adjust_resource(device_t bus, device_t child, struct resource *r,
 }
 
 static int
-acpi_release_resource(device_t bus, device_t child, int type, int rid,
+acpi_release_resource(device_t bus, device_t child, struct resource *r)
-    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

sys/dev/acpica/acpi_pcib_acpi.c

@@ -101,8 +101,7 @@ static int		acpi_pcib_acpi_adjust_resource(device_t dev,
 			    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,
+			    device_t child, struct resource *r);
-			    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 @@ acpi_pcib_acpi_attach(device_t dev)
 			    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 @@ acpi_pcib_acpi_adjust_resource(device_t dev, device_t child,
 
 #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)
+	if (rman_get_type(r) == PCI_RES_BUS)
-		return (pci_domain_release_bus(sc->ap_segment, child, rid, r));
+		return (pci_domain_release_bus(sc->ap_segment, child, r));
-	return (bus_generic_release_resource(dev, child, type, rid, r));
+	return (bus_generic_release_resource(dev, child, r));
 }
 
 int

sys/dev/agp/agp_i810.c

@@ -2053,8 +2053,8 @@ agp_i915_chipset_flush_free_page(device_t dev)
 		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,
+	BUS_RELEASE_RESOURCE(device_get_parent(vga), dev,
-	    sc->sc_flush_page_rid, sc->sc_flush_page_res);
+	    sc->sc_flush_page_res);
 }
 
 static int

sys/dev/ahci/ahci.c

@@ -640,16 +640,15 @@ ahci_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 int
-ahci_release_resource(device_t dev, device_t child, int type, int rid,
+ahci_release_resource(device_t dev, device_t child, struct resource *r)
-    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);
 	}

sys/dev/ahci/ahci.h

@@ -656,8 +656,7 @@ int ahci_setup_interrupt(device_t dev);
 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,
+int ahci_release_resource(device_t dev, device_t child, struct resource *r);
-    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);

sys/dev/ata/ata-pci.c

@@ -273,24 +273,20 @@ ata_pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 int
-ata_pci_release_resource(device_t dev, device_t child, int type, int rid,
+ata_pci_release_resource(device_t dev, device_t child, struct resource *r)
-			 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,
+				r);
-				PCIR_BAR(1) + (unit << 3), r);
 			default:
 			    return ENOENT;
 			}
@@ -300,7 +296,7 @@ ata_pci_release_resource(device_t dev, device_t child, int type, int rid,
 				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 @@ ata_pci_release_resource(device_t dev, device_t child, int type, int rid,
 			return (0);
 		} else {
 			return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
-			    type, rid, r));
+			    r));
 		}
 	}
 	return (EINVAL);

sys/dev/ata/ata-pci.h

@@ -538,7 +538,7 @@ void ata_pci_write_config(device_t dev, device_t child, int reg,
 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);

sys/dev/atkbdc/atkbdc_isa.c

@@ -53,7 +53,7 @@ static struct resource *atkbdc_isa_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	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 @@ atkbdc_isa_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-atkbdc_isa_release_resource(device_t dev, device_t child, int type, int rid,
+atkbdc_isa_release_resource(device_t dev, device_t child, struct resource *r)
-    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);

sys/dev/bhnd/bhnd_subr.c

@@ -2241,7 +2241,7 @@ bhnd_bus_generic_alloc_resource(device_t dev, device_t child, int type,
 
 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 @@ bhnd_bus_generic_release_resource(device_t dev, device_t child, int type,
 {
 	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);

sys/dev/bhnd/bhndb/bhndb.c

@@ -1034,8 +1034,7 @@ bhndb_alloc_resource(device_t dev, device_t child, int type,
  * Default bhndb(4) implementation of BUS_RELEASE_RESOURCE().
  */
 static int
-bhndb_release_resource(device_t dev, device_t child, int type, int rid,
+bhndb_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 	struct bhndb_softc		*sc;
 	struct resource_list_entry	*rle;
@@ -1047,9 +1046,9 @@ bhndb_release_resource(device_t dev, device_t child, int type, int rid,
 
 	/* 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 @@ bhndb_release_resource(device_t dev, device_t child, int type, int rid,
 	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;
 	}

sys/dev/bhnd/cores/chipc/chipc.c

@@ -873,8 +873,7 @@ chipc_alloc_resource(device_t dev, device_t child, int type,
 }
 
 static int
-chipc_release_resource(device_t dev, device_t child, int type, int rid,
+chipc_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 	struct chipc_softc		*sc;
 	struct chipc_region		*cr;
@@ -885,10 +884,9 @@ chipc_release_resource(device_t dev, device_t child, int type, int rid,
 	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,
+		return (bus_generic_rl_release_resource(dev, child, r));
-		    r));
 	}
 
 	/* Locate the mapping region */
@@ -897,7 +895,7 @@ chipc_release_resource(device_t dev, device_t child, int type, int rid,
 		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_resource(device_t dev, device_t child, int type, int rid,
 	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;
 

sys/dev/bhnd/cores/usb/bhnd_usb.c

@@ -69,8 +69,7 @@ static struct resource *	bhnd_usb_alloc_resource(device_t bus,
 				    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,
+				    device_t child, struct resource *r);
-				    struct resource *r);
 
 static struct resource_list *	bhnd_usb_get_reslist(device_t dev,
 				    device_t child);
@@ -311,8 +310,8 @@ bhnd_usb_get_reslist(device_t dev, device_t child)
 }
 
 static int
-bhnd_usb_release_resource(device_t dev, device_t child, int type,
+bhnd_usb_release_resource(device_t dev, device_t child,
-    int rid, struct resource *r)
+    struct resource *r)
 {
 	struct bhnd_usb_softc		*sc;
 	struct resource_list_entry	*rle;
@@ -325,18 +324,17 @@ bhnd_usb_release_resource(device_t dev, device_t child, int type,
 	/* 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,
+		return (bus_generic_rl_release_resource(dev, child, r));
-		    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;
 	}

sys/dev/dpaa/fman.c

@@ -116,8 +116,7 @@ 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,
+fman_release_resource(device_t bus, device_t child, struct resource *res)
-    struct resource *res)
 {
 	struct resource_list *rl;
 	struct resource_list_entry *rle;
@@ -125,9 +124,9 @@ fman_release_resource(device_t bus, device_t child, int type, int rid,
 
 	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 @@ fman_release_resource(device_t bus, device_t child, int type, int rid,
 		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 @@ fman_release_resource(device_t bus, device_t child, int type, int rid,
 		}
 		return (0);
 	}
-	return (resource_list_release(rl, bus, child, type, rid, res));
+	return (resource_list_release(rl, bus, child, res));
 }
 
 struct resource *

sys/dev/dpaa/fman.h

@@ -57,8 +57,7 @@ struct resource * fman_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 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,
+int fman_release_resource(device_t bus, device_t child, struct resource *res);
-    struct resource *res);
 int	fman_attach(device_t dev);
 int	fman_detach(device_t dev);
 int	fman_suspend(device_t dev);

sys/dev/dpaa2/dpaa2_mc.c

@@ -356,16 +356,14 @@ dpaa2_mc_adjust_resource(device_t mcdev, device_t child,
 }
 
 int
-dpaa2_mc_release_resource(device_t mcdev, device_t child, int type, int rid,
+dpaa2_mc_release_resource(device_t mcdev, device_t child, struct resource *r)
-    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,
+		return (bus_generic_rman_release_resource(mcdev, child, r));
-		    rid, r));
+	return (bus_generic_release_resource(mcdev, child, r));
-	return (bus_generic_release_resource(mcdev, child, type, rid, r));
 }
 
 int

sys/dev/dpaa2/dpaa2_mc.h

@@ -185,8 +185,8 @@ struct resource * dpaa2_mc_alloc_resource(device_t mcdev, device_t child,
     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 dpaa2_mc_release_resource(device_t mcdev, device_t child,
-    int rid, struct resource *r);
+    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,

sys/dev/dpaa2/dpaa2_rc.c

@@ -263,19 +263,18 @@ dpaa2_rc_alloc_resource(device_t rcdev, device_t child, int type, int *rid,
 }
 
 static int
-dpaa2_rc_release_resource(device_t rcdev, device_t child, int type, int rid,
+dpaa2_rc_release_resource(device_t rcdev, device_t child, struct resource *r)
-    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

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 @@ static device_method_t	simplebus_methods[] = {
 	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 @@ simplebus_alloc_resource(device_t bus, device_t child, int type, int *rid,
 	    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)
 {

sys/dev/hyperv/pcib/vmbus_pcib.c

@@ -1725,19 +1725,18 @@ vmbus_pcib_adjust_resource(device_t dev, device_t child,
 }
 
 static int
-vmbus_pcib_release_resource(device_t dev, device_t child, int type, int rid,
+vmbus_pcib_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 	struct vmbus_pcib_softc *sc = device_get_softc(dev);
 
-	if (type == PCI_RES_BUS)
+	switch (rman_get_type(r)) {
-		return (pci_domain_release_bus(sc->hbus->pci_domain, child,
+	case PCI_RES_BUS:
-		    rid, r));
+		return (pci_domain_release_bus(sc->hbus->pci_domain, child, r));
-
+	case SYS_RES_IOPORT:
-	if (type == SYS_RES_IOPORT)
 		return (EINVAL);
-
+	default:
-	return (bus_generic_release_resource(dev, child, type, rid, r));
+		return (bus_generic_release_resource(dev, child, r));
+	}
 }
 
 static int

sys/dev/mvs/mvs_pci.c

@@ -422,16 +422,15 @@ mvs_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-mvs_release_resource(device_t dev, device_t child, int type, int rid,
+mvs_release_resource(device_t dev, device_t child, struct resource *r)
-			 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);
 	}

sys/dev/mvs/mvs_soc.c

@@ -366,11 +366,10 @@ mvs_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-mvs_release_resource(device_t dev, device_t child, int type, int rid,
+mvs_release_resource(device_t dev, device_t child, struct resource *r)
-			 struct resource *r)
 {
 
-	switch (type) {
+	switch (rman_get_type(r)) {
 	case SYS_RES_MEMORY:
 		rman_release_resource(r);
 		return (0);

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,
+static int ofw_pcib_release_resource(device_t, device_t, struct resource *);
-    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 @@ ofw_pcib_alloc_resource(device_t bus, device_t child, int type, int *rid,
 }
 
 static int
-ofw_pcib_release_resource(device_t bus, device_t child, int type, int rid,
+ofw_pcib_release_resource(device_t bus, device_t child, struct resource *res)
-    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,
+		return (pci_domain_release_bus(sc->sc_pci_domain, child, res));
-		    res));
 #endif
 	case SYS_RES_MEMORY:
 	case SYS_RES_IOPORT:
-		return (bus_generic_rman_release_resource(bus, child, type, rid,
+		return (bus_generic_rman_release_resource(bus, child, res));
-		    res));
 	default:
-		return (bus_generic_release_resource(bus, child, type, rid,
+		return (bus_generic_release_resource(bus, child, res));
-		    res));
 	}
 }
 

sys/dev/ofw/ofwbus.c

@@ -170,8 +170,7 @@ ofwbus_alloc_resource(device_t bus, device_t child, int type, int *rid,
 }
 
 static int
-ofwbus_release_resource(device_t bus, device_t child, int type,
+ofwbus_release_resource(device_t bus, device_t child, struct resource *r)
-    int rid, struct resource *r)
 {
 	struct resource_list_entry *rle;
 	bool passthrough;
@@ -180,11 +179,11 @@ ofwbus_release_resource(device_t bus, device_t child, int type,
 	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));
 }

sys/dev/pccbb/pccbb.c

@@ -162,7 +162,7 @@ static struct resource	*cbb_cardbus_alloc_resource(device_t brdev,
 		    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 @@ cbb_cardbus_alloc_resource(device_t brdev, device_t child, int type,
 }
 
 static int
-cbb_cardbus_release_resource(device_t brdev, device_t child, int type,
+cbb_cardbus_release_resource(device_t brdev, device_t child,
-    int rid, struct resource *res)
+    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 @@ cbb_pcic_alloc_resource(device_t brdev, device_t child, int type, int *rid,
 }
 
 static int
-cbb_pcic_release_resource(device_t brdev, device_t child, int type,
+cbb_pcic_release_resource(device_t brdev, device_t child,
-    int rid, struct resource *res)
+    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 @@ cbb_alloc_resource(device_t brdev, device_t child, int type, int *rid,
 }
 
 int
-cbb_release_resource(device_t brdev, device_t child, int type, int rid,
+cbb_release_resource(device_t brdev, device_t child, struct resource *r)
-    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,
+		return (cbb_pcic_release_resource(brdev, child, r));
-		    rid, r));
 	else
-		return (cbb_cardbus_release_resource(brdev, child, type,
+		return (cbb_cardbus_release_resource(brdev, child, r));
-		    rid, r));
 }
 
 int

sys/dev/pccbb/pccbb_pci.c

@@ -818,24 +818,23 @@ cbb_pci_adjust_resource(device_t bus, device_t child,
 }
 
 static int
-cbb_pci_release_resource(device_t bus, device_t child, int type, int rid,
+cbb_pci_release_resource(device_t bus, device_t child, struct resource *r)
-    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
 

sys/dev/pccbb/pccbbvar.h

@@ -130,7 +130,7 @@ int	cbb_power_disable_socket(device_t brdev, device_t child);
 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);

sys/dev/pci/hostb_pci.c

@@ -106,11 +106,10 @@ pci_hostb_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-pci_hostb_release_resource(device_t dev, device_t child, int type, int rid,
+pci_hostb_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 
-	return (bus_release_resource(dev, type, rid, r));
+	return (bus_release_resource(dev, r));
 }
 
 /* PCI interface. */

sys/dev/pci/isa_pci.c

@@ -55,7 +55,7 @@ static struct resource *	isab_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	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 @@ isab_pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-isab_pci_release_resource(device_t dev, device_t child, int type, int rid,
+isab_pci_release_resource(device_t dev, device_t child, struct resource *r)
-    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 @@ isab_pci_release_resource(device_t dev, device_t child, int type, int rid,
 		}
 		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 @@ isab_pci_release_resource(device_t dev, device_t child, int type, int rid,
 		return (error);
 	}
 
-	return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, type,
+	return (bus_generic_release_resource(dev, child, r));
-		rid, r));
 }

sys/dev/pci/pci.c

@@ -5636,29 +5636,26 @@ pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 int
-pci_release_resource(device_t dev, device_t child, int type, int rid,
+pci_release_resource(device_t dev, device_t child, struct resource *r)
-    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,
+		return (bus_generic_release_resource(dev, child, r));
-		    type, rid, 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,
+			return (pci_vf_release_mem_resource(dev, child, r));
-			    r));
 		}
 
 		/* Fall through for other types of resource allocations. */
@@ -5671,19 +5668,19 @@ pci_release_resource(device_t dev, device_t child, int type, int rid,
 	 * those allocations just pass the request up the tree.
 	 */
 	if (cfg->hdrtype == PCIM_HDRTYPE_BRIDGE &&
-	    (type == SYS_RES_IOPORT || type == SYS_RES_MEMORY)) {
+	    (rman_get_type(r) == SYS_RES_IOPORT ||
-		switch (rid) {
+	    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,
+			return (bus_generic_release_resource(dev, child, r));
-			    rid, r));
 		}
 	}
 #endif
 
 	rl = &dinfo->resources;
-	return (resource_list_release(rl, dev, child, type, rid, r));
+	return (resource_list_release(rl, dev, child, r));
 }
 
 int

sys/dev/pci/pci_host_generic.c

@@ -436,26 +436,24 @@ generic_pcie_get_rman(device_t dev, int type, u_int flags)
 }
 
 int
-pci_host_generic_core_release_resource(device_t dev, device_t child, int type,
+pci_host_generic_core_release_resource(device_t dev, device_t child,
-    int rid, struct resource *res)
+    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,
+		return (bus_generic_rman_release_resource(dev, child, res));
-		    res));
 	default:
-		return (bus_generic_release_resource(dev, child, type, rid,
+		return (bus_generic_release_resource(dev, child, res));
-		    res));
 	}
 }
 

sys/dev/pci/pci_host_generic.h

@@ -95,7 +95,7 @@ int pci_host_generic_core_attach(device_t);
 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_ */

sys/dev/pci/pci_iov.c

@@ -778,9 +778,7 @@ pci_iov_config(struct cdev *cdev, struct pci_iov_arg *arg)
 
 	for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 		if (iov->iov_bar[i].res != NULL) {
-			pci_release_resource(bus, dev, SYS_RES_MEMORY,
+			pci_release_resource(bus, dev, iov->iov_bar[i].res);
-			    iov->iov_pos + PCIR_SRIOV_BAR(i),
-			    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 @@ pci_iov_delete_iov_children(struct pci_devinfo *dinfo)
 
 	for (i = 0; i <= PCIR_MAX_BAR_0; i++) {
 		if (iov->iov_bar[i].res != NULL) {
-			pci_release_resource(bus, dev, SYS_RES_MEMORY,
+			pci_release_resource(bus, dev, iov->iov_bar[i].res);
-			    iov->iov_pos + PCIR_SRIOV_BAR(i),
-			    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 @@ pci_vf_alloc_mem_resource(device_t dev, device_t child, int *rid,
 }
 
 int
-pci_vf_release_mem_resource(device_t dev, device_t child, int rid,
+pci_vf_release_mem_resource(device_t dev, device_t child, struct resource *r)
-    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;

sys/dev/pci/pci_pci.c

@@ -2440,8 +2440,7 @@ pcib_adjust_resource(device_t bus, device_t child, struct resource *r,
 }
 
 static int
-pcib_release_resource(device_t dev, device_t child, int type, int rid,
+pcib_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 	struct pcib_softc *sc;
 	int error;
@@ -2449,13 +2448,13 @@ pcib_release_resource(device_t dev, device_t child, int type, int rid,
 	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

sys/dev/pci/pci_private.h

@@ -117,8 +117,8 @@ int		pci_msix_table_bar_method(device_t dev, device_t child);
 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		pci_release_resource(device_t dev, device_t child,
-		    int rid, struct resource *r);
+		    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 @@ struct resource *pci_vf_alloc_mem_resource(device_t dev, device_t child,
 		    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_ */

sys/dev/pci/pci_subr.c

@@ -366,7 +366,7 @@ pci_domain_adjust_bus(int domain, device_t dev, struct resource *r,
 }
 
 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;

sys/dev/pci/pcib_private.h

@@ -158,7 +158,7 @@ struct resource *pci_domain_alloc_bus(int domain, device_t dev, int *rid,
 		    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);

sys/dev/pci/vga_pci.c

@@ -69,8 +69,8 @@ static struct vga_resource *lookup_res(struct vga_pci_softc *sc, int rid);
 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,
+static int	vga_pci_release_resource(device_t dev, device_t child,
-    int rid, struct resource *r);
+    struct resource *r);
 
 int vga_pci_default_unit = -1;
 SYSCTL_INT(_hw_pci, OID_AUTO, default_vgapci_unit, CTLFLAG_RDTUN,
@@ -241,8 +241,7 @@ vga_pci_map_bios(device_t dev, size_t *size)
 	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,
+	vga_pci_release_resource(dev, NULL, vr->vr_res);
-	    vr->vr_res);
 
 	/*
 	 * re-allocate
@@ -265,8 +264,7 @@ vga_pci_map_bios(device_t dev, size_t *size)
 		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,
+	vga_pci_release_resource(dev, NULL, vr->vr_res);
-	    vr->vr_res);
 	return (NULL);
 }
 
@@ -309,8 +307,7 @@ vga_pci_unmap_bios(device_t dev, void *bios)
 	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,
+	vga_pci_release_resource(dev, NULL, vr->vr_res);
-	    vr->vr_res);
 }
 
 int
@@ -478,20 +475,19 @@ vga_pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-vga_pci_release_resource(device_t dev, device_t child, int type, int rid,
+vga_pci_release_resource(device_t dev, device_t child, struct resource *r)
-    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 @@ vga_pci_release_resource(device_t dev, device_t child, int type, int rid,
 		}
 		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 @@ vga_pci_release_resource(device_t dev, device_t child, int type, int rid,
 		return (error);
 	}
 
-	return (bus_release_resource(dev, type, rid, r));
+	return (bus_release_resource(dev, r));
 }
 
 /* PCI interface. */

sys/dev/ppc/ppc.c

@@ -1976,22 +1976,12 @@ ppc_alloc_resource(device_t bus, device_t child, int type, int *rid,
 }
 
 int
-ppc_release_resource(device_t bus, device_t child, int type, int rid,
+ppc_release_resource(device_t bus, device_t child, struct resource *r)
-    struct resource *r)
 {
-#ifdef INVARIANTS
 	struct ppc_data *ppc = DEVTOSOFTC(bus);
-#endif
 
-	switch (type) {
+	if (r == ppc->res_irq)
-	case SYS_RES_IRQ:
+		return (0);
-		if (rid == 0) {
-			KASSERT(r == ppc->res_irq,
-			    ("ppc child IRQ resource mismatch"));
-			return (0);
-		}
-		break;
-	}
 	return (EINVAL);
 }
 

sys/dev/ppc/ppcvar.h

@@ -42,8 +42,7 @@ int ppc_exec_microseq(device_t, struct ppb_microseq **);
 
 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,
+int ppc_release_resource(device_t bus, device_t child, struct resource *r);
-    struct resource *r);
 int ppc_reset_epp(device_t);
 int ppc_ecp_sync(device_t);
 int ppc_setmode(device_t, int);

sys/dev/puc/puc.c

@@ -526,8 +526,7 @@ puc_bus_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 int
-puc_bus_release_resource(device_t dev, device_t child, int type, int rid,
+puc_bus_release_resource(device_t dev, device_t child, struct resource *res)
-    struct resource *res)
 {
 	struct puc_port *port;
 	device_t originator;
@@ -542,18 +541,13 @@ puc_bus_release_resource(device_t dev, device_t child, int type, int rid,
 	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_ires) {
-		if (res != port->p_rres)
-			return (EINVAL);
-	} else if (type == SYS_RES_IRQ) {
-		if (res != port->p_ires)
-			return (EINVAL);
 		if (port->p_hasintr)
 			return (EBUSY);
-	} else
+	} else if (res != port->p_rres)
 		return (EINVAL);
 
 	if (rman_get_device(res) != originator)

sys/dev/puc/puc_bfe.h

@@ -89,7 +89,7 @@ struct resource *puc_bus_alloc_resource(device_t, device_t, int, int *,
 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 *);

sys/dev/quicc/quicc_bfe.h

@@ -64,7 +64,7 @@ struct resource *quicc_bus_alloc_resource(device_t, device_t, int, int *,
 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 *);

sys/dev/quicc/quicc_core.c

@@ -333,8 +333,7 @@ quicc_bus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
 }
 
 int
-quicc_bus_release_resource(device_t dev, device_t child, int type, int rid,
+quicc_bus_release_resource(device_t dev, device_t child, struct resource *res)
-    struct resource *res)
 {
 	struct quicc_device *qd;
 	struct resource_list_entry *rle;
@@ -343,7 +342,8 @@ quicc_bus_release_resource(device_t dev, device_t child, int type, int rid,
 		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);
 }
 

sys/dev/scc/scc_bfe.h

@@ -145,7 +145,7 @@ struct resource *scc_bus_alloc_resource(device_t, device_t, int, int *,
     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 *);

sys/dev/scc/scc_core.c

@@ -495,8 +495,7 @@ scc_bus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
 }
 
 int
-scc_bus_release_resource(device_t dev, device_t child, int type, int rid,
+scc_bus_release_resource(device_t dev, device_t child, struct resource *res)
-    struct resource *res)
 {
 	struct resource_list_entry *rle;
 	struct scc_chan *ch;
@@ -507,7 +506,8 @@ scc_bus_release_resource(device_t dev, device_t child, int type, int rid,
 
 	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);
 }
 

sys/dev/siis/siis.c

@@ -346,16 +346,15 @@ siis_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-siis_release_resource(device_t dev, device_t child, int type, int rid,
+siis_release_resource(device_t dev, device_t child, struct resource *r)
-			 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);
 	}

sys/dev/sound/pci/csa.c

@@ -83,8 +83,7 @@ static int csa_attach(device_t dev);
 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,
+static int csa_release_resource(device_t bus, device_t child, struct resource *r);
-				   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 @@ csa_alloc_resource(device_t bus, device_t child, int type, int *rid,
 }
 
 static int
-csa_release_resource(device_t bus, device_t child, int type, int rid,
+csa_release_resource(device_t bus, device_t child, struct resource *r)
-			struct resource *r)
 {
 	return (0);
 }

sys/dev/sound/pci/fm801.c

@@ -728,8 +728,7 @@ fm801_alloc_resource(device_t bus, device_t child, int type, int *rid,
 }
 
 static int
-fm801_release_resource(device_t bus, device_t child, int type, int rid,
+fm801_release_resource(device_t bus, device_t child, struct resource *r)
-		       struct resource *r)
 {
 	return (0);
 }

sys/dev/vmd/vmd.c

@@ -480,15 +480,13 @@ vmd_adjust_resource(device_t dev, device_t child,
 }
 
 static int
-vmd_release_resource(device_t dev, device_t child, int type, int rid,
+vmd_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 
-	if (type == SYS_RES_IRQ) {
+	if (rman_get_type(r) == SYS_RES_IRQ) {
-		return (bus_generic_release_resource(dev, child, type, rid,
+		return (bus_generic_release_resource(dev, child, r));
-		    r));
 	}
-	return (bus_generic_rman_release_resource(dev, child, type, rid, r));
+	return (bus_generic_rman_release_resource(dev, child, r));
 }
 
 static int

sys/isa/isa_common.c

@@ -909,8 +909,6 @@ isa_driver_added(device_t dev, driver_t *driver)
 		STAILQ_FOREACH(rle, &idev->id_resources, link) {
 			if (rle->res)
 				resource_list_release(rl, dev, child,
-						      rle->type,
-						      rle->rid,
 						      rle->res);
 		}
 

sys/isa/isa_common.h

@@ -72,6 +72,6 @@ extern struct resource *isa_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);
 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;

sys/kern/bus_if.m

@@ -427,15 +427,11 @@ METHOD int translate_resource {
  *
  * @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;
 };
 

sys/kern/subr_bus.c

@@ -3133,8 +3133,6 @@ resource_list_alloc(struct resource_list *rl, device_t bus, device_t child,
  * @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 @@ resource_list_alloc(struct resource_list *rl, device_t bus, device_t child,
  */
 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 @@ resource_list_release(struct resource_list *rl, device_t bus, device_t child,
 
 	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 @@ resource_list_release(struct resource_list *rl, device_t bus, device_t child,
 	if (rle->flags & RLE_RESERVED) {
 		if (rle->flags & RLE_ALLOCATED) {
 			if (rman_get_flags(res) & RF_ACTIVE) {
-				error = bus_deactivate_resource(child, type,
+				error = bus_deactivate_resource(child, res);
-				    rid, res);
 				if (error)
 					return (error);
 			}
@@ -3174,8 +3171,7 @@ resource_list_release(struct resource_list *rl, device_t bus, device_t child,
 		return (EINVAL);
 	}
 
-	error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
+	error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, res);
-	    type, rid, res);
 	if (error)
 		return (error);
 
@@ -3215,8 +3211,7 @@ resource_list_release_active(struct resource_list *rl, device_t bus,
 		    RLE_RESERVED)
 			continue;
 		retval = EBUSY;
-		error = resource_list_release(rl, bus, child, type,
+		error = resource_list_release(rl, bus, child, rle->res);
-		    rman_get_rid(rle->res), rle->res);
 		if (error != 0)
 			device_printf(bus,
 			    "Failed to release active resource: %d\n", error);
@@ -3260,7 +3255,7 @@ resource_list_unreserve(struct resource_list *rl, device_t bus, device_t child,
 	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_generic_alloc_resource(device_t dev, device_t child, int type, int *rid,
  * 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,
+bus_generic_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 	/* Propagate up the bus hierarchy until someone handles it. */
 	if (dev->parent)
-		return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid,
+		return (BUS_RELEASE_RESOURCE(dev->parent, child, r));
-		    r));
 	return (EINVAL);
 }
 
@@ -4180,20 +4173,19 @@ bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid)
  * BUS_GET_RESOURCE_LIST() to find a suitable resource list.
  */
 int
-bus_generic_rl_release_resource(device_t dev, device_t child, int type,
+bus_generic_rl_release_resource(device_t dev, device_t child,
-    int rid, struct resource *r)
+    struct resource *r)
 {
 	struct resource_list *		rl = NULL;
 
 	if (device_get_parent(child) != dev)
-		return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
+		return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, r));
-		    type, rid, 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 @@ bus_generic_rman_adjust_resource(device_t dev, device_t child,
  * allocated by bus_generic_rman_alloc_resource.
  */
 int
-bus_generic_rman_release_resource(device_t dev, device_t child, int type,
+bus_generic_rman_release_resource(device_t dev, device_t child,
-    int rid, struct resource *r)
+    struct resource *r)
 {
 #ifdef INVARIANTS
 	struct rman *rm;
@@ -4293,13 +4285,13 @@ bus_generic_rman_release_resource(device_t dev, device_t child, int type,
 	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 @@ bus_unmap_resource_old(device_t dev, int type, struct resource *r,
  * 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),
+	return (bus_release_resource(dev, r));
-	    r));
 }
 
 /**

sys/powerpc/mpc85xx/isa.c

@@ -73,11 +73,10 @@ isa_alloc_resource(device_t bus, device_t child, int type, int *rid,
 }
 
 int
-isa_release_resource(device_t bus, device_t child, int type, int rid,
+isa_release_resource(device_t bus, device_t child, struct resource *r)
-    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));
 }

sys/powerpc/mpc85xx/lbc.c

@@ -83,8 +83,7 @@ static struct resource *lbc_alloc_resource(device_t, device_t, int, int *,
 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,
+static int lbc_release_resource(device_t, device_t, struct resource *);
-    struct resource *);
 static const struct ofw_bus_devinfo *lbc_get_devinfo(device_t, device_t);
 
 /*
@@ -776,18 +775,13 @@ lbc_adjust_resource(device_t dev, device_t child, struct resource *r,
 }
 
 static int
-lbc_release_resource(device_t dev, device_t child, int type, int rid,
+lbc_release_resource(device_t dev, device_t child, struct resource *res)
-    struct resource *res)
 {
-	switch (type) {
+	switch (rman_get_type(res)) {
-	case SYS_RES_IOPORT:
-		type = SYS_RES_MEMORY;
-		/* FALLTHROUGH */
 	case SYS_RES_MEMORY:
-		return (bus_generic_rman_release_resource(dev, child, type,
+		return (bus_generic_rman_release_resource(dev, child, res));
-		    rid, 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);
 	}

sys/powerpc/powermac/macio.c

@@ -88,8 +88,7 @@ static int  macio_adjust_resource(device_t, device_t, struct resource *,
 				  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,
+static int  macio_release_resource(device_t, device_t, struct resource *);
-				   struct resource *);
 static int  macio_map_resource(device_t, device_t, struct resource *,
 			       struct resource_map_request *,
 			       struct resource_map *);
@@ -610,17 +609,14 @@ macio_adjust_resource(device_t bus, device_t child, struct resource *r,
 }
 
 static int
-macio_release_resource(device_t bus, device_t child, int type, int rid,
+macio_release_resource(device_t bus, device_t child, struct resource *res)
-		       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,
+		return (bus_generic_rman_release_resource(bus, child, res));
-		    res));
 	case SYS_RES_IRQ:
-		return (bus_generic_rl_release_resource(bus, child, type, rid,
+		return (bus_generic_rl_release_resource(bus, child, res));
-		    res));
 	default:
 		return (EINVAL);
 	}

sys/powerpc/powermac/uninorth.c

@@ -87,8 +87,7 @@ static int  unin_chip_map_resource(device_t, device_t, struct resource *,
 				   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,
+static int  unin_chip_release_resource(device_t, device_t, struct resource *);
-				       struct resource *);
 static struct resource_list *unin_chip_get_resource_list (device_t, device_t);
 
 /*
@@ -570,17 +569,14 @@ unin_chip_adjust_resource(device_t bus, device_t child, struct resource *r,
 }
 
 static int
-unin_chip_release_resource(device_t bus, device_t child, int type, int rid,
+unin_chip_release_resource(device_t bus, device_t child, struct resource *res)
-			   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,
+		return (bus_generic_rman_release_resource(bus, child, res));
-		    res));
 	case SYS_RES_IRQ:
-		return (bus_generic_rl_release_resource(bus, child, type, rid,
+		return (bus_generic_rl_release_resource(bus, child, res));
-		    res));
 	default:
 		return (EINVAL);
 	}

sys/powerpc/psim/ata_iobus.c

@@ -61,8 +61,7 @@ static  int  ata_iobus_print_child(device_t dev, device_t child);
 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,
+static int ata_iobus_release_resource(device_t, device_t, struct resource *);
-				      struct resource *);
 
 static device_method_t ata_iobus_methods[] = {
         /* Device interface */
@@ -192,8 +191,7 @@ ata_iobus_alloc_resource(device_t dev, device_t child, int type, int *rid,
 }
 
 static int
-ata_iobus_release_resource(device_t dev, device_t child, int type, int rid,
+ata_iobus_release_resource(device_t dev, device_t child, struct resource *r)
-			   struct resource *r)
 {
 	/* no hotplug... */
 	return (0);

sys/powerpc/psim/iobus.c

@@ -83,8 +83,7 @@ static int  iobus_map_resource(device_t, device_t, struct resource *,
 			       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,
+static int  iobus_release_resource(device_t, device_t, struct resource *);
-				   struct resource *);
 
 /*
  * Bus interface definition
@@ -357,17 +356,15 @@ iobus_adjust_resource(device_t bus, device_t child, struct resource *r,
 }
 
 static int
-iobus_release_resource(device_t bus, device_t child, int type, int rid,
+iobus_release_resource(device_t bus, device_t child, struct resource *res)
-		       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,
+		return (bus_generic_rman_release_resource(bus, child, res));
-		   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);
 	}

sys/sys/bus.h

@@ -396,7 +396,7 @@ struct resource *
 			    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_probe(device_t dev);
 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 @@ int	bus_generic_rl_get_resource (device_t, device_t, int, int, rman_res_t *,
 				     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,
+int	bus_generic_rl_release_resource (device_t, device_t, struct resource *);
-					 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 @@ int	bus_generic_rman_adjust_resource(device_t dev, device_t child,
 					 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 @@ int	bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize,
 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,
+int	bus_release_resource(device_t dev, struct resource *r);
-			     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 @@ int	bus_map_resource_old(device_t dev, int type, struct resource *r,
 			     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 @@ int	bus_release_resource_new(device_t dev, struct resource *r);
 	    bus_unmap_resource)(__VA_ARGS__)
 
 #define	bus_release_resource(...)					\
-	_BUS_API_MACRO(__VA_ARGS__, INVALID, bus_release_resource,	\
+	_BUS_API_MACRO(__VA_ARGS__, INVALID, bus_release_resource_old,	\
-	    INVALID, bus_release_resource_new)(__VA_ARGS__)
+	    INVALID, bus_release_resource)(__VA_ARGS__)
 
 /*
  * Access functions for device.

sys/x86/include/legacyvar.h

@@ -60,8 +60,8 @@ struct resource *legacy_pcib_alloc_resource(device_t dev, device_t child,
     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	legacy_pcib_release_resource(device_t dev, device_t child,
-    int rid, struct resource *r);
+    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,

sys/x86/isa/isa.c

@@ -130,13 +130,12 @@ isa_alloc_resource(device_t bus, device_t child, int type, int *rid,
 }
 
 int
-isa_release_resource(device_t bus, device_t child, int type, int rid,
+isa_release_resource(device_t bus, device_t child, struct resource *r)
-		     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);
 }
 
 /*

sys/x86/pci/pci_bus.c

@@ -617,13 +617,12 @@ legacy_pcib_adjust_resource(device_t dev, device_t child,
 }
 
 int
-legacy_pcib_release_resource(device_t dev, device_t child, int type, int rid,
+legacy_pcib_release_resource(device_t dev, device_t child, struct resource *r)
-    struct resource *r)
 {
 
-	if (type == PCI_RES_BUS)
+	if (rman_get_type(r) == PCI_RES_BUS)
-		return (pci_domain_release_bus(0, child, rid, r));
+		return (pci_domain_release_bus(0, child, r));
-	return (bus_generic_release_resource(dev, child, type, rid, r));
+	return (bus_generic_release_resource(dev, child, r));
 }
 
 int