mirror of
https://github.com/freebsd/freebsd-src
synced 2024-10-06 16:40:47 +00:00
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
This commit is contained in:
parent
2baed46e85
commit
9dbf5b0e68
|
@ -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,
|
||||
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 ,
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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)
|
||||
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
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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;
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
r));
|
||||
return (bus_generic_rl_release_resource(dev, child, 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;
|
||||
|
||||
|
|
|
@ -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,
|
||||
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 @@ bhnd_usb_get_reslist(device_t dev, device_t child)
|
|||
}
|
||||
|
||||
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 @@ 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,
|
||||
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;
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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 *
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
|
@ -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 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,
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
|
|
|
@ -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 @@ 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,
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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));
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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 @@ 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,
|
||||
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
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,
|
||||
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. */
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
rid, r));
|
||||
return (bus_generic_release_resource(dev, child, r));
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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)) {
|
||||
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
|
||||
|
|
|
@ -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,
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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_ */
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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 @@ 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,
|
||||
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;
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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
|
||||
|
|
|
@ -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 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 @@ 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_ */
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
vr->vr_res);
|
||||
vga_pci_release_resource(dev, NULL, 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,
|
||||
vr->vr_res);
|
||||
vga_pci_release_resource(dev, NULL, 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,
|
||||
vr->vr_res);
|
||||
vga_pci_release_resource(dev, NULL, 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,
|
||||
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 @@ 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. */
|
||||
|
|
|
@ -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,
|
||||
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"));
|
||||
if (r == ppc->res_irq)
|
||||
return (0);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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_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)
|
||||
|
|
|
@ -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 *);
|
||||
|
|
|
@ -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 *);
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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 *);
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
struct resource *r)
|
||||
csa_release_resource(device_t bus, device_t child, struct resource *r)
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
struct resource *r)
|
||||
fm801_release_resource(device_t bus, device_t child, struct resource *r)
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
|
||||
|
|
|
@ -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,
|
||||
rid, res);
|
||||
error = bus_deactivate_resource(child, 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,
|
||||
type, rid, res);
|
||||
error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 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,
|
||||
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 @@ 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,
|
||||
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_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,
|
||||
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 @@ 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,
|
||||
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 @@ 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),
|
||||
r));
|
||||
return (bus_release_resource(dev, r));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -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,
|
||||
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));
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
struct resource *r)
|
||||
ata_iobus_release_resource(device_t dev, device_t child, struct resource *r)
|
||||
{
|
||||
/* no hotplug... */
|
||||
return (0);
|
||||
|
|
|
@ -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,
|
||||
struct resource *);
|
||||
static int iobus_release_resource(device_t, device_t, 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,
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
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 @@ 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,
|
||||
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 @@ 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, \
|
||||
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.
|
||||
|
|
|
@ -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 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,
|
||||
|
|
|
@ -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,
|
||||
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);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -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,
|
||||
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
|
||||
|
|
Loading…
Reference in a new issue