static int
envctrl_detach(device_t dev)
{
struct pcf_softc *sc;
int rv;
sc = DEVTOSOFTC(dev);
if ((rv = bus_generic_detach(dev)) != 0)
return (rv);
if ((rv = device_delete_child(dev, sc->iicbus)) != 0)
return (rv);
if (sc->res_irq != 0) {
BUS_TEARDOWN_INTR(device_get_parent(dev), dev, sc->res_irq,
sc->intr_cookie);
bus_deactivate_resource(dev, SYS_RES_IRQ, sc->rid_irq, sc->res_irq);
bus_release_resource(dev, SYS_RES_IRQ, sc->rid_irq, sc->res_irq);
}
bus_deactivate_resource(dev, SYS_RES_IOPORT, sc->rid_ioport, sc->res_ioport);
bus_release_resource(dev, SYS_RES_IOPORT, sc->rid_ioport, sc->res_ioport);
return (0);
}
static int
sbus_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
struct resource_list *rl;
struct resource_list_entry *rle;
int error, passthrough;
passthrough = (device_get_parent(child) != bus);
rl = BUS_GET_RESOURCE_LIST(bus, child);
if (type == SYS_RES_MEMORY) {
if ((rman_get_flags(r) & RF_ACTIVE) != 0) {
error = bus_deactivate_resource(child, type, rid, r);
if (error)
return (error);
}
error = rman_release_resource(r);
if (error != 0)
return (error);
if (!passthrough) {
rle = resource_list_find(rl, type, rid);
KASSERT(rle != NULL,
("%s: resource entry not found!", __func__));
KASSERT(rle->res != NULL,
("%s: resource entry is not busy", __func__));
rle->res = NULL;
}
return (0);
}
return (resource_list_release(rl, bus, child, type, rid, r));
}
static void
dmar_release_resources(device_t dev, struct dmar_unit *unit)
{
int i;
dmar_fini_busdma(unit);
dmar_fini_irt(unit);
dmar_fini_qi(unit);
dmar_fini_fault_log(unit);
for (i = 0; i < DMAR_INTR_TOTAL; i++)
dmar_release_intr(dev, unit, i);
if (unit->regs != NULL) {
bus_deactivate_resource(dev, SYS_RES_MEMORY, unit->reg_rid,
unit->regs);
bus_release_resource(dev, SYS_RES_MEMORY, unit->reg_rid,
unit->regs);
unit->regs = NULL;
}
if (unit->domids != NULL) {
delete_unrhdr(unit->domids);
unit->domids = NULL;
}
if (unit->ctx_obj != NULL) {
vm_object_deallocate(unit->ctx_obj);
unit->ctx_obj = NULL;
}
}
/*
* Release the resources allocated by cmx_allocate_resources.
*/
void
cmx_release_resources(device_t dev)
{
struct cmx_softc *sc = device_get_softc(dev);
mtx_destroy(&sc->mtx);
#ifdef CMX_INTR
if (sc->ih) {
bus_teardown_intr(dev, sc->irq, sc->ih);
sc->ih = NULL;
}
if (sc->irq) {
bus_release_resource(dev, SYS_RES_IRQ,
sc->irq_rid, sc->irq);
sc->irq = NULL;
}
#endif
if (sc->ioport) {
bus_deactivate_resource(dev, SYS_RES_IOPORT,
sc->ioport_rid, sc->ioport);
bus_release_resource(dev, SYS_RES_IOPORT,
sc->ioport_rid, sc->ioport);
sc->ioport = NULL;
}
return;
}
int
pci_vf_release_mem_resource(device_t dev, device_t child, int rid,
struct resource *r)
{
struct pci_devinfo *dinfo;
struct resource_list_entry *rle;
int error;
dinfo = device_get_ivars(child);
if (rman_get_flags(r) & RF_ACTIVE) {
error = bus_deactivate_resource(child, SYS_RES_MEMORY, rid, r);
if (error != 0)
return (error);
}
rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY, rid);
if (rle != NULL) {
rle->res = NULL;
resource_list_delete(&dinfo->resources, SYS_RES_MEMORY,
rid);
}
return (rman_release_resource(r));
}
static int
sbus_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
struct resource_list *rl;
struct resource_list_entry *rle;
int error, passthrough;
passthrough = (device_get_parent(child) != bus);
rl = BUS_GET_RESOURCE_LIST(bus, child);
if (type == SYS_RES_IRQ)
return (resource_list_release(rl, bus, child, type, rid, r));
if ((rman_get_flags(r) & RF_ACTIVE) != 0) {
error = bus_deactivate_resource(child, type, rid, r);
if (error != 0)
return (error);
}
error = rman_release_resource(r);
if (error != 0 || passthrough)
return (error);
rle = resource_list_find(rl, type, rid);
if (rle == NULL)
panic("%s: cannot find resource", __func__);
if (rle->res == NULL)
panic("%s: resource entry is not busy", __func__);
rle->res = NULL;
return (0);
}
static int
sbus_deactivate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
if (type == SYS_RES_IRQ)
return (bus_deactivate_resource(bus, type, rid, r));
return (rman_deactivate_resource(r));
}
static int
nexus_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
if (rman_get_flags(r) & RF_ACTIVE) {
int error = bus_deactivate_resource(child, type, rid, r);
if (error)
return error;
}
return (rman_release_resource(r));
}
static int
ofwbus_release_resource(device_t bus __unused, device_t child, int type,
int rid, struct resource *r)
{
int error;
if ((rman_get_flags(r) & RF_ACTIVE) != 0) {
error = bus_deactivate_resource(child, type, rid, r);
if (error)
return (error);
}
return (rman_release_resource(r));
}
/*
* Deallocate anything allocated by xenpci_allocate_resources.
*/
static int
xenpci_deallocate_resources(device_t dev)
{
struct xenpci_softc *scp = device_get_softc(dev);
if (scp->res_irq != 0) {
bus_deactivate_resource(dev, SYS_RES_IRQ,
scp->rid_irq, scp->res_irq);
bus_release_resource(dev, SYS_RES_IRQ,
scp->rid_irq, scp->res_irq);
scp->res_irq = 0;
}
if (scp->res_memory != 0) {
bus_deactivate_resource(dev, SYS_RES_MEMORY,
scp->rid_memory, scp->res_memory);
bus_release_resource(dev, SYS_RES_MEMORY,
scp->rid_memory, scp->res_memory);
scp->res_memory = 0;
}
return (0);
}
static int
lbc_release_resource(device_t dev, device_t child, int type, int rid,
struct resource *res)
{
int err;
if (rman_get_flags(res) & RF_ACTIVE) {
err = bus_deactivate_resource(child, type, rid, res);
if (err)
return (err);
}
return (rman_release_resource(res));
}
static int
pcf_probe(device_t pcfdev)
{
struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
device_t parent = device_get_parent(pcfdev);
uintptr_t base;
device_set_desc(pcfdev, "PCF8584 I2C bus controller");
bzero(pcf, sizeof(struct pcf_softc));
pcf->rid_irq = pcf->rid_ioport = 0;
pcf->res_irq = pcf->res_ioport = NULL;
/* IO port is mandatory */
pcf->res_ioport = bus_alloc_resource(pcfdev, SYS_RES_IOPORT,
&pcf->rid_ioport, 0ul, ~0ul,
IO_PCFSIZE, RF_ACTIVE);
if (pcf->res_ioport == NULL) {
device_printf(pcfdev, "cannot reserve I/O port range\n");
goto error;
}
BUS_READ_IVAR(parent, pcfdev, ISA_IVAR_PORT, &base);
pcf->pcf_base = base;
pcf->pcf_flags = device_get_flags(pcfdev);
if (!(pcf->pcf_flags & IIC_POLLED)) {
pcf->res_irq = bus_alloc_resource(pcfdev, SYS_RES_IRQ, &pcf->rid_irq,
0ul, ~0ul, 1, RF_ACTIVE);
if (pcf->res_irq == NULL) {
device_printf(pcfdev, "can't reserve irq, polled mode.\n");
pcf->pcf_flags |= IIC_POLLED;
}
}
/* reset the chip */
pcf_rst_card(pcfdev, IIC_FASTEST, PCF_DEFAULT_ADDR, NULL);
return (0);
error:
if (pcf->res_ioport != NULL) {
bus_deactivate_resource(pcfdev, SYS_RES_IOPORT, pcf->rid_ioport,
pcf->res_ioport);
bus_release_resource(pcfdev, SYS_RES_IOPORT, pcf->rid_ioport,
pcf->res_ioport);
}
return (ENXIO);
}
static int
ofw_pci_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
if (rman_get_flags(res) & RF_ACTIVE) {
int error;
error = bus_deactivate_resource(child, type, rid, res);
if (error != 0)
return (error);
}
return (rman_release_resource(res));
}
static int
nexus_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
if (rman_get_flags(r) & RF_ACTIVE) {
int error = bus_deactivate_resource(child, type, rid, r);
if (error)
return error;
}
#ifdef PC98
if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
i386_bus_space_handle_free(r->r_bustag, r->r_bushandle,
r->r_bushandle->bsh_sz);
}
#endif
return (rman_release_resource(r));
}
static int
zbpci_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
int error;
if (type != SYS_RES_IOPORT)
return (bus_generic_release_resource(bus, child, type, rid, r));
if (rman_get_flags(r) & RF_ACTIVE) {
error = bus_deactivate_resource(child, type, rid, r);
if (error)
return (error);
}
return (rman_release_resource(r));
}
static int
ofwbus_release_resource(device_t bus, device_t child, int type,
int rid, struct resource *r)
{
struct resource_list_entry *rle;
int error;
/* Clean resource list entry */
rle = resource_list_find(BUS_GET_RESOURCE_LIST(bus, child), type, rid);
if (rle != NULL)
rle->res = NULL;
if ((rman_get_flags(r) & RF_ACTIVE) != 0) {
error = bus_deactivate_resource(child, type, rid, r);
if (error)
return (error);
}
return (rman_release_resource(r));
}
static int
cbb_pci_release_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
struct cbb_softc *sc;
int error;
sc = device_get_softc(bus);
if (type == 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);
if (error)
return (error);
}
return (rman_release_resource(r));
}
return (cbb_release_resource(bus, child, type, rid, r));
}
/** Free the resource pointing to the register page. **/
static int quantis_deallocate_resources(device_t device)
{
struct quantis_pci_device *scp = DEVICE2SOFTC(device);
if (scp->reg != 0)
{
bus_deactivate_resource(device, scp->regtype, scp->regid, scp->reg);
bus_release_resource(device, scp->regtype, scp->regid, scp->reg);
scp->reg = 0;
}
if (scp->dev)
{
destroy_dev(scp->dev);
}
mtx_destroy(&scp->mutex);
return (0);
}
static int
macgpio_deactivate_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
struct macgpio_softc *sc;
struct macgpio_devinfo *dinfo;
u_char val;
sc = device_get_softc(bus);
dinfo = device_get_ivars(child);
if (type != SYS_RES_IRQ)
return ENXIO;
if (dinfo->gpio_num >= 0) {
val = bus_read_1(sc->sc_gpios,dinfo->gpio_num);
val &= ~0x80;
bus_write_1(sc->sc_gpios,dinfo->gpio_num,val);
}
return (bus_deactivate_resource(bus, type, rid, res));
}
int
ppc_probe(device_t dev)
{
#ifdef __i386__
static short next_bios_ppc = 0;
#endif
struct ppc_data *ppc;
int error;
u_long port;
/*
* Allocate the ppc_data structure.
*/
ppc = DEVTOSOFTC(dev);
bzero(ppc, sizeof(struct ppc_data));
ppc->rid_irq = ppc->rid_drq = ppc->rid_ioport = 0;
ppc->res_irq = ppc->res_drq = ppc->res_ioport = 0;
/* retrieve ISA parameters */
error = bus_get_resource(dev, SYS_RES_IOPORT, 0, &port, NULL);
#ifdef __i386__
/*
* If port not specified, use bios list.
*/
if (error) {
if((next_bios_ppc < BIOS_MAX_PPC) &&
(*(BIOS_PORTS+next_bios_ppc) != 0) ) {
port = *(BIOS_PORTS+next_bios_ppc++);
if (bootverbose)
device_printf(dev, "parallel port found at 0x%x\n",
(int) port);
} else {
device_printf(dev, "parallel port not found.\n");
return ENXIO;
}
bus_set_resource(dev, SYS_RES_IOPORT, 0, port,
IO_LPTSIZE_EXTENDED);
}
#endif
#ifdef __alpha__
/*
* There isn't a bios list on alpha. Put it in the usual place.
*/
if (error) {
bus_set_resource(dev, SYS_RES_IOPORT, 0, 0x3bc,
IO_LPTSIZE_NORMAL);
}
#endif
/* IO port is mandatory */
/* Try "extended" IO port range...*/
ppc->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT,
&ppc->rid_ioport, 0, ~0,
IO_LPTSIZE_EXTENDED, RF_ACTIVE);
if (ppc->res_ioport != 0) {
if (bootverbose)
device_printf(dev, "using extended I/O port range\n");
} else {
/* Failed? If so, then try the "normal" IO port range... */
ppc->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT,
&ppc->rid_ioport, 0, ~0,
IO_LPTSIZE_NORMAL,
RF_ACTIVE);
if (ppc->res_ioport != 0) {
if (bootverbose)
device_printf(dev, "using normal I/O port range\n");
} else {
device_printf(dev, "cannot reserve I/O port range\n");
goto error;
}
}
ppc->ppc_base = rman_get_start(ppc->res_ioport);
ppc->bsh = rman_get_bushandle(ppc->res_ioport);
ppc->bst = rman_get_bustag(ppc->res_ioport);
ppc->ppc_flags = device_get_flags(dev);
if (!(ppc->ppc_flags & 0x20)) {
ppc->res_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &ppc->rid_irq,
0ul, ~0ul, 1, RF_SHAREABLE);
ppc->res_drq = bus_alloc_resource(dev, SYS_RES_DRQ, &ppc->rid_drq,
0ul, ~0ul, 1, RF_ACTIVE);
}
if (ppc->res_irq)
ppc->ppc_irq = rman_get_start(ppc->res_irq);
if (ppc->res_drq)
ppc->ppc_dmachan = rman_get_start(ppc->res_drq);
ppc->ppc_unit = device_get_unit(dev);
ppc->ppc_model = GENERIC;
ppc->ppc_mode = PPB_COMPATIBLE;
ppc->ppc_epp = (ppc->ppc_flags & 0x10) >> 4;
ppc->ppc_type = PPC_TYPE_GENERIC;
/*
* Try to detect the chipset and its mode.
*/
if (ppc_detect(ppc, ppc->ppc_flags & 0xf))
goto error;
return (0);
error:
if (ppc->res_irq != 0) {
bus_release_resource(dev, SYS_RES_IRQ, ppc->rid_irq,
ppc->res_irq);
}
if (ppc->res_ioport != 0) {
bus_deactivate_resource(dev, SYS_RES_IOPORT, ppc->rid_ioport,
ppc->res_ioport);
bus_release_resource(dev, SYS_RES_IOPORT, ppc->rid_ioport,
ppc->res_ioport);
}
if (ppc->res_drq != 0) {
bus_deactivate_resource(dev, SYS_RES_DRQ, ppc->rid_drq,
ppc->res_drq);
bus_release_resource(dev, SYS_RES_DRQ, ppc->rid_drq,
ppc->res_drq);
}
return (ENXIO);
}
static int
envctrl_attach(device_t dev)
{
struct pcf_softc *sc;
int rv = ENXIO;
sc = DEVTOSOFTC(dev);
bzero(sc, sizeof(struct pcf_softc));
/* IO port is mandatory */
sc->res_ioport = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
&sc->rid_ioport, RF_ACTIVE);
if (sc->res_ioport == 0) {
device_printf(dev, "cannot reserve I/O port range\n");
goto error;
}
sc->bt_ioport = rman_get_bustag(sc->res_ioport);
sc->bh_ioport = rman_get_bushandle(sc->res_ioport);
sc->pcf_flags = device_get_flags(dev);
if (!(sc->pcf_flags & IIC_POLLED)) {
sc->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->rid_irq,
RF_ACTIVE);
if (sc->res_irq == 0) {
device_printf(dev, "can't reserve irq, polled mode.\n");
sc->pcf_flags |= IIC_POLLED;
}
}
/* reset the chip */
pcf_rst_card(dev, IIC_FASTEST, PCF_DEFAULT_ADDR, NULL);
rv = BUS_SETUP_INTR(device_get_parent(dev), dev, sc->res_irq,
INTR_TYPE_NET /* | INTR_ENTROPY */,
pcf_intr, sc, &sc->intr_cookie);
if (rv) {
device_printf(dev, "could not setup IRQ\n");
goto error;
}
if ((sc->iicbus = device_add_child(dev, "iicbus", -1)) == NULL)
device_printf(dev, "could not allocate iicbus instance\n");
/* probe and attach the iicbus */
bus_generic_attach(dev);
return (0);
error:
if (sc->res_irq != 0) {
bus_deactivate_resource(dev, SYS_RES_IRQ, sc->rid_irq,
sc->res_irq);
bus_release_resource(dev, SYS_RES_IRQ, sc->rid_irq,
sc->res_irq);
}
if (sc->res_ioport != 0) {
bus_deactivate_resource(dev, SYS_RES_IOPORT, sc->rid_ioport,
sc->res_ioport);
bus_release_resource(dev, SYS_RES_IOPORT, sc->rid_ioport,
sc->res_ioport);
}
return (rv);
}
