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

/*
 * Infiniband Device Management Agent for IB storage.
 */

#include <sys/conf.h>
#include <sys/file.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/priv.h>
#include <sys/sysmacros.h>

#include <sys/ib/ibtl/ibti.h>		/* IB public interfaces */

#include <sys/ib/mgt/ibdma/ibdma.h>
#include <sys/ib/mgt/ibdma/ibdma_impl.h>

/*
 * NOTE: The IB Device Management Agent function, like other IB
 * managers and agents is best implemented as a kernel misc.
 * module.
 * Eventually we could modify IBT_DM_AGENT so that we don't need to
 * open each HCA to receive asynchronous events.
 */

#define	IBDMA_NAME_VERSION	"IB Device Management Agent"

extern struct mod_ops mod_miscops;

static void ibdma_ibt_async_handler(void *clnt, ibt_hca_hdl_t hdl,
	ibt_async_code_t code, ibt_async_event_t *event);

static void ibdma_mad_recv_cb(ibmf_handle_t ibmf_hdl,
	ibmf_msg_t *msgp, void *args);
static void ibdma_create_resp_mad(ibmf_msg_t *msgp);

/*
 * Misc. kernel module for now.
 */
static struct modlmisc modlmisc = {
	&mod_miscops,
	IBDMA_NAME_VERSION
};

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

static ibt_clnt_modinfo_t ibdma_ibt_modinfo = {
	IBTI_V_CURR,
	IBT_DM_AGENT,
	ibdma_ibt_async_handler,
	NULL,
	"ibdma"
};

/*
 * Module global state allocated at init().
 */
static ibdma_mod_state_t	*ibdma = NULL;

/*
 * Init/Fini handlers and IBTL HCA management prototypes.
 */
static int ibdma_init();
static int ibdma_fini();
static int ibdma_ibt_init();
static void ibdma_ibt_fini();
static ibdma_hca_t *ibdma_hca_init(ib_guid_t guid);
static void ibdma_hca_fini(ibdma_hca_t *hca);
static ibdma_hca_t *ibdma_find_hca(ib_guid_t guid);

/*
 * DevMgmt Agent MAD attribute handlers prototypes.
 */
static void ibdma_get_class_portinfo(ibmf_msg_t *msg);
static void ibdma_get_io_unitinfo(ibdma_hca_t *hca, ibmf_msg_t *msg);
static void ibdma_get_ioc_profile(ibdma_hca_t *hca, ibmf_msg_t *msg);
static void ibdma_get_ioc_services(ibdma_hca_t *hca, ibmf_msg_t *msg);

/*
 * _init()
 */
int
_init(void)
{
	int status;

	ASSERT(ibdma == NULL);

	ibdma = kmem_zalloc(sizeof (*ibdma), KM_SLEEP);
	ASSERT(ibdma != NULL);

	status = ibdma_init();
	if (status != DDI_SUCCESS) {
		kmem_free(ibdma, sizeof (*ibdma));
		ibdma = NULL;
		return (status);
	}

	status = mod_install(&modlinkage);
	if (status != DDI_SUCCESS) {
		cmn_err(CE_NOTE, "_init, mod_install error (%d)", status);
		(void) ibdma_fini();
		kmem_free(ibdma, sizeof (*ibdma));
		ibdma = NULL;
	}
	return (status);
}

/*
 * _info()
 */
int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

/*
 * _fini()
 */
int
_fini(void)
{
	int		status;
	int		slot;
	ibdma_hca_t	*hca;

	status = mod_remove(&modlinkage);
	if (status != DDI_SUCCESS) {
		cmn_err(CE_NOTE, "_fini, mod_remove error (%d)", status);
		return (status);
	}

	/*
	 * Sanity check to see if anyone is not cleaning
	 * up appropriately.
	 */
	mutex_enter(&ibdma->ms_hca_list_lock);
	hca = list_head(&ibdma->ms_hca_list);
	while (hca != NULL) {
		for (slot = 0; slot < IBDMA_MAX_IOC; slot++) {
			if (hca->ih_ioc[slot].ii_inuse) {
				cmn_err(CE_NOTE, "_fini, IOC %d still attached"
				    " for (0x%0llx)", slot+1,
				    (u_longlong_t)hca->ih_iou_guid);
			}
		}
		hca = list_next(&ibdma->ms_hca_list, hca);
	}
	mutex_exit(&ibdma->ms_hca_list_lock);

	(void) ibdma_fini();
	kmem_free(ibdma, sizeof (*ibdma));
	return (status);
}

/*
 * ibdma_init()
 *
 * Initialize I/O Unit structure, generate initial HCA list and register
 * it port with the IBMF.
 */
static int
ibdma_init()
{
	int		status;

	/*
	 * Global lock and I/O Unit initialization.
	 */
	mutex_init(&ibdma->ms_hca_list_lock, NULL, MUTEX_DRIVER, NULL);

	/*
	 * Discover IB hardware and setup for device management agent
	 * support.
	 */
	status = ibdma_ibt_init();
	if (status != DDI_SUCCESS) {
		cmn_err(CE_NOTE, "ibdma_init, ibt_attach failed (%d)",
		    status);
		mutex_destroy(&ibdma->ms_hca_list_lock);
		return (status);
	}

	return (status);
}

/*
 * ibdma_fini()
 *
 * Release resource if we are no longer in use.
 */
static int
ibdma_fini()
{
	ibdma_ibt_fini();
	mutex_destroy(&ibdma->ms_hca_list_lock);
	return (DDI_SUCCESS);
}

/*
 * ibdma_ibt_async_handler()
 */
/* ARGSUSED */
static void
ibdma_ibt_async_handler(void *clnt, ibt_hca_hdl_t hdl,
	ibt_async_code_t code, ibt_async_event_t *event)
{
	ibdma_hca_t	*hca;

	switch (code) {

	case IBT_EVENT_PORT_UP:
	case IBT_ERROR_PORT_DOWN:
	case IBT_PORT_CHANGE_EVENT:
	case IBT_CLNT_REREG_EVENT:
		break;

	case IBT_HCA_ATTACH_EVENT:
		mutex_enter(&ibdma->ms_hca_list_lock);
		hca = ibdma_hca_init(event->ev_hca_guid);
		if (hca != NULL) {
			list_insert_tail(&ibdma->ms_hca_list, hca);
			cmn_err(CE_NOTE, "hca ibt hdl (%p)",
			    (void *)hca->ih_ibt_hdl);
			ibdma->ms_num_hcas++;
		}
		mutex_exit(&ibdma->ms_hca_list_lock);
		break;

	case IBT_HCA_DETACH_EVENT:
		mutex_enter(&ibdma->ms_hca_list_lock);
		hca = ibdma_find_hca(event->ev_hca_guid);
		if (hca != NULL) {
			list_remove(&ibdma->ms_hca_list, hca);
			cmn_err(CE_NOTE, "removing hca (%p) (0x%llx)",
			    (void *)hca, hca ?
			    (u_longlong_t)hca->ih_iou_guid : 0x0ll);
			ibdma_hca_fini(hca);
		}
		mutex_exit(&ibdma->ms_hca_list_lock);
		break;

	default:
#ifdef	DEBUG
		cmn_err(CE_NOTE, "ibt_async_handler, unhandled event(%d)",
		    code);
#endif
		break;
	}

}

/*
 * ibdma_ibt_init()
 */
static int
ibdma_ibt_init()
{
	int		status;
	int		hca_cnt;
	int		hca_ndx;
	ib_guid_t	*guid;
	ibdma_hca_t	*hca;

	/*
	 * Attach to IBTF and get HCA list.
	 */
	status = ibt_attach(&ibdma_ibt_modinfo, NULL,
	    ibdma, &ibdma->ms_ibt_hdl);
	if (status != DDI_SUCCESS) {
		cmn_err(CE_NOTE, "ibt_init, ibt_attach failed (%d)",
		    status);
		return (status);
	}

	list_create(&ibdma->ms_hca_list, sizeof (ibdma_hca_t),
	    offsetof(ibdma_hca_t, ih_node));

	hca_cnt = ibt_get_hca_list(&guid);
	if (hca_cnt < 1) {
#ifdef	DEBUG_IBDMA
		cmn_err(CE_NOTE, "ibt_init, no HCA(s) found");
#endif
		/* not an error if no HCAs, but nothing more to do here */
		return (DDI_SUCCESS);
	}

	mutex_enter(&ibdma->ms_hca_list_lock);

	for (hca_ndx = 0; hca_ndx < hca_cnt; hca_ndx++) {
#ifdef	DEBUG_IBDMA
		cmn_err(CE_NOTE, "adding hca GUID(0x%llx)",
		    (u_longlong_t)guid[hca_ndx]);
#endif

		hca = ibdma_hca_init(guid[hca_ndx]);
		if (hca == NULL) {
			cmn_err(CE_NOTE, "ibt_init, hca_init GUID(0x%llx)"
			    " failed", (u_longlong_t)guid[hca_ndx]);
			continue;
		}
		list_insert_tail(&ibdma->ms_hca_list, hca);
		ibdma->ms_num_hcas++;
	}

	mutex_exit(&ibdma->ms_hca_list_lock);

	ibt_free_hca_list(guid, hca_cnt);
#ifdef	DEBUG_IBDMA
	cmn_err(CE_NOTE, "Added %d HCA(s)",
	    ibdma->ms_num_hcas);
#endif
	return (DDI_SUCCESS);
}

/*
 * ibdma_ibt_fini()
 */
static void
ibdma_ibt_fini()
{
	ibdma_hca_t		*hca;
	ibdma_hca_t		*next;

	mutex_enter(&ibdma->ms_hca_list_lock);
	hca = list_head(&ibdma->ms_hca_list);
	while (hca != NULL) {
		next = list_next(&ibdma->ms_hca_list, hca);
		list_remove(&ibdma->ms_hca_list, hca);
#ifdef	DEBUG_IBDMA
		cmn_err(CE_NOTE, "removing hca (%p) (0x%llx)",
		    (void *)hca, hca ?
		    (u_longlong_t)hca->ih_iou_guid : 0x0ll);
		cmn_err(CE_NOTE, "hca ibt hdl (%p)",
		    (void *)hca->ih_ibt_hdl);
#endif
		ibdma_hca_fini(hca);
		hca = next;
	}
	list_destroy(&ibdma->ms_hca_list);

	(void) ibt_detach(ibdma->ms_ibt_hdl);
	ibdma->ms_ibt_hdl   = NULL;
	ibdma->ms_num_hcas  = 0;
	mutex_exit(&ibdma->ms_hca_list_lock);
}

/*
 * ibdma_find_hca()
 */
static ibdma_hca_t *
ibdma_find_hca(ib_guid_t guid)
{
	ibdma_hca_t	*hca;

	ASSERT(mutex_owned(&ibdma->ms_hca_list_lock));

	hca = list_head(&ibdma->ms_hca_list);
	while (hca != NULL) {
		if (hca->ih_iou_guid == guid) {
			break;
		}
		hca = list_next(&ibdma->ms_hca_list, hca);
	}
	return (hca);
}

/*
 * ibdma_hca_init()
 */
static ibdma_hca_t *
ibdma_hca_init(ib_guid_t guid)
{
	ibt_status_t		status;
	ibdma_hca_t		*hca;
	ibdma_port_t		*port;
	ibt_hca_attr_t		hca_attr;
	int			ndx;

	ASSERT(mutex_owned(&ibdma->ms_hca_list_lock));

	status = ibt_query_hca_byguid(guid, &hca_attr);
	if (status != IBT_SUCCESS) {
		cmn_err(CE_NOTE, "hca_init HCA query error (%d)",
		    status);
		return (NULL);
	}

	if (ibdma_find_hca(guid) != NULL) {
#ifdef	DEBUG_IBDMA
		cmn_err(CE_NOTE, "hca_init HCA already exists");
#endif
		return (NULL);
	}

	hca = kmem_zalloc(sizeof (ibdma_hca_t) +
	    (hca_attr.hca_nports-1)*sizeof (ibdma_port_t), KM_SLEEP);
	ASSERT(hca != NULL);

	hca->ih_nports   = hca_attr.hca_nports;

	rw_init(&hca->ih_iou_rwlock, NULL, RW_DRIVER, NULL);
	rw_enter(&hca->ih_iou_rwlock, RW_WRITER);
	hca->ih_iou_guid		= guid;
	hca->ih_iou.iou_changeid	= h2b16(1);
	hca->ih_iou.iou_num_ctrl_slots	= IBDMA_MAX_IOC;
	hca->ih_iou.iou_flag		= IB_DM_IOU_OPTIONROM_ABSENT;

	list_create(&hca->ih_hdl_list, sizeof (ibdma_hdl_impl_t),
	    offsetof(ibdma_hdl_impl_t, ih_node));
	rw_exit(&hca->ih_iou_rwlock);

	/*
	 * It would be better to not open, but IBTL is setup to only allow
	 * certain managers to get async call backs if not open.
	 */
	status = ibt_open_hca(ibdma->ms_ibt_hdl, guid, &hca->ih_ibt_hdl);
	if (status != IBT_SUCCESS) {
		cmn_err(CE_NOTE, "hca_init() IBT open failed (%d)",
		    status);

		list_destroy(&hca->ih_hdl_list);
		rw_destroy(&hca->ih_iou_rwlock);
		kmem_free(hca, sizeof (ibdma_hca_t) +
		    (hca_attr.hca_nports-1)*sizeof (ibdma_port_t));
		return (NULL);
	}

	/*
	 * Register with the IB Management Framework and setup MAD call-back.
	 */
	for (ndx = 0; ndx < hca->ih_nports; ndx++) {
		port = &hca->ih_port[ndx];
		port->ip_hcap = hca;
		port->ip_ibmf_reg.ir_ci_guid	= hca->ih_iou_guid;
		port->ip_ibmf_reg.ir_port_num	= ndx + 1;
		port->ip_ibmf_reg.ir_client_class = DEV_MGT_AGENT;

		status = ibmf_register(&port->ip_ibmf_reg, IBMF_VERSION,
		    0, NULL, NULL, &port->ip_ibmf_hdl, &port->ip_ibmf_caps);
		if (status != IBMF_SUCCESS) {
			cmn_err(CE_NOTE, "hca_init, IBMF register failed (%d)",
			    status);
			port->ip_ibmf_hdl = NULL;
			ibdma_hca_fini(hca);
			return (NULL);
		}

		status = ibmf_setup_async_cb(port->ip_ibmf_hdl,
		    IBMF_QP_HANDLE_DEFAULT, ibdma_mad_recv_cb, port, 0);
		if (status != IBMF_SUCCESS) {
			cmn_err(CE_NOTE, "hca_init, IBMF cb setup failed (%d)",
			    status);
			ibdma_hca_fini(hca);
			return (NULL);
		}

		status = ibt_modify_port_byguid(hca->ih_iou_guid,
		    ndx+1, IBT_PORT_SET_DEVMGT, 0);
		if (status != IBT_SUCCESS) {
			cmn_err(CE_NOTE, "hca_init, IBT modify port caps"
			    " error (%d)", status);
			ibdma_hca_fini(hca);
			return (NULL);
		}
	}
	return (hca);
}

/*
 * ibdma_hca_fini()
 */
static void
ibdma_hca_fini(ibdma_hca_t *hca)
{
	int			status;
	int			ndx;
	ibdma_port_t		*port;
	ibdma_hdl_impl_t	*hdl;
	ibdma_hdl_impl_t	*hdl_next;

	ASSERT(mutex_owned(&ibdma->ms_hca_list_lock));
	ASSERT(hca != NULL);

	rw_enter(&hca->ih_iou_rwlock, RW_WRITER);

	/*
	 * All handles should have been de-registered, but release
	 * any that are outstanding.
	 */
	hdl = list_head(&hca->ih_hdl_list);
	while (hdl != NULL) {
		hdl_next = list_next(&hca->ih_hdl_list, hdl);
		list_remove(&hca->ih_hdl_list, hdl);
		cmn_err(CE_NOTE, "hca_fini, unexpected ibdma user handle"
		    " exists");
		kmem_free(hdl, sizeof (*hdl));
		hdl = hdl_next;
	}
	list_destroy(&hca->ih_hdl_list);

	/*
	 * Un-register with the IBMF.
	 */
	for (ndx = 0; ndx < hca->ih_nports; ndx++) {
		port = &hca->ih_port[ndx];
		port->ip_hcap = NULL;

		status = ibt_modify_port_byguid(hca->ih_iou_guid,
		    ndx+1, IBT_PORT_RESET_DEVMGT, 0);
		if (status != IBT_SUCCESS)
			cmn_err(CE_NOTE, "hca_fini, IBT modify port caps"
			    " error (%d)", status);

		if (port->ip_ibmf_hdl == NULL)
			continue;

		status = ibmf_tear_down_async_cb(port->ip_ibmf_hdl,
		    IBMF_QP_HANDLE_DEFAULT, 0);
		if (status != IBMF_SUCCESS)
			cmn_err(CE_NOTE, "hca_fini, IBMF tear down cb"
			    " error (%d)", status);

		status = ibmf_unregister(&port->ip_ibmf_hdl, 0);
		if (status != IBMF_SUCCESS)
			cmn_err(CE_NOTE, "hca_fini, IBMF un-register"
			    " error (%d)", status);
		port->ip_ibmf_hdl = NULL;
	}

	status = ibt_close_hca(hca->ih_ibt_hdl);
	if (status != IBT_SUCCESS)
		cmn_err(CE_NOTE, "hca_fini close error (%d)", status);

	rw_exit(&hca->ih_iou_rwlock);
	rw_destroy(&hca->ih_iou_rwlock);
	kmem_free(hca, sizeof (ibdma_hca_t) +
	    (hca->ih_nports-1) * sizeof (ibdma_port_t));
}

/* DM IBMF MAD handlers */
/*
 * ibdma_create_resp_mad()
 */
static void
ibdma_create_resp_mad(ibmf_msg_t *msgp)
{
	/*
	 * Allocate send buffer fix up hdr for response.
	 */
	msgp->im_msgbufs_send.im_bufs_mad_hdr =
	    kmem_zalloc(IBDMA_MAD_SIZE, KM_SLEEP);

	msgp->im_msgbufs_send.im_bufs_cl_hdr = (uchar_t *)
	    msgp->im_msgbufs_send.im_bufs_mad_hdr + sizeof (ib_mad_hdr_t);
	msgp->im_msgbufs_send.im_bufs_cl_hdr_len = IBDMA_DM_MAD_HDR_SIZE;
	msgp->im_msgbufs_send.im_bufs_cl_data =
	    ((char *)msgp->im_msgbufs_send.im_bufs_cl_hdr +
	    IBDMA_DM_MAD_HDR_SIZE);
	msgp->im_msgbufs_send.im_bufs_cl_data_len =
	    IBDMA_MAD_SIZE - sizeof (ib_mad_hdr_t) - IBDMA_DM_MAD_HDR_SIZE;
	(void) memcpy(msgp->im_msgbufs_send.im_bufs_mad_hdr,
	    msgp->im_msgbufs_recv.im_bufs_mad_hdr, IBDMA_MAD_SIZE);

	/*
	 * We may want to support a GRH since this is a GMP; not
	 * required for current SRP device manager platforms.
	 */
#if 0
	if (msgp->im_msg_flags & IBMF_MSG_FLAGS_GLOBAL_ADDRESS) {
		ib_gid_t	temp = msgp->im_global_addr.ig_recver_gid;

		msgp->im_global_addr.ig_recver_gid =
		    msgp->im_global_addr.ig_sender_gid;
		msgp->im_global_addr.ig_sender_gid = temp;
	}
#endif
}

/*
 * ibdma_mad_send_cb()
 */
/* ARGSUSED */
static void
ibdma_mad_send_cb(ibmf_handle_t ibmf_hdl, ibmf_msg_t *msgp, void *arg)
{
	/*
	 * Just free the buffers and release the message.
	 */
	if (msgp->im_msgbufs_send.im_bufs_mad_hdr != NULL) {
		kmem_free(msgp->im_msgbufs_send.im_bufs_mad_hdr,
		    IBDMA_MAD_SIZE);
		msgp->im_msgbufs_send.im_bufs_mad_hdr = NULL;
	}
	if (ibmf_free_msg(ibmf_hdl, &msgp) != IBMF_SUCCESS) {
		cmn_err(CE_NOTE, "mad_send_cb, IBMF message free error");
	}
}

/*
 * ibdma_mad_recv_cb()
 */
static void
ibdma_mad_recv_cb(ibmf_handle_t ibmf_hdl, ibmf_msg_t *msgp, void *args)
{
	int		status;
	ib_mad_hdr_t	*in_mad;
	ib_mad_hdr_t	*out_mad;
	ibdma_port_t	*port = args;

	ASSERT(msgp != NULL);
	ASSERT(port != NULL);

	if (msgp->im_msg_status != IBMF_SUCCESS) {
		cmn_err(CE_NOTE, "mad_recv_cb, bad MAD receive status (%d)",
		    msgp->im_msg_status);
		goto drop;
	}

	in_mad = msgp->im_msgbufs_recv.im_bufs_mad_hdr;

	if (in_mad->MgmtClass != MAD_MGMT_CLASS_DEV_MGT) {
#ifdef	DEBUG_IBDMA
		cmn_err(CE_NOTE, "mad_recv_cb, MAD not of Dev Mgmt Class");
#endif
		goto drop;
	}

	ibdma_create_resp_mad(msgp);
	out_mad = msgp->im_msgbufs_send.im_bufs_mad_hdr;

	out_mad->R_Method = IB_DM_DEVMGT_METHOD_GET_RESP;
	out_mad->Status   = 0;

	if (in_mad->R_Method == MAD_METHOD_SET) {
#ifdef	DEBUG_IBDMA
		cmn_err(CE_NOTE, "mad_recv_cb, no attributes supported"
		    " for set");
#endif
		out_mad->Status = MAD_STATUS_UNSUPP_METHOD_ATTR;
		goto send_resp;
	}

	if (in_mad->R_Method != MAD_METHOD_GET) {
#ifdef	DEBUG_IBDMA
		cmn_err(CE_NOTE, "mad_recv_cb, no attributes supported"
		    " for set");
#endif
		out_mad->Status = MAD_STATUS_UNSUPP_METHOD;
		goto send_resp;
	}

	/*
	 * Process a GET method.
	 */
	switch (b2h16(in_mad->AttributeID)) {

	case IB_DM_ATTR_CLASSPORTINFO:
		ibdma_get_class_portinfo(msgp);
		break;

	case IB_DM_ATTR_IO_UNITINFO:
		ibdma_get_io_unitinfo(port->ip_hcap, msgp);
		break;

	case IB_DM_ATTR_IOC_CTRL_PROFILE:
		ibdma_get_ioc_profile(port->ip_hcap, msgp);
		break;

	case IB_DM_ATTR_SERVICE_ENTRIES:
		ibdma_get_ioc_services(port->ip_hcap, msgp);
		break;

	default:
		out_mad->Status = MAD_STATUS_UNSUPP_METHOD_ATTR;
		break;
	}

send_resp:
	status = ibmf_msg_transport(ibmf_hdl, IBMF_QP_HANDLE_DEFAULT,
	    msgp, NULL, ibdma_mad_send_cb, NULL, 0);
	if (status != IBMF_SUCCESS) {
		cmn_err(CE_NOTE, "mad_recv_cb, send error (%d)", status);
		ibdma_mad_send_cb(ibmf_hdl, msgp, NULL);
	}
	return;

drop:
	status = ibmf_free_msg(ibmf_hdl, &msgp);
	if (status != IBMF_SUCCESS) {
		cmn_err(CE_NOTE, "mad_recv_cb, error dropping (%d)",
		    status);
	}
}

/*
 * ibdma_get_class_portinfo()
 */
static void
ibdma_get_class_portinfo(ibmf_msg_t *msg)
{
	ib_mad_classportinfo_t	*cpip;

	cpip = (ib_mad_classportinfo_t *)msg->im_msgbufs_send.im_bufs_cl_data;
	bzero(cpip, sizeof (*cpip));
	cpip->BaseVersion   = MAD_CLASS_BASE_VERS_1;
	cpip->ClassVersion  = IB_DM_CLASS_VERSION_1;
	cpip->RespTimeValue = h2b32(IBDMA_DM_RESP_TIME);
}

/*
 * ibdma_get_io_unitinfo()
 */
static void
ibdma_get_io_unitinfo(ibdma_hca_t *hca, ibmf_msg_t *msg)
{
	ib_dm_io_unitinfo_t	*uip;

	uip = (ib_dm_io_unitinfo_t *)msg->im_msgbufs_send.im_bufs_cl_data;
	rw_enter(&hca->ih_iou_rwlock, RW_READER);
	bcopy(&hca->ih_iou, uip, sizeof (ib_dm_io_unitinfo_t));
	rw_exit(&hca->ih_iou_rwlock);
}

/*
 * ibdma_get_ioc_profile()
 */
static void
ibdma_get_ioc_profile(ibdma_hca_t *hca, ibmf_msg_t *msg)
{
	ib_dm_ioc_ctrl_profile_t	*iocp;
	uint32_t			slot;

	ASSERT(msg != NULL);

	slot = b2h32(msg->im_msgbufs_recv.im_bufs_mad_hdr->AttributeModifier);
	iocp = (ib_dm_ioc_ctrl_profile_t *)
	    msg->im_msgbufs_send.im_bufs_cl_data;
	if (slot == 0 || slot > IBDMA_MAX_IOC) {
		msg->im_msgbufs_send.im_bufs_mad_hdr->Status =
		    MAD_STATUS_INVALID_FIELD;
		return;
	}

	slot--;
	rw_enter(&hca->ih_iou_rwlock, RW_READER);
	if (ibdma_get_ioc_state(hca, slot) == IBDMA_IOC_PRESENT) {
		bcopy(&hca->ih_ioc[slot].ii_profile, iocp,
		    sizeof (ib_dm_ioc_ctrl_profile_t));
	} else {
		msg->im_msgbufs_send.im_bufs_mad_hdr->Status =
		    IB_DM_DEVMGT_MAD_STAT_NORESP;
	}
	rw_exit(&hca->ih_iou_rwlock);
}

/*
 * ibdma_get_ioc_services()
 */
static void
ibdma_get_ioc_services(ibdma_hca_t *hca, ibmf_msg_t *msg)
{
	ib_dm_srv_t	*to_svcp;
	ib_dm_srv_t	*from_svcp;
	uint32_t	slot;
	uint8_t		hi;
	uint8_t		low;

	ASSERT(msg != NULL);

	slot = b2h32(msg->im_msgbufs_recv.im_bufs_mad_hdr->AttributeModifier);
	hi   = (slot >> 8) & 0x00FF;
	low  = slot  & 0x00FF;
	slot = (slot >> 16) & 0x0FFFF;
	if (slot == 0 || slot > IBDMA_MAX_IOC) {
		msg->im_msgbufs_send.im_bufs_mad_hdr->Status =
		    MAD_STATUS_INVALID_FIELD;
		return;
	}

	slot--;

	rw_enter(&hca->ih_iou_rwlock, RW_READER);
	if (ibdma_get_ioc_state(hca, slot) != IBDMA_IOC_PRESENT) {
		msg->im_msgbufs_send.im_bufs_mad_hdr->Status =
		    IB_DM_DEVMGT_MAD_STAT_NORESP;
		rw_exit(&hca->ih_iou_rwlock);
		return;
	}

	if ((low > hi) || (hi - low > 4)) {
		msg->im_msgbufs_send.im_bufs_mad_hdr->Status =
		    MAD_STATUS_INVALID_FIELD;
		rw_exit(&hca->ih_iou_rwlock);
		return;
	}

	if (hi > hca->ih_ioc[slot].ii_profile.ioc_service_entries) {
		msg->im_msgbufs_send.im_bufs_mad_hdr->Status =
		    MAD_STATUS_INVALID_FIELD;
		rw_exit(&hca->ih_iou_rwlock);
		return;
	}

	to_svcp = (ib_dm_srv_t *)msg->im_msgbufs_send.im_bufs_cl_data;
	from_svcp = hca->ih_ioc[slot].ii_srvcs + low;
	bcopy(from_svcp, to_svcp, sizeof (ib_dm_srv_t) * (hi - low + 1));
	rw_exit(&hca->ih_iou_rwlock);
}


/*
 * Client API internal helpers
 */

/*
 * ibdma_hdl_to_ioc()
 */
ibdma_hdl_impl_t *
ibdma_get_hdl_impl(ibdma_hdl_t hdl)
{
	ibdma_hca_t		*hca;
	ibdma_hdl_impl_t	*hdl_tmp = hdl;
	ibdma_hdl_impl_t	*hdl_impl;

	ASSERT(mutex_owned(&ibdma->ms_hca_list_lock));

	if (hdl_tmp == NULL) {
		cmn_err(CE_NOTE, "get_hdl_impl, NULL handle");
		return (NULL);
	}

	hca = ibdma_find_hca(hdl_tmp->ih_iou_guid);
	if (hca == NULL) {
		cmn_err(CE_NOTE, "get_hdl_impl, invalid handle, bad IOU");
		return (NULL);
	}

	hdl_impl = list_head(&hca->ih_hdl_list);
	while (hdl_impl != NULL) {
		if (hdl_impl == hdl_tmp) {
			break;
		}
		hdl_impl = list_next(&hca->ih_hdl_list, hdl_impl);
	}
	return (hdl_impl);
}

/*
 * ibdma_set_ioc_state()
 *
 * slot should be 0 based (not DM 1 based slot).
 *
 * I/O Unit write lock should be held outside of this function.
 */
static void
ibdma_set_ioc_state(ibdma_hca_t *hca, int slot, ibdma_ioc_state_t state)
{
	uint8_t		cur;
	uint16_t	id;

	cur = hca->ih_iou.iou_ctrl_list[slot >> 1];
	if (slot & 1) {
		cur = (cur & 0xF0) | state;
	} else {
		cur = (cur & 0x0F) | (state << 4);
	}
	hca->ih_iou.iou_ctrl_list[slot >> 1] = cur;
	id = b2h16(hca->ih_iou.iou_changeid);
	id++;
	hca->ih_iou.iou_changeid = h2b16(id);
#ifdef	DEBUG_IBDMA
	cmn_err(CE_NOTE, "set_ioc_state, slot offset(%d), value(%d)",
	    slot, hca->ih_iou.iou_ctrl_list[slot >> 1]);
#endif
}

/*
 * ibdma_get_ioc_state()
 *
 * slot should be 0 based (not DM 1 based slot).
 *
 * I/O Unit read lock should be held outside of this function.
 */
static ibdma_ioc_state_t
ibdma_get_ioc_state(ibdma_hca_t *hca, int slot)
{
	uint8_t		cur;

	if (slot >= IBDMA_MAX_IOC)
		return (0xFF);

	cur = hca->ih_iou.iou_ctrl_list[slot >> 1];
	cur = slot & 1 ?  cur & 0x0F : cur >> 4;
	return (cur);
}

/* CLIENT API Implementation */
/*
 * ibdma_ioc_register()
 *
 */
ibdma_hdl_t
ibdma_ioc_register(ib_guid_t iou_guid, ib_dm_ioc_ctrl_profile_t *profile,
	ib_dm_srv_t *services)
{
	int			free_slot = -1;
	int			svc_entries;
	int			slot;
	ibdma_hca_t		*hca;
	ibdma_hdl_impl_t	*hdl;

	if (profile == NULL || services == NULL) {
		cmn_err(CE_NOTE, "ioc_register, bad parameter");
		return (NULL);
	}

	svc_entries = profile->ioc_service_entries;
	if (svc_entries == 0) {
		cmn_err(CE_NOTE, "ioc_register, bad profile no service");
		return (NULL);
	}

	/*
	 * Find the associated I/O Unit.
	 */
	mutex_enter(&ibdma->ms_hca_list_lock);
	hca = ibdma_find_hca(iou_guid);
	if (hca == NULL) {
		mutex_exit(&ibdma->ms_hca_list_lock);
		cmn_err(CE_NOTE, "ioc_register, bad I/O Unit GUID (0x%llx)",
		    (u_longlong_t)iou_guid);
		return (NULL);
	}

	rw_enter(&hca->ih_iou_rwlock, RW_WRITER);
	for (slot = 0; slot < IBDMA_MAX_IOC; slot++) {
		if (hca->ih_ioc[slot].ii_inuse == 0) {
			if (free_slot == -1) {
				free_slot = slot;
			}
			continue;
		}

		if (profile->ioc_guid ==
		    hca->ih_ioc[slot].ii_profile.ioc_guid) {
			rw_exit(&hca->ih_iou_rwlock);
			mutex_exit(&ibdma->ms_hca_list_lock);
#ifdef	DEBUG_IBDMA
			cmn_err(CE_NOTE, "ioc_register, IOC previously"
			    " registered");
#endif
			return (NULL);
		}
	}

	if (free_slot < 0) {
		rw_exit(&hca->ih_iou_rwlock);
		cmn_err(CE_NOTE, "ioc_register, error - I/O Unit full");
		return (NULL);
	}
#ifdef	DEBUG_IBDMA
	cmn_err(CE_NOTE, "ibdma_ioc_register, assigned to 0 based slot (%d)",
	    free_slot);
#endif

	hca->ih_ioc[free_slot].ii_inuse = 1;
	hca->ih_ioc[free_slot].ii_slot  = free_slot;
	hca->ih_ioc[free_slot].ii_hcap  = hca;

	/*
	 * Allocate local copy of profile and services.
	 */
	hca->ih_ioc[free_slot].ii_srvcs =
	    kmem_zalloc(sizeof (ib_dm_srv_t) * svc_entries, KM_SLEEP);
	bcopy(profile, &hca->ih_ioc[free_slot].ii_profile,
	    sizeof (ib_dm_ioc_ctrl_profile_t));
	bcopy(services, hca->ih_ioc[free_slot].ii_srvcs,
	    sizeof (ib_dm_srv_t) * svc_entries);

	/*
	 * Update the profile copy with the I/O controller slot assigned.
	 * The slot occupies the lower 8 biths of the vendor ID/slot 32bit
	 * field.
	 */
	profile->ioc_vendorid |= h2b32(free_slot);

	ibdma_set_ioc_state(hca, free_slot, IBDMA_IOC_PRESENT);

	hdl = kmem_alloc(sizeof (*hdl), KM_SLEEP);
	hdl->ih_iou_guid = hca->ih_iou_guid;
	hdl->ih_ioc_ndx = (uint8_t)free_slot;
	list_insert_tail(&hca->ih_hdl_list, hdl);

	rw_exit(&hca->ih_iou_rwlock);
	mutex_exit(&ibdma->ms_hca_list_lock);

	return ((ibdma_hdl_t)hdl);
}

/*
 * ibdma_ioc_unregister()
 *
 */
ibdma_status_t
ibdma_ioc_unregister(ibdma_hdl_t hdl)
{
	ibdma_ioc_t		*ioc;
	ibdma_hca_t		*hca;
	int			slot;
	ibdma_hdl_impl_t	*hdl_tmp = hdl;
	ibdma_hdl_impl_t	*hdl_impl;

	if (hdl == NULL) {
		cmn_err(CE_NOTE, "ioc_unregister, NULL handle");
		return (IBDMA_BAD_PARAM);
	}

	mutex_enter(&ibdma->ms_hca_list_lock);
	hca = ibdma_find_hca(hdl_tmp->ih_iou_guid);
	if (hca == NULL) {
		cmn_err(CE_NOTE, "ioc_unregsiter, invalid handle, IOU"
		    " not found");
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}

	hdl_impl = list_head(&hca->ih_hdl_list);
	while (hdl_impl != NULL) {
		if (hdl_impl == hdl_tmp) {
			break;
		}
		hdl_impl = list_next(&hca->ih_hdl_list, hdl_impl);
	}

	if (hdl_impl == NULL) {
		cmn_err(CE_NOTE, "ioc_unregsiter, invalid handle, not found");
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}

	list_remove(&hca->ih_hdl_list, hdl_impl);

	if (hdl_impl->ih_ioc_ndx >= IBDMA_MAX_IOC) {
		cmn_err(CE_NOTE, "ioc_unregister, corrupted handle");
		kmem_free(hdl_impl, sizeof (*hdl_impl));
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}
	ioc = &hca->ih_ioc[hdl_impl->ih_ioc_ndx];
	kmem_free(hdl_impl, sizeof (*hdl_impl));

	if (ioc->ii_slot > IBDMA_MAX_IOC) {
		cmn_err(CE_NOTE, "ioc_unregister, IOC corrupted, bad"
		    " slot in IOC");
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}

	rw_enter(&ioc->ii_hcap->ih_iou_rwlock, RW_WRITER);
	if (ioc->ii_inuse == 0) {
		rw_exit(&ioc->ii_hcap->ih_iou_rwlock);
		mutex_exit(&ibdma->ms_hca_list_lock);
		cmn_err(CE_NOTE, "ioc_unregister, slot not in use (%d)",
		    ioc->ii_slot+1);
		return (IBDMA_BAD_PARAM);
	}

	ASSERT(ioc->ii_srvcs != NULL);

	slot = ioc->ii_slot;
	hca  = ioc->ii_hcap;
	kmem_free(ioc->ii_srvcs, sizeof (ib_dm_srv_t) *
	    ioc->ii_profile.ioc_service_entries);
	bzero(ioc, sizeof (ibdma_ioc_t));
	ibdma_set_ioc_state(hca, slot, IBDMA_IOC_NOT_INSTALLED);

	rw_exit(&hca->ih_iou_rwlock);
	mutex_exit(&ibdma->ms_hca_list_lock);

	return (IBDMA_SUCCESS);
}

/*
 * ibdma_ioc_update()
 *
 */
ibdma_status_t
ibdma_ioc_update(ibdma_hdl_t hdl, ib_dm_ioc_ctrl_profile_t *profile,
	ib_dm_srv_t *services)
{
	ibdma_ioc_t		*ioc;
	ibdma_hca_t		*hca;
	ibdma_hdl_impl_t	*hdl_tmp = hdl;
	ibdma_hdl_impl_t	*hdl_impl;

	if (hdl == NULL) {
		cmn_err(CE_NOTE, "ioc_update, NULL handle");
		return (IBDMA_BAD_PARAM);
	}

	if (profile == NULL || services == NULL) {
		cmn_err(CE_NOTE, "ioc_update, NULL parameter");
		return (IBDMA_BAD_PARAM);
	}

	mutex_enter(&ibdma->ms_hca_list_lock);
	hca = ibdma_find_hca(hdl_tmp->ih_iou_guid);
	if (hca == NULL) {
		cmn_err(CE_NOTE, "ioc_update, invalid handle, IOU not found");
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}

	hdl_impl = list_head(&hca->ih_hdl_list);
	while (hdl_impl != NULL) {
		if (hdl_impl == hdl_tmp) {
			break;
		}
		hdl_impl = list_next(&hca->ih_hdl_list, hdl_impl);
	}

	if (hdl_impl == NULL) {
		cmn_err(CE_NOTE, "ioc_update, invalid handle, not found");
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}

	if (hdl_impl->ih_ioc_ndx >= IBDMA_MAX_IOC) {
		cmn_err(CE_NOTE, "ioc_update, corrupted handle");
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}
	ioc = &hca->ih_ioc[hdl_impl->ih_ioc_ndx];

	if (ioc->ii_slot >= IBDMA_MAX_IOC || ioc->ii_hcap == NULL) {
		cmn_err(CE_NOTE, "ioc_update, bad handle (%p)",
		    (void *)hdl);
		mutex_exit(&ibdma->ms_hca_list_lock);
		return (IBDMA_BAD_PARAM);
	}

	rw_enter(&ioc->ii_hcap->ih_iou_rwlock, RW_WRITER);
	if (ioc->ii_inuse == 0) {
		rw_exit(&ioc->ii_hcap->ih_iou_rwlock);
		mutex_exit(&ibdma->ms_hca_list_lock);
		cmn_err(CE_NOTE, "ioc_udate slot not in use (%d)",
		    ioc->ii_slot+1);
		return (IBDMA_BAD_PARAM);
	}

	ASSERT(ioc->ii_srvcs != NULL);

	kmem_free(ioc->ii_srvcs, ioc->ii_profile.ioc_service_entries *
	    sizeof (ib_dm_srv_t));
	ioc->ii_srvcs = kmem_zalloc(profile->ioc_service_entries  *
	    sizeof (ib_dm_srv_t), KM_SLEEP);

	bcopy(profile, &ioc->ii_profile, sizeof (ib_dm_ioc_ctrl_profile_t));
	bcopy(services, ioc->ii_srvcs, sizeof (ib_dm_srv_t) *
	    profile->ioc_service_entries);
	/*
	 * Update the profile copy with the I/O controller slot assigned.
	 * The slot occupies the lower 8 biths of the vendor ID/slot 32bit
	 * field.
	 */
	profile->ioc_vendorid |= h2b32(ioc->ii_slot);
	ibdma_set_ioc_state(ioc->ii_hcap, ioc->ii_slot, IBDMA_IOC_PRESENT);
	rw_exit(&ioc->ii_hcap->ih_iou_rwlock);
	mutex_exit(&ibdma->ms_hca_list_lock);

	return (IBDMA_SUCCESS);
}