/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "cfga_scsi.h"

/* Structure for walking the tree */
typedef struct {
	apid_t		*apidp;
	char		*hba_logp;
	ldata_list_t	*listp;
	scfga_cmd_t	cmd;
	cfga_stat_t	chld_config;
	cfga_stat_t	hba_rstate;
	scfga_ret_t	ret;
	int		l_errno;
} scfga_list_t;

typedef struct {
	uint_t itype;
	const char *ntype;
	const char *name;
	const char *pathname;
} scfga_devtype_t;

/* The TYPE field is parseable and should not contain spaces */
#define	SCFGA_BUS_TYPE		"scsi-bus"

/* Function prototypes */
static scfga_ret_t postprocess_list_data(const ldata_list_t *listp,
    scfga_cmd_t cmd, cfga_stat_t chld_config, int *np);
static int stat_dev(di_node_t node, void *arg);
static scfga_ret_t do_stat_bus(scfga_list_t *lap, int limited_bus_stat);
static int get_bus_state(di_node_t node, void *arg);

static scfga_ret_t do_stat_dev(const di_node_t node, const char *nodepath,
    scfga_list_t *lap, int limited_dev_stat);
static cfga_stat_t bus_devinfo_to_recep_state(uint_t bus_di_state);
static cfga_stat_t dev_devinfo_to_occupant_state(uint_t dev_di_state);
static char *get_device_type(di_node_t, dyncomp_t);
static void get_hw_info(di_node_t node, cfga_list_data_t *clp, dyncomp_t type);
static scfga_ret_t create_pathinfo_ldata(di_path_t pi_node, scfga_list_t *lap,
    int *l_errnop);


static scfga_devtype_t device_list[] = {
	{ DTYPE_DIRECT,	    DDI_NT_BLOCK_CHAN,	"disk",		"disk-path"},
	{ DTYPE_DIRECT,	    DDI_NT_BLOCK,	"disk",		"disk-path"},
	{ DTYPE_DIRECT,	    DDI_NT_BLOCK_WWN,	"disk",		"disk-path"},
	{ DTYPE_DIRECT,	    DDI_NT_BLOCK_FABRIC,    "disk",	"disk-path"},
	{ DTYPE_DIRECT,	    DDI_NT_BLOCK_SAS,   "disk",		"disk-path"},
	{ DTYPE_SEQUENTIAL, DDI_NT_TAPE,	"tape",		"tape-path"},
	{ DTYPE_PRINTER,    NULL,		"printer",	"printer-path"},
	{ DTYPE_PROCESSOR,  NULL,		"processor",	"PRCS-path"},
	{ DTYPE_WORM,	    NULL,		"WORM",		"WORM-path"},
	{ DTYPE_RODIRECT,   DDI_NT_CD_CHAN,	"CD-ROM",	"CD-ROM-path"},
	{ DTYPE_RODIRECT,   DDI_NT_CD,		"CD-ROM",	"CD-ROM-path"},
	{ DTYPE_SCANNER,    NULL,		"scanner",	"scanner-path"},
	{ DTYPE_OPTICAL,    NULL,		"optical",	"optical-path"},
	{ DTYPE_CHANGER,    NULL,		"med-changer",	"MEDCHGR-path"},
	{ DTYPE_COMM,	    NULL,		"comm-device",	"COMDEV-path"},
	{ DTYPE_ARRAY_CTRL, NULL,		"array-ctrl",	"ARRCTRL-path"},
	{ DTYPE_ESI,	    NULL,		"ESI",		"ESI-path"}
};

#define	N_DEVICE_TYPES	(sizeof (device_list) / sizeof (device_list[0]))

scfga_ret_t
do_list(
	apid_t *apidp,
	scfga_cmd_t cmd,
	ldata_list_t **llpp,
	int *nelemp,
	char **errstring)
{
	int n = -1, l_errno = 0, limited_bus_stat;
	walkarg_t u;
	scfga_list_t larg = {NULL};
	scfga_ret_t ret;
	int init_flag;

	assert(apidp->hba_phys != NULL && apidp->path != NULL);

	if (*llpp != NULL || *nelemp != 0) {
		return (SCFGA_ERR);
	}

	/* Create the HBA logid (also base component of logical ap_id) */
	ret = make_hba_logid(apidp->hba_phys, &larg.hba_logp, &l_errno);
	if (ret != SCFGA_OK) {
		cfga_err(errstring, l_errno, ERR_LIST, 0);
		return (SCFGA_ERR);
	}

	assert(larg.hba_logp != NULL);

	larg.cmd = cmd;
	larg.apidp = apidp;
	larg.hba_rstate = CFGA_STAT_NONE;


	/*
	 * For all list commands, the bus  and 1 or more devices
	 * needs to be stat'ed
	 */

	/*
	 * By default we use DINFOCACHE to get a "full" snapshot
	 * This much faster than DINFOFORCE which actually
	 * attaches devices. DINFOFORCE used only if caller
	 * explicitly requests it via a private option.
	 */
	init_flag = (apidp->flags & FLAG_USE_DIFORCE) ? DINFOFORCE : DINFOCACHE;
	limited_bus_stat = 0;

	switch (larg.cmd) {
		case SCFGA_STAT_DEV:
			limited_bus_stat = 1; /* We need only bus state */
			/*FALLTHRU*/
		case SCFGA_STAT_ALL:
			break;
		case SCFGA_STAT_BUS:
			/* limited_bus_stat = 0 and no DINFOCACHE/DINFOFORCE */
			init_flag = 0;
			break;
		default:
			cfga_err(errstring, EINVAL, ERR_LIST, 0);
			goto out;
	}

	/*
	 * DINFOCACHE implies DINFOCPYALL. DINFOCPYALL shouldn't
	 * be ORed with DINFOCACHE, else libdevinfo will return
	 * error
	 */
	if (init_flag != DINFOCACHE)
		init_flag |= DINFOCPYALL;

	if ((ret = do_stat_bus(&larg, limited_bus_stat)) != SCFGA_OK) {
		cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
		goto out;
	}

#ifdef DEBUG
	if (limited_bus_stat) {
		assert(larg.listp == NULL);
	} else {
		assert(larg.listp != NULL);
	}
#endif

	/* Assume that the bus has no configured children */
	larg.chld_config = CFGA_STAT_UNCONFIGURED;

	/*
	 * If stat'ing a specific device, we don't know if it exists yet.
	 * If stat'ing a bus or a bus and child devices, we have at least the
	 * bus stat data at this point.
	 */
	if (larg.cmd == SCFGA_STAT_DEV) {
		larg.ret = SCFGA_APID_NOEXIST;
	} else {
		larg.ret = SCFGA_OK;
	}

	/* we need to stat at least 1 device for all commands */
	if (apidp->dyntype == PATH_APID) {
		/*
		 * When cmd is SCFGA_STAT_DEV and the ap id is pathinfo
		 * related.
		 */
		ret = walk_tree(apidp->hba_phys, &larg, init_flag, NULL,
		    SCFGA_WALK_PATH, &larg.l_errno);
	} else {
		/* we need to stat at least 1 device for all commands */
		u.node_args.flags = DI_WALK_CLDFIRST;
		u.node_args.fcn = stat_dev;

		/*
		 * Subtree is ALWAYS rooted at the HBA (not at the device) as
		 * otherwise deadlock may occur if bus is disconnected.
		 */
		ret = walk_tree(apidp->hba_phys, &larg, init_flag, &u,
		    SCFGA_WALK_NODE, &larg.l_errno);

		/*
		 * Check path info on the following conditions.
		 *
		 * - chld_config is still set to CFGA_STAT_UNCONFIGURED for
		 *   SCFGA_STAT_BUS cmd after walking any child node.
		 * - walking node succeeded for SCFGA_STAT_ALL cmd(Continue on
		 *   stating path info node).
		 * - apid is pathinfo associated and larg.ret is still set to
		 *   SCFGA_APID_NOEXIST for SCFGA_STAT_DEV cmd.
		 */
		if (((cmd == SCFGA_STAT_BUS) &&
		    (larg.chld_config == CFGA_STAT_UNCONFIGURED)) ||
		    ((cmd == SCFGA_STAT_ALL) && (ret == SCFGA_OK))) {
			ret = walk_tree(apidp->hba_phys, &larg, init_flag, NULL,
			    SCFGA_WALK_PATH, &larg.l_errno);
		}
	}

	if (ret != SCFGA_OK || (ret = larg.ret) != SCFGA_OK) {
		if (ret != SCFGA_APID_NOEXIST) {
			cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
		}
		goto out;
	}

	assert(larg.listp != NULL);

	n = 0;
	ret = postprocess_list_data(larg.listp, cmd, larg.chld_config, &n);
	if (ret != SCFGA_OK) {
		cfga_err(errstring, 0, ERR_LIST, 0);
		ret = SCFGA_LIB_ERR;
		goto out;
	}

	*nelemp = n;
	*llpp = larg.listp;
	ret = SCFGA_OK;
	/* FALLTHROUGH */
out:
	if (ret != SCFGA_OK) list_free(&larg.listp);
	S_FREE(larg.hba_logp);
	return (ret);
}

static scfga_ret_t
postprocess_list_data(
	const ldata_list_t *listp,
	scfga_cmd_t cmd,
	cfga_stat_t chld_config,
	int *np)
{
	ldata_list_t *tmplp = NULL;
	cfga_list_data_t *hba_ldatap = NULL;
	int i;


	*np = 0;

	if (listp == NULL) {
		return (SCFGA_ERR);
	}

	hba_ldatap = NULL;
	tmplp = (ldata_list_t *)listp;
	for (i = 0; tmplp != NULL; tmplp = tmplp->next) {
		i++;
		if (GET_DYN(tmplp->ldata.ap_phys_id) == NULL) {
			/* A bus stat data */
			assert(GET_DYN(tmplp->ldata.ap_log_id) == NULL);
			hba_ldatap = &tmplp->ldata;
#ifdef DEBUG
		} else {
			assert(GET_DYN(tmplp->ldata.ap_log_id) != NULL);
#endif
		}
	}

	switch (cmd) {
	case SCFGA_STAT_DEV:
		if (i != 1 || hba_ldatap != NULL) {
			return (SCFGA_LIB_ERR);
		}
		break;
	case SCFGA_STAT_BUS:
		if (i != 1 || hba_ldatap == NULL) {
			return (SCFGA_LIB_ERR);
		}
		break;
	case SCFGA_STAT_ALL:
		if (i < 1 || hba_ldatap == NULL) {
			return (SCFGA_LIB_ERR);
		}
		break;
	default:
		return (SCFGA_LIB_ERR);
	}

	*np = i;

	/* Fill in the occupant (child) state. */
	if (hba_ldatap != NULL) {
		hba_ldatap->ap_o_state = chld_config;
	}
	return (SCFGA_OK);
}

static int
stat_dev(di_node_t node, void *arg)
{
	scfga_list_t *lap = NULL;
	char *devfsp = NULL, *nodepath = NULL;
	size_t len = 0;
	int limited_dev_stat = 0, match_minor, rv;
	scfga_ret_t ret;

	lap = (scfga_list_t *)arg;

	/* Skip stub nodes */
	if (IS_STUB_NODE(node)) {
		return (DI_WALK_CONTINUE);
	}

	/* Skip partial nodes */
	if (!known_state(node)) {
		return (DI_WALK_CONTINUE);
	}

	devfsp = di_devfs_path(node);
	if (devfsp == NULL) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	len = strlen(DEVICES_DIR) + strlen(devfsp) + 1;

	nodepath = calloc(1, len);
	if (nodepath == NULL) {
		lap->l_errno = errno;
		lap->ret = SCFGA_LIB_ERR;
		rv = DI_WALK_TERMINATE;
		goto out;
	}

	(void) snprintf(nodepath, len, "%s%s", DEVICES_DIR, devfsp);

	/* Skip node if it is HBA */
	match_minor = 0;
	if (!dev_cmp(lap->apidp->hba_phys, nodepath, match_minor)) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	/* If stat'ing a specific device, is this that device */
	if (lap->cmd == SCFGA_STAT_DEV) {
		assert(lap->apidp->path != NULL);
		if (dev_cmp(lap->apidp->path, nodepath, match_minor)) {
			rv = DI_WALK_CONTINUE;
			goto out;
		}
	}

	/*
	 * If stat'ing a bus only, we look at device nodes only to get
	 * bus configuration status. So a limited stat will suffice.
	 */
	if (lap->cmd == SCFGA_STAT_BUS) {
		limited_dev_stat = 1;
	} else {
		limited_dev_stat = 0;
	}

	/*
	 * Ignore errors if stat'ing a bus or listing all
	 */
	ret = do_stat_dev(node, nodepath, lap, limited_dev_stat);
	if (ret != SCFGA_OK) {
		if (lap->cmd == SCFGA_STAT_DEV) {
			lap->ret = ret;
			rv = DI_WALK_TERMINATE;
		} else {
			rv = DI_WALK_CONTINUE;
		}
		goto out;
	}

	/* Are we done ? */
	rv = DI_WALK_CONTINUE;
	if (lap->cmd == SCFGA_STAT_BUS &&
	    lap->chld_config == CFGA_STAT_CONFIGURED) {
		rv = DI_WALK_TERMINATE;
	} else if (lap->cmd == SCFGA_STAT_DEV) {
		/*
		 * If stat'ing a specific device, we are done at this point.
		 */
		lap->ret = SCFGA_OK;
		rv = DI_WALK_TERMINATE;
	}

	/*FALLTHRU*/
out:
	S_FREE(nodepath);
	if (devfsp != NULL) di_devfs_path_free(devfsp);
	return (rv);
}

/*
 * Create list date entry and add to ldata list.
 */
static scfga_ret_t
create_pathinfo_ldata(di_path_t pi_node, scfga_list_t *lap, int *l_errnop)
{
	ldata_list_t	*listp = NULL;
	cfga_list_data_t	*clp;
	di_node_t	client_node = DI_NODE_NIL;
	di_minor_t	minor;
	scfga_ret_t 	ret;
	di_path_state_t	pi_state;
	char		*dyncomp = NULL, *client_path = NULL;
	char		pathbuf[MAXPATHLEN], *client_devlink = NULL;
	int		match_minor;

	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		lap->l_errno = errno;
		return (SCFGA_LIB_ERR);
	}
	clp = &listp->ldata;
	ret = make_path_dyncomp(pi_node, &dyncomp, &lap->l_errno);
	if (ret != SCFGA_OK) {
		S_FREE(listp);
		return (ret);
	}

	client_node = di_path_client_node(pi_node);
	if (client_node == DI_NODE_NIL) {
		*l_errnop = errno;
		S_FREE(dyncomp);
		return (SCFGA_LIB_ERR);
	}

	/* Create logical and physical ap_id */
	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id), "%s%s%s",
	    lap->hba_logp, DYN_SEP, dyncomp);

	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id), "%s%s%s",
	    lap->apidp->hba_phys, DYN_SEP, dyncomp);

	S_FREE(dyncomp);

	/* ap class filled in by libcfgadm */
	clp->ap_class[0] = '\0';
	clp->ap_r_state = lap->hba_rstate;
	/* path info exist so set to configured. */
	clp->ap_o_state = CFGA_STAT_CONFIGURED;

	/* now fill up ap_info field with client dev link and instance #. */
	client_path = di_devfs_path(client_node);
	if (client_path) {
		/* get first minor node. */
		minor = di_minor_next(client_node, DI_MINOR_NIL);
		if (minor == DI_MINOR_NIL) {
			match_minor = 0;
			(void) snprintf(pathbuf, MAXPATHLEN, "%s:%s",
			    DEVICES_DIR, client_path);
		} else {
			match_minor = 1;
			(void) snprintf(pathbuf, MAXPATHLEN, "%s%s:%s",
			    DEVICES_DIR, client_path, di_minor_name(minor));
		}
		(void) physpath_to_devlink(pathbuf, &client_devlink, l_errnop,
		    match_minor);
		di_devfs_path_free(client_path);
	}

	if (client_devlink) {
		(void) snprintf(clp->ap_info, CFGA_INFO_LEN,
		    "%s: %s", "Client Device", client_devlink);
		S_FREE(client_devlink);
	}

	get_hw_info(client_node, clp, PATH_APID);

	if ((pi_state = di_path_state(pi_node)) == DI_PATH_STATE_OFFLINE) {
		clp->ap_o_state = CFGA_STAT_UNCONFIGURED;
	}

	if (pi_state == DI_PATH_STATE_FAULT) {
		clp->ap_cond = CFGA_COND_FAILED;
	} else {
		clp->ap_cond = CFGA_COND_UNKNOWN;
	}

	/* no way to determine state change */
	clp->ap_busy = 0;
	clp->ap_status_time = (time_t)-1;

	/* Link it in */
	listp->next = lap->listp;
	lap->listp = listp;

	return (SCFGA_OK);
}

/*
 * Routine to stat pathinfo nodes.
 *
 * No pathinfo founds returns a success.
 * When cmd is SCFGA_STAT_DEV, finds a matching pathinfo node and
 * and create ldata if found.
 * When cmd is SCFGA_STAT_ALL, create ldata for each pathinfo node.
 * When cmd is SCFGA_STAT_BUS, checks if any pathinfo exist.
 *
 * Return:
 *  0 for success
 *  -1 for failure.
 */
int
stat_path_info(
	di_node_t 	root,
	void		*arg,
	int 		*l_errnop)
{
	scfga_list_t	*lap = (scfga_list_t *)arg;
	di_path_t	pi_node;

	if (root == DI_NODE_NIL) {
		return (-1);
	}

	/*
	 * when there is no path_info node return SCFGA_OK.
	 */
	if (di_path_next_client(root, DI_PATH_NIL) == DI_PATH_NIL) {
		return (0);
	}

	if (lap->cmd == SCFGA_STAT_BUS) {
		lap->chld_config = CFGA_STAT_CONFIGURED;
		return (0);
	} else if (lap->cmd == SCFGA_STAT_DEV) {
		assert(lap->apidp->dyntype == PATH_APID);
		for (pi_node = di_path_next_client(root, DI_PATH_NIL); pi_node;
		    pi_node = di_path_next_client(root, pi_node)) {
			/*
			 * NOTE: apidt_create() validated pathinfo apid so
			 * the apid should have a valid format.
			 */

			/* check the length first. */
			if (strlen(di_path_bus_addr(pi_node)) !=
			    strlen(lap->apidp->dyncomp)) {
				continue;
			}

			/* check for full match. */
			if (strcmp(di_path_bus_addr(pi_node),
			    lap->apidp->dyncomp)) {
				continue;
			}

			/* found match, record information */
			if (create_pathinfo_ldata(pi_node, lap,
			    l_errnop) == SCFGA_OK) {
				lap->ret = SCFGA_OK;
				return (0);
			} else {
				return (-1);
			}
		}
	} else { /* cmd = STAT_ALL */
		/* set child config to configured */
		lap->chld_config = CFGA_STAT_CONFIGURED;
		for (pi_node = di_path_next_client(root, DI_PATH_NIL); pi_node;
		    pi_node = di_path_next_client(root, pi_node)) {
			/* continue on even if there is an error on one path. */
			(void) create_pathinfo_ldata(pi_node, lap, l_errnop);
		}
	}

	lap->ret = SCFGA_OK;
	return (0);

}

struct bus_state {
	int	b_state;
	int	b_retired;
	char	iconnect_type[16];
};

static scfga_ret_t
do_stat_bus(scfga_list_t *lap, int limited_bus_stat)
{
	cfga_list_data_t *clp = NULL;
	ldata_list_t *listp = NULL;
	int l_errno = 0;
	struct bus_state bstate = {0};
	walkarg_t u;
	scfga_ret_t ret;
	int i;
	char itypelower[MAXNAMELEN];

	assert(lap->hba_logp != NULL);

	/* Get bus state */
	u.node_args.flags = 0;
	u.node_args.fcn = get_bus_state;

	ret = walk_tree(lap->apidp->hba_phys, &bstate, DINFOPROP, &u,
	    SCFGA_WALK_NODE, &l_errno);
	if (ret == SCFGA_OK) {
		lap->hba_rstate = bus_devinfo_to_recep_state(bstate.b_state);
	} else {
		lap->hba_rstate = CFGA_STAT_NONE;
	}

	if (limited_bus_stat) {
		/* We only want to know bus(receptacle) connect status */
		return (SCFGA_OK);
	}

	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		lap->l_errno = errno;
		return (SCFGA_LIB_ERR);
	}

	clp = &listp->ldata;

	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id), "%s",
	    lap->hba_logp);
	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id), "%s",
	    lap->apidp->hba_phys);

	clp->ap_class[0] = '\0';	/* Filled by libcfgadm */
	clp->ap_r_state = lap->hba_rstate;
	clp->ap_o_state = CFGA_STAT_NONE; /* filled in later by the plug-in */
	clp->ap_cond =
	    (bstate.b_retired) ? CFGA_COND_FAILED : CFGA_COND_UNKNOWN;
	clp->ap_busy = 0;
	clp->ap_status_time = (time_t)-1;
	clp->ap_info[0] = '\0';

	if (bstate.iconnect_type) {
		/*
		 * For SPI type, keep the existing SCFGA_BUS_TYPE.
		 * For other types, the ap type will be scsi-'interconnct-type'.
		 */
		if (strcmp(bstate.iconnect_type, "SPI") == 0) {
			(void) snprintf(clp->ap_type, sizeof (clp->ap_type),
			    "%s", SCFGA_BUS_TYPE);
		} else {
			for (i = 0; i < strlen(bstate.iconnect_type); i++) {
				itypelower[i] =
				    tolower(bstate.iconnect_type[i]);
			}
			itypelower[i] = '\0';
			(void) snprintf(clp->ap_type, sizeof (clp->ap_type),
			    "%s-%s", "scsi", itypelower);
		}
	}

	/* Link it in */
	listp->next = lap->listp;
	lap->listp = listp;

	return (SCFGA_OK);
}

static int
get_bus_state(di_node_t node, void *arg)
{
	struct bus_state *bsp = (struct bus_state *)arg;
	char *itype = NULL;

	bsp->b_state = di_state(node);
	bsp->b_retired = di_retired(node);
	(void) di_prop_lookup_strings(DDI_DEV_T_ANY,
	    node, "initiator-interconnect-type", &itype);
	if (itype != NULL) {
		(void) strlcpy(bsp->iconnect_type, itype, 16);
	} else {
		bsp->iconnect_type[0] = '\0';
	}

	return (DI_WALK_TERMINATE);
}

static scfga_ret_t
do_stat_dev(
	const di_node_t node,
	const char *nodepath,
	scfga_list_t *lap,
	int limited_dev_stat)
{
	uint_t devinfo_state = 0;
	char *dyncomp = NULL;
	cfga_list_data_t *clp = NULL;
	ldata_list_t *listp = NULL;
	cfga_stat_t ostate;
	scfga_ret_t ret;

	assert(lap->apidp->hba_phys != NULL);
	assert(lap->hba_logp != NULL);

	devinfo_state = di_state(node);
	ostate = dev_devinfo_to_occupant_state(devinfo_state);

	/* If child device is configured, record it */
	if (ostate == CFGA_STAT_CONFIGURED) {
		lap->chld_config = CFGA_STAT_CONFIGURED;
	}

	if (limited_dev_stat) {
		/* We only want to know device config state */
		return (SCFGA_OK);
	}

	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		lap->l_errno = errno;
		return (SCFGA_LIB_ERR);
	}

	clp = &listp->ldata;

	/* Create the dynamic component */
	ret = make_dyncomp(node, nodepath, &dyncomp, &lap->l_errno);
	if (ret != SCFGA_OK) {
		S_FREE(listp);
		return (ret);
	}

	assert(dyncomp != NULL);

	/* Create logical and physical ap_id */
	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id), "%s%s%s",
	    lap->hba_logp, DYN_SEP, dyncomp);

	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id), "%s%s%s",
	    lap->apidp->hba_phys, DYN_SEP, dyncomp);

	S_FREE(dyncomp);

	clp->ap_class[0] = '\0'; /* Filled in by libcfgadm */
	clp->ap_r_state = lap->hba_rstate;
	clp->ap_o_state = ostate;
	clp->ap_cond = di_retired(node) ? CFGA_COND_FAILED : CFGA_COND_UNKNOWN;
	clp->ap_busy = 0; /* no way to determine state change */
	clp->ap_status_time = (time_t)-1;

	get_hw_info(node, clp, DEV_APID);

	/* Link it in */
	listp->next = lap->listp;
	lap->listp = listp;

	return (SCFGA_OK);
}

/* fill in device type, vid, pid from properties */
static void
get_hw_info(di_node_t node, cfga_list_data_t *clp, dyncomp_t type)
{
	char *cp = NULL;
	char *inq_vid, *inq_pid;
	char client_inst[MAXNAMELEN];

	/*
	 * Fill in type information
	 */
	cp = (char *)get_device_type(node, type);
	if (cp == NULL) {
		cp = (char *)GET_MSG_STR(ERR_UNAVAILABLE);
	}
	(void) snprintf(clp->ap_type, sizeof (clp->ap_type), "%s", S_STR(cp));

	if (type == DEV_APID) {
		/*
		 * Fill in vendor and product ID.
		 */
		if ((di_prop_lookup_strings(DDI_DEV_T_ANY, node,
		    "inquiry-product-id", &inq_pid) == 1) &&
		    (di_prop_lookup_strings(DDI_DEV_T_ANY, node,
		    "inquiry-vendor-id", &inq_vid) == 1)) {
			(void) snprintf(clp->ap_info, sizeof (clp->ap_info),
			    "%s %s", inq_vid, inq_pid);
		}
	} else {
		if ((di_driver_name(node) != NULL) &&
		    (di_instance(node) != -1)) {
			if (clp->ap_info == NULL) {
				(void) snprintf(client_inst, MAXNAMELEN - 1,
				    "%s%d", di_driver_name(node),
				    di_instance(node));
				(void) snprintf(clp->ap_info, MAXNAMELEN - 1,
				    "Client Device: %s", client_inst);
			} else {
				(void) snprintf(client_inst, MAXNAMELEN - 1,
				    "(%s%d)", di_driver_name(node),
				    di_instance(node));
				(void) strlcat(clp->ap_info, client_inst,
				    CFGA_INFO_LEN);
			}
		}

	}
}

/*
 * Get dtype from "inquiry-device-type" property. If not present,
 * derive it from minor node type
 */
static char *
get_device_type(di_node_t node, dyncomp_t type)
{
	char *name = NULL;
	int *inq_dtype;
	int i;

	if (di_prop_find(DDI_DEV_T_ANY, node, "smp-device") != DI_PROP_NIL) {
		return ("smp");
	}

	/* first, derive type based on inquiry property */
	if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "inquiry-device-type",
	    &inq_dtype) == 1) {
		int itype = (*inq_dtype) & DTYPE_MASK;

		for (i = 0; i < N_DEVICE_TYPES; i++) {
			if (device_list[i].itype == DTYPE_UNKNOWN)
				continue;
			if (itype == device_list[i].itype) {
				name = (type == DEV_APID) ?
				    (char *)device_list[i].name :
				    (char *)device_list[i].pathname;
				break;
			}
		}
	}

	/* if property fails, use minor nodetype */
	if (name == NULL) {
		char *nodetype;
		di_minor_t minor = di_minor_next(node, DI_MINOR_NIL);

		if ((minor != DI_MINOR_NIL) &&
		    ((nodetype = di_minor_nodetype(minor)) != NULL)) {
			for (i = 0; i < N_DEVICE_TYPES; i++) {
				if (device_list[i].ntype &&
				    (strcmp(nodetype, device_list[i].ntype)
				    == 0)) {
					name = (type == DEV_APID) ?
					    (char *)device_list[i].name :
					    (char *)device_list[i].pathname;
					break;
				}
			}
		}
	}

	if (name == NULL)	/* default to unknown */
		name = "unknown";
	return (name);
}

/* Transform linked list into an array */
scfga_ret_t
list_ext_postprocess(
	ldata_list_t		**llpp,
	int			nelem,
	cfga_list_data_t	**ap_id_list,
	int			*nlistp,
	char			**errstring)
{
	cfga_list_data_t *ldatap = NULL;
	ldata_list_t *tmplp = NULL;
	int i = -1;

	*ap_id_list = NULL;
	*nlistp = 0;

	if (*llpp == NULL || nelem < 0) {
		return (SCFGA_LIB_ERR);
	}

	if (nelem == 0) {
		return (SCFGA_APID_NOEXIST);
	}

	ldatap = calloc(nelem, sizeof (cfga_list_data_t));
	if (ldatap == NULL) {
		cfga_err(errstring, errno, ERR_LIST, 0);
		return (SCFGA_LIB_ERR);
	}

	/* Extract the list_data structures from the linked list */
	tmplp = *llpp;
	for (i = 0; i < nelem && tmplp != NULL; i++) {
		ldatap[i] = tmplp->ldata;
		tmplp = tmplp->next;
	}

	if (i < nelem || tmplp != NULL) {
		S_FREE(ldatap);
		return (SCFGA_LIB_ERR);
	}

	*nlistp = nelem;
	*ap_id_list = ldatap;

	return (SCFGA_OK);
}

/*
 * Convert bus state to receptacle state
 */
static cfga_stat_t
bus_devinfo_to_recep_state(uint_t bus_di_state)
{
	if (bus_di_state & (DI_BUS_QUIESCED | DI_BUS_DOWN))
		return (CFGA_STAT_DISCONNECTED);

	return (CFGA_STAT_CONNECTED);
}

/*
 * Convert device state to occupant state
 */
static cfga_stat_t
dev_devinfo_to_occupant_state(uint_t dev_di_state)
{
	if (dev_di_state & (DI_DEVICE_OFFLINE | DI_DEVICE_DOWN))
		return (CFGA_STAT_UNCONFIGURED);

	if (!(dev_di_state & DI_DRIVER_DETACHED))
		return (CFGA_STAT_CONFIGURED);

	return (CFGA_STAT_NONE);
}