io/pci/simba.c

	simba.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 *  PCI to PCI bus bridge nexus driver
 */

#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/modctl.h>
#include <sys/autoconf.h>
#include <sys/ddi_impldefs.h>
#include <sys/ddi_subrdefs.h>
#include <sys/ddifm.h>
#include <sys/fm/util.h>
#include <sys/fm/protocol.h>
#include <sys/fm/io/pci.h>
#include <sys/pci.h>
#include <sys/pci/pci_nexus.h>
#include <sys/pci/pci_regs.h>
#include <sys/pci/pci_simba.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/promif.h>     /* prom_printf */
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/file.h>

#if defined(DEBUG) && !defined(lint)
static uint_t simba_debug_flags = 0;
#define D_IDENTIFY  0x00000001
#define D_ATTACH    0x00000002
#define D_DETACH    0x00000004
#define D_MAP       0x00000008
#define D_CTLOPS    0x00000010
#define D_G_ISPEC   0x00000020
#define D_A_ISPEC   0x00000040
#define D_INIT_CLD  0x00400000
#define D_FAULT     0x00000080

#define DEBUG0(f, s) if ((f)& simba_debug_flags) \
    prom_printf("simba: " s "\n")

#define DEBUG1(f, s, a) if ((f)& simba_debug_flags) \
    prom_printf("simba: " s "\n", a)

#define DEBUG2(f, s, a, b) if ((f)& simba_debug_flags) \
    prom_printf("simba: " s "\n", a, b)

#define DEBUG3(f, s, a, b, c) if ((f)& simba_debug_flags) \
    prom_printf("simba: " s "\n", a, b, c)

#define DEBUG4(f, s, a, b, c, d) if ((f)& simba_debug_flags) \
    prom_printf("simba: " s "\n", a, b, c, d)

#define DEBUG5(f, s, a, b, c, d, e) if ((f)& simba_debug_flags) \
    prom_printf("simba: " s "\n", a, b, c, d, e)

#define DEBUG6(f, s, a, b, c, d, e, ff) if ((f)& simba_debug_flags) \
    prom_printf("simba: " s "\n", a, b, c, d, e, ff)

#else

#define DEBUG0(f, s)
#define DEBUG1(f, s, a)
#define DEBUG2(f, s, a, b)
#define DEBUG3(f, s, a, b, c)
#define DEBUG4(f, s, a, b, c, d)
#define DEBUG5(f, s, a, b, c, d, e)
#define DEBUG6(f, s, a, b, c, d, e, ff)

#endif

/*
 * The variable controls the default setting of the command register
 * for pci devices.  See simba_initchild() for details.
 */
static ushort_t simba_command_default = PCI_COMM_SERR_ENABLE |
                    PCI_COMM_WAIT_CYC_ENAB |
                    PCI_COMM_PARITY_DETECT |
                    PCI_COMM_ME |
                    PCI_COMM_MAE |
                    PCI_COMM_IO;

static int simba_bus_map(dev_info_t *, dev_info_t *, ddi_map_req_t *,
    off_t, off_t, caddr_t *);
static int simba_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t,
    void *, void *);
static int simba_fm_init_child(dev_info_t *dip, dev_info_t *tdip, int cap,
        ddi_iblock_cookie_t *ibc);
static void simba_bus_enter(dev_info_t *dip, ddi_acc_handle_t handle);
static void simba_bus_exit(dev_info_t *dip, ddi_acc_handle_t handle);

struct bus_ops simba_bus_ops = {
    BUSO_REV,
    simba_bus_map,
    0,
    0,
    0,
    i_ddi_map_fault,
    ddi_dma_map,
    ddi_dma_allochdl,
    ddi_dma_freehdl,
    ddi_dma_bindhdl,
    ddi_dma_unbindhdl,
    ddi_dma_flush,
    ddi_dma_win,
    ddi_dma_mctl,
    simba_ctlops,
    ddi_bus_prop_op,
    ndi_busop_get_eventcookie,
    ndi_busop_add_eventcall,
    ndi_busop_remove_eventcall,
    ndi_post_event,
    0,
    0,
    0,
    simba_fm_init_child,
    NULL,
    simba_bus_enter,
    simba_bus_exit,
    0,
    i_ddi_intr_ops
};

static int simba_open(dev_t *devp, int flags, int otyp, cred_t *credp);
static int simba_close(dev_t dev, int flags, int otyp, cred_t *credp);
static int simba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *credp, int *rvalp);

static struct cb_ops simba_cb_ops = {
    simba_open,         /* open */
    simba_close,            /* close */
    nulldev,            /* strategy */
    nulldev,            /* print */
    nulldev,            /* dump */
    nulldev,            /* read */
    nulldev,            /* write */
    simba_ioctl,            /* ioctl */
    nodev,              /* devmap */
    nodev,              /* mmap */
    nodev,              /* segmap */
    nochpoll,           /* poll */
    ddi_prop_op,            /* cb_prop_op */
    NULL,               /* streamtab */
    D_NEW | D_MP | D_HOTPLUG,   /* Driver compatibility flag */
    CB_REV,             /* rev */
    nodev,              /* int (*cb_aread)() */
    nodev               /* int (*cb_awrite)() */
};

static int simba_probe(dev_info_t *);
static int simba_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
static int simba_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
static int simba_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
    void *arg, void **result);

struct dev_ops simba_ops = {
    DEVO_REV,       /* devo_rev */
    0,          /* refcnt  */
    simba_info,     /* info */
    nulldev,        /* identify */
    simba_probe,        /* probe */
    simba_attach,       /* attach */
    simba_detach,       /* detach */
    nulldev,        /* reset */
    &simba_cb_ops,      /* driver operations */
    &simba_bus_ops      /* bus operations */

};

/*
 * Module linkage information for the kernel.
 */

static struct modldrv modldrv = {
    &mod_driverops, /* Type of module */
    "SIMBA PCI to PCI bridge nexus driver %I%",
    &simba_ops, /* driver ops */
};

static struct modlinkage modlinkage = {
    MODREV_1,
    (void *)&modldrv,
    NULL
};

/*
 * Simba specific error state structure
 */
static struct simba_errstate {
    char *error;
    ushort_t pci_cfg_stat;
    ushort_t pci_cfg_sec_stat;
    uint64_t afsr;
    uint64_t afar;
    int bridge_secondary;
};

static struct simba_cfg_state {
    dev_info_t *dip;
    ushort_t command;
    uchar_t cache_line_size;
    uchar_t latency_timer;
    uchar_t header_type;
    uchar_t bus_number;
    uchar_t sec_bus_number;
    uchar_t sub_bus_number;
    uchar_t sec_latency_timer;
    ushort_t bridge_control;
};

/*
 * soft state pointer and structure template:
 */
static void *simba_state;

typedef struct {

    dev_info_t *dip;

    /*
     * configuration register state for the bus:
     */
    ddi_acc_handle_t config_handle;
    uchar_t simba_cache_line_size;
    uchar_t simba_latency_timer;

    /*
     * cpr support:
     */
    uint_t config_state_index;
    struct simba_cfg_state *simba_config_state_p;
    ddi_iblock_cookie_t fm_ibc;
    int fm_cap;
    kmutex_t simba_mutex;
    uint_t simba_soft_state;
#define SIMBA_SOFT_STATE_CLOSED     0x00
#define SIMBA_SOFT_STATE_OPEN       0x01
#define SIMBA_SOFT_STATE_OPEN_EXCL  0x02
} simba_devstate_t;

/*
 * The following variable enables a workaround for the following obp bug:
 *
 *  1234181 - obp should set latency timer registers in pci
 *      configuration header
 *
 * Until this bug gets fixed in the obp, the following workaround should
 * be enabled.
 */
static uint_t simba_set_latency_timer_register = 1;

/*
 * The following variable enables a workaround for an obp bug to be
 * submitted.  A bug requesting a workaround fof this problem has
 * been filed:
 *
 *  1235094 - need workarounds on positron nexus drivers to set cache
 *      line size registers
 *
 * Until this bug gets fixed in the obp, the following workaround should
 * be enabled.
 */
static uint_t simba_set_cache_line_size_register = 1;


/*
 * forward function declarations:
 */
static void simba_uninitchild(dev_info_t *);
static int simba_initchild(dev_info_t *child);
static void simba_save_config_regs(simba_devstate_t *simba_p);
static void simba_restore_config_regs(simba_devstate_t *simba_p);
static int simba_err_callback(dev_info_t *dip, ddi_fm_error_t *derr,
        const void *impl_data);

int
_init(void)
{
    int e;

    DEBUG0(D_ATTACH, "_init() installing module...\n");
    if ((e = ddi_soft_state_init(&simba_state, sizeof (simba_devstate_t),
        1)) == 0 && (e = mod_install(&modlinkage)) != 0)
        ddi_soft_state_fini(&simba_state);

    DEBUG0(D_ATTACH, "_init() module installed\n");
    return (e);
}

int
_fini(void)
{
    int e;
    DEBUG0(D_ATTACH, "_fini() removing module...\n");
    if ((e = mod_remove(&modlinkage)) == 0)
        ddi_soft_state_fini(&simba_state);
    return (e);
}

int
_info(struct modinfo *modinfop)
{
    DEBUG0(D_ATTACH, "_info() called.\n");
    return (mod_info(&modlinkage, modinfop));
}

/*ARGSUSED*/
static int
simba_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
    simba_devstate_t *simba_p;  /* per simba state pointer */
    int instance;

    instance = getminor((dev_t)arg);
    simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
        instance);

    switch (infocmd) {
    default:
        return (DDI_FAILURE);

    case DDI_INFO_DEVT2INSTANCE:
        *result = (void *)instance;
        return (DDI_SUCCESS);

    case DDI_INFO_DEVT2DEVINFO:
        if (simba_p == NULL)
            return (DDI_FAILURE);
        *result = (void *)simba_p->dip;
        return (DDI_SUCCESS);
    }
}

/*ARGSUSED*/
static int
simba_probe(register dev_info_t *devi)
{
    DEBUG0(D_ATTACH, "simba_probe() called.\n");
    return (DDI_PROBE_SUCCESS);
}

/*ARGSUSED*/
static int
simba_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
    int instance;
    simba_devstate_t *simba;
    ddi_fm_error_t derr;

    switch (cmd) {
    case DDI_ATTACH:

        DEBUG1(D_ATTACH, "attach(%x) ATTACH\n", (int)devi);

        /*
         * Make sure the "device_type" property exists.
         */
        (void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
            "device_type", "pci");

        /*
         * Allocate and get soft state structure.
         */
        instance = ddi_get_instance(devi);
        if (ddi_soft_state_zalloc(simba_state, instance) != DDI_SUCCESS)
            return (DDI_FAILURE);
        simba = (simba_devstate_t *)ddi_get_soft_state(simba_state,
            instance);
        simba->dip = devi;
        mutex_init(&simba->simba_mutex, NULL, MUTEX_DRIVER, NULL);
        simba->simba_soft_state = SIMBA_SOFT_STATE_CLOSED;

        /*
         * create minor node for devctl interfaces
         */
        if (ddi_create_minor_node(devi, "devctl", S_IFCHR, instance,
            DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
            mutex_destroy(&simba->simba_mutex);
            ddi_soft_state_free(simba_state, instance);
            return (DDI_FAILURE);
        }

        if (pci_config_setup(devi, &simba->config_handle) !=
            DDI_SUCCESS) {
            ddi_remove_minor_node(devi, "devctl");
            mutex_destroy(&simba->simba_mutex);
            ddi_soft_state_free(simba_state, instance);
            return (DDI_FAILURE);
        }

        /*
         * Simba cache line size is 64 bytes and hardwired.
         */
        simba->simba_cache_line_size =
            pci_config_get8(simba->config_handle,
            PCI_CONF_CACHE_LINESZ);
        simba->simba_latency_timer =
            pci_config_get8(simba->config_handle,
            PCI_CONF_LATENCY_TIMER);

        /* simba specific, clears up the pri/sec status registers */
        pci_config_put16(simba->config_handle, 0x6, 0xffff);
        pci_config_put16(simba->config_handle, 0x1e, 0xffff);

        DEBUG2(D_ATTACH, "simba_attach(): clsz=%x, lt=%x\n",
            simba->simba_cache_line_size,
            simba->simba_latency_timer);

        /*
         * Initialize FMA support
         */
        simba->fm_cap = DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE |
            DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE;

        /*
         * Call parent to get it's capablity
         */
        ddi_fm_init(devi, &simba->fm_cap, &simba->fm_ibc);

        ASSERT((simba->fm_cap & DDI_FM_ERRCB_CAPABLE) &&
            (simba->fm_cap & DDI_FM_EREPORT_CAPABLE));

        pci_ereport_setup(devi);

        /*
         * clear any outstanding error bits
         */
        bzero(&derr, sizeof (ddi_fm_error_t));
        derr.fme_version = DDI_FME_VERSION;
        derr.fme_flag = DDI_FM_ERR_EXPECTED;
        pci_ereport_post(devi, &derr, NULL);
        pci_bdg_ereport_post(devi, &derr, NULL);

        ddi_fm_handler_register(devi, simba_err_callback, simba);

        ddi_report_dev(devi);
        DEBUG0(D_ATTACH, "attach(): ATTACH done\n");
        return (DDI_SUCCESS);

    case DDI_RESUME:

        /*
         * Get the soft state structure for the bridge.
         */
        simba = (simba_devstate_t *)
            ddi_get_soft_state(simba_state, ddi_get_instance(devi));
        simba_restore_config_regs(simba);
        return (DDI_SUCCESS);
    }
    return (DDI_FAILURE);
}

/*ARGSUSED*/
static int
simba_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
    simba_devstate_t *simba;
    simba = (simba_devstate_t *)
        ddi_get_soft_state(simba_state, ddi_get_instance(devi));

    switch (cmd) {
    case DDI_DETACH:
        DEBUG0(D_DETACH, "detach() called\n");
        ddi_fm_handler_unregister(devi);
        pci_ereport_teardown(devi);
        ddi_fm_fini(devi);
        pci_config_teardown(&simba->config_handle);
        (void) ddi_prop_remove(DDI_DEV_T_NONE, devi, "device_type");
        ddi_remove_minor_node(devi, "devctl");
        mutex_destroy(&simba->simba_mutex);
        ddi_soft_state_free(simba_state, ddi_get_instance(devi));
        return (DDI_SUCCESS);

    case DDI_SUSPEND:
        simba_save_config_regs(simba);
        return (DDI_SUCCESS);
    }
    return (DDI_FAILURE);
}

/*ARGSUSED*/
static int
simba_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
    off_t offset, off_t len, caddr_t *vaddrp)
{
    register dev_info_t *pdip;

    DEBUG3(D_MAP, "simba_bus_map(): dip=%x, rdip=%x, mp=%x", dip, rdip, mp);
    DEBUG3(D_MAP, "simba_bus_map(): offset=%x, len=%x, vaddrp=%x",
        offset, len, vaddrp);

    pdip = (dev_info_t *)DEVI(dip)->devi_parent;
    return ((DEVI(pdip)->devi_ops->devo_bus_ops->bus_map)
        (pdip, rdip, mp, offset, len, vaddrp));
}

/*
 * Registered error handling callback with our parent
 */
static int
simba_err_callback(dev_info_t *dip, ddi_fm_error_t *derr, const void *impl_data)
{
    simba_devstate_t *simba = (simba_devstate_t *)impl_data;
    struct simba_errstate simba_err;
    int ret = 0;

    bzero(&simba_err, sizeof (struct simba_errstate));
    simba_err.afsr = pci_config_get64(simba->config_handle, 0xe8);
    simba_err.afar = pci_config_get64(simba->config_handle, 0xf0);
    derr->fme_ena = fm_ena_generate(0, FM_ENA_FMT1);

    pci_ereport_post(dip, derr, &simba_err.pci_cfg_stat);
    pci_bdg_ereport_post(dip, derr, &simba_err.pci_cfg_sec_stat);
    ret = pci_bdg_check_status(dip, derr, simba_err.pci_cfg_stat,
        simba_err.pci_cfg_sec_stat);

    DEBUG6(D_FAULT, "%s-%d: cleaning up fault bits %x %x %x.%8x\n",
            ddi_driver_name(simba->dip),
            ddi_get_instance(simba->dip), simba_err.pci_cfg_stat,
            simba_err.pci_cfg_sec_stat,
            (uint_t)(simba_err.afsr >> 32),
            (uint_t)simba_err.afsr);
    pci_config_put64(simba->config_handle, 0xe8, simba_err.afsr);

    return (ret);
}

#if defined(DEBUG) && !defined(lint)
static char *ops[] =
{
    "DDI_CTLOPS_DMAPMAPC",
    "DDI_CTLOPS_INITCHILD",
    "DDI_CTLOPS_UNINITCHILD",
    "DDI_CTLOPS_REPORTDEV",
    "DDI_CTLOPS_REPORTINT",
    "DDI_CTLOPS_REGSIZE",
    "DDI_CTLOPS_NREGS",
    "DDI_CTLOPS_NINTRS",
    "DDI_CTLOPS_SIDDEV",
    "DDI_CTLOPS_SLAVEONLY",
    "DDI_CTLOPS_AFFINITY",
    "DDI_CTLOPS_IOMIN",
    "DDI_CTLOPS_PTOB",
    "DDI_CTLOPS_BTOP",
    "DDI_CTLOPS_BTOPR",
    "DDI_CTLOPS_RESERVED1",
    "DDI_CTLOPS_RESERVED2",
    "DDI_CTLOPS_RESERVED3",
    "DDI_CTLOPS_INTR_HILEVEL",
    "DDI_CTLOPS_XLATE_INTRS",
    "DDI_CTLOPS_DVMAPAGESIZE",
    "DDI_CTLOPS_POWER",
    "DDI_CTLOPS_ATTACH",
    "DDI_CTLOPS_DETACH",
    "DDI_CTLOPS_POKE",
    "DDI_CTLOPS_PEEK"
};
#endif

/*ARGSUSED*/
static int
simba_ctlops(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
    void *arg, void *result)
{
    int reglen;
    int rn;
    int totreg;
    pci_regspec_t *drv_regp;

    DEBUG6(D_CTLOPS,
        "simba_ctlops(): dip=%x rdip=%x ctlop=%x-%s arg=%x result=%x",
        dip, rdip, ctlop, ctlop < (sizeof (ops) / sizeof (ops[0])) ?
        ops[ctlop] : "Unknown", arg, result);

    switch (ctlop) {
    case DDI_CTLOPS_REPORTDEV:
        if (rdip == (dev_info_t *)0)
            return (DDI_FAILURE);
        cmn_err(CE_CONT, "?PCI-device: %s@%s, %s%d\n",
            ddi_node_name(rdip), ddi_get_name_addr(rdip),
            ddi_driver_name(rdip),
            ddi_get_instance(rdip));
        return (DDI_SUCCESS);

    case DDI_CTLOPS_INITCHILD:
        return (simba_initchild((dev_info_t *)arg));

    case DDI_CTLOPS_UNINITCHILD:
        simba_uninitchild((dev_info_t *)arg);
        return (DDI_SUCCESS);

    case DDI_CTLOPS_SIDDEV:
        return (DDI_SUCCESS);

    case DDI_CTLOPS_REGSIZE:
    case DDI_CTLOPS_NREGS:
        if (rdip == (dev_info_t *)0)
            return (DDI_FAILURE);
        break;

    default:
        DEBUG0(D_CTLOPS, "simba_ctlops(): calling ddi_ctlops()");
        return (ddi_ctlops(dip, rdip, ctlop, arg, result));
    }

    *(int *)result = 0;
    if (ddi_getlongprop(DDI_DEV_T_NONE, rdip,
        DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "reg",
        (caddr_t)&drv_regp, &reglen) != DDI_SUCCESS)
        return (DDI_FAILURE);

    totreg = reglen / sizeof (pci_regspec_t);
    if (ctlop == DDI_CTLOPS_NREGS)
        *(int *)result = totreg;
    else if (ctlop == DDI_CTLOPS_REGSIZE) {
        rn = *(int *)arg;
        if (rn >= totreg) {
            kmem_free(drv_regp, reglen);
            return (DDI_FAILURE);
        }
        *(off_t *)result = drv_regp[rn].pci_size_low |
            ((uint64_t)drv_regp[rn].pci_size_hi << 32);
    }

    kmem_free(drv_regp, reglen);
    DEBUG1(D_CTLOPS, "simba_ctlops(): *result=%x\n", *(off_t *)result);
    return (DDI_SUCCESS);
}

static int
simba_name_child(dev_info_t *child, char *name, int namelen)
{
    uint_t n, slot, func;
    pci_regspec_t *pci_rp;

    if (ndi_dev_is_persistent_node(child) == 0) {
        char **unit_addr;

        /* name .conf nodes by "unit-address" property" */
        if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, child,
            DDI_PROP_DONTPASS, "unit-address", &unit_addr, &n) !=
            DDI_PROP_SUCCESS) {
            cmn_err(CE_WARN, "cannot name node from %s.conf",
                ddi_driver_name(child));
            return (DDI_FAILURE);
        }
        if (n != 1 || *unit_addr == NULL || **unit_addr == 0) {
            cmn_err(CE_WARN, "unit-address property in %s.conf"
                " not well-formed", ddi_driver_name(child));
            ddi_prop_free(unit_addr);
            return (DDI_FAILURE);
        }

        (void) snprintf(name, namelen, "%s", *unit_addr);
        ddi_prop_free(unit_addr);
        return (DDI_SUCCESS);
    }

    /* name hardware nodes by "reg" property */
    if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, child, 0, "reg",
        (int **)&pci_rp, &n) != DDI_SUCCESS)
        return (DDI_FAILURE);

    /* get the device identifications */
    slot = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
    func = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);

    if (func != 0)
        (void) snprintf(name, namelen, "%x,%x", slot, func);
    else
        (void) snprintf(name, namelen, "%x", slot);

    ddi_prop_free(pci_rp);
    return (DDI_SUCCESS);
}

static int
simba_initchild(dev_info_t *child)
{
    char name[MAXNAMELEN];
    int i;
    ddi_acc_handle_t config_handle;
    ushort_t command_preserve, command;
    uchar_t header_type;
    uchar_t min_gnt, latency_timer;
    simba_devstate_t *simba;
    uint_t n;

    DEBUG1(D_INIT_CLD, "simba_initchild(): child=%x\n", child);

    /*
     * Pseudo nodes indicate a prototype node with per-instance
     * properties to be merged into the real h/w device node.
     * The interpretation of the unit-address is DD[,F]
     * where DD is the device id and F is the function.
     */
    if (ndi_dev_is_persistent_node(child) == 0) {
        extern int pci_allow_pseudo_children;
        pci_regspec_t *pci_rp;

        if (ddi_getlongprop(DDI_DEV_T_ANY, child,
            DDI_PROP_DONTPASS, "reg", (caddr_t)&pci_rp, &i) ==
            DDI_SUCCESS) {
            cmn_err(CE_WARN,
                "cannot merge prototype from %s.conf",
                ddi_driver_name(child));
            kmem_free(pci_rp, i);
            return (DDI_NOT_WELL_FORMED);
        }

        if (simba_name_child(child, name, MAXNAMELEN) != DDI_SUCCESS)
            return (DDI_NOT_WELL_FORMED);

        ddi_set_name_addr(child, name);
        ddi_set_parent_data(child, NULL);

        /*
         * Try to merge the properties from this prototype
         * node into real h/w nodes.
         */
        if (ndi_merge_node(child, simba_name_child) == DDI_SUCCESS) {
            /*
             * Merged ok - return failure to remove the node.
             */
            simba_uninitchild(child);
            return (DDI_FAILURE);
        }

        /* workaround for ddivs to run under PCI */
        if (pci_allow_pseudo_children)
            return (DDI_SUCCESS);

        /*
         * The child was not merged into a h/w node,
         * but there's not much we can do with it other
         * than return failure to cause the node to be removed.
         */
        cmn_err(CE_WARN, "!%s@%s: %s.conf properties not merged",
            ddi_driver_name(child), ddi_get_name_addr(child),
            ddi_driver_name(child));
        simba_uninitchild(child);
        return (DDI_NOT_WELL_FORMED);
    }

    /*
     * Initialize real h/w nodes
     */
    if (simba_name_child(child, name, MAXNAMELEN) != DDI_SUCCESS)
        return (DDI_FAILURE);

    ddi_set_name_addr(child, name);
    ddi_set_parent_data(child, NULL);

    if (pci_config_setup(child, &config_handle) != DDI_SUCCESS) {
        simba_uninitchild(child);
        return (DDI_FAILURE);
    }

    DEBUG0(D_INIT_CLD, "simba_initchild(): pci_config_setup success!\n");

    /*
     * Determine the configuration header type.
     */
    header_type = pci_config_get8(config_handle, PCI_CONF_HEADER);

    /*
     * Support for the "command-preserve" property.
     */
    command_preserve = ddi_prop_get_int(DDI_DEV_T_ANY, child,
        DDI_PROP_DONTPASS, "command-preserve", 0);
    command = pci_config_get16(config_handle, PCI_CONF_COMM);
    command &= (command_preserve | PCI_COMM_BACK2BACK_ENAB);
    command |= (simba_command_default & ~command_preserve);
    pci_config_put16(config_handle, PCI_CONF_COMM, command);

    /* clean up all PCI child devices status register */
    pci_config_put16(config_handle, PCI_CONF_STAT, 0xffff);

    /*
     * If the device has a primary bus control register then program it
     * based on the settings in the command register.
     */
    if ((header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE) {
        ushort_t bcr =
            pci_config_get16(config_handle, PCI_BCNF_BCNTRL);
        if (simba_command_default & PCI_COMM_PARITY_DETECT)
            bcr |= PCI_BCNF_BCNTRL_PARITY_ENABLE;
        if (simba_command_default & PCI_COMM_SERR_ENABLE)
            bcr |= PCI_BCNF_BCNTRL_SERR_ENABLE;
        bcr |= PCI_BCNF_BCNTRL_MAST_AB_MODE;
        pci_config_put8(config_handle, PCI_BCNF_BCNTRL, bcr);
    }

    simba = (simba_devstate_t *)ddi_get_soft_state(simba_state,
        ddi_get_instance(ddi_get_parent(child)));
    /*
     * Initialize cache-line-size configuration register if needed.
     */
    if (simba_set_cache_line_size_register &&
        ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
        "cache-line-size", 0) == 0) {
        pci_config_put8(config_handle, PCI_CONF_CACHE_LINESZ,
            simba->simba_cache_line_size);
        n = pci_config_get8(config_handle, PCI_CONF_CACHE_LINESZ);
        if (n != 0)
            (void) ndi_prop_update_int(DDI_DEV_T_NONE, child,
                "cache-line-size", n);
    }

    /*
     * Initialize latency timer configuration registers if needed.
     */
    if (simba_set_latency_timer_register &&
        ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
        "latency-timer", 0) == 0) {

        if ((header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE) {
            latency_timer = simba->simba_latency_timer;
            pci_config_put8(config_handle, PCI_BCNF_LATENCY_TIMER,
                simba->simba_latency_timer);
        } else {
            min_gnt = pci_config_get8(config_handle,
                PCI_CONF_MIN_G);
            latency_timer = min_gnt * 8;
        }
        pci_config_put8(config_handle, PCI_CONF_LATENCY_TIMER,
            latency_timer);
        n = pci_config_get8(config_handle, PCI_CONF_LATENCY_TIMER);
        if (n != 0)
            (void) ndi_prop_update_int(DDI_DEV_T_NONE, child,
                "latency-timer", n);
    }

    pci_config_teardown(&config_handle);
    DEBUG0(D_INIT_CLD, "simba_initchild(): pci_config_teardown called\n");
    return (DDI_SUCCESS);
}

static void
simba_uninitchild(dev_info_t *dip)
{
    ddi_set_name_addr(dip, NULL);

    /*
     * Strip the node to properly convert it back to prototype form
     */
    impl_rem_dev_props(dip);
}

/*
 * simba_save_config_regs
 *
 * This routine saves the state of the configuration registers of all
 * the child nodes of each PBM.
 *
 * used by: simba_detach() on suspends
 *
 * return value: none
 */
static void
simba_save_config_regs(simba_devstate_t *simba_p)
{
    int i;
    dev_info_t *dip;
    ddi_acc_handle_t ch;
    struct simba_cfg_state *statep;

    for (i = 0, dip = ddi_get_child(simba_p->dip); dip != NULL;
        dip = ddi_get_next_sibling(dip)) {
        if (i_ddi_node_state(dip) >= DS_ATTACHED)
            i++;
    }
    if (!i)
        return;
    simba_p->simba_config_state_p =
        kmem_zalloc(i * sizeof (struct simba_cfg_state), KM_NOSLEEP);
    if (!simba_p->simba_config_state_p) {
        cmn_err(CE_WARN, "not enough memrory to save simba child\n");
        return;
    }
    simba_p->config_state_index = i;

    for (statep = simba_p->simba_config_state_p,
        dip = ddi_get_child(simba_p->dip);
        dip != NULL;
        dip = ddi_get_next_sibling(dip)) {

        if (i_ddi_node_state(dip) < DS_ATTACHED) {
            DEBUG4(D_DETACH, "%s%d: skipping unattached %s%d\n",
                ddi_driver_name(simba_p->dip),
                ddi_get_instance(simba_p->dip),
                ddi_driver_name(dip),
                ddi_get_instance(dip));
            continue;
        }

        DEBUG4(D_DETACH, "%s%d: saving regs for %s%d\n",
            ddi_driver_name(simba_p->dip),
            ddi_get_instance(simba_p->dip),
            ddi_driver_name(dip),
            ddi_get_instance(dip));

        if (pci_config_setup(dip, &ch) != DDI_SUCCESS) {
            DEBUG4(D_DETACH, "%s%d: can't config space for %s%d\n",
                ddi_driver_name(simba_p->dip),
                ddi_get_instance(simba_p->dip),
                ddi_driver_name(dip),
                ddi_get_instance(dip));
            continue;
        }

        DEBUG3(D_DETACH, "%s%d: saving child dip=%x\n",
            ddi_driver_name(simba_p->dip),
            ddi_get_instance(simba_p->dip),
            dip);

        statep->dip = dip;
        statep->command = pci_config_get16(ch, PCI_CONF_COMM);
        statep->header_type = pci_config_get8(ch, PCI_CONF_HEADER);
        if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
            statep->bridge_control =
                pci_config_get16(ch, PCI_BCNF_BCNTRL);
        statep->cache_line_size =
            pci_config_get8(ch, PCI_CONF_CACHE_LINESZ);
        statep->latency_timer =
            pci_config_get8(ch, PCI_CONF_LATENCY_TIMER);
        if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
            statep->sec_latency_timer =
                pci_config_get8(ch, PCI_BCNF_LATENCY_TIMER);
        /*
         * Simba specific.
         */
        if (pci_config_get16(ch, PCI_CONF_VENID) == PCI_SIMBA_VENID &&
            pci_config_get16(ch, PCI_CONF_DEVID) == PCI_SIMBA_DEVID) {

            statep->bus_number =
                pci_config_get8(ch, PCI_BCNF_PRIBUS);
            statep->sec_bus_number =
                pci_config_get8(ch, PCI_BCNF_SECBUS);
            statep->sub_bus_number =
                pci_config_get8(ch, PCI_BCNF_SUBBUS);
            statep->bridge_control =
                pci_config_get16(ch, PCI_BCNF_BCNTRL);
        }
        pci_config_teardown(&ch);
        statep++;
    }
}


/*
 * simba_restore_config_regs
 *
 * This routine restores the state of the configuration registers of all
 * the child nodes of each PBM.
 *
 * used by: simba_attach() on resume
 *
 * return value: none
 */
static void
simba_restore_config_regs(simba_devstate_t *simba_p)
{
    int i;
    dev_info_t *dip;
    ddi_acc_handle_t ch;
    struct simba_cfg_state *statep = simba_p->simba_config_state_p;
    if (!simba_p->config_state_index)
        return;

    for (i = 0; i < simba_p->config_state_index; i++, statep++) {
        dip = statep->dip;
        if (!dip) {
            cmn_err(CE_WARN,
                "%s%d: skipping bad dev info (%d)\n",
                ddi_driver_name(simba_p->dip),
                ddi_get_instance(simba_p->dip),
                i);
            continue;
        }

        DEBUG5(D_ATTACH, "%s%d: restoring regs for %x-%s%d\n",
            ddi_driver_name(simba_p->dip),
            ddi_get_instance(simba_p->dip),
            dip,
            ddi_driver_name(dip),
            ddi_get_instance(dip));

        if (pci_config_setup(dip, &ch) != DDI_SUCCESS) {
            DEBUG4(D_ATTACH, "%s%d: can't config space for %s%d\n",
                ddi_driver_name(simba_p->dip),
                ddi_get_instance(simba_p->dip),
                ddi_driver_name(dip),
                ddi_get_instance(dip));
            continue;
        }
        pci_config_put16(ch, PCI_CONF_COMM, statep->command);
        if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
            pci_config_put16(ch, PCI_BCNF_BCNTRL,
                statep->bridge_control);
        /*
         * Simba specific.
         */
        if (pci_config_get16(ch, PCI_CONF_VENID) == PCI_SIMBA_VENID &&
            pci_config_get16(ch, PCI_CONF_DEVID) == PCI_SIMBA_DEVID) {
            pci_config_put8(ch, PCI_BCNF_PRIBUS,
                statep->bus_number);
            pci_config_put8(ch, PCI_BCNF_SECBUS,
                statep->sec_bus_number);
            pci_config_put8(ch, PCI_BCNF_SUBBUS,
                statep->sub_bus_number);
            pci_config_put16(ch, PCI_BCNF_BCNTRL,
                statep->bridge_control);
        }

        pci_config_put8(ch, PCI_CONF_CACHE_LINESZ,
            statep->cache_line_size);
        pci_config_put8(ch, PCI_CONF_LATENCY_TIMER,
            statep->latency_timer);
        if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
            pci_config_put8(ch, PCI_BCNF_LATENCY_TIMER,
                statep->sec_latency_timer);
        pci_config_teardown(&ch);
    }

    kmem_free(simba_p->simba_config_state_p,
        simba_p->config_state_index * sizeof (struct simba_cfg_state));
    simba_p->simba_config_state_p = NULL;
    simba_p->config_state_index = 0;
}

/* ARGSUSED */
static int
simba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
{
    simba_devstate_t *simba_p;

    /*
     * Make sure the open is for the right file type.
     */
    if (otyp != OTYP_CHR)
        return (EINVAL);

    /*
     * Get the soft state structure for the device.
     */
    simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
        getminor(*devp));
    if (simba_p == NULL)
        return (ENXIO);

    /*
     * Handle the open by tracking the device state.
     */
    mutex_enter(&simba_p->simba_mutex);
    if (flags & FEXCL) {
        if (simba_p->simba_soft_state != SIMBA_SOFT_STATE_CLOSED) {
            mutex_exit(&simba_p->simba_mutex);
            return (EBUSY);
        }
        simba_p->simba_soft_state = SIMBA_SOFT_STATE_OPEN_EXCL;
    } else {
        if (simba_p->simba_soft_state == SIMBA_SOFT_STATE_OPEN_EXCL) {
            mutex_exit(&simba_p->simba_mutex);
            return (EBUSY);
        }
        simba_p->simba_soft_state = SIMBA_SOFT_STATE_OPEN;
    }
    mutex_exit(&simba_p->simba_mutex);
    return (0);
}


/* ARGSUSED */
static int
simba_close(dev_t dev, int flags, int otyp, cred_t *credp)
{
    simba_devstate_t *simba_p;

    if (otyp != OTYP_CHR)
        return (EINVAL);

    simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
        getminor(dev));
    if (simba_p == NULL)
        return (ENXIO);

    mutex_enter(&simba_p->simba_mutex);
    simba_p->simba_soft_state = SIMBA_SOFT_STATE_CLOSED;
    mutex_exit(&simba_p->simba_mutex);
    return (0);
}


/*
 * simba_ioctl: devctl hotplug controls
 */
/* ARGSUSED */
static int
simba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
    simba_devstate_t *simba_p;
    dev_info_t *self;
    struct devctl_iocdata *dcp;
    uint_t bus_state;
    int rv = 0;

    simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
        getminor(dev));
    if (simba_p == NULL)
        return (ENXIO);

    self = simba_p->dip;

    /*
     * We can use the generic implementation for these ioctls
     */
    switch (cmd) {
    case DEVCTL_DEVICE_GETSTATE:
    case DEVCTL_DEVICE_ONLINE:
    case DEVCTL_DEVICE_OFFLINE:
    case DEVCTL_BUS_GETSTATE:
        return (ndi_devctl_ioctl(self, cmd, arg, mode, 0));
    }

    /*
     * read devctl ioctl data
     */
    if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
        return (EFAULT);

    switch (cmd) {

    case DEVCTL_DEVICE_RESET:
        rv = ENOTSUP;
        break;


    case DEVCTL_BUS_QUIESCE:
        if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
            if (bus_state == BUS_QUIESCED)
                break;
        (void) ndi_set_bus_state(self, BUS_QUIESCED);
        break;

    case DEVCTL_BUS_UNQUIESCE:
        if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
            if (bus_state == BUS_ACTIVE)
                break;
        (void) ndi_set_bus_state(self, BUS_ACTIVE);
        break;

    case DEVCTL_BUS_RESET:
        rv = ENOTSUP;
        break;

    case DEVCTL_BUS_RESETALL:
        rv = ENOTSUP;
        break;

    default:
        rv = ENOTTY;
    }

    ndi_dc_freehdl(dcp);
    return (rv);
}

/*
 * Initialize FMA resources for children devices. Called when
 * child calls ddi_fm_init().
 */
/*ARGSUSED*/
static int
simba_fm_init_child(dev_info_t *dip, dev_info_t *tdip, int cap,
        ddi_iblock_cookie_t *ibc)
{
    simba_devstate_t *simba_p = ddi_get_soft_state(simba_state,
            ddi_get_instance(dip));

    *ibc = simba_p->fm_ibc;
    return (simba_p->fm_cap);
}

static void
simba_bus_enter(dev_info_t *dip, ddi_acc_handle_t handle)
{
    i_ndi_busop_access_enter(dip, handle);
}

/* ARGSUSED */
static void
simba_bus_exit(dev_info_t *dip, ddi_acc_handle_t handle)
{
    i_ndi_busop_access_exit(dip, handle);
}