/*
* 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.
*/
/*
* safari system board DR module.
*/
#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/ndi_impldefs.h>
#include <sys/stat.h>
#include <sys/kmem.h>
#include <sys/cpuvar.h>
#include <sys/mem_config.h>
#include <sys/mem_cage.h>
#include <sys/autoconf.h>
#include <sys/cmn_err.h>
#include <sys/ddi_impldefs.h>
#include <sys/machsystm.h>
#include <sys/param.h>
#include <sys/sbdpriv.h>
#include <sys/sbd_io.h>
/* start sbd includes */
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/x_call.h>
#include <sys/membar.h>
#include <vm/seg_kmem.h>
extern int nulldev();
extern int nodev();
typedef struct { /* arg to sbd_get_handle */
dev_t dev;
int cmd;
int mode;
sbd_ioctl_arg_t *ioargp;
} sbd_init_arg_t;
/*
* sbd support operations.
*/
static void sbd_exec_op(sbd_handle_t *hp);
static void sbd_dev_configure(sbd_handle_t *hp);
static int sbd_dev_release(sbd_handle_t *hp);
static int sbd_dev_unconfigure(sbd_handle_t *hp);
static void sbd_attach_cpu(sbd_handle_t *hp, sbderror_t *ep,
dev_info_t *dip, int unit);
static void sbd_detach_cpu(sbd_handle_t *hp, sbderror_t *ep,
dev_info_t *dip, int unit);
static int sbd_detach_mem(sbd_handle_t *hp, sbderror_t *ep, int unit);
static void sbd_cancel(sbd_handle_t *hp);
void sbd_errno_decode(int err, sbderror_t *ep, dev_info_t *dip);
int sbd_dealloc_instance(sbd_board_t *sbp, int max_boards);
int sbd_errno2ecode(int error);
#pragma weak sbdp_cpu_get_impl
#ifdef DEBUG
uint_t sbd_debug = (uint_t)0x0;
#ifdef SBD_DEBUG_ERRS
/* controls which errors are injected */
uint_t sbd_err_debug = (uint_t)0x0;
/* controls printing about error injection */
uint_t sbd_print_errs = (uint_t)0x0;
#endif /* SBD_DEBUG_ERRS */
#endif /* DEBUG */
char *sbd_state_str[] = {
"EMPTY", "OCCUPIED", "CONNECTED", "UNCONFIGURED",
"PARTIAL", "CONFIGURED", "RELEASE", "UNREFERENCED",
"FATAL"
};
/* Note: this must be changed in tandem with sbd_ioctl.h */
char *sbd_ct_str[] = {
"NONE", "CPU", "MEM", "IO", "UNKNOWN"
};
/* Note: this must also be changed in tandem with sbd_ioctl.h */
#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_CONFIGURE) ? "CONFIGURE" : \
((c) == SBD_CMD_UNCONFIGURE) ? "UNCONFIGURE" : \
((c) == SBD_CMD_DISCONNECT) ? "DISCONNECT" : \
((c) == SBD_CMD_STATUS) ? "STATUS" : \
((c) == SBD_CMD_GETNCM) ? "GETNCM" : \
((c) == SBD_CMD_PASSTHRU) ? "PASSTHRU" : "unknown")
/*
* Defines and structures for device tree naming and mapping
* to node types
*/
sbd_devattr_t *sbd_devattr;
/* defines to access the attribute struct */
#define SBD_DEVNAME(i) sbd_devattr[i].s_devname
#define SBD_OTYPE(i) sbd_devattr[(i)].s_obp_type
#define SBD_COMP(i) sbd_devattr[i].s_dnodetype
/*
* 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 sbd_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_POWEROFF: return (4);
case SBD_CMD_POWERON: return (5);
case SBD_CMD_UNASSIGN: return (6);
case SBD_CMD_ASSIGN: return (7);
case SBD_CMD_TEST: return (8);
default: return (-1);
}
}
#define CMD2INDEX(c) _cmd2index(c)
static struct sbd_state_trans {
int x_cmd;
struct {
int x_rv; /* return value of pre_op */
int x_err; /* errno, if any */
} x_op[SBD_NUM_STATES];
} sbd_state_transition[] = {
{ SBD_CMD_CONNECT,
{
{ 0, 0 }, /* empty */
{ 0, 0 }, /* occupied */
{ 1, EIO }, /* connected */
{ 1, EIO }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 1, EIO }, /* configured */
{ 1, EIO }, /* release */
{ 1, EIO }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_DISCONNECT,
{
{ 1, EIO }, /* empty */
{ 0, 0 }, /* occupied */
{ 0, 0 }, /* connected */
{ 0, 0 }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 1, EIO }, /* configured */
{ 1, EIO }, /* release */
{ 1, EIO }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_CONFIGURE,
{
{ 1, EIO }, /* empty */
{ 1, EIO }, /* occupied */
{ 0, 0 }, /* connected */
{ 0, 0 }, /* unconfigured */
{ 0, 0 }, /* partial */
{ 1, 0 }, /* configured */
{ 0, 0 }, /* release */
{ 0, 0 }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_UNCONFIGURE,
{
{ 1, EIO }, /* empty */
{ 1, EIO }, /* occupied */
{ 1, EIO }, /* connected */
{ 1, EIO }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 0, 0 }, /* configured */
{ 0, 0 }, /* release */
{ 0, 0 }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_POWEROFF,
{
{ 1, EIO }, /* empty */
{ 0, 0 }, /* occupied */
{ 1, EIO }, /* connected */
{ 1, EIO }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 1, EIO }, /* configured */
{ 1, EIO }, /* release */
{ 1, EIO }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_POWERON,
{
{ 1, EIO }, /* empty */
{ 0, 0 }, /* occupied */
{ 1, EIO }, /* connected */
{ 1, EIO }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 1, EIO }, /* configured */
{ 1, EIO }, /* release */
{ 1, EIO }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_UNASSIGN,
{
{ 1, EIO }, /* empty */
{ 0, 0 }, /* occupied */
{ 1, EIO }, /* connected */
{ 1, EIO }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 1, EIO }, /* configured */
{ 1, EIO }, /* release */
{ 1, EIO }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_ASSIGN,
{
{ 1, EIO }, /* empty */
{ 0, 0 }, /* occupied */
{ 1, EIO }, /* connected */
{ 1, EIO }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 1, EIO }, /* configured */
{ 1, EIO }, /* release */
{ 1, EIO }, /* unreferenced */
{ 1, EIO }, /* fatal */
}
},
{ SBD_CMD_TEST,
{
{ 1, EIO }, /* empty */
{ 0, 0 }, /* occupied */
{ 1, EIO }, /* connected */
{ 1, EIO }, /* unconfigured */
{ 1, EIO }, /* partial */
{ 1, EIO }, /* configured */
{ 1, EIO }, /* release */
{ 1, EIO }, /* unreferenced */
{ 1, EIO }, /* 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 sbd_grwlock;
/*
* Global to determine if an event needs to be sent
*/
char send_event = 0;
/*
* Required/Expected functions.
*/
static sbd_handle_t *sbd_get_handle(dev_t dev, sbd_softstate_t *softsp,
intptr_t arg, sbd_init_arg_t *iap);
static void sbd_release_handle(sbd_handle_t *hp);
static int sbd_pre_op(sbd_handle_t *hp);
static void sbd_post_op(sbd_handle_t *hp);
static int sbd_probe_board(sbd_handle_t *hp);
static int sbd_deprobe_board(sbd_handle_t *hp);
static void sbd_connect(sbd_handle_t *hp);
static void sbd_assign_board(sbd_handle_t *hp);
static void sbd_unassign_board(sbd_handle_t *hp);
static void sbd_poweron_board(sbd_handle_t *hp);
static void sbd_poweroff_board(sbd_handle_t *hp);
static void sbd_test_board(sbd_handle_t *hp);
static int sbd_disconnect(sbd_handle_t *hp);
static sbd_devlist_t *sbd_get_attach_devlist(sbd_handle_t *hp,
int32_t *devnump, int32_t pass);
static int sbd_pre_attach_devlist(sbd_handle_t *hp,
sbd_devlist_t *devlist, int32_t devnum);
static int sbd_post_attach_devlist(sbd_handle_t *hp,
sbd_devlist_t *devlist, int32_t devnum);
static sbd_devlist_t *sbd_get_release_devlist(sbd_handle_t *hp,
int32_t *devnump, int32_t pass);
static int sbd_pre_release_devlist(sbd_handle_t *hp,
sbd_devlist_t *devlist, int32_t devnum);
static int sbd_post_release_devlist(sbd_handle_t *hp,
sbd_devlist_t *devlist, int32_t devnum);
static void sbd_release_done(sbd_handle_t *hp,
sbd_comp_type_t nodetype,
dev_info_t *dip);
static sbd_devlist_t *sbd_get_detach_devlist(sbd_handle_t *hp,
int32_t *devnump, int32_t pass);
static int sbd_pre_detach_devlist(sbd_handle_t *hp,
sbd_devlist_t *devlist, int32_t devnum);
static int sbd_post_detach_devlist(sbd_handle_t *hp,
sbd_devlist_t *devlist, int32_t devnum);
static void sbd_status(sbd_handle_t *hp);
static void sbd_get_ncm(sbd_handle_t *hp);
/*
* Support functions.
*/
static sbd_devset_t sbd_dev2devset(sbd_comp_id_t *cid);
static int sbd_copyin_ioarg(sbd_handle_t *hp, int mode, int cmd,
sbd_cmd_t *cmdp, sbd_ioctl_arg_t *iap);
static int sbd_copyout_errs(int mode, sbd_ioctl_arg_t *iap,
void *arg);
static int sbd_copyout_ioarg(int mode, int cmd, sbd_cmd_t *scp,
sbd_ioctl_arg_t *iap);
static int sbd_check_transition(sbd_board_t *sbp,
sbd_devset_t *devsetp,
struct sbd_state_trans *transp);
static sbd_devlist_t *sbd_get_devlist(sbd_handle_t *hp,
sbd_board_t *sbp,
sbd_comp_type_t nodetype,
int max_units, uint_t uset,
int *count, int present_only);
static int sbd_mem_status(sbd_handle_t *hp, sbd_devset_t devset,
sbd_dev_stat_t *dsp);
static int sbd_init_devlists(sbd_board_t *sbp);
static int sbd_name_to_idx(char *name);
static int sbd_otype_to_idx(char *otpye);
static int sbd_setup_devlists(dev_info_t *dip, void *arg);
static void sbd_init_mem_devlists(sbd_board_t *sbp);
static void sbd_init_cpu_unit(sbd_board_t *sbp, int unit);
static void sbd_board_discovery(sbd_board_t *sbp);
static void sbd_board_init(sbd_board_t *sbp,
sbd_softstate_t *softsp,
int bd, dev_info_t *dip, int wnode);
static void sbd_board_destroy(sbd_board_t *sbp);
static int sbd_check_unit_attached(sbd_board_t *sbp,
dev_info_t *dip, int unit,
sbd_comp_type_t nodetype, sbderror_t *ep);
static sbd_state_t rstate_cvt(sbd_istate_t state);
/*
* Autoconfiguration data structures
*/
extern struct mod_ops mod_miscops;
static struct modlmisc modlmisc = {
&mod_miscops,
"System Board DR"
};
static struct modlinkage modlinkage = {
MODREV_1,
(void *)&modlmisc,
NULL
};
static int sbd_instances = 0;
/*
* dr Global data elements
*/
sbd_global sbd_g;
/*
* We want to be able to unload the module when we wish to do so, but we don't
* want anything else to unload it. Unloading cannot occur until
* sbd_teardown_instance is called by an explicit IOCTL into the parent node.
* This support is for debugging purposes and should it be expected to work
* on the field, it should be enhanced:
* Currently, there is still a window where sbd_teardow_instance gets called,
* sbd_prevent_unloading now = 0, the driver doesn't get unloaded, and
* sbd_setup_instance gets called. This may cause a panic.
*/
int sbd_prevent_unloading = 1;
/*
* 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 **)&sbd_g.softsp,
sizeof (sbd_softstate_t), SBD_MAX_INSTANCES);
if (err)
return (err);
if ((err = mod_install(&modlinkage)) != 0) {
ddi_soft_state_fini((void **)&sbd_g.softsp);
return (err);
}
/* Get the array of names from platform helper routine */
sbd_devattr = sbdp_get_devattr();
return (err);
}
int
_fini(void)
{
int err;
if (sbd_prevent_unloading)
return (DDI_FAILURE);
ASSERT(sbd_instances == 0);
if ((err = mod_remove(&modlinkage)) != 0)
return (err);
ddi_soft_state_fini((void **)&sbd_g.softsp);
return (0);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
int
sbd_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, char *event)
{
int rv = 0, instance;
sbd_handle_t *hp;
sbd_softstate_t *softsp;
sbd_init_arg_t init_arg;
static fn_t f = "sbd_ioctl";
int dr_avail;
PR_BYP("sbd_ioctl cmd=%x, arg=%lx\n", cmd, arg);
/* Note: this must also be changed in tandem with sbd_ioctl.h */
switch (cmd) {
case SBD_CMD_ASSIGN:
case SBD_CMD_UNASSIGN:
case SBD_CMD_POWERON:
case SBD_CMD_POWEROFF:
case SBD_CMD_TEST:
case SBD_CMD_CONNECT:
case SBD_CMD_CONFIGURE:
case SBD_CMD_UNCONFIGURE:
case SBD_CMD_DISCONNECT:
case SBD_CMD_STATUS:
case SBD_CMD_GETNCM:
case SBD_CMD_PASSTHRU:
break;
default:
return (ENOTTY);
}
instance = SBD_GET_MINOR2INST(getminor(dev));
if ((softsp = (sbd_softstate_t *)GET_SOFTC(instance)) == NULL) {
cmn_err(CE_WARN,
"sbd:%s:%d: module not yet attached",
f, instance);
return (ENXIO);
}
init_arg.dev = dev;
init_arg.cmd = cmd;
init_arg.mode = mode;
init_arg.ioargp = (sbd_ioctl_arg_t *)arg;
hp = sbd_get_handle(dev, softsp, arg, &init_arg);
/* Check to see if we support dr */
dr_avail = sbdp_dr_avail();
if (dr_avail != 1) {
switch (hp->h_cmd) {
case SBD_CMD_STATUS:
case SBD_CMD_GETNCM:
case SBD_CMD_PASSTHRU:
break;
default:
sbd_release_handle(hp);
return (ENOTSUP);
}
}
switch (hp->h_cmd) {
case SBD_CMD_STATUS:
case SBD_CMD_GETNCM:
case SBD_CMD_PASSTHRU:
/* no locks needed for these commands */
break;
default:
rw_enter(&sbd_grwlock, RW_WRITER);
mutex_enter(&SBDH2BD(hp->h_sbd)->sb_mutex);
/*
* 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".
*/
/*
* XXX This is incorrect. The sh_devset has not
* been set at this point - it is 0.
*/
rv = DEVSET_IN_SET(HD2MACHHD(hp)->sh_devset,
SBD_COMP_MEM, DEVSET_ANYUNIT);
if (rv == 0)
rw_downgrade(&sbd_grwlock);
break;
}
/*
* Before any operations happen, reset the event flag
*/
send_event = 0;
if (sbd_pre_op(hp) == 0) {
sbd_exec_op(hp);
sbd_post_op(hp);
}
rv = SBD_GET_ERRNO(SBD_HD2ERR(hp));
*event = send_event;
/* undo locking, if any, done before sbd_pre_op */
switch (hp->h_cmd) {
case SBD_CMD_STATUS:
case SBD_CMD_GETNCM:
case SBD_CMD_PASSTHRU:
break;
default:
mutex_exit(&SBDH2BD(hp->h_sbd)->sb_mutex);
rw_exit(&sbd_grwlock);
}
sbd_release_handle(hp);
return (rv);
}
int
sbd_setup_instance(int instance, dev_info_t *root, int max_boards, int wnode,
caddr_t sbdp_arg)
{
int b;
sbd_softstate_t *softsp;
sbd_board_t *sbd_boardlist;
static fn_t f = "sbd_setup_instance";
sbd_instances++;
if (sbdp_setup_instance(sbdp_arg) != DDI_SUCCESS) {
sbd_instances--;
return (DDI_FAILURE);
}
if (ALLOC_SOFTC(instance) != DDI_SUCCESS) {
cmn_err(CE_WARN,
"sbd:%s:%d: failed to alloc soft-state",
f, instance);
(void) sbdp_teardown_instance(sbdp_arg);
sbd_instances--;
return (DDI_FAILURE);
}
softsp = (sbd_softstate_t *)GET_SOFTC(instance);
if (softsp == NULL) {
cmn_err(CE_WARN,
"sbd:%s:%d: failed to get soft-state instance",
f, instance);
goto exit;
}
sbd_boardlist = GETSTRUCT(sbd_board_t, max_boards);
if (sbd_boardlist == NULL) {
cmn_err(CE_WARN,
"sbd:%s: failed to alloc board list %d",
f, instance);
goto exit;
}
softsp->sbd_boardlist = (void *)sbd_boardlist;
softsp->max_boards = max_boards;
softsp->wnode = wnode;
for (b = 0; b < max_boards; b++) {
sbd_board_init(sbd_boardlist++, softsp, b, root, wnode);
}
return (DDI_SUCCESS);
exit:
(void) sbdp_teardown_instance(sbdp_arg);
FREE_SOFTC(instance);
sbd_instances--;
return (DDI_FAILURE);
}
int
sbd_teardown_instance(int instance, caddr_t sbdp_arg)
{
sbd_softstate_t *softsp;
if (sbdp_teardown_instance(sbdp_arg) != DDI_SUCCESS)
return (DDI_FAILURE);
softsp = (sbd_softstate_t *)GET_SOFTC(instance);
if (softsp == NULL) {
return (DDI_FAILURE);
}
(void) sbd_dealloc_instance((sbd_board_t *)softsp->sbd_boardlist,
softsp->max_boards);
FREE_SOFTC(instance);
sbd_instances--;
sbd_prevent_unloading = 0;
return (DDI_SUCCESS);
}
static void
sbd_exec_op(sbd_handle_t *hp)
{
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
static fn_t f = "sbd_exec_op";
switch (hp->h_cmd) {
int dev_canceled;
case SBD_CMD_CONNECT:
if (sbd_probe_board(hp))
break;
sbd_connect(hp);
break;
case SBD_CMD_CONFIGURE:
sbd_dev_configure(hp);
break;
case SBD_CMD_UNCONFIGURE:
if (((dev_canceled = sbd_dev_release(hp)) == 0) &&
(SBD_GET_ERRNO(SBD_HD2ERR(hp)) == 0 &&
SBD_GET_ERR(SBD_HD2ERR(hp)) == 0))
dev_canceled = sbd_dev_unconfigure(hp);
if (dev_canceled)
sbd_cancel(hp);
break;
case SBD_CMD_DISCONNECT:
mutex_enter(&sbp->sb_slock);
if (sbd_disconnect(hp) == 0)
(void) sbd_deprobe_board(hp);
mutex_exit(&sbp->sb_slock);
break;
case SBD_CMD_STATUS:
sbd_status(hp);
break;
case SBD_CMD_GETNCM:
sbd_get_ncm(hp);
break;
case SBD_CMD_ASSIGN:
sbd_assign_board(hp);
break;
case SBD_CMD_UNASSIGN:
sbd_unassign_board(hp);
break;
case SBD_CMD_POWEROFF:
sbd_poweroff_board(hp);
break;
case SBD_CMD_POWERON:
sbd_poweron_board(hp);
break;
case SBD_CMD_TEST:
sbd_test_board(hp);
break;
case SBD_CMD_PASSTHRU:
{
int rv;
sbdp_handle_t *hdp;
sbderror_t *ep = SBD_HD2ERR(hp);
sbdp_ioctl_arg_t ia, *iap;
iap = &ia;
iap->h_dev = hp->h_dev;
iap->h_cmd = hp->h_cmd;
iap->h_iap = (intptr_t)hp->h_iap;
iap->h_mode = hp->h_mode;
hdp = sbd_get_sbdp_handle(sbp, hp);
rv = sbdp_ioctl(hdp, iap);
if (rv != 0) {
SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
ep->e_errno = rv;
}
sbd_release_sbdp_handle(hdp);
break;
}
default:
SBD_SET_ERRNO(SBD_HD2ERR(hp), ENOTTY);
cmn_err(CE_WARN,
"sbd:%s: unknown command (%d)",
f, hp->h_cmd);
break;
}
if (SBD_GET_ERR(SBD_HD2ERR(hp)))
PR_BYP("XXX e_code=%d", SBD_GET_ERR(SBD_HD2ERR(hp)));
if (SBD_GET_ERRNO(SBD_HD2ERR(hp)))
PR_BYP("XXX errno=%d", SBD_GET_ERRNO(SBD_HD2ERR(hp)));
}
sbd_comp_type_t
sbd_get_devtype(sbd_handle_t *hp, dev_info_t *dip)
{
sbd_board_t *sbp = hp ? SBDH2BD(hp->h_sbd) : NULL;
sbd_istate_t bstate;
dev_info_t **devlist;
int i;
char device[OBP_MAXDRVNAME];
int devicelen;
devicelen = sizeof (device);
bstate = sbp ? SBD_BOARD_STATE(sbp) : SBD_STATE_EMPTY;
/*
* if the board's connected or configured, search the
* devlists. Otherwise check the device tree
*/
switch (bstate) {
case SBD_STATE_CONNECTED:
case SBD_STATE_CONFIGURED:
case SBD_STATE_UNREFERENCED:
case SBD_STATE_UNCONFIGURED:
devlist = sbp->sb_devlist[NIX(SBD_COMP_MEM)];
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++)
if (devlist[i] == dip)
return (SBD_COMP_MEM);
devlist = sbp->sb_devlist[NIX(SBD_COMP_CPU)];
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++)
if (devlist[i] == dip)
return (SBD_COMP_CPU);
devlist = sbp->sb_devlist[NIX(SBD_COMP_IO)];
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++)
if (devlist[i] == dip)
return (SBD_COMP_IO);
/*FALLTHROUGH*/
default:
if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
OBP_DEVICETYPE, (caddr_t)device, &devicelen))
break;
for (i = 0; SBD_COMP(i) != SBD_COMP_UNKNOWN; i++) {
if (strcmp(device, SBD_OTYPE(i)) != 0)
continue;
return (SBD_COMP(i));
}
break;
}
return (SBD_COMP_UNKNOWN);
}
static void
sbd_dev_configure(sbd_handle_t *hp)
{
int n, unit;
int32_t pass, devnum;
dev_info_t *dip;
sbd_devlist_t *devlist;
sbdp_handle_t *hdp;
sbd_comp_type_t nodetype;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
pass = 1;
hdp = sbd_get_sbdp_handle(sbp, hp);
while ((devlist = sbd_get_attach_devlist(hp, &devnum, pass)) != NULL) {
int err;
err = sbd_pre_attach_devlist(hp, devlist, devnum);
if (err < 0) {
break;
} else if (err > 0) {
pass++;
continue;
}
for (n = 0; n < devnum; n++) {
sbderror_t *ep;
ep = &devlist[n].dv_error;
SBD_SET_ERRNO(ep, 0);
SBD_SET_ERR(ep, 0);
dip = devlist[n].dv_dip;
nodetype = sbd_get_devtype(hp, dip);
unit = sbdp_get_unit_num(hdp, dip);
if (unit < 0) {
SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
break;
}
switch (nodetype) {
case SBD_COMP_MEM:
sbd_attach_mem(hp, ep);
if (SBD_GET_ERR(ep) == ESBD_CPUONLINE) {
FREESTRUCT(devlist, sbd_devlist_t,
MAX_MEM_UNITS_PER_BOARD);
sbd_release_sbdp_handle(hdp);
return;
}
break;
case SBD_COMP_CPU:
sbd_attach_cpu(hp, ep, dip, unit);
break;
case SBD_COMP_IO:
sbd_attach_io(hp, ep, dip, unit);
break;
default:
SBD_SET_ERRNO(ep, ENOTTY);
break;
}
if (sbd_set_err_in_hdl(hp, ep) == 0)
continue;
}
err = sbd_post_attach_devlist(hp, devlist, devnum);
if (err < 0)
break;
pass++;
}
sbd_release_sbdp_handle(hdp);
}
static int
sbd_dev_release(sbd_handle_t *hp)
{
int n, unit;
int32_t pass, devnum;
dev_info_t *dip;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbdp_handle_t *hdp;
sbd_devlist_t *devlist;
sbd_comp_type_t nodetype;
int err = 0;
int dev_canceled;
pass = 1;
hdp = sbd_get_sbdp_handle(sbp, hp);
sbp->sb_busy = 1;
while ((devlist =
sbd_get_release_devlist(hp, &devnum, pass)) != NULL) {
err = sbd_pre_release_devlist(hp, devlist, devnum);
if (err < 0) {
dev_canceled = 1;
break;
} else if (err > 0) {
pass++;
continue;
}
dev_canceled = 0;
for (n = 0; n < devnum; n++) {
dip = devlist[n].dv_dip;
nodetype = sbd_get_devtype(hp, dip);
unit = sbdp_get_unit_num(hdp, dip);
if (unit < 0) {
SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
break;
}
if ((nodetype == SBD_COMP_MEM) &&
sbd_release_mem(hp, dip, unit)) {
dev_canceled++;
}
sbd_release_done(hp, nodetype, dip);
}
err = sbd_post_release_devlist(hp, devlist, devnum);
if (err < 0)
break;
if (dev_canceled)
break;
pass++;
}
sbp->sb_busy = 0;
sbd_release_sbdp_handle(hdp);
if (dev_canceled)
return (dev_canceled);
return (err);
}
static int
sbd_dev_unconfigure(sbd_handle_t *hp)
{
int n, unit;
int32_t pass, devnum;
dev_info_t *dip;
sbd_devlist_t *devlist;
sbdp_handle_t *hdp;
sbd_comp_type_t nodetype;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
int dev_canceled = 0;
static fn_t f = "sbd_dev_unconfigure";
PR_ALL("%s...\n", f);
pass = 1;
hdp = sbd_get_sbdp_handle(sbp, hp);
while ((devlist = sbd_get_detach_devlist(hp, &devnum, pass)) != NULL) {
int err, detach_err = 0;
err = sbd_pre_detach_devlist(hp, devlist, devnum);
if (err) {
/*
* Only cancel the operation for memory in
* case of failure.
*/
nodetype = sbd_get_devtype(hp, devlist->dv_dip);
if (nodetype == SBD_COMP_MEM)
dev_canceled = 1;
(void) sbd_post_detach_devlist(hp, devlist, devnum);
break;
}
for (n = 0; n < devnum; n++) {
sbderror_t *ep;
ep = &devlist[n].dv_error;
SBD_SET_ERRNO(ep, 0);
SBD_SET_ERR(ep, 0);
dip = devlist[n].dv_dip;
nodetype = sbd_get_devtype(hp, dip);
unit = sbdp_get_unit_num(hdp, dip);
if (unit < 0) {
SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
break;
}
switch (nodetype) {
case SBD_COMP_MEM:
dev_canceled = sbd_detach_mem(hp, ep, unit);
break;
case SBD_COMP_CPU:
sbd_detach_cpu(hp, ep, dip, unit);
break;
case SBD_COMP_IO:
sbd_detach_io(hp, ep, dip, unit);
break;
default:
SBD_SET_ERRNO(ep, ENOTTY);
break;
}
if (sbd_set_err_in_hdl(hp, ep) == 0) {
detach_err = -1;
break;
}
}
err = sbd_post_detach_devlist(hp, devlist, devnum);
if ((err < 0) || (detach_err < 0))
break;
pass++;
}
sbd_release_sbdp_handle(hdp);
return (dev_canceled);
}
int
sbd_errno2ecode(int error)
{
int rv;
switch (error) {
case EBUSY:
rv = ESBD_BUSY;
break;
case EINVAL:
rv = ESBD_INVAL;
break;
case EALREADY:
rv = ESBD_ALREADY;
break;
case ENODEV:
rv = ESBD_NODEV;
break;
case ENOMEM:
rv = ESBD_NOMEM;
break;
default:
rv = ESBD_INVAL;
}
return (rv);
}
static void
sbd_attach_cpu(sbd_handle_t *hp, sbderror_t *ep, dev_info_t *dip, int unit)
{
int rv = 0;
processorid_t cpuid;
sbdp_handle_t *hdp;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
static fn_t f = "sbd_attach_cpu";
char *pathname;
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(dip);
/*
* With the introduction of CMP devices, the CPU nodes
* are no longer directly under the top node. Since
* there is no plan to support CPU attach in the near
* future, a branch configure operation is not required.
*/
hdp = sbd_get_sbdp_handle(sbp, hp);
cpuid = sbdp_get_cpuid(hdp, dip);
if (cpuid < 0) {
rv = -1;
SBD_GET_PERR(hdp->h_err, ep);
} else if ((rv = cpu_configure(cpuid)) != 0) {
cmn_err(CE_WARN,
"sbd:%s: cpu_configure for cpuid %d failed",
f, cpuid);
SBD_SET_ERR(ep, sbd_errno2ecode(rv));
}
sbd_release_sbdp_handle(hdp);
if (rv == 0) {
ASSERT(sbp->sb_cpupath[unit] != NULL);
pathname = sbp->sb_cpupath[unit];
(void) ddi_pathname(dip, pathname);
}
}
/*
* translate errno
*/
void
sbd_errno_decode(int err, sbderror_t *ep, dev_info_t *dip)
{
ASSERT(err != 0);
switch (err) {
case ENOMEM:
SBD_SET_ERR(ep, ESBD_NOMEM);
break;
case EBUSY:
SBD_SET_ERR(ep, ESBD_BUSY);
break;
case EIO:
SBD_SET_ERR(ep, ESBD_IO);
break;
case ENXIO:
SBD_SET_ERR(ep, ESBD_NODEV);
break;
case EINVAL:
SBD_SET_ERR(ep, ESBD_INVAL);
break;
case EFAULT:
default:
SBD_SET_ERR(ep, ESBD_FAULT);
break;
}
(void) ddi_pathname(dip, SBD_GET_ERRSTR(ep));
}
static void
sbd_detach_cpu(sbd_handle_t *hp, sbderror_t *ep, dev_info_t *dip, int unit)
{
processorid_t cpuid;
int rv;
sbdp_handle_t *hdp;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbd_error_t *spe;
static fn_t f = "sbd_detach_cpu";
ASSERT(MUTEX_HELD(&cpu_lock));
ASSERT(dip);
hdp = sbd_get_sbdp_handle(sbp, hp);
spe = hdp->h_err;
cpuid = sbdp_get_cpuid(hdp, dip);
if (cpuid < 0) {
SBD_GET_PERR(spe, ep);
sbd_release_sbdp_handle(hdp);
return;
}
if ((rv = cpu_unconfigure(cpuid)) != 0) {
SBD_SET_ERR(ep, sbd_errno2ecode(rv));
SBD_SET_ERRSTR(ep, sbp->sb_cpupath[unit]);
cmn_err(CE_WARN,
"sbd:%s: cpu_unconfigure for cpu %d failed",
f, cpuid);
sbd_release_sbdp_handle(hdp);
return;
}
sbd_release_sbdp_handle(hdp);
/*
* Since CPU nodes are no longer configured in CPU
* attach, the corresponding branch unconfigure
* operation that would be performed here is also
* no longer required.
*/
}
int
sbd_detach_mem(sbd_handle_t *hp, sbderror_t *ep, int unit)
{
sbd_mem_unit_t *mp;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
int i, rv;
static fn_t f = "sbd_detach_mem";
mp = SBD_GET_BOARD_MEMUNIT(sbp, unit);
if (sbd_detach_memory(hp, ep, mp, unit)) {
cmn_err(CE_WARN, "%s: detach fail", f);
return (-1);
}
/*
* Now detach mem devinfo nodes with status lock held.
*/
for (i = 0; i < SBD_NUM_MC_PER_BOARD; i++) {
dev_info_t *fdip = NULL;
if (mp->sbm_dip[i] == NULL)
continue;
ASSERT(e_ddi_branch_held(mp->sbm_dip[i]));
mutex_enter(&sbp->sb_slock);
rv = e_ddi_branch_unconfigure(mp->sbm_dip[i], &fdip,
DEVI_BRANCH_EVENT);
mutex_exit(&sbp->sb_slock);
if (rv) {
/*
* If non-NULL, fdip is returned held and must be
* released.
*/
if (fdip != NULL) {
sbd_errno_decode(rv, ep, fdip);
ddi_release_devi(fdip);
} else {
sbd_errno_decode(rv, ep, mp->sbm_dip[i]);
}
}
}
return (0);
}
/* start beginning of sbd.c */
/*
* MDR memory support - somewhat disabled for now.
* UNSAFE unsafe driver code - I don't think we want this.
* need to check.
* DEVNODE This driver creates attachment points for individual
* components as well as boards. We only need board
* support.
* DEV2DEVSET Put only present devices in devset.
*/
static sbd_state_t
rstate_cvt(sbd_istate_t state)
{
sbd_state_t cs;
switch (state) {
case SBD_STATE_EMPTY:
cs = SBD_STAT_EMPTY;
break;
case SBD_STATE_OCCUPIED:
case SBD_STATE_FATAL:
cs = SBD_STAT_DISCONNECTED;
break;
case SBD_STATE_CONFIGURED:
case SBD_STATE_CONNECTED:
case SBD_STATE_UNCONFIGURED:
case SBD_STATE_PARTIAL:
case SBD_STATE_RELEASE:
case SBD_STATE_UNREFERENCED:
cs = SBD_STAT_CONNECTED;
break;
default:
cs = SBD_STAT_NONE;
break;
}
return (cs);
}
sbd_state_t
ostate_cvt(sbd_istate_t state)
{
sbd_state_t cs;
switch (state) {
case SBD_STATE_EMPTY:
case SBD_STATE_OCCUPIED:
case SBD_STATE_UNCONFIGURED:
case SBD_STATE_CONNECTED:
case SBD_STATE_FATAL:
cs = SBD_STAT_UNCONFIGURED;
break;
case SBD_STATE_PARTIAL:
case SBD_STATE_CONFIGURED:
case SBD_STATE_RELEASE:
case SBD_STATE_UNREFERENCED:
cs = SBD_STAT_CONFIGURED;
break;
default:
cs = SBD_STAT_NONE;
break;
}
return (cs);
}
int
sbd_dealloc_instance(sbd_board_t *sbp, int max_boards)
{
int b;
sbd_board_t *list = sbp;
static fn_t f = "sbd_dealloc_instance";
PR_ALL("%s...\n", f);
if (sbp == NULL) {
return (-1);
}
for (b = 0; b < max_boards; b++) {
sbd_board_destroy(sbp++);
}
FREESTRUCT(list, sbd_board_t, max_boards);
return (0);
}
static sbd_devset_t
sbd_dev2devset(sbd_comp_id_t *cid)
{
static fn_t f = "sbd_dev2devset";
sbd_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);
break;
case SBD_COMP_CPU:
if ((unit > MAX_CPU_UNITS_PER_BOARD) || (unit < 0)) {
PR_ALL("%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);
break;
case SBD_COMP_MEM:
if ((unit > MAX_MEM_UNITS_PER_BOARD) || (unit < 0)) {
#ifdef XXX_jeffco
PR_ALL("%s: invalid mem unit# = %d",
f, unit);
devset = 0;
#endif
devset = DEVSET(cid->c_type, 0);
PR_ALL("%s: adjusted MEM devset = 0x%x\n",
f, devset);
} else
devset = DEVSET(cid->c_type, unit);
break;
case SBD_COMP_IO:
if ((unit > MAX_IO_UNITS_PER_BOARD) || (unit < 0)) {
PR_ALL("%s: invalid io unit# = %d",
f, unit);
devset = 0;
} else
devset = DEVSET(cid->c_type, unit);
break;
default:
case SBD_COMP_UNKNOWN:
devset = 0;
break;
}
return (devset);
}
/*
* Simple mutex for covering handle list ops as it is only
* used "infrequently". No need to add another mutex to the sbd_board_t.
*/
static kmutex_t sbd_handle_list_mutex;
static sbd_handle_t *
sbd_get_handle(dev_t dev, sbd_softstate_t *softsp, intptr_t arg,
sbd_init_arg_t *iap)
{
sbd_handle_t *hp;
sbderror_t *ep;
sbd_priv_handle_t *shp;
sbd_board_t *sbp = softsp->sbd_boardlist;
int board;
board = SBDGETSLOT(dev);
ASSERT(board < softsp->max_boards);
sbp += board;
/*
* Brand-new handle.
*/
shp = kmem_zalloc(sizeof (sbd_priv_handle_t), KM_SLEEP);
shp->sh_arg = (void *)arg;
hp = MACHHD2HD(shp);
ep = &shp->sh_err;
hp->h_err = ep;
hp->h_sbd = (void *) sbp;
hp->h_dev = iap->dev;
hp->h_cmd = iap->cmd;
hp->h_mode = iap->mode;
sbd_init_err(ep);
mutex_enter(&sbd_handle_list_mutex);
shp->sh_next = sbp->sb_handle;
sbp->sb_handle = shp;
mutex_exit(&sbd_handle_list_mutex);
return (hp);
}
void
sbd_init_err(sbderror_t *ep)
{
ep->e_errno = 0;
ep->e_code = 0;
ep->e_rsc[0] = '\0';
}
int
sbd_set_err_in_hdl(sbd_handle_t *hp, sbderror_t *ep)
{
sbderror_t *hep = SBD_HD2ERR(hp);
/*
* If there is an error logged already, don't rewrite it
*/
if (SBD_GET_ERR(hep) || SBD_GET_ERRNO(hep)) {
return (0);
}
if (SBD_GET_ERR(ep) || SBD_GET_ERRNO(ep)) {
SBD_SET_ERR(hep, SBD_GET_ERR(ep));
SBD_SET_ERRNO(hep, SBD_GET_ERRNO(ep));
SBD_SET_ERRSTR(hep, SBD_GET_ERRSTR(ep));
return (0);
}
return (-1);
}
static void
sbd_release_handle(sbd_handle_t *hp)
{
sbd_priv_handle_t *shp, **shpp;
sbd_board_t *sbp;
static fn_t f = "sbd_release_handle";
if (hp == NULL)
return;
sbp = SBDH2BD(hp->h_sbd);
shp = HD2MACHHD(hp);
mutex_enter(&sbd_handle_list_mutex);
/*
* Locate the handle in the board's reference list.
*/
for (shpp = &sbp->sb_handle; (*shpp) && ((*shpp) != shp);
shpp = &((*shpp)->sh_next))
/* empty */;
if (*shpp == NULL) {
cmn_err(CE_PANIC,
"sbd:%s: handle not found in board %d",
f, sbp->sb_num);
/*NOTREACHED*/
} else {
*shpp = shp->sh_next;
}
mutex_exit(&sbd_handle_list_mutex);
if (hp->h_opts.copts != NULL) {
FREESTRUCT(hp->h_opts.copts, char, hp->h_opts.size);
}
FREESTRUCT(shp, sbd_priv_handle_t, 1);
}
sbdp_handle_t *
sbd_get_sbdp_handle(sbd_board_t *sbp, sbd_handle_t *hp)
{
sbdp_handle_t *hdp;
hdp = kmem_zalloc(sizeof (sbdp_handle_t), KM_SLEEP);
hdp->h_err = kmem_zalloc(sizeof (sbd_error_t), KM_SLEEP);
if (sbp == NULL) {
hdp->h_board = -1;
hdp->h_wnode = -1;
} else {
hdp->h_board = sbp->sb_num;
hdp->h_wnode = sbp->sb_wnode;
}
if (hp == NULL) {
hdp->h_flags = 0;
hdp->h_opts = NULL;
} else {
hdp->h_flags = SBD_2_SBDP_FLAGS(hp->h_flags);
hdp->h_opts = &hp->h_opts;
}
return (hdp);
}
void
sbd_release_sbdp_handle(sbdp_handle_t *hdp)
{
if (hdp == NULL)
return;
kmem_free(hdp->h_err, sizeof (sbd_error_t));
kmem_free(hdp, sizeof (sbdp_handle_t));
}
void
sbd_reset_error_sbdph(sbdp_handle_t *hdp)
{
if ((hdp != NULL) && (hdp->h_err != NULL)) {
bzero(hdp->h_err, sizeof (sbd_error_t));
}
}
static int
sbd_copyin_ioarg(sbd_handle_t *hp, int mode, int cmd, sbd_cmd_t *cmdp,
sbd_ioctl_arg_t *iap)
{
static fn_t f = "sbd_copyin_ioarg";
if (iap == NULL)
return (EINVAL);
bzero((caddr_t)cmdp, sizeof (sbd_cmd_t));
#ifdef _MULTI_DATAMODEL
if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
sbd_cmd32_t scmd32;
bzero((caddr_t)&scmd32, sizeof (sbd_cmd32_t));
if (ddi_copyin((void *)iap, (void *)&scmd32,
sizeof (sbd_cmd32_t), mode)) {
cmn_err(CE_WARN,
"sbd:%s: (32bit) failed to copyin "
"sbdcmd-struct", f);
return (EFAULT);
}
cmdp->cmd_cm.c_id.c_type = scmd32.cmd_cm.c_id.c_type;
cmdp->cmd_cm.c_id.c_unit = scmd32.cmd_cm.c_id.c_unit;
bcopy(&scmd32.cmd_cm.c_id.c_name[0],
&cmdp->cmd_cm.c_id.c_name[0], OBP_MAXPROPNAME);
cmdp->cmd_cm.c_flags = scmd32.cmd_cm.c_flags;
cmdp->cmd_cm.c_len = scmd32.cmd_cm.c_len;
cmdp->cmd_cm.c_opts = (caddr_t)(uintptr_t)scmd32.cmd_cm.c_opts;
if (cmd == SBD_CMD_PASSTHRU) {
PR_BYP("passthru copyin: iap=%p, sz=%ld", (void *)iap,
sizeof (sbd_cmd32_t));
PR_BYP("passthru copyin: c_opts=%x, c_len=%d",
scmd32.cmd_cm.c_opts,
scmd32.cmd_cm.c_len);
}
switch (cmd) {
case SBD_CMD_STATUS:
cmdp->cmd_stat.s_nbytes = scmd32.cmd_stat.s_nbytes;
cmdp->cmd_stat.s_statp =
(caddr_t)(uintptr_t)scmd32.cmd_stat.s_statp;
break;
default:
break;
}
} else
#endif /* _MULTI_DATAMODEL */
if (ddi_copyin((void *)iap, (void *)cmdp,
sizeof (sbd_cmd_t), mode) != 0) {
cmn_err(CE_WARN,
"sbd:%s: failed to copyin sbd cmd_t struct", f);
return (EFAULT);
}
/*
* A user may set platform specific options so we need to
* copy them in
*/
if ((cmd != SBD_CMD_STATUS) && ((hp->h_opts.size = cmdp->cmd_cm.c_len)
> 0)) {
hp->h_opts.size += 1; /* For null termination of string. */
hp->h_opts.copts = GETSTRUCT(char, hp->h_opts.size);
if (ddi_copyin((void *)cmdp->cmd_cm.c_opts,
(void *)hp->h_opts.copts,
cmdp->cmd_cm.c_len, hp->h_mode) != 0) {
/* copts is freed in sbd_release_handle(). */
cmn_err(CE_WARN,
"sbd:%s: failed to copyin options", f);
return (EFAULT);
}
}
return (0);
}
static int
sbd_copyout_ioarg(int mode, int cmd, sbd_cmd_t *scp, sbd_ioctl_arg_t *iap)
{
static fn_t f = "sbd_copyout_ioarg";
if ((iap == NULL) || (scp == NULL))
return (EINVAL);
#ifdef _MULTI_DATAMODEL
if (ddi_model_convert_from(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,
scmd32.cmd_cm.c_id.c_name, OBP_MAXPROPNAME);
scmd32.cmd_cm.c_flags = scp->cmd_cm.c_flags;
switch (cmd) {
case SBD_CMD_GETNCM:
scmd32.cmd_getncm.g_ncm = scp->cmd_getncm.g_ncm;
break;
default:
break;
}
if (ddi_copyout((void *)&scmd32, (void *)iap,
sizeof (sbd_cmd32_t), mode)) {
cmn_err(CE_WARN,
"sbd:%s: (32bit) failed to copyout "
"sbdcmd struct", f);
return (EFAULT);
}
} else
#endif /* _MULTI_DATAMODEL */
if (ddi_copyout((void *)scp, (void *)iap,
sizeof (sbd_cmd_t), mode) != 0) {
cmn_err(CE_WARN,
"sbd:%s: failed to copyout sbdcmd struct", f);
return (EFAULT);
}
return (0);
}
static int
sbd_copyout_errs(int mode, sbd_ioctl_arg_t *iap, void *arg)
{
static fn_t f = "sbd_copyout_errs";
sbd_ioctl_arg_t *uap;
uap = (sbd_ioctl_arg_t *)arg;
#ifdef _MULTI_DATAMODEL
if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
sbd_error32_t err32;
sbd_ioctl_arg32_t *uap32;
uap32 = (sbd_ioctl_arg32_t *)arg;
err32.e_code = iap->ie_code;
(void) strcpy(err32.e_rsc, iap->ie_rsc);
if (ddi_copyout((void *)&err32, (void *)&uap32->i_err,
sizeof (sbd_error32_t), mode)) {
cmn_err(CE_WARN,
"sbd:%s: failed to copyout ioctl32 errs",
f);
return (EFAULT);
}
} else
#endif /* _MULTI_DATAMODEL */
if (ddi_copyout((void *)&iap->i_err, (void *)&uap->i_err,
sizeof (sbd_error_t), mode) != 0) {
cmn_err(CE_WARN,
"sbd:%s: failed to copyout ioctl errs", f);
return (EFAULT);
}
return (0);
}
/*
* State transition policy is that if at least one
* device cannot make the transition, then none of
* the requested devices are allowed to transition.
*
* Returns the state that is in error, if any.
*/
static int
sbd_check_transition(sbd_board_t *sbp, sbd_devset_t *devsetp,
struct sbd_state_trans *transp)
{
int s, ut;
int state_err = 0;
sbd_devset_t devset;
static fn_t f = "sbd_check_transition";
devset = *devsetp;
if (!devset) {
/*
* Transition does not deal with any components.
* This is the case for addboard/deleteboard.
*/
PR_ALL("%s: no devs: requested devset = 0x%x,"
" final devset = 0x%x\n",
f, (uint_t)*devsetp, (uint_t)devset);
return (0);
}
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;
s = (int)SBD_DEVICE_STATE(sbp, SBD_COMP_MEM, ut);
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_CPU, DEVSET_ANYUNIT)) {
for (ut = 0; ut < MAX_CPU_UNITS_PER_BOARD; ut++) {
if (DEVSET_IN_SET(devset, SBD_COMP_CPU, ut) == 0)
continue;
s = (int)SBD_DEVICE_STATE(sbp, SBD_COMP_CPU, ut);
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_IO, DEVSET_ANYUNIT)) {
for (ut = 0; ut < MAX_IO_UNITS_PER_BOARD; ut++) {
if (DEVSET_IN_SET(devset, SBD_COMP_IO, ut) == 0)
continue;
s = (int)SBD_DEVICE_STATE(sbp, SBD_COMP_IO, ut);
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.
*/
return (devset ? 0 : state_err);
}
/*
* pre-op entry point must SET_ERRNO(), if needed.
* Return value of non-zero indicates failure.
*/
static int
sbd_pre_op(sbd_handle_t *hp)
{
int rv = 0, t;
int cmd, serr = 0;
sbd_devset_t devset;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbd_priv_handle_t *shp = HD2MACHHD(hp);
sbderror_t *ep = SBD_HD2ERR(hp);
sbd_cmd_t *cmdp;
static fn_t f = "sbd_pre_op";
cmd = hp->h_cmd;
devset = shp->sh_devset;
switch (cmd) {
case SBD_CMD_CONNECT:
case SBD_CMD_DISCONNECT:
case SBD_CMD_UNCONFIGURE:
case SBD_CMD_CONFIGURE:
case SBD_CMD_ASSIGN:
case SBD_CMD_UNASSIGN:
case SBD_CMD_POWERON:
case SBD_CMD_POWEROFF:
case SBD_CMD_TEST:
/* ioctls allowed if caller has write permission */
if (!(hp->h_mode & FWRITE)) {
SBD_SET_ERRNO(ep, EPERM);
return (-1);
}
default:
break;
}
hp->h_iap = GETSTRUCT(sbd_ioctl_arg_t, 1);
rv = sbd_copyin_ioarg(hp, hp->h_mode, cmd,
(sbd_cmd_t *)hp->h_iap, shp->sh_arg);
if (rv) {
SBD_SET_ERRNO(ep, rv);
FREESTRUCT(hp->h_iap, sbd_ioctl_arg_t, 1);
hp->h_iap = NULL;
cmn_err(CE_WARN, "%s: copyin fail", f);
return (-1);
} else {
cmdp = (sbd_cmd_t *)hp->h_iap;
if (cmdp->cmd_cm.c_id.c_name[0] != '\0') {
cmdp->cmd_cm.c_id.c_type = SBD_COMP(sbd_name_to_idx(
cmdp->cmd_cm.c_id.c_name));
if (cmdp->cmd_cm.c_id.c_type == SBD_COMP_MEM) {
if (cmdp->cmd_cm.c_id.c_unit == -1)
cmdp->cmd_cm.c_id.c_unit = 0;
}
}
devset = shp->sh_orig_devset = shp->sh_devset =
sbd_dev2devset(&cmdp->cmd_cm.c_id);
if (devset == 0) {
SBD_SET_ERRNO(ep, EINVAL);
FREESTRUCT(hp->h_iap, sbd_ioctl_arg_t, 1);
hp->h_iap = NULL;
return (-1);
}
}
/*
* Always turn on these bits ala Sunfire DR.
*/
hp->h_flags |= SBD_FLAG_DEVI_FORCE;
if (cmdp->cmd_cm.c_flags & SBD_FLAG_FORCE)
hp->h_flags |= SBD_IOCTL_FLAG_FORCE;
/*
* Check for valid state transitions.
*/
if (!serr && ((t = CMD2INDEX(cmd)) != -1)) {
struct sbd_state_trans *transp;
int state_err;
transp = &sbd_state_transition[t];
ASSERT(transp->x_cmd == cmd);
state_err = sbd_check_transition(sbp, &devset, transp);
if (state_err < 0) {
/*
* Invalidate device.
*/
SBD_SET_ERRNO(ep, ENOTTY);
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.
*/
SBD_SET_ERRNO(ep, transp->x_op[state_err].x_err);
serr = transp->x_op[state_err].x_rv;
PR_ALL("%s: invalid state %s(%d) for cmd %s(%d)\n",
f, sbd_state_str[state_err], state_err,
SBD_CMD_STR(cmd), cmd);
}
if (serr && SBD_GET_ERRNO(ep) != 0) {
/*
* A state transition error occurred.
*/
if (serr < 0) {
SBD_SET_ERR(ep, ESBD_INVAL);
} else {
SBD_SET_ERR(ep, ESBD_STATE);
}
PR_ALL("%s: invalid state transition\n", f);
} else {
shp->sh_devset = devset;
}
}
if (serr && !rv && hp->h_iap) {
/*
* There was a state error. We successfully copied
* in the ioctl argument, so let's fill in the
* error and copy it back out.
*/
if (SBD_GET_ERR(ep) && SBD_GET_ERRNO(ep) == 0)
SBD_SET_ERRNO(ep, EIO);
SBD_SET_IOCTL_ERR(&hp->h_iap->i_err,
ep->e_code,
ep->e_rsc);
(void) sbd_copyout_errs(hp->h_mode, hp->h_iap, shp->sh_arg);
FREESTRUCT(hp->h_iap, sbd_ioctl_arg_t, 1);
hp->h_iap = NULL;
rv = -1;
}
return (rv);
}
static void
sbd_post_op(sbd_handle_t *hp)
{
int cmd;
sbderror_t *ep = SBD_HD2ERR(hp);
sbd_priv_handle_t *shp = HD2MACHHD(hp);
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
cmd = hp->h_cmd;
switch (cmd) {
case SBD_CMD_CONFIGURE:
case SBD_CMD_UNCONFIGURE:
case SBD_CMD_CONNECT:
case SBD_CMD_DISCONNECT:
sbp->sb_time = gethrestime_sec();
break;
default:
break;
}
if (SBD_GET_ERR(ep) && SBD_GET_ERRNO(ep) == 0) {
SBD_SET_ERRNO(ep, EIO);
}
if (shp->sh_arg != NULL) {
if (SBD_GET_ERR(ep) != ESBD_NOERROR) {
SBD_SET_IOCTL_ERR(&hp->h_iap->i_err,
ep->e_code,
ep->e_rsc);
(void) sbd_copyout_errs(hp->h_mode, hp->h_iap,
shp->sh_arg);
}
if (hp->h_iap != NULL) {
FREESTRUCT(hp->h_iap, sbd_ioctl_arg_t, 1);
hp->h_iap = NULL;
}
}
}
static int
sbd_probe_board(sbd_handle_t *hp)
{
int rv;
sbd_board_t *sbp;
sbdp_handle_t *hdp;
static fn_t f = "sbd_probe_board";
sbp = SBDH2BD(hp->h_sbd);
ASSERT(sbp != NULL);
PR_ALL("%s for board %d", f, sbp->sb_num);
hdp = sbd_get_sbdp_handle(sbp, hp);
if ((rv = sbdp_connect_board(hdp)) != 0) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_GET_PERR(hdp->h_err, ep);
}
/*
* We need to force a recache after the connect. The cached
* info may be incorrect
*/
mutex_enter(&sbp->sb_flags_mutex);
sbp->sb_flags &= ~SBD_BOARD_STATUS_CACHED;
mutex_exit(&sbp->sb_flags_mutex);
SBD_INJECT_ERR(SBD_PROBE_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESGT_PROBE, NULL);
sbd_release_sbdp_handle(hdp);
return (rv);
}
static int
sbd_deprobe_board(sbd_handle_t *hp)
{
int rv;
sbdp_handle_t *hdp;
sbd_board_t *sbp;
static fn_t f = "sbd_deprobe_board";
PR_ALL("%s...\n", f);
sbp = SBDH2BD(hp->h_sbd);
hdp = sbd_get_sbdp_handle(sbp, hp);
if ((rv = sbdp_disconnect_board(hdp)) != 0) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_GET_PERR(hdp->h_err, ep);
}
mutex_enter(&sbp->sb_flags_mutex);
sbp->sb_flags &= ~SBD_BOARD_STATUS_CACHED;
mutex_exit(&sbp->sb_flags_mutex);
SBD_INJECT_ERR(SBD_DEPROBE_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESGT_DEPROBE, NULL);
sbd_release_sbdp_handle(hdp);
return (rv);
}
/*
* Check if a CPU node is part of a CMP.
*/
int
sbd_is_cmp_child(dev_info_t *dip)
{
dev_info_t *pdip;
if (strcmp(ddi_node_name(dip), "cpu") != 0) {
return (0);
}
pdip = ddi_get_parent(dip);
ASSERT(pdip);
if (strcmp(ddi_node_name(pdip), "cmp") == 0) {
return (1);
}
return (0);
}
/*
* Returns the nodetype if dip is a top dip on the board of
* interest or SBD_COMP_UNKNOWN otherwise
*/
static sbd_comp_type_t
get_node_type(sbd_board_t *sbp, dev_info_t *dip, int *unitp)
{
int idx, unit;
sbd_handle_t *hp;
sbdp_handle_t *hdp;
char otype[OBP_MAXDRVNAME];
int otypelen;
ASSERT(sbp);
if (unitp)
*unitp = -1;
hp = MACHBD2HD(sbp);
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdp_get_board_num(hdp, dip) != sbp->sb_num) {
sbd_release_sbdp_handle(hdp);
return (SBD_COMP_UNKNOWN);
}
/*
* sbdp_get_unit_num will return (-1) for cmp as there
* is no "device_type" property associated with cmp.
* Therefore we will just skip getting unit number for
* cmp. Callers of this function need to check the
* value set in unitp before using it to dereference
* an array.
*/
if (strcmp(ddi_node_name(dip), "cmp") == 0) {
sbd_release_sbdp_handle(hdp);
return (SBD_COMP_CMP);
}
otypelen = sizeof (otype);
if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
OBP_DEVICETYPE, (caddr_t)otype, &otypelen)) {
sbd_release_sbdp_handle(hdp);
return (SBD_COMP_UNKNOWN);
}
idx = sbd_otype_to_idx(otype);
if (SBD_COMP(idx) == SBD_COMP_UNKNOWN) {
sbd_release_sbdp_handle(hdp);
return (SBD_COMP_UNKNOWN);
}
unit = sbdp_get_unit_num(hdp, dip);
if (unit == -1) {
cmn_err(CE_WARN,
"get_node_type: %s unit fail %p", otype, (void *)dip);
sbd_release_sbdp_handle(hdp);
return (SBD_COMP_UNKNOWN);
}
sbd_release_sbdp_handle(hdp);
if (unitp)
*unitp = unit;
return (SBD_COMP(idx));
}
typedef struct {
sbd_board_t *sbp;
int nmc;
int hold;
} walk_tree_t;
static int
sbd_setup_devlists(dev_info_t *dip, void *arg)
{
walk_tree_t *wp;
dev_info_t **devlist = NULL;
char *pathname = NULL;
sbd_mem_unit_t *mp;
static fn_t f = "sbd_setup_devlists";
sbd_board_t *sbp;
int unit;
sbd_comp_type_t nodetype;
ASSERT(dip);
wp = (walk_tree_t *)arg;
if (wp == NULL) {
PR_ALL("%s:bad arg\n", f);
return (DDI_WALK_TERMINATE);
}
sbp = wp->sbp;
nodetype = get_node_type(sbp, dip, &unit);
switch (nodetype) {
case SBD_COMP_CPU:
pathname = sbp->sb_cpupath[unit];
break;
case SBD_COMP_MEM:
pathname = sbp->sb_mempath[unit];
break;
case SBD_COMP_IO:
pathname = sbp->sb_iopath[unit];
break;
case SBD_COMP_CMP:
case SBD_COMP_UNKNOWN:
/*
* This dip is not of interest to us
*/
return (DDI_WALK_CONTINUE);
default:
ASSERT(0);
return (DDI_WALK_CONTINUE);
}
/*
* dip's parent is being held busy by ddi_walk_devs(),
* so dip doesn't have to be held while calling ddi_pathname()
*/
if (pathname) {
(void) ddi_pathname(dip, pathname);
}
devlist = sbp->sb_devlist[NIX(nodetype)];
/*
* The branch rooted at dip should already be held,
* unless we are dealing with a core of a CMP.
*/
ASSERT(sbd_is_cmp_child(dip) || e_ddi_branch_held(dip));
devlist[unit] = dip;
/*
* This test is required if multiple devices are considered
* as one. This is the case for memory-controller nodes.
*/
if (!SBD_DEV_IS_PRESENT(sbp, nodetype, unit)) {
sbp->sb_ndev++;
SBD_DEV_SET_PRESENT(sbp, nodetype, unit);
}
if (nodetype == SBD_COMP_MEM) {
mp = SBD_GET_BOARD_MEMUNIT(sbp, unit);
ASSERT(wp->nmc < SBD_NUM_MC_PER_BOARD);
mp->sbm_dip[wp->nmc++] = dip;
}
return (DDI_WALK_CONTINUE);
}
/*
* This routine is used to construct the memory devlist.
* In Starcat and Serengeti platforms, a system board can contain up to
* four memory controllers (MC). The MCs have been programmed by POST for
* optimum memory interleaving amongst their peers on the same board.
* This DR driver does not support deinterleaving. Therefore, the smallest
* unit of memory that can be manipulated by this driver is all of the
* memory on a board. Because of this restriction, a board's memory devlist
* is populated with only one of the four (possible) MC dnodes on that board.
* Care must be taken to ensure that the selected MC dnode represents the
* lowest physical address to which memory on the board will respond to.
* This is required in order to preserve the semantics of
* sbdp_get_base_physaddr() when applied to a MC dnode stored in the
* memory devlist.
*/
static void
sbd_init_mem_devlists(sbd_board_t *sbp)
{
dev_info_t **devlist;
sbd_mem_unit_t *mp;
dev_info_t *mc_dip;
sbdp_handle_t *hdp;
uint64_t mc_pa, lowest_pa;
int i;
sbd_handle_t *hp = MACHBD2HD(sbp);
devlist = sbp->sb_devlist[NIX(SBD_COMP_MEM)];
mp = SBD_GET_BOARD_MEMUNIT(sbp, 0);
mc_dip = mp->sbm_dip[0];
if (mc_dip == NULL)
return; /* No MC dips found for this board */
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdphw_get_base_physaddr(hdp, mc_dip, &mc_pa)) {
/* TODO: log complaint about dnode */
pretend_no_mem:
/*
* We are here because sbdphw_get_base_physaddr() failed.
* Although it is very unlikely to happen, it did. Lucky us.
* Since we can no longer examine _all_ of the MCs on this
* board to determine which one is programmed to the lowest
* physical address, we cannot involve any of the MCs on
* this board in DR operations. To ensure this, we pretend
* that this board does not contain any memory.
*
* Paranoia: clear the dev_present mask.
*/
if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, 0)) {
ASSERT(sbp->sb_ndev != 0);
SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_MEM, 0);
sbp->sb_ndev--;
}
for (i = 0; i < SBD_NUM_MC_PER_BOARD; i++) {
mp->sbm_dip[i] = NULL;
}
sbd_release_sbdp_handle(hdp);
return;
}
/* assume this one will win. */
devlist[0] = mc_dip;
mp->sbm_cm.sbdev_dip = mc_dip;
lowest_pa = mc_pa;
/*
* We know the base physical address of one of the MC devices. Now
* we will enumerate through all of the remaining MC devices on
* the board to find which of them is programmed to the lowest
* physical address.
*/
for (i = 1; i < SBD_NUM_MC_PER_BOARD; i++) {
mc_dip = mp->sbm_dip[i];
if (mc_dip == NULL) {
break;
}
if (sbdphw_get_base_physaddr(hdp, mc_dip, &mc_pa)) {
cmn_err(CE_NOTE, "No mem on board %d unit %d",
sbp->sb_num, i);
break;
}
if (mc_pa < lowest_pa) {
mp->sbm_cm.sbdev_dip = mc_dip;
devlist[0] = mc_dip;
lowest_pa = mc_pa;
}
}
sbd_release_sbdp_handle(hdp);
}
static int
sbd_name_to_idx(char *name)
{
int idx;
for (idx = 0; SBD_COMP(idx) != SBD_COMP_UNKNOWN; idx++) {
if (strcmp(name, SBD_DEVNAME(idx)) == 0) {
break;
}
}
return (idx);
}
static int
sbd_otype_to_idx(char *otype)
{
int idx;
for (idx = 0; SBD_COMP(idx) != SBD_COMP_UNKNOWN; idx++) {
if (strcmp(otype, SBD_OTYPE(idx)) == 0) {
break;
}
}
return (idx);
}
static int
sbd_init_devlists(sbd_board_t *sbp)
{
int i;
sbd_dev_unit_t *dp;
sbd_mem_unit_t *mp;
walk_tree_t *wp, walk = {0};
dev_info_t *pdip;
static fn_t f = "sbd_init_devlists";
PR_ALL("%s (board = %d)...\n", f, sbp->sb_num);
wp = &walk;
SBD_DEVS_DISCONNECT(sbp, (uint_t)-1);
/*
* Clear out old entries, if any.
*/
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
sbp->sb_devlist[NIX(SBD_COMP_MEM)][i] = NULL;
dp = (sbd_dev_unit_t *)SBD_GET_BOARD_MEMUNIT(sbp, i);
dp->u_common.sbdev_sbp = sbp;
dp->u_common.sbdev_unum = i;
dp->u_common.sbdev_type = SBD_COMP_MEM;
}
mp = SBD_GET_BOARD_MEMUNIT(sbp, 0);
ASSERT(mp != NULL);
for (i = 0; i < SBD_NUM_MC_PER_BOARD; i++) {
mp->sbm_dip[i] = NULL;
}
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
sbp->sb_devlist[NIX(SBD_COMP_CPU)][i] = NULL;
dp = (sbd_dev_unit_t *)SBD_GET_BOARD_CPUUNIT(sbp, i);
dp->u_common.sbdev_sbp = sbp;
dp->u_common.sbdev_unum = i;
dp->u_common.sbdev_type = SBD_COMP_CPU;
}
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
sbp->sb_devlist[NIX(SBD_COMP_IO)][i] = NULL;
dp = (sbd_dev_unit_t *)SBD_GET_BOARD_IOUNIT(sbp, i);
dp->u_common.sbdev_sbp = sbp;
dp->u_common.sbdev_unum = i;
dp->u_common.sbdev_type = SBD_COMP_IO;
}
wp->sbp = sbp;
wp->nmc = 0;
sbp->sb_ndev = 0;
/*
* ddi_walk_devs() requires that topdip's parent be held.
*/
pdip = ddi_get_parent(sbp->sb_topdip);
if (pdip) {
ndi_hold_devi(pdip);
ndi_devi_enter(pdip, &i);
}
ddi_walk_devs(sbp->sb_topdip, sbd_setup_devlists, (void *) wp);
if (pdip) {
ndi_devi_exit(pdip, i);
ndi_rele_devi(pdip);
}
/*
* There is no point checking all the components if there
* are no devices.
*/
if (sbp->sb_ndev == 0) {
sbp->sb_memaccess_ok = 0;
return (sbp->sb_ndev);
}
/*
* Initialize cpu sections before calling sbd_init_mem_devlists
* which will access the mmus.
*/
sbp->sb_memaccess_ok = 1;
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, i)) {
sbd_init_cpu_unit(sbp, i);
if (sbd_connect_cpu(sbp, i)) {
SBD_SET_ERR(HD2MACHERR(MACHBD2HD(sbp)),
ESBD_CPUSTART);
}
}
}
if (sbp->sb_memaccess_ok) {
sbd_init_mem_devlists(sbp);
} else {
cmn_err(CE_WARN, "unable to access memory on board %d",
sbp->sb_num);
}
return (sbp->sb_ndev);
}
static void
sbd_init_cpu_unit(sbd_board_t *sbp, int unit)
{
sbd_istate_t new_state;
sbd_cpu_unit_t *cp;
int cpuid;
dev_info_t *dip;
sbdp_handle_t *hdp;
sbd_handle_t *hp = MACHBD2HD(sbp);
extern kmutex_t cpu_lock;
if (SBD_DEV_IS_ATTACHED(sbp, SBD_COMP_CPU, unit)) {
new_state = SBD_STATE_CONFIGURED;
} else if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, unit)) {
new_state = SBD_STATE_CONNECTED;
} else {
new_state = SBD_STATE_EMPTY;
}
dip = sbp->sb_devlist[NIX(SBD_COMP_CPU)][unit];
cp = SBD_GET_BOARD_CPUUNIT(sbp, unit);
hdp = sbd_get_sbdp_handle(sbp, hp);
cpuid = sbdp_get_cpuid(hdp, dip);
cp->sbc_cpu_id = cpuid;
if (&sbdp_cpu_get_impl)
cp->sbc_cpu_impl = sbdp_cpu_get_impl(hdp, dip);
else
cp->sbc_cpu_impl = -1;
mutex_enter(&cpu_lock);
if ((cpuid >= 0) && cpu[cpuid])
cp->sbc_cpu_flags = cpu[cpuid]->cpu_flags;
else
cp->sbc_cpu_flags = CPU_OFFLINE | CPU_POWEROFF;
mutex_exit(&cpu_lock);
sbd_cpu_set_prop(cp, dip);
cp->sbc_cm.sbdev_cond = sbd_get_comp_cond(dip);
sbd_release_sbdp_handle(hdp);
/*
* Any changes to the cpu should be performed above
* this call to ensure the cpu is fully initialized
* before transitioning to the new state.
*/
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, unit, new_state);
}
/*
* Only do work if called to operate on an entire board
* which doesn't already have components present.
*/
static void
sbd_connect(sbd_handle_t *hp)
{
sbd_board_t *sbp;
sbderror_t *ep;
static fn_t f = "sbd_connect";
sbp = SBDH2BD(hp->h_sbd);
PR_ALL("%s board %d\n", f, sbp->sb_num);
ep = HD2MACHERR(hp);
if (SBD_DEVS_PRESENT(sbp)) {
/*
* Board already has devices present.
*/
PR_ALL("%s: devices already present (0x%x)\n",
f, SBD_DEVS_PRESENT(sbp));
SBD_SET_ERRNO(ep, EINVAL);
return;
}
if (sbd_init_devlists(sbp) == 0) {
cmn_err(CE_WARN, "%s: no devices present on board %d",
f, sbp->sb_num);
SBD_SET_ERR(ep, ESBD_NODEV);
return;
} else {
int i;
/*
* Initialize mem-unit section of board structure.
*/
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++)
if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, i))
sbd_init_mem_unit(sbp, i, SBD_HD2ERR(hp));
/*
* Initialize sb_io sections.
*/
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++)
if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_IO, i))
sbd_init_io_unit(sbp, i);
SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONNECTED);
sbp->sb_rstate = SBD_STAT_CONNECTED;
sbp->sb_ostate = SBD_STAT_UNCONFIGURED;
(void) drv_getparm(TIME, (void *)&sbp->sb_time);
SBD_INJECT_ERR(SBD_CONNECT_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESBD_INTERNAL, NULL);
}
}
static int
sbd_disconnect(sbd_handle_t *hp)
{
int i;
sbd_devset_t devset;
sbd_board_t *sbp;
static fn_t f = "sbd_disconnect it";
PR_ALL("%s ...\n", f);
sbp = SBDH2BD(hp->h_sbd);
/*
* Only devices which are present, but
* unattached can be disconnected.
*/
devset = HD2MACHHD(hp)->sh_devset & SBD_DEVS_PRESENT(sbp) &
SBD_DEVS_UNATTACHED(sbp);
ASSERT((SBD_DEVS_ATTACHED(sbp) & devset) == 0);
/*
* Update per-device state transitions.
*/
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++)
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, i)) {
if (sbd_disconnect_mem(hp, i) == 0) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, i,
SBD_STATE_EMPTY);
SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_MEM, i);
}
}
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++)
if (DEVSET_IN_SET(devset, SBD_COMP_CPU, i)) {
if (sbd_disconnect_cpu(hp, i) == 0) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, i,
SBD_STATE_EMPTY);
SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_CPU, i);
}
}
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++)
if (DEVSET_IN_SET(devset, SBD_COMP_IO, i)) {
if (sbd_disconnect_io(hp, i) == 0) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_IO, i,
SBD_STATE_EMPTY);
SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_IO, i);
}
}
/*
* 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 (SBD_DEVS_PRESENT(sbp) == 0) {
SBD_BOARD_TRANSITION(sbp, SBD_STATE_OCCUPIED);
sbp->sb_rstate = SBD_STAT_DISCONNECTED;
sbp->sb_ostate = SBD_STAT_UNCONFIGURED;
(void) drv_getparm(TIME, (void *)&sbp->sb_time);
SBD_INJECT_ERR(SBD_DISCONNECT_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESBD_INTERNAL, NULL);
return (0);
} else {
cmn_err(CE_WARN, "%s: could not disconnect devices on board %d",
f, sbp->sb_num);
return (-1);
}
}
static void
sbd_test_board(sbd_handle_t *hp)
{
sbd_board_t *sbp;
sbdp_handle_t *hdp;
sbp = SBDH2BD(hp->h_sbd);
PR_ALL("sbd_test_board: board %d\n", sbp->sb_num);
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdp_test_board(hdp, &hp->h_opts) != 0) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_GET_PERR(hdp->h_err, ep);
}
SBD_INJECT_ERR(SBD_TEST_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESBD_INTERNAL, NULL);
sbd_release_sbdp_handle(hdp);
}
static void
sbd_assign_board(sbd_handle_t *hp)
{
sbd_board_t *sbp;
sbdp_handle_t *hdp;
sbp = SBDH2BD(hp->h_sbd);
PR_ALL("sbd_assign_board: board %d\n", sbp->sb_num);
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdp_assign_board(hdp) != 0) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_GET_PERR(hdp->h_err, ep);
}
SBD_INJECT_ERR(SBD_ASSIGN_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESBD_INTERNAL, NULL);
sbd_release_sbdp_handle(hdp);
}
static void
sbd_unassign_board(sbd_handle_t *hp)
{
sbd_board_t *sbp;
sbdp_handle_t *hdp;
sbp = SBDH2BD(hp->h_sbd);
PR_ALL("sbd_unassign_board: board %d\n", sbp->sb_num);
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdp_unassign_board(hdp) != 0) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_GET_PERR(hdp->h_err, ep);
}
SBD_INJECT_ERR(SBD_ASSIGN_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESBD_INTERNAL, NULL);
sbd_release_sbdp_handle(hdp);
}
static void
sbd_poweron_board(sbd_handle_t *hp)
{
sbd_board_t *sbp;
sbdp_handle_t *hdp;
sbp = SBDH2BD(hp->h_sbd);
PR_ALL("sbd_poweron_board: %d\n", sbp->sb_num);
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdp_poweron_board(hdp) != 0) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_GET_PERR(hdp->h_err, ep);
}
SBD_INJECT_ERR(SBD_POWERON_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESBD_INTERNAL, NULL);
sbd_release_sbdp_handle(hdp);
}
static void
sbd_poweroff_board(sbd_handle_t *hp)
{
sbd_board_t *sbp;
sbdp_handle_t *hdp;
sbp = SBDH2BD(hp->h_sbd);
PR_ALL("sbd_poweroff_board: %d\n", sbp->sb_num);
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdp_poweroff_board(hdp) != 0) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_GET_PERR(hdp->h_err, ep);
}
SBD_INJECT_ERR(SBD_POWEROFF_BOARD_PSEUDO_ERR, hp->h_err, EIO,
ESBD_INTERNAL, NULL);
sbd_release_sbdp_handle(hdp);
}
/*
* Return a list of the dip's of devices that are
* either present and attached, or present only but
* not yet attached for the given board.
*/
sbd_devlist_t *
sbd_get_devlist(sbd_handle_t *hp, sbd_board_t *sbp, sbd_comp_type_t nodetype,
int max_units, uint_t uset, int *count, int present_only)
{
int i, ix;
sbd_devlist_t *ret_devlist;
dev_info_t **devlist;
sbdp_handle_t *hdp;
*count = 0;
ret_devlist = GETSTRUCT(sbd_devlist_t, max_units);
devlist = sbp->sb_devlist[NIX(nodetype)];
/*
* Turn into binary value since we're going
* to be using XOR for a comparison.
* if (present_only) then
* dev must be PRESENT, but NOT ATTACHED.
* else
* dev must be PRESENT AND ATTACHED.
* endif
*/
if (present_only)
present_only = 1;
hdp = sbd_get_sbdp_handle(sbp, hp);
for (i = ix = 0; (i < max_units) && uset; i++) {
int ut, is_present, is_attached;
dev_info_t *dip;
sbderror_t *ep = SBD_HD2ERR(hp);
int nunits, distance, j;
/*
* For CMPs, we would like to perform DR operation on
* all the cores before moving onto the next chip.
* Therefore, when constructing the devlist, we process
* all the cores together.
*/
if (nodetype == SBD_COMP_CPU) {
/*
* Number of units to process in the inner loop
*/
nunits = MAX_CORES_PER_CMP;
/*
* The distance between the units in the
* board's sb_devlist structure.
*/
distance = MAX_CMP_UNITS_PER_BOARD;
} else {
nunits = 1;
distance = 0;
}
for (j = 0; j < nunits; j++) {
if ((dip = devlist[i + j * distance]) == NULL)
continue;
ut = sbdp_get_unit_num(hdp, dip);
if (ut == -1) {
SBD_GET_PERR(hdp->h_err, ep);
PR_ALL("sbd_get_devlist bad unit %d"
" code %d errno %d",
i, ep->e_code, ep->e_errno);
}
if ((uset & (1 << ut)) == 0)
continue;
uset &= ~(1 << ut);
is_present = SBD_DEV_IS_PRESENT(sbp, nodetype, ut) ?
1 : 0;
is_attached = SBD_DEV_IS_ATTACHED(sbp, nodetype, ut) ?
1 : 0;
if (is_present && (present_only ^ is_attached)) {
ret_devlist[ix].dv_dip = dip;
sbd_init_err(&ret_devlist[ix].dv_error);
ix++;
}
}
}
sbd_release_sbdp_handle(hdp);
if ((*count = ix) == 0) {
FREESTRUCT(ret_devlist, sbd_devlist_t, max_units);
ret_devlist = NULL;
}
return (ret_devlist);
}
static sbd_devlist_t *
sbd_get_attach_devlist(sbd_handle_t *hp, int32_t *devnump, int32_t pass)
{
sbd_board_t *sbp;
uint_t uset;
sbd_devset_t devset;
sbd_devlist_t *attach_devlist;
static int next_pass = 1;
static fn_t f = "sbd_get_attach_devlist";
PR_ALL("%s (pass = %d)...\n", f, pass);
sbp = SBDH2BD(hp->h_sbd);
devset = HD2MACHHD(hp)->sh_devset;
*devnump = 0;
attach_devlist = NULL;
/*
* We switch on next_pass for the cases where a board
* does not contain a particular type of component.
* In these situations we don't want to return NULL
* prematurely. We need to check other devices and
* we don't want to check the same type multiple times.
* For example, if there were no cpus, then on pass 1
* we would drop through and return the memory nodes.
* However, on pass 2 we would switch back to the memory
* nodes thereby returning them twice! Using next_pass
* forces us down to the end (or next item).
*/
if (pass == 1)
next_pass = 1;
switch (next_pass) {
case 1:
if (DEVSET_IN_SET(devset, SBD_COMP_CPU, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_CPU);
attach_devlist = sbd_get_devlist(hp, sbp, SBD_COMP_CPU,
MAX_CPU_UNITS_PER_BOARD,
uset, devnump, 1);
DEVSET_DEL(devset, SBD_COMP_CPU, DEVSET_ANYUNIT);
if (!devset || attach_devlist) {
next_pass = 2;
return (attach_devlist);
}
/*
* If the caller is interested in the entire
* board, but there aren't any cpus, then just
* fall through to check for the next component.
*/
}
/*FALLTHROUGH*/
case 2:
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_MEM);
attach_devlist = sbd_get_devlist(hp, sbp, SBD_COMP_MEM,
MAX_MEM_UNITS_PER_BOARD,
uset, devnump, 1);
DEVSET_DEL(devset, SBD_COMP_MEM, DEVSET_ANYUNIT);
if (!devset || attach_devlist) {
next_pass = 3;
return (attach_devlist);
}
/*
* If the caller is interested in the entire
* board, but there isn't any memory, then
* just fall through to next component.
*/
}
/*FALLTHROUGH*/
case 3:
next_pass = -1;
if (DEVSET_IN_SET(devset, SBD_COMP_IO, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_IO);
attach_devlist = sbd_get_devlist(hp, sbp, SBD_COMP_IO,
MAX_IO_UNITS_PER_BOARD,
uset, devnump, 1);
DEVSET_DEL(devset, SBD_COMP_IO, DEVSET_ANYUNIT);
if (!devset || attach_devlist) {
next_pass = 4;
return (attach_devlist);
}
}
/*FALLTHROUGH*/
default:
*devnump = 0;
return (NULL);
}
/*NOTREACHED*/
}
static int
sbd_pre_attach_devlist(sbd_handle_t *hp, sbd_devlist_t *devlist,
int32_t devnum)
{
int max_units = 0, rv = 0;
sbd_comp_type_t nodetype;
static fn_t f = "sbd_pre_attach_devlist";
/*
* In this driver, all entries in a devlist[] are
* of the same nodetype.
*/
nodetype = sbd_get_devtype(hp, devlist->dv_dip);
PR_ALL("%s (nt = %s(%d), num = %d)...\n",
f, sbd_ct_str[(int)nodetype], (int)nodetype, devnum);
switch (nodetype) {
case SBD_COMP_MEM:
max_units = MAX_MEM_UNITS_PER_BOARD;
rv = sbd_pre_attach_mem(hp, devlist, devnum);
break;
case SBD_COMP_CPU:
max_units = MAX_CPU_UNITS_PER_BOARD;
rv = sbd_pre_attach_cpu(hp, devlist, devnum);
break;
case SBD_COMP_IO:
max_units = MAX_IO_UNITS_PER_BOARD;
break;
default:
rv = -1;
break;
}
if (rv && max_units) {
int i;
/*
* Need to clean up devlist
* if pre-op is going to fail.
*/
for (i = 0; i < max_units; i++) {
if (SBD_GET_ERRSTR(&devlist[i].dv_error)) {
SBD_FREE_ERR(&devlist[i].dv_error);
} else {
break;
}
}
FREESTRUCT(devlist, sbd_devlist_t, max_units);
}
/*
* If an error occurred, return "continue"
* indication so that we can continue attaching
* as much as possible.
*/
return (rv ? -1 : 0);
}
static int
sbd_post_attach_devlist(sbd_handle_t *hp, sbd_devlist_t *devlist,
int32_t devnum)
{
int i, max_units = 0, rv = 0;
sbd_devset_t devs_unattached, devs_present;
sbd_comp_type_t nodetype;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbdp_handle_t *hdp;
static fn_t f = "sbd_post_attach_devlist";
sbp = SBDH2BD(hp->h_sbd);
nodetype = sbd_get_devtype(hp, devlist->dv_dip);
PR_ALL("%s (nt = %s(%d), num = %d)...\n",
f, sbd_ct_str[(int)nodetype], (int)nodetype, devnum);
hdp = sbd_get_sbdp_handle(sbp, hp);
/*
* Need to free up devlist[] created earlier in
* sbd_get_attach_devlist().
*/
switch (nodetype) {
case SBD_COMP_CPU:
max_units = MAX_CPU_UNITS_PER_BOARD;
rv = sbd_post_attach_cpu(hp, devlist, devnum);
break;
case SBD_COMP_MEM:
max_units = MAX_MEM_UNITS_PER_BOARD;
rv = sbd_post_attach_mem(hp, devlist, devnum);
break;
case SBD_COMP_IO:
max_units = MAX_IO_UNITS_PER_BOARD;
break;
default:
rv = -1;
break;
}
for (i = 0; i < devnum; i++) {
int unit;
dev_info_t *dip;
sbderror_t *ep;
ep = &devlist[i].dv_error;
if (sbd_set_err_in_hdl(hp, ep) == 0)
continue;
dip = devlist[i].dv_dip;
nodetype = sbd_get_devtype(hp, dip);
unit = sbdp_get_unit_num(hdp, dip);
if (unit == -1) {
SBD_GET_PERR(hdp->h_err, ep);
continue;
}
unit = sbd_check_unit_attached(sbp, dip, unit, nodetype, ep);
if (unit == -1) {
PR_ALL("%s: ERROR (nt=%s, b=%d, u=%d) not attached\n",
f, sbd_ct_str[(int)nodetype], sbp->sb_num, i);
continue;
}
SBD_DEV_SET_ATTACHED(sbp, nodetype, unit);
SBD_DEVICE_TRANSITION(sbp, nodetype, unit,
SBD_STATE_CONFIGURED);
}
sbd_release_sbdp_handle(hdp);
if (rv) {
PR_ALL("%s: errno %d, ecode %d during attach\n",
f, SBD_GET_ERRNO(SBD_HD2ERR(hp)),
SBD_GET_ERR(HD2MACHERR(hp)));
}
devs_present = SBD_DEVS_PRESENT(sbp);
devs_unattached = SBD_DEVS_UNATTACHED(sbp);
switch (SBD_BOARD_STATE(sbp)) {
case SBD_STATE_CONNECTED:
case SBD_STATE_UNCONFIGURED:
ASSERT(devs_present);
if (devs_unattached == 0) {
/*
* All devices finally attached.
*/
SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONFIGURED);
sbp->sb_rstate = SBD_STAT_CONNECTED;
sbp->sb_ostate = SBD_STAT_CONFIGURED;
} else if (devs_present != devs_unattached) {
/*
* Only some devices are fully attached.
*/
SBD_BOARD_TRANSITION(sbp, SBD_STATE_PARTIAL);
sbp->sb_rstate = SBD_STAT_CONNECTED;
sbp->sb_ostate = SBD_STAT_UNCONFIGURED;
}
(void) drv_getparm(TIME, (void *)&sbp->sb_time);
break;
case SBD_STATE_PARTIAL:
ASSERT(devs_present);
/*
* All devices finally attached.
*/
if (devs_unattached == 0) {
SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONFIGURED);
sbp->sb_rstate = SBD_STAT_CONNECTED;
sbp->sb_ostate = SBD_STAT_CONFIGURED;
(void) drv_getparm(TIME, (void *)&sbp->sb_time);
}
break;
default:
break;
}
if (max_units && devlist) {
int i;
for (i = 0; i < max_units; i++) {
if (SBD_GET_ERRSTR(&devlist[i].dv_error)) {
SBD_FREE_ERR(&devlist[i].dv_error);
} else {
break;
}
}
FREESTRUCT(devlist, sbd_devlist_t, max_units);
}
/*
* Our policy is to attach all components that are
* possible, thus we always return "success" on the
* pre and post operations.
*/
return (0);
}
/*
* We only need to "release" cpu and memory devices.
*/
static sbd_devlist_t *
sbd_get_release_devlist(sbd_handle_t *hp, int32_t *devnump, int32_t pass)
{
sbd_board_t *sbp;
uint_t uset;
sbd_devset_t devset;
sbd_devlist_t *release_devlist;
static int next_pass = 1;
static fn_t f = "sbd_get_release_devlist";
PR_ALL("%s (pass = %d)...\n", f, pass);
sbp = SBDH2BD(hp->h_sbd);
devset = HD2MACHHD(hp)->sh_devset;
*devnump = 0;
release_devlist = NULL;
/*
* We switch on next_pass for the cases where a board
* does not contain a particular type of component.
* In these situations we don't want to return NULL
* prematurely. We need to check other devices and
* we don't want to check the same type multiple times.
* For example, if there were no cpus, then on pass 1
* we would drop through and return the memory nodes.
* However, on pass 2 we would switch back to the memory
* nodes thereby returning them twice! Using next_pass
* forces us down to the end (or next item).
*/
if (pass == 1)
next_pass = 1;
switch (next_pass) {
case 1:
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_MEM);
release_devlist = sbd_get_devlist(hp, sbp,
SBD_COMP_MEM,
MAX_MEM_UNITS_PER_BOARD,
uset, devnump, 0);
DEVSET_DEL(devset, SBD_COMP_MEM, DEVSET_ANYUNIT);
if (!devset || release_devlist) {
next_pass = 2;
return (release_devlist);
}
/*
* If the caller is interested in the entire
* board, but there isn't any memory, then
* just fall through to next component.
*/
}
/*FALLTHROUGH*/
case 2:
if (DEVSET_IN_SET(devset, SBD_COMP_CPU, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_CPU);
release_devlist = sbd_get_devlist(hp, sbp,
SBD_COMP_CPU,
MAX_CPU_UNITS_PER_BOARD,
uset, devnump, 0);
DEVSET_DEL(devset, SBD_COMP_CPU, DEVSET_ANYUNIT);
if (!devset || release_devlist) {
next_pass = 3;
return (release_devlist);
}
/*
* If the caller is interested in the entire
* board, but there aren't any cpus, then just
* fall through to check for the next component.
*/
}
/*FALLTHROUGH*/
case 3:
next_pass = -1;
if (DEVSET_IN_SET(devset, SBD_COMP_IO, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_IO);
release_devlist = sbd_get_devlist(hp, sbp,
SBD_COMP_IO,
MAX_IO_UNITS_PER_BOARD,
uset, devnump, 0);
DEVSET_DEL(devset, SBD_COMP_IO, DEVSET_ANYUNIT);
if (!devset || release_devlist) {
next_pass = 4;
return (release_devlist);
}
}
/*FALLTHROUGH*/
default:
*devnump = 0;
return (NULL);
}
/*NOTREACHED*/
}
static int
sbd_pre_release_devlist(sbd_handle_t *hp, sbd_devlist_t *devlist,
int32_t devnum)
{
int max_units = 0, rv = 0;
sbd_comp_type_t nodetype;
static fn_t f = "sbd_pre_release_devlist";
nodetype = sbd_get_devtype(hp, devlist->dv_dip);
PR_ALL("%s (nt = %s(%d), num = %d)...\n",
f, sbd_ct_str[(int)nodetype], (int)nodetype, devnum);
switch (nodetype) {
case SBD_COMP_CPU: {
int i, mem_present = 0;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbd_devset_t devset;
sbd_priv_handle_t *shp = HD2MACHHD(hp);
max_units = MAX_CPU_UNITS_PER_BOARD;
devset = shp->sh_orig_devset;
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
/*
* if client also requested to unconfigure memory
* the we allow the operation. Therefore
* we need to warranty that memory gets unconfig
* before cpus
*/
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, i)) {
continue;
}
if (SBD_DEV_IS_ATTACHED(sbp, SBD_COMP_MEM, i)) {
mem_present = 1;
break;
}
}
if (mem_present) {
sbderror_t *ep = SBD_HD2ERR(hp);
SBD_SET_ERR(ep, ESBD_MEMONLINE);
SBD_SET_ERRSTR(ep, sbp->sb_mempath[i]);
rv = -1;
} else {
rv = sbd_pre_release_cpu(hp, devlist, devnum);
}
break;
}
case SBD_COMP_MEM:
max_units = MAX_MEM_UNITS_PER_BOARD;
rv = sbd_pre_release_mem(hp, devlist, devnum);
break;
case SBD_COMP_IO:
max_units = MAX_IO_UNITS_PER_BOARD;
rv = sbd_pre_release_io(hp, devlist, devnum);
break;
default:
rv = -1;
break;
}
if (rv && max_units) {
int i;
/*
* the individual pre_release component routines should
* have set the error in the handle. No need to set it
* here
*
* Need to clean up dynamically allocated devlist
* if pre-op is going to fail.
*/
for (i = 0; i < max_units; i++) {
if (SBD_GET_ERRSTR(&devlist[i].dv_error)) {
SBD_FREE_ERR(&devlist[i].dv_error);
} else {
break;
}
}
FREESTRUCT(devlist, sbd_devlist_t, max_units);
}
return (rv ? -1 : 0);
}
static int
sbd_post_release_devlist(sbd_handle_t *hp, sbd_devlist_t *devlist,
int32_t devnum)
{
int i, max_units = 0;
sbd_comp_type_t nodetype;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbdp_handle_t *hdp;
sbd_error_t *spe;
static fn_t f = "sbd_post_release_devlist";
nodetype = sbd_get_devtype(hp, devlist->dv_dip);
ASSERT(nodetype >= SBD_COMP_CPU && nodetype <= SBD_COMP_IO);
PR_ALL("%s (nt = %s(%d), num = %d)...\n",
f, sbd_ct_str[(int)nodetype], (int)nodetype, devnum);
/*
* Need to free up devlist[] created earlier in
* sbd_get_release_devlist().
*/
switch (nodetype) {
case SBD_COMP_CPU:
max_units = MAX_CPU_UNITS_PER_BOARD;
break;
case SBD_COMP_MEM:
max_units = MAX_MEM_UNITS_PER_BOARD;
break;
case SBD_COMP_IO:
/*
* Need to check if specific I/O is referenced and
* fail post-op.
*/
if (sbd_check_io_refs(hp, devlist, devnum) > 0) {
PR_IO("%s: error - I/O devices ref'd\n", f);
}
max_units = MAX_IO_UNITS_PER_BOARD;
break;
default:
{
cmn_err(CE_WARN, "%s: invalid nodetype (%d)",
f, (int)nodetype);
SBD_SET_ERR(HD2MACHERR(hp), ESBD_INVAL);
}
break;
}
hdp = sbd_get_sbdp_handle(sbp, hp);
spe = hdp->h_err;
for (i = 0; i < devnum; i++) {
int unit;
sbderror_t *ep;
ep = &devlist[i].dv_error;
if (sbd_set_err_in_hdl(hp, ep) == 0) {
continue;
}
unit = sbdp_get_unit_num(hdp, devlist[i].dv_dip);
if (unit == -1) {
SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
PR_ALL("%s bad unit num: %d code %d",
f, unit, spe->e_code);
continue;
}
}
sbd_release_sbdp_handle(hdp);
if (SBD_GET_ERRNO(SBD_HD2ERR(hp))) {
PR_ALL("%s: errno %d, ecode %d during release\n",
f, SBD_GET_ERRNO(SBD_HD2ERR(hp)),
SBD_GET_ERR(SBD_HD2ERR(hp)));
}
if (max_units && devlist) {
int i;
for (i = 0; i < max_units; i++) {
if (SBD_GET_ERRSTR(&devlist[i].dv_error)) {
SBD_FREE_ERR(&devlist[i].dv_error);
} else {
break;
}
}
FREESTRUCT(devlist, sbd_devlist_t, max_units);
}
return (SBD_GET_ERRNO(SBD_HD2ERR(hp)) ? -1 : 0);
}
static void
sbd_release_dev_done(sbd_board_t *sbp, sbd_comp_type_t nodetype, int unit)
{
SBD_DEV_SET_UNREFERENCED(sbp, nodetype, unit);
SBD_DEVICE_TRANSITION(sbp, nodetype, unit, SBD_STATE_UNREFERENCED);
}
static void
sbd_release_done(sbd_handle_t *hp, sbd_comp_type_t nodetype, dev_info_t *dip)
{
int unit;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbderror_t *ep;
static fn_t f = "sbd_release_done";
sbdp_handle_t *hdp;
PR_ALL("%s...\n", f);
hdp = sbd_get_sbdp_handle(sbp, hp);
ep = SBD_HD2ERR(hp);
if ((unit = sbdp_get_unit_num(hdp, dip)) < 0) {
cmn_err(CE_WARN,
"sbd:%s: unable to get unit for dip (0x%p)",
f, (void *)dip);
SBD_GET_PERR(hdp->h_err, ep);
sbd_release_sbdp_handle(hdp);
return;
}
sbd_release_sbdp_handle(hdp);
/*
* Transfer the device which just completed its release
* to the UNREFERENCED state.
*/
switch (nodetype) {
case SBD_COMP_MEM:
sbd_release_mem_done((void *)hp, unit);
break;
default:
sbd_release_dev_done(sbp, nodetype, unit);
break;
}
/*
* If the entire board was released and all components
* unreferenced then transfer it to the UNREFERENCED state.
*/
if (SBD_DEVS_RELEASED(sbp) == SBD_DEVS_UNREFERENCED(sbp)) {
SBD_BOARD_TRANSITION(sbp, SBD_STATE_UNREFERENCED);
(void) drv_getparm(TIME, (void *)&sbp->sb_time);
}
}
static sbd_devlist_t *
sbd_get_detach_devlist(sbd_handle_t *hp, int32_t *devnump, int32_t pass)
{
sbd_board_t *sbp;
uint_t uset;
sbd_devset_t devset;
sbd_devlist_t *detach_devlist;
static int next_pass = 1;
static fn_t f = "sbd_get_detach_devlist";
PR_ALL("%s (pass = %d)...\n", f, pass);
sbp = SBDH2BD(hp->h_sbd);
devset = HD2MACHHD(hp)->sh_devset;
*devnump = 0;
detach_devlist = NULL;
/*
* We switch on next_pass for the cases where a board
* does not contain a particular type of component.
* In these situations we don't want to return NULL
* prematurely. We need to check other devices and
* we don't want to check the same type multiple times.
* For example, if there were no cpus, then on pass 1
* we would drop through and return the memory nodes.
* However, on pass 2 we would switch back to the memory
* nodes thereby returning them twice! Using next_pass
* forces us down to the end (or next item).
*/
if (pass == 1)
next_pass = 1;
switch (next_pass) {
case 1:
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_MEM);
detach_devlist = sbd_get_devlist(hp, sbp,
SBD_COMP_MEM,
MAX_MEM_UNITS_PER_BOARD,
uset, devnump, 0);
DEVSET_DEL(devset, SBD_COMP_MEM, DEVSET_ANYUNIT);
if (!devset || detach_devlist) {
next_pass = 2;
return (detach_devlist);
}
/*
* If the caller is interested in the entire
* board, but there isn't any memory, then
* just fall through to next component.
*/
}
/*FALLTHROUGH*/
case 2:
if (DEVSET_IN_SET(devset, SBD_COMP_CPU, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_CPU);
detach_devlist = sbd_get_devlist(hp, sbp,
SBD_COMP_CPU,
MAX_CPU_UNITS_PER_BOARD,
uset, devnump, 0);
DEVSET_DEL(devset, SBD_COMP_CPU, DEVSET_ANYUNIT);
if (!devset || detach_devlist) {
next_pass = 2;
return (detach_devlist);
}
/*
* If the caller is interested in the entire
* board, but there aren't any cpus, then just
* fall through to check for the next component.
*/
}
/*FALLTHROUGH*/
case 3:
next_pass = -1;
if (DEVSET_IN_SET(devset, SBD_COMP_IO, DEVSET_ANYUNIT)) {
uset = DEVSET_GET_UNITSET(devset, SBD_COMP_IO);
detach_devlist = sbd_get_devlist(hp, sbp,
SBD_COMP_IO,
MAX_IO_UNITS_PER_BOARD,
uset, devnump, 0);
DEVSET_DEL(devset, SBD_COMP_IO, DEVSET_ANYUNIT);
if (!devset || detach_devlist) {
next_pass = 4;
return (detach_devlist);
}
}
/*FALLTHROUGH*/
default:
*devnump = 0;
return (NULL);
}
/*NOTREACHED*/
}
static int
sbd_pre_detach_devlist(sbd_handle_t *hp, sbd_devlist_t *devlist,
int32_t devnum)
{
int rv = 0;
sbd_comp_type_t nodetype;
static fn_t f = "sbd_pre_detach_devlist";
nodetype = sbd_get_devtype(hp, devlist->dv_dip);
PR_ALL("%s (nt = %s(%d), num = %d)...\n",
f, sbd_ct_str[(int)nodetype], (int)nodetype, devnum);
switch (nodetype) {
case SBD_COMP_CPU:
rv = sbd_pre_detach_cpu(hp, devlist, devnum);
break;
case SBD_COMP_MEM:
rv = sbd_pre_detach_mem(hp, devlist, devnum);
break;
case SBD_COMP_IO:
rv = sbd_pre_detach_io(hp, devlist, devnum);
break;
default:
rv = -1;
break;
}
/*
* We want to continue attempting to detach
* other components.
*/
return (rv);
}
static int
sbd_post_detach_devlist(sbd_handle_t *hp, sbd_devlist_t *devlist,
int32_t devnum)
{
int i, max_units = 0, rv = 0;
sbd_comp_type_t nodetype;
sbd_board_t *sbp;
sbd_istate_t bstate;
static fn_t f = "sbd_post_detach_devlist";
sbdp_handle_t *hdp;
sbp = SBDH2BD(hp->h_sbd);
nodetype = sbd_get_devtype(hp, devlist->dv_dip);
hdp = sbd_get_sbdp_handle(sbp, hp);
PR_ALL("%s (nt = %s(%d), num = %d)...\n",
f, sbd_ct_str[(int)nodetype], (int)nodetype, devnum);
/*
* Need to free up devlist[] created earlier in
* sbd_get_detach_devlist().
*/
switch (nodetype) {
case SBD_COMP_CPU:
max_units = MAX_CPU_UNITS_PER_BOARD;
rv = sbd_post_detach_cpu(hp, devlist, devnum);
break;
case SBD_COMP_MEM:
max_units = MAX_MEM_UNITS_PER_BOARD;
rv = sbd_post_detach_mem(hp, devlist, devnum);
break;
case SBD_COMP_IO:
max_units = MAX_IO_UNITS_PER_BOARD;
rv = sbd_post_detach_io(hp, devlist, devnum);
break;
default:
rv = -1;
break;
}
for (i = 0; i < devnum; i++) {
int unit;
sbderror_t *ep;
dev_info_t *dip;
ep = &devlist[i].dv_error;
if (sbd_set_err_in_hdl(hp, ep) == 0)
continue;
dip = devlist[i].dv_dip;
unit = sbdp_get_unit_num(hdp, dip);
if (unit == -1) {
if (hp->h_flags & SBD_IOCTL_FLAG_FORCE)
continue;
else {
SBD_GET_PERR(hdp->h_err, ep);
break;
}
}
nodetype = sbd_get_devtype(hp, dip);
if (sbd_check_unit_attached(sbp, dip, unit, nodetype,
ep) >= 0) {
/*
* Device is still attached probably due
* to an error. Need to keep track of it.
*/
PR_ALL("%s: ERROR (nt=%s, b=%d, u=%d) not detached\n",
f, sbd_ct_str[(int)nodetype], sbp->sb_num,
unit);
continue;
}
SBD_DEV_CLR_ATTACHED(sbp, nodetype, unit);
SBD_DEV_CLR_RELEASED(sbp, nodetype, unit);
SBD_DEV_CLR_UNREFERENCED(sbp, nodetype, unit);
SBD_DEVICE_TRANSITION(sbp, nodetype, unit,
SBD_STATE_UNCONFIGURED);
}
sbd_release_sbdp_handle(hdp);
bstate = SBD_BOARD_STATE(sbp);
if (bstate != SBD_STATE_UNCONFIGURED) {
if (SBD_DEVS_PRESENT(sbp) == SBD_DEVS_UNATTACHED(sbp)) {
/*
* All devices are finally detached.
*/
SBD_BOARD_TRANSITION(sbp, SBD_STATE_UNCONFIGURED);
} else if ((SBD_BOARD_STATE(sbp) != SBD_STATE_PARTIAL) &&
SBD_DEVS_ATTACHED(sbp)) {
/*
* Some devices remain attached.
*/
SBD_BOARD_TRANSITION(sbp, SBD_STATE_PARTIAL);
}
}
if (rv) {
PR_ALL("%s: errno %d, ecode %d during detach\n",
f, SBD_GET_ERRNO(SBD_HD2ERR(hp)),
SBD_GET_ERR(HD2MACHERR(hp)));
}
if (max_units && devlist) {
int i;
for (i = 0; i < max_units; i++) {
if (SBD_GET_ERRSTR(&devlist[i].dv_error)) {
SBD_FREE_ERR(&devlist[i].dv_error);
} else {
break;
}
}
FREESTRUCT(devlist, sbd_devlist_t, max_units);
}
return (SBD_GET_ERRNO(SBD_HD2ERR(hp)) ? -1 : 0);
}
/*
* Return the unit number of the respective dip if
* it's found to be attached.
*/
static int
sbd_check_unit_attached(sbd_board_t *sbp, dev_info_t *dip, int unit,
sbd_comp_type_t nodetype, sbderror_t *ep)
{
int rv = -1;
processorid_t cpuid;
uint64_t basepa, endpa;
struct memlist *ml;
extern struct memlist *phys_install;
sbdp_handle_t *hdp;
sbd_handle_t *hp = MACHBD2HD(sbp);
static fn_t f = "sbd_check_unit_attached";
hdp = sbd_get_sbdp_handle(sbp, hp);
switch (nodetype) {
case SBD_COMP_CPU:
cpuid = sbdp_get_cpuid(hdp, dip);
if (cpuid < 0) {
break;
}
mutex_enter(&cpu_lock);
if (cpu_get(cpuid) != NULL)
rv = unit;
mutex_exit(&cpu_lock);
break;
case SBD_COMP_MEM:
if (sbdphw_get_base_physaddr(hdp, dip, &basepa)) {
break;
}
if (sbdp_get_mem_alignment(hdp, dip, &endpa)) {
cmn_err(CE_WARN, "%s sbdp_get_mem_alignment fail", f);
break;
}
basepa &= ~(endpa - 1);
endpa += basepa;
/*
* 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 = unit;
break;
case SBD_COMP_IO:
{
dev_info_t *tdip, *pdip;
tdip = dip;
/*
* ddi_walk_devs() requires that topdip's parent be held.
*/
pdip = ddi_get_parent(sbp->sb_topdip);
if (pdip) {
ndi_hold_devi(pdip);
ndi_devi_enter(pdip, &rv);
}
ddi_walk_devs(sbp->sb_topdip, sbd_check_io_attached,
(void *)&tdip);
if (pdip) {
ndi_devi_exit(pdip, rv);
ndi_rele_devi(pdip);
}
if (tdip == NULL)
rv = unit;
else
rv = -1;
break;
}
default:
PR_ALL("%s: unexpected nodetype(%d) for dip 0x%p\n",
f, nodetype, (void *)dip);
rv = -1;
break;
}
/*
* Save the error that sbdp sent us and report it
*/
if (rv == -1)
SBD_GET_PERR(hdp->h_err, ep);
sbd_release_sbdp_handle(hdp);
return (rv);
}
/*
* Return memhandle, if in fact, this memunit is the owner of
* a scheduled memory delete.
*/
int
sbd_get_memhandle(sbd_handle_t *hp, dev_info_t *dip, memhandle_t *mhp)
{
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbd_mem_unit_t *mp;
sbdp_handle_t *hdp;
int unit;
static fn_t f = "sbd_get_memhandle";
PR_MEM("%s...\n", f);
hdp = sbd_get_sbdp_handle(sbp, hp);
unit = sbdp_get_unit_num(hdp, dip);
if (unit == -1) {
SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
sbd_release_sbdp_handle(hdp);
return (-1);
}
sbd_release_sbdp_handle(hdp);
mp = SBD_GET_BOARD_MEMUNIT(sbp, unit);
if (mp->sbm_flags & SBD_MFLAG_RELOWNER) {
*mhp = mp->sbm_memhandle;
return (0);
} else {
SBD_SET_ERR(SBD_HD2ERR(hp), ESBD_INTERNAL);
SBD_SET_ERRSTR(SBD_HD2ERR(hp), sbp->sb_mempath[unit]);
return (-1);
}
/*NOTREACHED*/
}
static int
sbd_cpu_cnt(sbd_handle_t *hp, sbd_devset_t devset)
{
int c, cix;
sbd_board_t *sbp;
sbp = SBDH2BD(hp->h_sbd);
/*
* Only look for requested devices that are actually present.
*/
devset &= SBD_DEVS_PRESENT(sbp);
for (c = cix = 0; c < MAX_CMP_UNITS_PER_BOARD; c++) {
/*
* Index for core 1 , if exists.
* With the current implementation it is
* MAX_CMP_UNITS_PER_BOARD off from core 0.
* The calculation will need to change if
* the assumption is no longer true.
*/
int c1 = c + MAX_CMP_UNITS_PER_BOARD;
if (DEVSET_IN_SET(devset, SBD_COMP_CMP, c) == 0) {
continue;
}
/*
* Check to see if the dip(s) exist for this chip
*/
if ((sbp->sb_devlist[NIX(SBD_COMP_CMP)][c] == NULL) &&
(sbp->sb_devlist[NIX(SBD_COMP_CMP)][c1] == NULL))
continue;
cix++;
}
return (cix);
}
static int
sbd_mem_cnt(sbd_handle_t *hp, sbd_devset_t devset)
{
int i, ix;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
/*
* Only look for requested devices that are actually present.
*/
devset &= SBD_DEVS_PRESENT(sbp);
for (i = ix = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
dev_info_t *dip;
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, i) == 0) {
continue;
}
dip = sbp->sb_devlist[NIX(SBD_COMP_MEM)][i];
if (dip == NULL)
continue;
ix++;
}
return (ix);
}
/*
* NOTE: This routine is only partially smart about multiple
* mem-units. Need to make mem-status structure smart
* about them also.
*/
static int
sbd_mem_status(sbd_handle_t *hp, sbd_devset_t devset, sbd_dev_stat_t *dsp)
{
int m, mix, rv;
memdelstat_t mdst;
memquery_t mq;
sbd_board_t *sbp;
sbd_mem_unit_t *mp;
sbd_mem_stat_t *msp;
extern int kcage_on;
int i;
static fn_t f = "sbd_mem_status";
sbp = SBDH2BD(hp->h_sbd);
/*
* Check the present devset and access the dip with
* status lock held to protect agains a concurrent
* unconfigure or disconnect thread.
*/
mutex_enter(&sbp->sb_slock);
/*
* Only look for requested devices that are actually present.
*/
devset &= SBD_DEVS_PRESENT(sbp);
for (m = mix = 0; m < MAX_MEM_UNITS_PER_BOARD; m++) {
dev_info_t *dip;
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, m) == 0)
continue;
/*
* Check to make sure the memory unit is in a state
* where its fully initialized.
*/
if (SBD_DEVICE_STATE(sbp, SBD_COMP_MEM, m) == SBD_STATE_EMPTY)
continue;
dip = sbp->sb_devlist[NIX(SBD_COMP_MEM)][m];
if (dip == NULL)
continue;
mp = SBD_GET_BOARD_MEMUNIT(sbp, m);
msp = &dsp->d_mem;
bzero((caddr_t)msp, sizeof (*msp));
msp->ms_type = SBD_COMP_MEM;
/*
* The plugin expects -1 for the mem unit
*/
msp->ms_cm.c_id.c_unit = -1;
/*
* Get the memory name from what sbdp gave us
*/
for (i = 0; SBD_COMP(i) != SBD_COMP_UNKNOWN; i++) {
if (SBD_COMP(i) == SBD_COMP_MEM) {
(void) strcpy(msp->ms_name, SBD_DEVNAME(i));
}
}
msp->ms_cm.c_cond = mp->sbm_cm.sbdev_cond;
msp->ms_cm.c_busy = mp->sbm_cm.sbdev_busy;
msp->ms_cm.c_time = mp->sbm_cm.sbdev_time;
/* XXX revisit this after memory conversion */
msp->ms_ostate = ostate_cvt(SBD_DEVICE_STATE(
sbp, SBD_COMP_MEM, m));
msp->ms_basepfn = mp->sbm_basepfn;
msp->ms_pageslost = mp->sbm_pageslost;
msp->ms_cage_enabled = kcage_on;
msp->ms_interleave = mp->sbm_interleave;
if (mp->sbm_flags & SBD_MFLAG_RELOWNER)
rv = kphysm_del_status(mp->sbm_memhandle, &mdst);
else
rv = KPHYSM_EHANDLE; /* force 'if' to fail */
if (rv == KPHYSM_OK) {
msp->ms_totpages += mdst.phys_pages;
/*
* Any pages above managed is "free",
* i.e. it's collected.
*/
msp->ms_detpages += (uint_t)(mdst.collected +
mdst.phys_pages -
mdst.managed);
} else {
msp->ms_totpages += (uint_t)mp->sbm_npages;
/*
* If we're UNREFERENCED or UNCONFIGURED,
* then the number of detached pages is
* however many pages are on the board.
* I.e. detached = not in use by OS.
*/
switch (msp->ms_cm.c_ostate) {
/*
* changed to use cfgadm states
*
* was:
* case SFDR_STATE_UNREFERENCED:
* case SFDR_STATE_UNCONFIGURED:
*/
case SBD_STAT_UNCONFIGURED:
msp->ms_detpages = msp->ms_totpages;
break;
default:
break;
}
}
rv = kphysm_del_span_query(mp->sbm_basepfn,
mp->sbm_npages, &mq);
if (rv == KPHYSM_OK) {
msp->ms_managed_pages = mq.managed;
msp->ms_noreloc_pages = mq.nonrelocatable;
msp->ms_noreloc_first = mq.first_nonrelocatable;
msp->ms_noreloc_last = mq.last_nonrelocatable;
msp->ms_cm.c_sflags = 0;
if (mq.nonrelocatable) {
SBD_SET_SUSPEND(SBD_CMD_UNCONFIGURE,
dsp->ds_suspend);
}
} else {
PR_MEM("%s: kphysm_del_span_query() = %d\n", f, rv);
}
mix++;
dsp++;
}
mutex_exit(&sbp->sb_slock);
return (mix);
}
static void
sbd_cancel(sbd_handle_t *hp)
{
int i;
sbd_devset_t devset;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
static fn_t f = "sbd_cancel";
int rv;
PR_ALL("%s...\n", f);
/*
* Only devices which have been "released" are
* subject to cancellation.
*/
devset = HD2MACHHD(hp)->sh_devset & SBD_DEVS_UNREFERENCED(sbp);
/*
* Nothing to do for CPUs or IO other than change back
* their state.
*/
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
if (!DEVSET_IN_SET(devset, SBD_COMP_CPU, i))
continue;
if (sbd_cancel_cpu(hp, i) != SBD_CPUERR_FATAL) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, i,
SBD_STATE_CONFIGURED);
} else {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, i,
SBD_STATE_FATAL);
}
}
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
if (!DEVSET_IN_SET(devset, SBD_COMP_IO, i))
continue;
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_IO, i,
SBD_STATE_CONFIGURED);
}
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
if (!DEVSET_IN_SET(devset, SBD_COMP_MEM, i))
continue;
if ((rv = sbd_cancel_mem(hp, i)) == 0) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, i,
SBD_STATE_CONFIGURED);
} else if (rv == -1) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, i,
SBD_STATE_FATAL);
}
}
PR_ALL("%s: unreleasing devset (0x%x)\n", f, (uint_t)devset);
SBD_DEVS_CANCEL(sbp, devset);
if (SBD_DEVS_UNREFERENCED(sbp) == 0) {
sbd_istate_t new_state;
/*
* If the board no longer has any released devices
* than transfer it back to the CONFIG/PARTIAL state.
*/
if (SBD_DEVS_ATTACHED(sbp) == SBD_DEVS_PRESENT(sbp))
new_state = SBD_STATE_CONFIGURED;
else
new_state = SBD_STATE_PARTIAL;
if (SBD_BOARD_STATE(sbp) != new_state) {
SBD_BOARD_TRANSITION(sbp, new_state);
}
sbp->sb_ostate = SBD_STAT_CONFIGURED;
(void) drv_getparm(TIME, (void *)&sbp->sb_time);
}
}
static void
sbd_get_ncm(sbd_handle_t *hp)
{
sbd_devset_t devset;
sbd_priv_handle_t *shp = HD2MACHHD(hp);
sbd_cmd_t *cmdp = (sbd_cmd_t *)hp->h_iap;
int error;
/* pre_op restricted the devices to those selected by the ioctl */
devset = shp->sh_devset;
cmdp->cmd_getncm.g_ncm = sbd_cpu_cnt(hp, devset)
+ sbd_io_cnt(hp, devset) + sbd_mem_cnt(hp, devset);
error = sbd_copyout_ioarg(hp->h_mode, hp->h_cmd, cmdp,
(sbd_ioctl_arg_t *)shp->sh_arg);
if (error != 0)
SBD_SET_ERRNO(SBD_HD2ERR(hp), error);
}
static void
sbd_status(sbd_handle_t *hp)
{
int nstat, mode, ncm, sz, cksz;
sbd_priv_handle_t *shp = HD2MACHHD(hp);
sbd_devset_t devset;
sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
sbd_stat_t *dstatp;
sbd_cmd_t *cmdp = (sbd_cmd_t *)hp->h_iap;
sbdp_handle_t *hdp;
sbd_dev_stat_t *devstatp;
#ifdef _MULTI_DATAMODEL
int sz32;
sbd_stat32_t *dstat32p;
#endif /* _MULTI_DATAMODEL */
static fn_t f = "sbd_status";
mode = hp->h_mode;
devset = shp->sh_devset;
devset &= SBD_DEVS_PRESENT(sbp);
if (cmdp->cmd_cm.c_id.c_type == SBD_COMP_NONE) {
if (cmdp->cmd_cm.c_flags & SBD_FLAG_ALLCMP) {
/*
* Get the number of components "ncm" on the board.
* Calculate size of buffer required to store one
* sbd_stat_t structure plus ncm-1 sbd_dev_stat_t
* structures. Note that sbd_stat_t already contains
* one sbd_dev_stat_t, so only an additional ncm-1
* sbd_dev_stat_t structures need to be accounted for
* in the calculation when more than one component
* is present.
*/
ncm = sbd_cpu_cnt(hp, devset) + sbd_io_cnt(hp, devset) +
sbd_mem_cnt(hp, devset);
} 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;
}
} else {
/* Confirm that only one component is selected. */
ncm = sbd_cpu_cnt(hp, devset) + sbd_io_cnt(hp, devset) +
sbd_mem_cnt(hp, devset);
if (ncm != 1) {
PR_ALL("%s: expected ncm of 1, got %d, devset 0x%x\n",
f, ncm, devset);
SBD_SET_ERRNO(SBD_HD2ERR(hp), EINVAL);
return;
}
}
sz = sizeof (sbd_stat_t);
if (ncm > 1)
sz += sizeof (sbd_dev_stat_t) * (ncm - 1);
cksz = sz;
/*
* s_nbytes describes the size of the preallocated user
* buffer into which the application is executing to
* receive the sbd_stat_t and sbd_dev_stat_t structures.
* This buffer must be at least the required (sz) size.
*/
#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);
cksz = sz32;
} else
sz32 = 0;
#endif
if ((int)cmdp->cmd_stat.s_nbytes < cksz) {
PR_ALL("%s: ncm=%d s_nbytes = 0x%x\n", f, ncm,
cmdp->cmd_stat.s_nbytes);
PR_ALL("%s: expected size of 0x%x\n", f, cksz);
SBD_SET_ERRNO(SBD_HD2ERR(hp), EINVAL);
return;
}
dstatp = kmem_zalloc(sz, KM_SLEEP);
devstatp = &dstatp->s_stat[0];
#ifdef _MULTI_DATAMODEL
if (sz32 != 0)
dstat32p = kmem_zalloc(sz32, KM_SLEEP);
#endif
/*
* if connected or better, provide cached status if available,
* otherwise call sbdp for status
*/
mutex_enter(&sbp->sb_flags_mutex);
switch (sbp->sb_state) {
case SBD_STATE_CONNECTED:
case SBD_STATE_PARTIAL:
case SBD_STATE_CONFIGURED:
if (sbp->sb_flags & SBD_BOARD_STATUS_CACHED) {
bcopy(&sbp->sb_stat, dstatp, sizeof (sbd_stat_t));
dstatp->s_rstate = rstate_cvt(sbp->sb_state);
dstatp->s_ostate = ostate_cvt(sbp->sb_state);
dstatp->s_busy = sbp->sb_busy;
dstatp->s_time = sbp->sb_time;
dstatp->s_cond = sbp->sb_cond;
break;
}
/*FALLTHROUGH*/
default:
sbp->sb_flags &= ~SBD_BOARD_STATUS_CACHED;
dstatp->s_board = sbp->sb_num;
dstatp->s_ostate = ostate_cvt(sbp->sb_state);
dstatp->s_time = sbp->sb_time;
hdp = sbd_get_sbdp_handle(sbp, hp);
if (sbdp_get_board_status(hdp, dstatp) != 0) {
SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
sbd_release_sbdp_handle(hdp);
#ifdef _MULTI_DATAMODEL
if (sz32 != 0)
kmem_free(dstat32p, sz32);
#endif
kmem_free(dstatp, sz);
mutex_exit(&sbp->sb_flags_mutex);
return;
}
/*
* Do not cache status if the busy flag has
* been set by the call to sbdp_get_board_status().
*/
if (!dstatp->s_busy) {
/* Can get board busy flag now */
dstatp->s_busy = sbp->sb_busy;
sbp->sb_cond = (sbd_cond_t)dstatp->s_cond;
bcopy(dstatp, &sbp->sb_stat,
sizeof (sbd_stat_t));
sbp->sb_flags |= SBD_BOARD_STATUS_CACHED;
}
sbd_release_sbdp_handle(hdp);
break;
}
mutex_exit(&sbp->sb_flags_mutex);
if (DEVSET_IN_SET(devset, SBD_COMP_CPU, DEVSET_ANYUNIT))
if ((nstat = sbd_cpu_flags(hp, devset, devstatp)) > 0) {
dstatp->s_nstat += nstat;
devstatp += nstat;
}
if (DEVSET_IN_SET(devset, SBD_COMP_MEM, DEVSET_ANYUNIT))
if ((nstat = sbd_mem_status(hp, devset, devstatp)) > 0) {
dstatp->s_nstat += nstat;
devstatp += nstat;
}
if (DEVSET_IN_SET(devset, SBD_COMP_IO, DEVSET_ANYUNIT))
if ((nstat = sbd_io_status(hp, devset, devstatp)) > 0) {
dstatp->s_nstat += nstat;
devstatp += nstat;
}
/* paranoia: detect buffer overrun */
if ((caddr_t)devstatp > ((caddr_t)dstatp) + sz) {
PR_ALL("%s: buffer overrun\n", f);
#ifdef _MULTI_DATAMODEL
if (sz32 != 0)
kmem_free(dstat32p, sz32);
#endif
kmem_free(dstatp, sz);
SBD_SET_ERRNO(SBD_HD2ERR(hp), EINVAL);
return;
}
/* if necessary, move data into intermediate device status buffer */
#ifdef _MULTI_DATAMODEL
if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
int i, j;
ASSERT(sz32 != 0);
/* paranoia: detect buffer overrun */
if ((caddr_t)&dstat32p->s_stat[dstatp->s_nstat] >
((caddr_t)dstat32p) + sz32) {
cmn_err(CE_WARN,
"sbd:%s: buffer32 overrun", f);
#ifdef _MULTI_DATAMODEL
if (sz32 != 0)
kmem_free(dstat32p, sz32);
#endif
kmem_free(dstatp, sz);
SBD_SET_ERRNO(SBD_HD2ERR(hp), EINVAL);
return;
}
/*
* initialize 32 bit sbd board status structure
*/
dstat32p->s_board = (int32_t)dstatp->s_board;
dstat32p->s_nstat = (int32_t)dstatp->s_nstat;
dstat32p->s_rstate = dstatp->s_rstate;
dstat32p->s_ostate = dstatp->s_ostate;
dstat32p->s_cond = dstatp->s_cond;
dstat32p->s_busy = dstatp->s_busy;
dstat32p->s_time = dstatp->s_time;
dstat32p->s_assigned = dstatp->s_assigned;
dstat32p->s_power = dstatp->s_power;
dstat32p->s_platopts = (int32_t)dstatp->s_platopts;
(void) strcpy(dstat32p->s_type, dstatp->s_type);
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];
/*
* copy common data for the device
*/
ds32p->d_cm.ci_type = (int32_t)dsp->d_cm.ci_type;
ds32p->d_cm.ci_unit = (int32_t)dsp->d_cm.ci_unit;
ds32p->d_cm.c_ostate = (int32_t)dsp->d_cm.c_ostate;
ds32p->d_cm.c_cond = (int32_t)dsp->d_cm.c_cond;
ds32p->d_cm.c_busy = (int32_t)dsp->d_cm.c_busy;
ds32p->d_cm.c_time = (time32_t)dsp->d_cm.c_time;
ds32p->d_cm.c_sflags = (int32_t)dsp->d_cm.c_sflags;
(void) strcpy(ds32p->d_cm.ci_name, dsp->d_cm.ci_name);
/* copy type specific data for the device */
switch (dsp->d_cm.ci_type) {
case SBD_COMP_CPU:
ds32p->d_cpu.cs_isbootproc =
(int32_t)dsp->d_cpu.cs_isbootproc;
ds32p->d_cpu.cs_cpuid =
(int32_t)dsp->d_cpu.cs_cpuid;
ds32p->d_cpu.cs_speed =
(int32_t)dsp->d_cpu.cs_speed;
ds32p->d_cpu.cs_ecache =
(int32_t)dsp->d_cpu.cs_ecache;
break;
case SBD_COMP_MEM:
ds32p->d_mem.ms_type =
(int32_t)dsp->d_mem.ms_type;
ds32p->d_mem.ms_ostate =
(int32_t)dsp->d_mem.ms_ostate;
ds32p->d_mem.ms_cond =
(int32_t)dsp->d_mem.ms_cond;
ds32p->d_mem.ms_interleave =
(uint32_t)dsp->d_mem.ms_interleave;
ds32p->d_mem.ms_basepfn =
(uint32_t)dsp->d_mem.ms_basepfn;
ds32p->d_mem.ms_totpages =
(uint32_t)dsp->d_mem.ms_totpages;
ds32p->d_mem.ms_detpages =
(uint32_t)dsp->d_mem.ms_detpages;
ds32p->d_mem.ms_pageslost =
(int32_t)dsp->d_mem.ms_pageslost;
ds32p->d_mem.ms_managed_pages =
(int32_t)dsp->d_mem.ms_managed_pages;
ds32p->d_mem.ms_noreloc_pages =
(int32_t)dsp->d_mem.ms_noreloc_pages;
ds32p->d_mem.ms_noreloc_first =
(int32_t)dsp->d_mem.ms_noreloc_first;
ds32p->d_mem.ms_noreloc_last =
(int32_t)dsp->d_mem.ms_noreloc_last;
ds32p->d_mem.ms_cage_enabled =
(int32_t)dsp->d_mem.ms_cage_enabled;
ds32p->d_mem.ms_peer_is_target =
(int32_t)dsp->d_mem.ms_peer_is_target;
(void) strcpy(ds32p->d_mem.ms_peer_ap_id,
dsp->d_mem.ms_peer_ap_id);
break;
case SBD_COMP_IO:
ds32p->d_io.is_type =
(int32_t)dsp->d_io.is_type;
ds32p->d_io.is_unsafe_count =
(int32_t)dsp->d_io.is_unsafe_count;
ds32p->d_io.is_referenced =
(int32_t)dsp->d_io.is_referenced;
for (j = 0; j < SBD_MAX_UNSAFE; j++)
ds32p->d_io.is_unsafe_list[j] =
(int32_t)
ds32p->d_io.is_unsafe_list[j];
bcopy(dsp->d_io.is_pathname,
ds32p->d_io.is_pathname, 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));
ds32p->d_cmp.ps_ncores =
(int32_t)dsp->d_cmp.ps_ncores;
ds32p->d_cmp.ps_speed =
(int32_t)dsp->d_cmp.ps_speed;
ds32p->d_cmp.ps_ecache =
(int32_t)dsp->d_cmp.ps_ecache;
break;
default:
cmn_err(CE_WARN,
"sbd:%s: unknown dev type (%d)", f,
(int)dsp->d_cm.c_id.c_type);
break;
}
}
if (ddi_copyout((void *)dstat32p,
cmdp->cmd_stat.s_statp, sz32, mode) != 0) {
cmn_err(CE_WARN,
"sbd:%s: failed to copyout status "
"for board %d", f, sbp->sb_num);
SBD_SET_ERRNO(SBD_HD2ERR(hp), EFAULT);
}
} else
#endif /* _MULTI_DATAMODEL */
if (ddi_copyout((void *)dstatp, cmdp->cmd_stat.s_statp,
sz, mode) != 0) {
cmn_err(CE_WARN,
"sbd:%s: failed to copyout status for board %d",
f, sbp->sb_num);
SBD_SET_ERRNO(SBD_HD2ERR(hp), EFAULT);
}
#ifdef _MULTI_DATAMODEL
if (sz32 != 0)
kmem_free(dstat32p, sz32);
#endif
kmem_free(dstatp, sz);
}
/*
* Called at driver load time to determine the state and condition
* of an existing board in the system.
*/
static void
sbd_board_discovery(sbd_board_t *sbp)
{
int i;
dev_info_t *dip;
sbd_devset_t devs_lost, devs_attached = 0;
extern kmutex_t cpu_lock;
sbdp_handle_t *hdp;
static fn_t f = "sbd_board_discovery";
sbderror_t error, *ep;
sbd_handle_t *hp = MACHBD2HD(sbp);
if (SBD_DEVS_PRESENT(sbp) == 0) {
PR_ALL("%s: board %d has no devices present\n",
f, sbp->sb_num);
return;
}
ep = &error;
bzero(ep, sizeof (sbderror_t));
/*
* Check for existence of cpus.
*/
hdp = sbd_get_sbdp_handle(sbp, hp);
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
processorid_t cpuid;
if (!SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, i))
continue;
dip = sbp->sb_devlist[NIX(SBD_COMP_CPU)][i];
if (dip != NULL) {
cpuid = sbdp_get_cpuid(hdp, dip);
if (cpuid < 0) {
SBD_GET_PERR(hdp->h_err,
ep);
continue;
}
mutex_enter(&cpu_lock); /* needed to call cpu_get() */
if (cpu_get(cpuid)) {
SBD_DEV_SET_ATTACHED(sbp, SBD_COMP_CPU, i);
DEVSET_ADD(devs_attached, SBD_COMP_CPU, i);
PR_ALL("%s: board %d, cpuid %d - attached\n",
f, sbp->sb_num, cpuid);
}
mutex_exit(&cpu_lock);
sbd_init_cpu_unit(sbp, i);
}
}
/*
* Check for existence of memory.
*/
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
uint64_t basepa, endpa;
struct memlist *ml;
extern struct memlist *phys_install;
if (!SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, i))
continue;
dip = sbp->sb_devlist[NIX(SBD_COMP_MEM)][i];
if (dip == NULL)
continue;
if (sbdphw_get_base_physaddr(hdp, dip, &basepa)) {
/* omit phantom memory controllers on I/O boards */
if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, i)) {
ASSERT(sbp->sb_ndev != 0);
SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_MEM, i);
sbp->sb_ndev--;
}
sbp->sb_devlist[NIX(SBD_COMP_MEM)][i] = NULL;
continue;
}
/*
* basepa may not be on a alignment boundary, make it so.
*/
if (sbdp_get_mem_alignment(hdp, dip, &endpa)) {
cmn_err(CE_WARN, "%s sbdp_get_mem_alignment fail", f);
continue;
}
basepa &= ~(endpa - 1);
endpa += basepa;
/*
* 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) {
SBD_DEV_SET_ATTACHED(sbp, SBD_COMP_MEM, i);
DEVSET_ADD(devs_attached, SBD_COMP_MEM, i);
PR_ALL("%s: board %d, mem-unit %d - attached\n",
f, sbp->sb_num, i);
}
sbd_init_mem_unit(sbp, i, ep);
}
sbd_release_sbdp_handle(hdp);
/*
* If so far we have found an error, we just log it but continue
*/
if (SBD_GET_ERRNO(ep) != 0)
cmn_err(CE_WARN, "%s errno has occurred: errno %d", f,
SBD_GET_ERRNO(ep));
/*
* Check for i/o state.
*/
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
if (!SBD_DEV_IS_PRESENT(sbp, SBD_COMP_IO, i))
continue;
dip = sbp->sb_devlist[NIX(SBD_COMP_IO)][i];
if (dip == NULL)
continue;
ASSERT(e_ddi_branch_held(dip));
/*
* XXX Is the devstate check needed ?
*/
if (i_ddi_devi_attached(dip) ||
ddi_get_devstate(dip) == DDI_DEVSTATE_UP) {
/*
* Found it!
*/
SBD_DEV_SET_ATTACHED(sbp, SBD_COMP_IO, i);
DEVSET_ADD(devs_attached, SBD_COMP_IO, i);
PR_ALL("%s: board %d, io-unit %d - attached\n",
f, sbp->sb_num, i);
}
sbd_init_io_unit(sbp, i);
}
SBD_DEVS_CONFIGURE(sbp, devs_attached);
if (devs_attached && ((devs_lost = SBD_DEVS_UNATTACHED(sbp)) != 0)) {
int ut;
/*
* A prior comment stated that a partially configured
* board was not permitted. The Serengeti architecture
* makes this possible, so the SB_DEVS_DISCONNECT
* at the end of this block has been removed.
*/
PR_ALL("%s: some devices not configured (0x%x)...\n",
f, devs_lost);
for (ut = 0; ut < MAX_CPU_UNITS_PER_BOARD; ut++)
if (DEVSET_IN_SET(devs_lost, SBD_COMP_CPU, ut)) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU,
ut, SBD_STATE_UNCONFIGURED);
}
for (ut = 0; ut < MAX_MEM_UNITS_PER_BOARD; ut++)
if (DEVSET_IN_SET(devs_lost, SBD_COMP_MEM, ut)) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM,
ut, SBD_STATE_UNCONFIGURED);
}
for (ut = 0; ut < MAX_IO_UNITS_PER_BOARD; ut++)
if (DEVSET_IN_SET(devs_lost, SBD_COMP_IO, ut)) {
SBD_DEVICE_TRANSITION(sbp, SBD_COMP_IO,
ut, SBD_STATE_UNCONFIGURED);
}
}
}
static int
hold_rele_branch(dev_info_t *rdip, void *arg)
{
walk_tree_t *wp = (walk_tree_t *)arg;
ASSERT(wp && (wp->hold == 0 || wp->hold == 1));
switch (get_node_type(wp->sbp, rdip, NULL)) {
case SBD_COMP_CMP:
case SBD_COMP_MEM:
case SBD_COMP_IO:
break;
case SBD_COMP_CPU:
/*
* All CPU nodes under CMP nodes should have
* gotten pruned when the CMP node was first
* encountered.
*/
ASSERT(!sbd_is_cmp_child(rdip));
break;
case SBD_COMP_UNKNOWN:
/* Not of interest to us */
return (DDI_WALK_CONTINUE);
default:
ASSERT(0);
return (DDI_WALK_PRUNECHILD);
}
if (wp->hold) {
ASSERT(!e_ddi_branch_held(rdip));
e_ddi_branch_hold(rdip);
} else {
ASSERT(e_ddi_branch_held(rdip));
e_ddi_branch_rele(rdip);
}
return (DDI_WALK_PRUNECHILD);
}
static void
sbd_board_init(sbd_board_t *sbp, sbd_softstate_t *softsp,
int bd, dev_info_t *top_dip, int wnode)
{
int i;
dev_info_t *pdip;
int circ;
walk_tree_t walk = {0};
mutex_init(&sbp->sb_mutex, NULL, MUTEX_DRIVER, NULL);
mutex_init(&sbp->sb_flags_mutex, NULL, MUTEX_DRIVER, NULL);
mutex_init(&sbp->sb_slock, NULL, MUTEX_DRIVER, NULL);
sbp->sb_ref = 0;
sbp->sb_num = bd;
sbp->sb_time = gethrestime_sec();
/*
* For serengeti, top_dip doesn't need to be held because
* sbp i.e. sbd_board_t will be destroyed in sbd_teardown_instance()
* before top_dip detaches. For Daktari, top_dip is the
* root node which never has to be held.
*/
sbp->sb_topdip = top_dip;
sbp->sb_cpuid = -1;
sbp->sb_softsp = (void *) softsp;
sbp->sb_cond = SBD_COND_UNKNOWN;
sbp->sb_wnode = wnode;
sbp->sb_memaccess_ok = 1;
ASSERT(MAX_IO_UNITS_PER_BOARD <= SBD_MAX_UNITS_PER_BOARD);
ASSERT(MAX_CPU_UNITS_PER_BOARD <= SBD_MAX_UNITS_PER_BOARD);
ASSERT(MAX_MEM_UNITS_PER_BOARD <= SBD_MAX_UNITS_PER_BOARD);
/*
* Allocate the devlist for cpus.
*/
sbp->sb_devlist[NIX(SBD_COMP_CPU)] = GETSTRUCT(dev_info_t *,
MAX_CPU_UNITS_PER_BOARD);
/*
* Allocate the devlist for mem.
*/
sbp->sb_devlist[NIX(SBD_COMP_MEM)] = GETSTRUCT(dev_info_t *,
MAX_MEM_UNITS_PER_BOARD);
/*
* Allocate the devlist for io.
*/
sbp->sb_devlist[NIX(SBD_COMP_IO)] = GETSTRUCT(dev_info_t *,
MAX_IO_UNITS_PER_BOARD);
sbp->sb_dev[NIX(SBD_COMP_CPU)] = GETSTRUCT(sbd_dev_unit_t,
MAX_CPU_UNITS_PER_BOARD);
sbp->sb_dev[NIX(SBD_COMP_MEM)] = GETSTRUCT(sbd_dev_unit_t,
MAX_MEM_UNITS_PER_BOARD);
sbp->sb_dev[NIX(SBD_COMP_IO)] = GETSTRUCT(sbd_dev_unit_t,
MAX_IO_UNITS_PER_BOARD);
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
sbp->sb_cpupath[i] = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
}
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
sbp->sb_mempath[i] = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
}
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
sbp->sb_iopath[i] = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
}
/*
* Walk the device tree, find all top dips on this board and
* hold the branches rooted at them
*/
ASSERT(sbp->sb_topdip);
pdip = ddi_get_parent(sbp->sb_topdip);
if (pdip)
ndi_devi_enter(pdip, &circ);
walk.sbp = sbp;
walk.hold = 1;
ddi_walk_devs(sbp->sb_topdip, hold_rele_branch, (void *)&walk);
if (pdip)
ndi_devi_exit(pdip, circ);
/*
* Initialize the devlists
*/
if (sbd_init_devlists(sbp) == 0) {
SBD_BOARD_TRANSITION(sbp, SBD_STATE_EMPTY);
} else {
/*
* Couldn't have made it down here without
* having found at least one device.
*/
ASSERT(SBD_DEVS_PRESENT(sbp) != 0);
/*
* Check the state of any possible devices on the
* board.
*/
sbd_board_discovery(sbp);
if (SBD_DEVS_UNATTACHED(sbp) == 0) {
/*
* The board has no unattached devices, therefore
* by reason of insanity it must be configured!
*/
SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONFIGURED);
sbp->sb_cond = SBD_COND_OK;
} else if (SBD_DEVS_ATTACHED(sbp)) {
SBD_BOARD_TRANSITION(sbp, SBD_STATE_PARTIAL);
} else {
SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONNECTED);
}
}
}
static void
sbd_board_destroy(sbd_board_t *sbp)
{
int i;
dev_info_t *pdip;
int circ;
walk_tree_t walk = {0};
SBD_BOARD_TRANSITION(sbp, SBD_STATE_EMPTY);
#ifdef DEBUG
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
sbd_mem_unit_t *mp;
mp = SBD_GET_BOARD_MEMUNIT(sbp, i);
ASSERT(mp->sbm_mlist == NULL);
}
#endif /* DEBUG */
/*
* Free up MEM unit structs.
*/
FREESTRUCT(sbp->sb_dev[NIX(SBD_COMP_MEM)],
sbd_dev_unit_t, MAX_MEM_UNITS_PER_BOARD);
sbp->sb_dev[NIX(SBD_COMP_MEM)] = NULL;
/*
* Free up CPU unit structs.
*/
FREESTRUCT(sbp->sb_dev[NIX(SBD_COMP_CPU)],
sbd_dev_unit_t, MAX_CPU_UNITS_PER_BOARD);
sbp->sb_dev[NIX(SBD_COMP_CPU)] = NULL;
/*
* Free up IO unit structs.
*/
FREESTRUCT(sbp->sb_dev[NIX(SBD_COMP_IO)],
sbd_dev_unit_t, MAX_IO_UNITS_PER_BOARD);
sbp->sb_dev[NIX(SBD_COMP_IO)] = NULL;
/*
* free up CPU devlists.
*/
for (i = 0; i < MAX_CPU_UNITS_PER_BOARD; i++) {
kmem_free((caddr_t)sbp->sb_cpupath[i], MAXPATHLEN);
}
FREESTRUCT(sbp->sb_devlist[NIX(SBD_COMP_CPU)], dev_info_t *,
MAX_CPU_UNITS_PER_BOARD);
sbp->sb_devlist[NIX(SBD_COMP_CPU)] = NULL;
/*
* free up MEM devlists.
*/
for (i = 0; i < MAX_MEM_UNITS_PER_BOARD; i++) {
kmem_free((caddr_t)sbp->sb_mempath[i], MAXPATHLEN);
}
FREESTRUCT(sbp->sb_devlist[NIX(SBD_COMP_MEM)], dev_info_t *,
MAX_MEM_UNITS_PER_BOARD);
sbp->sb_devlist[NIX(SBD_COMP_MEM)] = NULL;
/*
* free up IO devlists.
*/
for (i = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
kmem_free((caddr_t)sbp->sb_iopath[i], MAXPATHLEN);
}
FREESTRUCT(sbp->sb_devlist[NIX(SBD_COMP_IO)], dev_info_t *,
MAX_IO_UNITS_PER_BOARD);
sbp->sb_devlist[NIX(SBD_COMP_IO)] = NULL;
/*
* Release all branches held earlier
*/
ASSERT(sbp->sb_topdip);
pdip = ddi_get_parent(sbp->sb_topdip);
if (pdip)
ndi_devi_enter(pdip, &circ);
walk.sbp = sbp;
walk.hold = 0;
ddi_walk_devs(sbp->sb_topdip, hold_rele_branch, (void *)&walk);
if (pdip)
ndi_devi_exit(pdip, circ);
mutex_destroy(&sbp->sb_slock);
mutex_destroy(&sbp->sb_flags_mutex);
mutex_destroy(&sbp->sb_mutex);
}
sbd_comp_type_t
sbd_cm_type(char *name)
{
sbd_comp_type_t type = SBD_COMP_UNKNOWN;
int i;
/* look up type in table */
for (i = 0; SBD_COMP(i) != SBD_COMP_UNKNOWN; i++) {
if (strcmp(name, SBD_OTYPE(i)) == 0) {
type = SBD_COMP(i);
break;
}
}
return (type);
}
/*
* There are certain cases where obp marks components as failed
* If the status is ok the node won't have any status property. It
* is only there if the status is other than ok.
*
* The translation is as follows:
* If there is no status prop, the the cond is SBD_COND_OK
* If we find a status prop but can't get to it then cond is SBD_COND_UNKNOWN
* if we find a stat and it is failed the cond is SBD_COND_FAILED
* If the stat is disabled, the cond is SBD_COND_UNUSABLE
* Otherwise we return con as SBD_COND_OK
*/
sbd_cond_t
sbd_get_comp_cond(dev_info_t *dip)
{
int len;
char *status_buf;
static const char *status = "status";
static const char *failed = "fail";
static const char *disabled = "disabled";
if (dip == NULL) {
PR_BYP("dip is NULL\n");
return (SBD_COND_UNKNOWN);
}
/*
* If retired, return FAILED
*/
if (DEVI(dip)->devi_flags & DEVI_RETIRED) {
PR_CPU("dip is retired\n");
return (SBD_COND_FAILED);
}
if (ddi_getproplen(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
(char *)status, &len) != DDI_PROP_SUCCESS) {
PR_CPU("status in sbd is ok\n");
return (SBD_COND_OK);
}
status_buf = kmem_zalloc(sizeof (char) * OBP_MAXPROPNAME, KM_SLEEP);
if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
(char *)status, status_buf, &len) != DDI_PROP_SUCCESS) {
PR_CPU("status in sbd is unknown\n");
return (SBD_COND_UNKNOWN);
}
if (strncmp(status_buf, failed, strlen(failed)) == 0) {
PR_CPU("status in sbd is failed\n");
kmem_free(status_buf, sizeof (char) * OBP_MAXPROPNAME);
return (SBD_COND_FAILED);
}
if (strcmp(status_buf, disabled) == 0) {
PR_CPU("status in sbd is unusable\n");
kmem_free(status_buf, sizeof (char) * OBP_MAXPROPNAME);
return (SBD_COND_UNUSABLE);
}
kmem_free(status_buf, sizeof (char) * OBP_MAXPROPNAME);
return (SBD_COND_OK);
}
#ifdef SBD_DEBUG_ERRS
/* function to simulate errors throughout the sbd code */
void
sbd_inject_err(int error, sbderror_t *ep, int Errno, int ecode,
char *rsc)
{
static fn_t f = "sbd_inject_err";
if (sbd_err_debug == 0)
return;
if (ep == NULL) {
cmn_err(CE_WARN, "%s ep is NULL", f);
return;
}
if (SBD_GET_ERRNO(ep) != 0) {
cmn_err(CE_WARN, "%s errno already set to %d", f,
SBD_GET_ERRNO(ep));
return;
}
if (SBD_GET_ERR(ep) != 0) {
cmn_err(CE_WARN, "%s code already set to %d", f,
SBD_GET_ERR(ep));
return;
}
if ((sbd_err_debug & (1 << error)) != 0) {
ep->e_errno = Errno;
ep->e_code = ecode;
if (rsc != NULL)
bcopy((caddr_t)rsc,
(caddr_t)ep->e_rsc,
sizeof (ep->e_rsc));
if (Errno != 0)
PR_ERR_ERRNO("%s set errno to %d", f, ep->e_errno);
if (ecode != 0)
PR_ERR_ECODE("%s set ecode to %d", f, ep->e_code);
if (rsc != NULL)
PR_ERR_RSC("%s set rsc to %s", f, ep->e_rsc);
}
}
#endif