static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
/*
* If this is a memory resource, map it into the kernel.
*/
if (rman_get_bustag(r) == I386_BUS_SPACE_MEM) {
caddr_t vaddr = 0;
if (rman_get_end(r) < 1024 * 1024) {
/*
* The first 1Mb is mapped at KERNBASE.
*/
vaddr = (caddr_t)(uintptr_t)(KERNBASE + rman_get_start(r));
} else {
u_int64_t paddr;
u_int64_t psize;
u_int32_t poffs;
paddr = rman_get_start(r);
psize = rman_get_size(r);
poffs = paddr - trunc_page(paddr);
vaddr = (caddr_t) pmap_mapdev(paddr-poffs, psize+poffs) + poffs;
}
rman_set_virtual(r, vaddr);
/* IBM-PC: the type of bus_space_handle_t is u_int */
rman_set_bushandle(r, (bus_space_handle_t) vaddr);
}
return (rman_activate_resource(r));
}
static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
vm_paddr_t paddr, psize;
void *vaddr;
/*
* If this is a memory resource, map it into the kernel.
*/
switch (type) {
case SYS_RES_IOPORT:
rman_set_bustag(r, IA64_BUS_SPACE_IO);
rman_set_bushandle(r, rman_get_start(r));
break;
case SYS_RES_MEMORY:
paddr = rman_get_start(r);
psize = rman_get_size(r);
vaddr = pmap_mapdev(paddr, psize);
rman_set_virtual(r, vaddr);
rman_set_bustag(r, IA64_BUS_SPACE_MEM);
rman_set_bushandle(r, (bus_space_handle_t) paddr);
break;
}
return (rman_activate_resource(r));
}
int
ofw_pci_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
struct ofw_pci_softc *sc;
struct bus_space_tag *tag;
sc = device_get_softc(bus);
switch (type) {
case SYS_RES_IRQ:
return (bus_generic_activate_resource(bus, child, type, rid,
r));
case SYS_RES_MEMORY:
tag = sparc64_alloc_bus_tag(r, PCI_MEMORY_BUS_SPACE);
if (tag == NULL)
return (ENOMEM);
rman_set_bustag(r, tag);
rman_set_bushandle(r, sc->sc_pci_bh[OFW_PCI_CS_MEM32] +
rman_get_start(r));
break;
case SYS_RES_IOPORT:
rman_set_bustag(r, sc->sc_pci_iot);
rman_set_bushandle(r, sc->sc_pci_bh[OFW_PCI_CS_IO] +
rman_get_start(r));
break;
}
return (rman_activate_resource(r));
}
static int
thunder_pem_activate_resource(device_t dev, device_t child, int type, int rid,
struct resource *r)
{
int err;
bus_addr_t paddr;
bus_size_t psize;
bus_space_handle_t vaddr;
struct thunder_pem_softc *sc;
if ((err = rman_activate_resource(r)) != 0)
return (err);
sc = device_get_softc(dev);
/*
* If this is a memory resource, map it into the kernel.
*/
if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
paddr = (bus_addr_t)rman_get_start(r);
psize = (bus_size_t)rman_get_size(r);
paddr = range_addr_pci_to_phys(sc->ranges, paddr);
err = bus_space_map(&memmap_bus, paddr, psize, 0, &vaddr);
if (err != 0) {
rman_deactivate_resource(r);
return (err);
}
rman_set_bustag(r, &memmap_bus);
rman_set_virtual(r, (void *)vaddr);
rman_set_bushandle(r, vaddr);
}
return (0);
}
static int
sbus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
struct sbus_softc *sc;
struct bus_space_tag *tag;
int i;
switch (type) {
case SYS_RES_IRQ:
return (bus_generic_activate_resource(bus, child, type, rid,
r));
case SYS_RES_MEMORY:
sc = device_get_softc(bus);
for (i = 0; i < sc->sc_nrange; i++) {
if (rman_is_region_manager(r,
&sc->sc_rd[i].rd_rman) != 0) {
tag = sparc64_alloc_bus_tag(r, SBUS_BUS_SPACE);
if (tag == NULL)
return (ENOMEM);
rman_set_bustag(r, tag);
rman_set_bushandle(r,
sc->sc_rd[i].rd_bushandle +
rman_get_start(r));
return (rman_activate_resource(r));
}
}
/* FALLTHROUGH */
default:
return (EINVAL);
}
}
static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
void *vaddr;
vm_paddr_t paddr;
vm_size_t psize;
int err;
/*
* If this is a memory resource, use pmap_mapdev to map it.
*/
if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
paddr = rman_get_start(r);
psize = rman_get_size(r);
rman_set_bustag(r, mips_bus_space_generic);
err = bus_space_map(rman_get_bustag(r), paddr, psize, 0,
(bus_space_handle_t *)&vaddr);
if (err != 0) {
rman_deactivate_resource(r);
return (err);
}
rman_set_virtual(r, vaddr);
rman_set_bushandle(r, (bus_space_handle_t)(uintptr_t)vaddr);
} else if (type == SYS_RES_IRQ) {
#ifdef INTRNG
intr_activate_irq(child, r);
#endif
}
return (rman_activate_resource(r));
}
static int
ocpbus_setup_intr(device_t dev, device_t child, struct resource *res, int flags,
driver_filter_t *filter, driver_intr_t *ihand, void *arg, void **cookiep)
{
int error;
if (res == NULL)
panic("ocpbus_setup_intr: NULL irq resource!");
*cookiep = 0;
if ((rman_get_flags(res) & RF_SHAREABLE) == 0)
flags |= INTR_EXCL;
/*
* We depend here on rman_activate_resource() being idempotent.
*/
error = rman_activate_resource(res);
if (error)
return (error);
error = powerpc_setup_intr(device_get_nameunit(child),
rman_get_start(res), filter, ihand, arg, flags, cookiep);
return (error);
}
static int
nexus_setup_intr(device_t bus __unused, device_t child, struct resource *r,
int flags, driver_filter_t *filt, driver_intr_t *intr, void *arg,
void **cookiep)
{
int error, domain;
if (r == NULL)
panic("%s: NULL interrupt resource!", __func__);
if (cookiep != NULL)
*cookiep = NULL;
if ((rman_get_flags(r) & RF_SHAREABLE) == 0)
flags |= INTR_EXCL;
/* We depend here on rman_activate_resource() being idempotent. */
error = rman_activate_resource(r);
if (error)
return (error);
if (bus_get_domain(child, &domain) != 0) {
if(bootverbose)
device_printf(child, "no domain found\n");
domain = 0;
}
error = powerpc_setup_intr(device_get_nameunit(child),
rman_get_start(r), filt, intr, arg, flags, cookiep, domain);
return (error);
}
static int
fdtbus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
return (rman_activate_resource(res));
}
/*
* Currently this uses the really grody interface from kern/kern_intr.c
* (which really doesn't belong in kern/anything.c). Eventually, all of
* the code in kern_intr.c and machdep_intr.c should get moved here, since
* this is going to be the official interface.
*/
static int
nexus_setup_intr(device_t bus, device_t child, struct resource *irq,
int flags, void (*ihand)(void *), void *arg,
void **cookiep, lwkt_serialize_t serializer)
{
int error, icflags;
/* somebody tried to setup an irq that failed to allocate! */
if (irq == NULL)
panic("nexus_setup_intr: NULL irq resource!");
*cookiep = 0;
icflags = flags;
if ((irq->r_flags & RF_SHAREABLE) == 0)
icflags |= INTR_EXCL;
/*
* We depend here on rman_activate_resource() being idempotent.
*/
error = rman_activate_resource(irq);
if (error)
return (error);
/*
* XXX cast the interrupt handler function to an inthand2_t. The
* difference is that an additional frame argument is passed which
* we do not currently want to expose the BUS subsystem to.
*/
*cookiep = register_int(irq->r_start, (inthand2_t *)ihand, arg,
device_get_nameunit(child), serializer,
icflags, rman_get_cpuid(irq));
if (*cookiep == NULL)
error = EINVAL;
return (error);
}
static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
int err;
bus_addr_t paddr;
bus_size_t psize;
bus_space_handle_t vaddr;
if ((err = rman_activate_resource(r)) != 0)
return (err);
/*
* If this is a memory resource, map it into the kernel.
*/
if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
paddr = (bus_addr_t)rman_get_start(r);
psize = (bus_size_t)rman_get_size(r);
err = bus_space_map(&memmap_bus, paddr, psize, 0, &vaddr);
if (err != 0) {
rman_deactivate_resource(r);
return (err);
}
rman_set_bustag(r, &memmap_bus);
rman_set_virtual(r, (void *)vaddr);
rman_set_bushandle(r, vaddr);
} else if (type == SYS_RES_IRQ) {
intr_activate_irq(child, r);
}
return (0);
}
static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
/*
* If this is a memory resource, map it into the kernel.
*/
if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
caddr_t vaddr = 0;
u_int32_t paddr;
u_int32_t psize;
u_int32_t poffs;
paddr = rman_get_start(r);
psize = rman_get_size(r);
poffs = paddr - trunc_page(paddr);
vaddr = (caddr_t) pmap_mapdev(paddr-poffs, psize+poffs) + poffs;
rman_set_virtual(r, vaddr);
#ifdef FDT
rman_set_bustag(r, fdtbus_bs_tag);
#else
rman_set_bustag(r, (void *)1);
#endif
rman_set_bushandle(r, (bus_space_handle_t) vaddr);
}
return (rman_activate_resource(r));
}
static int
pxa_activate_resource(device_t dev, device_t child, int type, int rid,
struct resource *r)
{
return (rman_activate_resource(r));
}
static int
unin_chip_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
void *p;
if (type == SYS_RES_IRQ)
return (bus_activate_resource(bus, type, rid, res));
if ((type == SYS_RES_MEMORY) || (type == SYS_RES_IOPORT)) {
vm_offset_t start;
start = (vm_offset_t) rman_get_start(res);
if (bootverbose)
printf("unin mapdev: start %zx, len %ld\n", start,
rman_get_size(res));
p = pmap_mapdev(start, (vm_size_t) rman_get_size(res));
if (p == NULL)
return (ENOMEM);
rman_set_virtual(res, p);
rman_set_bustag(res, &bs_be_tag);
rman_set_bushandle(res, (u_long)p);
}
return (rman_activate_resource(res));
}
static int
ebus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
struct ebus_softc *sc;
struct ebus_rinfo *eri;
bus_space_tag_t bt;
bus_space_handle_t bh;
int i, rv;
sc = device_get_softc(bus);
if ((sc->sc_flags & EBUS_PCI) != 0 && type == SYS_RES_MEMORY) {
for (i = 0; i < sc->sc_nrange; i++) {
eri = &sc->sc_rinfo[i];
if (rman_is_region_manager(res, &eri->eri_rman) != 0) {
bt = rman_get_bustag(eri->eri_res);
rv = bus_space_subregion(bt,
rman_get_bushandle(eri->eri_res),
rman_get_start(res) -
rman_get_start(eri->eri_res),
rman_get_size(res), &bh);
if (rv != 0)
return (rv);
rman_set_bustag(res, bt);
rman_set_bushandle(res, bh);
return (rman_activate_resource(res));
}
}
return (EINVAL);
}
return (bus_generic_activate_resource(bus, child, type, rid, res));
}
static int
wiibus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
void *p;
switch (type) {
case SYS_RES_MEMORY:
p = pmap_mapdev(rman_get_start(res), rman_get_size(res));
if (p == NULL)
return (ENOMEM);
rman_set_virtual(res, p);
rman_set_bustag(res, &bs_be_tag);
rman_set_bushandle(res, (unsigned long)p);
break;
case SYS_RES_IRQ:
return (bus_activate_resource(bus, type, rid, res));
default:
device_printf(bus,
"unknown activate resource request from %s\n",
device_get_nameunit(child));
return (ENXIO);
}
return (rman_activate_resource(res));
}
/*
* Currently this uses the really grody interface from kern/kern_intr.c
* (which really doesn't belong in kern/anything.c). Eventually, all of
* the code in kern_intr.c and machdep_intr.c should get moved here, since
* this is going to be the official interface.
*/
static int
nexus_setup_intr(device_t bus, device_t child, struct resource *irq,
int flags, void (*ihand)(void *), void *arg, void **cookiep)
{
driver_t *driver;
int error;
/* somebody tried to setup an irq that failed to allocate! */
if (irq == NULL)
panic("nexus_setup_intr: NULL irq resource!");
*cookiep = 0;
if ((irq->r_flags & RF_SHAREABLE) == 0)
flags |= INTR_EXCL;
driver = device_get_driver(child);
/*
* We depend here on rman_activate_resource() being idempotent.
*/
error = rman_activate_resource(irq);
if (error)
return (error);
error = inthand_add(device_get_nameunit(child), irq->r_start,
ihand, arg, flags, cookiep);
return (error);
}
static int
octopci_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
bus_space_handle_t bh;
int error;
switch (type) {
case SYS_RES_IRQ:
error = bus_generic_activate_resource(bus, child, type, rid,
res);
if (error != 0)
return (error);
return (0);
case SYS_RES_MEMORY:
case SYS_RES_IOPORT:
error = bus_space_map(rman_get_bustag(res),
rman_get_bushandle(res), rman_get_size(res), 0, &bh);
if (error != 0)
return (error);
rman_set_bushandle(res, bh);
break;
default:
return (ENXIO);
}
error = rman_activate_resource(res);
if (error != 0)
return (error);
return (0);
}
static int
ofw_pci_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *res)
{
struct ofw_pci_softc *sc;
void *p;
sc = device_get_softc(bus);
if (type == SYS_RES_IRQ) {
return (bus_activate_resource(bus, type, rid, res));
}
if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
struct ofw_pci_range *rp;
vm_offset_t start;
int space;
start = (vm_offset_t)rman_get_start(res);
/*
* Map this through the ranges list
*/
for (rp = sc->sc_range; rp < sc->sc_range + sc->sc_nrange &&
rp->pci_hi != 0; rp++) {
if (start < rp->pci || start >= rp->pci + rp->size)
continue;
switch (rp->pci_hi & OFW_PCI_PHYS_HI_SPACEMASK) {
case OFW_PCI_PHYS_HI_SPACE_IO:
space = SYS_RES_IOPORT;
break;
case OFW_PCI_PHYS_HI_SPACE_MEM32:
case OFW_PCI_PHYS_HI_SPACE_MEM64:
space = SYS_RES_MEMORY;
break;
default:
space = -1;
}
if (type == space) {
start += (rp->host - rp->pci);
break;
}
}
if (bootverbose)
printf("ofw_pci mapdev: start %zx, len %ld\n", start,
rman_get_size(res));
p = pmap_mapdev(start, (vm_size_t)rman_get_size(res));
if (p == NULL)
return (ENOMEM);
rman_set_virtual(res, p);
rman_set_bustag(res, &bs_le_tag);
rman_set_bushandle(res, (u_long)p);
}
return (rman_activate_resource(res));
}
static int
nexus_setup_intr(device_t bus __unused, device_t child, struct resource *r,
int flags, driver_filter_t *filt, driver_intr_t *intr, void *arg,
void **cookiep)
{
int error;
if (r == NULL)
panic("%s: NULL interrupt resource!", __func__);
if ((rman_get_flags(r) & RF_SHAREABLE) == 0)
flags |= INTR_EXCL;
/* We depend here on rman_activate_resource() being idempotent. */
error = rman_activate_resource(r);
if (error)
return (error);
error = inthand_add(device_get_nameunit(child), rman_get_start(r),
filt, intr, arg, flags, cookiep);
/*
* XXX in case of the AFB/FFB interrupt and a Psycho, Sabre or U2S
* bridge enable the interrupt in the respective bridge.
*/
return (error);
}
static int
lbc_activate_resource(device_t bus __unused, device_t child __unused,
int type __unused, int rid __unused, struct resource *r)
{
/* Child resources were already mapped, just activate. */
return (rman_activate_resource(r));
}
static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
/* Not much to be done yet... */
return (rman_activate_resource(r));
}
static int
vnex_setup_intr(device_t dev, device_t child, struct resource *res, int flags,
driver_filter_t *filt,driver_intr_t *intr, void *arg, void **cookiep)
{
uint64_t reg, nreg;
uint64_t ihdl, cfg;
uint64_t ino, nino;
int error, cpuid;
if (res == NULL)
panic("%s: NULL interrupt resource!", __func__);
if ((error = bus_get_resource(dev, SYS_RES_MEMORY, 0, ®, &nreg)))
goto fail;
if ((error = bus_get_resource(child, SYS_RES_IRQ, 0, &ino, &nino)))
goto fail;
cfg = SUN4V_REG_SPEC2CFG_HDL(reg);
if (hv_intr_devino_to_sysino(cfg, (uint32_t)ino, &ihdl) != H_EOK) {
error = ENXIO;
goto fail;
}
cpuid = 0;
if (hv_intr_settarget(ihdl, cpuid) != H_EOK) {
error = ENXIO;
goto fail;
}
if (hv_intr_setstate(ihdl, HV_INTR_IDLE_STATE) != H_EOK) {
error = ENXIO;
goto fail;
}
if (hv_intr_setenabled(ihdl, HV_INTR_ENABLED) != H_EOK) {
error = ENXIO;
goto fail;
}
if ((rman_get_flags(res) & RF_SHAREABLE) == 0)
flags |= INTR_EXCL;
/* We depend here on rman_activate_resource() being idempotent. */
if ((error = rman_activate_resource(res)))
goto fail;
error = inthand_add(device_get_nameunit(child), ihdl,
filt, intr, arg, flags, cookiep);
printf("inthandler added\n");
fail:
return (error);
}
static int
sbus_activate_resource(device_t bus, device_t child, int type, int rid,
struct resource *r)
{
if (type == SYS_RES_IRQ)
return (bus_activate_resource(bus, type, rid, r));
return (rman_activate_resource(r));
}
/*
* Currently this uses the really grody interface from kern/kern_intr.c
* (which really doesn't belong in kern/anything.c). Eventually, all of
* the code in kern_intr.c and machdep_intr.c should get moved here, since
* this is going to be the official interface.
*/
static int
nexus_setup_intr(device_t bus, device_t child, struct resource *irq,
int flags, void (*ihand)(void *), void *arg, void **cookiep)
{
intrmask_t *mask;
driver_t *driver;
int error, icflags;
/* somebody tried to setup an irq that failed to allocate! */
if (irq == NULL)
panic("nexus_setup_intr: NULL irq resource!");
*cookiep = 0;
if (irq->r_flags & RF_SHAREABLE)
icflags = 0;
else
icflags = INTR_EXCL;
driver = device_get_driver(child);
switch (flags) {
case INTR_TYPE_TTY:
mask = &tty_imask;
break;
case (INTR_TYPE_TTY | INTR_TYPE_FAST):
mask = &tty_imask;
icflags |= INTR_FAST;
break;
case INTR_TYPE_BIO:
mask = &bio_imask;
break;
case INTR_TYPE_NET:
mask = &net_imask;
break;
case INTR_TYPE_CAM:
mask = &cam_imask;
break;
case INTR_TYPE_MISC:
mask = 0;
break;
default:
panic("still using grody create_intr interface");
}
/*
* We depend here on rman_activate_resource() being idempotent.
*/
error = rman_activate_resource(irq);
if (error)
return (error);
*cookiep = inthand_add(device_get_nameunit(child), irq->r_start,
ihand, arg, mask, icflags);
if (*cookiep == NULL)
error = EINVAL; /* XXX ??? */
return (error);
}
static int
nexus_activate_resource(device_t bus __unused, device_t child __unused,
int type, int rid __unused, struct resource *r)
{
if (type == SYS_RES_MEMORY) {
rman_set_bustag(r, &nexus_bustag);
rman_set_bushandle(r, rman_get_start(r));
}
return (rman_activate_resource(r));
}
struct resource *
puc_bus_alloc_resource(device_t dev, device_t child, int type, int *rid,
u_long start, u_long end, u_long count, u_int flags)
{
struct puc_port *port;
struct resource *res;
device_t assigned, originator;
int error;
/* Get our immediate child. */
originator = child;
while (child != NULL && device_get_parent(child) != dev)
child = device_get_parent(child);
if (child == NULL)
return (NULL);
port = device_get_ivars(child);
KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
if (rid == NULL || *rid != 0)
return (NULL);
/* We only support default allocations. */
if (start != 0UL || end != ~0UL)
return (NULL);
if (type == port->p_bar->b_type)
res = port->p_rres;
else if (type == SYS_RES_IRQ)
res = port->p_ires;
else
return (NULL);
if (res == NULL)
return (NULL);
assigned = rman_get_device(res);
if (assigned == NULL) /* Not allocated */
rman_set_device(res, originator);
else if (assigned != originator)
return (NULL);
if (flags & RF_ACTIVE) {
error = rman_activate_resource(res);
if (error) {
if (assigned == NULL)
rman_set_device(res, NULL);
return (NULL);
}
}
return (res);
}
static int
generic_pcie_activate_resource(device_t dev, device_t child, int type,
int rid, struct resource *r)
{
struct generic_pcie_core_softc *sc;
uint64_t phys_base;
uint64_t pci_base;
uint64_t size;
int found;
int res;
int i;
sc = device_get_softc(dev);
if ((res = rman_activate_resource(r)) != 0)
return (res);
switch (type) {
case SYS_RES_IOPORT:
found = 0;
for (i = 0; i < MAX_RANGES_TUPLES; i++) {
pci_base = sc->ranges[i].pci_base;
phys_base = sc->ranges[i].phys_base;
size = sc->ranges[i].size;
if ((rid > pci_base) && (rid < (pci_base + size))) {
found = 1;
break;
}
}
if (found) {
rman_set_start(r, rman_get_start(r) + phys_base);
rman_set_end(r, rman_get_end(r) + phys_base);
res = BUS_ACTIVATE_RESOURCE(device_get_parent(dev),
child, type, rid, r);
} else {
device_printf(dev,
"Failed to activate IOPORT resource\n");
res = 0;
}
break;
case SYS_RES_MEMORY:
case SYS_RES_IRQ:
res = BUS_ACTIVATE_RESOURCE(device_get_parent(dev), child,
type, rid, r);
break;
default:
break;
}
return (res);
}
/**
* Retain an RF_ACTIVE reference to the region mapping @p r, and
* configure @p r with its subregion values.
*
* @param sc Driver instance state.
* @param child Requesting child device.
* @param type resource type of @p r.
* @param rid resource id of @p r
* @param r resource to be activated.
* @param req_direct If true, failure to allocate a direct bhnd resource
* will be treated as an error. If false, the resource will not be marked
* as RF_ACTIVE if bhnd direct resource allocation fails.
*/
static int
chipc_try_activate_resource(struct chipc_softc *sc, device_t child, int type,
int rid, struct resource *r, bool req_direct)
{
struct rman *rm;
struct chipc_region *cr;
bhnd_size_t cr_offset;
rman_res_t r_start, r_end, r_size;
int error;
rm = chipc_get_rman(sc, type);
if (rm == NULL || !rman_is_region_manager(r, rm))
return (EINVAL);
r_start = rman_get_start(r);
r_end = rman_get_end(r);
r_size = rman_get_size(r);
/* Find the corresponding chipc region */
cr = chipc_find_region(sc, r_start, r_end);
if (cr == NULL)
return (EINVAL);
/* Calculate subregion offset within the chipc region */
cr_offset = r_start - cr->cr_addr;
/* Retain (and activate, if necessary) the chipc region */
if ((error = chipc_retain_region(sc, cr, RF_ACTIVE)))
return (error);
/* Configure child resource with its subregion values. */
if (cr->cr_res->direct) {
error = chipc_init_child_resource(r, cr->cr_res->res,
cr_offset, r_size);
if (error)
goto cleanup;
/* Mark active */
if ((error = rman_activate_resource(r)))
goto cleanup;
} else if (req_direct) {
error = ENOMEM;
goto cleanup;
}
return (0);
cleanup:
chipc_release_region(sc, cr, RF_ACTIVE);
return (error);
}
int
isa_setup_intr(device_t dev, device_t child,
struct resource *irq, int flags,
driver_intr_t *intr, void *arg, void **cookiep)
{
struct isa_intr *ii;
int error;
if (platform.isa_setup_intr)
return platform.isa_setup_intr(dev, child, irq, flags,
intr, arg, cookiep);
if (irq == NULL)
return ENODEV;
error = rman_activate_resource(irq);
if (error)
return error;
ii = malloc(sizeof(struct isa_intr), M_DEVBUF, M_NOWAIT);
if (!ii)
return ENOMEM;
ii->intr = intr;
ii->arg = arg;
ii->irq = irq->r_start;
error = alpha_setup_intr(
device_get_nameunit(child ? child : dev),
0x800 + (irq->r_start << 4),
((flags & INTR_FAST) ? isa_handle_fast_intr :
isa_handle_intr), ii, flags, &ii->ih,
&intrcnt[INTRCNT_ISA_IRQ + irq->r_start],
isa_disable_intr, isa_enable_intr);
if (error) {
free(ii, M_DEVBUF);
return error;
}
mtx_lock_spin(&icu_lock);
isa_intr_enable(irq->r_start);
mtx_unlock_spin(&icu_lock);
*cookiep = ii;
if (child)
device_printf(child, "interrupting at ISA irq %d\n",
(int)irq->r_start);
return 0;
}