/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * Copyright (c) 2010, Intel Corporation.
 * All rights reserved.
 */

/*
 * PIM-DR layer of DR driver.  Provides interface between user
 * level applications and the PSM-DR layer.
 */

#include <sys/note.h>
#include <sys/debug.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/cred.h>
#include <sys/dditypes.h>
#include <sys/devops.h>
#include <sys/modctl.h>
#include <sys/poll.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/stat.h>
#include <sys/kmem.h>
#include <sys/processor.h>
#include <sys/cpuvar.h>
#include <sys/mem_config.h>

#include <sys/autoconf.h>
#include <sys/cmn_err.h>

#include <sys/ddi_impldefs.h>
#include <sys/promif.h>
#include <sys/machsystm.h>

#include <sys/dr.h>
#include <sys/drmach.h>
#include <sys/dr_util.h>

extern int               nulldev();
extern int               nodev();
extern struct memlist   *phys_install;

#ifdef DEBUG
uint_t  dr_debug = 0;                   /* dr.h for bit values */
#endif /* DEBUG */

static int      dr_dev_type_to_nt(char *);

/*
 * NOTE: state_str, nt_str and SBD_CMD_STR are only used in a debug
 * kernel.  They are, however, referenced during both debug and non-debug
 * compiles.
 */

static char *state_str[] = {
        "EMPTY", "OCCUPIED", "CONNECTED", "UNCONFIGURED",
        "PARTIAL", "CONFIGURED", "RELEASE", "UNREFERENCED",
        "FATAL"
};

#define SBD_CMD_STR(c) \
        (((c) == SBD_CMD_ASSIGN)        ? "ASSIGN"      : \
        ((c) == SBD_CMD_UNASSIGN)       ? "UNASSIGN"    : \
        ((c) == SBD_CMD_POWERON)        ? "POWERON"     : \
        ((c) == SBD_CMD_POWEROFF)       ? "POWEROFF"    : \
        ((c) == SBD_CMD_TEST)           ? "TEST"        : \
        ((c) == SBD_CMD_CONNECT)        ? "CONNECT"     : \
        ((c) == SBD_CMD_DISCONNECT)     ? "DISCONNECT"  : \
        ((c) == SBD_CMD_CONFIGURE)      ? "CONFIGURE"   : \
        ((c) == SBD_CMD_UNCONFIGURE)    ? "UNCONFIGURE" : \
        ((c) == SBD_CMD_GETNCM)         ? "GETNCM"      : \
        ((c) == SBD_CMD_PASSTHRU)       ? "PASSTHRU"    : \
        ((c) == SBD_CMD_STATUS)         ? "STATUS"      : "unknown")

#define DR_GET_BOARD_DEVUNIT(sb, ut, un) (&((sb)->b_dev[DEVSET_NIX(ut)][un]))

#define DR_MAKE_MINOR(i, b)     (((i) << 16) | (b))
#define DR_MINOR2INST(m)        (((m) >> 16) & 0xffff)
#define DR_MINOR2BNUM(m)        ((m) & 0xffff)

/* for the DR*INTERNAL_ERROR macros.  see sys/dr.h. */
static char *dr_ie_fmt = "dr.c %d";

/* struct for drmach device name to sbd_comp_type_t mapping */
typedef struct {
        char            *s_devtype;
        sbd_comp_type_t s_nodetype;
} dr_devname_t;

/* struct to map starfire device attributes - name:sbd_comp_type_t */
static  dr_devname_t    dr_devattr[] = {
        { DRMACH_DEVTYPE_MEM,   SBD_COMP_MEM },
        { DRMACH_DEVTYPE_CPU,   SBD_COMP_CPU },
        { DRMACH_DEVTYPE_PCI,   SBD_COMP_IO },
#if defined(DRMACH_DEVTYPE_SBUS)
        { DRMACH_DEVTYPE_SBUS,  SBD_COMP_IO },
#endif
#if defined(DRMACH_DEVTYPE_WCI)
        { DRMACH_DEVTYPE_WCI,   SBD_COMP_IO },
#endif
        /* last s_devtype must be NULL, s_nodetype must be SBD_COMP_UNKNOWN */
        { NULL,                 SBD_COMP_UNKNOWN }
};

/*
 * Per instance soft-state structure.
 */
typedef struct dr_softstate {
        dev_info_t      *dip;
        dr_board_t      *boards;
        kmutex_t         i_lock;
        int              dr_initialized;
} dr_softstate_t;

/*
 * dr Global data elements
 */
struct dr_global {
        dr_softstate_t  *softsp;        /* pointer to initialize soft state */
        kmutex_t        lock;
} dr_g;

dr_unsafe_devs_t        dr_unsafe_devs;

/*
 * Table of known passthru commands.
 */
struct {
        char    *pt_name;
        int     (*pt_func)(dr_handle_t *);
} pt_arr[] = {
        "quiesce",              dr_pt_test_suspend,
};

int dr_modunload_okay = 0;              /* set to non-zero to allow unload */

/*
 * State transition table.  States valid transitions for "board" state.
 * Recall that non-zero return value terminates operation, however
 * the herrno value is what really indicates an error , if any.
 */
static int
_cmd2index(int c)
{
        /*
         * Translate DR CMD to index into dr_state_transition.
         */
        switch (c) {
        case SBD_CMD_CONNECT:           return (0);
        case SBD_CMD_DISCONNECT:        return (1);
        case SBD_CMD_CONFIGURE:         return (2);
        case SBD_CMD_UNCONFIGURE:       return (3);
        case SBD_CMD_ASSIGN:            return (4);
        case SBD_CMD_UNASSIGN:          return (5);
        case SBD_CMD_POWERON:           return (6);
        case SBD_CMD_POWEROFF:          return (7);
        case SBD_CMD_TEST:              return (8);
        default:                        return (-1);
        }
}

#define CMD2INDEX(c)    _cmd2index(c)

static struct dr_state_trans {
        int     x_cmd;
        struct {
                int     x_rv;           /* return value of pre_op */
                int     x_err;          /* error, if any */
        } x_op[DR_STATE_MAX];
} dr_state_transition[] = {
        { SBD_CMD_CONNECT,
                {
                        { 0, 0 },                       /* empty */
                        { 0, 0 },                       /* occupied */
                        { -1, ESBD_STATE },             /* connected */
                        { -1, ESBD_STATE },             /* unconfigured */
                        { -1, ESBD_STATE },             /* partial */
                        { -1, ESBD_STATE },             /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_DISCONNECT,
                {
                        { -1, ESBD_STATE },             /* empty */
                        { 0, 0 },                       /* occupied */
                        { 0, 0 },                       /* connected */
                        { 0, 0 },                       /* unconfigured */
                        { -1, ESBD_STATE },             /* partial */
                        { -1, ESBD_STATE },             /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_CONFIGURE,
                {
                        { -1, ESBD_STATE },             /* empty */
                        { -1, ESBD_STATE },             /* occupied */
                        { 0, 0 },                       /* connected */
                        { 0, 0 },                       /* unconfigured */
                        { 0, 0 },                       /* partial */
                        { 0, 0 },                       /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_UNCONFIGURE,
                {
                        { -1, ESBD_STATE },             /* empty */
                        { -1, ESBD_STATE },             /* occupied */
                        { -1, ESBD_STATE },             /* connected */
                        { -1, ESBD_STATE },             /* unconfigured */
                        { 0, 0 },                       /* partial */
                        { 0, 0 },                       /* configured */
                        { 0, 0 },                       /* release */
                        { 0, 0 },                       /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_ASSIGN,
                {
                        { 0, 0 },                       /* empty */
                        { 0, 0 },                       /* occupied */
                        { -1, ESBD_STATE },             /* connected */
                        { -1, ESBD_STATE },             /* unconfigured */
                        { -1, ESBD_STATE },             /* partial */
                        { -1, ESBD_STATE },             /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_UNASSIGN,
                {
                        { 0, 0 },                       /* empty */
                        { 0, 0 },                       /* occupied */
                        { -1, ESBD_STATE },             /* connected */
                        { -1, ESBD_STATE },             /* unconfigured */
                        { -1, ESBD_STATE },             /* partial */
                        { -1, ESBD_STATE },             /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_POWERON,
                {
                        { 0, 0 },                       /* empty */
                        { 0, 0 },                       /* occupied */
                        { -1, ESBD_STATE },             /* connected */
                        { -1, ESBD_STATE },             /* unconfigured */
                        { -1, ESBD_STATE },             /* partial */
                        { -1, ESBD_STATE },             /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_POWEROFF,
                {
                        { 0, 0 },                       /* empty */
                        { 0, 0 },                       /* occupied */
                        { -1, ESBD_STATE },             /* connected */
                        { -1, ESBD_STATE },             /* unconfigured */
                        { -1, ESBD_STATE },             /* partial */
                        { -1, ESBD_STATE },             /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
        { SBD_CMD_TEST,
                {
                        { 0, 0 },                       /* empty */
                        { 0, 0 },                       /* occupied */
                        { -1, ESBD_STATE },             /* connected */
                        { -1, ESBD_STATE },             /* unconfigured */
                        { -1, ESBD_STATE },             /* partial */
                        { -1, ESBD_STATE },             /* configured */
                        { -1, ESBD_STATE },             /* release */
                        { -1, ESBD_STATE },             /* unreferenced */
                        { -1, ESBD_FATAL_STATE },       /* fatal */
                }
        },
};

/*
 * Global R/W lock to synchronize access across
 * multiple boards.  Users wanting multi-board access
 * must grab WRITE lock, others must grab READ lock.
 */
krwlock_t       dr_grwlock;

/*
 * Head of the boardlist used as a reference point for
 * locating board structs.
 * TODO: eliminate dr_boardlist
 */
dr_board_t      *dr_boardlist;

/*
 * DR support functions.
 */
static dr_devset_t      dr_dev2devset(sbd_comp_id_t *cid);
static int              dr_check_transition(dr_board_t *bp,
                                        dr_devset_t *devsetp,
                                        struct dr_state_trans *transp,
                                        int cmd);
static int              dr_check_unit_attached(dr_common_unit_t *dp);
static sbd_error_t      *dr_init_devlists(dr_board_t *bp);
static void             dr_board_discovery(dr_board_t *bp);
static int              dr_board_init(dr_board_t *bp, dev_info_t *dip, int bd);
static void             dr_board_destroy(dr_board_t *bp);
static void             dr_board_transition(dr_board_t *bp, dr_state_t st);

/*
 * DR driver (DDI) entry points.
 */
static int      dr_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
                                void *arg, void **result);
static int      dr_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int      dr_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int      dr_probe(dev_info_t *dip);
static int      dr_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
                                cred_t *cred_p, int *rval_p);
static int      dr_close(dev_t dev, int flag, int otyp, cred_t *cred_p);
static int      dr_open(dev_t *dev, int flag, int otyp, cred_t *cred_p);

/*
 * DR command processing operations.
 */
static int      dr_copyin_iocmd(dr_handle_t *hp);
static int      dr_copyout_iocmd(dr_handle_t *hp);
static int      dr_copyout_errs(dr_handle_t *hp);
static int      dr_pre_op(dr_handle_t *hp);
static int      dr_post_op(dr_handle_t *hp, int rv);
static int      dr_exec_op(dr_handle_t *hp);
static void     dr_assign_board(dr_handle_t *hp);
static void     dr_unassign_board(dr_handle_t *hp);
static void     dr_connect(dr_handle_t *hp);
static int      dr_disconnect(dr_handle_t *hp);
static void     dr_dev_configure(dr_handle_t *hp);
static void     dr_dev_release(dr_handle_t *hp);
static int      dr_dev_unconfigure(dr_handle_t *hp);
static void     dr_dev_cancel(dr_handle_t *hp);
static int      dr_dev_status(dr_handle_t *hp);
static int      dr_get_ncm(dr_handle_t *hp);
static int      dr_pt_ioctl(dr_handle_t *hp);
static void     dr_poweron_board(dr_handle_t *hp);
static void     dr_poweroff_board(dr_handle_t *hp);
static void     dr_test_board(dr_handle_t *hp);

/*
 * Autoconfiguration data structures
 */
struct cb_ops dr_cb_ops = {
        dr_open,        /* open */
        dr_close,       /* close */
        nodev,          /* strategy */
        nodev,          /* print */
        nodev,          /* dump */
        nodev,          /* read */
        nodev,          /* write */
        dr_ioctl,       /* ioctl */
        nodev,          /* devmap */
        nodev,          /* mmap */
        nodev,          /* segmap */
        nochpoll,       /* chpoll */
        ddi_prop_op,    /* cb_prop_op */
        NULL,           /* struct streamtab */
        D_NEW | D_MP | D_MTSAFE,        /* compatibility flags */
        CB_REV,         /* Rev */
        nodev,          /* cb_aread */
        nodev           /* cb_awrite */
};

struct dev_ops dr_dev_ops = {
        DEVO_REV,       /* build version */
        0,              /* dev ref count */
        dr_getinfo,     /* getinfo */
        nulldev,        /* identify */
        dr_probe,       /* probe */
        dr_attach,      /* attach */
        dr_detach,      /* detach */
        nodev,          /* reset */
        &dr_cb_ops,     /* cb_ops */
        (struct bus_ops *)NULL, /* bus ops */
        NULL,           /* power */
        ddi_quiesce_not_needed, /* quiesce */
};

extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
        &mod_driverops,
        "Dynamic Reconfiguration",
        &dr_dev_ops
};

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

/*
 * Driver entry points.
 */
int
_init(void)
{
        int     err;

        /*
         * If you need to support multiple nodes (instances), then
         * whatever the maximum number of supported nodes is would
         * need to passed as the third parameter to ddi_soft_state_init().
         * Alternative would be to dynamically fini and re-init the
         * soft state structure each time a node is attached.
         */
        err = ddi_soft_state_init((void **)&dr_g.softsp,
            sizeof (dr_softstate_t), 1);
        if (err)
                return (err);

        mutex_init(&dr_g.lock, NULL, MUTEX_DRIVER, NULL);
        rw_init(&dr_grwlock, NULL, RW_DEFAULT, NULL);

        return (mod_install(&modlinkage));
}

int
_fini(void)
{
        int     err;

        if ((err = mod_remove(&modlinkage)) != 0)
                return (err);

        mutex_destroy(&dr_g.lock);
        rw_destroy(&dr_grwlock);

        ddi_soft_state_fini((void **)&dr_g.softsp);

        return (0);
}

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

/*ARGSUSED1*/
static int
dr_open(dev_t *dev, int flag, int otyp, cred_t *cred_p)
{
        int              instance;
        dr_softstate_t  *softsp;
        dr_board_t      *bp;

        /*
         * Don't open unless we've attached.
         */
        instance = DR_MINOR2INST(getminor(*dev));
        softsp = ddi_get_soft_state(dr_g.softsp, instance);
        if (softsp == NULL)
                return (ENXIO);

        mutex_enter(&softsp->i_lock);
        if (!softsp->dr_initialized) {
                int              bd;
                int              rv = 0;

                bp = softsp->boards;

                /* initialize each array element */
                for (bd = 0; bd < MAX_BOARDS; bd++, bp++) {
                        rv = dr_board_init(bp, softsp->dip, bd);
                        if (rv)
                                break;
                }

                if (rv == 0) {
                        softsp->dr_initialized = 1;
                } else {
                        /* destroy elements initialized thus far */
                        while (--bp >= softsp->boards)
                                dr_board_destroy(bp);

                        /* TODO: should this be another errno val ? */
                        mutex_exit(&softsp->i_lock);
                        return (ENXIO);
                }
        }
        mutex_exit(&softsp->i_lock);

        bp = &softsp->boards[DR_MINOR2BNUM(getminor(*dev))];

        /*
         * prevent opening of a dyn-ap for a board
         * that does not exist
         */
        if (!bp->b_assigned) {
                if (drmach_board_lookup(bp->b_num, &bp->b_id) != 0)
                        return (ENODEV);
        }

        return (0);
}

/*ARGSUSED*/
static int
dr_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
        return (0);
}

/*
 * Enable/disable DR features.
 */
int dr_enable = 1;

/*ARGSUSED3*/
static int
dr_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *cred_p, int *rval_p)
{
        int             rv = 0;
        int             instance;
        int             bd;
        dr_handle_t     *hp;
        dr_softstate_t  *softsp;
        static fn_t     f = "dr_ioctl";

        PR_ALL("%s...\n", f);

        instance = DR_MINOR2INST(getminor(dev));
        softsp = ddi_get_soft_state(dr_g.softsp, instance);
        if (softsp == NULL) {
                cmn_err(CE_WARN, "dr%d: module not yet attached", instance);
                return (ENXIO);
        }

        if (!dr_enable) {
                switch (cmd) {
                        case SBD_CMD_STATUS:
                        case SBD_CMD_GETNCM:
                        case SBD_CMD_PASSTHRU:
                                break;
                        default:
                                return (ENOTSUP);
                }
        }

        bd = DR_MINOR2BNUM(getminor(dev));
        if (bd >= MAX_BOARDS)
                return (ENXIO);

        /* get and initialize storage for new handle */
        hp = GETSTRUCT(dr_handle_t, 1);
        hp->h_bd = &softsp->boards[bd];
        hp->h_err = NULL;
        hp->h_dev = getminor(dev);
        hp->h_cmd = cmd;
        hp->h_mode = mode;
        hp->h_iap = (sbd_ioctl_arg_t *)arg;

        /* copy sbd command into handle */
        rv = dr_copyin_iocmd(hp);
        if (rv) {
                FREESTRUCT(hp, dr_handle_t, 1);
                return (EINVAL);
        }

        /* translate canonical name to component type */
        if (hp->h_sbdcmd.cmd_cm.c_id.c_name[0] != '\0') {
                hp->h_sbdcmd.cmd_cm.c_id.c_type =
                    dr_dev_type_to_nt(hp->h_sbdcmd.cmd_cm.c_id.c_name);

                PR_ALL("%s: c_name = %s, c_type = %d\n",
                    f,
                    hp->h_sbdcmd.cmd_cm.c_id.c_name,
                    hp->h_sbdcmd.cmd_cm.c_id.c_type);
        } else {
                /*EMPTY*/
                PR_ALL("%s: c_name is NULL\n", f);
        }

        /* determine scope of operation */
        hp->h_devset = dr_dev2devset(&hp->h_sbdcmd.cmd_cm.c_id);

        switch (hp->h_cmd) {
        case SBD_CMD_STATUS:
        case SBD_CMD_GETNCM:
                /* no locks needed for these commands */
                break;

        default:
                rw_enter(&dr_grwlock, RW_WRITER);
                mutex_enter(&hp->h_bd->b_lock);

                /*
                 * If we're dealing with memory at all, then we have
                 * to keep the "exclusive" global lock held.  This is
                 * necessary since we will probably need to look at
                 * multiple board structs.  Otherwise, we only have
                 * to deal with the board in question and so can drop
                 * the global lock to "shared".
                 */
                rv = DEVSET_IN_SET(hp->h_devset, SBD_COMP_MEM, DEVSET_ANYUNIT);
                if (rv == 0)
                        rw_downgrade(&dr_grwlock);
                break;
        }
        rv = 0;

        if (rv == 0)
                rv = dr_pre_op(hp);
        if (rv == 0) {
                rv = dr_exec_op(hp);
                rv = dr_post_op(hp, rv);
        }

        if (rv == -1)
                rv = EIO;

        if (hp->h_err != NULL)
                if (!(rv = dr_copyout_errs(hp)))
                        rv = EIO;

        /* undo locking, if any, done before dr_pre_op */
        switch (hp->h_cmd) {
        case SBD_CMD_STATUS:
        case SBD_CMD_GETNCM:
                break;

        case SBD_CMD_ASSIGN:
        case SBD_CMD_UNASSIGN:
        case SBD_CMD_POWERON:
        case SBD_CMD_POWEROFF:
        case SBD_CMD_CONNECT:
        case SBD_CMD_CONFIGURE:
        case SBD_CMD_UNCONFIGURE:
        case SBD_CMD_DISCONNECT:
                /* Board changed state. Log a sysevent. */
                if (rv == 0)
                        (void) drmach_log_sysevent(hp->h_bd->b_num, "",
                            SE_SLEEP, 0);
                /* Fall through */

        default:
                mutex_exit(&hp->h_bd->b_lock);
                rw_exit(&dr_grwlock);
        }

        if (hp->h_opts.size != 0)
                FREESTRUCT(hp->h_opts.copts, char, hp->h_opts.size);

        FREESTRUCT(hp, dr_handle_t, 1);

        return (rv);
}

/*ARGSUSED*/
static int
dr_probe(dev_info_t *dip)
{
        return (DDI_PROBE_SUCCESS);
}

static int
dr_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int             rv, rv2;
        int             bd;
        int             instance;
        sbd_error_t     *err;
        dr_softstate_t  *softsp;

        instance = ddi_get_instance(dip);

        switch (cmd) {
        case DDI_ATTACH:
                rw_enter(&dr_grwlock, RW_WRITER);

                rv = ddi_soft_state_zalloc(dr_g.softsp, instance);
                if (rv != DDI_SUCCESS) {
                        cmn_err(CE_WARN, "dr%d: failed to alloc soft-state",
                            instance);
                        return (DDI_FAILURE);
                }

                /* initialize softstate structure */
                softsp = ddi_get_soft_state(dr_g.softsp, instance);
                softsp->dip = dip;

                mutex_init(&softsp->i_lock, NULL, MUTEX_DRIVER, NULL);

                /* allocate board array (aka boardlist) */
                softsp->boards = GETSTRUCT(dr_board_t, MAX_BOARDS);

                /* TODO: eliminate dr_boardlist */
                dr_boardlist = softsp->boards;

                /* initialize each array element */
                rv = DDI_SUCCESS;
                for (bd = 0; bd < MAX_BOARDS; bd++) {
                        dr_board_t      *bp = &softsp->boards[bd];
                        char            *p, *name;
                        int              l, minor_num;

                        /*
                         * initialized board attachment point path
                         * (relative to pseudo) in a form immediately
                         * reusable as an cfgadm command argument.
                         * TODO: clean this up
                         */
                        p = bp->b_path;
                        l = sizeof (bp->b_path);
                        (void) snprintf(p, l, "dr@%d:", instance);
                        while (*p != '\0') {
                                l--;
                                p++;
                        }

                        name = p;
                        err = drmach_board_name(bd, p, l);
                        if (err) {
                                sbd_err_clear(&err);
                                rv = DDI_FAILURE;
                                break;
                        }

                        minor_num = DR_MAKE_MINOR(instance, bd);
                        rv = ddi_create_minor_node(dip, name, S_IFCHR,
                            minor_num, DDI_NT_SBD_ATTACHMENT_POINT, 0);
                        if (rv != DDI_SUCCESS)
                                rv = DDI_FAILURE;
                }

                if (rv == DDI_SUCCESS) {
                        /*
                         * Announce the node's presence.
                         */
                        ddi_report_dev(dip);
                } else {
                        ddi_remove_minor_node(dip, NULL);
                }
                /*
                 * Init registered unsafe devs.
                 */
                dr_unsafe_devs.devnames = NULL;
                rv2 = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, dip,
                    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
                    "unsupported-io-drivers", &dr_unsafe_devs.devnames,
                    &dr_unsafe_devs.ndevs);

                if (rv2 != DDI_PROP_SUCCESS)
                        dr_unsafe_devs.ndevs = 0;

                rw_exit(&dr_grwlock);
                return (rv);

        default:
                return (DDI_FAILURE);
        }

        /*NOTREACHED*/
}

static int
dr_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        int             instance;
        dr_softstate_t  *softsp;

        switch (cmd) {
        case DDI_DETACH:
                if (!dr_modunload_okay)
                        return (DDI_FAILURE);

                rw_enter(&dr_grwlock, RW_WRITER);

                instance = ddi_get_instance(dip);
                softsp = ddi_get_soft_state(dr_g.softsp, instance);

                /* TODO: eliminate dr_boardlist */
                ASSERT(softsp->boards == dr_boardlist);

                /* remove all minor nodes */
                ddi_remove_minor_node(dip, NULL);

                if (softsp->dr_initialized) {
                        int bd;

                        for (bd = 0; bd < MAX_BOARDS; bd++)
                                dr_board_destroy(&softsp->boards[bd]);
                }

                FREESTRUCT(softsp->boards, dr_board_t, MAX_BOARDS);
                mutex_destroy(&softsp->i_lock);
                ddi_soft_state_free(dr_g.softsp, instance);

                rw_exit(&dr_grwlock);
                return (DDI_SUCCESS);

        default:
                return (DDI_FAILURE);
        }
        /*NOTREACHED*/
}

static int
dr_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
        _NOTE(ARGUNUSED(dip))

        dev_t           dev = (dev_t)arg;
        int             instance, error;
        dr_softstate_t  *softsp;

        *result = NULL;
        error = DDI_SUCCESS;
        instance = DR_MINOR2INST(getminor(dev));

        switch (cmd) {
        case DDI_INFO_DEVT2DEVINFO:
                softsp = ddi_get_soft_state(dr_g.softsp, instance);
                if (softsp == NULL)
                        return (DDI_FAILURE);
                *result = (void *)softsp->dip;
                break;

        case DDI_INFO_DEVT2INSTANCE:
                *result = (void *)(uintptr_t)instance;
                break;

        default:
                error = DDI_FAILURE;
                break;
        }

        return (error);
}

/*
 * DR operations.
 */

static int
dr_copyin_iocmd(dr_handle_t *hp)
{
        static fn_t     f = "dr_copyin_iocmd";
        sbd_cmd_t       *scp = &hp->h_sbdcmd;

        if (hp->h_iap == NULL)
                return (EINVAL);

        bzero((caddr_t)scp, sizeof (sbd_cmd_t));

#ifdef _MULTI_DATAMODEL
        if (ddi_model_convert_from(hp->h_mode & FMODELS) == DDI_MODEL_ILP32) {
                sbd_cmd32_t     scmd32;

                bzero((caddr_t)&scmd32, sizeof (sbd_cmd32_t));

                if (ddi_copyin((void *)hp->h_iap, (void *)&scmd32,
                    sizeof (sbd_cmd32_t), hp->h_mode)) {
                        cmn_err(CE_WARN,
                            "%s: (32bit) failed to copyin "
                            "sbdcmd-struct", f);
                        return (EFAULT);
                }
                scp->cmd_cm.c_id.c_type = scmd32.cmd_cm.c_id.c_type;
                scp->cmd_cm.c_id.c_unit = scmd32.cmd_cm.c_id.c_unit;
                bcopy(&scmd32.cmd_cm.c_id.c_name[0],
                    &scp->cmd_cm.c_id.c_name[0], OBP_MAXPROPNAME);
                scp->cmd_cm.c_flags = scmd32.cmd_cm.c_flags;
                scp->cmd_cm.c_len = scmd32.cmd_cm.c_len;
                scp->cmd_cm.c_opts = (caddr_t)(uintptr_t)scmd32.cmd_cm.c_opts;

                switch (hp->h_cmd) {
                case SBD_CMD_STATUS:
                        scp->cmd_stat.s_nbytes = scmd32.cmd_stat.s_nbytes;
                        scp->cmd_stat.s_statp =
                            (caddr_t)(uintptr_t)scmd32.cmd_stat.s_statp;
                        break;
                default:
                        break;

                }
        } else
#endif /* _MULTI_DATAMODEL */
        if (ddi_copyin((void *)hp->h_iap, (void *)scp,
            sizeof (sbd_cmd_t), hp->h_mode) != 0) {
                cmn_err(CE_WARN,
                    "%s: failed to copyin sbdcmd-struct", f);
                return (EFAULT);
        }

        if ((hp->h_opts.size = scp->cmd_cm.c_len) != 0) {
                hp->h_opts.copts = GETSTRUCT(char, scp->cmd_cm.c_len + 1);
                ++hp->h_opts.size;
                if (ddi_copyin((void *)scp->cmd_cm.c_opts,
                    (void *)hp->h_opts.copts,
                    scp->cmd_cm.c_len, hp->h_mode) != 0) {
                        cmn_err(CE_WARN, "%s: failed to copyin options", f);
                        return (EFAULT);
                }
        }

        return (0);
}

static int
dr_copyout_iocmd(dr_handle_t *hp)
{
        static fn_t     f = "dr_copyout_iocmd";
        sbd_cmd_t       *scp = &hp->h_sbdcmd;

        if (hp->h_iap == NULL)
                return (EINVAL);

#ifdef _MULTI_DATAMODEL
        if (ddi_model_convert_from(hp->h_mode & FMODELS) == DDI_MODEL_ILP32) {
                sbd_cmd32_t     scmd32;

                scmd32.cmd_cm.c_id.c_type = scp->cmd_cm.c_id.c_type;
                scmd32.cmd_cm.c_id.c_unit = scp->cmd_cm.c_id.c_unit;
                bcopy(&scp->cmd_cm.c_id.c_name[0],
                    &scmd32.cmd_cm.c_id.c_name[0], OBP_MAXPROPNAME);

                scmd32.cmd_cm.c_flags = scp->cmd_cm.c_flags;
                scmd32.cmd_cm.c_len = scp->cmd_cm.c_len;
                scmd32.cmd_cm.c_opts = (caddr32_t)(uintptr_t)scp->cmd_cm.c_opts;

                switch (hp->h_cmd) {
                case SBD_CMD_GETNCM:
                        scmd32.cmd_getncm.g_ncm = scp->cmd_getncm.g_ncm;
                        break;
                default:
                        break;
                }

                if (ddi_copyout((void *)&scmd32, (void *)hp->h_iap,
                    sizeof (sbd_cmd32_t), hp->h_mode)) {
                        cmn_err(CE_WARN,
                            "%s: (32bit) failed to copyout "
                            "sbdcmd-struct", f);
                        return (EFAULT);
                }
        } else
#endif /* _MULTI_DATAMODEL */
        if (ddi_copyout((void *)scp, (void *)hp->h_iap,
            sizeof (sbd_cmd_t), hp->h_mode) != 0) {
                cmn_err(CE_WARN,
                    "%s: failed to copyout sbdcmd-struct", f);
                return (EFAULT);
        }

        return (0);
}

static int
dr_copyout_errs(dr_handle_t *hp)
{
        static fn_t     f = "dr_copyout_errs";

        if (hp->h_err == NULL)
                return (0);

        if (hp->h_err->e_code) {
                PR_ALL("%s: error %d %s",
                    f, hp->h_err->e_code, hp->h_err->e_rsc);
        }

#ifdef _MULTI_DATAMODEL
        if (ddi_model_convert_from(hp->h_mode & FMODELS) == DDI_MODEL_ILP32) {
                sbd_error32_t   *serr32p;

                serr32p = GETSTRUCT(sbd_error32_t, 1);

                serr32p->e_code = hp->h_err->e_code;
                bcopy(&hp->h_err->e_rsc[0], &serr32p->e_rsc[0],
                    MAXPATHLEN);
                if (ddi_copyout((void *)serr32p,
                    (void *)&((sbd_ioctl_arg32_t *)hp->h_iap)->i_err,
                    sizeof (sbd_error32_t), hp->h_mode)) {
                        cmn_err(CE_WARN,
                            "%s: (32bit) failed to copyout", f);
                        return (EFAULT);
                }
                FREESTRUCT(serr32p, sbd_error32_t, 1);
        } else
#endif /* _MULTI_DATAMODEL */
        if (ddi_copyout((void *)hp->h_err,
            (void *)&hp->h_iap->i_err,
            sizeof (sbd_error_t), hp->h_mode)) {
                cmn_err(CE_WARN,
                    "%s: failed to copyout", f);
                return (EFAULT);
        }

        sbd_err_clear(&hp->h_err);

        return (0);

}

/*
 * pre-op entry point must sbd_err_set_c(), if needed.
 * Return value of non-zero indicates failure.
 */
static int
dr_pre_op(dr_handle_t *hp)
{
        int             rv = 0, t;
        int             cmd, serr = 0;
        dr_devset_t     devset;
        dr_board_t      *bp = hp->h_bd;
        dr_handle_t     *shp = hp;
        static fn_t     f = "dr_pre_op";

        cmd = hp->h_cmd;
        devset = shp->h_devset;

        PR_ALL("%s (cmd = %s)...\n", f, SBD_CMD_STR(cmd));

        devset = DEVSET_AND(devset, DR_DEVS_PRESENT(bp));
        hp->h_err = drmach_pre_op(cmd, bp->b_id, &hp->h_opts, &devset);
        if (hp->h_err != NULL) {
                PR_ALL("drmach_pre_op failed for cmd %s(%d)\n",
                    SBD_CMD_STR(cmd), cmd);
                return (-1);
        }

        /*
         * Check for valid state transitions.
         */
        if ((t = CMD2INDEX(cmd)) != -1) {
                struct dr_state_trans   *transp;
                int                     state_err;

                transp = &dr_state_transition[t];
                ASSERT(transp->x_cmd == cmd);

                state_err = dr_check_transition(bp, &devset, transp, cmd);

                if (state_err < 0) {
                        /*
                         * Invalidate device.
                         */
                        dr_op_err(CE_IGNORE, hp, ESBD_INVAL, NULL);
                        serr = -1;
                        PR_ALL("%s: invalid devset (0x%x)\n",
                            f, (uint_t)devset);
                } else if (state_err != 0) {
                        /*
                         * State transition is not a valid one.
                         */
                        dr_op_err(CE_IGNORE, hp,
                            transp->x_op[state_err].x_err, NULL);

                        serr = transp->x_op[state_err].x_rv;

                        PR_ALL("%s: invalid state %s(%d) for cmd %s(%d)\n",
                            f, state_str[state_err], state_err,
                            SBD_CMD_STR(cmd), cmd);
                } else {
                        shp->h_devset = devset;
                }
        }

        if (serr) {
                rv = -1;
        }

        return (rv);
}

static int
dr_post_op(dr_handle_t *hp, int rv)
{
        int             cmd;
        sbd_error_t     *err;
        dr_board_t      *bp = hp->h_bd;
        static fn_t     f = "dr_post_op";

        cmd = hp->h_cmd;

        PR_ALL("%s (cmd = %s)...\n", f, SBD_CMD_STR(cmd));

        err = drmach_post_op(cmd, bp->b_id, &hp->h_opts, rv);
        if (err != NULL) {
                PR_ALL("drmach_post_op failed for cmd %s(%d)\n",
                    SBD_CMD_STR(cmd), cmd);
                if (rv == 0) {
                        ASSERT(hp->h_err == NULL);
                        hp->h_err = err;
                        rv = -1;
                } else if (hp->h_err == NULL) {
                        hp->h_err = err;
                } else {
                        sbd_err_clear(&err);
                }
        }

        return (rv);
}

static int
dr_exec_op(dr_handle_t *hp)
{
        int             rv = 0;
        static fn_t     f = "dr_exec_op";

        /* errors should have been caught by now */
        ASSERT(hp->h_err == NULL);

        switch (hp->h_cmd) {
        case SBD_CMD_ASSIGN:
                dr_assign_board(hp);
                break;

        case SBD_CMD_UNASSIGN:
                dr_unassign_board(hp);
                break;

        case SBD_CMD_POWEROFF:
                dr_poweroff_board(hp);
                break;

        case SBD_CMD_POWERON:
                dr_poweron_board(hp);
                break;

        case SBD_CMD_TEST:
                dr_test_board(hp);
                break;

        case SBD_CMD_CONNECT:
                dr_connect(hp);
                break;

        case SBD_CMD_CONFIGURE:
                dr_dev_configure(hp);
                break;

        case SBD_CMD_UNCONFIGURE:
                dr_dev_release(hp);
                if (hp->h_err == NULL)
                        rv = dr_dev_unconfigure(hp);
                else
                        dr_dev_cancel(hp);
                break;

        case SBD_CMD_DISCONNECT:
                rv = dr_disconnect(hp);
                break;

        case SBD_CMD_STATUS:
                rv = dr_dev_status(hp);
                break;

        case SBD_CMD_GETNCM:
                hp->h_sbdcmd.cmd_getncm.g_ncm = dr_get_ncm(hp);
                rv = dr_copyout_iocmd(hp);
                break;

        case SBD_CMD_PASSTHRU:
                rv = dr_pt_ioctl(hp);
                break;

        default:
                cmn_err(CE_WARN,
                    "%s: unknown command (%d)",
                    f, hp->h_cmd);
                break;
        }

        if (hp->h_err != NULL) {
                rv = -1;
        }

        return (rv);
}

static void
dr_assign_board(dr_handle_t *hp)
{
        dr_board_t *bp = hp->h_bd;

        hp->h_err = drmach_board_assign(bp->b_num, &bp->b_id);
        if (hp->h_err == NULL) {
                bp->b_assigned = 1;
        }
}

static void
dr_unassign_board(dr_handle_t *hp)
{
        dr_board_t *bp = hp->h_bd;

        /*
         * Block out status during unassign.
         * Not doing cv_wait_sig here as starfire SSP software
         * ignores unassign failure and removes board from
         * domain mask causing system panic.
         * TODO: Change cv_wait to cv_wait_sig when SSP software
         * handles unassign failure.
         */
        dr_lock_status(bp);

        hp->h_err = drmach_board_unassign(bp->b_id);
        if (hp->h_err == NULL) {
                /*
                 * clear drmachid_t handle; not valid after board unassign
                 */
                bp->b_id = 0;
                bp->b_assigned = 0;
        }

        dr_unlock_status(bp);
}

static void
dr_poweron_board(dr_handle_t *hp)
{
        dr_board_t *bp = hp->h_bd;

        hp->h_err = drmach_board_poweron(bp->b_id);
}

static void
dr_poweroff_board(dr_handle_t *hp)
{
        dr_board_t *bp = hp->h_bd;

        hp->h_err = drmach_board_poweroff(bp->b_id);
}

static void
dr_test_board(dr_handle_t *hp)
{
        dr_board_t *bp = hp->h_bd;
        hp->h_err = drmach_board_test(bp->b_id, &hp->h_opts,
            dr_cmd_flags(hp) & SBD_FLAG_FORCE);
}

/*
 * Create and populate the component nodes for a board.  Assumes that the
 * devlists for the board have been initialized.
 */
static void
dr_make_comp_nodes(dr_board_t *bp)
{
        int     i;

        /*
         * Make nodes for the individual components on the board.
         * First we need to initialize memory unit data structures of board
         * structure.
         */
        for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
                dr_mem_unit_t *mp;

                mp = dr_get_mem_unit(bp, i);
                dr_init_mem_unit(mp);
        }

        /*
         * Initialize cpu unit data structures.
         */
        for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
                dr_cpu_unit_t *cp;

                cp = dr_get_cpu_unit(bp, i);
                dr_init_cpu_unit(cp);
        }

        /*
         * Initialize io unit data structures.
         */
        for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
                dr_io_unit_t *ip;

                ip = dr_get_io_unit(bp, i);
                dr_init_io_unit(ip);
        }

        dr_board_transition(bp, DR_STATE_CONNECTED);

        bp->b_rstate = SBD_STAT_CONNECTED;
        bp->b_ostate = SBD_STAT_UNCONFIGURED;
        bp->b_cond = SBD_COND_OK;
        (void) drv_getparm(TIME, (void *)&bp->b_time);

}

/*
 * Only do work if called to operate on an entire board
 * which doesn't already have components present.
 */
static void
dr_connect(dr_handle_t *hp)
{
        dr_board_t      *bp = hp->h_bd;
        static fn_t     f = "dr_connect";

        PR_ALL("%s...\n", f);

        if (DR_DEVS_PRESENT(bp)) {
                /*
                 * Board already has devices present.
                 */
                PR_ALL("%s: devices already present (" DEVSET_FMT_STR ")\n",
                    f, DEVSET_FMT_ARG(DR_DEVS_PRESENT(bp)));
                return;
        }

        hp->h_err = drmach_board_connect(bp->b_id, &hp->h_opts);
        if (hp->h_err)
                return;

        hp->h_err = dr_init_devlists(bp);
        if (hp->h_err)
                return;
        else if (bp->b_ndev == 0) {
                dr_op_err(CE_WARN, hp, ESBD_EMPTY_BD, bp->b_path);
                return;
        } else {
                dr_make_comp_nodes(bp);
                return;
        }
        /*NOTREACHED*/
}

static int
dr_disconnect(dr_handle_t *hp)
{
        int             i;
        dr_devset_t     devset;
        dr_board_t      *bp = hp->h_bd;
        static fn_t     f = "dr_disconnect";

        PR_ALL("%s...\n", f);

        /*
         * Only devices which are present, but
         * unattached can be disconnected.
         */
        devset = hp->h_devset & DR_DEVS_PRESENT(bp) &
            DR_DEVS_UNATTACHED(bp);

        if ((devset == 0) && DR_DEVS_PRESENT(bp)) {
                dr_op_err(CE_IGNORE, hp, ESBD_EMPTY_BD, bp->b_path);
                return (0);
        }

        /*
         * Block out status during disconnect.
         */
        mutex_enter(&bp->b_slock);
        while (bp->b_sflags & DR_BSLOCK) {
                if (cv_wait_sig(&bp->b_scv, &bp->b_slock) == 0) {
                        mutex_exit(&bp->b_slock);
                        return (EINTR);
                }
        }
        bp->b_sflags |= DR_BSLOCK;
        mutex_exit(&bp->b_slock);

        hp->h_err = drmach_board_disconnect(bp->b_id, &hp->h_opts);
        if (hp->h_err && hp->h_err->e_code == EX86_WALK_DEPENDENCY) {
                /*
                 * Other boards have dependency on this board. No device nodes
                 * have been destroyed so keep current board status.
                 */
                goto disconnect_done;
        }

        DR_DEVS_DISCONNECT(bp, devset);

        ASSERT((DR_DEVS_ATTACHED(bp) & devset) == 0);

        /*
         * Update per-device state transitions.
         */
        for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
                dr_cpu_unit_t *cp;

                if (!DEVSET_IN_SET(devset, SBD_COMP_CPU, i))
                        continue;

                cp = dr_get_cpu_unit(bp, i);
                if (dr_disconnect_cpu(cp) == 0)
                        dr_device_transition(&cp->sbc_cm, DR_STATE_EMPTY);
                else if (cp->sbc_cm.sbdev_error != NULL)
                        DRERR_SET_C(&hp->h_err, &cp->sbc_cm.sbdev_error);

                ASSERT(cp->sbc_cm.sbdev_error == NULL);
        }

        for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
                dr_mem_unit_t *mp;

                if (!DEVSET_IN_SET(devset, SBD_COMP_MEM, i))
                        continue;

                mp = dr_get_mem_unit(bp, i);
                if (dr_disconnect_mem(mp) == 0)
                        dr_device_transition(&mp->sbm_cm, DR_STATE_EMPTY);
                else if (mp->sbm_cm.sbdev_error != NULL)
                        DRERR_SET_C(&hp->h_err, &mp->sbm_cm.sbdev_error);

                ASSERT(mp->sbm_cm.sbdev_error == NULL);
        }

        for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
                dr_io_unit_t *ip;

                if (!DEVSET_IN_SET(devset, SBD_COMP_IO, i))
                        continue;

                ip = dr_get_io_unit(bp, i);
                if (dr_disconnect_io(ip) == 0)
                        dr_device_transition(&ip->sbi_cm, DR_STATE_EMPTY);
                else if (ip->sbi_cm.sbdev_error != NULL)
                        DRERR_SET_C(&hp->h_err, &ip->sbi_cm.sbdev_error);

                ASSERT(ip->sbi_cm.sbdev_error == NULL);
        }

        if (hp->h_err) {
                /*
                 * For certain errors, drmach_board_disconnect will mark
                 * the board as unusable; in these cases the devtree must
                 * be purged so that status calls will succeed.
                 * XXX
                 * This implementation checks for discrete error codes -
                 * someday, the i/f to drmach_board_disconnect should be
                 * changed to avoid the e_code testing.
                 */
                if (hp->h_err->e_code == EX86_DEPROBE) {
                        bp->b_ostate = SBD_STAT_UNCONFIGURED;
                        bp->b_busy = 0;
                        (void) drv_getparm(TIME, (void *)&bp->b_time);

                        if (drmach_board_deprobe(bp->b_id))
                                goto disconnect_done;
                        else
                                bp->b_ndev = 0;
                }
        }

        /*
         * Once all the components on a board have been disconnect
         * the board's state can transition to disconnected and
         * we can allow the deprobe to take place.
         */
        if (hp->h_err == NULL && DR_DEVS_PRESENT(bp) == 0) {
                dr_board_transition(bp, DR_STATE_OCCUPIED);
                bp->b_rstate = SBD_STAT_DISCONNECTED;
                bp->b_ostate = SBD_STAT_UNCONFIGURED;
                bp->b_busy = 0;
                (void) drv_getparm(TIME, (void *)&bp->b_time);

                hp->h_err = drmach_board_deprobe(bp->b_id);

                if (hp->h_err == NULL) {
                        bp->b_ndev = 0;
                        dr_board_transition(bp, DR_STATE_EMPTY);
                        bp->b_rstate = SBD_STAT_EMPTY;
                        (void) drv_getparm(TIME, (void *)&bp->b_time);
                }
        }

disconnect_done:
        dr_unlock_status(bp);

        return (0);
}

/*
 * Check if a particular device is a valid target of the current
 * operation. Return 1 if it is a valid target, and 0 otherwise.
 */
static int
dr_dev_is_target(dr_dev_unit_t *dp, int present_only, uint_t uset)
{
        dr_common_unit_t *cp;
        int              is_present;
        int              is_attached;

        cp = &dp->du_common;

        /* check if the user requested this device */
        if ((uset & (1 << cp->sbdev_unum)) == 0) {
                return (0);
        }

        is_present = DR_DEV_IS_PRESENT(cp) ? 1 : 0;
        is_attached = DR_DEV_IS_ATTACHED(cp) ? 1 : 0;

        /*
         * If the present_only flag is set, a valid target
         * must be present but not attached. Otherwise, it
         * must be both present and attached.
         */
        if (is_present && (present_only ^ is_attached)) {
                /* sanity check */
                ASSERT(cp->sbdev_id != (drmachid_t)0);

                return (1);
        }

        return (0);
}

static void
dr_dev_make_list(dr_handle_t *hp, sbd_comp_type_t type, int present_only,
    dr_common_unit_t ***devlist, int *devnum)
{
        dr_board_t      *bp = hp->h_bd;
        int              unum;
        int              nunits;
        uint_t           uset;
        int              len;
        dr_common_unit_t **list, **wp;

        switch (type) {
        case SBD_COMP_CPU:
                nunits = MAX_CPU_UNITS_PER_BOARD;
                break;
        case SBD_COMP_MEM:
                nunits = MAX_MEM_UNITS_PER_BOARD;
                break;
        case SBD_COMP_IO:
                nunits = MAX_IO_UNITS_PER_BOARD;
                break;
        default:
                nunits = 0;
                /* catch this in debug kernels */
                ASSERT(0);
                break;
        }

        /* allocate list storage. */
        len = sizeof (dr_common_unit_t *) * (nunits + 1);
        list = kmem_zalloc(len, KM_SLEEP);

        /* record length of storage in first element */
        *list++ = (dr_common_unit_t *)(uintptr_t)len;

        /* get bit array signifying which units are to be involved */
        uset = DEVSET_GET_UNITSET(hp->h_devset, type);

        /*
         * Adjust the loop count for CPU devices since all cores
         * in a CMP will be examined in a single iteration.
         */
        if (type == SBD_COMP_CPU) {
                nunits = MAX_CMP_UNITS_PER_BOARD;
        }

        /* populate list */
        for (wp = list, unum = 0; unum < nunits; unum++) {
                dr_dev_unit_t   *dp;
                int             core;
                int             cunum;

                dp = DR_GET_BOARD_DEVUNIT(bp, type, unum);
                if (dr_dev_is_target(dp, present_only, uset)) {
                        *wp++ = &dp->du_common;
                }

                /* further processing is only required for CPUs */
                if (type != SBD_COMP_CPU) {
                        continue;
                }

                /*
                 * Add any additional cores from the current CPU
                 * device. This is to ensure that all the cores
                 * are grouped together in the device list, and
                 * consequently sequenced together during the actual
                 * operation.
                 */
                for (core = 1; core < MAX_CORES_PER_CMP; core++) {
                        cunum = DR_CMP_CORE_UNUM(unum, core);
                        dp = DR_GET_BOARD_DEVUNIT(bp, type, cunum);

                        if (dr_dev_is_target(dp, present_only, uset)) {
                                *wp++ = &dp->du_common;
                        }
                }
        }

        /* calculate number of units in list, return result and list pointer */
        *devnum = wp - list;
        *devlist = list;
}

static void
dr_dev_clean_up(dr_handle_t *hp, dr_common_unit_t **list, int devnum)
{
        int len;
        int n = 0;
        dr_common_unit_t *cp, **rp = list;

        /*
         * move first encountered unit error to handle if handle
         * does not yet have a recorded error.
         */
        if (hp->h_err == NULL) {
                while (n++ < devnum) {
                        cp = *rp++;
                        if (cp->sbdev_error != NULL) {
                                hp->h_err = cp->sbdev_error;
                                cp->sbdev_error = NULL;
                                break;
                        }
                }
        }

        /* free remaining unit errors */
        while (n++ < devnum) {
                cp = *rp++;
                if (cp->sbdev_error != NULL) {
                        sbd_err_clear(&cp->sbdev_error);
                        cp->sbdev_error = NULL;
                }
        }

        /* free list */
        list -= 1;
        len = (int)(uintptr_t)list[0];
        kmem_free(list, len);
}

static int
dr_dev_walk(dr_handle_t *hp, sbd_comp_type_t type, int present_only,
    int (*pre_op)(dr_handle_t *, dr_common_unit_t **, int),
    void (*op)(dr_handle_t *, dr_common_unit_t *),
    int (*post_op)(dr_handle_t *, dr_common_unit_t **, int),
    void (*board_op)(dr_handle_t *, dr_common_unit_t **, int))
{
        int                       devnum, rv;
        dr_common_unit_t        **devlist;

        dr_dev_make_list(hp, type, present_only, &devlist, &devnum);

        rv = 0;
        if (devnum > 0) {
                rv = (*pre_op)(hp, devlist, devnum);
                if (rv == 0) {
                        int n;

                        for (n = 0; n < devnum; n++)
                                (*op)(hp, devlist[n]);

                        rv = (*post_op)(hp, devlist, devnum);

                        (*board_op)(hp, devlist, devnum);
                }
        }

        dr_dev_clean_up(hp, devlist, devnum);
        return (rv);
}

/*ARGSUSED*/
static int
dr_dev_noop(dr_handle_t *hp, dr_common_unit_t **devlist, int devnum)
{
        return (0);
}

static void
dr_attach_update_state(dr_handle_t *hp,
    dr_common_unit_t **devlist, int devnum)
{
        dr_board_t      *bp = hp->h_bd;
        int             i;
        dr_devset_t     devs_unattached, devs_present;
        static fn_t     f = "dr_attach_update_state";

        for (i = 0; i < devnum; i++) {
                dr_common_unit_t *cp = devlist[i];

                if (dr_check_unit_attached(cp) == -1) {
                        PR_ALL("%s: ERROR %s not attached\n",
                            f, cp->sbdev_path);
                        continue;
                }

                DR_DEV_SET_ATTACHED(cp);

                dr_device_transition(cp, DR_STATE_CONFIGURED);
                cp->sbdev_cond = SBD_COND_OK;
        }

        devs_present = DR_DEVS_PRESENT(bp);
        devs_unattached = DR_DEVS_UNATTACHED(bp);

        switch (bp->b_state) {
        case DR_STATE_CONNECTED:
        case DR_STATE_UNCONFIGURED:
                ASSERT(devs_present);

                if (devs_unattached == 0) {
                        /*
                         * All devices finally attached.
                         */
                        dr_board_transition(bp, DR_STATE_CONFIGURED);
                        hp->h_bd->b_ostate = SBD_STAT_CONFIGURED;
                        hp->h_bd->b_rstate = SBD_STAT_CONNECTED;
                        hp->h_bd->b_cond = SBD_COND_OK;
                        hp->h_bd->b_busy = 0;
                        (void) drv_getparm(TIME, (void *)&hp->h_bd->b_time);
                } else if (devs_present != devs_unattached) {
                        /*
                         * Only some devices are fully attached.
                         */
                        dr_board_transition(bp, DR_STATE_PARTIAL);
                        hp->h_bd->b_rstate = SBD_STAT_CONNECTED;
                        hp->h_bd->b_ostate = SBD_STAT_CONFIGURED;
                        (void) drv_getparm(TIME, (void *)&hp->h_bd->b_time);
                }
                break;

        case DR_STATE_PARTIAL:
                ASSERT(devs_present);
                /*
                 * All devices finally attached.
                 */
                if (devs_unattached == 0) {
                        dr_board_transition(bp, DR_STATE_CONFIGURED);
                        hp->h_bd->b_rstate = SBD_STAT_CONNECTED;
                        hp->h_bd->b_ostate = SBD_STAT_CONFIGURED;
                        hp->h_bd->b_cond = SBD_COND_OK;
                        hp->h_bd->b_busy = 0;
                        (void) drv_getparm(TIME, (void *)&hp->h_bd->b_time);
                }
                break;

        default:
                break;
        }
}

static void
dr_dev_configure(dr_handle_t *hp)
{
        int rv;

        rv = dr_dev_walk(hp, SBD_COMP_CPU, 1,
            dr_pre_attach_cpu,
            dr_attach_cpu,
            dr_post_attach_cpu,
            dr_attach_update_state);

        if (rv >= 0) {
                rv = dr_dev_walk(hp, SBD_COMP_MEM, 1,
                    dr_pre_attach_mem,
                    dr_attach_mem,
                    dr_post_attach_mem,
                    dr_attach_update_state);
        }

        if (rv >= 0) {
                (void) dr_dev_walk(hp, SBD_COMP_IO, 1,
                    dr_pre_attach_io,
                    dr_attach_io,
                    dr_post_attach_io,
                    dr_attach_update_state);
        }
}

static void
dr_release_update_state(dr_handle_t *hp,
    dr_common_unit_t **devlist, int devnum)
{
        _NOTE(ARGUNUSED(devlist))
        _NOTE(ARGUNUSED(devnum))

        dr_board_t *bp = hp->h_bd;

        /*
         * If the entire board was released and all components
         * unreferenced then transfer it to the UNREFERENCED state.
         */
        if ((bp->b_state != DR_STATE_RELEASE) &&
            (DR_DEVS_RELEASED(bp) == DR_DEVS_ATTACHED(bp))) {
                dr_board_transition(bp, DR_STATE_RELEASE);
                hp->h_bd->b_busy = 1;
        }
}

/* called by dr_release_done [below] and dr_release_mem_done [dr_mem.c] */
int
dr_release_dev_done(dr_common_unit_t *cp)
{
        if (cp->sbdev_state == DR_STATE_RELEASE) {
                ASSERT(DR_DEV_IS_RELEASED(cp));

                DR_DEV_SET_UNREFERENCED(cp);

                dr_device_transition(cp, DR_STATE_UNREFERENCED);

                return (0);
        } else {
                return (-1);
        }
}

static void
dr_release_done(dr_handle_t *hp, dr_common_unit_t *cp)
{
        _NOTE(ARGUNUSED(hp))

        dr_board_t              *bp;
        static fn_t             f = "dr_release_done";

        PR_ALL("%s...\n", f);

        /* get board pointer & sanity check */
        bp = cp->sbdev_bp;
        ASSERT(bp == hp->h_bd);

        /*
         * Transfer the device which just completed its release
         * to the UNREFERENCED state.
         */
        switch (cp->sbdev_type) {
        case SBD_COMP_MEM:
                dr_release_mem_done(cp);
                break;

        default:
                DR_DEV_SET_RELEASED(cp);

                dr_device_transition(cp, DR_STATE_RELEASE);

                (void) dr_release_dev_done(cp);
                break;
        }

        /*
         * If we're not already in the RELEASE state for this
         * board and we now have released all that were previously
         * attached, then transfer the board to the RELEASE state.
         */
        if ((bp->b_state == DR_STATE_RELEASE) &&
            (DR_DEVS_RELEASED(bp) == DR_DEVS_UNREFERENCED(bp))) {
                dr_board_transition(bp, DR_STATE_UNREFERENCED);
                bp->b_busy = 1;
                (void) drv_getparm(TIME, (void *)&bp->b_time);
        }
}

static void
dr_dev_release_mem(dr_handle_t *hp, dr_common_unit_t *dv)
{
        dr_release_mem(dv);
        dr_release_done(hp, dv);
}

static void
dr_dev_release(dr_handle_t *hp)
{
        int rv;

        hp->h_bd->b_busy = 1;

        rv = dr_dev_walk(hp, SBD_COMP_CPU, 0,
            dr_pre_release_cpu,
            dr_release_done,
            dr_dev_noop,
            dr_release_update_state);

        if (rv >= 0) {
                rv = dr_dev_walk(hp, SBD_COMP_MEM, 0,
                    dr_pre_release_mem,
                    dr_dev_release_mem,
                    dr_dev_noop,
                    dr_release_update_state);
        }

        if (rv >= 0) {
                rv = dr_dev_walk(hp, SBD_COMP_IO, 0,
                    dr_pre_release_io,
                    dr_release_done,
                    dr_dev_noop,
                    dr_release_update_state);

        }

        if (rv < 0)
                hp->h_bd->b_busy = 0;
        /* else, b_busy will be cleared in dr_detach_update_state() */
}

static void
dr_detach_update_state(dr_handle_t *hp,
    dr_common_unit_t **devlist, int devnum)
{
        dr_board_t      *bp = hp->h_bd;
        int             i;
        dr_state_t      bstate;
        static fn_t     f = "dr_detach_update_state";

        for (i = 0; i < devnum; i++) {
                dr_common_unit_t *cp = devlist[i];

                if (dr_check_unit_attached(cp) >= 0) {
                        /*
                         * Device is still attached probably due
                         * to an error.  Need to keep track of it.
                         */
                        PR_ALL("%s: ERROR %s not detached\n",
                            f, cp->sbdev_path);

                        continue;
                }

                DR_DEV_CLR_ATTACHED(cp);
                DR_DEV_CLR_RELEASED(cp);
                DR_DEV_CLR_UNREFERENCED(cp);
                dr_device_transition(cp, DR_STATE_UNCONFIGURED);
        }

        bstate = bp->b_state;
        if (bstate != DR_STATE_UNCONFIGURED) {
                if (DR_DEVS_PRESENT(bp) == DR_DEVS_UNATTACHED(bp)) {
                        /*
                         * All devices are finally detached.
                         */
                        dr_board_transition(bp, DR_STATE_UNCONFIGURED);
                        hp->h_bd->b_ostate = SBD_STAT_UNCONFIGURED;
                        (void) drv_getparm(TIME, (void *)&hp->h_bd->b_time);
                } else if ((bp->b_state != DR_STATE_PARTIAL) &&
                    (DR_DEVS_ATTACHED(bp) !=
                    DR_DEVS_PRESENT(bp))) {
                        /*
                         * Some devices remain attached.
                         */
                        dr_board_transition(bp, DR_STATE_PARTIAL);
                        (void) drv_getparm(TIME, (void *)&hp->h_bd->b_time);
                }

                if ((hp->h_devset & DR_DEVS_UNATTACHED(bp)) == hp->h_devset)
                        hp->h_bd->b_busy = 0;
        }
}

static int
dr_dev_unconfigure(dr_handle_t *hp)
{
        dr_board_t      *bp = hp->h_bd;

        /*
         * Block out status during IO unconfig.
         */
        mutex_enter(&bp->b_slock);
        while (bp->b_sflags & DR_BSLOCK) {
                if (cv_wait_sig(&bp->b_scv, &bp->b_slock) == 0) {
                        mutex_exit(&bp->b_slock);
                        return (EINTR);
                }
        }
        bp->b_sflags |= DR_BSLOCK;
        mutex_exit(&bp->b_slock);

        (void) dr_dev_walk(hp, SBD_COMP_IO, 0,
            dr_pre_detach_io,
            dr_detach_io,
            dr_post_detach_io,
            dr_detach_update_state);

        dr_unlock_status(bp);

        (void) dr_dev_walk(hp, SBD_COMP_CPU, 0,
            dr_pre_detach_cpu,
            dr_detach_cpu,
            dr_post_detach_cpu,
            dr_detach_update_state);

        (void) dr_dev_walk(hp, SBD_COMP_MEM, 0,
            dr_pre_detach_mem,
            dr_detach_mem,
            dr_post_detach_mem,
            dr_detach_update_state);

        return (0);
}

static void
dr_dev_cancel(dr_handle_t *hp)
{
        int             i;
        dr_devset_t     devset;
        dr_board_t      *bp = hp->h_bd;
        static fn_t     f = "dr_dev_cancel";

        PR_ALL("%s...\n", f);

        /*
         * Only devices which have been "released" are
         * subject to cancellation.
         */
        devset = hp->h_devset & DR_DEVS_RELEASED(bp);

        /*
         * Nothing to do for CPUs or IO other than change back
         * their state.
         */
        for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
                dr_cpu_unit_t   *cp;
                dr_state_t      nstate;

                if (!DEVSET_IN_SET(devset, SBD_COMP_CPU, i))
                        continue;

                cp = dr_get_cpu_unit(bp, i);
                if (dr_cancel_cpu(cp) == 0)
                        nstate = DR_STATE_CONFIGURED;
                else
                        nstate = DR_STATE_FATAL;

                dr_device_transition(&cp->sbc_cm, nstate);
        }

        for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
                dr_io_unit_t *ip;

                if (!DEVSET_IN_SET(devset, SBD_COMP_IO, i))
                        continue;
                ip = dr_get_io_unit(bp, i);
                dr_device_transition(&ip->sbi_cm, DR_STATE_CONFIGURED);
        }
        for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
                dr_mem_unit_t   *mp;
                dr_state_t      nstate;

                if (!DEVSET_IN_SET(devset, SBD_COMP_MEM, i))
                        continue;

                mp = dr_get_mem_unit(bp, i);
                if (dr_cancel_mem(mp) == 0)
                        nstate = DR_STATE_CONFIGURED;
                else
                        nstate = DR_STATE_FATAL;

                dr_device_transition(&mp->sbm_cm, nstate);
        }

        PR_ALL("%s: unreleasing devset (0x%x)\n", f, (uint_t)devset);

        DR_DEVS_CANCEL(bp, devset);

        if (DR_DEVS_RELEASED(bp) == 0) {
                dr_state_t      new_state;
                /*
                 * If the board no longer has any released devices
                 * than transfer it back to the CONFIG/PARTIAL state.
                 */
                if (DR_DEVS_ATTACHED(bp) == DR_DEVS_PRESENT(bp))
                        new_state = DR_STATE_CONFIGURED;
                else
                        new_state = DR_STATE_PARTIAL;
                if (bp->b_state != new_state) {
                        dr_board_transition(bp, new_state);
                }
                hp->h_bd->b_ostate = SBD_STAT_CONFIGURED;
                hp->h_bd->b_busy = 0;
                (void) drv_getparm(TIME, (void *)&hp->h_bd->b_time);
        }
}

static int
dr_dev_status(dr_handle_t *hp)
{
        int             nstat, mode, ncm, sz, pbsz, pnstat;
        dr_handle_t     *shp;
        dr_devset_t     devset = 0;
        sbd_stat_t      *dstatp = NULL;
        sbd_dev_stat_t  *devstatp;
        dr_board_t      *bp;
        drmach_status_t  pstat;
        int             rv = 0;

#ifdef _MULTI_DATAMODEL
        int sz32 = 0;
#endif /* _MULTI_DATAMODEL */

        static fn_t     f = "dr_dev_status";

        PR_ALL("%s...\n", f);

        mode = hp->h_mode;
        shp = hp;
        devset = shp->h_devset;
        bp = hp->h_bd;

        /*
         * Block out disconnect, unassign, IO unconfigure and
         * devinfo branch creation during status.
         */
        mutex_enter(&bp->b_slock);
        while (bp->b_sflags & DR_BSLOCK) {
                if (cv_wait_sig(&bp->b_scv, &bp->b_slock) == 0) {
                        mutex_exit(&bp->b_slock);
                        return (EINTR);
                }
        }
        bp->b_sflags |= DR_BSLOCK;
        mutex_exit(&bp->b_slock);

        ncm = 1;
        if (hp->h_sbdcmd.cmd_cm.c_id.c_type == SBD_COMP_NONE) {
                if (dr_cmd_flags(hp) & SBD_FLAG_ALLCMP) {
                /*
                 * Calculate the maximum number of components possible
                 * for a board.  This number will be used to size the
                 * status scratch buffer used by board and component
                 * status functions.
                 * This buffer may differ in size from what is provided
                 * by the plugin, since the known component set on the
                 * board may change between the plugin's GETNCM call, and
                 * the status call.  Sizing will be adjusted to the plugin's
                 * receptacle buffer at copyout time.
                 */
                        ncm = MAX_CPU_UNITS_PER_BOARD +
                            MAX_MEM_UNITS_PER_BOARD +
                            MAX_IO_UNITS_PER_BOARD;

                } else {
                        /*
                         * In the case of c_type == SBD_COMP_NONE, and
                         * SBD_FLAG_ALLCMP not specified, only the board
                         * info is to be returned, no components.
                         */
                        ncm = 0;
                        devset = 0;
                }
        }

        sz = sizeof (sbd_stat_t);
        if (ncm > 1)
                sz += sizeof (sbd_dev_stat_t) * (ncm - 1);


        pbsz = (int)hp->h_sbdcmd.cmd_stat.s_nbytes;
        pnstat = (pbsz - sizeof (sbd_stat_t)) / sizeof (sbd_dev_stat_t);

        /*
         * s_nbytes describes the size of the preallocated user
         * buffer into which the application is execting to
         * receive the sbd_stat_t and sbd_dev_stat_t structures.
         */

#ifdef _MULTI_DATAMODEL

        /*
         * More buffer space is required for the 64bit to 32bit
         * conversion of data structures.
         */
        if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
                sz32 = sizeof (sbd_stat32_t);
                if (ncm > 1)
                        sz32  += sizeof (sbd_dev_stat32_t) * (ncm - 1);
                pnstat = (pbsz - sizeof (sbd_stat32_t))/
                    sizeof (sbd_dev_stat32_t);
        }

        sz += sz32;
#endif
        /*
         * Since one sbd_dev_stat_t is included in the sbd_stat_t,
         * increment the plugin's nstat count.
         */
        ++pnstat;

        if (bp->b_id == 0) {
                bzero(&pstat, sizeof (pstat));
        } else {
                sbd_error_t *err;

                err = drmach_status(bp->b_id, &pstat);
                if (err) {
                        DRERR_SET_C(&hp->h_err, &err);
                        rv = EIO;
                        goto status_done;
                }
        }

        dstatp = (sbd_stat_t *)(void *)GETSTRUCT(char, sz);

        devstatp = &dstatp->s_stat[0];

        dstatp->s_board = bp->b_num;

        /*
         * Detect transitions between empty and disconnected.
         */
        if (!pstat.empty && (bp->b_rstate == SBD_STAT_EMPTY))
                bp->b_rstate = SBD_STAT_DISCONNECTED;
        else if (pstat.empty && (bp->b_rstate == SBD_STAT_DISCONNECTED))
                bp->b_rstate = SBD_STAT_EMPTY;

        dstatp->s_rstate = bp->b_rstate;
        dstatp->s_ostate = bp->b_ostate;
        dstatp->s_cond = bp->b_cond = pstat.cond;
        dstatp->s_busy = bp->b_busy | pstat.busy;
        dstatp->s_time = bp->b_time;
        dstatp->s_power = pstat.powered;
        dstatp->s_assigned = bp->b_assigned = pstat.assigned;
        dstatp->s_nstat = nstat = 0;
        bcopy(&pstat.type[0], &dstatp->s_type[0], SBD_TYPE_LEN);
        bcopy(&pstat.info[0], &dstatp->s_info[0], SBD_MAX_INFO);

        devset &= DR_DEVS_PRESENT(bp);
        if (devset == 0) {
                /*
                 * No device chosen.
                 */
                PR_ALL("%s: no device present\n", f);
        }

        if (DEVSET_IN_SET(devset, SBD_COMP_CPU, DEVSET_ANYUNIT))
                if ((nstat = dr_cpu_status(hp, devset, devstatp)) > 0) {
                        dstatp->s_nstat += nstat;
                        devstatp += nstat;
                }

        if (DEVSET_IN_SET(devset, SBD_COMP_MEM, DEVSET_ANYUNIT))
                if ((nstat = dr_mem_status(hp, devset, devstatp)) > 0) {
                        dstatp->s_nstat += nstat;
                        devstatp += nstat;
                }

        if (DEVSET_IN_SET(devset, SBD_COMP_IO, DEVSET_ANYUNIT))
                if ((nstat = dr_io_status(hp, devset, devstatp)) > 0) {
                        dstatp->s_nstat += nstat;
                        devstatp += nstat;
                }

        /*
         * Due to a possible change in number of components between
         * the time of plugin's GETNCM call and now, there may be
         * more or less components than the plugin's buffer can
         * hold.  Adjust s_nstat accordingly.
         */

        dstatp->s_nstat = dstatp->s_nstat > pnstat ? pnstat : dstatp->s_nstat;

#ifdef _MULTI_DATAMODEL
        if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
                int             i, j;
                sbd_stat32_t    *dstat32p;

                dstat32p = (sbd_stat32_t *)devstatp;

                /* Alignment Paranoia */
                if ((ulong_t)dstat32p & 0x1) {
                        PR_ALL("%s: alignment: sz=0x%lx dstat32p=0x%p\n",
                            f, sizeof (sbd_stat32_t), (void *)dstat32p);
                        DR_OP_INTERNAL_ERROR(hp);
                        rv = EINVAL;
                        goto status_done;
                }

                /* paranoia: detect buffer overrun */
                if ((caddr_t)&dstat32p->s_stat[dstatp->s_nstat] >
                    ((caddr_t)dstatp) + sz) {
                        DR_OP_INTERNAL_ERROR(hp);
                        rv = EINVAL;
                        goto status_done;
                }

                /* copy sbd_stat_t structure members */
#define _SBD_STAT(t, m) dstat32p->m = (t)dstatp->m
                _SBD_STAT(int32_t, s_board);
                _SBD_STAT(int32_t, s_rstate);
                _SBD_STAT(int32_t, s_ostate);
                _SBD_STAT(int32_t, s_cond);
                _SBD_STAT(int32_t, s_busy);
                _SBD_STAT(time32_t, s_time);
                _SBD_STAT(uint32_t, s_power);
                _SBD_STAT(uint32_t, s_assigned);
                _SBD_STAT(int32_t, s_nstat);
                bcopy(&dstatp->s_type[0], &dstat32p->s_type[0],
                    SBD_TYPE_LEN);
                bcopy(&dstatp->s_info[0], &dstat32p->s_info[0],
                    SBD_MAX_INFO);
#undef _SBD_STAT

                for (i = 0; i < dstatp->s_nstat; i++) {
                        sbd_dev_stat_t          *dsp = &dstatp->s_stat[i];
                        sbd_dev_stat32_t        *ds32p = &dstat32p->s_stat[i];
#define _SBD_DEV_STAT(t, m) ds32p->m = (t)dsp->m

                        /* copy sbd_cm_stat_t structure members */
                        _SBD_DEV_STAT(int32_t, ds_type);
                        _SBD_DEV_STAT(int32_t, ds_unit);
                        _SBD_DEV_STAT(int32_t, ds_ostate);
                        _SBD_DEV_STAT(int32_t, ds_cond);
                        _SBD_DEV_STAT(int32_t, ds_busy);
                        _SBD_DEV_STAT(int32_t, ds_suspend);
                        _SBD_DEV_STAT(time32_t, ds_time);
                        bcopy(&dsp->ds_name[0], &ds32p->ds_name[0],
                            OBP_MAXPROPNAME);

                        switch (dsp->ds_type) {
                        case SBD_COMP_CPU:
                                /* copy sbd_cpu_stat_t structure members */
                                _SBD_DEV_STAT(int32_t, d_cpu.cs_isbootproc);
                                _SBD_DEV_STAT(int32_t, d_cpu.cs_cpuid);
                                _SBD_DEV_STAT(int32_t, d_cpu.cs_speed);
                                _SBD_DEV_STAT(int32_t, d_cpu.cs_ecache);
                                break;

                        case SBD_COMP_MEM:
                                /* copy sbd_mem_stat_t structure members */
                                _SBD_DEV_STAT(int32_t, d_mem.ms_interleave);
                                _SBD_DEV_STAT(uint32_t, d_mem.ms_basepfn);
                                _SBD_DEV_STAT(uint32_t, d_mem.ms_totpages);
                                _SBD_DEV_STAT(uint32_t, d_mem.ms_detpages);
                                _SBD_DEV_STAT(int32_t, d_mem.ms_pageslost);
                                _SBD_DEV_STAT(uint32_t, d_mem.ms_managed_pages);
                                _SBD_DEV_STAT(uint32_t, d_mem.ms_noreloc_pages);
                                _SBD_DEV_STAT(uint32_t, d_mem.ms_noreloc_first);
                                _SBD_DEV_STAT(uint32_t, d_mem.ms_noreloc_last);
                                _SBD_DEV_STAT(int32_t, d_mem.ms_cage_enabled);
                                _SBD_DEV_STAT(int32_t, d_mem.ms_peer_is_target);
                                bcopy(&dsp->d_mem.ms_peer_ap_id[0],
                                    &ds32p->d_mem.ms_peer_ap_id[0],
                                    sizeof (ds32p->d_mem.ms_peer_ap_id));
                                break;

                        case SBD_COMP_IO:
                                /* copy sbd_io_stat_t structure members */
                                _SBD_DEV_STAT(int32_t, d_io.is_referenced);
                                _SBD_DEV_STAT(int32_t, d_io.is_unsafe_count);

                                for (j = 0; j < SBD_MAX_UNSAFE; j++)
                                        _SBD_DEV_STAT(int32_t,
                                            d_io.is_unsafe_list[j]);

                                bcopy(&dsp->d_io.is_pathname[0],
                                    &ds32p->d_io.is_pathname[0], MAXPATHLEN);
                                break;

                        case SBD_COMP_CMP:
                                /* copy sbd_cmp_stat_t structure members */
                                bcopy(&dsp->d_cmp.ps_cpuid[0],
                                    &ds32p->d_cmp.ps_cpuid[0],
                                    sizeof (ds32p->d_cmp.ps_cpuid));
                                _SBD_DEV_STAT(int32_t, d_cmp.ps_ncores);
                                _SBD_DEV_STAT(int32_t, d_cmp.ps_speed);
                                _SBD_DEV_STAT(int32_t, d_cmp.ps_ecache);
                                break;

                        default:
                                cmn_err(CE_WARN, "%s: unknown dev type (%d)",
                                    f, (int)dsp->ds_type);
                                rv = EFAULT;
                                goto status_done;
                        }
#undef _SBD_DEV_STAT
                }


                if (ddi_copyout((void *)dstat32p,
                    hp->h_sbdcmd.cmd_stat.s_statp, pbsz, mode) != 0) {
                        cmn_err(CE_WARN,
                            "%s: failed to copyout status "
                            "for board %d", f, bp->b_num);
                        rv = EFAULT;
                        goto status_done;
                }
        } else
#endif /* _MULTI_DATAMODEL */

        if (ddi_copyout((void *)dstatp, hp->h_sbdcmd.cmd_stat.s_statp,
            pbsz, mode) != 0) {
                cmn_err(CE_WARN,
                    "%s: failed to copyout status for board %d",
                    f, bp->b_num);
                rv = EFAULT;
                goto status_done;
        }

status_done:
        if (dstatp != NULL)
                FREESTRUCT(dstatp, char, sz);

        dr_unlock_status(bp);

        return (rv);
}

static int
dr_get_ncm(dr_handle_t *hp)
{
        int             i;
        int             ncm = 0;
        dr_devset_t     devset;

        devset = DR_DEVS_PRESENT(hp->h_bd);
        if (hp->h_sbdcmd.cmd_cm.c_id.c_type != SBD_COMP_NONE)
                devset &= DEVSET(hp->h_sbdcmd.cmd_cm.c_id.c_type,
                    DEVSET_ANYUNIT);

        /*
         * Handle CPUs first to deal with possible CMP
         * devices. If the CPU is a CMP, we need to only
         * increment ncm once even if there are multiple
         * cores for that CMP present in the devset.
         */
        for (i = 0; i < MAX_CMP_UNITS_PER_BOARD; i++) {
                if (devset & DEVSET(SBD_COMP_CMP, i)) {
                        ncm++;
                }
        }

        /* eliminate the CPU information from the devset */
        devset &= ~(DEVSET(SBD_COMP_CMP, DEVSET_ANYUNIT));

        for (i = 0; i < (sizeof (dr_devset_t) * 8); i++) {
                ncm += devset & 0x1;
                devset >>= 1;
        }

        return (ncm);
}

/* used by dr_mem.c */
/* TODO: eliminate dr_boardlist */
dr_board_t *
dr_lookup_board(int board_num)
{
        dr_board_t *bp;

        ASSERT(board_num >= 0 && board_num < MAX_BOARDS);

        bp = &dr_boardlist[board_num];
        ASSERT(bp->b_num == board_num);

        return (bp);
}

static dr_dev_unit_t *
dr_get_dev_unit(dr_board_t *bp, sbd_comp_type_t nt, int unit_num)
{
        dr_dev_unit_t   *dp;

        dp = DR_GET_BOARD_DEVUNIT(bp, nt, unit_num);
        ASSERT(dp->du_common.sbdev_bp == bp);
        ASSERT(dp->du_common.sbdev_unum == unit_num);
        ASSERT(dp->du_common.sbdev_type == nt);

        return (dp);
}

dr_cpu_unit_t *
dr_get_cpu_unit(dr_board_t *bp, int unit_num)
{
        dr_dev_unit_t   *dp;

        ASSERT(unit_num >= 0 && unit_num < MAX_CPU_UNITS_PER_BOARD);

        dp = dr_get_dev_unit(bp, SBD_COMP_CPU, unit_num);
        return (&dp->du_cpu);
}

dr_mem_unit_t *
dr_get_mem_unit(dr_board_t *bp, int unit_num)
{
        dr_dev_unit_t   *dp;

        ASSERT(unit_num >= 0 && unit_num < MAX_MEM_UNITS_PER_BOARD);

        dp = dr_get_dev_unit(bp, SBD_COMP_MEM, unit_num);
        return (&dp->du_mem);
}

dr_io_unit_t *
dr_get_io_unit(dr_board_t *bp, int unit_num)
{
        dr_dev_unit_t   *dp;

        ASSERT(unit_num >= 0 && unit_num < MAX_IO_UNITS_PER_BOARD);

        dp = dr_get_dev_unit(bp, SBD_COMP_IO, unit_num);
        return (&dp->du_io);
}

dr_common_unit_t *
dr_get_common_unit(dr_board_t *bp, sbd_comp_type_t nt, int unum)
{
        dr_dev_unit_t   *dp;

        dp = dr_get_dev_unit(bp, nt, unum);
        return (&dp->du_common);
}

static dr_devset_t
dr_dev2devset(sbd_comp_id_t *cid)
{
        static fn_t     f = "dr_dev2devset";

        dr_devset_t     devset;
        int             unit = cid->c_unit;

        switch (cid->c_type) {
                case SBD_COMP_NONE:
                        devset =  DEVSET(SBD_COMP_CPU, DEVSET_ANYUNIT);
                        devset |= DEVSET(SBD_COMP_MEM, DEVSET_ANYUNIT);
                        devset |= DEVSET(SBD_COMP_IO,  DEVSET_ANYUNIT);
                        PR_ALL("%s: COMP_NONE devset = " DEVSET_FMT_STR "\n",
                            f, DEVSET_FMT_ARG(devset));
                        break;

                case SBD_COMP_CPU:
                        if ((unit > MAX_CPU_UNITS_PER_BOARD) || (unit < 0)) {
                                cmn_err(CE_WARN,
                                    "%s: invalid cpu unit# = %d",
                                    f, unit);
                                devset = 0;
                        } else {
                                /*
                                 * Generate a devset that includes all the
                                 * cores of a CMP device. If this is not a
                                 * CMP, the extra cores will be eliminated
                                 * later since they are not present. This is
                                 * also true for CMP devices that do not have
                                 * all cores active.
                                 */
                                devset = DEVSET(SBD_COMP_CMP, unit);
                        }

                        PR_ALL("%s: CPU devset = " DEVSET_FMT_STR "\n",
                            f, DEVSET_FMT_ARG(devset));
                        break;

                case SBD_COMP_MEM:
                        if (unit == SBD_NULL_UNIT) {
                                unit = 0;
                                cid->c_unit = 0;
                        }

                        if ((unit > MAX_MEM_UNITS_PER_BOARD) || (unit < 0)) {
                                cmn_err(CE_WARN,
                                    "%s: invalid mem unit# = %d",
                                    f, unit);
                                devset = 0;
                        } else
                                devset = DEVSET(cid->c_type, unit);

                        PR_ALL("%s: MEM devset = " DEVSET_FMT_STR "\n",
                            f, DEVSET_FMT_ARG(devset));
                        break;

                case SBD_COMP_IO:
                        if ((unit > MAX_IO_UNITS_PER_BOARD) || (unit < 0)) {
                                cmn_err(CE_WARN,
                                    "%s: invalid io unit# = %d",
                                    f, unit);
                                devset = 0;
                        } else
                                devset = DEVSET(cid->c_type, unit);

                        PR_ALL("%s: IO devset = " DEVSET_FMT_STR "\n",
                            f, DEVSET_FMT_ARG(devset));
                        break;

                default:
                case SBD_COMP_UNKNOWN:
                        devset = 0;
                        break;
        }

        return (devset);
}

/*
 * Converts a dynamic attachment point name to a SBD_COMP_* type.
 * Returns SDB_COMP_UNKNOWN if name is not recognized.
 */
static int
dr_dev_type_to_nt(char *type)
{
        int i;

        for (i = 0; dr_devattr[i].s_nodetype != SBD_COMP_UNKNOWN; i++)
                if (strcmp(dr_devattr[i].s_devtype, type) == 0)
                        break;

        return (dr_devattr[i].s_nodetype);
}

/*
 * Converts a SBD_COMP_* type to a dynamic attachment point name.
 * Return NULL if SBD_COMP_ type is not recognized.
 */
char *
dr_nt_to_dev_type(int nt)
{
        int i;

        for (i = 0; dr_devattr[i].s_nodetype != SBD_COMP_UNKNOWN; i++)
                if (dr_devattr[i].s_nodetype == nt)
                        break;

        return (dr_devattr[i].s_devtype);
}

/*
 * State transition policy is that if there is some component for which
 * the state transition is valid, then let it through. The exception is
 * SBD_CMD_DISCONNECT. On disconnect, the state transition must be valid
 * for ALL components.
 * Returns the state that is in error, if any.
 */
static int
dr_check_transition(dr_board_t *bp, dr_devset_t *devsetp,
    struct dr_state_trans *transp, int cmd)
{
        int                     s, ut;
        int                     state_err = 0;
        dr_devset_t             devset;
        dr_common_unit_t        *cp;
        static fn_t             f = "dr_check_transition";

        devset = *devsetp;

        if (DEVSET_IN_SET(devset, SBD_COMP_CPU, DEVSET_ANYUNIT)) {
                for (ut = 0; ut < MAX_CPU_UNITS_PER_BOARD; ut++) {
                        if (DEVSET_IN_SET(devset, SBD_COMP_CPU, ut) == 0)
                                continue;

                        cp = dr_get_common_unit(bp, SBD_COMP_CPU, ut);
                        s = (int)cp->sbdev_state;
                        if (!DR_DEV_IS_PRESENT(cp)) {
                                DEVSET_DEL(devset, SBD_COMP_CPU, ut);
                        } else {
                                if (transp->x_op[s].x_rv) {
                                        if (!state_err)
                                                state_err = s;
                                        DEVSET_DEL(devset, SBD_COMP_CPU, ut);
                                }
                        }
                }
        }
        if (DEVSET_IN_SET(devset, SBD_COMP_MEM, DEVSET_ANYUNIT)) {
                for (ut = 0; ut < MAX_MEM_UNITS_PER_BOARD; ut++) {
                        if (DEVSET_IN_SET(devset, SBD_COMP_MEM, ut) == 0)
                                continue;

                        cp = dr_get_common_unit(bp, SBD_COMP_MEM, ut);
                        s = (int)cp->sbdev_state;
                        if (!DR_DEV_IS_PRESENT(cp)) {
                                DEVSET_DEL(devset, SBD_COMP_MEM, ut);
                        } else {
                                if (transp->x_op[s].x_rv) {
                                        if (!state_err)
                                                state_err = s;
                                        DEVSET_DEL(devset, SBD_COMP_MEM, ut);
                                }
                        }
                }
        }
        if (DEVSET_IN_SET(devset, SBD_COMP_IO, DEVSET_ANYUNIT)) {
                for (ut = 0; ut < MAX_IO_UNITS_PER_BOARD; ut++) {
                        if (DEVSET_IN_SET(devset, SBD_COMP_IO, ut) == 0)
                                continue;

                        cp = dr_get_common_unit(bp, SBD_COMP_IO, ut);
                        s = (int)cp->sbdev_state;
                        if (!DR_DEV_IS_PRESENT(cp)) {
                                DEVSET_DEL(devset, SBD_COMP_IO, ut);
                        } else {
                                if (transp->x_op[s].x_rv) {
                                        if (!state_err)
                                                state_err = s;
                                        DEVSET_DEL(devset, SBD_COMP_IO, ut);
                                }
                        }
                }
        }

        PR_ALL("%s: requested devset = 0x%x, final devset = 0x%x\n",
            f, (uint_t)*devsetp, (uint_t)devset);

        *devsetp = devset;
        /*
         * If there are some remaining components for which
         * this state transition is valid, then allow them
         * through, otherwise if none are left then return
         * the state error. The exception is SBD_CMD_DISCONNECT.
         * On disconnect, the state transition must be valid for ALL
         * components.
         */
        if (cmd == SBD_CMD_DISCONNECT)
                return (state_err);
        return (devset ? 0 : state_err);
}

void
dr_device_transition(dr_common_unit_t *cp, dr_state_t st)
{
        PR_STATE("%s STATE %s(%d) -> %s(%d)\n",
            cp->sbdev_path,
            state_str[cp->sbdev_state], cp->sbdev_state,
            state_str[st], st);

        cp->sbdev_state = st;
        if (st == DR_STATE_CONFIGURED) {
                cp->sbdev_ostate = SBD_STAT_CONFIGURED;
                if (cp->sbdev_bp->b_ostate != SBD_STAT_CONFIGURED) {
                        cp->sbdev_bp->b_ostate = SBD_STAT_CONFIGURED;
                        (void) drv_getparm(TIME,
                            (void *) &cp->sbdev_bp->b_time);
                }
        } else
                cp->sbdev_ostate = SBD_STAT_UNCONFIGURED;

        (void) drv_getparm(TIME, (void *) &cp->sbdev_time);
}

static void
dr_board_transition(dr_board_t *bp, dr_state_t st)
{
        PR_STATE("BOARD %d STATE: %s(%d) -> %s(%d)\n",
            bp->b_num,
            state_str[bp->b_state], bp->b_state,
            state_str[st], st);

        bp->b_state = st;
}

void
dr_op_err(int ce, dr_handle_t *hp, int code, char *fmt, ...)
{
        sbd_error_t     *err;
        va_list         args;

        va_start(args, fmt);
        err = drerr_new_v(code, fmt, args);
        va_end(args);

        if (ce != CE_IGNORE)
                sbd_err_log(err, ce);

        DRERR_SET_C(&hp->h_err, &err);
}

void
dr_dev_err(int ce, dr_common_unit_t *cp, int code)
{
        sbd_error_t     *err;

        err = drerr_new(0, code, cp->sbdev_path, NULL);

        if (ce != CE_IGNORE)
                sbd_err_log(err, ce);

        DRERR_SET_C(&cp->sbdev_error, &err);
}

/*
 * A callback routine.  Called from the drmach layer as a result of
 * call to drmach_board_find_devices from dr_init_devlists.
 */
static sbd_error_t *
dr_dev_found(void *data, const char *name, int unum, drmachid_t id)
{
        dr_board_t      *bp = data;
        dr_dev_unit_t   *dp;
        int              nt;
        static fn_t     f = "dr_dev_found";

        PR_ALL("%s (board = %d, name = %s, unum = %d, id = %p)...\n",
            f, bp->b_num, name, unum, id);

        nt = dr_dev_type_to_nt((char *)name);
        if (nt == SBD_COMP_UNKNOWN) {
                /*
                 * this should not happen.  When it does, it indicates
                 * a missmatch in devices supported by the drmach layer
                 * vs devices supported by this layer.
                 */
                return (DR_INTERNAL_ERROR());
        }

        dp = DR_GET_BOARD_DEVUNIT(bp, nt, unum);

        /* sanity check */
        ASSERT(dp->du_common.sbdev_bp == bp);
        ASSERT(dp->du_common.sbdev_unum == unum);
        ASSERT(dp->du_common.sbdev_type == nt);

        /* render dynamic attachment point path of this unit */
        (void) snprintf(dp->du_common.sbdev_path,
            sizeof (dp->du_common.sbdev_path), "%s::%s%d",
            bp->b_path, name, DR_UNUM2SBD_UNUM(unum, nt));

        dp->du_common.sbdev_id = id;
        DR_DEV_SET_PRESENT(&dp->du_common);

        bp->b_ndev++;

        return (NULL);
}

static sbd_error_t *
dr_init_devlists(dr_board_t *bp)
{
        int             i;
        sbd_error_t     *err;
        dr_dev_unit_t   *dp;
        static fn_t     f = "dr_init_devlists";

        PR_ALL("%s (%s)...\n", f, bp->b_path);

        /* sanity check */
        ASSERT(bp->b_ndev == 0);

        DR_DEVS_DISCONNECT(bp, (uint_t)-1);

        /*
         * This routine builds the board's devlist and initializes
         * the common portion of the unit data structures.
         * Note: because the common portion is considered
         * uninitialized, the dr_get_*_unit() routines can not
         * be used.
         */

        /*
         * Clear out old entries, if any.
         */
        for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
                dp = DR_GET_BOARD_DEVUNIT(bp, SBD_COMP_CPU, i);

                bzero(dp, sizeof (*dp));
                dp->du_common.sbdev_bp = bp;
                dp->du_common.sbdev_unum = i;
                dp->du_common.sbdev_type = SBD_COMP_CPU;
        }

        for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
                dp = DR_GET_BOARD_DEVUNIT(bp, SBD_COMP_MEM, i);

                bzero(dp, sizeof (*dp));
                dp->du_common.sbdev_bp = bp;
                dp->du_common.sbdev_unum = i;
                dp->du_common.sbdev_type = SBD_COMP_MEM;
        }

        for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
                dp = DR_GET_BOARD_DEVUNIT(bp, SBD_COMP_IO, i);

                bzero(dp, sizeof (*dp));
                dp->du_common.sbdev_bp = bp;
                dp->du_common.sbdev_unum = i;
                dp->du_common.sbdev_type = SBD_COMP_IO;
        }

        err = NULL;
        if (bp->b_id) {
                /* find devices on this board */
                err = drmach_board_find_devices(
                    bp->b_id, bp, dr_dev_found);
        }

        return (err);
}

/*
 * Return the unit number of the respective drmachid if
 * it's found to be attached.
 */
static int
dr_check_unit_attached(dr_common_unit_t *cp)
{
        int             rv = 0;
        processorid_t   cpuid;
        uint64_t        basepa, endpa;
        struct memlist  *ml;
        extern struct memlist   *phys_install;
        sbd_error_t     *err;
        int             yes;
        static fn_t     f = "dr_check_unit_attached";

        switch (cp->sbdev_type) {
        case SBD_COMP_CPU:
                err = drmach_cpu_get_id(cp->sbdev_id, &cpuid);
                if (err) {
                        DRERR_SET_C(&cp->sbdev_error, &err);
                        rv = -1;
                        break;
                }
                mutex_enter(&cpu_lock);
                if (cpu_get(cpuid) == NULL)
                        rv = -1;
                mutex_exit(&cpu_lock);
                break;

        case SBD_COMP_MEM:
                err = drmach_mem_get_slice_info(cp->sbdev_id,
                    &basepa, &endpa, NULL);
                if (err) {
                        DRERR_SET_C(&cp->sbdev_error, &err);
                        rv = -1;
                        break;
                }

                /*
                 * Check if base address is in phys_install.
                 */
                memlist_read_lock();
                for (ml = phys_install; ml; ml = ml->ml_next)
                        if ((endpa <= ml->ml_address) ||
                            (basepa >= (ml->ml_address + ml->ml_size)))
                                continue;
                        else
                                break;
                memlist_read_unlock();
                if (ml == NULL)
                        rv = -1;
                break;

        case SBD_COMP_IO:
                err = drmach_io_is_attached(cp->sbdev_id, &yes);
                if (err) {
                        DRERR_SET_C(&cp->sbdev_error, &err);
                        rv = -1;
                        break;
                } else if (!yes)
                        rv = -1;
                break;

        default:
                PR_ALL("%s: unexpected nodetype(%d) for id 0x%p\n",
                    f, cp->sbdev_type, cp->sbdev_id);
                rv = -1;
                break;
        }

        return (rv);
}

/*
 * See if drmach recognizes the passthru command.  DRMACH expects the
 * id to identify the thing to which the command is being applied.  Using
 * nonsense SBD terms, that information has been perversely encoded in the
 * c_id member of the sbd_cmd_t structure.  This logic reads those tea
 * leaves, finds the associated drmach id, then calls drmach to process
 * the passthru command.
 */
static int
dr_pt_try_drmach(dr_handle_t *hp)
{
        dr_board_t      *bp = hp->h_bd;
        sbd_comp_id_t   *comp_id = &hp->h_sbdcmd.cmd_cm.c_id;
        drmachid_t       id;

        if (comp_id->c_type == SBD_COMP_NONE) {
                id = bp->b_id;
        } else {
                sbd_comp_type_t  nt;

                nt = dr_dev_type_to_nt(comp_id->c_name);
                if (nt == SBD_COMP_UNKNOWN) {
                        dr_op_err(CE_IGNORE, hp, ESBD_INVAL, comp_id->c_name);
                        id = 0;
                } else {
                        /* pt command applied to dynamic attachment point */
                        dr_common_unit_t *cp;
                        cp = dr_get_common_unit(bp, nt, comp_id->c_unit);
                        id = cp->sbdev_id;
                }
        }

        if (hp->h_err == NULL)
                hp->h_err = drmach_passthru(id, &hp->h_opts);

        return (hp->h_err == NULL ? 0 : -1);
}

static int
dr_pt_ioctl(dr_handle_t *hp)
{
        int             cmd, rv, len;
        int32_t         sz;
        int             found;
        char            *copts;
        static fn_t     f = "dr_pt_ioctl";

        PR_ALL("%s...\n", f);

        sz = hp->h_opts.size;
        copts = hp->h_opts.copts;

        if (sz == 0 || copts == (char *)NULL) {
                cmn_err(CE_WARN, "%s: invalid passthru args", f);
                return (EINVAL);
        }

        found = 0;
        for (cmd = 0; cmd < (sizeof (pt_arr) / sizeof (pt_arr[0])); cmd++) {
                len = strlen(pt_arr[cmd].pt_name);
                found = (strncmp(pt_arr[cmd].pt_name, copts, len) == 0);
                if (found)
                        break;
        }

        if (found)
                rv = (*pt_arr[cmd].pt_func)(hp);
        else
                rv = dr_pt_try_drmach(hp);

        return (rv);
}

/*
 * Called at driver load time to determine the state and condition
 * of an existing board in the system.
 */
static void
dr_board_discovery(dr_board_t *bp)
{
        int                     i;
        dr_devset_t             devs_lost, devs_attached = 0;
        dr_cpu_unit_t           *cp;
        dr_mem_unit_t           *mp;
        dr_io_unit_t            *ip;
        static fn_t             f = "dr_board_discovery";

        if (DR_DEVS_PRESENT(bp) == 0) {
                PR_ALL("%s: board %d has no devices present\n",
                    f, bp->b_num);
                return;
        }

        /*
         * Check for existence of cpus.
         */
        for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
                cp = dr_get_cpu_unit(bp, i);

                if (!DR_DEV_IS_PRESENT(&cp->sbc_cm))
                        continue;

                if (dr_check_unit_attached(&cp->sbc_cm) >= 0) {
                        DR_DEV_SET_ATTACHED(&cp->sbc_cm);
                        DEVSET_ADD(devs_attached, SBD_COMP_CPU, i);
                        PR_ALL("%s: board %d, cpu-unit %d - attached\n",
                            f, bp->b_num, i);
                }
                dr_init_cpu_unit(cp);
        }

        /*
         * Check for existence of memory.
         */
        for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
                mp = dr_get_mem_unit(bp, i);

                if (!DR_DEV_IS_PRESENT(&mp->sbm_cm))
                        continue;

                if (dr_check_unit_attached(&mp->sbm_cm) >= 0) {
                        DR_DEV_SET_ATTACHED(&mp->sbm_cm);
                        DEVSET_ADD(devs_attached, SBD_COMP_MEM, i);
                        PR_ALL("%s: board %d, mem-unit %d - attached\n",
                            f, bp->b_num, i);
                }
                dr_init_mem_unit(mp);
        }

        /*
         * Check for i/o state.
         */
        for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
                ip = dr_get_io_unit(bp, i);

                if (!DR_DEV_IS_PRESENT(&ip->sbi_cm))
                        continue;

                if (dr_check_unit_attached(&ip->sbi_cm) >= 0) {
                        /*
                         * Found it!
                         */
                        DR_DEV_SET_ATTACHED(&ip->sbi_cm);
                        DEVSET_ADD(devs_attached, SBD_COMP_IO, i);
                        PR_ALL("%s: board %d, io-unit %d - attached\n",
                            f, bp->b_num, i);
                }
                dr_init_io_unit(ip);
        }

        DR_DEVS_CONFIGURE(bp, devs_attached);
        if (devs_attached && ((devs_lost = DR_DEVS_UNATTACHED(bp)) != 0)) {
                int             ut;

                /*
                 * It is not legal on board discovery to have a
                 * board that is only partially attached.  A board
                 * is either all attached or all connected.  If a
                 * board has at least one attached device, then
                 * the the remaining devices, if any, must have
                 * been lost or disconnected.  These devices can
                 * only be recovered by a full attach from scratch.
                 * Note that devices previously in the unreferenced
                 * state are subsequently lost until the next full
                 * attach.  This is necessary since the driver unload
                 * that must have occurred would have wiped out the
                 * information necessary to re-configure the device
                 * back online, e.g. memlist.
                 */
                PR_ALL("%s: some devices LOST (" DEVSET_FMT_STR ")...\n",
                    f, DEVSET_FMT_ARG(devs_lost));

                for (ut = 0; ut < MAX_CPU_UNITS_PER_BOARD; ut++) {
                        if (!DEVSET_IN_SET(devs_lost, SBD_COMP_CPU, ut))
                                continue;

                        cp = dr_get_cpu_unit(bp, ut);
                        dr_device_transition(&cp->sbc_cm, DR_STATE_EMPTY);
                }

                for (ut = 0; ut < MAX_MEM_UNITS_PER_BOARD; ut++) {
                        if (!DEVSET_IN_SET(devs_lost, SBD_COMP_MEM, ut))
                                continue;

                        mp = dr_get_mem_unit(bp, ut);
                        dr_device_transition(&mp->sbm_cm, DR_STATE_EMPTY);
                }

                for (ut = 0; ut < MAX_IO_UNITS_PER_BOARD; ut++) {
                        if (!DEVSET_IN_SET(devs_lost, SBD_COMP_IO, ut))
                                continue;

                        ip = dr_get_io_unit(bp, ut);
                        dr_device_transition(&ip->sbi_cm, DR_STATE_EMPTY);
                }

                DR_DEVS_DISCONNECT(bp, devs_lost);
        }
}

static int
dr_board_init(dr_board_t *bp, dev_info_t *dip, int bd)
{
        sbd_error_t     *err;

        mutex_init(&bp->b_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&bp->b_slock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&bp->b_scv, NULL, CV_DRIVER, NULL);
        bp->b_rstate = SBD_STAT_EMPTY;
        bp->b_ostate = SBD_STAT_UNCONFIGURED;
        bp->b_cond = SBD_COND_UNKNOWN;
        (void) drv_getparm(TIME, (void *)&bp->b_time);

        (void) drmach_board_lookup(bd, &bp->b_id);
        bp->b_num = bd;
        bp->b_dip = dip;

        bp->b_dev[DEVSET_NIX(SBD_COMP_CPU)] = GETSTRUCT(dr_dev_unit_t,
            MAX_CPU_UNITS_PER_BOARD);

        bp->b_dev[DEVSET_NIX(SBD_COMP_MEM)] = GETSTRUCT(dr_dev_unit_t,
            MAX_MEM_UNITS_PER_BOARD);

        bp->b_dev[DEVSET_NIX(SBD_COMP_IO)] = GETSTRUCT(dr_dev_unit_t,
            MAX_IO_UNITS_PER_BOARD);

        /*
         * Initialize the devlists
         */
        err = dr_init_devlists(bp);
        if (err) {
                sbd_err_clear(&err);
                dr_board_destroy(bp);
                return (-1);
        } else if (bp->b_ndev == 0) {
                dr_board_transition(bp, DR_STATE_EMPTY);
        } else {
                /*
                 * Couldn't have made it down here without
                 * having found at least one device.
                 */
                ASSERT(DR_DEVS_PRESENT(bp) != 0);
                /*
                 * Check the state of any possible devices on the
                 * board.
                 */
                dr_board_discovery(bp);

                bp->b_assigned = 1;

                if (DR_DEVS_UNATTACHED(bp) == 0) {
                        /*
                         * The board has no unattached devices, therefore
                         * by reason of insanity it must be configured!
                         */
                        dr_board_transition(bp, DR_STATE_CONFIGURED);
                        bp->b_ostate = SBD_STAT_CONFIGURED;
                        bp->b_rstate = SBD_STAT_CONNECTED;
                        bp->b_cond = SBD_COND_OK;
                        (void) drv_getparm(TIME, (void *)&bp->b_time);
                } else if (DR_DEVS_ATTACHED(bp)) {
                        dr_board_transition(bp, DR_STATE_PARTIAL);
                        bp->b_ostate = SBD_STAT_CONFIGURED;
                        bp->b_rstate = SBD_STAT_CONNECTED;
                        bp->b_cond = SBD_COND_OK;
                        (void) drv_getparm(TIME, (void *)&bp->b_time);
                } else {
                        dr_board_transition(bp, DR_STATE_CONNECTED);
                        bp->b_rstate = SBD_STAT_CONNECTED;
                        (void) drv_getparm(TIME, (void *)&bp->b_time);
                }
        }

        return (0);
}

static void
dr_board_destroy(dr_board_t *bp)
{
        PR_ALL("dr_board_destroy: num %d, path %s\n",
            bp->b_num, bp->b_path);

        dr_board_transition(bp, DR_STATE_EMPTY);
        bp->b_rstate = SBD_STAT_EMPTY;
        (void) drv_getparm(TIME, (void *)&bp->b_time);

        /*
         * Free up MEM unit structs.
         */
        FREESTRUCT(bp->b_dev[DEVSET_NIX(SBD_COMP_MEM)],
            dr_dev_unit_t, MAX_MEM_UNITS_PER_BOARD);
        bp->b_dev[DEVSET_NIX(SBD_COMP_MEM)] = NULL;
        /*
         * Free up CPU unit structs.
         */
        FREESTRUCT(bp->b_dev[DEVSET_NIX(SBD_COMP_CPU)],
            dr_dev_unit_t, MAX_CPU_UNITS_PER_BOARD);
        bp->b_dev[DEVSET_NIX(SBD_COMP_CPU)] = NULL;
        /*
         * Free up IO unit structs.
         */
        FREESTRUCT(bp->b_dev[DEVSET_NIX(SBD_COMP_IO)],
            dr_dev_unit_t, MAX_IO_UNITS_PER_BOARD);
        bp->b_dev[DEVSET_NIX(SBD_COMP_IO)] = NULL;

        mutex_destroy(&bp->b_lock);
        mutex_destroy(&bp->b_slock);
        cv_destroy(&bp->b_scv);

        /*
         * Reset the board structure to its initial state, otherwise it will
         * cause trouble on the next call to dr_board_init() for the same board.
         * dr_board_init() may be called multiple times for the same board
         * if DR driver fails to initialize some boards.
         */
        bzero(bp, sizeof (*bp));
}

void
dr_lock_status(dr_board_t *bp)
{
        mutex_enter(&bp->b_slock);
        while (bp->b_sflags & DR_BSLOCK)
                cv_wait(&bp->b_scv, &bp->b_slock);
        bp->b_sflags |= DR_BSLOCK;
        mutex_exit(&bp->b_slock);
}

void
dr_unlock_status(dr_board_t *bp)
{
        mutex_enter(&bp->b_slock);
        bp->b_sflags &= ~DR_BSLOCK;
        cv_signal(&bp->b_scv);
        mutex_exit(&bp->b_slock);
}

/*
 * Extract flags passed via ioctl.
 */
int
dr_cmd_flags(dr_handle_t *hp)
{
        return (hp->h_sbdcmd.cmd_cm.c_flags);
}