xref: /onnv-gate/usr/src/uts/common/io/ib/ibtl/ibtl_ibnex.c (revision 13101:da7b13ec3a28)

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

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

/*
 * ibtl_ibnex.c
 *    These routines tie the Device Manager into IBTL.
 *
 *    ibt_reprobe_dev which can be called by IBTF clients.
 *    This results in calls to IBnexus callback.
 */

/*
 * Globals.
 */
static char		ibtl_ibnex[] = "ibtl_ibnex";
ibtl_ibnex_callback_t	ibtl_ibnex_callback_routine = NULL;

/*
 * Function:
 *	ibtl_ibnex_get_hca_info
 * Input:
 *	hca_guid	- The HCA's node GUID.
 *	flag		- Tells what to do
 *			IBTL_IBNEX_LIST_CLNTS_FLAG - Build a NVLIST containing
 *						client's names, their AP_IDs and
 *						alternate_HCA information.
 *						(-x list_clients option)
 *			IBTL_IBNEX_UNCFG_CLNTS_FLAG - Build a NVLIST containing
 *						clients' devpaths and their
 *						AP_IDs. (-x unconfig_clients)
 *	callback	- Callback function to get ap_id from ib(7d)
 * Output:
 *	buffer		- The information is returned in this buffer
 *      bufsiz		- The size of the information buffer
 * Returns:
 *	IBT_SUCCESS/IBT_HCA_INVALID/IBT_INVALID_PARAM
 * Description:
 *      For a given HCA node GUID it figures out the registered clients
 *	(ie. ones who called ibt_open_hca(9f) on this GUID) and creates
 *	a NVL packed buffer (of client names/ap_ids or devpaths) and returns
 *	it. If flag is not specified, then an error is returned.
 */
ibt_status_t
ibtl_ibnex_get_hca_info(ib_guid_t hca_guid, int flag, char **buffer,
    size_t *bufsiz, void (*callback)(dev_info_t *, char **))
{
	char			*node_name;
	char			*ret_apid;
	nvlist_t		*nvl;
	ibtl_hca_t		*ibt_hca;
	ibtl_clnt_t		*clntp;
	dev_info_t		*child;
	dev_info_t		*parent;
	ibtl_hca_devinfo_t	*hca_devp;

	IBTF_DPRINTF_L3(ibtl_ibnex, "ibtl_ibnex_get_hca_info: "
	    "GUID  0x%llX, flag = 0x%x", hca_guid, flag);

	*buffer = NULL;
	*bufsiz = 0;

	/* verify that valid "flag" is passed */
	if (flag != IBTL_IBNEX_LIST_CLNTS_FLAG &&
	    flag != IBTL_IBNEX_UNCFG_CLNTS_FLAG) {
		return (IBT_INVALID_PARAM);
	}

	mutex_enter(&ibtl_clnt_list_mutex);

	if ((hca_devp = ibtl_get_hcadevinfo(hca_guid)) == NULL) {
		mutex_exit(&ibtl_clnt_list_mutex);

		/*
		 * If we are here, then the requested HCA device is not
		 * present. Return the status as Invalid HCA GUID.
		 */
		IBTF_DPRINTF_L2(ibtl_ibnex, "ibtl_ibnex_get_hca_info: "
		    "HCA Not Found, Invalid HCA GUID 0x%llX", hca_guid);
		return (IBT_HCA_INVALID);
	}

	/* Walk the client list */
	ibt_hca = hca_devp->hd_clnt_list;
	(void) nvlist_alloc(&nvl, 0, KM_SLEEP);

	/* Allocate memory for ret_apid, instead of using stack */
	ret_apid = kmem_alloc(IBTL_IBNEX_APID_LEN, KM_SLEEP);

	while (ibt_hca != NULL) {
		clntp = ibt_hca->ha_clnt_devp;
		child = clntp->clnt_dip;
		IBTF_DPRINTF_L4(ibtl_ibnex, "ibtl_ibnex_get_hca_info: "
		    "Client = %s", clntp->clnt_modinfop->mi_clnt_name);

		if (flag == IBTL_IBNEX_LIST_CLNTS_FLAG) {
			(void) nvlist_add_string(nvl, "Client",
			    clntp->clnt_modinfop->mi_clnt_name);

			/*
			 * Always check, first, if this client exists
			 * under this HCA anymore? If not, continue.
			 */
			if (clntp->clnt_hca_list == NULL) {
				(void) nvlist_add_string(nvl, "Alt_HCA", "no");
				(void) nvlist_add_string(nvl, "ApID", "-");
				ibt_hca = ibt_hca->ha_clnt_link;
				continue;
			}

			/* Check if this client has more than one HCAs */
			if (clntp->clnt_hca_list->ha_hca_link == NULL)
				(void) nvlist_add_string(nvl, "Alt_HCA", "no");
			else
				(void) nvlist_add_string(nvl, "Alt_HCA", "yes");

			if (child == NULL) {
				(void) nvlist_add_string(nvl, "ApID", "-");
				ibt_hca = ibt_hca->ha_clnt_link;
				continue;
			}

			/*
			 * All IB clients (IOC, VPPA, Port, Pseudo etc.)
			 * need to be looked at. The parent of IOC nodes
			 * is "ib" nexus and node-name is "ioc". "VPPA/Port"s
			 * should have HCA as parent and node-name is "ibport".
			 * HCA validity is checked by looking at parent's "dip"
			 * and the dip saved in the ibtl_hca_devinfo_t.
			 * NOTE: We only want to list this HCA's IB clients.
			 * All others clients are ignored.
			 */
			parent = ddi_get_parent(child);
			if (parent == NULL || /* No parent? */
			    ddi_get_parent_data(child) == NULL) {
				(void) nvlist_add_string(nvl, "ApID", "-");
				ibt_hca = ibt_hca->ha_clnt_link;
				continue;
			}

			node_name = ddi_node_name(child);
			if ((strcmp(ddi_node_name(parent), "ib") == 0) ||
			    ((hca_devp->hd_hca_dip == parent) &&
			    (strncmp(node_name, IBNEX_IBPORT_CNAME, 6) == 0))) {
				ASSERT(callback != NULL);
				/*
				 * Callback is invoked to figure out the
				 * ap_id string.
				 */
				callback(child, &ret_apid);
				(void) nvlist_add_string(nvl, "ApID", ret_apid);
			} else {
				(void) nvlist_add_string(nvl, "ApID", "-");
			}

		} else if (flag == IBTL_IBNEX_UNCFG_CLNTS_FLAG) {
			char		path[MAXPATHLEN];

			if (child == NULL) {
				IBTF_DPRINTF_L4(ibtl_ibnex,
				    "ibtl_ibnex_get_hca_info: No dip exists");
				ibt_hca = ibt_hca->ha_clnt_link;
				continue;
			}

			/*
			 * if the child has a alternate HCA then skip it
			 */
			if (clntp->clnt_hca_list->ha_hca_link) {
				IBTF_DPRINTF_L4(ibtl_ibnex,
				    "ibtl_ibnex_get_hca_info: Alt HCA exists");
				ibt_hca = ibt_hca->ha_clnt_link;
				continue;
			}

			/*
			 * See earlier comments on how to check if a client
			 * is IOC, VPPA, Port or a Pseudo node.
			 */
			parent = ddi_get_parent(child);
			if (parent == NULL || /* No parent? */
			    ddi_get_parent_data(child) == NULL) {
				IBTF_DPRINTF_L4(ibtl_ibnex,
				    "ibtl_ibnex_get_hca_info: no parent");
				ibt_hca = ibt_hca->ha_clnt_link;
				continue;
			}

			node_name = ddi_node_name(child);
			if ((strcmp(ddi_node_name(parent), "ib") == 0) ||
			    ((hca_devp->hd_hca_dip == parent) &&
			    (strncmp(node_name, IBNEX_IBPORT_CNAME, 6) == 0))) {
				ASSERT(callback != NULL);
				/*
				 * Callback is invoked to figure out the
				 * ap_id string.
				 */
				callback(child, &ret_apid);
				(void) nvlist_add_string(nvl, "ApID", ret_apid);

				/*
				 * ddi_pathname() doesn't supply /devices,
				 * so we do
				 */
				(void) strcpy(path, "/devices");
				(void) ddi_pathname(child, path + strlen(path));
				IBTF_DPRINTF_L4(ibtl_ibnex,
				    "ibtl_ibnex_get_hca_info: "
				    "device path = %s", path);

				if (nvlist_add_string(nvl, "devpath", path)) {
					IBTF_DPRINTF_L2(ibtl_ibnex,
					    "ibtl_ibnex_get_hca_info: "
					    "failed to fill in path %s", path);
					mutex_exit(&ibtl_clnt_list_mutex);
					nvlist_free(nvl);
					kmem_free(ret_apid,
					    IBTL_IBNEX_APID_LEN);
					return (ibt_get_module_failure(
					    IBT_FAILURE_IBTL, 0));
				}
			} /* end of if */
		} /* end of while */

		ibt_hca = ibt_hca->ha_clnt_link;
	} /* End of while */
	mutex_exit(&ibtl_clnt_list_mutex);

	kmem_free(ret_apid, IBTL_IBNEX_APID_LEN);

	/* Pack all data into "buffer" */
	if (nvlist_pack(nvl, buffer, bufsiz, NV_ENCODE_NATIVE, KM_SLEEP)) {
		IBTF_DPRINTF_L2(ibtl_ibnex, "ibtl_ibnex_get_hca_info: "
		    "nvlist_pack failed");
		nvlist_free(nvl);
		return (ibt_get_module_failure(IBT_FAILURE_IBTL, 0));
	}

	IBTF_DPRINTF_L4(ibtl_ibnex, "ibtl_ibnex_get_hca_info: size = %x",
	    *bufsiz);
	nvlist_free(nvl);
	return (IBT_SUCCESS);
}


/*
 * Function:
 *      ibtl_ibnex_register_callback()
 * Input:
 *	ibnex_cb	- IB nexus driver callback routine
 * Output:
 *      none
 * Returns:
 *      none
 * Description:
 *     	Register a callback routine for IB nexus driver
 */
void
ibtl_ibnex_register_callback(ibtl_ibnex_callback_t ibnex_cb)
{
	IBTF_DPRINTF_L5(ibtl_ibnex, "ibtl_ibnex_register_callback:");

	mutex_enter(&ibtl_clnt_list_mutex);
	ibtl_ibnex_callback_routine = ibnex_cb;
	mutex_exit(&ibtl_clnt_list_mutex);
}

/*
 * Function:
 *      ibtl_ibnex_unregister_callback()
 * Input:
 *      none
 * Output:
 *      none
 * Returns:
 *      none
 * Description:
 *     	Un-register a callback routine for IB nexus driver
 */
void
ibtl_ibnex_unregister_callback()
{
	IBTF_DPRINTF_L5(ibtl_ibnex, "ibtl_ibnex_unregister_callback: ibnex cb");

	mutex_enter(&ibtl_clnt_list_mutex);
	ibtl_ibnex_callback_routine = NULL;
	mutex_exit(&ibtl_clnt_list_mutex);
}


/*
 * Function:
 *	ibtl_ibnex_hcadip2guid
 * Input:
 *	dev_info_t	- The "dip" of this HCA
 * Output:
 *	hca_guid	- The HCA's node GUID.
 * Returns:
 *	"HCA GUID" on SUCCESS, NULL on FAILURE
 * Description:
 *      For a given HCA node GUID it figures out the HCA GUID
 *	and returns it. If not found, NULL is returned.
 */
ib_guid_t
ibtl_ibnex_hcadip2guid(dev_info_t *hca_dip)
{
	ib_guid_t		hca_guid = 0LL;
	ibtl_hca_devinfo_t	*hca_devp;

	mutex_enter(&ibtl_clnt_list_mutex);
	hca_devp = ibtl_hca_list;

	while (hca_devp) {
		if (hca_devp->hd_hca_dip == hca_dip) {
			hca_guid = hca_devp->hd_hca_attr->hca_node_guid;
			break;
		}
		hca_devp = hca_devp->hd_hca_dev_link;
	}
	mutex_exit(&ibtl_clnt_list_mutex);
	IBTF_DPRINTF_L4(ibtl_ibnex, "ibtl_ibnex_hcadip_guid: hca_guid 0x%llX",
	    hca_guid);
	return (hca_guid);
}


/*
 * Function:
 *	ibtl_ibnex_hcaguid2dip
 * Input:
 *	hca_guid	- The HCA's node GUID.
 * Output:
 *	dev_info_t	- The "dip" of this HCA
 * Returns:
 *	"dip" on SUCCESS, NULL on FAILURE
 * Description:
 *      For a given HCA node GUID it figures out the "dip"
 *	and returns it. If not found, NULL is returned.
 */
dev_info_t *
ibtl_ibnex_hcaguid2dip(ib_guid_t hca_guid)
{
	dev_info_t		*dip = NULL;
	ibtl_hca_devinfo_t	*hca_devp;

	IBTF_DPRINTF_L4(ibtl_ibnex, "ibtl_ibnex_hcaguid2dip:");

	mutex_enter(&ibtl_clnt_list_mutex);
	hca_devp = ibtl_hca_list;

	while (hca_devp) {
		if (hca_devp->hd_hca_attr->hca_node_guid == hca_guid) {
			dip = hca_devp->hd_hca_dip;
			break;
		}
		hca_devp = hca_devp->hd_hca_dev_link;
	}
	mutex_exit(&ibtl_clnt_list_mutex);
	return (dip);
}


/*
 * Function:
 *	ibtl_ibnex_get_hca_verbose_data
 * Input:
 *	hca_guid	- The HCA's node GUID.
 * Output:
 *	buffer		- The information is returned in this buffer
 *      bufsiz		- The size of the information buffer
 * Returns:
 *	IBT_SUCCESS/IBT_HCA_INVALID
 * Description:
 *      For a given HCA node GUID it figures out the verbose listing display.
 */
ibt_status_t
ibtl_ibnex_get_hca_verbose_data(ib_guid_t hca_guid, char **buffer,
    size_t *bufsiz)
{
	char			path[IBTL_IBNEX_STR_LEN];
	char			tmp[MAXPATHLEN];
	uint_t			ii;
	ibt_hca_portinfo_t	*pinfop;
	ibtl_hca_devinfo_t	*hca_devp;

	IBTF_DPRINTF_L3(ibtl_ibnex, "ibtl_ibnex_get_hca_verbose_data: "
	    "HCA GUID 0x%llX", hca_guid);

	*buffer = NULL;
	*bufsiz = 0;

	mutex_enter(&ibtl_clnt_list_mutex);
	if ((hca_devp = ibtl_get_hcadevinfo(hca_guid)) == NULL) {
		mutex_exit(&ibtl_clnt_list_mutex);

		/*
		 * If we are here, then the requested HCA device is not
		 * present. Return the status as Invalid HCA GUID.
		 */
		IBTF_DPRINTF_L2(ibtl_ibnex, "ibtl_ibnex_get_hca_verbose_data: "
		    "HCA Not Found, Invalid HCA GUID");
		return (IBT_HCA_INVALID);
	}

	(void) snprintf(tmp, MAXPATHLEN, "VID: 0x%x, PID: 0x%x, #ports: 0x%x",
	    hca_devp->hd_hca_attr->hca_vendor_id,
	    hca_devp->hd_hca_attr->hca_device_id,
	    hca_devp->hd_hca_attr->hca_nports);

	pinfop = hca_devp->hd_portinfop;
	for (ii = 0; ii < hca_devp->hd_hca_attr->hca_nports; ii++) {
		(void) snprintf(path, IBTL_IBNEX_STR_LEN,
		    ", port%d GUID: 0x%llX", ii + 1,
		    (longlong_t)pinfop[ii].p_sgid_tbl->gid_guid);
		(void) strcat(tmp, path);
	}
	mutex_exit(&ibtl_clnt_list_mutex);

	*bufsiz =  strlen(tmp);
	*buffer = kmem_alloc(*bufsiz, KM_SLEEP);
	(void) strncpy(*buffer, tmp, *bufsiz);

	IBTF_DPRINTF_L4(ibtl_ibnex, "ibtl_ibnex_get_hca_verbose_data: "
	    "data = %s, size = 0x%x", *buffer, *bufsiz);
	return (IBT_SUCCESS);
}

/*
 * Function:
 *      ibt_reprobe_dev()
 * Input:
 *      dev_info_t	*dip
 * Output:
 *      none
 * Returns:
 *      Return value from IBnexus callback handler
 *		IBT_ILLEGAL_OP if IBnexus callback is not installed.
 * Description:
 *     	This function passes the IBTF client's "reprobe device
 *		properties" request to IBnexus. See ibt_reprobe_dev(9f)
 *		for details.
 */
ibt_status_t
ibt_reprobe_dev(dev_info_t *dip)
{
	ibt_status_t		rv;
	ibtl_ibnex_cb_args_t	cb_args;

	if (dip == NULL)
		return (IBT_NOT_SUPPORTED);

	/*
	 * Restricting the reprobe request to the children of
	 * ibnexus. Note the IB_CONF_UPDATE_EVENT DDI event can
	 * be subscribed by any device on the IBnexus device tree.
	 */
	if (strcmp(ddi_node_name(ddi_get_parent(dip)), "ib") != 0)
		return (IBT_NOT_SUPPORTED);

	/* Reprobe for IOC nodes only */
	if (strncmp(ddi_node_name(dip), IBNEX_IBPORT_CNAME, 6) == 0)
		return (IBT_NOT_SUPPORTED);

	cb_args.cb_flag = IBTL_IBNEX_REPROBE_DEV_REQ;
	cb_args.cb_dip = dip;
	mutex_enter(&ibtl_clnt_list_mutex);
	if (ibtl_ibnex_callback_routine) {
		rv = (*ibtl_ibnex_callback_routine)(&cb_args);
		mutex_exit(&ibtl_clnt_list_mutex);
		return (rv);
	}
	mutex_exit(&ibtl_clnt_list_mutex);

	/* Should -not- come here */
	IBTF_DPRINTF_L2("ibtl", "ibt_reprobe_dev: ibnex not registered!!");
	return (IBT_ILLEGAL_OP);
}


/*
 * Function:
 *	ibtl_ibnex_valid_hca_parent
 * Input:
 *	pdip		- The parent dip from client's child dev_info_t
 * Output:
 *	NONE
 * Returns:
 *	IBT_SUCCESS/IBT_NO_HCAS_AVAILABLE
 * Description:
 *	For a given pdip, of Port/VPPA devices, match it against all the
 *	registered HCAs's dip.  If match found return IBT_SUCCESS,
 *	else IBT_NO_HCAS_AVAILABLE.
 *
 *	For IOC/Pseudo devices check if the given pdip is that of
 *	the ib(7d) nexus or that of the eoib(7d) nexus. If yes
 *	return IBT_SUCCESS, else IBT_NO_HCAS_AVAILABLE.
 */
ibt_status_t
ibtl_ibnex_valid_hca_parent(dev_info_t *pdip)
{
	ibtl_hca_devinfo_t	*hca_devp;

	IBTF_DPRINTF_L4(ibtl_ibnex, "ibtl_ibnex_valid_hca_parent: pdip %p",
	    pdip);

	/* For Pseudo devices and IOCs */
	if (strncmp(ddi_node_name(pdip), "ib", 2) == 0 ||
	    strncmp(ddi_node_name(pdip), "eibnx", 5) == 0) {
		return (IBT_SUCCESS);
	} else {
		/* For Port devices and VPPAs */
		mutex_enter(&ibtl_clnt_list_mutex);
		hca_devp = ibtl_hca_list;
		while (hca_devp) {
			if (hca_devp->hd_hca_dip == pdip) {
				mutex_exit(&ibtl_clnt_list_mutex);
				return (IBT_SUCCESS);
			}
			hca_devp = hca_devp->hd_hca_dev_link;
		}
		mutex_exit(&ibtl_clnt_list_mutex);
		return (IBT_NO_HCAS_AVAILABLE);
	}
}

/*
 * Function:
 *	ibtl_ibnex_phci_register
 * Input:
 *	hca_dip		- The HCA dip
 * Output:
 *	NONE
 * Returns:
 *	IBT_SUCCESS/IBT_FAILURE
 * Description:
 * 	Register the HCA dip as the MPxIO PCHI.
 */
ibt_status_t
ibtl_ibnex_phci_register(dev_info_t *hca_dip)
{
	/* Register the with MPxIO as PHCI */
	if (mdi_phci_register(MDI_HCI_CLASS_IB, hca_dip, 0) !=
	    MDI_SUCCESS) {
		return (IBT_FAILURE);
	}
	return (IBT_SUCCESS);
}

/*
 * Function:
 *	ibtl_ibnex_phci_unregister
 * Input:
 *	hca_dip		- The HCA dip
 * Output:
 *	NONE
 * Returns:
 *	IBT_SUCCESS/IBT_FAILURE
 * Description:
 * 	Free up any pending MPxIO Pathinfos and unregister the HCA dip as the
 * 	MPxIO PCHI.
 */
ibt_status_t
ibtl_ibnex_phci_unregister(dev_info_t *hca_dip)
{
	mdi_pathinfo_t *pip = NULL;
	dev_info_t *vdip = 0;
	int circ = 0, circ1 = 0;

	/*
	 * Should free all the Pathinfos associated with the HCA pdip before
	 * unregistering the PHCI.
	 *
	 * mdi_pi_free will call ib_vhci_pi_uninit() callbackfor each PI where
	 * the ibnex internal datastructures (ibnex_node_data) will have to be
	 * cleaned up if needed.
	 */
	vdip = mdi_devi_get_vdip(hca_dip);
	ndi_devi_enter(vdip, &circ1);
	ndi_devi_enter(hca_dip, &circ);
	while (pip = mdi_get_next_client_path(hca_dip, NULL)) {
		if (mdi_pi_free(pip, 0) == MDI_SUCCESS) {
			continue;
		}
		ndi_devi_exit(hca_dip, circ);
		ndi_devi_exit(vdip, circ1);
		IBTF_DPRINTF_L1(ibtl_ibnex, "ibtl_ibnex_phci_unregister: "
		    "mdi_pi_free failed");
		return (IBT_FAILURE);
	}
	ndi_devi_exit(hca_dip, circ);
	ndi_devi_exit(vdip, circ1);

	if (mdi_phci_unregister(hca_dip, 0) != MDI_SUCCESS) {
		IBTF_DPRINTF_L1(ibtl_ibnex, "ibtl_ibnex_phci_unregister: PHCI "
		    "unregister failed");
		return (IBT_FAILURE);
	}
	return (IBT_SUCCESS);
}

/*
 * Function:
 *	ibtl_ibnex_query_hca_byguid
 * Input:
 *	hca_guid	- The HCA's node GUID.
 *	driver_name_size- size of the caller allocated driver_name buffer
 * Output:
 *	hca_attrs	- caller allocated buffer which will contain
 *			  HCA attributes upon success
 *	driver_name	- caller allocated buffer which will contain
 *			  HCA driver name upon success
 *	driver_instance - HCA driver instance
 *	hca_device_path	- caller allocated buffer of size MAXPATHLEN which
 *			  will contain hca device path upon success.
 * Returns:
 *	IBT_SUCCESS/IBT_FAILURE
 * Description:
 *	Get the HCA attributes, driver name and instance number of the
 *	specified HCA.
 */
ibt_status_t
ibtl_ibnex_query_hca_byguid(ib_guid_t hca_guid, ibt_hca_attr_t *hca_attrs,
    char *driver_name, size_t driver_name_size, int *driver_instance,
    char *hca_device_path)
{
	ibtl_hca_devinfo_t	*hca_devp;

	IBTF_DPRINTF_L4(ibtl_ibnex, "ibtl_ibnex_query_hca_byguid("
	    "hca_guid = 0x%llx, hca_attrs = 0x%p, driver_name = 0x%p, "
	    "driver_name_size = 0x%d, driver_instancep = 0x%p)", hca_guid,
	    hca_attrs, driver_name, (int)driver_name_size, driver_instance);

	mutex_enter(&ibtl_clnt_list_mutex);

	hca_devp = ibtl_get_hcadevinfo(hca_guid);
	if (hca_devp == NULL) {
		mutex_exit(&ibtl_clnt_list_mutex);
		return (IBT_HCA_INVALID);
	}

	if (strlcpy(driver_name,
	    ddi_driver_name(hca_devp->hd_hca_dip), driver_name_size) >=
	    driver_name_size) {
		mutex_exit(&ibtl_clnt_list_mutex);
		return (IBT_INSUFF_KERNEL_RESOURCE);
	}

	(void) ddi_pathname(hca_devp->hd_hca_dip, hca_device_path);
	*driver_instance = ddi_get_instance(hca_devp->hd_hca_dip);
	bcopy(hca_devp->hd_hca_attr, hca_attrs, sizeof (ibt_hca_attr_t));

	mutex_exit(&ibtl_clnt_list_mutex);
	return (IBT_SUCCESS);
}