diff --git a/sys/powerpc/powermac/ata_macio.c b/sys/powerpc/powermac/ata_macio.c new file mode 100644 index 000000000000..6b163d1db15c --- /dev/null +++ b/sys/powerpc/powermac/ata_macio.c @@ -0,0 +1,241 @@ +/* + * Copyright 2002 by Peter Grehan. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * Mac-io ATA controller + */ +#include "opt_ata.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +/* + * Define the macio ata bus attachment. This creates a pseudo-bus that + * the ATA device can be attached to + */ +static int ata_macio_attach(device_t dev); +static int ata_macio_probe(device_t dev); +static int ata_macio_print_child(device_t dev, device_t child); +struct resource *ata_macio_alloc_resource(device_t, device_t, int, int *, + u_long, u_long, u_long, u_int); +static int ata_macio_release_resource(device_t, device_t, int, int, + struct resource *); + +static device_method_t ata_macio_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, ata_macio_probe), + DEVMETHOD(device_attach, ata_macio_attach), + DEVMETHOD(device_shutdown, bus_generic_shutdown), + DEVMETHOD(device_suspend, bus_generic_suspend), + DEVMETHOD(device_resume, bus_generic_resume), + + /* Bus methods */ + DEVMETHOD(bus_print_child, ata_macio_print_child), + DEVMETHOD(bus_alloc_resource, ata_macio_alloc_resource), + DEVMETHOD(bus_release_resource, ata_macio_release_resource), + DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), + DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), + DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), + DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), + + { 0, 0 } +}; + +static driver_t ata_macio_driver = { + "atamacio", + ata_macio_methods, + 0, +}; + +static devclass_t ata_macio_devclass; + +DRIVER_MODULE(atamacio, macio, ata_macio_driver, ata_macio_devclass, 0, 0); + + +static int +ata_macio_probe(device_t dev) +{ + char *type = macio_get_devtype(dev); + + if (strcmp(type, "ata") != 0) + return (ENXIO); + + /* Print keylargo/pangea ??? */ + device_set_desc(dev, "Mac-IO ATA Controller"); + return (0); +} + + +static int +ata_macio_attach(device_t dev) +{ + /* + * Add a single child per controller. Should be able + * to add two + */ + device_add_child(dev, "ata", + devclass_find_free_unit(ata_devclass, 0)); + + return (bus_generic_attach(dev)); +} + + +static int +ata_macio_print_child(device_t dev, device_t child) +{ + int retval = 0; + + retval += bus_print_child_header(dev, child); + retval += bus_print_child_footer(dev, child); + + return (retval); +} + +/* offset to control registers from base */ +#define ATA_MACIO_ALTOFFSET 0x160 + +struct resource * +ata_macio_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 resource *res = NULL; + int myrid; + u_int *ofw_regs; + + ofw_regs = macio_get_regs(dev); + + /* + * The offset for the register bank is in the first ofw register, + * with the base address coming from the parent macio bus (but + * accessible via the ata-macio child) + */ + if (type == SYS_RES_IOPORT) { + switch (*rid) { + case ATA_IOADDR_RID: + myrid = 0; + start = ofw_regs[0]; + end = start + (ATA_IOSIZE << 4) - 1; + count = ATA_IOSIZE << 4; + res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child, + SYS_RES_IOPORT, &myrid, + start, end, count, + PPC_BUS_SPARSE4 | flags); + break; + + case ATA_ALTADDR_RID: + myrid = 0; + start = ofw_regs[0] + ATA_MACIO_ALTOFFSET; + end = start + (ATA_ALTIOSIZE << 4) - 1; + count = ATA_ALTIOSIZE << 4; + res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child, + SYS_RES_IOPORT, &myrid, + start, end, count, + PPC_BUS_SPARSE4 | flags); + break; + + case ATA_BMADDR_RID: + /* looks difficult to support DBDMA in FreeBSD... */ + break; + } + return (res); + + } else if (type == SYS_RES_IRQ && *rid == ATA_IRQ_RID) { + /* + * Pass this on to the parent, using the IRQ from the + * ATA pseudo-bus resource + */ + res = bus_generic_rl_alloc_resource(device_get_parent(dev), + dev, SYS_RES_IRQ, 0, 0, ~0, 1, flags); + return (res); + + } else { + return (NULL); + } +} + + +static int +ata_macio_release_resource(device_t dev, device_t child, int type, int rid, + struct resource *r) +{ + printf("macio: release resource\n"); + return (0); +} + + +/* + * Define the actual ATA device. This is a sub-bus to the ata-macio layer + * to allow the higher layer bus to massage the resource allocation. + */ + +static int ata_macio_sub_probe(device_t dev); + +static device_method_t ata_macio_sub_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, ata_macio_sub_probe), + DEVMETHOD(device_attach, ata_attach), + DEVMETHOD(device_detach, ata_detach), + DEVMETHOD(device_resume, ata_resume), + + { 0, 0 } +}; + +static driver_t ata_macio_sub_driver = { + "ata", + ata_macio_sub_methods, + sizeof(struct ata_channel), +}; + +DRIVER_MODULE(ata, atamacio, ata_macio_sub_driver, ata_devclass, 0, 0); + +static int +ata_macio_sub_probe(device_t dev) +{ + struct ata_channel *ch = device_get_softc(dev); + + ch->unit = 0; + ch->flags = ATA_USE_16BIT; + + return ata_probe(dev); +} diff --git a/sys/powerpc/powermac/macio.c b/sys/powerpc/powermac/macio.c new file mode 100644 index 000000000000..bf8c57725d6d --- /dev/null +++ b/sys/powerpc/powermac/macio.c @@ -0,0 +1,484 @@ +/* + * Copyright 2002 by Peter Grehan. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * Driver for KeyLargo/Pangea, the MacPPC south bridge ASIC. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include + +#include + +#include +#include + +static MALLOC_DEFINE(M_MACIO, "macio", "macio device information"); + +static int macio_probe(device_t); +static int macio_attach(device_t); +static int macio_print_child(device_t dev, device_t child); +static void macio_probe_nomatch(device_t, device_t); +static int macio_read_ivar(device_t, device_t, int, uintptr_t *); +static int macio_write_ivar(device_t, device_t, int, uintptr_t); +static struct resource *macio_alloc_resource(device_t, device_t, int, int *, + u_long, u_long, u_long, u_int); +static int macio_activate_resource(device_t, device_t, int, int, + struct resource *); +static int macio_deactivate_resource(device_t, device_t, int, int, + struct resource *); +static int macio_release_resource(device_t, device_t, int, int, + struct resource *); +static struct resource_list *macio_get_resource_list (device_t, device_t); + +/* + * Bus interface definition + */ +static device_method_t macio_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, macio_probe), + DEVMETHOD(device_attach, macio_attach), + DEVMETHOD(device_detach, bus_generic_detach), + DEVMETHOD(device_shutdown, bus_generic_shutdown), + DEVMETHOD(device_suspend, bus_generic_suspend), + DEVMETHOD(device_resume, bus_generic_resume), + + /* Bus interface */ + DEVMETHOD(bus_print_child, macio_print_child), + DEVMETHOD(bus_probe_nomatch, macio_probe_nomatch), + DEVMETHOD(bus_read_ivar, macio_read_ivar), + DEVMETHOD(bus_write_ivar, macio_write_ivar), + DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), + DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), + + DEVMETHOD(bus_alloc_resource, macio_alloc_resource), + DEVMETHOD(bus_release_resource, macio_release_resource), + DEVMETHOD(bus_activate_resource, macio_activate_resource), + DEVMETHOD(bus_deactivate_resource, macio_deactivate_resource), + DEVMETHOD(bus_get_resource_list, macio_get_resource_list), + + { 0, 0 } +}; + +static driver_t macio_pci_driver = { + "macio", + macio_methods, + sizeof(struct macio_softc) +}; + +devclass_t macio_devclass; + +DRIVER_MODULE(macio, pci, macio_pci_driver, macio_devclass, 0, 0); + + +/* + * PCI ID search table + */ +static struct macio_pci_dev { + u_int32_t mpd_devid; + char *mpd_desc; +} macio_pci_devlist[] = { + { 0x0025106b, "Pangea I/O Controller" }, + { 0x0022106b, "KeyLargo I/O Controller" }, + { 0, NULL } +}; + +/* + * Devices to exclude from the probe + * XXX some of these may be required in the future... + */ +static char *macio_excl_name[] = { + "interrupt-controller", + "escc-legacy", + "gpio", + "timer", + NULL +}; + +static int +macio_inlist(char *name) +{ + int i; + + for (i = 0; macio_excl_name[i] != NULL; i++) + if (strcmp(name, macio_excl_name[i]) == 0) + return (1); + return (0); +} + + +/* + * Add an interrupt to the dev's resource list if present + */ +static void +macio_add_intr(phandle_t devnode, struct macio_devinfo *dinfo) +{ + u_int intr = -1; + + if ((OF_getprop(devnode, "interrupts", &intr, sizeof(intr)) != -1) || + (OF_getprop(devnode, "AAPL,interrupts", + &intr, sizeof(intr) != -1))) { + resource_list_add(&dinfo->mdi_resources, + SYS_RES_IRQ, 0, intr, intr, 1); + } + dinfo->mdi_interrupt = intr; +} + + +static void +macio_add_reg(phandle_t devnode, struct macio_devinfo *dinfo) +{ + u_int size; + u_int start; + u_int end; + + size = OF_getprop(devnode, "reg", dinfo->mdi_reg, + sizeof(dinfo->mdi_reg)); + + if (size != -1) { + + /* + * Only do a single range for the moment... + */ + dinfo->mdi_nregs = 1; + start = dinfo->mdi_reg[0]; + end = start + dinfo->mdi_reg[1] - 1; + resource_list_add(&dinfo->mdi_resources, SYS_RES_MEMORY, 0, + start, end, end - start + 1); + } else { + dinfo->mdi_nregs = -1; + } +} + +/* + * PCI probe + */ +static int +macio_probe(device_t dev) +{ + int i; + u_int32_t devid; + + devid = pci_get_devid(dev); + for (i = 0; macio_pci_devlist[i].mpd_desc != NULL; i++) { + if (devid == macio_pci_devlist[i].mpd_devid) { + device_set_desc(dev, macio_pci_devlist[i].mpd_desc); + return (0); + } + } + + return (ENXIO); +} + +/* + * PCI attach: scan OpenFirmware child nodes, and attach these as children + * of the macio bus + */ +static int +macio_attach(device_t dev) +{ + struct macio_softc *sc; + struct macio_devinfo *dinfo; + phandle_t root; + phandle_t child; + device_t cdev; + u_int reg[3]; + char *name, *type; + + sc = device_get_softc(dev); + root = sc->sc_node = OF_finddevice("mac-io"); + + /* + * Locate the device node and it's base address + */ + if (OF_getprop(root, "assigned-addresses", + reg, sizeof(reg)) < sizeof(reg)) { + return (ENXIO); + } + + sc->sc_base = reg[2]; + sc->sc_size = MACIO_REG_SIZE; + + sc->sc_mem_rman.rm_type = RMAN_ARRAY; + sc->sc_mem_rman.rm_descr = "IOBus Device Memory"; + if (rman_init(&sc->sc_mem_rman) != 0) { + device_printf(dev, + "failed to init mem range resources\n"); + return (ENXIO); + } + rman_manage_region(&sc->sc_mem_rman, 0, sc->sc_size); + + /* + * Iterate through the sub-devices + */ + for (child = OF_child(root); child != 0; child = OF_peer(child)) { + OF_getprop_alloc(child, "name", 1, (void **)&name); + OF_getprop_alloc(child, "device_type", 1, (void **)&type); + + if (macio_inlist(name)) { + free(name, M_OFWPROP); + free(type, M_OFWPROP); + continue; + } + + cdev = device_add_child(dev, NULL, -1); + if (cdev != NULL) { + dinfo = malloc(sizeof(*dinfo), M_MACIO, M_WAITOK); + memset(dinfo, 0, sizeof(*dinfo)); + resource_list_init(&dinfo->mdi_resources); + dinfo->mdi_node = child; + dinfo->mdi_name = name; + dinfo->mdi_device_type = type; + macio_add_intr(child, dinfo); + macio_add_reg(child, dinfo); + device_set_ivars(cdev, dinfo); + } else { + free(name, M_OFWPROP); + free(type, M_OFWPROP); + } + } + + return (bus_generic_attach(dev)); +} + + +static int +macio_print_child(device_t dev, device_t child) +{ + struct macio_devinfo *dinfo; + struct resource_list *rl; + int retval = 0; + + dinfo = device_get_ivars(child); + rl = &dinfo->mdi_resources; + + retval += bus_print_child_header(dev, child); + + retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#lx"); + retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld"); + + retval += bus_print_child_footer(dev, child); + + return (retval); +} + + +static void +macio_probe_nomatch(device_t dev, device_t child) +{ + u_int *regs; + + if (bootverbose) { + regs = macio_get_regs(child); + + device_printf(dev, "<%s, %s>", macio_get_devtype(child), + macio_get_name(child)); + printf("at offset 0x%x (no driver attached)\n", regs[0]); + } +} + + +static int +macio_read_ivar(device_t dev, device_t child, int which, uintptr_t *result) +{ + struct macio_devinfo *dinfo; + + if ((dinfo = device_get_ivars(child)) == 0) + return (ENOENT); + + switch (which) { + case MACIO_IVAR_NODE: + *result = dinfo->mdi_node; + break; + case MACIO_IVAR_NAME: + *result = (uintptr_t)dinfo->mdi_name; + break; + case MACIO_IVAR_DEVTYPE: + *result = (uintptr_t)dinfo->mdi_device_type; + break; + case MACIO_IVAR_NREGS: + *result = dinfo->mdi_nregs; + break; + case MACIO_IVAR_REGS: + *result = (uintptr_t) &dinfo->mdi_reg[0]; + break; + default: + return (ENOENT); + } + + return (0); +} + + +static int +macio_write_ivar(device_t dev, device_t child, int which, uintptr_t value) +{ + return (EINVAL); +} + + +static struct resource * +macio_alloc_resource(device_t bus, device_t child, int type, int *rid, + u_long start, u_long end, u_long count, u_int flags) +{ + struct macio_softc *sc; + int needactivate; + struct resource *rv; + struct rman *rm; + bus_space_tag_t tagval; + + sc = device_get_softc(bus); + + needactivate = flags & RF_ACTIVE; + flags &= ~RF_ACTIVE; + + switch (type) { + case SYS_RES_MEMORY: + case SYS_RES_IOPORT: + rm = &sc->sc_mem_rman; + tagval = PPC_BUS_SPACE_MEM; + if (flags & PPC_BUS_SPARSE4) + tagval |= 4; + break; + case SYS_RES_IRQ: + return (bus_alloc_resource(bus, type, rid, start, end, count, + flags)); + break; + default: + device_printf(bus, "unknown resource request from %s\n", + device_get_nameunit(child)); + return (NULL); + } + + rv = rman_reserve_resource(rm, start, end, count, flags, child); + if (rv == NULL) { + device_printf(bus, "failed to reserve resource for %s\n", + device_get_nameunit(child)); + return (NULL); + } + + rman_set_bustag(rv, tagval); + rman_set_bushandle(rv, rman_get_start(rv)); + + if (needactivate) { + if (bus_activate_resource(child, type, *rid, rv) != 0) { + device_printf(bus, + "failed to activate resource for %s\n", + device_get_nameunit(child)); + rman_release_resource(rv); + return (NULL); + } + } + + return (rv); +} + + +static int +macio_release_resource(device_t bus, device_t child, int type, int rid, + struct resource *res) +{ + if (rman_get_flags(res) & RF_ACTIVE) { + int error = bus_deactivate_resource(child, type, rid, res); + if (error) + return error; + } + + return (rman_release_resource(res)); +} + + +static int +macio_activate_resource(device_t bus, device_t child, int type, int rid, + struct resource *res) +{ + struct macio_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)) { + p = pmap_mapdev((vm_offset_t)rman_get_start(res) + sc->sc_base, + (vm_size_t)rman_get_size(res)); + if (p == NULL) + return (ENOMEM); + rman_set_virtual(res, p); + rman_set_bushandle(res, (u_long)p); + } + + return (rman_activate_resource(res)); +} + + +static int +macio_deactivate_resource(device_t bus, device_t child, int type, int rid, + struct resource *res) +{ + /* + * If this is a memory resource, unmap it. + */ + if ((type == SYS_RES_MEMORY) || (type == SYS_RES_IOPORT)) { + u_int32_t psize; + + psize = rman_get_size(res); + pmap_unmapdev((vm_offset_t)rman_get_virtual(res), psize); + } + + return (rman_deactivate_resource(res)); +} + + +static struct resource_list * +macio_get_resource_list (device_t dev, device_t child) +{ + struct macio_devinfo *dinfo = device_get_ivars(child); + struct resource_list *rl = &dinfo->mdi_resources; + + if (!rl) + return (NULL); + + return (rl); +} diff --git a/sys/powerpc/powermac/maciovar.h b/sys/powerpc/powermac/maciovar.h new file mode 100644 index 000000000000..9570f5b46669 --- /dev/null +++ b/sys/powerpc/powermac/maciovar.h @@ -0,0 +1,92 @@ +/* + * Copyright 2002 by Peter Grehan. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _MACIO_MACIOVAR_H_ +#define _MACIO_MACIOVAR_H_ + +/* + * Accessors for macio devices + */ + +enum macio_ivars { + MACIO_IVAR_NODE, + MACIO_IVAR_NAME, + MACIO_IVAR_DEVTYPE, + MACIO_IVAR_NREGS, + MACIO_IVAR_REGS, +}; + +#define MACIO_ACCESSOR(var, ivar, type) \ + __BUS_ACCESSOR(macio, var, MACIO, ivar, type) + +MACIO_ACCESSOR(node, NODE, phandle_t) +MACIO_ACCESSOR(name, NAME, char *) +MACIO_ACCESSOR(devtype, DEVTYPE, char *) +MACIO_ACCESSOR(nregs, NREGS, u_int) +MACIO_ACCESSOR(regs, REGS, u_int *) + +#undef MACIO_ACCESSOR + +/* + * Upper limit on OpenFirmware reg array + */ +#define MACIO_MAXREG 16 + +/* + * The addr space size + * XXX it would be better if this could be determined by querying the + * PCI device, but there isn't an access method for this + */ +#define MACIO_REG_SIZE 0x7ffff + +/* + * Macio softc + */ +struct macio_softc { + phandle_t sc_node; + vm_offset_t sc_base; + vm_offset_t sc_size; + struct rman sc_mem_rman; +}; + +/* + * Per macio device structure. + */ +struct macio_devinfo { + phandle_t mdi_node; + char *mdi_name; + char *mdi_device_type; + int mdi_interrupt; + int mdi_base; + int mdi_nregs; + u_int mdi_reg[MACIO_MAXREG]; + struct resource_list mdi_resources; +}; + +#endif /* _MACIO_MACIOVAR_H_ */