/*
 * 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.
 */

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <libdevinfo.h>
#include <errno.h>
#include <libintl.h>
#define	CFGA_PLUGIN_LIB
#include <config_admin.h>
#include "ap.h"
#include <sys/obpdefs.h>
#include <sys/processor.h>
#include <sys/stat.h>
#include <sys/sbd_ioctl.h>
#include <sys/int_fmtio.h>

static cfga_err_t
ap_getncm(apd_t *a, sbd_comp_type_t type, int *ncm)
{
	sbd_ioctl_arg_t *ctl;
	sbd_getncm_cmd_t *cp;

	if (a->fd == -1 || a->ctl == NULL)
		return (CFGA_LIB_ERROR);

	ctl = (sbd_ioctl_arg_t *)a->ctl;
	ctl->ic_type = type;
	ctl->ic_name[0] = '\0';
	ctl->ic_unit = 0;
	ctl->i_len = 0;
	ctl->i_opts = NULL;

	DBG("ioctl(%d SBD_CMD_GETNCM, 0x%p)\n", a->fd, (void *)ctl);

	if (ioctl(a->fd, SBD_CMD_GETNCM, ctl) == -1) {
		ap_err(a, ERR_CMD_FAIL, CMD_GETNCM);
		return (CFGA_ERROR);
	}

	cp = &ctl->i_cmd.cmd_getncm;

	DBG("ncm(%d)=%d\n", type, cp->g_ncm);

	if (ncm)
		*ncm = cp->g_ncm;

	return (CFGA_OK);
}

cfga_err_t
ap_stat(apd_t *a, int all)
{
	int fd;
	int ncm;
	int select;
	int stsize;
	int oflag;
	sbd_stat_cmd_t *sc;
	sbd_ioctl_arg_t *ctl;
	cfga_err_t rc;
	sbd_stat_t *new_stat;

	rc = CFGA_LIB_ERROR;

	DBG("ap_stat(%s)\n", a->path);

	/* Open the file descriptor if not already open */
	if (a->fd == -1) {
		DBG("open(%s)\n", a->path);
		if (a->statonly != 0)
			oflag = O_RDONLY;
		else
			oflag = O_RDWR;
		if ((fd = open(a->path, oflag, 0)) == -1) {
			ap_err(a, ERR_AP_INVAL);
			return (rc);
		}
		a->fd = fd;
	} else {
		fd = a->fd;
	}

	if (a->ctl == NULL && (a->ctl = calloc(1, sizeof (*ctl))) == NULL) {
		ap_err(a, ERR_CMD_FAIL, CMD_STATUS);
		return (rc);
	}

	if (a->tgt == AP_BOARD) {
		/*
		 * The status target is the board. If we need to
		 * return component data (to support the -a option),
		 * get the number of components on the board.
		 */
		select = 0;
		if (all) {
			cfga_err_t r;
			r = ap_getncm(a, SBD_COMP_NONE, &ncm);
			if (r != CFGA_OK) {
				return (r);
			}
		} else {
			ncm = 0;
		}
	} else {
		select = 1;
		ncm = 1;
	}

	DBG("ncm=%d\n", ncm);

	a->ncm = ncm;

	/*
	 * The status structure contains space for one component;
	 * add the space for the other components if necessary.
	 */
	stsize = sizeof (sbd_stat_t);
	if (ncm > 1)
		stsize += ((ncm - 1) * sizeof (sbd_dev_stat_t));

	if ((new_stat = realloc(a->stat, stsize)) == NULL) {
		ap_err(a, ERR_CMD_FAIL, CMD_STATUS);
		return (rc);
	}

	a->stat = new_stat;


	ctl = (sbd_ioctl_arg_t *)a->ctl;
	ctl->i_len = 0;
	ctl->i_opts = NULL;
	ctl->ic_type = SBD_COMP_NONE;
	if (all)
		ctl->i_flags |= SBD_FLAG_ALLCMP;
	sc = &ctl->i_cmd.cmd_stat;
	sc->s_statp = (caddr_t)a->stat;
	sc->s_nbytes = stsize;

	if (select) {
		/*
		 * The target is a specific component.  Pass its
		 * name and unit number to the driver.  Set its
		 * type to UNKNOWN since the plugin does not know
		 * the type of the component specified by the user.
		 */
		ctl->ic_type = SBD_COMP_UNKNOWN;
		ctl->ic_unit = a->cnum;
		(void) strcpy(ctl->ic_name, a->cname);
	}

	DBG("ioctl(%d SBD_CMD_STATUS, sc=0x%p sz=%d flags=%d",
	    fd, (void *)sc->s_statp, sc->s_nbytes, ctl->i_flags);
	if (select)
		DBG(" cname=<%s> cnum=%d", a->cname, a->cnum);
	DBG(")\n");

	if (ioctl(fd, SBD_CMD_STATUS, ctl) == -1) {
		ap_err(a, ERR_CMD_FAIL, CMD_STATUS);
		rc = CFGA_ERROR;
	} else
		rc = CFGA_OK;

	DBG("ap_stat()=%d\n", rc);

	return (rc);
}

/*
 * Convert a component to a target type.
 */
static ap_target_t
ap_cm_tgt(sbd_comp_type_t type)
{
	ap_target_t c;

	switch (type) {
	case SBD_COMP_CPU:
		c = AP_CPU;
		break;
	case SBD_COMP_MEM:
		c = AP_MEM;
		break;
	case SBD_COMP_IO:
		c = AP_IO;
		break;
	case SBD_COMP_CMP:
		c = AP_CMP;
		break;
	default:
		c = AP_NONE;
		break;
	}

	return (c);
}

cfga_err_t
apd_init(apd_t *a, int all)
{
	int i;
	char *cn, *dn;
	sbd_stat_t *st;
	sbd_dev_stat_t *dst;
	cfga_err_t rc;

	/*
	 * Ideally, for board operations (other than status) it is not
	 * necessary to issue the STATUS ioctl.  The call however allows a
	 * final sanity check to ensure that the board number returned
	 * by the driver matches the plugin's notion of the board number
	 * as extracted from the ap_id.  If this check is not desirable,
	 * we can change the code to issue the status call only when
	 * necessary.  Note that for component operations, we need to do
	 * the STATUS in order to figure out the component type and
	 * validate the command/options accordingly. XXX
	 */
	if ((rc = ap_stat(a, all)) != CFGA_OK) {
		ap_err(a, ERR_AP_INVAL);
		return (rc);
	}

	st = (sbd_stat_t *)a->stat;

	/*
	 * Set the component count to the returned stat count.
	 */
	if (a->ncm > st->s_nstat) {

		DBG("ncm=%d nstat=%d (truncated)\n", a->ncm, st->s_nstat);

		a->ncm = st->s_nstat;
	}

	if (a->tgt == AP_BOARD) {

		DBG("tgt=%d\n", a->tgt);

		/*
		 * Initialize the RCM module here so that it can record
		 * the initial state of the capacity information.
		 */
		rc = ap_rcm_init(a);

		return (rc);
	}

	a->tgt = AP_NONE;
	cn = a->cname;

	DBG("cname=<%s> cunit=<%d>\n", a->cname, a->cnum);

	for (dst = st->s_stat, i = 0; i < st->s_nstat; i++, dst++) {

		DBG("ds_name,ds_unit,ds_type=<%s,%d,%d> ",
		    dst->ds_name, dst->ds_unit, dst->ds_type);

		if (dst->ds_unit != a->cnum)
			continue;

		/*
		 * Consider the names matched if they are either
		 * both absent or the same. It is conceivable that
		 * a NULL component name be considered valid
		 * by the driver.
		 */
		dn = dst->ds_name;

		if ((dn == NULL && cn == NULL) ||
		    (dn != NULL && cn != NULL && strcmp(dn, cn) == 0)) {
			a->tgt = ap_cm_tgt(dst->ds_type);
			a->cmstat = (void *)dst;

			DBG("found ");

			break;
		}
	}

	DBG("tgt=%d\n", a->tgt);

	if (a->tgt == AP_NONE) {
		ap_err(a, ERR_CM_INVAL, a->cid);
		return (CFGA_INVAL);
	}

	/*
	 * Initialize the RCM module here so that it can record
	 * the initial state of the capacity information.
	 */
	rc = ap_rcm_init(a);

	return (rc);
}

void
apd_free(apd_t *a)
{
	if (a == NULL)
		return;

	ap_rcm_fini(a);

	if (a->fd != -1)
		(void) close(a->fd);

	s_free(a->options);
	s_free(a->path);
	s_free(a->drv);
	s_free(a->target);
	s_free(a->cname);
	s_free(a->ctl);
	s_free(a->stat);

	free(a);
}

apd_t *
apd_alloc(const char *ap_id, cfga_flags_t flags, char **errstring,
	struct cfga_msg *msgp, struct cfga_confirm *confp)
{
	apd_t *a;

	if ((a = calloc(1, sizeof (*a))) == NULL)
		return (NULL);

	if (errstring != NULL)
		*errstring = NULL;

	a->fd = -1;
	a->errstring = errstring;
	a->msgp = msgp;
	a->confp = confp;
	a->class = "sbd";

	if (flags & CFGA_FLAG_LIST_ALL)
		ap_setopt(a, OPT_LIST_ALL);
	if (flags & CFGA_FLAG_FORCE)
		ap_setopt(a, OPT_FORCE);
	if (flags & CFGA_FLAG_VERBOSE)
		ap_setopt(a, OPT_VERBOSE);

	if (ap_id == NULL || ap_parse(a, ap_id) == 0)
		return (a);

	apd_free(a);
	return (NULL);
}

/*
 * The type field is defined to be parsable by cfgadm(8): It
 * must not contain white space characters. This function
 * converts white space to underscore.
 */

static void
parsable_strncpy(char *op, const char *ip, size_t n)
{
	char c;

	while (n-- > 0) {
		c = *ip++;
		if (isspace(c))
			c = '_';
		*op++ = c;
		if (c == '\0')
			break;
	}
}

void
ap_init(apd_t *a, cfga_list_data_t *ap)
{
	sbd_stat_t *st;

	st = (sbd_stat_t *)a->stat;

	DBG("ap_init bd=%d rs=%d os=%d type=<%s>\n",
	    a->bnum, st->s_rstate, st->s_ostate, st->s_type);

	parsable_strncpy(ap->ap_type, st->s_type, sizeof (ap->ap_type));
	ap->ap_r_state = (cfga_stat_t)st->s_rstate;
	ap->ap_o_state = (cfga_stat_t)st->s_ostate;
	ap->ap_cond = (cfga_cond_t)st->s_cond;
	ap->ap_busy = (cfga_busy_t)st->s_busy;
	ap->ap_status_time = st->s_time;
	ap_info(a, ap->ap_info, AP_BOARD);
}

typedef struct {
	int cmd;
	int ioc;
} ap_ioc_t;

static ap_ioc_t
ap_iocs[] =  {
	{CMD_ASSIGN,	  SBD_CMD_ASSIGN	},
	{CMD_POWERON,	  SBD_CMD_POWERON	},
	{CMD_TEST,	  SBD_CMD_TEST		},
	{CMD_CONNECT,	  SBD_CMD_CONNECT	},
	{CMD_CONFIGURE,	  SBD_CMD_CONFIGURE	},
	{CMD_UNCONFIGURE, SBD_CMD_UNCONFIGURE	},
	{CMD_DISCONNECT,  SBD_CMD_DISCONNECT	},
	{CMD_POWEROFF,	  SBD_CMD_POWEROFF	},
	{CMD_STATUS,	  SBD_CMD_STATUS	},
	{CMD_GETNCM,	  SBD_CMD_GETNCM	},
	{CMD_UNASSIGN,	  SBD_CMD_UNASSIGN	},
	{CMD_PASSTHRU,	  SBD_CMD_PASSTHRU	},
	{CMD_NONE,	  0			}
};

static int
ap_ioc(int cmd)
{
	ap_ioc_t *acp;

	DBG("ap_ioc(%d)\n", cmd);

	for (acp = ap_iocs; acp->cmd != CMD_NONE; acp++)
		if (acp->cmd == cmd)
			break;

	DBG("ap_ioc(%d)=0x%x\n", cmd, acp->ioc);

	return (acp->ioc);
}

cfga_err_t
ap_suspend_query(apd_t *a, int cmd, int *check)
{
	int ioc;
	sbd_dev_stat_t *dst;

	/*
	 * See if the a quiesce operation is required for
	 * this command for any of the components.  If the
	 * command does not map to an ioctl, then there is
	 * nothing to do.
	 */
	if ((ioc = ap_ioc(cmd)) == 0)
		return (CFGA_OK);
	else if (a->tgt == AP_BOARD) {
		int i;

		dst = ((sbd_stat_t *)a->stat)->s_stat;

		/*
		 * See if any component requires a
		 * OS suspension for this command.
		 */
		for (i = 0; i < a->ncm; i++, dst++)
			if (SBD_CHECK_SUSPEND(ioc, dst->ds_suspend))
				(*check)++;
	} else {
		dst = (sbd_dev_stat_t *)a->cmstat;
		if (SBD_CHECK_SUSPEND(ioc, dst->ds_suspend))
				(*check)++;
	}

	return (CFGA_OK);
}

cfga_err_t
ap_platopts_check(apd_t *a, int first, int last)
{
	int c;
	uint_t platopts;
	sbd_stat_t *stat;
	ap_opts_t *opts;

	opts = &a->opts;
	stat = (sbd_stat_t *)a->stat;
	platopts = stat->s_platopts;


	/*
	 * If there are no platform options set then there
	 * is no need to check this operation
	 */
	if (opts->platform == NULL)
		return (CFGA_OK);

	/*
	 * Check if any of the steps in the sequence
	 * allows for a platform option
	 */
	for (c = first; c <= last; c++)
		/*
		 * If the platopt is set it means that the platform does not
		 * support options for this cmd
		 */
		if (SBD_CHECK_PLATOPTS(ap_ioc(c), platopts) == 0) {
			return (CFGA_OK);
		}

	ap_err(a, ERR_OPT_INVAL, opts->platform);

	return (CFGA_INVAL);
}

cfga_err_t
ap_ioctl(apd_t *a, int cmd)
{
	int ioc;
	sbd_ioctl_arg_t *ctl;

	if (a->ctl == NULL && (a->ctl = calloc(1, sizeof (*ctl))) == NULL) {
		ap_err(a, ERR_CMD_FAIL, cmd);
		return (CFGA_LIB_ERROR);
	}

	ap_msg(a, MSG_ISSUE, cmd, a->target);

	ctl = (sbd_ioctl_arg_t *)a->ctl;
	ctl->i_flags = 0;
	ctl->i_len = 0;
	ctl->i_opts = NULL;

	if (ap_getopt(a, OPT_FORCE))
		ctl->i_flags |= SBD_FLAG_FORCE;
	if (ap_getopt(a, OPT_SUSPEND_OK))
		ctl->i_flags |= SBD_FLAG_QUIESCE_OKAY;

	if (a->tgt == AP_BOARD)
		ctl->ic_type = SBD_COMP_NONE;
	else {
		ctl->ic_type = SBD_COMP_UNKNOWN;
		ctl->ic_unit = a->cnum;
		(void) strcpy(ctl->ic_name, a->cname);
	}

	if (!(ioc = ap_ioc(cmd))) {
		ap_err(a, ERR_CMD_FAIL, cmd);
		return (CFGA_LIB_ERROR);
	}

	/*
	 * If this is a passthru command, pass all of its
	 * options; otherwise, pass all options after the
	 * platform keyword.
	 */
	if (cmd == CMD_PASSTHRU)
		ctl->i_opts = a->options;
	else {
		/*
		 * Only pass the platform option to the cmds that the platform
		 * has specified as ok
		 */
		sbd_stat_t *stat;

		stat = (sbd_stat_t *)a->stat;
		if (SBD_CHECK_PLATOPTS(ioc, stat->s_platopts) == 0)
			ctl->i_opts = a->opts.platform;
	}

	if (ctl->i_opts != NULL)
		ctl->i_len = strlen(ctl->i_opts) + 1;

	DBG("i_opts=%s\n", ctl->i_opts ? ctl->i_opts : "NULL");
	DBG("i_flags=0x%x\n", ctl->i_flags);

	if (ap_getopt(a, OPT_SIM)) {
		ap_msg(a, MSG_DONE, cmd, a->target);
		return (CFGA_OK);
	}

	if (ioctl(a->fd, ioc, ctl) == -1) {
		ap_err(a, ERR_CMD_FAIL, cmd);
		return (CFGA_ERROR);
	}
	ap_msg(a, MSG_DONE, cmd, a->target);

	return (CFGA_OK);
}

/*
 * Return the error string corresponding to a given error code.
 * String table and error code sets are provided by sbd_etab.  This data
 * structure is automatically generated at compile time from the error
 * code and message text information in sbd_ioctl.h.
 */
static char *
mod_estr(int code)
{
	int i;
	char *s;
	extern sbd_etab_t sbd_etab[];
	extern int sbd_etab_len;

	s = NULL;

	for (i = 0; i < sbd_etab_len; i++) {
		sbd_etab_t *eptr = &sbd_etab[i];

		if ((code >= eptr->t_base) && (code <= eptr->t_bnd)) {
			int index;
			char **t_text;

			/*
			 * Found it. Just extract the string
			 */
			index = code - eptr->t_base;
			t_text = eptr->t_text;
			s = strdup(t_text[index]);
			break;
		}
	}

	if (i == sbd_etab_len) {
		char buf[32];

		(void) snprintf(buf, sizeof (buf), "error %d", code);
		s = strdup(buf);
	}

	return (s);
}

char *
ap_sys_err(apd_t *a, char **rp)
{
	int code;
	char *p;
	char *rsc;

	sbd_ioctl_arg_t *ctl = (sbd_ioctl_arg_t *)a->ctl;

	/*
	 * The driver sets the errno to EIO if it returns
	 * more detailed error info via e_code.  In all
	 * other cases, use standard error text.
	 */
	if (ctl == NULL || errno != EIO) {
		if ((p = strerror(errno)) != NULL)
			p = strdup(p);
		return (p);
	}

	code = ctl->ie_code;
	rsc = ctl->ie_rsc;

	if (code)
		p = mod_estr(code);
	else if ((p = strerror(errno)) != NULL)
		p = strdup(p);

	if (*rsc != '\0' && rp != NULL)
		*rp = strdup(rsc);

	return (p);
}

/*
 * cfgadm -o err=plugin-err,cmd=name,code=ecode -x errtest ap_id.
 */
cfga_err_t
ap_test_err(apd_t *a, const char *options)
{
	int err;
	int cmd;
	ap_opts_t *opts;
	sbd_ioctl_arg_t ctl;

	opts = &a->opts;
	err = opts->err;
	cmd = CMD_DISCONNECT;

	DBG("ap_test_err(%d %d)\n", opts->code, opts->err);

	switch (err) {
	case ERR_CMD_INVAL:
		ap_err(a, err, ap_cmd_name(cmd));
		break;
	case ERR_CMD_NOTSUPP:
		ap_err(a, err, cmd);
		break;
	case ERR_CMD_FAIL:
		errno = EIO;
		ctl.i_err.e_code = opts->code;
		*ctl.i_err.e_rsc = '\0';
		a->ctl = &ctl;
		ap_err(a, err, cmd);
		a->ctl = NULL;
		break;
	case ERR_OPT_INVAL:
		ap_err(a, err, options);
		break;
	case ERR_OPT_NOVAL:
		ap_err(a, err, options);
		break;
	case ERR_AP_INVAL:
		ap_err(a, err);
		break;
	case ERR_CM_INVAL:
		ap_err(a, err, a->cid);
		break;
	case ERR_TRANS_INVAL:
		ap_err(a, ERR_TRANS_INVAL, cmd);
		break;
	}

	return (CFGA_LIB_ERROR);
}

static char *
ap_help_topics[] = {
	"\nSbd specific commands/options:\n\n",
	"\tcfgadm [-o parsable] -l ap_id\n",
	"\tcfgadm [-o unassign|nopoweroff] -c disconnect ap_id\n",
	"\tcfgadm -t ap_id\n",
	"\tcfgadm -x assign ap_id\n",
	"\tcfgadm -x unassign ap_id\n",
	"\tcfgadm -x poweron ap_id\n",
	"\tcfgadm -x poweroff ap_id\n",
	NULL
};

/*ARGSUSED*/
cfga_err_t
ap_help(struct cfga_msg *msgp, const char *options, cfga_flags_t flags)
{
	int len;
	char **p;
	char *q;

	if (msgp == NULL || msgp->message_routine == NULL)
		return (CFGA_OK);

	for (p = ap_help_topics; *p != NULL; p++) {
		if ((len = strlen(*p)) == 0)
			continue;
		if ((q = (char *)calloc(len + 1, 1)) == NULL)
			continue;
		(void) strcpy(q, *p);
		(*msgp->message_routine)(msgp->appdata_ptr, q);
		free(q);
	}

	return (CFGA_OK);
}

static char *
ap_dev_type(sbd_dev_stat_t *dst)
{
	char *type;

	switch (dst->ds_type) {
	case SBD_COMP_CPU:
		type = "cpu";
		break;
	case SBD_COMP_MEM:
		type = "memory";
		break;
	case SBD_COMP_IO:
		type = "io";
		break;
	case SBD_COMP_CMP:
		type = "cpu";
		break;
	default:
		type = "other";
		break;
	}

	DBG("ap_dev_type(%d)=%s\n", dst->ds_type, type);

	return (type);
}

static sbd_dev_stat_t *
ap_cm_stat(apd_t *a, int seq)
{
	sbd_stat_t *st;

	if (seq == CM_DFLT)
		return (a->cmstat);

	st = (sbd_stat_t *)a->stat;
	return (st->s_stat + seq);
}

char *
ap_cm_devpath(apd_t *a, int seq)
{
	int len;
	char *path;
	char *devpath;
	sbd_io_stat_t *dst;


	/*
	 * If no component sequence number is provided
	 * default to the current target component.
	 * Assume an io component so that we can get
	 * the path if the component is indeed of type io.
	 */
	if (seq == CM_DFLT)
		dst = (sbd_io_stat_t *)a->cmstat;
	else {
		sbd_stat_t *st;
		st = (sbd_stat_t *)a->stat;
		dst = (sbd_io_stat_t *)st->s_stat + seq;
	}

	if (dst->is_type != SBD_COMP_IO)
		path = NULL;
	else
		path = dst->is_pathname;

	if (str_valid(path)) {
		len = strlen(DEVDIR) + strlen(path) + 1;

		if ((devpath = calloc(1, len)) == NULL)
			return (NULL);

		(void) snprintf(devpath, len, "%s%s", DEVDIR, path);
	} else
		devpath = NULL;

	DBG("ap_cm_path(%d)=%s\n", seq, devpath ? devpath : "");

	return (devpath);
}

void
ap_cm_id(apd_t *a, int seq, char *id, size_t bufsize)
{
	int unit;
	char *name;
	sbd_dev_stat_t *dst;

	dst = ap_cm_stat(a, seq);

	unit = dst->ds_unit;
	name = dst->ds_name;

	/*
	 * If the component has a unit number,
	 * add it to the id, otherwise just use
	 * the component's name.
	 */
	if (unit == -1)
		(void) snprintf(id, bufsize, "%s", name);
	else
		(void) snprintf(id, bufsize, "%s%d", name, unit);

	DBG("ap_cm_id(%d)=%s\n", seq, id);
}

/*
 * Convert a component to a target type.
 */
ap_target_t
ap_cm_type(apd_t *a, int seq)
{
	ap_target_t c;
	sbd_dev_stat_t *dst;

	dst = ap_cm_stat(a, seq);

	switch (dst->ds_type) {
	case SBD_COMP_CPU:
		c = AP_CPU;
		break;
	case SBD_COMP_MEM:
		c = AP_MEM;
		break;
	case SBD_COMP_IO:
		c = AP_IO;
		break;
	case SBD_COMP_CMP:
		c = AP_CMP;
		break;
	default:
		c = AP_NONE;
		break;
	}

	return (c);
}

int
ap_cm_ncap(apd_t *a, int seq)
{
	sbd_dev_stat_t	*dst;
	int		ncap;

	dst = ap_cm_stat(a, seq);

	switch (dst->ds_type) {
	case SBD_COMP_CPU:
	case SBD_COMP_MEM:
	case SBD_COMP_IO:
		ncap = 1;
		break;
	case SBD_COMP_CMP:
		ncap = ((sbd_cmp_stat_t *)dst)->ps_ncores;
		break;
	default:
		ncap = 0;
		break;
	}

	return (ncap);
}

int
ap_cm_capacity(apd_t *a, int seq, void *cap, int *ncap, cfga_stat_t *ostate)
{
	int i;
	sbd_dev_stat_t *dst;
	cfga_stat_t os;

	if (cap == NULL)
		return (0);

	dst = ap_cm_stat(a, seq);
	os = (cfga_stat_t)dst->ds_ostate;
	if (os != CFGA_STAT_CONFIGURED && os != CFGA_STAT_UNCONFIGURED)
		return (0);
	if (ostate)
		*ostate = os;

	*ncap = 1;

	switch (dst->ds_type) {
	case SBD_COMP_CPU: {
		sbd_cpu_stat_t *cpu = (sbd_cpu_stat_t *)dst;
		*((processorid_t *)cap) = cpu->cs_cpuid;
		break;
	}
	case SBD_COMP_MEM: {
		sbd_mem_stat_t *mem = (sbd_mem_stat_t *)dst;
		*((long *)cap) = mem->ms_totpages;
		break;
	}
	case SBD_COMP_CMP: {
		sbd_cmp_stat_t	*cmp = (sbd_cmp_stat_t *)dst;
		processorid_t	*cpuid;

		cpuid = (processorid_t *)cap;
		for (i = 0; i < cmp->ps_ncores; i++) {
			cpuid[i] = cmp->ps_cpuid[i];
		}

		*ncap = cmp->ps_ncores;
		break;
	}
	default:
		return (0);
	}

	DBG("ap_cm_capacity(%d)=(", seq);
	for (i = 0; i < *ncap; i++) {
		DBG("%d ", ((int *)cap)[i]);
	}
	DBG("%d)\n", *ostate);

	return (1);
}

void
ap_cm_init(apd_t *a, cfga_list_data_t *ap, int seq)
{
	char *type;
	sbd_stat_t *st;
	sbd_dev_stat_t *dst;

	st = (sbd_stat_t *)a->stat;
	dst = st->s_stat + seq;
	type = ap_dev_type(dst);

	a->cmstat = (void *)dst;

	DBG("ap_cm_init bd=%d rs=%d os=%d type=<%s> seq=%d\n",
	    a->bnum, st->s_rstate, dst->ds_ostate, type, seq);

	(void) strncpy(ap->ap_type, type, sizeof (ap->ap_type));
	ap->ap_r_state = (cfga_stat_t)st->s_rstate;
	ap->ap_o_state = (cfga_stat_t)dst->ds_ostate;
	ap->ap_cond = (cfga_cond_t)dst->ds_cond;
	ap->ap_busy = (cfga_busy_t)dst->ds_busy;
	ap->ap_status_time = dst->ds_time;
	ap_info(a, ap->ap_info, ap_cm_tgt(dst->ds_type));
}

void
ap_state(apd_t *a, cfga_stat_t *rs, cfga_stat_t *os)
{
	sbd_stat_t *st;
	sbd_dev_stat_t *dst;

	st = (sbd_stat_t *)a->stat;
	dst = (sbd_dev_stat_t *)a->cmstat;

	if (rs != NULL) {
		if (a->tgt == AP_NONE)
			*rs = CFGA_STAT_NONE;
		else
			*rs = (cfga_stat_t)st->s_rstate;
	}

	if (os != NULL) {
		if (a->tgt == AP_NONE)
			*os = CFGA_STAT_NONE;
		else if (a->tgt == AP_BOARD)
			*os = (cfga_stat_t)st->s_ostate;
		else
			*os = (cfga_stat_t)dst->ds_ostate;
	}
}

#define	BI_POWERED		0
#define	BI_ASSIGNED		1

static const char *
binfo[] = {
	"powered-on",
	", assigned"
};

static const char *
binfo_parsable[] = {
	"powered-on",
	" assigned"
};

static void
bd_info(apd_t *a, cfga_info_t info, int parsable)
{
	int i;
	int nsep;
	const char **p;
	sbd_stat_t *st;
	char *end = &info[sizeof (cfga_info_t)];

	DBG("bd_info(%p)\n", (void *)info);

	st = (sbd_stat_t *)a->stat;

	if (parsable) {
		p = binfo_parsable;
		nsep = 1;
	} else {
		p = binfo;
		nsep = 2;
	}

	i = nsep;

	if (st->s_power) {
		info += snprintf(info, end - info, p[BI_POWERED]);
		i = 0;
	}
	if (st->s_assigned)
		info += snprintf(info, end - info, p[BI_ASSIGNED] + i);
}

#define	CI_CPUID		0
#define	CI_SPEED		1
#define	CI_ECACHE		2

static const char *
cpuinfo[] = {
	"cpuid %d",
	", speed %d MHz",
	", ecache %d MBytes"
};

static const char *
cpuinfo_parsable[] = {
	"cpuid=%d",
	" speed=%d",
	" ecache=%d"
};

static void
cpu_info(apd_t *a, cfga_info_t info, int parsable)
{
	const char **p;
	sbd_cpu_stat_t *dst;
	char *end = &info[sizeof (cfga_info_t)];

	DBG("cpu_info(%p)\n", (void *)info);

	dst = (sbd_cpu_stat_t *)a->cmstat;

	if (parsable)
		p = cpuinfo_parsable;
	else
		p = cpuinfo;

	info += snprintf(info, end - info, p[CI_CPUID], dst->cs_cpuid);
	info += snprintf(info, end - info, p[CI_SPEED], dst->cs_speed);
	info += snprintf(info, end - info, p[CI_ECACHE], dst->cs_ecache);
}

#define	MI_ADDRESS		0
#define	MI_SIZE			1
#define	MI_PERMANENT		2
#define	MI_UNCONFIGURABLE	3
#define	MI_SOURCE		4
#define	MI_TARGET		5
#define	MI_DELETED		6
#define	MI_REMAINING		7
#define	MI_INTERLEAVE		8

static const char *
meminfo_nonparsable[] = {
	"base address 0x%" PRIx64,
	", %lu KBytes total",
	", %lu KBytes permanent",
	", unconfigurable",
	", memory delete requested on %s",
	", memory delete in progress on %s",
	", %lu KBytes deleted",
	", %lu KBytes remaining",
	", inter board interleave"
};

static const char *
meminfo_parsable[] = {
	"address=0x%" PRIx64,
	" size=%lu",
	" permanent=%lu",
	" unconfigurable",
	" source=%s",
	" target=%s",
	" deleted=%lu",
	" remaining=%lu",
	" inter-board-interleave"
};


#define	_K1	1024

/*
 * This function assumes pagesize > 1024 and that
 * pagesize is a multiple of 1024.
 */
static ulong_t
pages_to_kbytes(uint_t pgs)
{
	long pagesize;

	pagesize = sysconf(_SC_PAGESIZE);
	return (pgs * (pagesize / _K1));
}

static uint64_t
pages_to_bytes(uint_t pgs)
{
	long pagesize;

	pagesize = sysconf(_SC_PAGESIZE);
	return ((uint64_t)pgs * pagesize);
}

static void
mem_info(apd_t *a, cfga_info_t info, int parsable)
{
	const char **p;
	sbd_mem_stat_t *dst;
	int want_progress;
	char *end = &info[sizeof (cfga_info_t)];

	DBG("mem_info(%p)\n", (void *)info);

	dst = (sbd_mem_stat_t *)a->cmstat;

	if (parsable)
		p = meminfo_parsable;
	else
		p = meminfo_nonparsable;

	info += snprintf(info, end - info, p[MI_ADDRESS],
	    pages_to_bytes(dst->ms_basepfn));
	info += snprintf(info, end - info, p[MI_SIZE],
	    pages_to_kbytes(dst->ms_totpages));

	if (dst->ms_noreloc_pages)
		info += snprintf(info, end - info, p[MI_PERMANENT],
		    pages_to_kbytes(dst->ms_noreloc_pages));
	if (!dst->ms_cage_enabled)
		info += snprintf(info, end - info, p[MI_UNCONFIGURABLE]);
	if (dst->ms_interleave)
		info += snprintf(info, end - info, p[MI_INTERLEAVE]);

	/*
	 * If there is a valid peer physical ap_id specified,
	 * convert it to a logical id.
	 */
	want_progress = 0;
	if (str_valid(dst->ms_peer_ap_id)) {
		char *cm;
		char *peer;
		char physid[MAXPATHLEN];
		char logid[MAXPATHLEN];

		(void) snprintf(physid, sizeof (physid), "%s%s",
		    DEVDIR, dst->ms_peer_ap_id);

		/*
		 * Save the component portion of the physid and
		 * add it back after converting to logical format.
		 */
		if ((cm = strstr(physid, "::")) != NULL) {
			*cm = '\0';
			cm += 2;
		}

		/* attempt to resolve to symlink */
		if (ap_symid(a, physid, logid, sizeof (logid)) == 0)
			peer = logid;
		else
			peer = physid;

		if (dst->ms_peer_is_target) {
			info += snprintf(info, end - info, p[MI_TARGET], peer);
			if (cm)
				info += snprintf(info, end - info, "::%s", cm);
			want_progress = 1;
		} else {
			info += snprintf(info, end - info, p[MI_SOURCE], peer);
			if (cm)
				info += snprintf(info, end - info, "::%s", cm);
		}
	}
	if (want_progress ||
	    (dst->ms_detpages != 0 && dst->ms_detpages != dst->ms_totpages)) {
		info += snprintf(info, end - info, p[MI_DELETED],
		    pages_to_kbytes(dst->ms_detpages));
		info += snprintf(info, end - info, p[MI_REMAINING],
		    pages_to_kbytes(dst->ms_totpages -
		    dst->ms_detpages));
	}
}

#define	II_DEVICE		0
#define	II_REFERENCED		1

static const char *
ioinfo[] = {
	"device %s",
	", referenced"
};

static const char *
ioinfo_parsable[] = {
	"device=%s",
	" referenced"
};

static void
io_info(apd_t *a, cfga_info_t info, int parsable)
{
	const char **p;
	sbd_io_stat_t *dst;
	char *end = &info[sizeof (cfga_info_t)];

	dst = (sbd_io_stat_t *)a->cmstat;

	if (parsable)
		p = ioinfo_parsable;
	else
		p = ioinfo;

	info += snprintf(info, end - info, p[II_DEVICE], dst->is_pathname);
	if (dst->is_referenced)
		info += snprintf(info, end - info, p[II_REFERENCED]);
}

#define	PI_CPUID		0
#define	PI_CPUID_PAIR		1
#define	PI_CPUID_CONT		2
#define	PI_CPUID_LAST		3
#define	PI_SPEED		4
#define	PI_ECACHE		5

static const char *
cmpinfo[] = {
	"cpuid %d",
	" and %d",
	", %d",
	", and %d",
	", speed %d MHz",
	", ecache %d MBytes"
};

static const char *
cmpinfo_parsable[] = {
	"cpuid=%d",
	",%d",
	",%d",
	",%d",
	" speed=%d",
	" ecache=%d"
};

static void
cmp_info(apd_t *a, cfga_info_t info, int parsable)
{
	int		i;
	int		last;
	const char	**p;
	sbd_cmp_stat_t	*dst;
	char *end = &info[sizeof (cfga_info_t)];

	DBG("cmp_info(%p)\n", (void *)info);

	dst = (sbd_cmp_stat_t *)a->cmstat;

	if (parsable)
		p = cmpinfo_parsable;
	else
		p = cmpinfo;

	/* Print the first cpuid */
	info += snprintf(info, end - info, p[PI_CPUID], dst->ps_cpuid[0]);

	/*
	 * Print the middle cpuids, if necessary. Stop before
	 * the last one, since printing the last cpuid is a
	 * special case for the non parsable form.
	 */
	for (i = 1; i < (dst->ps_ncores - 1); i++) {
		info += snprintf(info, end - info, p[PI_CPUID_CONT],
		    dst->ps_cpuid[i]);
	}

	/* Print the last cpuid, if necessary */
	if (dst->ps_ncores > 1) {
		last = (dst->ps_ncores == 2) ? PI_CPUID_PAIR : PI_CPUID_LAST;
		info += snprintf(info, end - info,
		    dgettext(TEXT_DOMAIN, p[last]), dst->ps_cpuid[i]);
	}

	info += snprintf(info, end - info, p[PI_SPEED], dst->ps_speed);
	info += snprintf(info, end - info, p[PI_ECACHE], dst->ps_ecache);
}

void
ap_info(apd_t *a, cfga_info_t info, ap_target_t tgt)
{
	int parsable = ap_getopt(a, OPT_PARSABLE);

	DBG("ap_info(%p, %d)\n", (void *)info, parsable);

	switch (tgt) {
	case AP_BOARD:
		bd_info(a, info, parsable);
		break;
	case AP_CPU:
		cpu_info(a, info, parsable);
		break;
	case AP_MEM:
		mem_info(a, info, parsable);
		break;
	case AP_IO:
		io_info(a, info, parsable);
		break;
	case AP_CMP:
		cmp_info(a, info, parsable);
		break;
	default:
		break;
	}
}