xref: /onnv-gate/usr/src/uts/common/io/ib/ibtl/ibtl_impl.c (revision 12965:b65a8427f8fe)

/*
 * 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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * ibtl_impl.c
 *
 * This file contains the IBTF module's initialization and
 * IBTF Clients/Modules registration routines.
 */

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

/*
 * Globals.
 */
static char ibtf[] = "ibtl_impl";

extern ibtl_ibnex_callback_t	ibtl_ibnex_callback_routine;

/*
 * ibtl_clnt_list:
 *
 *	Head of the list of IBT Client Instances. The IBT Client List
 *	is modified by IBTF on an IBT client's ibt_attach/ibt_detach call.
 *
 * ibtl_hca_list:
 *
 *	Head of the list of HCA devices. The HCA List is modified by IBTF on
 *	a CI's ibc_attach/ibc_detach call.
 *	The datap of the list elements points to an ibtl_hca_devinfo_s
 *	structure.
 *
 *				(ibc_attach)
 *  ibtl_hca_list	-> ibtl_hca_devinfo_t--> ...	-->ibtl_hca_devinfo_t
 *	[per-hca_dev]		|	^			{nth HCA Dev}
 *				|	|
 *				|  ibtl_hca_t (ibt_open_hca)
 *				|	^  |
 *				|	|  |
 *				v	|  V
 *  ibtl_clnt_list	->	ibtl_clnt_t--> ...--> {n'th Module}
 *	[per-client_instance]	(ibt_attach)
 *
 */

/* Global List of IBT Client Instances, and associated mutex. */
struct ibtl_clnt_s *ibtl_clnt_list = NULL;
kmutex_t ibtl_clnt_list_mutex;

/* Lock for the race between the client and CM to free QPs. */
kmutex_t ibtl_free_qp_mutex;

/* Lock for the race between the client closing the HCA and QPN being freed. */
kcondvar_t ibtl_close_hca_cv;

/* Global List of HCA Devices, and associated mutex. */
struct ibtl_hca_devinfo_s *ibtl_hca_list = NULL;

/* Well-known async handlers and associated client private. */
ibt_async_handler_t ibtl_cm_async_handler;
ibt_async_handler_t ibtl_dm_async_handler;
ibt_async_handler_t ibtl_ibma_async_handler;
void	*ibtl_cm_clnt_private;
void	*ibtl_dm_clnt_private;
void	*ibtl_ibma_clnt_private;

extern int ib_hw_status;
_NOTE(SCHEME_PROTECTS_DATA("Scheme protects data", ib_hw_status))

/*
 * Misc Module Declarations.
 */
extern struct mod_ops mod_miscops;
static struct modlmisc modlmisc = {
	&mod_miscops,			/* Type of module - misc. */
	"IB Transport Layer"		/* Name of the Module. */
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modlmisc, NULL
};

static void ibtl_kstat_init(ibtl_hca_devinfo_t *);
static void ibtl_kstat_fini(ibtl_hca_devinfo_t *);
static void ibtl_kstat_stats_create(ibtl_hca_devinfo_t *, uint_t);
static void ibtl_kstat_pkeys_create(ibtl_hca_devinfo_t *, uint_t);

extern kmutex_t ibtl_part_attr_mutex;

/*
 * IBTF Loadable Module Routines.
 */

int
_init(void)
{
	int rval;

	if ((rval = mod_install(&modlinkage)) != 0)
		return (rval);

	/*
	 * initialize IBTL ib2usec table
	 */
	ibtl_ib2usec_init();

	/*
	 * Initialize Logging
	 */
	ibtl_logging_initialization();

	/*
	 * Initialize the Alloc QP States.
	 */
	ibtl_init_cep_states();

	/*
	 * Initialize all Global Link Lists.
	 */
	mutex_init(&ibtl_clnt_list_mutex, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&ibtl_free_qp_mutex, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&ibtl_close_hca_cv, NULL, CV_DEFAULT, NULL);

	mutex_init(&ibtl_qp_mutex, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&ibtl_qp_cv, NULL, CV_DEFAULT, NULL);

	mutex_init(&ibtl_part_attr_mutex, NULL, MUTEX_DEFAULT, NULL);

	ibtl_thread_init();

	return (rval);
}


int
_fini(void)
{
	int rval;

	if ((rval = mod_remove(&modlinkage)) != 0) {
		return (rval);
	}

	ibtl_thread_fini();

	mutex_destroy(&ibtl_clnt_list_mutex);
	mutex_destroy(&ibtl_free_qp_mutex);
	cv_destroy(&ibtl_close_hca_cv);
	mutex_destroy(&ibtl_qp_mutex);
	cv_destroy(&ibtl_qp_cv);
	mutex_destroy(&ibtl_part_attr_mutex);

	/*
	 * Stop Logging
	 */
	ibtl_logging_destroy();

	return (rval);
}


int
_info(struct modinfo *modinfop)
{
	/* Return the Module Information. */
	return (mod_info(&modlinkage, modinfop));
}


/*
 * IBTF Client Registration Routines.
 */

/*
 * Function:
 *	ibt_attach
 * Input:
 *	modinfop	- Client Module info structure.
 *	arg		- usually client's dip
 *	clnt_private	- client's private data pointer.
 * Output:
 *	ibt_hdl_p	- pointer to client's specific IBT handle,
 *			 which is opaque to clients.
 * Returns:
 *	IBT_SUCCESS
 *	IBT_INVALID_PARAM
 * Called by:
 *	IBTF Client module during its attach() to register its instance
 *	to IBTF.
 * Description:
 *	Registers the IBTF client module instance and returns an opaque
 *	handler to the client to be used for future calls to IBTF.
 *	Adds this client module instance to ibtl_clnt_list list.
 *	Records well-known async handlers.
 */
ibt_status_t
ibt_attach(ibt_clnt_modinfo_t *mod_infop, dev_info_t *arg, void *clnt_private,
    ibt_clnt_hdl_t *ibt_hdl_p)
{
	dev_info_t	*pdip;
	ibtl_clnt_t	*clntp;

	IBTF_DPRINTF_L3(ibtf, "ibt_attach(%p, %p, %p)",
	    mod_infop, arg, clnt_private);

	if (mod_infop->mi_clnt_name == NULL) {
		IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
		    "IB client needs to specify its name");
		return (IBT_INVALID_PARAM);
	}

	/*
	 * Validate the Transport API version.
	 */
	if (mod_infop->mi_ibt_version != IBTI_V_CURR) {
		IBTF_DPRINTF_L1(ibtf, "ibt_attach: IB client '%s' has an "
		    "invalid IB TI Version '%d'", mod_infop->mi_clnt_name,
		    mod_infop->mi_ibt_version);
		return (IBT_NOT_SUPPORTED);
	}

	if (mod_infop->mi_async_handler == NULL) {
		IBTF_DPRINTF_L2(ibtf, "ibt_attach: Client '%s' has not\n"
		    "        provided an Asynchronous Event Handler.\n"
		    "        This will be required soon.",
		    mod_infop->mi_clnt_name);
	}

	/*
	 * Check out Client's Class information. If it is not of mgmt class,
	 * we expect 'arg' to be Not NULL and point to client driver's
	 * device info struct.
	 */
	if ((!IBT_MISCMOD_CLIENTS(mod_infop->mi_clnt_class)) &&
	    (arg == NULL)) {
		IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
		    "arg not set with driver's dip.");
		return (IBT_INVALID_PARAM);
	}

	if (!IBT_MISCMOD_CLIENTS(mod_infop->mi_clnt_class)) {
		pdip = ddi_get_parent(arg);
		if (pdip == NULL ||
		    ibtl_ibnex_valid_hca_parent(pdip) != IBT_SUCCESS) {
			IBTF_DPRINTF_L2(ibtf, "ibt_attach: "
			    "client %s is not a child of IB nexus driver.",
			    ddi_driver_name(arg));
			return (IBT_INVALID_PARAM);
		}
	}

	mutex_enter(&ibtl_clnt_list_mutex);
	if (mod_infop->mi_clnt_class == IBT_CM) {
		if (ibtl_cm_async_handler != NULL) {
			IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
			    "CM is already attached.");
			mutex_exit(&ibtl_clnt_list_mutex);
			return (IBT_INVALID_PARAM);
		}
		ibtl_cm_async_handler = mod_infop->mi_async_handler;
		ibtl_cm_clnt_private = clnt_private;
	} else if (mod_infop->mi_clnt_class == IBT_DM) {
		if (ibtl_dm_async_handler != NULL) {
			IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
			    "DM is already attached.");
			mutex_exit(&ibtl_clnt_list_mutex);
			return (IBT_INVALID_PARAM);
		}
		ibtl_dm_async_handler = mod_infop->mi_async_handler;
		ibtl_dm_clnt_private = clnt_private;
	} else if (mod_infop->mi_clnt_class == IBT_IBMA) {
		if (ibtl_ibma_async_handler != NULL) {
			IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
			    "IBMF is already attached.");
			mutex_exit(&ibtl_clnt_list_mutex);
			return (IBT_INVALID_PARAM);
		}
		ibtl_ibma_async_handler = mod_infop->mi_async_handler;
		ibtl_ibma_clnt_private = clnt_private;
	}

	/* Allocate the memory for per-client-device info structure */
	clntp = kmem_zalloc(sizeof (ibtl_clnt_t), KM_SLEEP);

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(clntp->clnt_modinfop,
	    clntp->clnt_dip, clntp->clnt_name, clntp->clnt_async_cnt,
	    clntp->clnt_private))
	/* Update the Client info structure */
	clntp->clnt_modinfop = mod_infop;	/* IBT Client's Mod Info */
	clntp->clnt_private = clnt_private;	/* IBT Client's private */
	clntp->clnt_dip = arg;			/* IBT Client's dip */
	clntp->clnt_async_cnt = 0;
	/* using a count of 7 below guarantees it is NULL terminated */
	(void) strncpy(clntp->clnt_name, mod_infop->mi_clnt_name, 7);
	_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(clntp->clnt_modinfop,
	    clntp->clnt_dip, clntp->clnt_name, clntp->clnt_async_cnt,
	    clntp->clnt_private))

	/*
	 * Update Client Device Instance List.
	 */
	clntp->clnt_list_link = ibtl_clnt_list;
	ibtl_clnt_list = clntp;
	mutex_exit(&ibtl_clnt_list_mutex);

	/*
	 * The ibt_hdl_p is a opaque handle which is the address of
	 * ibt_clnt_t structure passed back to the clients.
	 * The client will pass on this handle in its future calls to IBTF.
	 */
	*ibt_hdl_p = clntp;

	return (IBT_SUCCESS);
}


/*
 * Function:
 *	ibt_detach
 * Input:
 *	ibt_hdl - IBT Handle as returned during ibt_attach call.
 * Output:
 *	none
 * Returns:
 *	IBT_SUCCESS
 *	IBT_INVALID_PARAM.
 * Called by:
 *	IBTF Client module during its detach() to de-register its instance
 *	from IBTF.
 * Description:
 *	Deregisters the IBTF client module instance from the IBTF.
 *	All resources and any reference to this ibt_hdl will be removed.
 */
ibt_status_t
ibt_detach(ibt_clnt_hdl_t ibt_hdl)
{
	ibtl_clnt_t **clntpp;

	IBTF_DPRINTF_L3(ibtf, "ibt_detach(%p)", ibt_hdl);

	mutex_enter(&ibtl_clnt_list_mutex);
	clntpp = &ibtl_clnt_list;
	for (; *clntpp != NULL; clntpp = &(*clntpp)->clnt_list_link)
		if (*clntpp == ibt_hdl)
			break;
	if (*clntpp == NULL) {
		IBTF_DPRINTF_L1(ibtf, "ibt_detach: Client @ %p Not Found",
		    ibt_hdl);
		mutex_exit(&ibtl_clnt_list_mutex);
		return (IBT_INVALID_PARAM);
	}

	/*
	 * Check out whether the client has freed all its resources.
	 * If not done, then fail the detach.
	 *
	 * viz. A client has to close all the HCA they have opened,
	 * i.e. the HCA List maintained for clients has to be empty.
	 * If this list is not empty, then the client has not performed
	 * complete clean-up, so fail the detach.
	 */
	if (ibt_hdl->clnt_hca_list != NULL) {
		mutex_exit(&ibtl_clnt_list_mutex);

		IBTF_DPRINTF_L2(ibtf, "ibt_detach: "
		    "ERROR: Client '%s' has not closed all of its HCAs",
		    ibt_hdl->clnt_modinfop->mi_clnt_name);
		cmn_err(CE_CONT, "IBT DETACH failed: resources not yet "
		    "freed by client '%s'\n",
		    ibt_hdl->clnt_modinfop->mi_clnt_name);
		return (IBT_HCA_RESOURCES_NOT_FREED);
	}

	if (ibt_hdl->clnt_srv_cnt != 0) {
		mutex_exit(&ibtl_clnt_list_mutex);
		IBTF_DPRINTF_L2(ibtf, "ibt_detach: client '%s' still has "
		    "services or subnet_notices registered",
		    ibt_hdl->clnt_modinfop->mi_clnt_name);
		cmn_err(CE_CONT, "IBT DETACH failed: resources not yet "
		    "freed by client '%s'\n",
		    ibt_hdl->clnt_modinfop->mi_clnt_name);
		return (IBT_HCA_RESOURCES_NOT_FREED);
	}

	/*
	 * Delete the entry of this module from the ibtl_clnt_list List.
	 */
	*clntpp = ibt_hdl->clnt_list_link;	/* remove us */

	/* make sure asyncs complete before freeing */
	ibtl_free_clnt_async_check(ibt_hdl);

	if (ibt_hdl->clnt_modinfop->mi_clnt_class == IBT_CM) {
		ibtl_cm_async_handler = NULL;
		ibtl_cm_clnt_private = NULL;
	} else if (ibt_hdl->clnt_modinfop->mi_clnt_class == IBT_DM) {
		ibtl_dm_async_handler = NULL;
		ibtl_dm_clnt_private = NULL;
	} else if (ibt_hdl->clnt_modinfop->mi_clnt_class == IBT_IBMA) {
		ibtl_ibma_async_handler = NULL;
		ibtl_ibma_clnt_private = NULL;
	}
	mutex_exit(&ibtl_clnt_list_mutex);

	/* Free up the memory of per-client info struct. */
	kmem_free(ibt_hdl, sizeof (ibtl_clnt_t));

	return (IBT_SUCCESS);
}

static void
ibtl_set_ibhw_status()
{
	ib_hw_status++;
}

static void
ibtl_clear_ibhw_status()
{
	ib_hw_status--;
}

/*
 * Function:
 *	ibc_init
 * Input:
 *	modlp		- Pointer to IBC client module linkage structure
 * Output:
 *	None
 * Returns:
 *	0 always for now
 * Called by:
 *	CI client calls IBTF during its _init() to register HCA with
 *	Solaris I/O framework.
 * Description:
 *	Initializes the CI clients module linkage structure with
 *	default bus_ops structure
 */
int
ibc_init(struct modlinkage *modlp)
{
	ibtl_ibnex_cb_args_t	cb_args;

	mutex_enter(&ibtl_clnt_list_mutex);
	cb_args.cb_flag = IBTL_IBNEX_IBC_INIT;
	cb_args.cb_modlp = modlp;
	if (ibtl_ibnex_callback_routine) {
		(void) ((*ibtl_ibnex_callback_routine)(&cb_args));
	}
	mutex_exit(&ibtl_clnt_list_mutex);
	return (0);
}


/*
 * Function:
 *	ibc_fini
 * Input:
 *	modlp		- Pointer to IBC client module linkage structure
 * Output:
 *	None
 * Returns:
 *	None
 * Called by:
 *	CI client calls IBTF during its _fini() to remove HCA with
 *	Solaris I/O framework.
 * Description:
 *	Undo what is done during ibc_init
 */
void
ibc_fini(struct modlinkage *modlp)
{
	ibtl_ibnex_cb_args_t	cb_args;

	mutex_enter(&ibtl_clnt_list_mutex);
	cb_args.cb_flag = IBTL_IBNEX_IBC_FINI;
	cb_args.cb_modlp = modlp;
	if (ibtl_ibnex_callback_routine) {
		(void) ((*ibtl_ibnex_callback_routine)(&cb_args));
	}
	mutex_exit(&ibtl_clnt_list_mutex);
}

/*
 * Function:
 *	ibc_attach
 * Input:
 *	info_p		- IBC HCA Info.
 * Output:
 *	ibc_hdl_p	- IBC Client's HCA Handle.
 * Returns:
 *	IBC_SUCCESS
 *	IBC_FAILURE
 * Called by:
 *	CI calls IBTF during its attach() to register HCA Device with IBTF.
 * Description:
 *	Registers the presence of HCA device by providing the HCA device info
 *  	structure and provides an opaque HCA handler for future calls to this
 *  	HCA device.
 */
ibc_status_t
ibc_attach(ibc_clnt_hdl_t *ibc_hdl_p, ibc_hca_info_t *info_p)
{
	ibtl_hca_devinfo_t	*hca_devp;
	uint_t			nports;
	ibt_status_t		status;

	IBTF_DPRINTF_L2(ibtf, "ibc_attach(%p, %p)", ibc_hdl_p, info_p);

	/* Validate the Transport API version */
	if (info_p->hca_ci_vers != IBCI_V4) {
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: Invalid IB CI Version '%d'",
		    info_p->hca_ci_vers);
		return (IBC_FAILURE);
	}

	if (info_p->hca_attr == NULL) {
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
		    "HCA Attributes must be specified.");
		return (IBC_FAILURE);
	}

	nports = info_p->hca_attr->hca_nports;
	if (nports == 0) {
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
		    "Number of ports must be valid");
		return (IBC_FAILURE);
	}

	if (info_p->hca_attr->hca_max_port_pkey_tbl_sz == 0) {
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
		    "Number of Partitions must be at least 1");
		return (IBC_FAILURE);
	}

	if ((info_p->hca_attr->hca_flags & IBT_HCA_CURRENT_QP_STATE) == 0) {
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
		    "HCA driver must support QP current state checking");
		return (IBC_FAILURE);
	}

	if ((info_p->hca_attr->hca_flags & IBT_HCA_PORT_UP) == 0) {
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
		    "HCA driver must support PORT_UP async events");
		return (IBC_FAILURE);
	}

	/*
	 * Install IB nexus driver (if not installed already)
	 */
	ibtl_set_ibhw_status();
	if (ndi_devi_config_vhci("ib", 0) == NULL) {
		IBTF_DPRINTF_L2(ibtf, "ibc_attach: IB nexus attach failed");
		ibtl_clear_ibhw_status();
		return (IBC_FAILURE);
	}

	ibtl_thread_init2();

	/* Allocate the memory for per-client info structure */
	hca_devp = kmem_zalloc(sizeof (ibtl_hca_devinfo_t) +
	    (nports - 1) * sizeof (ibtl_async_port_event_t), KM_SLEEP);

	mutex_enter(&ibtl_clnt_list_mutex);

	/* Update HCA dev info structure */
	hca_devp->hd_ibc_hca_hdl = info_p->hca_handle;
	hca_devp->hd_ibc_ops	= info_p->hca_ops;
	hca_devp->hd_hca_attr	= info_p->hca_attr;
	hca_devp->hd_hca_dip	= info_p->hca_attr->hca_dip;

	status = ibtl_init_hca_portinfo(hca_devp);
	if (status != IBT_SUCCESS) {
		mutex_exit(&ibtl_clnt_list_mutex);
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: call to ibc_query_hca_ports "
		    "failed: status = %d", status);
		kmem_free(hca_devp, sizeof (ibtl_hca_devinfo_t) +
		    (nports - 1) * sizeof (ibtl_async_port_event_t));
		return (IBC_FAILURE);
	}

	/* Register the with MPxIO as PHCI */
	if (ibtl_ibnex_phci_register(hca_devp->hd_hca_dip) != IBT_SUCCESS) {
		mutex_exit(&ibtl_clnt_list_mutex);
		IBTF_DPRINTF_L1(ibtf, "ibc_attach: MPxIO register failed");
		kmem_free(hca_devp, sizeof (ibtl_hca_devinfo_t) +
		    (nports - 1) * sizeof (ibtl_async_port_event_t));
		return (IBC_FAILURE);
	}

	/* Initialize the Client List for this HCA. */
	hca_devp->hd_state	= IBTL_HCA_DEV_ATTACHED;

	/* lock out asyncs until after we announce the new HCA */
	hca_devp->hd_async_busy = 1;

	cv_init(&hca_devp->hd_async_task_cv, NULL, CV_DEFAULT, NULL);
	cv_init(&hca_devp->hd_async_busy_cv, NULL, CV_DEFAULT, NULL);

	/* init portinfo locking variables */
	hca_devp->hd_portinfo_locked_port = 0;
	cv_init(&hca_devp->hd_portinfo_cv, NULL, CV_DEFAULT, NULL);

	ibtl_kstat_init(hca_devp);

	mutex_exit(&ibtl_clnt_list_mutex);

	/*
	 * The ibc_hdl_p points to an opaque handle which is the address
	 * of ibt_hca_devinfo_t structure passed back to the CI.
	 * The CI will pass on this handle in its future upcalls to IBTF.
	 */
	*ibc_hdl_p = hca_devp;

	return (IBC_SUCCESS);
}


/*
 * Function:
 *	ibc_post_attach
 * Input:
 *	ibc_hdl		- IBC Client's HCA Handle.
 * Returns:
 *	none
 * Called by:
 *	CI calls IBTF during its attach() after a successful ibc_attach().
 * Description:
 *	Announces to all known clients the existence of this HCA (by GUID).
 */
void
ibc_post_attach(ibc_clnt_hdl_t ibc_hdl)
{
	IBTF_DPRINTF_L2(ibtf, "ibc_post_attach(%p)", ibc_hdl);

	/*
	 * Update the HCA Device List.
	 */
	mutex_enter(&ibtl_clnt_list_mutex);
	ibc_hdl->hd_hca_dev_link = ibtl_hca_list;
	ibtl_hca_list = ibc_hdl;
	mutex_exit(&ibtl_clnt_list_mutex);

	/* notify all IBT Client Device Instances of the new HCA Device */
	ibtl_announce_new_hca(ibc_hdl);
}


/*
 * Function:
 *	ibc_pre_detach
 * Input:
 *	ibc_clnt_hdl	- IBC HCA Handle as returned during ibc_attach call.
 *  	cmd		- DDI_DETACH/DDI_SUSPEND command.
 * Output:
 *	none
 * Returns:
 *	IBC_SUCCESS
 *	IBC_FAILURE.
 * Called by:
 *	CI to try to get all IBTF clients to close the HCA device.
 * Description:
 *	Attempts to deregister the HCA device entry from the IBTF.
 *	If all resources are freed by the IBTF clients and this HCA
 *	is closed, then IBC_SUCCESS is returned.
 */
ibc_status_t
ibc_pre_detach(ibc_clnt_hdl_t hca_devp, ddi_detach_cmd_t cmd)
{
	ibtl_hca_devinfo_t **hcapp, *hcap;

	IBTF_DPRINTF_L2(ibtf, "ibc_pre_detach(%p, 0x%x)", hca_devp, cmd);

	/*
	 * Return failure, if command is not DDI_DETACH
	 */
	switch (cmd) {
	case DDI_DETACH:
		break;
	default:
		return (IBC_FAILURE); /* TBD: DDI_FAILURE */
	}

	/* Make sure this HCA is on the HCA Device List.  */
	mutex_enter(&ibtl_clnt_list_mutex);
	hcap = ibtl_hca_list;
	while (hcap != NULL) {
		if (hcap == hca_devp)
			break;
		hcap = hcap->hd_hca_dev_link;
	}
	if (hcap == NULL) {
		mutex_exit(&ibtl_clnt_list_mutex);
		return (IBC_FAILURE);
	}

	/*
	 * Initially set the state to "Detaching".
	 */
	hca_devp->hd_state = IBTL_HCA_DEV_DETACHING;

	/*
	 * Try to detach all IBTI clients, and continue only if all
	 * of the detaches succeed.
	 */
	if (ibtl_detach_all_clients(hca_devp)) {
		hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED; /* fix hd_state */
		mutex_exit(&ibtl_clnt_list_mutex);

		return (IBC_FAILURE);
	}

	/*
	 * Check to see if all clients closed this HCA, or not.
	 * We only succeed if all clients cooperated.
	 */
	if (hca_devp->hd_clnt_list != NULL) {
		hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED;
		mutex_exit(&ibtl_clnt_list_mutex);
		IBTF_DPRINTF_L2(ibtf, "ibc_pre_detach: HCA still has attached "
		    "clients");
		return (IBC_FAILURE);
	}

	/*
	 * mark this device as detached
	 */
	hca_devp->hd_state = IBTL_HCA_DEV_DETACHED;

	/* Delete the entry for this hca_devp from hca_head_list */
	hcapp = &ibtl_hca_list;
	while (*hcapp != NULL) {
		if (*hcapp == hca_devp)
			break;
		hcapp = &(*hcapp)->hd_hca_dev_link;
	}

	if (ibtl_ibnex_phci_unregister(hca_devp->hd_hca_dip) != IBT_SUCCESS) {
		hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED; /* fix hd_state */
		mutex_exit(&ibtl_clnt_list_mutex);
		IBTF_DPRINTF_L1(ibtf, "ibc_pre_detach: PHCI unregister failed");
		return (IBC_FAILURE);
	}

	if (*hcapp == NULL) {
		hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED; /* fix hd_state */
		mutex_exit(&ibtl_clnt_list_mutex);
		IBTF_DPRINTF_L1(ibtf, "ibc_pre_detach: HCA not attached");
		return (IBC_FAILURE);
	}
	*hcapp = hca_devp->hd_hca_dev_link;
	ibtl_fast_gid_cache_valid = B_FALSE;	/* invalidate fast_gid_cache */
	mutex_exit(&ibtl_clnt_list_mutex);

	return (IBC_SUCCESS);
}

/*
 * Function:
 *	ibc_detach
 * Input:
 *	ibc_clnt_hdl	- IBC HCA Handle as returned during ibc_attach call.
 * Output:
 *	none
 * Returns:
 *	None
 * Called by:
 *	CI to detach the HCA device from IBTF.
 * Description:
 *	Do the second step of detaching the HCA, which is required
 *	after a successful ibc_pre_detach.
 */
void
ibc_detach(ibc_clnt_hdl_t hca_devp)
{
	IBTF_DPRINTF_L2(ibtf, "ibc_detach(%p)", hca_devp);

	mutex_enter(&ibtl_clnt_list_mutex);
	if (hca_devp->hd_state != IBTL_HCA_DEV_DETACHED) {
		mutex_exit(&ibtl_clnt_list_mutex);
		IBTF_DPRINTF_L0(ibtf, "ibc_detach: HCA has not successfully "
		    "pre-detached");
		return;
	}

	cv_destroy(&hca_devp->hd_async_task_cv);
	cv_destroy(&hca_devp->hd_async_busy_cv);
	cv_destroy(&hca_devp->hd_portinfo_cv);

	kmem_free(hca_devp->hd_portinfop, hca_devp->hd_portinfo_len);
	mutex_exit(&ibtl_clnt_list_mutex);

	ibtl_kstat_fini(hca_devp);

	/* Free up the memory of per-client info struct */
	kmem_free(hca_devp, sizeof (ibtl_hca_devinfo_t) +
	    (hca_devp->hd_hca_attr->hca_nports - 1) *
	    sizeof (ibtl_async_port_event_t));
	ibtl_clear_ibhw_status();
}

/*
 * Function:
 *	ibt_ci_data_in()
 *
 * Input:
 *	hca_hdl			HCA Handle.
 *	flags			IBT_COMPLETE_ALLOC - Finish a deferred alloc.
 *      object                  Identifies the type object pointed to by
 *                              ibt_object_handle.
 *
 *      ibt_object_handle       The handle of the object to be associated with
 *				the data in/out
 *
 *	data_p			Pointer data passed in to the CI. The buffer
 *				should be allocated by the caller.
 *
 *	data_sz			The size of the buffer pointed to by
 *				data_p.
 * Output:
 *
 * Returns:
 *	IBT_SUCCESS
 *	IBT_NOT_SUPPORTED	Feature not supported.
 *	IBT_INVALID_PARAM	Invalid object type specified.
 *	IBT_HCA_HDL_INVALID
 *	IBT_AH_HDL_INVALID/IBT_UD_DEST_HDL_INVALID
 *	IBT_CHAN_HDL_INVALID/IBT_QP_HDL_INVALID
 *	IBT_CQ_HDL_INVALID
 *	IBT_EEC_HDL_INVALID
 *	IBT_RDD_HDL_INVALID
 *	IBT_MW_HDL_INVALID
 *	IBT_PD_HDL_INVALID
 *	IBT_SRQ_HDL_INVALID
 *
 * Description:
 *	Exchange CI private data for the specified CI object.
 */
ibt_status_t
ibt_ci_data_in(ibt_hca_hdl_t hca, ibt_ci_data_flags_t flags,
    ibt_object_type_t object, void *ibt_object_handle, void *data_p,
    size_t data_sz)
{
	ibt_status_t		retval;
	void			*ci_obj_hdl;

	IBTF_DPRINTF_L3(ibtf, "ibt_ci_data_in(%p, %x, %d, %p, %p, %d)",
	    hca, flags, object, ibt_object_handle, data_p, data_sz);

	switch (object) {
	case IBT_HDL_HCA:
		ci_obj_hdl = (void *)
		    (IBTL_HCA2CIHCA(((ibt_hca_hdl_t)ibt_object_handle)));
		break;

	case IBT_HDL_CHANNEL:
		ci_obj_hdl = (void *)
		    (IBTL_CHAN2CIQP(((ibt_channel_hdl_t)ibt_object_handle)));
		break;

	case IBT_HDL_CQ:
		ci_obj_hdl = (void *)
		    (((ibt_cq_hdl_t)(ibt_object_handle))->cq_ibc_cq_hdl);
		break;

	case IBT_HDL_EEC:
		ci_obj_hdl = (void *)
		    (((ibt_eec_hdl_t)(ibt_object_handle))->eec_ibc_eec_hdl);
		break;

	case IBT_HDL_UD_DEST:
		ci_obj_hdl = (void *)
		    (((ibt_ud_dest_hdl_t)(ibt_object_handle))->ud_ah);
		break;

	case IBT_HDL_SRQ:
		ci_obj_hdl = (void *)
		    (((ibt_srq_hdl_t)(ibt_object_handle))->srq_ibc_srq_hdl);
		break;

	default:
		ci_obj_hdl = ibt_object_handle;
		break;
	}

	retval = (IBTL_HCA2CIHCAOPS_P(hca)->ibc_ci_data_in)(IBTL_HCA2CIHCA(hca),
	    flags, object, ci_obj_hdl, data_p, data_sz);

	if (retval != IBT_SUCCESS) {
		IBTF_DPRINTF_L2(ibtf, "ibt_ci_data_in: Failed : %d", retval);
	}
	return (retval);
}

/*
 * Function:
 *	ibt_ci_data_out()
 *
 * Input:
 *	hca_hdl			HCA Handle.
 *	flags			IBT_COMPLETE_ALLOC - Finish a deferred alloc.
 *      object                  Identifies the type object pointed to by
 *                              ibt_object_handle.
 *
 *      ibt_object_handle       The handle of the object to be associated with
 *				the data in/out
 *
 *	data_p			Pointer to a buffer in which to return the CI
 *				private data. The buffer should be allocated
 *				by the caller.
 *
 *	data_sz			The size of the buffer pointed to by
 *				data_p.
 * Output:
 *
 * Returns:
 *	IBT_SUCCESS
 *	IBT_NOT_SUPPORTED	Feature not supported.
 *	IBT_INSUFF_RESOURCE	The buffer pointed to by data_p was too
 *				small to hold the data.
 *	IBT_INVALID_PARAM	Invalid object type specified.
 *	IBT_HCA_HDL_INVALID
 *	IBT_AH_HDL_INVALID/IBT_UD_DEST_HDL_INVALID
 *	IBT_CHAN_HDL_INVALID/IBT_QP_HDL_INVALID
 *	IBT_CQ_HDL_INVALID
 *	IBT_EEC_HDL_INVALID
 *	IBT_RDD_HDL_INVALID
 *	IBT_MW_HDL_INVALID
 *	IBT_PD_HDL_INVALID
 *	IBT_SRQ_HDL_INVALID
 *
 * Description:
 *	Exchange CI private data for the specified CI object.
 */
ibt_status_t
ibt_ci_data_out(ibt_hca_hdl_t hca, ibt_ci_data_flags_t flags,
    ibt_object_type_t object, void *ibt_object_handle, void *data_p,
    size_t data_sz)
{
	ibt_status_t		retval;
	void			*ci_obj_hdl;

	IBTF_DPRINTF_L3(ibtf, "ibt_ci_data_out(%p, %x, %d, %p, %p, %d)",
	    hca, flags, object, ibt_object_handle, data_p, data_sz);

	switch (object) {
	case  IBT_HDL_HCA:
		ci_obj_hdl = (void *)
		    (IBTL_HCA2CIHCA(((ibt_hca_hdl_t)ibt_object_handle)));
		break;

	case IBT_HDL_CHANNEL:
		ci_obj_hdl = (void *)
		    (IBTL_CHAN2CIQP(((ibt_channel_hdl_t)ibt_object_handle)));
		break;

	case IBT_HDL_CQ:
		ci_obj_hdl = (void *)
		    (((ibt_cq_hdl_t)(ibt_object_handle))->cq_ibc_cq_hdl);
		break;

	case IBT_HDL_EEC:
		ci_obj_hdl = (void *)
		    (((ibt_eec_hdl_t)(ibt_object_handle))->eec_ibc_eec_hdl);
		break;

	case IBT_HDL_UD_DEST:
		ci_obj_hdl = (void *)
		    (((ibt_ud_dest_hdl_t)(ibt_object_handle))->ud_ah);
		break;

	case IBT_HDL_SRQ:
		ci_obj_hdl = (void *)
		    (((ibt_srq_hdl_t)(ibt_object_handle))->srq_ibc_srq_hdl);
		break;

	default:
		ci_obj_hdl = ibt_object_handle;
		break;
	}

	retval = (IBTL_HCA2CIHCAOPS_P(hca)->ibc_ci_data_out)
	    (IBTL_HCA2CIHCA(hca), flags, object, ci_obj_hdl, data_p, data_sz);

	if (retval != IBT_SUCCESS) {
		IBTF_DPRINTF_L2(ibtf, "ibt_ci_data_out: Failed : %d", retval);
	}
	return (retval);
}


/*
 * FMA Support functions.
 */

#define	IBTL_ENA_MASK		0xC0000000
#define	IBTL_ENA_POSSIBLE	0x80000000
#define	IBTL_TYPE_SHIFT		27

/*
 * Function:
 *	ibt_get_module_failure()
 *
 * Input:
 *	type			Identifies the failing IB module.
 *	ena			'0' or the data for Fault Management
 *				Architecture (ENA).
 *
 * Returns:
 *	status			Special IB failure status.
 *
 * Description:
 *	XXX Just stubbed out to return failures with no data for Fault
 *	Management Architecture (ENAs) at the moment XXX
 */
ibt_status_t
ibt_get_module_failure(ibt_failure_type_t type, uint64_t ena)
{
	ibt_status_t	ret;

	IBTF_DPRINTF_L3(ibtf, "ibt_get_module_failure(%d, 0x%llX)", type, ena);

	switch (type) {
	case IBT_FAILURE_CI:
	case IBT_FAILURE_IBMF:
	case IBT_FAILURE_IBCM:
	case IBT_FAILURE_IBDM:
	case IBT_FAILURE_IBTL:
	case IBT_FAILURE_IBSM:
		ret = IBTL_ENA_POSSIBLE | (type << IBTL_TYPE_SHIFT);
		break;
	default:
		ret = IBT_FAILURE;
	}
	IBTF_DPRINTF_L3(ibtf, "ibt_get_module_failure: ret = 0x%lX", ret);
	return (ret);
}


/*
 * Function:
 *	ibc_get_ci_failure()
 *
 * Input:
 *	ena			'0' or the data for Fault Management
 *				Architecture (ENA).
 *
 * Returns:
 *	status			Special CI failure status.
 *
 * Description:
 *	Just use the function above to do the job.
 */
ibt_status_t
ibc_get_ci_failure(uint64_t ena)
{
	return (ibt_get_module_failure(IBT_FAILURE_CI, ena));
}


/*
 * ibt_check_failure()
 *	Function to test for special case failures.
 *
 *	status		An ibt_status_t returned from an IBTF function call.
 *
 *	reserved_p	NULL, or a pointer to where we store the data for
 *			Fault Management Architecture (ENA).
 *
 * Description:
 *	XXX Still need to determine the data for Fault Management Architecture
 *	(ENA), using 0 for now XXX
 */
ibt_failure_type_t
ibt_check_failure(ibt_status_t status, uint64_t *reserved_p)
{
	ibt_failure_type_t type;

	IBTF_DPRINTF_L3(ibtf, "ibt_check_failure(%X)", status);

	if ((status & IBTL_ENA_MASK) == IBTL_ENA_POSSIBLE) {
		type = status & ~IBTL_ENA_POSSIBLE >> IBTL_TYPE_SHIFT;

		/* XXX Need more work here... */
		if (reserved_p != NULL)
			*reserved_p = 0;
	} else {
		type = IBT_FAILURE_STANDARD;
		if (reserved_p != NULL)
			*reserved_p = 0;	/* No FMA Data Available. */
	}
	IBTF_DPRINTF_L3(ibtf, "ibt_check_failure: type = 0x%X", type);
	return (type);
}

/*
 * Initialize and create kstats.
 *
 * We create the following kstats on all ports of the HCA:
 *	<hca_driver_name><instance_number>/port<port_num>/stats
 *	<hca_driver_name><instance_number>/port<port_num>/pkeys
 */
static void
ibtl_kstat_init(ibtl_hca_devinfo_t *hca_devp)
{
	uint_t			nports = hca_devp->hd_hca_attr->hca_nports;
	ibtl_hca_port_kstat_t	*pks;
	int			i;

	IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_init(hca_devp = 0x%p)", hca_devp);

	hca_devp->hd_hca_port_ks_info_len =
	    sizeof (ibtl_hca_port_kstat_t) * nports;
	pks = kmem_zalloc(hca_devp->hd_hca_port_ks_info_len, KM_SLEEP);
	hca_devp->hd_hca_port_ks_info = pks;

	for (i = 0; i < nports; i++, pks++) {
		pks->pks_hca_devp = hca_devp;
		pks->pks_port_num = i + 1;
		ibtl_kstat_stats_create(hca_devp, i + 1);
		ibtl_kstat_pkeys_create(hca_devp, i + 1);
	}
}

/*
 * Delete kstats on all ports of the HCA.
 */
static void
ibtl_kstat_fini(ibtl_hca_devinfo_t *hca_devp)
{
	ibtl_hca_port_kstat_t	*pks;
	int			i;

	IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_fini(hca_devp = 0x%p)", hca_devp);

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*hca_devp))

	pks = hca_devp->hd_hca_port_ks_info;
	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*pks))

	if (pks == NULL)
		return;

	for (i = 0; i < hca_devp->hd_hca_attr->hca_nports; i++, pks++) {
		if (pks->pks_stats_ksp)
			kstat_delete(pks->pks_stats_ksp);

		if (pks->pks_pkeys_ksp) {
			ASSERT(!MUTEX_HELD(&ibtl_clnt_list_mutex));
			kstat_delete(pks->pks_pkeys_ksp);
		}
	}

	kmem_free(hca_devp->hd_hca_port_ks_info,
	    hca_devp->hd_hca_port_ks_info_len);
}

/*
 * Update "stats" kstat.
 * Called by kstat framework.
 */
static int
ibtl_kstat_stats_update(kstat_t *ksp, int rw)
{
	ibtl_hca_port_kstat_t	*pks;
	ibtl_hca_devinfo_t	*hca_devp;
	ibt_hca_portinfo_t	*p;
	struct kstat_named	*data;

	IBTF_DPRINTF_L4(ibtf, "ibtl_kstat_stats_update(ksp = 0x%p, rw = %d)",
	    ksp, rw);

	if (rw == KSTAT_WRITE)
		return (EACCES);

	mutex_enter(&ibtl_clnt_list_mutex);

	/*
	 * Update the link_state kstat using the value from portinfo cache.
	 */
	pks = ksp->ks_private;
	hca_devp = pks->pks_hca_devp;
	data = (struct kstat_named *)(ksp->ks_data);
	p = hca_devp->hd_portinfop + pks->pks_port_num - 1;
	data[0].value.ui32 = (uint32_t)p->p_linkstate;

	mutex_exit(&ibtl_clnt_list_mutex);

	return (0);
}

/*
 * Create "stats" kstat for the specified HCA port in the form:
 *	<hca_driver_name><instance_number>/port<port_num>/stats
 *	At preset it contains only one named data of "link_state"
 */
static void
ibtl_kstat_stats_create(ibtl_hca_devinfo_t *hca_devp, uint_t port_num)
{
	struct kstat		*ksp;
	struct kstat_named	*named_data;
	char			*drv_name;
	int			drv_instance;
	ibtl_hca_port_kstat_t	*pks;
	char			kname[40];

	IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_stats_create(hca_devp = 0x%p, "
	    "port_num = 0x%u)", hca_devp, port_num);

	drv_name = (char *)ddi_driver_name(hca_devp->hd_hca_dip);
	drv_instance = ddi_get_instance(hca_devp->hd_hca_dip);
	(void) snprintf(kname, sizeof (kname), "%s%d/port%d/stats",
	    drv_name, drv_instance, port_num);

	ksp = kstat_create("ibtf", 0, kname, "ib", KSTAT_TYPE_NAMED, 1, 0);
	if (ksp == NULL) {
		IBTF_DPRINTF_L2(ibtf,
		    "ibtl_kstat_stats_create: kstat_create() failed");
		return;
	}

	named_data = (struct kstat_named *)(ksp->ks_data);
	kstat_named_init(&named_data[0], "link_state", KSTAT_DATA_UINT32);

	pks = hca_devp->hd_hca_port_ks_info + port_num - 1;
	pks->pks_stats_ksp = ksp;

	ksp->ks_private = pks;
	ksp->ks_update = ibtl_kstat_stats_update;

	/* Install the kstat */
	kstat_install(ksp);
}

/*
 * Update "pkeys" kstat.
 *
 * Called by kstat framework. Since ks_lock was set to ibtl_clnt_list_mutex
 * at the time of the kstat creation, kstat framework will hold this lock
 * while calling this function.
 */
static int
ibtl_kstat_pkeys_update(kstat_t *ksp, int rw)
{
	ibtl_hca_port_kstat_t	*pks;
	ibtl_hca_devinfo_t	*hca_devp;
	ibt_hca_portinfo_t	*p;

	IBTF_DPRINTF_L4(ibtf, "ibtl_kstat_pkeys_update(ksp = 0x%p, rw = %d)",
	    ksp, rw);

#ifndef	__lock_lint
	ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex));
#endif

	if (rw == KSTAT_WRITE)
		return (EACCES);

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ksp))

	pks = ksp->ks_private;
	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*pks))

	hca_devp = pks->pks_hca_devp;
	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*hca_devp))

	/*
	 * Point kstat data to the pkey table in the portinfo cache.
	 */

	p = hca_devp->hd_portinfop + pks->pks_port_num - 1;

	ksp->ks_data = p->p_pkey_tbl;
	ksp->ks_ndata = p->p_pkey_tbl_sz;
	ksp->ks_data_size = p->p_pkey_tbl_sz * sizeof (ib_pkey_t);

	return (0);
}

/*
 * Create "pkeys" kstat for the specified HCA port in the form:
 *	<hca_driver_name><instance_number>/port<port_num>/pkeys
 *
 * Currently kstat framework allows only some fixed data types as named
 * data components under a named kstat. Due to this limitation it is not
 * possible to add "pkeys" as a named data under the "stats" kstat.
 */
static void
ibtl_kstat_pkeys_create(ibtl_hca_devinfo_t *hca_devp, uint_t port_num)
{
	struct kstat		*ksp;
	char			*drv_name;
	int			drv_instance;
	char			kname[40];
	ibtl_hca_port_kstat_t	*pks;

	IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_stats_create(hca_devp = 0x%p, "
	    "port_num = 0x%u)", hca_devp, port_num);

	drv_name = (char *)ddi_driver_name(hca_devp->hd_hca_dip);
	drv_instance = ddi_get_instance(hca_devp->hd_hca_dip);
	(void) snprintf(kname, sizeof (kname), "%s%d/port%d/pkeys",
	    drv_name, drv_instance, port_num);

	ksp = kstat_create("ibtf", 0, kname, "ib", KSTAT_TYPE_RAW, 0,
	    KSTAT_FLAG_VAR_SIZE | KSTAT_FLAG_VIRTUAL);
	if (ksp == NULL) {
		IBTF_DPRINTF_L2(ibtf,
		    "ibtl_kstat_pkeys_create: kstat_create() failed");
		return;
	}

	pks = hca_devp->hd_hca_port_ks_info + port_num - 1;
	pks->pks_pkeys_ksp = ksp;

	ksp->ks_private = pks;
	ksp->ks_update = ibtl_kstat_pkeys_update;
	ksp->ks_lock = &ibtl_clnt_list_mutex;

	/*
	 * We just go with the default_kstat_snapshot().
	 * So there is no need to set ks_snapshot field.
	 */

	/* Install the kstat */
	kstat_install(ksp);
}