sun4u/io/sbbc.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * Starcat PCI SBBC Nexus Driver.
 *
 * This source code's compiled binary runs on both a Starcat System
 * Controller (SSC) and a Starcat Domain.  One of the SBBC hardware
 * registers is read during attach(9e) in order to determine which
 * environment the driver is executing on.
 *
 * On both the SSC and the Domain, this driver provides nexus driver
 * services to its Device Tree children.  Note that the children in
 * each environment are not necessarily the same.
 *
 * This driver allows one concurrent open(2) of its associated device
 * (/dev/sbbc0).  The client uses the file descriptor to issue
 * ioctl(2)'s in order to read and write from the 2MB (PCI) space
 * reserved for "SBBC Internal Registers".  Among other things,
 * these registers consist of command/control/status registers for
 * devices such as Console Bus, I2C, EPLD, IOSRAM, and JTAG.  The 2MB
 * space is very sparse; EINVAL is returned if a reserved or unaligned
 * address is specified in the ioctl(2).
 *
 * Note that the 2MB region reserved for SBBC Internal Registers is
 * a subset of the 128MB of PCI address space addressable by the SBBC
 * ASIC.  Address space outside of the 2MB (such as the 64MB reserved
 * for the Console Bus) is not accessible via this driver.
 *
 * Also, note that the SBBC Internal Registers are only read and
 * written by the SSC; no process on the Domain accesses these
 * registers.  As a result, the registers are unmapped (when running
 * on the Domain) near the end of attach(9e) processing.  This conserves
 * kernel virtual address space resources (as one instance of the driver
 * is created for each Domain-side IO assembly).  (To be complete, only
 * one instance of the driver is created on the SSC).
 */

#include <sys/types.h>

#include <sys/conf.h>       /* req. by dev_ops flags MTSAFE etc. */
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/ddi_subrdefs.h>
#include <sys/pci.h>
#include <sys/pci/pci_nexus.h>
#include <sys/autoconf.h>
#include <sys/cmn_err.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/machsystm.h>
#include <sys/modctl.h>
#include <sys/stat.h>


#include <sys/sbbcreg.h>    /* hw description */
#include <sys/sbbcvar.h>    /* driver description */
#include <sys/sbbcio.h>     /* ioctl description */

#define getprop(dip, name, addr, intp)      \
        ddi_getlongprop(DDI_DEV_T_ANY, (dip), DDI_PROP_DONTPASS, \
                (name), (caddr_t)(addr), (intp))

/* driver entry point fn definitions */
static int sbbc_open(dev_t *, int, int, cred_t *);
static int sbbc_close(dev_t, int, int, cred_t *);
static int sbbc_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

/* configuration entry point fn definitions */
static int sbbc_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int sbbc_attach(dev_info_t *, ddi_attach_cmd_t);
static int sbbc_detach(dev_info_t *, ddi_detach_cmd_t);

/* local utility routines */
/*
 * NOTE - sbbc_offset_valid contains detailed address information taken from
 * the Serengeti Architecture Programmer's Reference Manual.  If any
 * changes are made to the SBBC registers, this routine may need to be
 * updated.
 */
static int sbbc_offset_valid(uint32_t offset);

/*
 * function prototypes for bus ops routines:
 */
static int sbbc_busmap(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
    off_t offset, off_t len, caddr_t *addrp);
static int sbbc_ctlops(dev_info_t *dip, dev_info_t *rdip,
    ddi_ctl_enum_t op, void *arg, void *result);

static int sbbc_intr_ops(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_op_t intr_op, ddi_intr_handle_impl_t *hdlp, void *result);
static int sbbc_add_intr_impl(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_op_t intr_op, ddi_intr_handle_impl_t *hdlp, void *result);
static int sbbc_remove_intr_impl(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_op_t intr_op, ddi_intr_handle_impl_t *hdlp, void *result);
static int sbbc_update_intr_state(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_op_t intr_op, ddi_intr_handle_impl_t *hdlp, void *result);

static int sbbc_apply_range(struct sbbcsoft *sbbc_p, dev_info_t *rdip,
    sbbc_child_regspec_t *child_rp, pci_regspec_t *rp);

static int sbbc_init(struct sbbcsoft *);

static uint_t sbbc_intr_wrapper(caddr_t arg);

static int sbbc_get_ranges(struct sbbcsoft *);
static int sbbc_config4pci(struct sbbcsoft *);
static int sbbc_initchild(dev_info_t *, dev_info_t *, dev_info_t *);
static int sbbc_uninitchild(dev_info_t *, dev_info_t *);
static void sbbc_remove_reg_maps(struct sbbcsoft *);

/* debugging functions */
#ifdef DEBUG
uint32_t sbbc_dbg_flags = 0x0;
static void sbbc_dbg(uint32_t flag, dev_info_t *dip, char *fmt,
    uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5);
static void sbbc_dump_devid(dev_info_t *, struct sbbcsoft *, int instance);
#endif

/*
 * For tracing, allocate space for the trace buffer
 */
#if defined(SBBC_TRACE)
struct sbbctrace sbbctrace_buffer[NSBBCTRACE+1];
struct sbbctrace *sbbctrace_ptr;
int sbbctrace_count;
#endif

/*
 * Local declarations and variables
 */

static void *sbbcsoft_statep;

/* Determines whether driver is executing on System Controller or Domain */
int sbbc_scmode = FALSE;

/*
 * ops stuff.
 */
static struct bus_ops sbbc_bus_ops = {
    BUSO_REV,
    sbbc_busmap,
    0,
    0,
    0,
    NULL,           /* (*bus_map_fault)() */
    ddi_no_dma_map,
    ddi_no_dma_allochdl,
    ddi_no_dma_freehdl,     /* (*bus_dma_freehdl)() */
    ddi_no_dma_bindhdl,     /* (*bus_dma_bindhdl)() */
    ddi_no_dma_unbindhdl,   /* (*bus_dma_unbindhdl)() */
    ddi_no_dma_flush,   /* (*bus_dma_flush)() */
    ddi_no_dma_win,     /* (*bus_dma_win)() */
    ddi_no_dma_mctl,    /* (*bus_dma_ctl)() */
    sbbc_ctlops,
    ddi_bus_prop_op,
    0,          /* (*bus_get_eventcookie)();    */
    0,          /* (*bus_add_eventcall)();  */
    0,          /* (*bus_remove_eventcall)();   */
    0,          /* (*bus_post_event)();     */
    0,          /* (*bus_intr_ctl)();   */
    0,          /* (*bus_config)(); */
    0,          /* (*bus_unconfig)();   */
    0,          /* (*bus_fm_init)();    */
    0,          /* (*bus_fm_fini)();    */
    0,          /* (*bus_fm_access_enter)();    */
    0,          /* (*bus_fm_access_exit)(); */
    0,          /* (*bus_power)();  */
    sbbc_intr_ops       /* (*bus_intr_op)();    */
};

/*
 * cb_ops
 */
static struct cb_ops sbbc_cb_ops = {
    sbbc_open,      /* cb_open */
    sbbc_close,     /* cb_close */
    nodev,          /* cb_strategy */
    nodev,          /* cb_print */
    nodev,          /* cb_dump */
    nodev,          /* cb_read */
    nodev,          /* cb_write */
    sbbc_ioctl,     /* cb_ioctl */
    nodev,          /* cb_devmap */
    nodev,          /* cb_mmap */
    nodev,          /* cb_segmap */
    nochpoll,       /* cb_chpoll */
    ddi_prop_op,        /* cb_prop_op */
    NULL,           /* cb_stream */
    (int)(D_NEW | D_MP) /* cb_flag */
};

/*
 * Declare ops vectors for auto configuration.
 */
struct dev_ops  sbbc_ops = {
    DEVO_REV,       /* devo_rev */
    0,          /* devo_refcnt */
    sbbc_getinfo,       /* devo_getinfo */
    nulldev,        /* devo_identify */
    nulldev,        /* devo_probe */
    sbbc_attach,        /* devo_attach */
    sbbc_detach,        /* devo_detach */
    nodev,          /* devo_reset */
    &sbbc_cb_ops,       /* devo_cb_ops */
    &sbbc_bus_ops,      /* devo_bus_ops */
    nulldev,            /* devo_power */
    ddi_quiesce_not_supported,  /* devo_quiesce */
};

/*
 * Loadable module support.
 */
extern struct mod_ops mod_driverops;

static struct modldrv sbbcmodldrv = {
    &mod_driverops,     /* type of module - driver */
    "PCI Sbbc Nexus Driver",
    &sbbc_ops,
};

static struct modlinkage sbbcmodlinkage = {
    MODREV_1,
    &sbbcmodldrv,
    NULL
};

int
_init(void)
{
    int    error;

    if ((error = ddi_soft_state_init(&sbbcsoft_statep,
        sizeof (struct sbbcsoft), 1)) != 0)
        return (error);
    if ((error = mod_install(&sbbcmodlinkage)) != 0)
        ddi_soft_state_fini(&sbbcsoft_statep);

    return (error);
}

int
_fini(void)
{
    int    error;

    if ((error = mod_remove(&sbbcmodlinkage)) == 0)
        ddi_soft_state_fini(&sbbcsoft_statep);

    return (error);
}

int
_info(struct modinfo *modinfop)
{
    return (mod_info(&sbbcmodlinkage, modinfop));
}

static int
sbbc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
    int instance;
    char    name[32];
    struct  sbbcsoft *sbbcsoftp;
    struct ddi_device_acc_attr attr;
    uint32_t sbbc_id_reg;

    attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
    attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
    attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;

    /* initialize tracing */
    SBBCTRACEINIT();

    SBBC_DBG0(SBBC_DBG_ATTACH, dip, "Attaching\n");

    instance = ddi_get_instance(dip);
    switch (cmd) {
    case DDI_ATTACH:
        break;
    case DDI_RESUME:
        if (!(sbbcsoftp =
            ddi_get_soft_state(sbbcsoft_statep, instance))) {
            cmn_err(CE_WARN, "sbbc_attach:resume: unable "
                "to acquire sbbcsoftp for instance %d",
                instance);
            return (DDI_FAILURE);
        }
        mutex_enter(&sbbcsoftp->umutex);
        if (!sbbcsoftp->suspended) {
            mutex_exit(&sbbcsoftp->umutex);
            return (DDI_FAILURE);
        }
        sbbcsoftp->suspended = 0;
        mutex_exit(&sbbcsoftp->umutex);
        return (DDI_SUCCESS);

    default:
        return (DDI_FAILURE);
    }

    if (ddi_soft_state_zalloc(sbbcsoft_statep, instance) != 0) {
        cmn_err(CE_WARN, "sbbc_attach: Unable to allocate statep "
            "for instance %d", instance);
        return (DDI_FAILURE);
    }

    sbbcsoftp = ddi_get_soft_state(sbbcsoft_statep, instance);

    if (sbbcsoftp == NULL) {
        cmn_err(CE_WARN, "sbbc_attach: Unable to acquire "
            "sbbcsoftp for instance %d", instance);
        ddi_soft_state_free(sbbcsoft_statep, instance);
        return (DDI_FAILURE);
    }

    sbbcsoftp->instance = instance;
    sbbcsoftp->dip = dip;
    sbbcsoftp->oflag = FALSE;

    /*
     * Read our ranges property from OBP to map children space.
     * And setup the internal structure for a later use when
     * a child gets initialized.
     */
    if (sbbc_get_ranges(sbbcsoftp)) {
        cmn_err(CE_WARN, "sbbc_attach: Unable to read sbbc "
            "ranges from OBP %d", instance);
        ddi_soft_state_free(sbbcsoft_statep, instance);
        return (DDI_FAILURE);
    }

    if (sbbc_config4pci(sbbcsoftp)) {
        cmn_err(CE_WARN, "sbbc_attach: Unable to configure "
            "sbbc on PCI %d", instance);
        kmem_free(sbbcsoftp->rangep, sbbcsoftp->range_len);
        ddi_soft_state_free(sbbcsoft_statep, instance);
        return (DDI_FAILURE);
    }

    mutex_init(&sbbcsoftp->umutex, NULL, MUTEX_DRIVER, (void *)NULL);
    mutex_init(&sbbcsoftp->sbbc_intr_mutex, NULL,
        MUTEX_DRIVER, (void *)NULL);

    /* Map SBBC's Internal Registers */
    if (ddi_regs_map_setup(dip, 1, (caddr_t *)&sbbcsoftp->pci_sbbc_map,
        offsetof(struct pci_sbbc, sbbc_internal_regs),
        sizeof (struct sbbc_regs_map), &attr,
        &sbbcsoftp->pci_sbbc_map_handle) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "(%d):sbbc_attach failed to map sbbc_reg",
            instance);
        goto failed;
    }

    SBBC_DBG1(SBBC_DBG_ATTACH, dip, "Mapped sbbc at %lx\n",
        sbbcsoftp->pci_sbbc_map);
#ifdef DEBUG
    sbbc_dump_devid(dip, sbbcsoftp, instance);
#endif
    /*
     * Read a hardware register to determine if we are executing on
     * a Starcat System Controller or a Starcat Domain.
     */
    sbbc_id_reg = ddi_get32(sbbcsoftp->pci_sbbc_map_handle,
        &sbbcsoftp->pci_sbbc_map->device_conf);

    if (sbbc_id_reg & SBBC_SC_MODE) {
        sbbc_scmode = TRUE;
        SBBC_DBG1(SBBC_DBG_ATTACH, dip, "SBBC(%d) nexus running "
            "in System Controller Mode.\n", instance);

        /* initialize SBBC ASIC */
        if (!sbbc_init(sbbcsoftp)) {
            goto failed;
        }
    } else {
        sbbc_scmode = FALSE;
        SBBC_DBG1(SBBC_DBG_ATTACH, dip, "SBBC(%d) nexus "
            "running in Domain Mode.\n", instance);

        /* initialize SBBC ASIC before we unmap registers */
        if (!sbbc_init(sbbcsoftp)) {
            goto failed;
        }

        /*
         * Access to SBBC registers is no longer needed.  Unmap
         * the registers to conserve kernel virtual address space.
         */
        SBBC_DBG1(SBBC_DBG_ATTACH, dip, "SBBC(%d): unmap "
            "SBBC registers\n", instance);
        sbbc_remove_reg_maps(sbbcsoftp);
        sbbcsoftp->pci_sbbc_map = NULL;
    }

    (void) sprintf(name, "sbbc%d", instance);

    if (ddi_create_minor_node(dip, name, S_IFCHR, instance, NULL,
        NULL) == DDI_FAILURE) {
        ddi_remove_minor_node(dip, NULL);
        goto failed;
    }

    ddi_report_dev(dip);

    SBBC_DBG0(SBBC_DBG_ATTACH, dip, "Attached successfully\n");

    return (DDI_SUCCESS);

failed:
    mutex_destroy(&sbbcsoftp->sbbc_intr_mutex);
    mutex_destroy(&sbbcsoftp->umutex);

    sbbc_remove_reg_maps(sbbcsoftp);
    kmem_free(sbbcsoftp->rangep, sbbcsoftp->range_len);
    ddi_soft_state_free(sbbcsoft_statep, instance);

    SBBC_DBG0(SBBC_DBG_ATTACH, dip, "Attach failed\n");

    return (DDI_FAILURE);
}

static int
sbbc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    int     instance;
    struct sbbcsoft *sbbcsoftp;

    SBBCTRACE(sbbc_detach, 'DETA', dip);

    instance = ddi_get_instance(dip);

    switch (cmd) {
    case DDI_DETACH:
        break;

    case DDI_SUSPEND:
        if (!(sbbcsoftp =
            ddi_get_soft_state(sbbcsoft_statep, instance))) {
            cmn_err(CE_WARN,
                "sbbc_detach: unable to get softstate %p",
                (void *)sbbcsoftp);
            return (DDI_FAILURE);
        }
        mutex_enter(&sbbcsoftp->umutex);
        if (sbbcsoftp->suspended) {
            mutex_exit(&sbbcsoftp->umutex);
            return (DDI_FAILURE);
        }
        sbbcsoftp->suspended = 1;
        mutex_exit(&sbbcsoftp->umutex);
        return (DDI_SUCCESS);

    default:
        return (DDI_FAILURE);
    }

    if (!(sbbcsoftp = ddi_get_soft_state(sbbcsoft_statep, instance))) {
        cmn_err(CE_WARN, "sbbc_detach: unable to get softstate %p",
            (void *)sbbcsoftp);
        return (DDI_FAILURE);
    }

    ddi_remove_minor_node(dip, NULL);

    mutex_destroy(&sbbcsoftp->sbbc_intr_mutex);
    mutex_destroy(&sbbcsoftp->umutex);

    sbbc_remove_reg_maps(sbbcsoftp);
    kmem_free(sbbcsoftp->rangep, sbbcsoftp->range_len);

    ddi_soft_state_free(sbbcsoft_statep, instance);

    return (DDI_SUCCESS);

}


/*
 * Translate child's address into parents.
 */
static int
sbbc_busmap(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
        off_t off, off_t len, caddr_t *addrp)
{
    struct sbbcsoft *sbbcsoftp;
    sbbc_child_regspec_t *child_rp, *child_regs;
    pci_regspec_t pci_reg;
    ddi_map_req_t p_map_request;
    int rnumber, i, n;
    int rval = DDI_SUCCESS;
    int instance;

    SBBC_DBG4(SBBC_DBG_BUSMAP, dip,
        "mapping child %s, type %llx, off %llx, len %llx\n",
        ddi_driver_name(rdip), mp->map_type, off, len);

    SBBCTRACE(sbbc_busmap, 'BMAP', mp);

    /*
     * Handle the mapping according to its type.
     */
    instance = ddi_get_instance(dip);
    if (!(sbbcsoftp = ddi_get_soft_state(sbbcsoft_statep, instance)))
        return (DDI_FAILURE);

    switch (mp->map_type) {
    case DDI_MT_REGSPEC:

        /*
         * We assume the register specification is in sbbc format.
         * We must convert it into a PCI format regspec and pass
         * the request to our parent.
         */
        child_rp = (sbbc_child_regspec_t *)mp->map_obj.rp;
        break;

    case DDI_MT_RNUMBER:

        /*
         * map_type 0
         * Get the "reg" property from the device node and convert
         * it to our parent's format.
         */
        rnumber = mp->map_obj.rnumber;

        /* get the requester's reg property */
        if (ddi_getlongprop(DDI_DEV_T_ANY, rdip, DDI_PROP_DONTPASS,
            "reg", (caddr_t)&child_regs, &i) != DDI_SUCCESS) {
            cmn_err(CE_WARN,
                "SBBC: couldn't get %s ranges property %d",
                ddi_get_name(sbbcsoftp->dip), instance);
            return (DDI_ME_RNUMBER_RANGE);
        }
        n = i / sizeof (sbbc_child_regspec_t);

        if (rnumber < 0 || rnumber >= n) {
            kmem_free(child_regs, i);
            return (DDI_ME_RNUMBER_RANGE);
        }
        child_rp = &child_regs[rnumber];
        break;

    default:
        return (DDI_ME_INVAL);

    }

    /* Adjust our reg property with offset and length */
    child_rp->addr_low += off;

    if (len)
        child_rp->size = len;

    /*
     * Combine this reg prop. into our parents PCI address using the ranges
     * property.
     */
    rval = sbbc_apply_range(sbbcsoftp, rdip, child_rp, &pci_reg);

    if (mp->map_type == DDI_MT_RNUMBER)
        kmem_free(child_regs, i);

    if (rval != DDI_SUCCESS)
        return (rval);

    p_map_request = *mp;
    p_map_request.map_type = DDI_MT_REGSPEC;
    p_map_request.map_obj.rp = (struct regspec *)&pci_reg;

    /* Send it to PCI nexus to map into the PCI space */
    rval = ddi_map(dip, &p_map_request, 0, 0, addrp);

    return (rval);

}


/* new intr_ops structure */
static int
sbbc_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
    ddi_intr_handle_impl_t *hdlp, void *result)
{
    int ret = DDI_SUCCESS;

    switch (intr_op) {
    case DDI_INTROP_GETCAP:
        *(int *)result = DDI_INTR_FLAG_LEVEL;
        break;
    case DDI_INTROP_ALLOC:
        *(int *)result = hdlp->ih_scratch1;
        break;
    case DDI_INTROP_FREE:
        break;
    case DDI_INTROP_GETPRI:
        if (hdlp->ih_pri == 0) {
            hdlp->ih_pri = 0x1;

            cmn_err(CE_WARN, "%s%d assigning default interrupt "
                "level %d for device %s%d", ddi_driver_name(dip),
                ddi_get_instance(dip), hdlp->ih_pri,
                ddi_driver_name(rdip), ddi_get_instance(rdip));
        }

        *(int *)result = hdlp->ih_pri;

        break;
    case DDI_INTROP_ADDISR:
        ret = sbbc_add_intr_impl(dip, rdip, intr_op, hdlp, result);
        break;
    case DDI_INTROP_REMISR:
        ret = sbbc_remove_intr_impl(dip, rdip, intr_op, hdlp, result);
        break;
    case DDI_INTROP_ENABLE:
        ret = sbbc_update_intr_state(dip, rdip, intr_op, hdlp, &result);
        break;
    case DDI_INTROP_DISABLE:
        ret = sbbc_update_intr_state(dip, rdip, intr_op, hdlp, &result);
        break;
    case DDI_INTROP_NINTRS:
    case DDI_INTROP_NAVAIL:
        *(int *)result = i_ddi_get_intx_nintrs(rdip);
        break;
    case DDI_INTROP_SUPPORTED_TYPES:
        /* PCI nexus driver supports only fixed interrupts */
        *(int *)result = i_ddi_get_intx_nintrs(rdip) ?
            DDI_INTR_TYPE_FIXED : 0;
        break;
    default:
        ret = DDI_ENOTSUP;
        break;
    }

    return (ret);
}


static int
sbbc_add_intr_impl(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
    ddi_intr_handle_impl_t *hdlp, void *result)
{
    sbbcsoft_t *sbbcsoftp;
    sbbc_child_intr_t *childintr;
    int instance, i, rval = DDI_SUCCESS;

    SBBC_DBG2(SBBC_DBG_INTR, dip,
        "add: rdip 0x%llx hdlp 0x%llx\n", rdip, hdlp);

    /* insert the sbbc isr wrapper instead */
    instance = ddi_get_instance(dip);
    if (!(sbbcsoftp = ddi_get_soft_state(sbbcsoft_statep, instance)))
        return (DDI_FAILURE);

    childintr = kmem_zalloc(sizeof (struct sbbc_child_intr), KM_SLEEP);

    childintr->name = ddi_get_name(rdip);
    childintr->inum = hdlp->ih_inum;
    childintr->intr_handler = hdlp->ih_cb_func;
    childintr->arg1 = hdlp->ih_cb_arg1;
    childintr->arg2 = hdlp->ih_cb_arg2;
    childintr->status = SBBC_INTR_STATE_DISABLE;

    for (i = 0; i < MAX_SBBC_DEVICES; i++) {
        if (sbbcsoftp->child_intr[i] == 0) {
            sbbcsoftp->child_intr[i] = childintr;
            break;
        }
    }

    DDI_INTR_ASSIGN_HDLR_N_ARGS(hdlp,
        (ddi_intr_handler_t *)sbbc_intr_wrapper,
        (caddr_t)sbbcsoftp, NULL);

    if ((rval = i_ddi_intr_ops(dip, rdip, intr_op,
        hdlp, result)) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "sbbc%d: failed to add intr for %s",
            instance, ddi_get_name(rdip));
        kmem_free(childintr, sizeof (struct sbbc_child_intr));
        sbbcsoftp->child_intr[i] = NULL;
    }

    /*
     * Restore original interrupt handler
     * and arguments in interrupt handle.
     */
    DDI_INTR_ASSIGN_HDLR_N_ARGS(hdlp, childintr->intr_handler,
        childintr->arg1, childintr->arg2);

    return (rval);
}

static int
sbbc_remove_intr_impl(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
    ddi_intr_handle_impl_t *hdlp, void *result)
{
    sbbcsoft_t *sbbcsoftp;
    sbbc_child_intr_t *childintr;
    int instance, i, rval = DDI_SUCCESS;

    SBBC_DBG2(SBBC_DBG_INTR, dip,
        "remove: rdip 0x%llx hdlp 0x%llx\n", rdip, hdlp);

    instance = ddi_get_instance(dip);
    if (!(sbbcsoftp = ddi_get_soft_state(sbbcsoft_statep, instance)))
        return (DDI_FAILURE);

    /* remove the sbbc isr wrapper instead */
    for (i = 0; i < MAX_SBBC_DEVICES; i++) {
        if (sbbcsoftp->child_intr[i]) {
            childintr = sbbcsoftp->child_intr[i];
            if (childintr->status == SBBC_INTR_STATE_DISABLE &&
                childintr->name == ddi_get_name(rdip)) {
                /* put back child's inum */
                hdlp->ih_inum = childintr->inum;
                break;
            }
        }
    }

    if (i >= MAX_SBBC_DEVICES) {
        cmn_err(CE_WARN, "sbbc%d:obound failed to remove intr for %s",
            instance, ddi_get_name(rdip));
        return (DDI_FAILURE);
    }

    if ((rval = i_ddi_intr_ops(dip, rdip, intr_op,
        hdlp, result)) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "sbbc%d: failed to remove intr for %s",
            instance, ddi_get_name(rdip));
        return (rval);
    }

    kmem_free(childintr, sizeof (struct sbbc_child_intr));
    sbbcsoftp->child_intr[i] = NULL;

    return (rval);
}


static int
sbbc_update_intr_state(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
    ddi_intr_handle_impl_t *hdlp, void *result)
{
    sbbcsoft_t      *sbbcsoftp;
    sbbc_child_intr_t   *childintr;
    int         instance, i;
    int         ret = DDI_SUCCESS;

    SBBC_DBG2(SBBC_DBG_INTR, dip, "sbbc_update_intr_state: "
        "rdip 0x%llx hdlp 0x%llx state 0x%x\n", rdip, hdlp);

    instance = ddi_get_instance(dip);
    if (!(sbbcsoftp = ddi_get_soft_state(sbbcsoft_statep, instance)))
        return (DDI_FAILURE);

    for (i = 0; i < MAX_SBBC_DEVICES; i++) {
        if (sbbcsoftp->child_intr[i]) {
            childintr = sbbcsoftp->child_intr[i];
            if (childintr->name == ddi_get_name(rdip))
                break;
        }
    }

    if (i >= MAX_SBBC_DEVICES) {
        cmn_err(CE_WARN, "sbbc%d: failed to update intr state for %s",
            instance, ddi_get_name(rdip));
        return (DDI_FAILURE);
    }

    if ((ret = i_ddi_intr_ops(dip, rdip, intr_op,
        hdlp, result)) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "sbbc%d: failed to update intr state for %s",
            instance, ddi_get_name(rdip));
        return (ret);
    }

    /* Update the interrupt state */
    childintr->status = (intr_op == DDI_INTROP_ENABLE) ?
        SBBC_INTR_STATE_ENABLE : SBBC_INTR_STATE_DISABLE;

    return (ret);
}


/*
 * This entry point is called before a child's probe or attach is called.
 * The arg pointer points to child's dev_info_t structure.
 */
static int
sbbc_ctlops(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t op,
        void *arg, void *result)
{
    sbbc_child_regspec_t *child_rp;
    int i, n;

    SBBC_DBG3(SBBC_DBG_CTLOPS, dip,
        "Initializing %s, arg %x, op %x\n",
        ddi_driver_name(rdip), arg, op);

    SBBCTRACE(sbbc_ctlops, 'CTLO', arg);

    switch (op) {
    case DDI_CTLOPS_INITCHILD: {
        return (sbbc_initchild(dip, rdip, (dev_info_t *)arg));
    }

    case DDI_CTLOPS_UNINITCHILD: {
        return (sbbc_uninitchild(rdip, (dev_info_t *)arg));
    }

    case DDI_CTLOPS_REPORTDEV:

        cmn_err(CE_CONT, "?%s%d at %s%d: offset %s\n",
            ddi_driver_name(rdip), ddi_get_instance(rdip),
            ddi_driver_name(dip), ddi_get_instance(dip),
            ddi_get_name_addr(rdip));
        return (DDI_SUCCESS);

    case DDI_CTLOPS_REGSIZE:

        if (getprop(rdip, "reg", &child_rp, &i) != DDI_SUCCESS) {
            return (DDI_FAILURE);
        }
        n = i / sizeof (sbbc_child_regspec_t);
        if (*(int *)arg < 0 || *(int *)arg >= n) {
            kmem_free(child_rp, i);
            return (DDI_FAILURE);
        }
        *((off_t *)result) = child_rp[*(int *)arg].size;
        kmem_free(child_rp, i);
        return (DDI_SUCCESS);

    case DDI_CTLOPS_NREGS:

        if (getprop(rdip, "reg", &child_rp, &i) != DDI_SUCCESS) {
            return (DDI_FAILURE);
        }
        *((uint_t *)result) = i / sizeof (sbbc_child_regspec_t);
        kmem_free(child_rp, i);
        return (DDI_SUCCESS);
    }

    /*
     * Now pass the request up to our parent.
     */
    SBBC_DBG0(SBBC_DBG_CTLOPS, dip, "Calling ddi_ctlops\n");

    return (ddi_ctlops(dip, rdip, op, arg, result));
}


/*
 * The following routine uses ranges property, that was read earlier, and
 * takes child's reg property, and computes the complete address and size
 * for the PCI parent to map.
 */
static int
sbbc_apply_range(struct sbbcsoft *sbbc_p, dev_info_t *rdip,
    sbbc_child_regspec_t *child_rp, pci_regspec_t *rp)
{
    int b;
    int rval = DDI_SUCCESS;
    struct sbbc_pci_rangespec *rangep = sbbc_p->rangep;
    int nrange = sbbc_p->range_cnt;

    SBBC_DBG4(SBBC_DBG_MAPRANGES, rdip,
        "Applying ranges for %s, rangep %llx, child_rp %llx, range %x\n",
        ddi_driver_name(rdip), sbbc_p->rangep, child_rp, nrange);

    SBBCTRACE(sbbc_apply_range, 'APPL', sbbc_p);

    for (b = 0; b < nrange; ++b, ++rangep) {

        /* Make sure the correct range is being mapped */
        if (child_rp->addr_hi == rangep->sbbc_phys_hi)
            /* See if we fit in this range */
            if ((child_rp->addr_low >=
                rangep->sbbc_phys_low) &&
                ((child_rp->addr_low + child_rp->size - 1)
                <= (rangep->sbbc_phys_low +
                rangep->rng_size - 1))) {
                uint_t addr_offset = child_rp->addr_low -
                    rangep->sbbc_phys_low;
                /*
                 * Use the range entry to translate
                 * the SBBC physical address into the
                 * parents PCI space.
                 */
                rp->pci_phys_hi =
                    rangep->pci_phys_hi;
                rp->pci_phys_mid = rangep->pci_phys_mid;
                rp->pci_phys_low =
                    rangep->pci_phys_low + addr_offset;
                rp->pci_size_hi = 0;
                rp->pci_size_low =
                    min(child_rp->size, (rangep->rng_size -
                    addr_offset));

                break;
            }
    }

    if (b == nrange)  {
        cmn_err(CE_WARN, "out_of_range %s", ddi_get_name(rdip));
        return (DDI_ME_REGSPEC_RANGE);
    }

    return (rval);
}


/*
 * The following routine reads sbbc's ranges property from OBP and sets up
 * its soft structure with it.
 */
static int
sbbc_get_ranges(struct sbbcsoft *sbbcsoftp)
{
    struct sbbc_pci_rangespec *rangep;
    int range_len, nrange;

    if (ddi_getlongprop(DDI_DEV_T_ANY, sbbcsoftp->dip, DDI_PROP_DONTPASS,
        "ranges", (caddr_t)&rangep, &range_len) != DDI_SUCCESS) {
        cmn_err(CE_WARN, "SBBC: couldn't get %s ranges property %d",
            ddi_get_name(sbbcsoftp->dip), sbbcsoftp->instance);
        return (DDI_ME_REGSPEC_RANGE);
    }

    nrange = range_len / sizeof (struct sbbc_pci_rangespec);

    if (!nrange) {
        kmem_free(rangep, range_len);
        return (DDI_FAILURE);
    }

    /* setup the soft structure with ranges info. */
    sbbcsoftp->rangep = rangep;
    sbbcsoftp->range_cnt = nrange;
    sbbcsoftp->range_len = range_len;

    return (DDI_SUCCESS);
}


/*
 * Configure the SBBC for PCI
 */
static int
sbbc_config4pci(struct sbbcsoft *sbbcsoftp)
{
    ddi_acc_handle_t conf_handle;
    uint16_t comm, vendid, devid, stat;
    uint8_t revid;

#ifdef DEBUG
    if (sbbc_dbg_flags & SBBC_DBG_PCICONF) {
        cmn_err(CE_CONT,
            "sbbc_config4pci: sbbcsoftp %p\n", (void *)sbbcsoftp);
    }
#endif
    if (pci_config_setup(sbbcsoftp->dip, &conf_handle) != DDI_SUCCESS)
        return (1);

    vendid = pci_config_get16(conf_handle, PCI_CONF_VENID);
    devid = pci_config_get16(conf_handle, PCI_CONF_DEVID);
    comm = pci_config_get16(conf_handle, PCI_CONF_COMM);
    stat = pci_config_get16(conf_handle, PCI_CONF_STAT);
    revid = pci_config_get8(conf_handle, PCI_CONF_REVID);

#ifdef DEBUG
    if (sbbc_dbg_flags & SBBC_DBG_PCICONF) {
        cmn_err(CE_CONT,
            "SBBC vendid %x, devid %x, comm %x, stat %x, revid %x\n",
            vendid, devid, comm, stat, revid);
    }
#endif
    comm = (PCI_COMM_ME | PCI_COMM_MAE | PCI_COMM_SERR_ENABLE |
        PCI_COMM_PARITY_DETECT);

    pci_config_put16(conf_handle, PCI_CONF_COMM, comm);

    comm = pci_config_get16(conf_handle, PCI_CONF_COMM);

#ifdef DEBUG
    if (sbbc_dbg_flags & SBBC_DBG_PCICONF) {
        cmn_err(CE_CONT, "comm %x\n", comm);
    }
#endif
    pci_config_teardown(&conf_handle);

    return (0);
}


/* ARGSUSED0 */
int
sbbc_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
    dev_t   dev = (dev_t)arg;
    struct sbbcsoft *sbbcsoftp;
    int instance, ret;

    instance = getminor(dev);

    SBBCTRACE(sbbc_getinfo, 'GINF', instance);

    switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
            sbbcsoftp = (struct sbbcsoft *)
                ddi_get_soft_state(sbbcsoft_statep, instance);
            if (sbbcsoftp == NULL) {
                *result = (void *) NULL;
                ret = DDI_FAILURE;
            } else {
                *result = sbbcsoftp->dip;
                ret = DDI_SUCCESS;
            }
            break;
        case DDI_INFO_DEVT2INSTANCE:
            *result = (void *)(uintptr_t)instance;
            ret = DDI_SUCCESS;
            break;
        default:
            ret = DDI_FAILURE;
            break;
    }

    return (ret);
}

/*ARGSUSED1*/
static int
sbbc_open(dev_t *dev, int flag, int otype, cred_t *credp)
{
    struct sbbcsoft *sbbcsoftp;
    int     instance;

    /* check privilege of caller process */
    if (drv_priv(credp)) {
        return (EPERM);
    }

    instance = getminor(*dev);
    if (instance < 0)
        return (ENXIO);
    sbbcsoftp = (struct sbbcsoft *)ddi_get_soft_state(sbbcsoft_statep,
        instance);
    SBBCTRACE(sbbc_open, 'OPEN', sbbcsoftp);

    if (sbbcsoftp == NULL)
        return (ENXIO);

    mutex_enter(&sbbcsoftp->umutex);

    /* check for exclusive access */
    if ((sbbcsoftp->oflag == TRUE)) {
        mutex_exit(&sbbcsoftp->umutex);
        return (EBUSY);
    }
    sbbcsoftp->oflag = TRUE;

    mutex_exit(&sbbcsoftp->umutex);

    return (0);
}

/*ARGSUSED1*/
static int
sbbc_close(dev_t dev, int flag, int otype, cred_t *credp)
{
    struct sbbcsoft *sbbcsoftp;
    int     instance;

    instance = getminor(dev);
    if (instance < 0)
        return (ENXIO);
    sbbcsoftp = (struct sbbcsoft *)ddi_get_soft_state(sbbcsoft_statep,
        instance);
    /* wait till all output activity has ceased */

    mutex_enter(&sbbcsoftp->umutex);

    SBBCTRACE(sbbc_close, 'CLOS', sbbcsoftp);

    sbbcsoftp->oflag = FALSE;

    mutex_exit(&sbbcsoftp->umutex);

    return (0);
}

/*ARGSUSED2*/
static int
sbbc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
        int *rvalp)
{
    struct sbbcsoft *sbbcsoftp;

    SBBCTRACE(sbbc_ioctl, 'IOCT', arg);

    sbbcsoftp = ddi_get_soft_state(sbbcsoft_statep, getminor(dev));

    if (sbbcsoftp == NULL) {
        return (ENXIO);
    }

    switch (cmd) {
    case SBBC_SBBCREG_WR:
        {
        struct ssc_sbbc_regio sbbcregs;
        uint64_t offset;

        if (sbbc_scmode == FALSE) {
            /* then we're executing on Domain; Writes not allowed */
            return (EINVAL);
        }

        if (arg == NULL) {
            return (ENXIO);
        }

        if (ddi_copyin((caddr_t)arg, (caddr_t)&sbbcregs,
                    sizeof (struct ssc_sbbc_regio), mode)) {
            cmn_err(CE_WARN, "sbbc_ioctl: copyin failed arg %p",
                (void *)arg);
            return (EFAULT);
        }

        /*
         * Bug #4287186: SBBC driver on cp1500 doesn't check length for
         *      reads or writes
         * Note that I've also added a check to make sure the offset is
         * valid, since misaligned (i.e. not on 16-byte boundary)
         * accesses or accesses to "Reserved" register offsets are
         * treated as unmapped by the SBBC.
         */
        if ((sbbcregs.len != 4) ||
            !sbbc_offset_valid(sbbcregs.offset)) {
            return (EINVAL);
        }

        offset = (uint64_t)sbbcsoftp->pci_sbbc_map;
        offset += sbbcregs.offset;
        ddi_put32(sbbcsoftp->pci_sbbc_map_handle, (uint32_t *)offset,
            sbbcregs.value);
        }
        break;
    case SBBC_SBBCREG_RD:
        {
        struct ssc_sbbc_regio sbbcregs;
        uint64_t offset;

        if (sbbc_scmode == FALSE) {
            /* then we're executing on Domain; Reads not allowed */
            return (EINVAL);
        }

        if (arg == NULL) {
            return (ENXIO);
        }

        if (ddi_copyin((caddr_t)arg, (caddr_t)&sbbcregs,
                    sizeof (struct ssc_sbbc_regio), mode)) {
            cmn_err(CE_WARN, "sbbc_ioctl: copyin failed arg %p",
                (void *)arg);
            return (EFAULT);
        }

        /*
         * Bug #4287186: SBBC driver on cp1500 doesn't check length for
         *      reads or writes
         * Note that I've also added a check to make sure the offset is
         * valid, since misaligned (i.e. not on 16-byte boundary)
         * accesses or accesses to "Reserved" register offsets are
         * treated as unmapped by the SBBC.
         */
        if ((sbbcregs.len != 4) ||
            !sbbc_offset_valid(sbbcregs.offset)) {
            return (EINVAL);
        }

        offset = (uint64_t)sbbcsoftp->pci_sbbc_map;
        offset += sbbcregs.offset;

        sbbcregs.value = ddi_get32(sbbcsoftp->pci_sbbc_map_handle,
            (uint32_t *)offset);

        if (ddi_copyout((caddr_t)&sbbcregs.value,
            &((struct ssc_sbbc_regio *)arg)->value,
            sbbcregs.len, mode)) {
            cmn_err(CE_WARN, "sbbc_ioctl:copyout failed arg %p",
                (void *)arg);
            return (EFAULT);
        }
        }
        break;
    default:
        cmn_err(CE_WARN, "sbbc_ioctl:Illegal command 0x%08x", cmd);
        return (ENOTTY);
    }

    return (DDI_SUCCESS);
}

static void
sbbc_remove_reg_maps(struct sbbcsoft *sbbcsoftp)
{
    SBBCTRACE(sbbc_remove_reg_maps, 'RMAP', sbbcsoftp);
    if (sbbcsoftp->pci_sbbc_map_handle)
        ddi_regs_map_free(&sbbcsoftp->pci_sbbc_map_handle);
}


static int
sbbc_init(struct sbbcsoft *sbbcsoftp)
{
    /* Mask all the interrupts until we are ready. */
    ddi_put32(sbbcsoftp->pci_sbbc_map_handle,
        &sbbcsoftp->pci_sbbc_map->sys_intr_enable,
        0x00000000);

    return (1);
}

/*
 * The following routine is a generic routine to initialize any child of
 * sbbc nexus driver information into parent private data structure.
 */
/* ARGSUSED0 */
static int
sbbc_initchild(dev_info_t *dip, dev_info_t *rdip, dev_info_t *child)
{
    sbbc_child_regspec_t *child_rp;
    int reglen, slot;
    char name[10];

    SBBC_DBG1(SBBC_DBG_INITCHILD, dip, "Initializing %s\n",
        ddi_driver_name(rdip));

    /*
     * Initialize a child
     * Set the address portion of the node name based on the
     * address/offset.
     */
    if (ddi_getlongprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
        "reg", (caddr_t)&child_rp, &reglen) != DDI_SUCCESS) {
        if (strcmp(ddi_node_name(child), "hotplug-controller") == 0) {
            slot = 1;
            (void) sprintf(name, "%x", slot);
            ddi_set_name_addr(child, name);
            return (DDI_SUCCESS);
        }
        return (DDI_FAILURE);
    }

    SBBC_DBG3(SBBC_DBG_INITCHILD, dip, "hi 0x%x, low 0x%x, size 0x%x\n",
        child_rp->addr_hi, child_rp->addr_low, child_rp->size);

    (void) sprintf(name, "%x,%x", child_rp->addr_hi, child_rp->addr_low);

    /*
     * set child's addresses from the reg property into parent private
     * data structure.
     */
    ddi_set_name_addr(child, name);
    kmem_free(child_rp, reglen);

    ddi_set_parent_data(child, NULL);

    return (DDI_SUCCESS);
}


/* ARGSUSED0 */
static int
sbbc_uninitchild(dev_info_t *rdip, dev_info_t *child)
{

    SBBC_DBG1(SBBC_DBG_UNINITCHILD, rdip, "Uninitializing %s\n",
        ddi_driver_name(rdip));

    ddi_set_name_addr(child, NULL);
    ddi_remove_minor_node(child, NULL);
    impl_rem_dev_props(child);

    return (DDI_SUCCESS);

}


/*
 * The following routine is an interrupt service routine that is used
 * as a wrapper to all the children requiring interrupt services.
 */
static uint_t
sbbc_intr_wrapper(caddr_t arg)
{

    struct sbbcsoft *sbbcsoftp = (struct sbbcsoft *)arg;
    int i, rval;

    SBBC_DBG1(SBBC_DBG_INTR, sbbcsoftp->dip, "Isr arg 0x%llx\n", arg);

    mutex_enter(&sbbcsoftp->sbbc_intr_mutex);

    for (i = 0; i < MAX_SBBC_DEVICES; i++) {
        /*
         * Check the interrupt status reg. to determine the cause.
         */
        /*
         * Check the error status reg. to determine the cause.
         */
        if (sbbcsoftp->child_intr[i] &&
            sbbcsoftp->child_intr[i]->status ==
            SBBC_INTR_STATE_ENABLE) {
            /*
             * Dispatch the children interrupt service routines and
             * look for someone to claim.
             */
            rval = sbbcsoftp->child_intr[i]->intr_handler(
                sbbcsoftp->child_intr[i]->arg1,
                sbbcsoftp->child_intr[i]->arg2);

            if (rval == DDI_INTR_CLAIMED) {
                mutex_exit(&sbbcsoftp->sbbc_intr_mutex);
                return (rval);
            }
        }
    }

    mutex_exit(&sbbcsoftp->sbbc_intr_mutex);

    /* for now do not claim since we know its not enabled */
    return (DDI_INTR_UNCLAIMED);
}


/*
 * This function checks an SBBC register offset to make sure that it is properly
 * aligned (i.e. on a 16-byte boundary) and that it corresponds to an accessible
 * register.  Since the SBBC treates accesses to unaligned or reserved addresses
 * as unmapped, failing to check for these would leave a loophole that could be
 * used to crash the system.
 */
static int
sbbc_offset_valid(uint32_t offset) {
    /*
     * Check for proper alignment first.
     */
    if ((offset % 16) != 0) {
        return (0);
    }

    /*
     * Now start checking for the various reserved ranges.
     * While sticking a bunch of constants in the code (rather than
     * #define'd values) is usually best avoided, it would probably
     * do more harm than good here.  These values were taken from the
     * Serengeti Architecture Programmer's Reference Manual dated
     * August 10, 1999, pages 2-99 through 2-103.  While there are
     * various "clever" ways this check could be performed that would
     * be slightly more efficient, arranging the code in this fashion
     * should maximize maintainability.
     */
    if (((offset >= 0x001a0) && (offset <= 0x001ff)) ||
        ((offset >= 0x002a0) && (offset <= 0x002ff)) ||
        ((offset >= 0x00350) && (offset <= 0x003ff)) ||
        ((offset >= 0x00500) && (offset <= 0x00fff)) ||
        ((offset >= 0x01160) && (offset <= 0x011ff)) ||
        ((offset >= 0x01210) && (offset <= 0x017ff)) ||
        ((offset >= 0x01810) && (offset <= 0x01fff)) ||
        ((offset >= 0x02030) && (offset <= 0x022ff)) ||
        ((offset >= 0x02340) && (offset <= 0x03fff)) ||
        ((offset >= 0x04030) && (offset <= 0x05fff)) ||
        ((offset >= 0x060a0) && (offset <= 0x060ff)) ||
        (offset == 0x06120) ||
        ((offset >= 0x06190) && (offset <= 0x061ff)) ||
        ((offset >= 0x06230) && (offset <= 0x062f0)) ||
        (offset > 0x06320)) {
        return (0);
    }

    return (1);
}

#ifdef DEBUG
void
sbbc_dbg(uint32_t flag, dev_info_t *dip, char *fmt,
    uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5)
{
    char *s = NULL;

    if (sbbc_dbg_flags && ((sbbc_dbg_flags & flag) == flag)) {
        switch (flag) {
        case SBBC_DBG_ATTACH:
            s = "attach";
            break;
        case SBBC_DBG_DETACH:
            s = "detach";
            break;
        case SBBC_DBG_CTLOPS:
            s = "ctlops";
            break;
        case SBBC_DBG_INITCHILD:
            s = "initchild";
            break;
        case SBBC_DBG_UNINITCHILD:
            s = "uninitchild";
            break;
        case SBBC_DBG_BUSMAP:
            s = "busmap";
            break;
        case SBBC_DBG_INTR:
            s = "intr";
            break;
        case SBBC_DBG_INTROPS:
            s = "intr_ops";
            break;
        case SBBC_DBG_PCICONF:
            s = "pciconfig";
            break;
        case SBBC_DBG_MAPRANGES:
            s = "mapranges";
            break;
        case SBBC_DBG_PROPERTIES:
            s = "properties";
            break;
        case SBBC_DBG_OPEN:
            s = "open";
            break;
        case SBBC_DBG_CLOSE:
            s = "close";
            break;
        case SBBC_DBG_IOCTL:
            s = "ioctl";
            break;
        default:
            s = "Unknown debug flag";
            break;
        }

        cmn_err(CE_CONT, "%s_%s(%d): ", ddi_driver_name(dip), s,
            ddi_get_instance(dip));
        cmn_err(CE_CONT, fmt, a1, a2, a3, a4, a5);
    }
}

/*
 * Dump the SBBC chip's Device ID Register
 */
static void sbbc_dump_devid(dev_info_t *dip, struct sbbcsoft *sbbcsoftp,
    int instance)
{
    uint32_t sbbc_id_reg;
    uint16_t sbbc_id_reg_partid;
    uint16_t sbbc_id_reg_manfid;

    sbbc_id_reg = ddi_get32(sbbcsoftp->pci_sbbc_map_handle,
        (uint32_t *)&sbbcsoftp->pci_sbbc_map->devid);

    sbbc_id_reg_partid = ((sbbc_id_reg << 4) >> 16);
    sbbc_id_reg_manfid = ((sbbc_id_reg << 20) >> 21);

    SBBC_DBG4(SBBC_DBG_ATTACH, dip,
        "FOUND SBBC(%d) Version %x, Partid %x, Manfid %x\n",
        instance, (sbbc_id_reg >> 28), sbbc_id_reg_partid,
        sbbc_id_reg_manfid);
}

#endif /* DEBUG */