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


#include "cfga_fp.h"

/* Function prototypes */

static fpcfga_ret_t get_xport_devlink(const char *hba_phys,
    char **hba_logpp, int *l_errnop);
static char ctoi(char c);
static fpcfga_ret_t is_apid_configured(const char *xport_phys,
	const char *dyncomp, struct luninfo_list **lunlistpp, int *l_errnop);
static fpcfga_ret_t insert_lun_to_lunlist(struct luninfo_list **lunlistpp,
	const char *dyncomp, di_node_t devnode, int *l_errnop);
static fpcfga_ret_t update_lunlist(struct luninfo_list **lunlistpp, int lun,
	uint_t	state, char *pathp, int	*l_errnop);


/* Globals */

/* Various conversions routines */

void
cvt_lawwn_to_dyncomp(const la_wwn_t *pwwn, char **dyncomp, int *l_errnop)
{
	*dyncomp = calloc(1, WWN_SIZE*2 + 1);
	if (*dyncomp == NULL) {
		*l_errnop = errno;
	}

	(void) sprintf(*dyncomp, "%016llx",
	(wwnConversion((uchar_t *)pwwn->raw_wwn)));
}


int
cvt_dyncomp_to_lawwn(const char *dyncomp, la_wwn_t *port_wwn)
{
	int	i;
	char	c, c1;
	uchar_t	*wwnp;

	wwnp = port_wwn->raw_wwn;
	for (i = 0; i < WWN_SIZE; i++, wwnp++) {

		c = ctoi(*dyncomp++);
		c1 = ctoi(*dyncomp++);
		if (c == -1 || c1 == -1)
			return (-1);
		*wwnp = ((c << 4) + c1);
	}

	return (0);
}


static char
ctoi(char c)
{
	if ((c >= '0') && (c <= '9'))
		c -= '0';
	else if ((c >= 'A') && (c <= 'F'))
		c = c - 'A' + 10;
	else if ((c >= 'a') && (c <= 'f'))
		c = c - 'a' + 10;
	else
		c = -1;
	return (c);
}


/*
 * Generates the HBA logical ap_id from physical ap_id.
 */
fpcfga_ret_t
make_xport_logid(const char *xport_phys, char **xport_logpp, int *l_errnop)
{
	if (*xport_logpp != NULL) {
		return (FPCFGA_ERR);
	}

	/*
	 * A devlink for the XPORT should exist.  Without the /dev/cfg link
	 * driver name and instance number based based link needs to be
	 * constructed for the minor node type of DDI_NT_FC_ATTACHMENT_POINT.
	 * sunddi.h defines DDI_NT_FC_ATTACHMENT_POINT for
	 * ddi_ctl:attachment_point:fc
	 */
	if (get_xport_devlink(xport_phys, xport_logpp, l_errnop) == FPCFGA_OK) {
		assert(*xport_logpp != NULL);
		return (FPCFGA_OK);
	} else {
		return (FPCFGA_ERR);
	}
}

static fpcfga_ret_t
get_xport_devlink(const char *xport_phys, char **xport_logpp, int *l_errnop)
{
	int match_minor;
	size_t len;
	fpcfga_ret_t ret;

	match_minor = 1;
	ret = physpath_to_devlink(CFGA_DEV_DIR, (char *)xport_phys,
	    xport_logpp, l_errnop, match_minor);
	if (ret != FPCFGA_OK) {
		return (ret);
	}

	assert(*xport_logpp != NULL);

	/* Remove the "/dev/cfg/"  prefix */
	len = strlen(CFGA_DEV_DIR SLASH);

	(void) memmove(*xport_logpp, *xport_logpp + len,
	    strlen(*xport_logpp + len) + 1);

	return (FPCFGA_OK);
}


/*
 * Given a xport path and dynamic ap_id, returns the physical
 * path in pathpp.  If the dynamic ap is not configured pathpp set to NULL
 * and returns FPCFGA_APID_NOCONFIGURE.
 */
fpcfga_ret_t
dyn_apid_to_path(
	const char *xport_phys,
	const char *dyncomp,
	struct luninfo_list **lunlistpp,
	int *l_errnop)
{
	fpcfga_ret_t 	ret;

	/* A device MUST have a dynamic component */
	if (dyncomp == NULL) {
		return (FPCFGA_LIB_ERR);
	}

	ret = is_apid_configured(xport_phys, dyncomp, lunlistpp, l_errnop);

	assert(ret != FPCFGA_OK);

	return (ret);
}

/*
 * When both the transport and dynamic comp are given this function
 * checks to see if the dynamic ap is configured on the dev tree.
 * If it is configured the devfs path will be stored in pathpp.
 * When the dynamic comp is null this function check to see if the transport
 * node has any child.
 *
 * Retrun value: FPCFGA_OK if the apid is configured.
 *		 FPCFGA_APID_NOCONFIGURE if the apid is not configured.
 *		 FPCFGA_LIB_ERR for other errors.
 */
static fpcfga_ret_t
is_apid_configured(
	const char *xport_phys,
	const char *dyncomp,
	struct luninfo_list **lunlistpp,
	int *l_errnop)
{
	char 		*devfs_phys, *devfs_fp_path, *client_path, *cp,
			*pathp = NULL;
	char 		path_name[MAXPATHLEN];
	di_node_t	tree_root, root, fpnode, dev_node, client_node;
	di_path_t 	path = DI_PATH_NIL;
	di_prop_t	prop = DI_PROP_NIL;
	uchar_t		*port_wwn_data = NULL;
	char		*lun_guid = NULL;
	char		port_wwn[WWN_SIZE*2+1];
	int		count, *lunnump, devlen,
			found_fp = 0;
	uint_t		state;
	uint_t		statep;
	fpcfga_ret_t 	ret;

	if (*lunlistpp != NULL) {
		return (FPCFGA_LIB_ERR);
	}

	ret = FPCFGA_APID_NOCONFIGURE;

	if ((devfs_phys = strdup(xport_phys)) == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	if (strncmp(devfs_phys, DEVICES_DIR SLASH, strlen(DEVICES_DIR) +
			strlen(SLASH)) == 0) {
		cp = devfs_phys + strlen(DEVICES_DIR);
		(void) memmove(devfs_phys, cp, strlen(cp) + 1);
	}

	if ((cp = strstr(devfs_phys, MINOR_SEP)) != NULL) {
		*cp = '\0';  /* Terminate string. */
	}

	if ((tree_root = di_init("/", DINFOCPYALL | DINFOPATH))
			== DI_NODE_NIL) {
		*l_errnop = errno;
		S_FREE(devfs_phys);
		return (FPCFGA_LIB_ERR);
	}

	fpnode = di_drv_first_node("fp", tree_root);

	while (fpnode) {
		devfs_fp_path = di_devfs_path(fpnode);
		if ((devfs_fp_path) && !(strncmp(devfs_fp_path,
				devfs_phys, strlen(devfs_phys)))) {
			found_fp = 1;
			di_devfs_path_free(devfs_fp_path);
			break;
		}
		di_devfs_path_free(devfs_fp_path);
		fpnode = di_drv_next_node(fpnode);
	}
	if (!(found_fp)) {
		ret = FPCFGA_LIB_ERR;
		goto out;
	} else {
		root = fpnode;
	}

	/*
	 * when there is no child and path info node the
	 * FPCFGA_APID_NOCONFIGURE is returned
	 * regardless of the dynamic comp.
	 */
	dev_node = di_child_node(root);
	path = di_path_next_client(root, path);
	if ((dev_node == DI_NODE_NIL) && (path == DI_PATH_NIL)) {
		*l_errnop = errno;
		ret = FPCFGA_APID_NOCONFIGURE;
		goto out;
	}

	/*
	 * when dyn comp is null the function just checks if there is any
	 * child under fp transport attachment point.
	 */
	if (dyncomp == NULL) {
		ret = FPCFGA_OK;
		goto out;
	}

	/*
	 * now checks the children node to find
	 * if dynamic ap is configured. if there are multiple luns
	 * store into lunlist.
	 */
	if (dev_node != DI_NODE_NIL) {
		do {
			while ((prop = di_prop_next(dev_node, prop)) !=
					DI_PROP_NIL) {
				/* is property name port-wwn */
				if ((!(strcmp(PORT_WWN_PROP,
					di_prop_name(prop)))) &&
					(di_prop_type(prop) ==
					DI_PROP_TYPE_BYTE)) {
					break;
				}
			}

			if (prop != DI_PROP_NIL) {
				count = di_prop_bytes(prop, &port_wwn_data);
				if (count != WWN_SIZE) {
					ret = FPCFGA_LIB_ERR;
					goto out;
				} else {
					(void) sprintf(port_wwn,
				"%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
					port_wwn_data[0], port_wwn_data[1],
					port_wwn_data[2], port_wwn_data[3],
					port_wwn_data[4], port_wwn_data[5],
					port_wwn_data[6], port_wwn_data[7]);
					if (!(strncmp(port_wwn, dyncomp,
							WWN_SIZE*2))) {
						ret = insert_lun_to_lunlist(
							lunlistpp, dyncomp,
							dev_node, l_errnop);
						if (ret != FPCFGA_OK) {
							goto out;
						}
					}
				}
			}
			dev_node = di_sibling_node(dev_node);
			prop = DI_PROP_NIL;
		} while (dev_node != DI_NODE_NIL);
	}

	/*
	 * now checks the path info node to find
	 * if dynamic ap is configured. if there are multiple luns
	 * store into lunlist.
	 */
	if (path != DI_PATH_NIL) {
		/*
		 * now parse the path info node.
		 */
		do {
			count = di_path_prop_lookup_bytes(path, PORT_WWN_PROP,
				&port_wwn_data);
			if (count != WWN_SIZE) {
				ret = FPCFGA_LIB_ERR;
				goto out;
			}

			(void) sprintf(port_wwn,
				"%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
				port_wwn_data[0], port_wwn_data[1],
				port_wwn_data[2], port_wwn_data[3],
				port_wwn_data[4], port_wwn_data[5],
				port_wwn_data[6], port_wwn_data[7]);

			/* if matches get the path of scsi_vhci child node. */
			if (!(strncmp(port_wwn, dyncomp, WWN_SIZE*2))) {
				client_node = di_path_client_node(path);
				if (client_node == DI_NODE_NIL) {
					ret = FPCFGA_LIB_ERR;
					*l_errnop = errno;
					goto out;
				}
				count = di_path_prop_lookup_ints(path,
						LUN_PROP, &lunnump);
				client_path = di_devfs_path(client_node);
				strcpy(path_name, client_path);
				di_devfs_path_free(client_path);
				state = di_state(client_node);
				statep = di_path_state(path);

				/*
				 * If the node is
				 * state then check the devfs_path to
				 * see if it has a complete path.
				 * For non scsi_vhci node the path
				 * doesn't contain @w(portwwn) part
				 * consistently.  For scsi_vhci
				 * this behavior may not be there.
				 * To be safe @g(guid) is attempted
				 * to be added here.
				 */
				if ((state & DI_DRIVER_DETACHED) &&
					(strstr(path_name, "@g") == NULL)) {
					prop = DI_PROP_NIL;
					while ((prop = di_prop_next(client_node,
							prop)) != DI_PROP_NIL) {
						/* is property name lun-wwn */
						if ((!(strcmp(LUN_GUID_PROP,
							di_prop_name(prop)))) &&
							(di_prop_type(prop) ==
							DI_PROP_TYPE_STRING)) {
							break;
						}
					}

					if (prop != DI_PROP_NIL) {
						count = di_prop_strings(
							prop, &lun_guid);
						sprintf(&path_name[
							strlen(path_name)],
							"@g%s", lun_guid);
					} else {
						ret = FPCFGA_LIB_ERR;
						goto out;
					}
				}

				devlen = strlen(DEVICES_DIR) +
						strlen(path_name) + 1;
				if ((pathp = calloc(1, devlen))
						== NULL) {
					*l_errnop = errno;
					return (FPCFGA_LIB_ERR);
				} else {
					(void) snprintf(pathp, devlen,
					"%s%s", DEVICES_DIR, path_name);
				}
				if ((ret = (update_lunlist(lunlistpp, *lunnump,
						statep, pathp, l_errnop))) !=
						FPCFGA_OK) {
					S_FREE(pathp);
					goto out;
				}
			}
			path = di_path_next_client(root, path);
		} while (path != DI_PATH_NIL);
	}

out:
	di_fini(tree_root);
	S_FREE(devfs_phys);
	return (ret);
}

static fpcfga_ret_t
insert_lun_to_lunlist(
	struct luninfo_list **lunlistpp,
	const char *dyncomp,
	di_node_t dev_node,
	int *l_errnop)
{
	char		path_name[MAXPATHLEN];
	char 		*pathp, *dev_phys;
	di_prop_t	prop_lun = DI_PROP_NIL;
	uint_t 		state;
	int		count, devlen;
	int		*lunp;

	while ((prop_lun = di_prop_next(dev_node, prop_lun)) != DI_PROP_NIL) {
		if (!(strcmp(LUN_PROP, di_prop_name(prop_lun))) &&
				(di_prop_type(prop_lun) == DI_PROP_TYPE_INT)) {
			count = di_prop_ints(prop_lun, &lunp);
			if (count <= 0) {
				return (FPCFGA_LIB_ERR);
			}
			break;
		}
	}

	if (prop_lun == DI_PROP_NIL) {
		return (FPCFGA_LIB_ERR);
	}

	/*
	 * stores state info in state.
	 * This information is used to get the
	 * validity of path.
	 * if driver_detached don't try to get
	 * the devfs_path since it is not
	 * complete. ex, /pci@1f,2000/pci@1/
	 * SUNW,qlc@5/fp@0,0/ssd
	 * which doesn't contain the port wwn
	 * part.  The attached node looks like
	 * /pci@1f,2000/pci@1/SUNW,qlc@5/fp@0,0/
	 * ssd@w2100002037006b14,0
	 */
	state = di_state(dev_node);

	dev_phys = di_devfs_path(dev_node);
	if (dev_phys == NULL) {
		return (FPCFGA_LIB_ERR);
	}

	strcpy(path_name, dev_phys);

	di_devfs_path_free(dev_phys);

	if ((state & DI_DRIVER_DETACHED) &&
		(strstr(path_name, "@w") == NULL)) {
		sprintf(&path_name[strlen(path_name)], "@w%s,%x", dyncomp,
									*lunp);
	}

	devlen = strlen(DEVICES_DIR) + strlen(path_name) + 1;

	if ((pathp = calloc(1, devlen))
			== NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	} else {
		(void) snprintf(pathp, devlen, "%s%s", DEVICES_DIR, path_name);
	}

	return (update_lunlist(lunlistpp, *lunp, state, pathp, l_errnop));
}

static fpcfga_ret_t
update_lunlist(
	struct luninfo_list **lunlistpp,
	int	lun,
	uint_t	state,
	char 	*pathp,
	int 	*l_errnop)
{
	struct luninfo_list *newlun, *curlun, *prevlun;

	newlun = curlun = prevlun = (struct luninfo_list *)NULL;

	newlun = calloc(1, sizeof (struct luninfo_list));
	if (newlun == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	newlun->lunnum = lun;
	newlun->node_state = state;
	newlun->path = pathp;
	newlun->next = (struct luninfo_list *)NULL;

	/* if lunlist is empty add the new lun info and return. */
	if (*lunlistpp == NULL) {
		*lunlistpp = newlun;
		return (FPCFGA_OK);
	}

	/* if the first lun in the list is the same as the new lun return. */
	if ((*lunlistpp)->lunnum == lun) {
		S_FREE(newlun);
		return (FPCFGA_OK);
	}

	/*
	 * if the first lun in the list is less than the new lun add the
	 * new lun as the first lun and return.
	 */
	if ((*lunlistpp)->lunnum < lun) {
		newlun->next = *lunlistpp;
		*lunlistpp = newlun;
		return (FPCFGA_OK);
	}

	/*
	 * if the first lun in the list is greater than the new lun and
	 * there is a single lun add new lun after the first lun and return.
	 */
	if ((*lunlistpp)->next == NULL) {
		(*lunlistpp)->next = newlun;
		return (FPCFGA_OK);
	}

	/*
	 * now there is more than two luns in the list and the first lun
	 * is greter than the input lun.
	 */
	curlun = (*lunlistpp)->next;
	prevlun = *lunlistpp;

	while (curlun != NULL) {
		if (curlun->lunnum == lun) {
			S_FREE(newlun);
			return (FPCFGA_OK);
		} else if (curlun->lunnum < lun) {
			newlun->next = curlun;
			prevlun->next = newlun;
			return (FPCFGA_OK);
		} else {
			prevlun = curlun;
			curlun = curlun->next;
		}
	}

	/* add the new lun at the end of list. */
	prevlun->next = newlun;
	return (FPCFGA_OK);

}


fpcfga_ret_t
make_dyncomp_from_dinode(
	const di_node_t node,
	char **dyncompp,
	int *l_errnop)
{
	di_prop_t	prop = DI_PROP_NIL;
	uchar_t		*port_wwn_data;
	int		count;

	*l_errnop = 0;
	*dyncompp = calloc(1, WWN_SIZE*2 + 1);
	if (*dyncompp == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	/* now get port-wwn for the input node. */
	while ((prop = di_prop_next(node, prop)) != DI_PROP_NIL) {
		if (!(strcmp(PORT_WWN_PROP, di_prop_name(prop))) &&
			(di_prop_type(prop) == DI_PROP_TYPE_BYTE)) {
			break;
		}
	}

	if (prop != DI_PROP_NIL) {
		count = di_prop_bytes(prop, &port_wwn_data);
		if (count != WWN_SIZE) {
			S_FREE(*dyncompp);
			return (FPCFGA_LIB_ERR);
		}

		(void) sprintf(*dyncompp, "%016llx",
			(wwnConversion(port_wwn_data)));
	} else {
		*l_errnop = errno;
		S_FREE(*dyncompp);
		return (FPCFGA_LIB_ERR);
	}

	return (FPCFGA_OK);
}

fpcfga_ret_t
make_portwwn_luncomp_from_dinode(
	const di_node_t node,
	char **dyncompp,
	int **luncompp,
	int *l_errnop)
{
	uchar_t		*port_wwn_data;
	int		pwwn_ret, lun_ret;

	*l_errnop = 0;

	if ((dyncompp != NULL) &&
			((pwwn_ret = di_prop_lookup_bytes(DDI_DEV_T_ANY,
			node, PORT_WWN_PROP, &port_wwn_data)) <= 0)) {
		*l_errnop = errno;
	}
	if ((luncompp != NULL) &&
			((lun_ret = di_prop_lookup_ints(DDI_DEV_T_ANY,
			node, LUN_PROP, luncompp)) <= 0)) {
		*l_errnop = errno;
	}

	/*
	 * di_prop* returns the number of entries found or 0 if not found
	 * or -1 for othere failure.
	 */
	if ((pwwn_ret <= 0) || (lun_ret <= 0)) {
		return (FPCFGA_LIB_ERR);
	}

	*dyncompp = calloc(1, WWN_SIZE*2+1);
	if (*dyncompp == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	(void) sprintf(*dyncompp, "%016llx", (wwnConversion(port_wwn_data)));

	return (FPCFGA_OK);
}

fpcfga_ret_t
make_portwwn_luncomp_from_pinode(
	const di_path_t pinode,
	char **dyncompp,
	int **luncompp,
	int *l_errnop)
{
	uchar_t		*port_wwn_data;
	int		pwwn_ret, lun_ret;

	*l_errnop = 0;

	if ((dyncompp != NULL) &&
			((pwwn_ret = di_path_prop_lookup_bytes(pinode,
			PORT_WWN_PROP, &port_wwn_data)) <= 0)) {
		*l_errnop = errno;
	}
	if ((luncompp != NULL) &&
			((lun_ret = di_path_prop_lookup_ints(pinode,
			LUN_PROP, luncompp)) <= 0)) {
		*l_errnop = errno;
	}

	/*
	 * di_prop* returns the number of entries found or 0 if not found
	 * or -1 for othere failure.
	 */
	if ((pwwn_ret <= 0) || (lun_ret <= 0)) {
		return (FPCFGA_LIB_ERR);
	}

	*dyncompp = calloc(1, WWN_SIZE*2+1);
	if (*dyncompp == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	(void) sprintf(*dyncompp, "%016llx", (wwnConversion(port_wwn_data)));

	return (FPCFGA_OK);
}

fpcfga_ret_t
construct_nodepath_from_dinode(
	const di_node_t node,
	char **node_pathp,
	int *l_errnop)
{
	char *devfs_path, path_name[MAXPATHLEN], *lun_guid, *port_wwn;
	uchar_t *port_wwn_data;
	int is_scsi_vhci_dev, di_ret, devlen;
	uint_t	state;

	devfs_path = di_devfs_path(node);
	strcpy(path_name, devfs_path);
	di_devfs_path_free(devfs_path);
	state = di_state(node);

	is_scsi_vhci_dev = (strstr(path_name, SCSI_VHCI_DRVR) != NULL) ? 1 : 0;

	/*
	 * If the node is
	 * state then check the devfs_path to
	 * see if it has a complete path.
	 * For non scsi_vhci node the path
	 * doesn't contain @w(portwwn) part
	 * consistently.  For scsi_vhci
	 * this behavior may not be there.
	 * To be safe @g(guid) is attempted
	 * to be added here.
	 */
	if (state & DI_DRIVER_DETACHED) {
		if (is_scsi_vhci_dev &&
			(strstr(path_name, "@g") == NULL)) {
			di_ret = di_prop_lookup_strings(DDI_DEV_T_ANY, node,
				LUN_GUID_PROP, &lun_guid);
			if (di_ret == -1) {
				*l_errnop = errno;
				return (FPCFGA_LIB_ERR);
			} else {
				sprintf(&path_name[strlen(path_name)],
					"@g%s", lun_guid);
			}
		} else if (!is_scsi_vhci_dev &&
			(strstr(path_name, "@w") == NULL)) {
			di_ret = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
				PORT_WWN_PROP, &port_wwn_data);
			if (di_ret == -1) {
				*l_errnop = errno;
				return (FPCFGA_LIB_ERR);
			} else {
				if ((port_wwn = calloc(1, WWN_SIZE*2 + 1))
						== NULL) {
					*l_errnop = errno;
					return (FPCFGA_LIB_ERR);
				}

				(void) sprintf(port_wwn, "%016llx",
					(wwnConversion(port_wwn_data)));
				(void) sprintf(&path_name[strlen(path_name)],
					"@w%s", port_wwn);
				S_FREE(port_wwn);
			}
		}
	}

	devlen = strlen(DEVICES_DIR) + strlen(path_name) + 1;
	if ((*node_pathp = calloc(1, devlen)) == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	} else {
		(void) snprintf(*node_pathp, devlen,
		"%s%s", DEVICES_DIR, path_name);
	}

	return (FPCFGA_OK);
}

u_longlong_t
wwnConversion(uchar_t *wwn)
{
	u_longlong_t tmp;
	memcpy(&tmp, wwn, sizeof (u_longlong_t));
	return (ntohll(tmp));
}