static int
canbus_release_resource(
device_t dev, device_t child, int type, int rid, struct resource *res)
{
return (BUS_RELEASE_RESOURCE(
device_get_parent(dev), child, type, rid, res));
}
/* proxying to the parent */
static int
siba_bwn_release_resource(device_t dev, device_t child, int type,
int rid, struct resource *r)
{
return (BUS_RELEASE_RESOURCE(device_get_parent(dev), dev, type,
rid, r));
}
int
ata_pci_release_resource(device_t dev, device_t child, int type, int rid,
struct resource *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);
default:
return ENOENT;
}
}
if (type == SYS_RES_IRQ) {
if (rid != ATA_IRQ_RID)
return ENOENT;
if (controller->legacy) {
return BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
SYS_RES_IRQ, rid, r);
} else
return 0;
}
} else {
if (type == SYS_RES_IRQ) {
if (rid != ATA_IRQ_RID)
return (ENOENT);
return (0);
} else {
return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
type, rid, r));
}
}
return (EINVAL);
}
static int
release_resource(sc_p scp)
{
int i, lid, flags;
device_t dev;
flags = 0;
if (isa_get_vendorid(scp->dev))
lid = isa_get_logicalid(scp->dev);
else {
lid = LOGICALID_NOPNP;
flags = device_get_flags(scp->dev);
}
switch(lid) {
case LOGICALID_PCM:
case LOGICALID_NOPNP: /* XXX Non-PnP */
for (i = 0 ; i < NELEM(scp->io) ; i++) {
if (scp->io[i] != NULL) {
bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[i], scp->io[i]);
scp->io[i] = NULL;
}
}
if (scp->irq != NULL) {
bus_release_resource(scp->dev, SYS_RES_IRQ, scp->irq_rid, scp->irq);
scp->irq = NULL;
}
for (i = 0 ; i < NELEM(scp->drq) ; i++) {
if (scp->drq[i] != NULL) {
bus_release_resource(scp->dev, SYS_RES_DRQ, scp->drq_rid[i], scp->drq[i]);
scp->drq[i] = NULL;
}
}
break;
case LOGICALID_OPL:
if (scp->io[0] != NULL) {
bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
scp->io[0] = NULL;
}
break;
case LOGICALID_MIDI:
if (scp->io[0] != NULL) {
bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
scp->io[0] = NULL;
}
if (scp->irq != NULL) {
/* The irq is shared with pcm audio. */
dev = find_masterdev(scp);
if (dev == NULL)
return (1);
BUS_RELEASE_RESOURCE(dev, NULL, SYS_RES_IOPORT, scp->irq_rid, scp->irq);
scp->irq = NULL;
}
break;
}
return (0);
}
static int
thunder_pem_release_resource(device_t dev, device_t child, int type, int rid,
struct resource *res)
{
device_t parent_dev;
/* Find parent device. On ThunderX we know an exact path. */
parent_dev = device_get_parent(device_get_parent(dev));
if ((type != SYS_RES_MEMORY) && (type != SYS_RES_IOPORT))
return (BUS_RELEASE_RESOURCE(parent_dev, child,
type, rid, res));
return (rman_release_resource(res));
}
int
ata_pci_release_resource(device_t dev, device_t child, int type, int rid,
struct resource *r)
{
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);
break;
case ATA_CTLADDR_RID:
return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
SYS_RES_IOPORT,
PCIR_BAR(1) + (unit << 3), r);
break;
default:
return ENOENT;
}
}
if (type == SYS_RES_IRQ) {
if (rid != ATA_IRQ_RID)
return ENOENT;
if (ata_legacy(dev)) {
return BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
SYS_RES_IRQ, rid, r);
}
else
return 0;
}
return EINVAL;
}
static int
xlp_pci_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
u_long start;
/* If custom alloc, handle that */
start = rman_get_start(r);
if (type == SYS_RES_MEMORY && pci_get_bus(child) == 0 &&
start >= EMUL_MEM_START && start <= EMUL_MEM_END)
return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
type, rid, r));
/* use default PCI function */
return (bus_generic_rl_release_resource(bus, child, type, rid, r));
}
static int
isab_pci_release_resource(device_t dev, device_t child, int type, int rid,
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);
switch (type) {
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);
if (bar < 0 || bar > PCIR_MAX_BAR_0)
return (EINVAL);
sc = device_get_softc(dev);
if (sc->isab_pci_res[bar].ip_res == NULL)
return (EINVAL);
KASSERT(sc->isab_pci_res[bar].ip_res == r,
("isa_pci resource mismatch"));
if (sc->isab_pci_res[bar].ip_refs > 1) {
sc->isab_pci_res[bar].ip_refs--;
return (0);
}
KASSERT(sc->isab_pci_res[bar].ip_refs > 0,
("isa_pci resource reference count underflow"));
error = bus_release_resource(dev, type, rid, r);
if (error == 0) {
sc->isab_pci_res[bar].ip_res = NULL;
sc->isab_pci_res[bar].ip_refs = 0;
}
return (error);
}
return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, type,
rid, r));
}
static int
thunder_pem_release_resource(device_t dev, device_t child, int type, int rid,
struct resource *res)
{
device_t parent_dev;
#if defined(NEW_PCIB) && defined(PCI_RES_BUS)
struct thunder_pem_softc *sc = device_get_softc(dev);
if (type == PCI_RES_BUS)
return (pci_domain_release_bus(sc->id, child, rid, res));
#endif
/* Find parent device. On ThunderX we know an exact path. */
parent_dev = device_get_parent(device_get_parent(dev));
if ((type != SYS_RES_MEMORY) && (type != SYS_RES_IOPORT))
return (BUS_RELEASE_RESOURCE(parent_dev, child,
type, rid, res));
return (rman_release_resource(res));
}
static int
eisa_release_resource(device_t dev, device_t child, int type, int rid,
struct resource *r)
{
int rv;
struct eisa_device *e_dev = device_get_ivars(child);
struct resvaddr *resv = 0;
switch (type) {
case SYS_RES_IRQ:
if (eisa_find_irq(e_dev, rid) == NULL)
return (EINVAL);
break;
case SYS_RES_MEMORY:
if (device_get_parent(child) == dev)
resv = eisa_find_maddr(e_dev, rid);
break;
case SYS_RES_IOPORT:
if (device_get_parent(child) == dev)
resv = eisa_find_ioaddr(e_dev, rid);
break;
default:
return (ENOENT);
}
rv = BUS_RELEASE_RESOURCE(device_get_parent(dev), child, type, rid, r);
if (rv == 0) {
if (resv != NULL)
resv->res = 0;
}
return (rv);
}
/**
* Helper function for implementing BHND_BUS_RELEASE_RESOURCE().
*
* This simple implementation of BHND_BUS_RELEASE_RESOURCE() simply calls the
* BHND_BUS_RELEASE_RESOURCE() method of the parent of @p dev.
*
* If no parent device is available, the request is delegated to
* BUS_RELEASE_RESOURCE().
*/
int
bhnd_generic_release_bhnd_resource(device_t dev, device_t child, int type,
int rid, struct bhnd_resource *r)
{
int error;
/* Try to delegate to the parent. */
if (device_get_parent(dev) != NULL)
return (BHND_BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
type, rid, r));
/* Release the resource directly */
if (!r->direct) {
panic("bhnd indirect resource released without "
"bhnd parent bus");
}
error = BUS_RELEASE_RESOURCE(dev, child, type, rid, r->res);
if (error)
return (error);
free(r, M_BHND);
return (0);
}
static int
acpi_cpu_release_resource(device_t dev, device_t child __unused,
int type, int rid, struct resource *r)
{
return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev, type, rid, r);
}
static void
pcib_mbus_identify(driver_t *driver, device_t parent)
{
const struct obio_pci *info = mv_pci_info;
struct pcib_mbus_softc *sc;
uint32_t control;
while (info->op_base) {
sc = malloc(driver->size, M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc == NULL) {
device_printf(parent, "Could not allocate pcib "
"memory\n");
break;
}
sc->sc_info = info++;
/*
* PCI bridge objects are instantiated immediately. PCI-Express
* bridges require more complicated handling depending on
* platform configuration.
*/
if (sc->sc_info->op_type == MV_TYPE_PCI) {
pcib_mbus_add_child(driver, parent, sc);
continue;
}
/*
* Read link configuration
*/
sc->sc_rid = 0;
sc->sc_res = BUS_ALLOC_RESOURCE(parent, parent, SYS_RES_MEMORY,
&sc->sc_rid, sc->sc_info->op_base, sc->sc_info->op_base +
sc->sc_info->op_size - 1, sc->sc_info->op_size,
RF_ACTIVE);
if (sc->sc_res == NULL) {
device_printf(parent, "Could not map pcib memory\n");
break;
}
sc->sc_bst = rman_get_bustag(sc->sc_res);
sc->sc_bsh = rman_get_bushandle(sc->sc_res);
control = bus_space_read_4(sc->sc_bst, sc->sc_bsh,
PCIE_REG_CONTROL);
BUS_RELEASE_RESOURCE(parent, parent, SYS_RES_MEMORY, sc->sc_rid,
sc->sc_res);
/*
* If this PCI-E port (controller) is configured (by the
* underlying firmware) with lane width other than 1x, there
* are auxiliary resources defined for aggregating more width
* on our lane. Skip all such entries as they are not
* standalone ports and must not have a device object
* instantiated.
*/
if ((control & PCIE_CTRL_LINK1X) == 0)
while (info->op_base &&
info->op_type == MV_TYPE_PCIE_AGGR_LANE)
info++;
pcib_mbus_add_child(driver, parent, sc);
}
}
