/*

 * 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

 */

/*

 */

/*

 * This file contains support required for IB cfgadm plugin.

 */

#include <sys/conf.h>

#include <sys/stat.h>

#include <sys/modctl.h>

#include <sys/ib/mgt/ibdm/ibdm_impl.h>

#include <sys/ib/ibnex/ibnex.h>

#include <sys/ib/ibnex/ibnex_devctl.h>

#include <sys/ib/ibtl/impl/ibtl_ibnex.h>

#include <sys/ib/ibtl/impl/ibtl.h>

#include <sys/file.h>

#include <sys/sunndi.h>

#include <sys/fs/dv_node.h>

#include <sys/mdi_impldefs.h>

#include <sys/sunmdi.h>

/* return the minimum value of (x) and (y) */

#define	MIN(x, y)	((x) < (y) ? (x) : (y))

/*

 * function prototypes

 */

int			ibnex_open(dev_t *, int, int, cred_t *);

int			ibnex_close(dev_t, int, int, cred_t *);

int			ibnex_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

int			ibnex_offline_childdip(dev_info_t *);

static int		ibnex_get_num_devices(void);

static int		ibnex_get_snapshot(char **, size_t *, int);

static int		ibnex_get_commsvcnode_snapshot(nvlist_t **, ib_guid_t,

			    ib_guid_t, int, ib_pkey_t, ibnex_node_type_t);

static int		ibnex_fill_ioc_tmp(nvlist_t **, ibdm_ioc_info_t *);

static int		ibnex_fill_nodeinfo(nvlist_t **, ibnex_node_data_t *,

			    void *);

			    devctl_ap_state_t *);

static void		ibnex_figure_ib_apid_devstate(devctl_ap_state_t *);

static	char 		*ibnex_get_apid(struct devctl_iocdata *);

static int		ibnex_get_dip_from_apid(char *, dev_info_t **,

			    ibnex_node_data_t **);

static ibnex_rval_t	ibnex_handle_pseudo_configure(char *);

static ibnex_rval_t	ibnex_handle_ioc_configure(char *);

static ibnex_rval_t	ibnex_handle_commsvcnode_configure(char *);

static void		ibnex_return_apid(dev_info_t *, char **);

static void		ibnex_port_conf_entry_add(char *);

static void		ibnex_vppa_conf_entry_add(char *);

static void		ibnex_hcasvc_conf_entry_add(char *);

static int		ibnex_port_conf_entry_delete(char *, char *);

static int		ibnex_vppa_conf_entry_delete(char *, char *);

static int		ibnex_hcasvc_conf_entry_delete(char *, char *);

static ibnex_rval_t	ibnex_ioc_fininode(dev_info_t *, ibnex_ioc_node_t *);

static ibnex_rval_t	ibnex_commsvc_fininode(dev_info_t *);

static ibnex_rval_t	ibnex_pseudo_fininode(dev_info_t *);

static int		ibnex_devctl(dev_t, int, intptr_t, int,

			    cred_t *, int *);

static int		ibnex_ctl_get_api_ver(dev_t, int, intptr_t, int,

			    cred_t *, int *);

static int		ibnex_ctl_get_hca_list(dev_t, int, intptr_t, int,

			    cred_t *, int *);

static int		ibnex_ctl_query_hca(dev_t, int, intptr_t, int,

			    cred_t *, int *);

static int		ibnex_ctl_query_hca_port(dev_t, int, intptr_t, int,

			    cred_t *, int *);

extern uint64_t		ibnex_str2hex(char *, int, int *);

extern int		ibnex_ioc_initnode_all_pi(ibdm_ioc_info_t *);

extern dev_info_t	*ibnex_commsvc_initnode(dev_info_t *,

			    ibdm_port_attr_t *, int, int, ib_pkey_t, int *,

			    int);

extern int		ibnex_get_dip_from_guid(ib_guid_t, int,

			    ib_pkey_t, dev_info_t **);

extern void		ibnex_reprobe_ioc_dev(void *arg);

extern void		ibnex_reprobe_ioc_all();

extern int		ibnex_pseudo_create_all_pi(ibnex_node_data_t *);

extern void		ibnex_pseudo_initnodes(void);

extern ibnex_t	ibnex;

/*

 * ibnex_open()

 */

/* ARGSUSED */

int

ibnex_open(dev_t *dev, int flag, int otyp, cred_t *credp)

{

	IBTF_DPRINTF_L4("ibnex", "\topen");

	return (0);

}

/*

 * ibnex_close()

 */

/* ARGSUSED */

int

ibnex_close(dev_t dev, int flag, int otyp, cred_t *credp)

{

	IBTF_DPRINTF_L4("ibnex", "\tclose");

	return (0);

}

int

ibnex_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,

    int *rvalp)

{

	/*

	 * For all generic devctl ioctls (such as DEVCTL_AP_CONFIGURE),

	 * call ibnex_devctl().

	 */

	if (IS_DEVCTL(cmd))

		return (ibnex_devctl(dev, cmd, arg, mode, credp, rvalp));

	/*

	 * The rest are ibnex specific ioctls.

	 */

	switch (cmd) {

	case IBNEX_CTL_GET_API_VER:

		return (ibnex_ctl_get_api_ver(dev, cmd, arg, mode,

		    credp, rvalp));

	case IBNEX_CTL_GET_HCA_LIST:

		return (ibnex_ctl_get_hca_list(dev, cmd, arg, mode,

		    credp, rvalp));

	case IBNEX_CTL_QUERY_HCA:

		return (ibnex_ctl_query_hca(dev, cmd, arg, mode,

		    credp, rvalp));

	case IBNEX_CTL_QUERY_HCA_PORT:

		return (ibnex_ctl_query_hca_port(dev, cmd, arg, mode,

		    credp, rvalp));

	default:

		return (EINVAL);

	}

}

/*

 * ibnex_ioctl()

 *	Ioctl routine for cfgadm controls

 *	DEVCTL_AP_GETSTATE:	returns attachment point state

 *	DEVCTL_AP_CONTROL:	Does "ibnex" specific ioctls listed below

 *		IBNEX_NUM_DEVICE_NODES	Gives how many device nodes exist?

 *		IBNEX_NUM_HCA_NODES	Gives how many HCAs exist in the fabric

 *		IBNEX_UPDATE_PKEY_TBLS	"-x update_pkey_tbls"

 *		IBNEX_GET_SNAPSHOT	Gets the "snapshot" back to user-land

 *		IBNEX_SNAPSHOT_SIZE	What is "snapshot" size

 *		IBNEX_DEVICE_PATH_SZ	What is device-path size

 *		IBNEX_GET_DEVICE_PATH	Gets the device path for Dynamic ap

 *		IBNEX_HCA_LIST_SZ	"-x list" option size for the HCA ap_id

 *		IBNEX_HCA_LIST_INFO	"-x list" option info for the HCA ap_id

 *		IBNEX_UNCFG_CLNTS_SZ	"-x unconfig_client option size"

 *		IBNEX_UNCFG_CLNTS_INFO	"-x unconfig_client data"

 *		IBNEX_CONF_ENTRY_ADD:	"-x add_service"

 *		IBNEX_CONF_ENTRY_DEL:	"-x delete_service"

 *		IBNEX_HCA_VERBOSE_SZ:	"-alv hca_apid data size"

 *		IBNEX_HCA_VERBOSE_INFO: "-alv hca_apid actual data"

 *		IBNEX_UPDATE_IOC_CONF	"-x update_ioc_conf"

 *	DEVCTL_AP_CONFIGURE:	"configure" the attachment point

 *	DEVCTL_AP_UNCONFIGURE:	"unconfigure" the attachment point

 */

/* ARGSUSED */

static int

ibnex_devctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,

    int *rvalp)

{

	int			ret, rv = 0, ioc_reprobe_pending = 0;

	int			circ;

	char			*snapshot = NULL;

	char			*apid_n = NULL;

	char			*service = NULL;

	char			*devnm = NULL;

	char			*msg;

	char			*guid_str;

	uint_t			num_hcas = 0;

	size_t			snapshot_sz  = 0;

	uint32_t		ssiz;

	uint32_t		apid_len;

	ib_guid_t		hca_guid;

	boolean_t		apid_alloced = B_FALSE;

	dev_info_t		*apid_dip = NULL;

	dev_info_t		*pdip;

	ibnex_rval_t		ret_val;

	ib_service_type_t	svc_type = IB_NONE;

	devctl_ap_state_t	ap_state;

	struct devctl_iocdata	*dcp = NULL;

	IBTF_DPRINTF_L4("ibnex", "\tdevctl: cmd=%x, arg=%p, mode=%x, cred=%p, "

	    "\t\trval=%p dev=0x%x", cmd, arg, mode, credp, rvalp, dev);

	/* read devctl ioctl data */

	if ((cmd != DEVCTL_AP_CONTROL) &&

	    (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)) {

		IBTF_DPRINTF_L4("ibnex",

		    "\tdevctl: ndi_dc_allochdl failed\n");

		return (EFAULT);

	}

	mutex_enter(&ibnex.ibnex_mutex);

	switch (cmd) {

	case DEVCTL_AP_GETSTATE:

		msg = "\tdevctl: DEVCTL_AP_GETSTATE";

		IBTF_DPRINTF_L4("ibnex", "%s:", msg);

		apid_n = ibnex_get_apid(dcp);

		if (*apid_n == '\0') {

			IBTF_DPRINTF_L2("ibnex",

			    "%s: ibnex_get_apid failed", msg);

			rv = EIO;

			break;

		}

		if (strncmp(apid_n, IBNEX_FABRIC, strlen(IBNEX_FABRIC)) == 0) {

			ibnex_figure_ib_apid_devstate(&ap_state);

			apid_dip = ibnex.ibnex_dip;

		} else {

			/* if this apid is already seen by IBNEX, get the dip */

			rv = ibnex_get_dip_from_apid(apid_n, &apid_dip, &nodep);

			if (rv != IBNEX_DYN_APID) {

				IBTF_DPRINTF_L2("ibnex",

				    "%s: ibnex_get_dip_from_apid failed", msg);

				rv = EIO;

				break;

			}

			if (apid_dip)

				ndi_rele_devi(apid_dip);

			/* rv could be something undesirable, so reset it */

			rv = 0;

		}

		/* copy the return-AP-state information to the user space */

		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {

			IBTF_DPRINTF_L2("ibnex",

			    "%s: ndi_dc_return_ap_state failed", msg);

			rv = EFAULT;

		}

		break;

	case DEVCTL_AP_CONTROL:

	{

		int			num_nodes = 0;

		ibnex_ioctl_data_t	ioc;	/* for 64-bit copies only */

		msg = "\tdevctl: DEVCTL_AP_CONTROL";

#ifdef	_MULTI_DATAMODEL

		if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {

			ibnex_ioctl_data_32_t ioc32;

			if (ddi_copyin((void *)arg, &ioc32,

			    sizeof (ioc32), mode) != 0) {

				IBTF_DPRINTF_L2("ibnex",

				    "%s: ddi_copyin err 1", msg);

				rv = EFAULT;

				break;

			}

			ioc.cmd		= (uint_t)ioc32.cmd;

			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;

			ioc.bufsiz	= (uint_t)ioc32.bufsiz;

			ioc.ap_id	= (caddr_t)(uintptr_t)ioc32.ap_id;

			ioc.ap_id_len	= (uint_t)ioc32.ap_id_len;

			ioc.misc_arg	= (uint_t)ioc32.misc_arg;

		}

#else

		if (ddi_copyin((void *)arg, &ioc, sizeof (ioc),

		    mode) != 0) {

			IBTF_DPRINTF_L2("ibnex",

			    "%s: ddi_copyin 2 failed", msg);

			rv = EFAULT;

			break;

		}

#endif	/* _MULTI_DATAMODEL */

		IBTF_DPRINTF_L4("ibnex", "%s: \n\tioc: cmd=%x buf=%p, "

		    "bufsiz=%d", msg, ioc.cmd, ioc.buf, ioc.bufsiz);

		/*

		 * figure out ap_id name as passed from user-land

		 * NOTE: We don't need to figure out ap_id for these

		 * two sub-commands:-

		 *	IBNEX_NUM_DEVICE_NODES, IBNEX_NUM_HCA_NODES

		 *

		 * Hence, In user-land, these two ioctls force "ap_id_len" to 0.

		 */

		if (ioc.ap_id_len > 0) {

			apid_alloced = B_TRUE;

			apid_len = ioc.ap_id_len + 1;

			apid_n = kmem_zalloc(apid_len, KM_SLEEP);

			if (ddi_copyin((void *)ioc.ap_id, apid_n,

			    ioc.ap_id_len, mode) != 0) {

				IBTF_DPRINTF_L2("ibnex",

				    "%s: ddi_copyin err 3", msg);

				rv = EFAULT;

				break;

			}

			IBTF_DPRINTF_L3("ibnex", "%s: apid_n= %s", msg, apid_n);

		}

		/* process sub-commands */

		switch (ioc.cmd) {

		case IBNEX_NUM_DEVICE_NODES:

			msg = "\tdevctl: DEVCTL_AP_CONTROL: NUM_DEVICE_NODES";

			/*

			 * figure out how many IOC, VPPA,

			 * Pseudo and Port nodes are present

			 */

			num_nodes = ibnex_get_num_devices();

			IBTF_DPRINTF_L4("ibnex", "%s: num_nodes = %d",

			    msg, num_nodes);

			if (ddi_copyout(&num_nodes, ioc.buf,

			    ioc.bufsiz, mode) != 0) {

				IBTF_DPRINTF_L2("ibnex", "%s: copyout", msg);

				rv = EIO;

			}

			mutex_exit(&ibnex.ibnex_mutex);

			return (rv);

		case IBNEX_NUM_HCA_NODES:

			msg = "\tdevctl: DEVCTL_AP_CONTROL: NUM_HCA_NODES";

			/* figure out how many HCAs are present in the host */

			mutex_exit(&ibnex.ibnex_mutex);

			num_hcas = ibt_get_hca_list(NULL);

			IBTF_DPRINTF_L4("ibnex", "%s: num %d", msg, num_hcas);

			if (ddi_copyout(&num_hcas, ioc.buf,

			    ioc.bufsiz, mode) != 0) {

				IBTF_DPRINTF_L2("ibnex", "%s: copyout", msg);

				rv = EIO;

			}

			return (rv);

		case IBNEX_UPDATE_PKEY_TBLS:

			msg = "\tdevctl: DEVCTL_AP_CONTROL: UPDATE_PKEY_TBLS";

			IBTF_DPRINTF_L4("ibnex", "%s", msg);

			/*

			 * update P_Key tables:

			 *	ibdm_ibnex_update_pkey_tbls() calls

			 *	ibt_query_hca_ports_byguids() for all the

			 *	HCAs that the IBDM has "seen" in the system.

			 *	This ends up updating the IBTL P_Key database.

			 *	NOTE: Changes in this area will break this

			 *	assumption. Initially the plan was to call

			 *	ibt_query_hca_ports_byguids() in IBTL but

			 *	IBDM needs to call it as well. So, eliminating

			 *	the first invocation.

			 *

			 *	It next updates the DM P_Key database.

			 *	Note that the DM P_Key database updating

			 *	will always be driven through cfgadm.

			 */

			mutex_exit(&ibnex.ibnex_mutex);

			ibdm_ibnex_update_pkey_tbls();

			mutex_enter(&ibnex.ibnex_mutex);

			break;

		case IBNEX_GET_SNAPSHOT:

		case IBNEX_SNAPSHOT_SIZE:

			msg = (ioc.cmd == IBNEX_SNAPSHOT_SIZE) ?

			    "\tdevctl: DEVCTL_AP_CONTROL: IBNEX_SNAPSHOT_SIZE" :

			    "\tdevctl: DEVCTL_AP_CONTROL: IBNEX_GET_SNAPSHOT";

			IBTF_DPRINTF_L4("ibnex", "%s:", msg);

			if (ibnex_get_snapshot(&snapshot, &snapshot_sz,

			    ioc.misc_arg) != 0) {

				IBTF_DPRINTF_L2("ibnex",

				    "%s:\n\tibnex_get_snapshot failed", msg);

				rv = EIO;

				break;

			}

			/* ssiz needs to be reinitialized again */

			ssiz = snapshot_sz;

			IBTF_DPRINTF_L4("ibnex",

			    "%s:\n\tsize =%x", msg, snapshot_sz);

			if (ioc.cmd == IBNEX_SNAPSHOT_SIZE) {

				if (ddi_copyout(&ssiz, ioc.buf,

				    ioc.bufsiz, mode) != 0) {

					IBTF_DPRINTF_L2("ibnex",

					    "%s:\n\tddi_copyout 2 failed", msg);

					rv = EFAULT;

				}

			} else {

				if (ioc.bufsiz != snapshot_sz) {

					IBTF_DPRINTF_L2("ibnex",

					    "%s:\n\tinvalid buffer size (%x %x)"

					    " ", msg, ioc.bufsiz, snapshot_sz);

					rv = EINVAL;

				} else if (ddi_copyout(snapshot, ioc.buf,

				    ioc.bufsiz, mode) != 0) {

					IBTF_DPRINTF_L2("ibnex",

					    "%s:\n\tddi_copyout 3 failed", msg);

					rv = EFAULT;

				}

			}

			kmem_free(snapshot, snapshot_sz);

			break;

		case IBNEX_DEVICE_PATH_SZ:

		case IBNEX_GET_DEVICE_PATH:

		{

			char	 path[MAXPATHLEN];

			msg = (ioc.cmd == IBNEX_DEVICE_PATH_SZ) ?

			    "\tdevctl:DEVCTL_AP_CONTROL: IBNEX_DEVICE_PATH_SZ" :

			    "\tdevctl:DEVCTL_AP_CONTROL: IBNEX_GET_DEVICE_PATH";

			IBTF_DPRINTF_L4("ibnex", "%s: apid = %s", msg, apid_n);

			/* if this apid is already seen by IBNEX, get the dip */

			rv = ibnex_get_dip_from_apid(apid_n, &apid_dip, &nodep);

			if (rv != IBNEX_DYN_APID || apid_dip == NULL) {

				IBTF_DPRINTF_L2("ibnex",

				    "%s:\n\tget_dip_from_apid failed", msg);

				rv = EIO;

				break;

			}

			ndi_rele_devi(apid_dip);

			/* ddi_pathname doesn't supply /devices, so we do. */

			(void) strcpy(path, "/devices");

			(void) ddi_pathname(apid_dip, path + strlen(path));

			ssiz = (uint32_t)strlen(path) + 1;

			IBTF_DPRINTF_L4("ibnex",

			    "%s: len = %x\n\tpath = %s", msg, ssiz, path);

			/* rv could be something undesirable, so reset it */

			rv = 0;

			if (ioc.cmd == IBNEX_DEVICE_PATH_SZ) {

				if (ddi_copyout(&ssiz, ioc.buf,

				    ioc.bufsiz, mode) != 0) {

					IBTF_DPRINTF_L2("ibnex",

					    "%s: ddi_copyout 4 failed", msg);

					rv = EFAULT;

				}

			} else {

				if (ioc.bufsiz != ssiz) {

					IBTF_DPRINTF_L2("ibnex",

					    "%s: invalid size (%x, %x)",

					    msg, ioc.bufsiz, ssiz);

					rv = EINVAL;

				} else if (ddi_copyout(&path, ioc.buf,

				    ioc.bufsiz, mode) != 0) {

					IBTF_DPRINTF_L2("ibnex", "%s "

					    "ddi_copyout 5 failed", msg);

					rv = EFAULT;

				}

			}

			break;

		}

		case IBNEX_HCA_LIST_SZ:

		case IBNEX_HCA_LIST_INFO:

			msg = (ioc.cmd == IBNEX_HCA_LIST_SZ) ?

			    "DEVCTL_AP_CONTROL: IBNEX_HCA_LIST_SZ" :

			    "DEVCTL_AP_CONTROL: IBNEX_HCA_LIST_INFO";

			guid_str = strrchr(apid_n, ':') + 1;

			IBTF_DPRINTF_L4("ibnex", "%s, input apid = %s, "

			    "guid = %s", msg, apid_n, guid_str);

			if (guid_str == NULL) {

				IBTF_DPRINTF_L2("ibnex", "%s: invalid input "

				    "GUID passed %s", msg, guid_str);

				rv = EFAULT;

				break;

			}

			/* Get the GUID(hex value) from apid_n */

			hca_guid = ibnex_str2hex(guid_str, strlen(guid_str),

			    &ret);

			if (ret != IBNEX_SUCCESS) {

				IBTF_DPRINTF_L2("ibnex", "%s: Invalid HCA "

				    "GUID string", msg);

				rv = EIO;

				break;