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

#ifndef _SYS_IB_MGT_IBCM_IBCM_IMPL_H
#define	_SYS_IB_MGT_IBCM_IBCM_IMPL_H

/*
 * ibcm_impl.h
 *
 * This file contains all of the internal data structures and
 * definitions for IBCM.
 *
 * The general state transition processing of CM is achieved by the
 * following callgraph:
 *
 * CM INIT : Register for hca attach and detach callbacks, and other asyncs
 *
 * On new HCA attach:	Register with IBMF on all ports of upcoming HCA
 *			Specify CM callback and callback "per HCA arg"
 *			Register with SA, allocate AVL trees etc.
 *
 * IBMF Callback
 *  	Validate combination of method and attribute Id in the generic MAD hdr
 *	-> Call CM Connection state transition function based on attribute ID
 *	    Create/lookup/delete CM state structure and save it into avl tree
 *	    Handle duplicate messages and MRA to adjust timers etc.
 *	    Handle stale connections
 *	    Allocate reply MADs
 *		-> Call CM QP/EEC state transition function based on CM message
 *		     Change QP/EEC state  (to enable recvQ posting by client)
 *		     Call Client/Server handler callback function
 *		     Modify QP/EEC attributes
 *		     Optionally fill up some fields of response MAD
 *	    Post reply MADs
 *	    Store reply MADs and reply MAD address, if necessary
 *	    Initialize timeouts for the message
 *	    Change CM state
 *	    Deallocate reply MADs
 *
 * NOTES:
 * 	o There are *NO* explicit CM allocation and deallocation routines for
 *	CM MADs and state data structures
 *	o CM timeouts are scheduled using timeout(9f), and cancelled using
 *	untimeout(9f)
 *	o svc_id allocation scheme
 *	A new counter for svcid is maintained in ibcm_hca_info_t
 *	which is used to allocate svcid. The svcids are incremented
 *	sequentially and allocated (with wrap around on overflow) with
 *	these considerations:
 *		The WellKnown service id's and locally allocated svcid's
 *		could be maintained in separate lists, thus allowing the
 *		lists to be kept apart and sorted easily.
 *		The insertions are done at the end of the list
 *	o reqid allocation scheme
 *	The list is a sorted one (as reqid's are allocated sequentially).
 *	If there is a code required for wrap around, it would search for
 *	a reqid from the head of the list.
 *	The insertions are always done at the end of the lists
 *	o XXX svc_id allocation scheme and req_id allocation scheme will
 *	be revisited.
 */

#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/avl.h>
#include <sys/taskq.h>
#include <sys/vmem.h>
#include <sys/note.h>
#include <sys/t_lock.h>

#include <sys/ib/ibtl/ibvti.h>
#include <sys/ib/ibtl/impl/ibtl_cm.h>
#include <sys/ib/ibtl/impl/ibtl_util.h>
#include <sys/ib/mgt/ibmf/ibmf.h>
#include <sys/ib/mgt/ibcm/ibcm_trace.h>
#include <inet/ip.h>

#ifdef __cplusplus
extern "C" {
#endif

_NOTE(SCHEME_PROTECTS_DATA("Private", sa_service_record_s))
_NOTE(SCHEME_PROTECTS_DATA("Exclusive access to ibmf msg buf based on state",
ib_mad_hdr_t))
_NOTE(SCHEME_PROTECTS_DATA("Exclusive access to ibmf msg buf based on state",
_ibmf_msg))

/*
 * Defines for all CM state machine states, as defined in
 * section 12.9.7. IBCM_REJ_SENT is a state not defined in
 * the spec and is added for implementation purposes.
 */
typedef enum ibcm_conn_state_e {
	/* Initial states */
	IBCM_STATE_IDLE			= 0,
	IBCM_STATE_LISTEN,

	/* States during connection establishment */
	IBCM_STATE_REQ_SENT,
	IBCM_STATE_REQ_RCVD,
	IBCM_STATE_REP_SENT,
	IBCM_STATE_REP_RCVD,
	IBCM_STATE_REP_WAIT,
	IBCM_STATE_MRA_SENT,
	IBCM_STATE_MRA_REP_SENT,
	IBCM_STATE_MRA_REP_RCVD,

	/* States during connection establishment failures */
	IBCM_STATE_TIMED_OUT,
	IBCM_STATE_ABORTED,
	IBCM_STATE_REJ_SENT,

	/* Established state */
	IBCM_STATE_TRANSIENT_ESTABLISHED,
	IBCM_STATE_ESTABLISHED,

	/* States during connection teardown */
	IBCM_STATE_TRANSIENT_DREQ_SENT,
	IBCM_STATE_DREQ_SENT,
	IBCM_STATE_DREQ_RCVD,
	IBCM_STATE_DREP_RCVD,
	IBCM_STATE_TIMEWAIT,

	/* states for UD side of things */
	IBCM_STATE_SIDR_REQ_SENT,
	IBCM_STATE_SIDR_REQ_RCVD,
	IBCM_STATE_SIDR_REP_SENT,
	IBCM_STATE_SIDR_REP_RCVD,

	/* states common to RC and UD, during state resource deletion */
	IBCM_STATE_DELETE
} ibcm_conn_state_t;

/* Defines the AP states for LAP/APR */
typedef enum ibcm_ap_state_e {
	IBCM_AP_STATE_IDLE	= 0x0,
	IBCM_AP_STATE_LAP_SENT,
	IBCM_AP_STATE_LAP_RCVD,
	IBCM_AP_STATE_APR_RCVD,
	IBCM_AP_STATE_MRA_LAP_RCVD,
	IBCM_AP_STATE_MRA_LAP_SENT,
	IBCM_AP_STATE_TIMED_OUT
} ibcm_ap_state_t;

/*
 * Defines for the CM event types/MAD attribute IDs
 */
typedef enum ibcm_event_type_e {
	IBCM_INCOMING_REQ	= 0x0,
	IBCM_INCOMING_MRA	= 0x1,
	IBCM_INCOMING_REJ	= 0x2,
	IBCM_INCOMING_REP	= 0x3,
	IBCM_INCOMING_RTU	= 0x4,
	IBCM_INCOMING_DREQ	= 0x5,
	IBCM_INCOMING_DREP	= 0x6,
	IBCM_INCOMING_SIDR_REQ	= 0x7,
	IBCM_INCOMING_SIDR_REP	= 0x8,
	IBCM_INCOMING_LAP	= 0x9,
	IBCM_INCOMING_APR	= 0xA,
	IBCM_OUTGOING_REQ	= 0xB,	/* REQ Sent on active CM side */
	IBCM_INCOMING_REQ_STALE	= 0xC,	/* lookup by remote HCA and */
					/* remote comid */
	IBCM_INCOMING_REP_STALE	= 0xD,	/* lookup by passive HCA and QPN */
	IBCM_INCOMING_REJ_RCOMID = 0xE	/* lookup by remote com id */
} ibcm_event_type_t;

/*
 * IBMF calls back into CM on only the first 11 events defined in
 * ibcm_event_type_t. CM has pre-defined functions for these 11 events
 *
 */
#define	IBCM_MAX_EVENTS		11

/*
 * CM message attribute IDs begin at this "base ID". The first 11 event types
 * in ibcm_event_type_t are CM protocol messages that are posted to IBMF by
 * adding the "base_id" to the respective event type value. By subtracting
 * the "base_id" in IBMF callback in CM MAD, the message type is gotten back
 */
#define	IBCM_ATTR_BASE_ID		0x10

#define	IBCM_MAX_RETRY_CNT		15
#define	IBCM_ATTRID_FIELD_SIZE		4
#define	IBCM_TRANID_PRIV_FIELD_SIZE	28

#define	IBCM_RNR_RETRY_CNT_MASK		0x7	/* 3 bits */
#define	IBCM_MAX_RNR_RETRY_CNT		7

#define	IBCM_INITIAL_COMID		1
#define	IBCM_INITIAL_REQID		1
#define	IBCM_INITIAL_SID		1

/*
 * Maximum number of com ids / req ids that can be active at any given time
 * MUST ENSURE THAT (INITIAL ID + MAX IDS -1), for any of the IDs does not
 * exceed the max 32 bit
 */

/* An hca can have max of 2^24 -2  RC connections */
#define	IBCM_MAX_COMIDS		(0x01000000 - 2)
#define	IBCM_MAX_REQIDS		0xFFFFFFFF
#define	IBCM_MAX_LOCAL_SIDS	0xFFFFFFFF
#define	IBCM_MAX_IP_SIDS	0xFFFF

typedef uint32_t ib_com_id_t;	/* CM Communication ID */

/*
 * Defines the CM Mode of operation for a connection
 */
typedef enum ibcm_mode_e {
	IBCM_ACTIVE_MODE	= 1,	/* Active side CM */
	IBCM_PASSIVE_MODE	= 2	/* Passive side CM */
} ibcm_mode_t;


/* different IBCM return values */
typedef enum ibcm_status_e {
	IBCM_SUCCESS  		= 0,	/* good status */
	IBCM_LOOKUP_EXISTS,		/* statep lookup found existing entry */
	IBCM_LOOKUP_NEW,		/* lookup created new statep entry */
	IBCM_LOOKUP_FAIL,		/* lookup found no statep entry */
	IBCM_SEND_REJ,			/* CM QP state change sent REJ msg */
	IBCM_SEND_REP,			/* CM QP state change sent REP msg */
	IBCM_SEND_RTU,			/* CM QP state change sent RTU msg */
	IBCM_SEND_APR,			/* CM to send APR MAD as response */
	IBCM_SEND_SIDR_REP, 		/* client's UD handler returned this */
	IBCM_DEFER,			/* client's handler returned this */
	IBCM_FAILURE			/* generic IBCM failure */
} ibcm_status_t;

/*
 * Struct definition for addressing information that CM maintains for
 * each of the incoming MADs
 */
typedef	struct	ibcm_mad_addr {
	ibmf_global_addr_info_t	grh_hdr;	/* GRH related fields of MAD */
	ibmf_addr_info_t	rcvd_addr;	/* Outgoing/Incoming MAD addr */
	ibmf_handle_t		ibmf_hdl;	/* IBMF handle */
	boolean_t		grh_exists;	/* TRUE if grh exists */
	uint8_t			port_num;
	struct ibcm_qp_list_s	*cm_qp_entry;	/* IBMF hdl on which MAD rcvd */
						/* or on which MAD shall be */
						/* sent out */
} ibcm_mad_addr_t;

_NOTE(READ_ONLY_DATA(ibcm_mad_addr))

#define	IBCM_MAD_SIZE		0x100			/* size of MAD */
#define	IBCM_MAD_HDR_SIZE	sizeof (ib_mad_hdr_t)	/* size of MAD HDR */
#define	IBCM_MSG_SIZE		IBCM_MAD_SIZE-IBCM_MAD_HDR_SIZE

typedef enum ibcm_abort_flag_e {
	IBCM_ABORT_INIT		= 0,	/* no abort flag is set */
	IBCM_ABORT_CLIENT	= 1,	/* client requested connection abort */
	IBCM_ABORT_REJ		= 2	/* REJ received with timeout reason */
} ibcm_abort_flag_t;

typedef	enum ibcm_isync_e {
	IBCM_BLOCK	= 0,	/* Block cm operation */
	IBCM_UNBLOCK	= 1,	/* Unblock cm operation */
	IBCM_FAIL	= 2	/* fail cm operation */
} ibcm_isync_t;

/*
 * Define a connection state structure, used by the IBTF CM
 * to maintain state about connected QPs.
 *
 * mode			: CM connection mode active/passive
 * state		: CM connection state
 * ap_state		: CM AP Internal state to manage LAP/APR state machine
 * state_mutex		: lock for this structure
 * channel		: Channel associated with this RC state structure
 * ref_cnt		: Number of active threads that may reference this
 *			  state structure
 * svcid		: Service ID
 * cm_handler		: Client handler callback address
 * stored_reply_addr	: Address for replying using the stored mad
 * hcap			: A pointer to the HCA's entry
 * stored_msg		: Stores the response REP/REJ/RTU MAD
 * mra_msg		: Stores the response MRA MAD
 * dreq_msg		: Stores the DREQ MAD
 * drep_msg		: Stores the DREP MAD
 * lapr_msg		: Stores the LAP/APR MAD
 *			  detect duplicate LAP messages
 * local_comid  	: Local communication id
 * local_hca_guid	: Local HCA GUID
 * local_qpn		: Local QPN
 *
 * remote_comid 	: Remote communication id
 * remote_hca_guid	: Remote HCA GUID
 * remote_qpn		: Remote QPN
 *
 * timerid		: Timer id for the timeout either for re-sending the
 *			  stored mad or deleting the stored mad
 *			  Ex: A REJ/RTU response for an incoming REP
 *			      A REP response to an incoming REQ
 *			      An outgoing REQ on active connection side
 * timer_value		: Time for any of the above timers in HZ
 * pkt_life_time	: pkt life time from source to destination
 * remote_ack_delay	: Remote hca's ack delay in clock_t
 * rc_alt_pkt_lt	: Life time for new ALT path specified in LAP
 * stale_clock		: clock used to detect stale vs duplicate REQs
 * timer_stored_state	: state of connection for timeout() validation
 * timer_stored_ap_state: CM ap_state for timeout validation
 * remaining_retry_count: Remaining count for retries ie., posting stored MADs
 * max_cm_retries	: Max retry count for sending a REQ/REP/DREQ
 * delete_mra_msg	: Set to TRUE for deletion, if MRA re-send in progress
 * resend_mad		: B_TRUE, if REQ/REP/RTU/REJ MAD re-send is in progress
 * resend_mra_mad	: B_TRUE, if a MRA mad re-sens is in progress
 * cep_retry_cnt	: Retry count for CEP.
 * stale		: B_TRUE, if connection has become stale
 * blocking_done	: B_TRUE, if cv_signal been issued to block_client_cv
 * clnt_hdl		: Clnt_hdl passed in ibt_open_channel
 * return_data		: RC return args, valid for blocking
 *			  ibt_open_channel
 * drep_priv_data;	: The pointer to client specified outgoing private
 *			  data, from close channel API call
 * drep_priv_data_len   : The length of DREP private data that client would
 *			  like to be returned from close channel API call
 * delete_state_data	: B_TRUE, if CM decides to delete state data, but
 *			  there is some thread that could access state data
 *
 * avl_active_link	: For inserting this state-data into active AVL tree
 * avl_passive_link	: For inserting this state-data into passive AVL tree
 * Note : All timer values that are of type "clock_t" below are in usecs
 */
typedef struct ibcm_state_data_s {
	/* for AVL tree */
	avl_node_t		avl_active_link;
	avl_node_t		avl_passive_link;
	avl_node_t		avl_passive_comid_link;

	/* remote stuff */
	ib_guid_t		remote_hca_guid;
	ib_com_id_t		remote_comid;
	ib_qpn_t		remote_qpn;

	/* local stuff */
	ib_com_id_t		local_comid;
	ib_qpn_t		local_qpn;
	ib_guid_t		local_hca_guid;

	ibcm_mode_t		mode;
	ibcm_conn_state_t	state;
	ibcm_ap_state_t		ap_state;
	kmutex_t		state_mutex;
	ibt_channel_hdl_t	channel;	/* save a copy */

	/* ref_cnt so others cannot delete a statep that may be referenced */
	int			ref_cnt;

	ib_svc_id_t		svcid;
	ibt_cm_handler_t	cm_handler;

	ibcm_mad_addr_t		stored_reply_addr;

	struct ibcm_hca_info_s *hcap;

	ibmf_msg_t		*stored_msg;
	ibmf_msg_t		*mra_msg;
	ibmf_msg_t		*dreq_msg;
	ibmf_msg_t		*drep_msg;
	ibmf_msg_t		*lapr_msg;

	void			*defer_cm_msg;

	/* timeout related stuff */
	timeout_id_t		timerid;
	clock_t			timer_value;
	clock_t			pkt_life_time;
	clock_t			remote_ack_delay;
	clock_t			rc_alt_pkt_lt;

	hrtime_t		stale_clock;
	hrtime_t		post_time;
	hrtime_t		mra_time;

	ibcm_conn_state_t	timer_stored_state;
	ibcm_ap_state_t		timer_stored_ap_state;
	uint8_t			remaining_retry_cnt;
	uint8_t			max_cm_retries;
	uint8_t			cm_retries;

	uint8_t			drep_in_progress;

	/* some cep stuff, stored here temporarily during connection est  */
	uint8_t			cep_retry_cnt:3;
	ibt_srate_t		local_srate;
	ibt_srate_t		local_alt_srate;
	ib_pkey_t		pkey;
	uint8_t			prim_port;
	uint8_t			alt_port;
	uint32_t		starting_psn;
	ib_path_bits_t		prim_src_path_bits;
	ib_path_bits_t		alt_src_path_bits;

	boolean_t		delete_mra_msg;
	boolean_t		stale;
	boolean_t		delete_state_data;
	boolean_t		is_this_ofuv_chan;

	boolean_t		open_done;
	boolean_t		close_done;
	boolean_t		ap_done;

	uint8_t			send_mad_flags;
	uint8_t			close_flow;
	uint8_t			open_flow;
	ibcm_abort_flag_t	abort_flag;

	struct ibcm_state_data_s	*timeout_next;

	ibcm_conn_state_t	timedout_state;

	ibcm_isync_t		cep_in_rts;
	ibcm_isync_t		clnt_proceed;
	ibcm_isync_t		close_nocb_state;

	/* Clients' information */
	void			*state_cm_private;

	/* pointer to service info */
	struct ibcm_svc_info_s  *state_svc_infop;

	kcondvar_t		block_client_cv;
	kcondvar_t		block_mad_cv;

	/* Data for recycle function */
	struct ibcm_taskq_recycle_arg_s	*recycle_arg;

	/* Return data pointers in various cm api calls */
	ibt_rc_returns_t	*open_return_data;
	ibt_ap_returns_t	*ap_return_data;
	uint8_t			*close_ret_priv_data;
	ibt_priv_data_len_t	*close_ret_priv_data_len;
	uint8_t			*close_ret_status;

	/* for queuing of open_rc_channel requests */
	struct ibcm_state_data_s	*open_link;
	/* for queuing of non-blocking close_rc_channel requests */
	struct ibcm_state_data_s	*close_link;

	struct ibcm_conn_trace_s	*conn_trace;

	/* For ibt_ofuvcm_get_req_data() */
	void			*req_msgp;

	/* Stored RNR retry count from incoming REQ or REP */
	ibt_rnr_retry_cnt_t	local_qp_rnr_cnt;

} ibcm_state_data_t;

_NOTE(MUTEX_PROTECTS_DATA(ibcm_state_data_s::state_mutex,
    ibcm_state_data_s::{state ref_cnt timer_stored_state timer_value
    timer_stored_ap_state remaining_retry_cnt clnt_proceed cep_in_rts
    close_nocb_state block_client_cv block_mad_cv timedout_state cm_handler
    abort_flag mra_msg}))

_NOTE(READ_ONLY_DATA(ibcm_state_data_s::{mode channel svcid hcap
    local_comid local_hca_guid local_qpn remote_comid remote_hca_guid
    remote_qpn pkt_life_time remote_ack_delay rc_alt_pkt_lt stored_reply_addr
    max_cm_retries cep_retry_cnt local_srate local_alt_srate pkey
    prim_port alt_port starting_psn state_svc_infop avl_active_link
    avl_passive_link avl_passive_comid_link defer_cm_msg recycle_arg
    conn_trace}))

_NOTE(SCHEME_PROTECTS_DATA("Serailized access by block_client_cv",
    ibcm_state_data_s::{open_return_data ap_return_data close_ret_priv_data
    close_ret_priv_data_len close_ret_status}))

_NOTE(DATA_READABLE_WITHOUT_LOCK(ibcm_state_data_s::{timedout_state
    cm_handler mra_msg abort_flag local_qp_rnr_cnt}))

/*
 * Definitions for send mad flags. Respective bits in send_mad_flags or
 * ud_send_mad_flags are set to 1, during MAD transmission, and reset in
 * ibmf send completion callback or on completion of a blocking ibmf mad post.
 */
#define	IBCM_REP_POST_BUSY	1	/* REP post in progress */
#define	IBCM_REJ_POST_BUSY	2	/* REJ post in progress */
#define	IBCM_RTU_POST_BUSY	4	/* RTU post in progress */
#define	IBCM_MRA_POST_BUSY	8	/* MRA post in progress */
#define	IBCM_DREP_POST_BUSY	16	/* DREQ post in progress */
#define	IBCM_SREP_POST_BUSY	32	/* SIDR REP post in progress */

/* MADs that are retransmitted only because of a timeout */
#define	IBCM_REQ_POST_BUSY	64	/* REQ post in progress */


/* Incr/Decr ref_cnt by 1 */
#define	IBCM_REF_CNT_INCR(s)	(s->ref_cnt++)
#define	IBCM_REF_CNT_DECR(s)	\
	if ((--(s->ref_cnt) == 0) && (s->delete_state_data == B_TRUE)) { \
		ibcm_add_tlist(s);\
	} \
	ASSERT(s->ref_cnt >= 0);

/*
 * This macro checks if ch_qp/ch_eec handles are both not set for a channel
 */
#define	IBCM_INVALID_CHANNEL(chan)	(chan == NULL)

/*
 * The next macros are used to get/set the statep from the QP
 * handles, using the CM private data. These call into IBTL.
 * The WAIT and RELEASE macros deal with related issues that
 * require use of the same lock within IBTL.
 */
#define	IBCM_GET_CHAN_PRIVATE(ch, s) \
	if ((ch) != NULL) { \
		s = ibtl_cm_get_chan_private(ch); \
	} else \
		s = NULL;

#define	IBCM_SET_CHAN_PRIVATE(ch, s) \
	if ((ch) != NULL) { \
		ibtl_cm_set_chan_private(ch, (void *)(s)); \
	}

#define	IBCM_RELEASE_CHAN_PRIVATE(ch) \
	if ((ch) != NULL) { \
		ibtl_cm_release_chan_private(ch); \
	}

#define	IBCM_WAIT_CHAN_PRIVATE(ch) \
	ibtl_cm_wait_chan_private(ch);

/* In future, if we intend to change it to realtime_timeout, it's easy */
#define	IBCM_TIMEOUT(arg1, arg2)	timeout(ibcm_timeout_cb, arg1,\
						drv_usectohz(arg2))
#define	IBCM_UD_TIMEOUT(arg1, arg2)	timeout(ibcm_sidr_timeout_cb, arg1,\
						drv_usectohz(arg2))

extern void ibcm_open_enqueue(ibcm_state_data_t *statep);
extern void ibcm_open_done(ibcm_state_data_t *statep);
extern void ibcm_close_enqueue(ibcm_state_data_t *statep);
extern void ibcm_close_done(ibcm_state_data_t *statep, int send_done);
extern void ibcm_close_enter(void);
extern void ibcm_close_exit(void);
extern void ibcm_lapr_enter(void);
extern void ibcm_lapr_exit(void);
extern void ibcm_check_for_opens(void);
extern void ibcm_check_for_async_close(void);
extern void ibcm_close_start(ibcm_state_data_t *statep);
extern void ibcm_run_tlist_thread(void);

/*
 * Structures & defines for SIDR
 */

/*
 * Define a connection state structure, used for SIDR REQ and REP
 * (ibcm_ud_state_data_t - struct for SIDR connection)
 *
 * ud_state: 		CM connection state (See ibcm_conn_state_t)
 * ud_req_id:		Request ID
 * ud_svcid:		Service ID
 * ud_state_mutex:	CM connection state
 *
 * ud_max_cm_retries:	Max retry count for sending a SIDR REQ
 * ud_ref_cnt:		State ref count for not deleting accidentally
 * ud_remaining_retry_count: Remaining count for retries ie., posting
 *			stored MADs
 * ud_cm_handler:	Server's handler callback address
 *
 * ud_nextp:		CM link for IBTF list
 * ud_hcap:		A pointer to the HCA's entry
 *
 * ud_timerid:		Timer id for the timeout either for re-sending the
 *			stored mad or deleting the stored mad
 *			Ex: A SIDR REP response for an incoming SIDR REQ
 *			An outgoing SIDR REQ on active connection side
 * ud_timer_value:	Time for any of the above timers in HZ
 * ud_pkt_life_time:	pkt life time from source to destination
 * ud_stored_reply_addr: Address for replying using the stored mad
 *
 * ud_sidr_req_lid:	SIDR REQ sender's port LID
 * ud_sidr_req_gid:	SIDR REQ sender's port GID
 * ud_grh_exists:	TRUE if GRH exists in the incoming SIDR REQ
 *
 * ud_passive_qpn:	QPN allocated by server for a SIDR REQ
 * ud_passive_qpn_qkey:	QPN's QKEY allocated by server
 *
 * ud_block_client_cv:	CV condition variable on which ibt_ud_get_dqpn() waits,
 *			if called in blocking mode.
 * ud_return_data:	UD return args, valid for blocking ibt_ud_get_dqpn
 * ud_timer_stored_state: State stored for timeout handling
 * ud_blocking_done	: Tells if cv_wait is needed or not. To handle the
 *			  case where a cv_signal is received prior to its
 *			  cv_wait().
 * Note : All timer values that are of type "clock_t" below are in usec
 */
typedef struct ibcm_ud_state_data_s {
	kmutex_t		ud_state_mutex;
	ibcm_conn_state_t	ud_state;
	ibcm_mode_t		ud_mode;

	int			ud_ref_cnt;

	uint32_t		ud_req_id;
	ib_svc_id_t		ud_svc_id;

	uint8_t			ud_max_cm_retries;
	uint8_t			ud_remaining_retry_cnt;
	ibt_cm_ud_handler_t	ud_cm_handler;

	struct ibcm_ud_state_data_s	*ud_nextp;
	struct ibcm_hca_info_s *ud_hcap;

	/* timeout related stuff */
	timeout_id_t		ud_timerid;
	clock_t			ud_timer_value;
	clock_t			ud_pkt_life_time;
	ibcm_mad_addr_t		ud_stored_reply_addr;
	ibmf_msg_t		*ud_stored_msg;


	/* SIDR REQ side related */
	ib_lid_t		ud_sidr_req_lid;
	ib_gid_t		ud_sidr_req_gid;
	boolean_t		ud_grh_exists;

	/* Stored values on server/SIDR REP side for re-transmits */
	ib_qpn_t		ud_passive_qpn;
	ib_qkey_t		ud_passive_qp_qkey;

	/* Clients' information */
	void			*ud_state_cm_private;

	struct ibcm_ud_state_data_s	*ud_timeout_next;
	boolean_t		ud_delete_state_data;
	boolean_t		ud_blocking_done;

	uint8_t			ud_send_mad_flags;

	ibcm_isync_t		ud_clnt_proceed;

	/* The following fields are not used by server side connection */
	kcondvar_t		ud_block_client_cv;
	ibt_ud_returns_t	*ud_return_data;
	ibcm_conn_state_t	ud_timer_stored_state;
} ibcm_ud_state_data_t;

_NOTE(MUTEX_PROTECTS_DATA(ibcm_ud_state_data_s::ud_state_mutex,
    ibcm_ud_state_data_s::{ud_state ud_ref_cnt ud_timerid
    ud_delete_state_data ud_blocking_done ud_send_mad_flags ud_clnt_proceed
    ud_timer_stored_state ud_send_mad_flags ud_clnt_proceed
    ud_block_client_cv ud_timer_value ud_remaining_retry_cnt}))

_NOTE(READ_ONLY_DATA(ibcm_ud_state_data_s::{ud_mode ud_req_id ud_svc_id
    ud_max_cm_retries ud_pkt_life_time ud_stored_reply_addr ud_stored_msg
    ud_sidr_req_lid ud_sidr_req_gid ud_grh_exists ud_passive_qpn
    ud_passive_qp_qkey ud_state_cm_private ud_stored_reply_addr ud_stored_msg}))

_NOTE(SCHEME_PROTECTS_DATA("Serailized access by ud_block_client_cv",
    ibcm_ud_state_data_s::{ud_return_data}))

_NOTE(DATA_READABLE_WITHOUT_LOCK(ibcm_ud_state_data_s::{ud_cm_handler}))

/*
 * Structure used to specify the SIDR search parameters
 */
typedef struct ibcm_sidr_srch_s {
	ib_lid_t		srch_lid;
	ib_gid_t		srch_gid;
	boolean_t		srch_grh_exists;
	uint32_t		srch_req_id;
	ibcm_mode_t		srch_mode;
} ibcm_sidr_srch_t;

_NOTE(READ_ONLY_DATA(ibcm_sidr_srch_s))

/*
 * Incr/Decr ud_ref_cnt by 1
 */
#define	IBCM_UD_REF_CNT_INCR(s)	((s)->ud_ref_cnt++)
#define	IBCM_UD_REF_CNT_DECR(s)	\
	if ((--(s->ud_ref_cnt) == 0) && (s->ud_delete_state_data == B_TRUE)) { \
		ibcm_add_ud_tlist(s);\
	} \
	ASSERT(s->ud_ref_cnt >= 0);

/*
 * Structure to store the Service Registration and Service Bind entries.
 *
 * Well known service id's are unique on a given HCA, but can be registered
 * only at some GID's. Hence can be multiple GID's per Service ID. For each
 * such GID and PKEY combination registered, there will be an ibcm_svc_info_t
 * entry in the CM global service list.
 *
 * Annex A of the spec constrains that there shall be one service provider per
 * service id, which implies same svc_rc_handler for all such entries
 * There can be multiple transport types (svc_tran_type) per Service ID. For
 * each such transport type, there will be an ibcm_svc_info_t entry in the
 * CM global service list and cm handler can be different
 *
 * For locally allocated service id's (maintained by OS), there can be only
 * one GID, where the service can be registered
 *
 * svc_id:		Service ID
 * svc_num_sids:	Number (Range) of service-ids supported
 * svc_flags:		Service flags specified at registration time
 * svc_link:		Global AVL tree of ibcm_svc_info_t structs
 * svc_rc_handler:	Server handler for RC (only one is valid at a time)
 * svc_ud_handler:	Server handler for UD (only one is valid at a time)
 * svc_ref_cnt:		Reference count
 * svc_to_delete:	If 1, then the entry is marked to be deleted
 *
 * sbind_gid:		GID
 * sbind_pkey:		P_Key
 * sbind_lease:		Service Lease
 * sbind_name:		Service Name
 */
typedef struct ibcm_svc_info_s {
	avl_node_t		svc_link;
	struct ibcm_svc_bind_s	*svc_bind_list;
	ibt_cm_handler_t	svc_rc_handler;
	ibt_cm_ud_handler_t	svc_ud_handler;
	int			svc_ref_cnt;
	int			svc_to_delete;
	ib_svc_id_t		svc_id;
	int			svc_num_sids;
	ibt_service_flags_t	svc_flags;
} ibcm_svc_info_t;

typedef struct ibcm_svc_bind_s {
	struct ibcm_svc_bind_s	*sbind_link;
	void			*sbind_cm_private;
	ib_gid_t		sbind_gid;
	ib_guid_t		sbind_hcaguid;
	uint64_t		sbind_key[2];
				/* sbind_data is assumed to be 8-byte aligned */
	uint8_t			sbind_data[IB_SVC_DATA_LEN]; /* ServiceData */
	uint32_t		sbind_lease;
	ib_pkey_t		sbind_pkey;
	uint8_t			sbind_port;
	uint8_t			sbind_rewrite_state;
	char			sbind_name[IB_SVC_NAME_LEN];
} ibcm_svc_bind_t;

/*
 * Service records may be lost by the SM/SA (reboot, change in who
 * is the master, etc.).  When any of the above occurs, a PORT_UP
 * async event is supposed to occur, at which point we mark all of
 * our service record information as stale (REWRITE_NEEDED), and
 * subsequently make the necessary sa_update calls to get the
 * SM/SA in sync with all the service records we previously wrote.
 *
 * Values for sbind_rewrite_state follow.  This field is protected by
 * ibcm_svc_info_lock.  ibt_unbind_service has to wait until a service
 * binding is either idle or needed, sleeping on ibcm_svc_info_cv if
 * busy (rewrite in progress).
 */
#define	IBCM_REWRITE_IDLE	0
#define	IBCM_REWRITE_NEEDED	1
#define	IBCM_REWRITE_BUSY	2

typedef struct ibcm_port_up_s {
	ib_guid_t	pup_hca_guid;
	uint8_t		pup_port;
} ibcm_port_up_t;

/* arg is a pointer to ibcm_port_up_t */
extern void ibcm_service_record_rewrite_task(void *);

#define	IBCM_SVC_INCR(svcinfop) (svcinfop)->svc_ref_cnt++
#define	IBCM_SVC_DECR(svcinfop) \
	if (--((svcinfop)->svc_ref_cnt) == 0 && \
	    (svcinfop)->svc_to_delete) \
		cv_broadcast(&ibcm_svc_info_cv); \
	ASSERT(svcinfop->svc_ref_cnt >= 0);

_NOTE(READ_ONLY_DATA(ibcm_svc_info_s::{svc_rc_handler svc_ud_handler svc_id
    svc_num_sids svc_flags}))

_NOTE(READ_ONLY_DATA(ibcm_svc_bind_s::{sbind_cm_private sbind_gid sbind_hcaguid
    sbind_key sbind_data sbind_lease sbind_pkey sbind_port sbind_name}))

/* for avl tree search */
typedef struct ibcm_svc_lookup_s {
	ib_svc_id_t	sid;
	int		num_sids;
} ibcm_svc_lookup_t;

typedef struct ibcm_ar_ref_s {
	struct ibcm_ar_ref_s	*ar_ref_link;
	ibt_clnt_hdl_t		ar_ibt_hdl;
} ibcm_ar_ref_t;

typedef struct ibcm_ar_s {
	ibt_ar_t		ar;
	int			ar_flags;	/* 1 = INITING, 2 = FAILED */
	int			ar_waiters;	/* # of waiters */
	kcondvar_t		ar_cv;
	uint8_t			ar_port;
	uint8_t			ar_rewrite_state; /* see sbind_rewrite_state */
	ibcm_ar_ref_t		*ar_ibt_hdl_list;
	struct ibcm_ar_s	*ar_link;
	sa_service_record_t	*ar_srv_recp;
	ibmf_saa_handle_t	ar_saa_handle;
	struct ibcm_hca_info_s	*ar_hcap;
} ibcm_ar_t;

/* ar_flags */
#define	IBCM_AR_SUCCESS		0
#define	IBCM_AR_FAILED		1
#define	IBCM_AR_INITING		2


/*
 * These flags are used for adding (if an entry does not exist) or
 * for just looking one up
 */
typedef enum ibcm_lookup_flag_e {
	IBCM_FLAG_LOOKUP		= 0,	/* just lookup */
	IBCM_FLAG_ADD			= 1,	/* just add */
	IBCM_FLAG_LOOKUP_AND_ADD	= 2	/* lookup first. add if  */
						/* lookup failed */
} ibcm_lookup_flag_t;

typedef enum ibcm_finit_state_e {
	IBCM_FINIT_INIT,		/* CM's init is not yet completed */
	IBCM_FINIT_IDLE,		/* CM not in either init or fini */
	IBCM_FINIT_BUSY,		/* CM busy either in init or fini */
	IBCM_FINIT_FAIL,		/* Init failed */
	IBCM_FINIT_SUCCESS		/* Fini has succeeded */
} ibcm_finit_state_t;

/*
 * Identifies HCA's state. Used in the definition of ibcm_hca_info_t
 * If HCA is in ACTIVE state only does CM allow any MAD processing.
 */
typedef enum ibcm_hca_state_e {
	IBCM_HCA_INIT,
	IBCM_HCA_ACTIVE,
	IBCM_HCA_NOT_ACTIVE
} ibcm_hca_state_t;

/* QP information per pkey, stored in port information */
typedef struct ibcm_qp_list_s {
	ib_pkey_t		qp_pkey;
	ibmf_qp_handle_t	qp_cm;
	uint32_t		qp_ref_cnt;
	struct ibcm_port_info_s *qp_port;
	struct ibcm_qp_list_s	*qp_next;
} ibcm_qp_list_t;

_NOTE(READ_ONLY_DATA(ibcm_qp_list_s::{qp_pkey qp_cm qp_port qp_next}))
_NOTE(DATA_READABLE_WITHOUT_LOCK(ibcm_qp_list_s))

/*
 * port information per HCA
 * port_ibmf_hdl	- contains IBMF handle for that port if valid
 *			  otherwise is NULL
 * port_ibmf_saa_hdl	- contains SA Access handle for that port if valid
 *			  otherwise is NULL
 */
typedef struct ibcm_port_info_s {
	ibmf_handle_t		port_ibmf_hdl;
	ibmf_saa_handle_t	port_ibmf_saa_hdl;
	ib_gid_t		port_sgid0;
	uint8_t			port_event_status;
	uint8_t			port_saa_open_in_progress;
	uint8_t			port_num;
	ibmf_register_info_t	port_ibmf_reg;
	ibmf_impl_caps_t	port_ibmf_caps;
	ibcm_qp_list_t		port_qp1;
	ibcm_qp_list_t		*port_qplist;
	struct ibcm_hca_info_s	*port_hcap;
} ibcm_port_info_t;

_NOTE(READ_ONLY_DATA(ibcm_port_info_s::{port_num port_ibmf_caps port_qp1
    port_hcap}))

/* Value to indicate to exit the timeout list processing thread */
#define	IBCM_TIMEOUT_THREAD_EXIT	01

/*
 * IBCM code relies on AVL routines already in kernel for faster lookups.
 * AVL was chosen over mod hashing mechanism based on the its internal
 * limitations in the kernel (no support for over 100,000 keys).
 *
 * IBCM uses two AVL trees on the passive side and one on active side per HCA.
 * The two trees are need on the passive side because the tree lookup criteria
 * changes based on the type of message being processed. On passive side it is
 * based on remote_qpn and remote_hca_guid for only incoming REQ message and for
 * for all other messages the search criteria is based upon remote_comid.
 * On active side the lookup criteria remains static based upon local_comid.
 *
 * AVL tree insertions are done by grabbing the writer lock (hca_state_rwlock)
 * and lookups are done by grabbing the reader lock.
 */

/*
 * CM's per HCA data structure.
 *
 * One such entry is added/removed on hca attach/detach notifications to CM
 * respectively.
 *
 * Comids are used for all connections. Req ids are used for SIDR REQ and
 * SIDR REP messages.  These are  simple counters that wrap around INT_MAX.
 * NOTE: The starting value for comid, per HCA, is 2.
 *
 * hca_state:		HCA's current state (ibcm_hca_state_t) - whether
 *				IBT_HCA_ACTIVE, IBT_HCA_NOT_ACTIVE,
 * hca_guid:            Active HCA guid
 * hca_caps:		HCA capability mask
 * hca_ack_delay:	HCA ack delay
 * hca_max_rdma_rd	Max RDMA in Reads
 * hca_max_rdma_dpt	Max RDMA out Reads
 * hca_active_tree:	This tree is used for lookups on Active/Passive side
 *			CM based on communication id ONLY.
 * hca_passive_tree:	This tree is used to lookup/create ibcm_state_data_t on
 *			Passive Side CM based on remote_qpn and remote_hca_guid.
 * hca_passive_comid_tree:
 *			This tree is used to lookup/create ibcm_state_data_t on
 *			Passive Side CM based on remote_comid and
 *			remote_hca_guid.
 * hca_state_rwlock:	reader/writer Lock for the hca entry
 *				for hca_active_tree
 *				for hca_passive_tree
 *				for hca_next_comid
 * hca_sidr_list:	List for UD side
 * hca_sidr_list_lock:	List lock for UD side
 *				for hca_sidr_list
 *				for hca_next_reqid
 * hca_next_reqid:	Next active ReqId
 * hca_next_comid:	Next active ComID
 * hca_next:		Pointer to the next HCA
 * hca_svc_cnt:		A count of services registered on this hca
 * hca_acc_cnt:		A count of active references to this ibcm_hca_info_t
 * hca_res_cnt:		A count of client's active resources on this hca
 * hca_num_ports:	Number of ports that this HCA has
 * hca_port_info:	Per port information (IBMA/SA access handles etc.)
 *
 * Note : The global mutex ibcm_global_hca_mutex declared in CM is used for
 * accesses to the following fields :
 * hca_acc_cnt, hca_res_cnt, hca_svc_cnt, hca_state
 */
typedef struct ibcm_hca_info_s {
	ibcm_hca_state_t	hca_state;		/* Is HCA attached? */
	ib_guid_t		hca_guid;		/* HCA's guid value */
	ibt_hca_flags_t		hca_caps;		/* HCA capabilities */
	uint32_t		hca_vendor_id:24;
	uint16_t		hca_device_id;
	ib_time_t		hca_ack_delay;		/* HCA ack delay */
	uint8_t			hca_max_rdma_in_qp;	/* Max RDMA in Reads */
	uint8_t			hca_max_rdma_out_qp;	/* Max RDMA out Reads */
	vmem_t			*hca_comid_arena;	/* arena for com ids */
	vmem_t			*hca_reqid_arena;	/* arena for req ids */
	avl_tree_t		hca_active_tree;	/* active node tree */
	avl_tree_t		hca_passive_tree;	/* passive node tree */
	avl_tree_t		hca_passive_comid_tree;	/* passive comid tree */
	krwlock_t		hca_state_rwlock;	/* per HCA lock */
	ibcm_ud_state_data_t	*hca_sidr_list;		/* SIDR state list */
	krwlock_t		hca_sidr_list_lock;

	struct ibcm_hca_info_s	*hca_next;		/* Next HCA entry */

	int			hca_svc_cnt;		/* # of */
							/* services allocated */
	int			hca_acc_cnt;		/* active references */
	int			hca_res_cnt;		/* total resources */
	uint8_t			hca_num_ports;		/* #ports on this HCA */
	ibcm_port_info_t	hca_port_info[1];	/* Per portinfo array */
} ibcm_hca_info_t;

_NOTE(RWLOCK_PROTECTS_DATA(ibcm_hca_info_s::hca_state_rwlock,
    ibcm_hca_info_s::{hca_active_tree hca_passive_tree hca_passive_comid_tree}))

_NOTE(SCHEME_PROTECTS_DATA("hca_sidr_list_lock protects hca_sidr_list",
    ibcm_hca_info_s::{hca_sidr_list}))

_NOTE(READ_ONLY_DATA(ibcm_hca_info_s::{hca_guid hca_caps hca_ack_delay
    hca_max_rdma_in_qp hca_max_rdma_out_qp hca_comid_arena hca_reqid_arena
    hca_passive_tree hca_active_tree hca_passive_comid_tree hca_num_ports }))

/* Are we on Tavor HCA */
#define	IBCM_IS_HCA_TAVOR(hcap)	\
	(((hcap)->hca_device_id == 0x5a44) && ((hcap)->hca_vendor_id == 0x15b3))

/*
 * called to ensure that HCA is in "attached" state and is willing to
 * process connections etc.
 */
#define	IBCM_ACCESS_HCA_OK(s)	((s)->hca_state == IBCM_HCA_ACTIVE)

/*
 * Passive AVL tree lookup info  (for hca_passive_tree)
 * CM needs this structure as passive tree lookups are based on
 * QPN and HCA GUID.
 */
typedef	struct ibcm_passive_node_info_s {
	ib_qpn_t	info_qpn;
	ib_guid_t	info_hca_guid;
} ibcm_passive_node_info_t;

/*
 * Passive Com ID AVL tree lookup info  (for hca_passive_comid_tree)
 * CM needs this structure as passive comid tree lookups are based on
 * Remote Com ID and Remote HCA GUID.
 */
typedef struct ibcm_passive_comid_node_info_s {
	ib_com_id_t	info_comid;
	ib_guid_t	info_hca_guid;
} ibcm_passive_comid_node_info_t;

/* CM proceed task args structure definition */
typedef struct ibcm_proceed_targs_s {
	ibt_cm_event_type_t	event;
	ibt_cm_status_t		status;
	union tst_t {
		struct rc_s {
			ibcm_state_data_t	*statep;
			ibt_cm_proceed_reply_t	rc_cm_event_data;
		} rc;
		struct ud_s {
			ibcm_ud_state_data_t	*ud_statep;
			ib_qpn_t		ud_qpn;
			ib_qkey_t		ud_qkey;
			ibt_redirect_info_t	ud_redirect_info;
		} ud;
	} tst;
	ibt_priv_data_len_t	priv_data_len;
	/* keep priv_data as the last field */
	uint8_t			priv_data[IBT_MAX_PRIV_DATA_SZ];
} ibcm_proceed_targs_t;

_NOTE(READ_ONLY_DATA(ibcm_proceed_targs_s))


/*
 * function prototypes for AVL tree compares
 */
int	ibcm_active_node_compare(const void *, const void *);
int	ibcm_passive_node_compare(const void *, const void *);
int	ibcm_passive_comid_node_compare(const void *, const void *);

/*
 * function prototypes to allocate IBMF/SA_ACCESS handles
 */
ibt_status_t	ibcm_hca_reinit_port(ibcm_hca_info_t *hca_p,
		    uint8_t port_index);

/* function prototypes to Manage CM's IBMF QP's */

ibcm_qp_list_t *ibcm_find_qp(ibcm_hca_info_t *hcap, int port_no,
		    ib_pkey_t pkey);

void		ibcm_release_qp(ibcm_qp_list_t *cm_qp_entry);

ibcm_status_t	ibcm_free_qp(ibcm_qp_list_t *cm_qp_entry);

ibcm_status_t	ibcm_free_allqps(ibcm_hca_info_t *hcap, int port_no);

/*
 * function prototypes to allocate and free outgoing CM messages
 */
ibt_status_t
ibcm_alloc_out_msg(ibmf_handle_t ibmf_handle, ibmf_msg_t **ibmf_msgpp,
    uint8_t method);
ibcm_status_t
ibcm_free_out_msg(ibmf_handle_t ibmf_handle, ibmf_msg_t **ibmf_msgpp);

/*
 * Definition for CM state transition processing function
 */
typedef void (*ibcm_state_handler_t)(ibcm_hca_info_t *hcap,
		uint8_t *cm_input_mad, ibcm_mad_addr_t *cm_mad_addr);

/*
 * CM REQ Message structure
 *
 * Request for communication.
 *
 * Things of interest are:-
 * ib_qpn_t cannot be used - it is typecast to uint32_t but is 24 bits
 * ib_eecn_t cannot be used - it is typecast to uint32_t but is 24 bits
 *
 * (See Table 85 REQ Message Contents - chapter 12 in IB Spec v1.0a)
 *
 */
typedef struct ibcm_req_msg_s {
	ib_com_id_t	req_local_comm_id;	/* Local communication id */
						/* 32 bits */
	uint32_t	req_rsvd1;		/* Reserved1 - 32 bits */
	ib_svc_id_t	req_svc_id;		/* Service Id - 64 bits */
	ib_guid_t	req_local_ca_guid;	/* Local CA GUID - 64 bits */
	uint32_t	req_rsvd1p;		/* Reserved1+ - 32 bits */
	ib_qkey_t	req_local_qkey;		/* Local Q_KEY - 32 bits */
	uint32_t	req_local_qpn_plus;	/* QPN_24 RESP_RSRC_8 */
						/* local side QPN - 24 bits */
						/* Offered responder */
						/* resources - 8 bits */
	uint32_t	req_local_eec_no_plus;	/* LOCAL_EECN_24 INIT_DEPTH_8 */
						/* Local side EECN - 24 bits */
						/* Offered initiator */
						/* depth - 8 bits */
	uint32_t	req_remote_eecn_plus;	/* REM_EECN_24 TO_5 TT_2 EE_1 */
						/* Remote side EECN - 24 bits */
						/* Remote CM timeout - 5 bits */
						/* Transport srvtype - 2 bits */
						/* End-to-End flow - 1 bit */
	uint32_t	req_starting_psn_plus;	/* START_PSN_24 TO_5 RETRY_3 */
						/* Starting PSN - 24 bits */
						/* Local CM timeout - 5 bits */
						/* Retry count - 3 bits */
	ib_pkey_t	req_part_key;		/* Partition key - 16 bits */
	uint8_t		req_mtu_plus;		/* PATH_MTU_4 RDC_1 RNR_3 */
						/* Path Pkt MTU - 4 bits */
						/* Does RDC exist? - 1 bits */
						/* RNR retry count - 3 bits */
	uint8_t		req_max_cm_retries_plus; /* MAX_CM_RET_4 SRQ_1 RSV_3 */
						/* Max CM retries - 4 bits */
						/* SRQ Exists - 1 bit */
						/* Reserved2 - 3 bits */
	ib_lid_t	req_primary_l_port_lid;	/* Primary local port LID */
	ib_lid_t	req_primary_r_port_lid;	/* Primary Remote port LID */
	ib_gid_t	req_primary_l_port_gid;	/* Primary local port GID */
	ib_gid_t	req_primary_r_port_gid;	/* Primary remote port GID */
	uint32_t	req_primary_flow_label_plus; /* FLOW_20 RSV_4 SRATE_6 */
						/* Prim. flow label - 20 bits */
						/* Reserved3 - 6 bits */
						/* Primary rate - 6 bits */
	uint8_t		req_primary_traffic_class;
						/* Primary Traffic class */
	uint8_t		req_primary_hop_limit;	/* Prim Hop Limit */
	uint8_t		req_primary_sl_plus;	/* PRIMARY_SL_4 LOCAL_1 RSV_3 */
						/* Primary SL - 4 bits */
						/* Prim. subnet local - 1 bit */
						/* Reserved4 - 3 bits */
	uint8_t		req_primary_localtime_plus; /* LOCAL_TO_5 RSV_3 */
						/* Primary local */
						/* timeout - 5 bits */
						/* Reserved5 - 3 bits */
	ib_lid_t	req_alt_l_port_lid;	/* Alt local port LID */
	ib_lid_t	req_alt_r_port_lid;	/* Alt Remote port LID */
	/* Note: req_alt_l_port_gid/req_alt_r_port_gid are not 8-byte aligned */
	uint8_t		req_alt_l_port_gid[16];	/* Alt local port GID */
	uint8_t		req_alt_r_port_gid[16];	/* Alt remote port GID */
	uint32_t	req_alt_flow_label_plus; /* ALT_FLOW_20 RSV_6 ARATE_6 */
						/* Alt flow label - 20 bits */
						/* Reserved6 - 6 bits */
						/* Alternate rate - 6 bits */
	uint8_t		req_alt_traffic_class;	/* Alt traffic class */
	uint8_t		req_alt_hop_limit;	/* Alt hop limit */
	uint8_t		req_alt_sl_plus;	/* ALT_SL_4 A_LOCAL_1 RSV_3 */
						/* Alternate SL - 4 bits */
						/* Alt subnet local - 1 bit */
						/* Reserved7 - 3 bits */
	uint8_t		req_alt_localtime_plus;	/* ALT_LOCAL_ACK_TO_5 RSV_3 */
						/* Alt Local ACK */
						/* timeout - 5 bits */
						/* Reserved8 - 3 bits */
	uint8_t		req_private_data[IBT_REQ_PRIV_DATA_SZ];
						/* Private data */
} ibcm_req_msg_t;


/*
 * The following set of defines are short-cuts to CEP_PATH or GRH info
 */
#define	IBCM_PRIM_CEP_PATH(s)	(s)->oc_path->pi_prim_cep_path
#define	IBCM_PRIM_ADDS_VECT(s)	(s)->oc_path->pi_prim_cep_path.cep_adds_vect

#define	IBCM_ALT_CEP_PATH(s)	(s)->oc_path->pi_alt_cep_path
#define	IBCM_ALT_ADDS_VECT(s)	(s)->oc_path->pi_alt_cep_path.cep_adds_vect

#define	IBCM_UD_CEP_PATH(s)	(s)->us_path_info->ai_cep_path
#define	IBCM_UD_ADDS_VECT(s)	(s)->us_path_info->ai_cep_path.cep_adds_vect

/*
 * The following set of defines are short-cuts to ibt_cm_event_t
 */
#define	IBCM_EVT_REQ(e)		(e).cm_event.req
#define	IBCM_EVT_REP(e)		(e).cm_event.rep

/*
 * The following set of defines are short-cuts to qp_attrs or qp_info
 */
#define	IBCM_QP_RC(q)		(q).qp_info.qp_transport.rc
#define	IBCM_QP_UD(q)		(q).qp_info.qp_transport.ud
#define	IBCM_QP_UC(q)		(q).qp_info.qp_transport.uc

#define	IBCM_QPINFO(q)		(q).qp_transport
#define	IBCM_QPINFO_RC(q)	(q).qp_transport.rc
#define	IBCM_QPINFO_RC_PATH(q)	(q).qp_transport.rc.rc_path
#define	IBCM_QPINFO_UC(q)	(q).qp_transport.uc
#define	IBCM_QPINFO_UC_PATH(q)	(q).qp_transport.uc.uc_path
#define	IBCM_QPINFO_UD(q)	(q).qp_transport.ud


/* The following set of defines are short-cuts to RC and SIDR MAD HDRs */

#define	IBCM_OUT_MADP(msgp)	(msgp->im_msgbufs_send.im_bufs_mad_hdr)
#define	IBCM_OUT_HDRP(msgp)	((ib_mad_hdr_t *)IBCM_OUT_MADP(msgp))
#define	IBCM_OUT_MSGP(msgp)	(msgp->im_msgbufs_send.im_bufs_cl_data)

#define	IBCM_IN_MADP(msgp)	(msgp->im_msgbufs_recv.im_bufs_mad_hdr)
#define	IBCM_IN_HDRP(msgp)	((ib_mad_hdr_t *)IBCM_IN_MADP(msgp))
#define	IBCM_IN_MSGP(msgp)	(msgp->im_msgbufs_recv.im_bufs_cl_data)

#define	IBCM_REJ_PRIV(msgp)  &(((ibcm_rej_msg_t *) \
	IBCM_OUT_MSGP(statep->stored_msg))->rej_private_data[0])
/*
 * CM MRA Message structure
 *
 * Message Receipt Acknowledgement (MRA).
 *
 * NOTE: IB hosts and targets are required to be able to receive and
 * act upon an MRA, but the ability to send an MRA is optional.
 */
typedef struct ibcm_mra_msg_s {
	ib_com_id_t	mra_local_comm_id;	/* Local communication id */
	ib_com_id_t	mra_remote_comm_id;	/* Remote communication id */
	uint8_t		mra_message_type_plus;	/* Message Type - 2 bits */
						/* Reserved1 - 6 bits */
	uint8_t		mra_service_timeout_plus; /* SVC_TO_5 RSV_3 */
						/* Service timeout - 5 bits */
						/* Reserved2 - 3 bits */
	uint8_t		mra_private_data[IBT_MRA_PRIV_DATA_SZ];
						/* Private data */
} ibcm_mra_msg_t;

/*
 * CM REJ Message structure
 * REJ indicates that the sender will not continue through the communication
 * establishment sequence and the reason why it will not.
 *
 * NOTE: See ibt_cm_reason_t in common/sys/ib/ib_cm.h for complete list
 * of rejection reasons supported.
 */
typedef struct ibcm_rej_msg_s {
	ib_com_id_t	rej_local_comm_id;	/* Local communication id */
	ib_com_id_t	rej_remote_comm_id;	/* Remote communication id */
	uint8_t		rej_msg_type_plus;	/* REJ_MSG_TYPE_2 RSV_6 */
						/* Msg being REJed - 2 bits */
						/* Reserved1 - 6 bits */
	uint8_t		rej_reject_info_len_plus; /* REJ_INFO_LEN_7 RSV_1 */
						/* Rej. Info Length - 7 bits */
						/* Reserved2 - 1 bit */
	uint16_t	rej_rejection_reason;	/* Reject err code - 16 bits */
	uint8_t		rej_addl_rej_info[IBT_CM_ADDL_REJ_LEN];
						/* Additional Reject Info */
	uint8_t		rej_private_data[IBT_REJ_PRIV_DATA_SZ];
						/* Private data */
} ibcm_rej_msg_t;

/*
 * CM REP Message structure
 *
 * REP is returned in response to REQ, indicating that the respondent
 * accepts the Service-ID, proposed primary port, and any parameters
 * specified in the PrivateData of the REQ.
 */
typedef struct ibcm_rep_msg_s {
	ib_com_id_t	rep_local_comm_id;	/* Local communication id */
	ib_com_id_t	rep_remote_comm_id;	/* Remote communication id */
	ib_qkey_t	rep_local_qkey;		/* Local Q_KEY */
	uint32_t	rep_local_qpn_plus;	/* LOCAL_QPN_24 RSV_8 */
						/* Local side QPN - 24 bits */
						/* Reserved1 - 8 bits */
	uint32_t	rep_local_eecn_plus;	/* LOCAL_EECN_24 RSV_8 */
						/* Local side EECN - 24 bits */
						/* Reserved2 - 8 bits */
	uint32_t	rep_starting_psn_plus;	/* STARTING_PSN_24 RSV_8 */
						/* Starting PSN - 24 bits */
						/* Reserved3 - 8 bits */
	uint8_t		rep_resp_resources;	/* Responder resources 8 bits */
	uint8_t		rep_initiator_depth;	/* Initiator depth - 8 bits */
	uint8_t		rep_target_delay_plus;	/* TGT_ACK_DLY_5 FAIL_2 EE_1 */
						/* Target ACK delay - 5 bits */
						/* Failover accepted - 2 bits */
						/* End-to-End flow control - */
						/* 1 bit */
	uint8_t		rep_rnr_retry_cnt_plus;	/* RNR_COUNT_3 SRQ_1 RSV_4 */
						/* RNR retry count - 3 bits */
						/* SRQ Exists - 1 bit */
						/* Reserved4 - 4 bits */
	uint8_t		rep_local_ca_guid[8];	/* Local CA GUID - 64 bits */
	uint8_t		rep_private_data[IBT_REP_PRIV_DATA_SZ];
						/* Private data */
} ibcm_rep_msg_t;


/*
 * CM RTU Message structure
 *
 * RTU indicates that the connection is established, and that the
 * recipient may begin transmitting.
 */
typedef struct ibcm_rtu_msg_s {
	ib_com_id_t	rtu_local_comm_id;	/* Local communication id */
	ib_com_id_t	rtu_remote_comm_id;	/* Remote communication id */
	uint8_t		rtu_private_data[IBT_RTU_PRIV_DATA_SZ];
						/* Private data */
} ibcm_rtu_msg_t;


/*
 * CM DREQ Message structure
 *
 * DREQ is sent to initiate the connection release sequence.
 */
typedef struct ibcm_dreq_msg_s {
	ib_com_id_t	dreq_local_comm_id;	/* Local communication id */
	ib_com_id_t	dreq_remote_comm_id;	/* Remote communication id */
	uint32_t	dreq_remote_qpn_eecn_plus; /* REM_EECN_24 RSV_8 */
						/* Remote QPN/EECN - 24 bits */
						/* reserved - 8 bits */
	uint8_t		dreq_private_data[IBT_DREQ_PRIV_DATA_SZ];
						/* Private data */
} ibcm_dreq_msg_t;


/*
 * CM DREP Message structure
 *
 * DREP is sent in response to DREQ, and signifies that the sender has
 * received DREQ.
 */
typedef struct ibcm_drep_msg_s {
	ib_com_id_t	drep_local_comm_id;	/* Local communication id */
	ib_com_id_t	drep_remote_comm_id;	/* Remote communication id */
	uint8_t		drep_private_data[IBT_DREP_PRIV_DATA_SZ];
						/* Private Data */
} ibcm_drep_msg_t;


/*
 * CM LAP Message structure
 *
 * NOTE: LAP and APR messages are optional. These are needed if CM
 * accepts REQ messages and agrees to perform Automatic Path Migration.
 *
 * This message is used to change the alternate path information for a
 * specific connection.
 */
typedef struct ibcm_lap_msg_s {
	ib_com_id_t	lap_local_comm_id;	/* Local communication id */
	ib_com_id_t	lap_remote_comm_id;	/* Remote communication id */
	uint32_t	lap_rsvd1;		/* Reserved - 32 bits */
	uint32_t	lap_remote_qpn_eecn_plus; /* REM_EECN_24 TO_5 RSV_3 */
						/* Remote QPN/EECN - 24 bits */
						/* Remote CM response */
						/* timeout - 5 bits */
						/* Reserved1 - 3 bits */
	uint32_t	lap_rsvd2;		/* Reserved2 - 32 bits */
	ib_lid_t	lap_alt_l_port_lid;	/* Alt local port LID */
	ib_lid_t	lap_alt_r_port_lid;	/* Alt Remote port LID */
	ib_gid_t	lap_alt_l_port_gid;	/* Alt local port GID */
	ib_gid_t	lap_alt_r_port_gid;	/* Alt remote port GID */
	uint32_t	lap_alt_flow_label_plus; /* ALT_FLOW_20 RSV_4 TCL_8 */
						/* Alt flow label - 20 bits */
						/* Reserved3 - 4 bits */
						/* Alt traffic class - 8 bits */
	uint8_t		lap_alt_hop_limit;	/* Alt hop limit */
	uint8_t		lap_alt_srate_plus;	/* Reserved4 - 2 bits */
						/* Alt. static rate - 6 bits */
	uint8_t		lap_alt_sl_plus;	/* ALT_SL_4 A_LOCAL_1 RSV_3 */
						/* Alternate SL - 4 bits */
						/* Alt subnet local - 1 bit */
						/* Reserved5 - 3 bits */
	uint8_t		lap_alt_local_acktime_plus; /* ALT_TO_5 RSV_3 */
						/* Alt Local ACK */
						/* timeout - 5 bits */
						/* Reserved6 - 3 bits */
	uint8_t		lap_private_data[IBT_LAP_PRIV_DATA_SZ];
						/* Private data */
} ibcm_lap_msg_t;


/*
 * CM APR Message structure
 *
 * APR is sent in response to a LAP request. MRA may be sent to allow
 * processing of the LAP.
 */
typedef struct ibcm_apr_msg_s {
	ib_com_id_t	apr_local_comm_id;	/* Local communication id */
	ib_com_id_t	apr_remote_comm_id;	/* Remote communication id */
	uint8_t		apr_addl_info_len;	/* Add'l Info Len - 8 bits */
	uint8_t		apr_ap_status;		/* AP status - 8 bits */
	uint16_t	apr_rsvd1;		/* Reserved1 - 16 bits */
	uint8_t		apr_addl_info[IBT_CM_APR_ADDL_LEN];
						/* Additional Information */
	uint8_t		apr_private_data[IBT_APR_PRIV_DATA_SZ];
						/* Private data */
} ibcm_apr_msg_t;


/*
 * CM SIDR_REQ Message structure
 *
 * NOTE: SIDR_REQ and SIDR_REP messages are conditionally required.
 * These are needed if non-management services are provided on the Channel
 * Adapter other than fixed QPNs. Management services include those
 * provided thru Subnet Manager Packets or thru General Management Packets.
 *
 * SIDR_REQ requests that the recipient return the information necessary
 * to communicate via UD messages with the entity specified by
 * SIDR_REQ:ServiceID
 */
typedef struct ibcm_sidr_req_msg_s {
	uint32_t	sidr_req_request_id;		/* Request id */
	ib_pkey_t	sidr_req_pkey;			/* P_Key */
	uint8_t		sidr_req_reserved[2];		/* Reserved */
	ib_svc_id_t	sidr_req_service_id;		/* Service Id */
	uint8_t		sidr_req_private_data[IBT_SIDR_REQ_PRIV_DATA_SZ];
							/* Private Data */
} ibcm_sidr_req_msg_t;


/*
 * CM SIDR_REP Message structure
 *
 * SIDR_REP returns the information necessary to communicate via UD
 * messages with the entity specified by SIDR_REQ:ServiceID
 */
typedef struct ibcm_sidr_rep_msg_s {
	uint32_t	sidr_rep_request_id;		/* Request id */
	uint8_t		sidr_rep_rep_status;		/* Status */
	uint8_t		sidr_rep_add_info_len;		/* Length of Add Info */
	uint8_t		sidr_rep_reserved1[2];		/* Reserved */
	uint32_t	sidr_rep_qpn_plus;		/* QPN_24 RSV_8 */
	/* since the 64-bit SID is not aligned, treat it as a byte array */
	uint8_t		sidr_rep_service_id[8];		/* Service Id */
	ib_qkey_t	sidr_rep_qkey;			/* Q_KEY */
	uint8_t		sidr_rep_class_port_info[IBT_CM_SIDR_CP_LEN];
							/* Class Port Info */
							/* aka., add'l info */
	uint8_t		sidr_rep_private_data[IBT_SIDR_REP_PRIV_DATA_SZ];
							/* Private data */
} ibcm_sidr_rep_msg_t;

typedef struct ibcm_classportinfo_msg_s {
	uint8_t		BaseVersion;		/* ver. of MAD base format */
	uint8_t		ClassVersion;		/* ver. of MAD class format */
	uint16_t	CapabilityMask;		/* capabilities of this class */
	uint32_t	RespTimeValue_plus;	/* reserved : 27 bits */
						/* resptime value : 5 bits */
	uint64_t	RedirectGID_hi;		/* dest gid of redirect msgs */
	uint64_t	RedirectGID_lo;		/* dest gid of redirect msgs */
	uint32_t	RedirectTC_plus;	/* traffic class: 8 bits */
						/* SL: 4 bits */
						/* Flow label: 20 bits */
	ib_lid_t	RedirectLID;		/* dlid for class services */
	ib_pkey_t	RedirectP_Key;		/* p_key for class services */
	uint32_t	RedirectQP_plus;	/* Reserved: 8 bits */
						/* QPN: 24 bits */
	ib_qkey_t	RedirectQ_Key;		/* q_key for class services */
	uint64_t	TrapGID_hi;		/* dest gid of trap msgs */
	uint64_t	TrapGID_lo;		/* dest gid of trap msgs */
	uint32_t	TrapTC_plus;		/* Trap traffic class, etc., */
	ib_lid_t	TrapLID;		/* dlid for traps */
	ib_pkey_t	TrapP_Key;		/* p_key for traps */
	uint32_t	TrapHL_plus;		/* Trap hop limit,etc., */
	ib_qkey_t	TrapQ_Key;		/* q_key for traps */
} ibcm_classportinfo_msg_t;

/* All msgs are readonly on receiving side */
_NOTE(READ_ONLY_DATA(ibcm_req_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_rep_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_mra_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_rej_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_lap_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_apr_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_sidr_req_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_sidr_rep_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_rtu_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_dreq_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_drep_msg_s))
_NOTE(READ_ONLY_DATA(ibcm_classportinfo_msg_s))

/* Prototype definitions for CM implementation functions */

/*
 * The callback from IBMF to CM. This routines calls one of the CM
 * state processing functions depending upon mesg/attribute id
 *
 * ibmf_handle	: IBMF handle on which CM MAD was received
 * pktp		: MAD packet
 * args		: IBMF receive mad callback arg
 */
void	ibcm_recv_cb(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args);

/*
 * Prototypes for CM state transition handling functions
 */

/*
 * The following are the CM state processing functions called on an
 * incoming REQ/REP/RTU/MRA/REJ/DREQ/DREP on active/passive sides
 * (Also handled are SIDR_REP and SIDR_REQ)
 * The brief description of these functions
 *	Search based on CM message fields in CM's HCA entry.
 *	Create/Delete state structures based on incoming message
 *	Handle duplicate messages and state transitions
 *	Set and Cancel timeouts
 *	Handle stale connections
 *	Change CM connection state
 *	Call CM CEP state transition functions to update CEP state
 *	and set CEP attributes
 *
 * INPUTS:
 *	hcap:		- IBMF callback argument
 *	cm_input_mad:	- ibmf message pointer of incoming MAD
 *	cm_mad_addr	- CM MAD address
 *
 * The state transition processing is specified in different functions based
 * on incoming message type rather than as one function because, the CM
 * processing is different for each of them.
 *
 * A global call table is initialized with these function addresses
 * (is defined in ibcm_impl.c), and invoked from ibcm_recv_cb
 * (IBMF's recv callback to CM) based on mesg/attribute id.
 */
void	ibcm_process_req_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_rep_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_rtu_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_dreq_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_drep_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_rej_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_mra_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_apr_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_lap_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad,
	    ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_sidr_req_msg(ibcm_hca_info_t *hcap,
	    uint8_t *cm_input_mad, ibcm_mad_addr_t *cm_mad_addr);
void	ibcm_process_sidr_rep_msg(ibcm_hca_info_t *hcap,
	    uint8_t *cm_input_mad, ibcm_mad_addr_t *cm_mad_addr);

typedef enum ibcm_proceed_error_e {
	IBCM_PROCEED_INVALID_NONE	= 0,
	IBCM_PROCEED_INVALID_EVENT,
	IBCM_PROCEED_INVALID_EVENT_STATE,
	IBCM_PROCEED_INVALID_PRIV_SZ,
	IBCM_PROCEED_INVALID_LAP
} ibcm_proceed_error_t;

/* Encapsulates the information that client returns back from CM callback */
typedef struct ibcm_clnt_reply_info_s {
	ibt_cm_proceed_reply_t	*reply_event;
	void			*priv_data;
	ibt_priv_data_len_t	priv_data_len;
} ibcm_clnt_reply_info_t;

/* Encapsulates the information that UD client returns back from CM callback */
typedef struct ibcm_ud_clnt_reply_info_s {
	ib_qpn_t		ud_qpn;
	ib_qkey_t		ud_qkey;
	ibt_redirect_info_t	*redirect_infop;
	void			*priv_data;
	ibt_priv_data_len_t	priv_data_len;
} ibcm_ud_clnt_reply_info_t;

/*
 * Prototypes for CM CEP state transition handling functions. These are
 * called from CM connection state transition handling functions.
 *
 * The brief description of these functions :
 *	Validate CEP related attributes in the messages
 *	Change CEP state
 *	Set CEP attributes (modify CEP)
 *	Call client/server callback handlers
 *	Fill up the response MADs
 *
 * The arguments are :
 *	statep:		Connection state structure
 *	cm_req/rep/rtu/rej msg : Received CM message
 *	cm_output_mad	: The response CM MAD with some of the fields filled in
 *			  The cm output mad is allocated by CM state transition
 *			  functions and has generic MAD header
 *			  Certain fields like com id, etc., are filled by CM
 *			  connection state transition functions that are above
 */

/* QP state transition function called for an incoming REQ on passive side */
ibcm_status_t	ibcm_cep_state_req(ibcm_state_data_t *statep,
		    ibcm_req_msg_t *cm_req_msg, ibt_cm_reason_t *reason,
		    uint8_t *arej_info_len);

/* Processes QP state machine based on return values from cm handler */
ibcm_status_t	ibcm_process_cep_req_cm_hdlr(ibcm_state_data_t *statep,
		    ibt_cm_status_t cb_status,
		    ibcm_clnt_reply_info_t *clnt_info,
		    ibt_cm_reason_t *reject_reason, uint8_t *arej_len,
		    ibcm_req_msg_t *cm_req_msgp);

/* Processes CM state machine based on return values from ibcm_cep_state_req */
void		ibcm_handle_cep_req_response(ibcm_state_data_t *statep,
		    ibcm_status_t response, ibt_cm_reason_t reject_reason,
		    uint8_t arej_info_len);

/* QP state transition function called for an incoming REP on active side */
ibcm_status_t	ibcm_cep_state_rep(ibcm_state_data_t *statep,
		    ibcm_rep_msg_t *cm_rep_msg, ibt_cm_reason_t *reason,
		    uint8_t *arej_info_len);

/* Processes QP state machine based on return values from cm handler */
ibcm_status_t	ibcm_process_cep_rep_cm_hdlr(ibcm_state_data_t *statep,
		    ibt_cm_status_t cb_status,
		    ibcm_clnt_reply_info_t *clnt_info,
		    ibt_cm_reason_t *reject_reason, uint8_t *arej_len,
		    ibcm_rep_msg_t *cm_rep_msgp);

/* Processes CM state machine based on return values from ibcm_cep_state_rep */
void		ibcm_handle_cep_rep_response(ibcm_state_data_t *statep,
		    ibcm_status_t response, ibt_cm_reason_t reject_reason,
		    uint8_t arej_info_len, ibcm_rep_msg_t *rep_msgp);

/* QP state transition function called for an incoming RTU on passive side */
void	ibcm_cep_state_rtu(ibcm_state_data_t *statep,
	    ibcm_rtu_msg_t *cm_rtu_msg);

/* QP state transition func called for an incoming REJ on active/passive side */
void	ibcm_cep_state_rej(ibcm_state_data_t *statep,
	    ibcm_rej_msg_t *cm_rej_msg, ibcm_conn_state_t rej_state);

/* QP state transition func for an incoming REJ on active side in est state */
void	ibcm_cep_state_rej_est(ibcm_state_data_t *statep);

/*
 * QP state transition function called for an outgoing RTU on active side,
 * after setting CEP to RTS state active/passive side
 */
void	ibcm_cep_send_rtu(ibcm_state_data_t *statep);


/* QP state transition function called for an incoming LAP */
ibcm_status_t	ibcm_cep_state_lap(ibcm_state_data_t *statep,
		    ibcm_lap_msg_t *lap_msg, ibcm_apr_msg_t *apr_msg);

/* Processes QP state machine based on return value from cm handler for LAP */
void		ibcm_process_cep_lap_cm_hdlr(ibcm_state_data_t *statep,
		    ibt_cm_status_t cb_status,
		    ibcm_clnt_reply_info_t *clnt_info,
		    ibcm_lap_msg_t *lap_msg, ibcm_apr_msg_t *apr_msg);

void		ibcm_post_apr_mad(ibcm_state_data_t *statep);

void		ibcm_cep_state_apr(ibcm_state_data_t *statep,
		    ibcm_lap_msg_t *lap_msg, ibcm_apr_msg_t *apr_msg);

/* Processes CM state machine based on return value from cm handler */
void		ibcm_handle_cep_dreq_response(ibcm_state_data_t *statep,
		    void *priv_data, ibt_priv_data_len_t  priv_data_len);

/* Processes CM UD state machine based on return values from cm handler */
void		ibcm_process_sidr_req_cm_hdlr(ibcm_ud_state_data_t *ud_statep,
		    ibt_cm_status_t cb_status,
		    ibcm_ud_clnt_reply_info_t *ud_clnt_info,
		    ibt_sidr_status_t *sidr_status,
		    ibcm_sidr_rep_msg_t *sidr_repp);

void		ibcm_proceed_via_taskq(void *targs);
void		ibcm_ud_proceed_via_taskq(void *targs);

/*
 * Builds the reply MAD address based on "incoming mad addr" that is
 * supplied to it as an arg.
 *	Swaps the source and destination lids in ibmf_addr_info_t
 *	Swaps the source and destination gids in ib_grh_t
 *
 * INPUTS:
 *	incoming_cm_mad_addr	- Address information in the incoming MAD
 *	reply_cm_mad_addr	- Derived address for the reply MAD
 *				  The reply MAD address is derived based
 *				  address information of incoming CM MAD
 */
void	ibcm_build_reply_mad_addr(ibcm_mad_addr_t *incoming_cm_mad_addr,
	    ibcm_mad_addr_t *reply_cm_mad_addr);

/*  Posts RC CM MAD using IBMF */
void	ibcm_post_rc_mad(ibcm_state_data_t *statep, ibmf_msg_t *msgp,
	    ibmf_msg_cb_t post_cb, void *args);

/*  Posts UD CM MAD using IBMF */
void	ibcm_post_ud_mad(ibcm_ud_state_data_t *ud_statep, ibmf_msg_t *msgp,
	    ibmf_msg_cb_t ud_post_cb, void *args);

/*  Posts CM MAD using IBMF */
ibt_status_t	ibcm_post_mad(ibmf_msg_t *msgp, ibcm_mad_addr_t *cm_mad_addr,
	    ibmf_msg_cb_t post_cb, void *args);

/* Post REJ MAD */
void	ibcm_post_rej_mad(ibcm_state_data_t *statep, ibt_cm_reason_t reason,
	    int who, void *addl_rej_info, uint8_t arej_info_len);

/* Post REP MAD */
void	ibcm_post_rep_mad(ibcm_state_data_t *statep);

/* Post RTU MAD */
ibcm_status_t	ibcm_post_rtu_mad(ibcm_state_data_t *statep);

/* Post DREQ MAD */
void	ibcm_post_dreq_mad(void *statep);

/* Post LAP MAD */
void	ibcm_post_lap_mad(ibcm_state_data_t *statep);


/*
 * Posts CM SIDR MAD using IBMF in blocking mode
 *
 * INPUTS:
 *	ud_statep:	UD statep which is posting the mad
 *	cm_mad_addr:	Address information for the MAD to be posted
 *	status:		SIDR status
 */
void	ibcm_post_sidr_rep_mad(ibcm_ud_state_data_t *ud_statep,
	    ibt_sidr_status_t status);

/* prototypes to resend RC mad and UD MAD */
void	ibcm_resend_rep_mad(ibcm_state_data_t *statep);
void	ibcm_resend_rtu_mad(ibcm_state_data_t *statep);
void	ibcm_resend_rej_mad(ibcm_state_data_t *statep);
void	ibcm_resend_mra_mad(ibcm_state_data_t *statep);
void	ibcm_resend_srep_mad(ibcm_ud_state_data_t *statep);


/* Helper function used in connection abort processing */
void	ibcm_process_abort(ibcm_state_data_t	*statep);

/*
 * Prototypes for CM functions that lookup for a connection state structure
 */

/*
 * ibcm_lookup_msg:
 *
 * Retrieves an existing state structure or creates a new one if none found.
 * This function is used during passive side of connection establishment for
 * INCOMING REQ/REJ/RTU/MRA
 * This function is used during active side of connection establishment for
 * INCOMING REP/REJ/MRA
 * This function is used during active side of connection establishment for
 * an outgoing REQ.
 *
 * NOTE: IBCM_LOOKP_FAIL is only returned if a new entry wasn't created and
 * a match wasn't found.
 *
 * Arguments are:-
 *	ibcm_event_type_t	- what type of message
 *				  incoming REQ, REP, REJ, MRA, RTU, DREQ, DREP
 *	local_comid		- ONLY *NOT* valid for incoming REQ.
 *					needed for others
 *	remote_qpn		- Remote CM's QP number
 *	remote_hca_guid		- ONLY VALID FOR incoming REQ.
 *				  Ignored for others
 *	hcap			- HCA entry table pointer
 *	statep			- "return"ed state pointer
 *
 * Return Values:
 *	IBCM_LOOKUP_NEW		- new statep allocated
 *	IBCM_LOOKUP_EXISTS	- found an existing entry
 *	IBCM_LOOKUP_FAIL	- failed to find an entry
 *	IBCM_MEMORY_FAILURE	- failed to get memory
 *					iff flags != IBT_CHAN_BLOCKING
 */
ibcm_status_t	ibcm_lookup_msg(ibcm_event_type_t event_type,
		    ib_com_id_t local_comid, ib_qpn_t remote_qpn,
		    ib_guid_t remote_hca_guid, ibcm_hca_info_t *hcap,
		    ibcm_state_data_t **statep);


/*
 * Routines for CM SIDR state structure list manipulation
 * Wherever possible, the list routines of ibtl are used
 * for list manipulation
 */

/*
 * Finds an entry based on lid, gid and grh exists fields
 * lid:		LID of incoming SIDR REQ
 * gid:		GID of incoming SIDR REQ
 * grh_exists:		TRUE if GRH exists in the incoming SIDR REQ
 * hcap:	CM State HCA entry ptr to search for SIDR state structure
 * statep:	Returns a valid state structure, if one exists based
 *		on lid, gid and grh_exists fields
 * flag:	whether to just look OR to look and add if it doesn't exist.
 */
ibcm_status_t		ibcm_find_sidr_entry(ibcm_sidr_srch_t *srch_param,
			    ibcm_hca_info_t *hcap,
			    ibcm_ud_state_data_t **statep,
			    ibcm_lookup_flag_t flag);

ibcm_ud_state_data_t	*ibcm_add_sidr_entry(ibcm_sidr_srch_t *srch_param,
			    ibcm_hca_info_t *hcap);

/*
 * Deletes a given state structure, from both hca state and passive trees
 * If ref cnt is zero, deallocates all buffers and memory of state data
 */
void	ibcm_delete_state_data(ibcm_state_data_t *statep);

/*
 * Deallocates all the buffers and memory of state data.
 * This function must be called, only when ref_cnt is zero.
 */
void	ibcm_dealloc_state_data(ibcm_state_data_t *statep);

/*
 * Deletes a given UD state structure, from SIDR list.
 * The routine acquires and releases the SIDR list lock.
 */
void	ibcm_delete_ud_state_data(ibcm_ud_state_data_t *statep);
void	ibcm_dealloc_ud_state_data(ibcm_ud_state_data_t *statep);

/*
 * Service ID entry create and lookup functions
 */

/*
 * Adds/looks-up an ibcm_svc_info_t entry in the CM's global table.
 * This global table is defined in ibcm_impl.c.
 *
 * svc_info_list_lock must be held for RW_READER by caller of
 * ibcm_find_svc_entry().
 *
 * Arguments are:-
 *	sid		- service id
 *	num_sids	- Number (Range) of service-ids
 *
 * Return values:
 *	Pointer to ibcm_svc_info_t on success, otherwise NULL.
 */
int ibcm_svc_compare(const void *p1, const void *p2);
ibcm_svc_info_t *ibcm_create_svc_entry(ib_svc_id_t sid, int num_sids);
ibcm_svc_info_t *ibcm_find_svc_entry(ib_svc_id_t sid);

/*
 * The following are the function prototypes for various id initialization,
 * allocation, free and destroy operations. The cm id allocations are based
 * on vmem operations
 * The service id's are maintained globally per host
 * The com id and req id's are maintained per hca
 * To maintain compatibility with intel, service ids are allocated on a 32 bit
 * range, though spec has 64 bit range for service id's
 */
ibcm_status_t	ibcm_init_ids();
void		ibcm_fini_ids();

ibcm_status_t	ibcm_init_hca_ids(ibcm_hca_info_t *hcap);
void		ibcm_fini_hca_ids(ibcm_hca_info_t *hcap);

ibcm_status_t	ibcm_alloc_comid(ibcm_hca_info_t *hcap, ib_com_id_t *comid);
void		ibcm_free_comid(ibcm_hca_info_t *hcap, ib_com_id_t comid);

ibcm_status_t	ibcm_alloc_reqid(ibcm_hca_info_t *hcap, uint32_t *reqid);
void		ibcm_free_reqid(ibcm_hca_info_t *hcap, uint32_t reqid);

ib_svc_id_t	ibcm_alloc_local_sids(int num_sids);
void		ibcm_free_local_sids(ib_svc_id_t service_id, int num_sids);

ib_svc_id_t	ibcm_alloc_ip_sid();
void		ibcm_free_ip_sid(ib_svc_id_t sid);

uint64_t	ibcm_generate_tranid(uint8_t event, uint32_t id,
		    uint32_t cm_tran_priv);

void		ibcm_decode_tranid(uint64_t tran_id, uint32_t *cm_tran_priv);

ibcm_status_t	ibcm_ar_init(void);
ibcm_status_t	ibcm_ar_fini(void);

/* IP Addressing API debugging */
extern int ibcm_printip;	/* set to 1 to enable IBTF DPRINTFs */
extern void ibcm_ip_print(char *label, ibt_ip_addr_t *ipa);

#define	IBCM_PRINT_IP(LABEL, IP_ADDR)			\
	if (ibcm_printip) {			\
		ibcm_ip_print(LABEL, IP_ADDR);	\
	}
/*
 * These functions are called to do timeout processing from CM connection
 * state transitions. (Also for SIDR REQ and SIDR REP processing)
 *
 * Brief description :
 *	If retry count is below max retry value, then post the stored response
 *	MAD using IBMF in blocking mode, adjusts remaining retry counters.
 *	If retry counter reaches max value, then retry failure handling is
 *	done here
 *
 *	CM will ensure that the state data structure of the associated
 *	timeout is valid when this timeout function is called.
 *	(See timer_stored_state in ibcm_state_data_t and
 *	ud_timer_stored_state in ibcm_ud_state_data_t)
 */
void	ibcm_timeout_cb(void *arg);
void	ibcm_sidr_timeout_cb(void *arg);

/*
 * function prototypes for IBMF send completion callbacks on non-blocking
 * MAD posts
 */
void	ibcm_post_req_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);
void	ibcm_post_rep_wait_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);	/* MRA Rcvd on active side */
void	ibcm_post_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);
void	ibcm_resend_post_rep_complete(ibmf_handle_t ibmf_handle,
	    ibmf_msg_t *msgp, void *args);
void	ibcm_post_mra_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);	/* MRA Rcvd on passive side */
void	ibcm_post_rej_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);
void	ibcm_post_dreq_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);
void	ibcm_post_drep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);
void	ibcm_post_lap_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);
void	ibcm_post_apr_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);
void	ibcm_post_stored_apr_complete(ibmf_handle_t ibmf_handle,
	    ibmf_msg_t *msgp, void *args);
void	ibcm_post_mra_lap_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);	/* MRA Rcvd for LAP on active side */
void	ibcm_post_mra_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);	/* for MRA sender */
void	ibcm_post_rtu_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp,
	    void *args);

void	ibcm_post_sidr_req_complete(ibmf_handle_t ibmf_handle,
	    ibmf_msg_t *msgp, void *args);

/*
 * ibcm_find_hca_entry:
 *	Given a HCA's GUID find out ibcm_hca_info_t entry for that HCA
 *	This entry can be then used to access AVL tree/SIDR list etc.
 *
 *	NOTE: This entry is not removed from the "ibcm_hca_listp".
 *	And this function is called with ibcm_hca_list_mutex mutex held.
 *
 * INPUTS:
 *	hca_guid	- HCA's guid
 *
 * RETURN VALUE:
 *	hcap		- if a match is found, else NULL
 */
ibcm_hca_info_t	*ibcm_find_hca_entry(ib_guid_t hca_guid);
ibcm_hca_info_t	*ibcm_find_hcap_entry(ib_guid_t hca_guid);
void ibcm_delete_hca_entry(ibcm_hca_info_t *hcap);

/* Routines that manage the hca's temporary access count */
ibcm_status_t ibcm_inc_hca_acc_cnt(ibcm_hca_info_t *hca);
void ibcm_dec_hca_acc_cnt(ibcm_hca_info_t *hca);

/* Routines that manage the hca's resource count */
void ibcm_inc_hca_res_cnt(ibcm_hca_info_t *hca);
void ibcm_dec_hca_res_cnt(ibcm_hca_info_t *hca);

/* Routines that manage the hca's service count */
void ibcm_inc_hca_svc_cnt(ibcm_hca_info_t *hca);
void ibcm_dec_hca_svc_cnt(ibcm_hca_info_t *hca);

/* Routine to fetch the saa_handle */
ibmf_saa_handle_t ibcm_get_saa_handle(ibcm_hca_info_t *hcap, uint8_t port);

/* Allow some flow control of RC connection initiations */
void ibcm_flow_inc(void);
void ibcm_flow_dec(hrtime_t delta, char *mad_type);

/* Allow some flow control of SA requests */
void ibcm_sa_access_enter(void);
void ibcm_sa_access_exit(void);

/*
 * ibcm_cep_to_error_state:
 *	Helper function to transition a CEP to ERROR state
 *
 *	NOTE: This function checks if ch_qp is valid or ch_eec and calls
 *	into IBTL to transition the CEP.
 *
 * INPUTS:
 *	statep	- Connection state pointer
 *
 * RETURN VALUE:
 *	IBT_SUCCESS	- if CEP transition succeeded; else error
 */
ibt_status_t	ibcm_cep_to_error_state(ibcm_state_data_t *statep);

/*
 * Processes the pending stateps in a linked list. The operations are to
 * invoke a cm handler or delete statep
 * When the above operations are required on statep from a timeout handler,
 * they are linked for later processing by an independent thread
 */
void	ibcm_process_tlist();
/* Links RC stateps to an RC timeout processing list */
void	ibcm_add_tlist(ibcm_state_data_t *statep);

/* Links SIDR/UD stateps to an SIDR/UD timeout processing list */
void	ibcm_add_ud_tlist(ibcm_ud_state_data_t *ud_statep);

/*
 * This call either aborts a pending or completes a in-progress LAP/APR
 * operation
 */
void	ibcm_sync_lapr_idle(ibcm_state_data_t	*statep);

void	ibcm_process_rc_recycle(void *recycle_arg);

/*
 * Helper function to handle endianess in case of Service Data.
 * Used by ibt_bind_service() and ibt_get_paths().
 */
void ibcm_swizzle_from_srv(ibt_srv_data_t *sb_data, uint8_t *service_bytes);
void ibcm_swizzle_to_srv(uint8_t *service_bytes, ibt_srv_data_t *sb_data);

/* Misc ibcm global variables */
extern char			cmlog[];
extern ibt_clnt_hdl_t		ibcm_ibt_handle;
extern taskq_t			*ibcm_taskq;
extern ibcm_state_handler_t	ibcm_sm_funcs_tbl[];
extern uint8_t			ibcm_timeout_list_flags;
extern ibcm_classportinfo_msg_t	ibcm_clpinfo;

/* Global lists */
extern avl_tree_t	ibcm_svc_avl_tree;	/* global service id tree */
extern ibcm_state_data_t	*ibcm_timeout_list_hdr, *ibcm_timeout_list_tail;
extern ibcm_ud_state_data_t	*ibcm_ud_timeout_list_hdr,
				*ibcm_ud_timeout_list_tail;
/* Default global retry counts */
extern uint8_t		ibcm_max_retries;
extern uint32_t		ibcm_max_sa_retries;
extern int		ibcm_sa_timeout_delay;	/* in ticks */

/* Various default global timers */
extern ibt_rnr_nak_time_t	ibcm_default_rnr_nak_time;

extern clock_t		ibcm_local_processing_time;	/* usecs */
extern clock_t		ibcm_remote_response_time;
extern ib_time_t	ibcm_max_sidr_rep_proctime;
extern ib_time_t	ibcm_max_sidr_rep_store_time;
extern uint32_t		ibcm_adj_btime;
extern uint32_t		ibcm_sw_delay;

extern ib_time_t	ibcm_max_ib_pkt_lt;
extern ib_time_t	ibcm_max_ib_mad_pkt_lt;

/* Global locks */
extern kmutex_t		ibcm_svc_info_lock;
extern kmutex_t		ibcm_mcglist_lock;
extern kmutex_t		ibcm_global_hca_lock;
extern kmutex_t		ibcm_qp_list_lock;
extern kmutex_t		ibcm_timeout_list_lock;
extern kmutex_t		ibcm_recv_mutex;

/* Global cond variables */
extern kcondvar_t	ibcm_global_hca_cv;
extern kcondvar_t	ibcm_svc_info_cv;
extern kcondvar_t	ibcm_timeout_list_cv;
extern kcondvar_t	ibcm_timeout_thread_done_cv;

_NOTE(LOCK_ORDER(ibcm_state_data_s::state_mutex ibcm_timeout_list_lock))
_NOTE(LOCK_ORDER(ibcm_ud_state_data_s::ud_state_mutex ibcm_timeout_list_lock))
_NOTE(LOCK_ORDER(ibcm_hca_info_s::hca_state_rwlock
    ibcm_state_data_s::state_mutex))
_NOTE(LOCK_ORDER(ibcm_hca_info_s::hca_sidr_list_lock
    ibcm_ud_state_data_s::ud_state_mutex))

_NOTE(READ_ONLY_DATA(ibcm_local_processing_time ibcm_remote_response_time
    ibcm_max_sidr_rep_proctime ibcm_max_sidr_rep_store_time ibcm_adj_btime
    ibcm_sw_delay ibcm_max_retries ibcm_max_sa_retries))

/*
 * miscellaneous defines for retries, times etc.
 */
#define	IBCM_MAX_RETRIES		11	/* Max CM retries for a msg */
#define	IBCM_LOCAL_RESPONSE_TIME	300000	/* Local CM processing time */
						/* in usecs */
#define	IBCM_REMOTE_RESPONSE_TIME	300000	/* Remote CM response time  */
						/* in usecs */
#define	IBCM_MAX_SIDR_PROCESS_TIME	16	/* Time to process SIDR REP */
#define	IBCM_MAX_SIDR_PKT_LIFE_TIME	9	/* Approx pkt lt for UD srver */

#define	IBCM_MAX_IB_PKT_LT		20	/* 4 second */
#define	IBCM_MAX_IB_MAD_PKT_LT		18	/* 1 second */

#define	IBCM_MAX_SA_RETRIES		0	/* Max CM retry for SA update */

/* versions for CM MADs */
#define	IBCM_MAD_BASE_VERSION		1
#define	IBCM_MAD_CLASS_VERSION		2

/* for Class_Port_Info stuff - see section 16.7.3.1 in Vol1 IB Spec */
#define	IBCM_CPINFO_CAP_RC		0x0200	/* RC is supported */
#define	IBCM_CPINFO_CAP_RD		0x0400	/* RD is supported */
#define	IBCM_CPINFO_CAP_RAW		0x0800	/* Raw Datagrams supported */
#define	IBCM_CPINFO_CAP_UC		0x1000	/* UC supported */
#define	IBCM_CPINFO_CAP_SIDR		0x2000	/* SIDR supported */

#define	IBCM_V4_PART_OF_V6(v6)	v6.s6_addr32[3]
/* RDMA CM IP Service's Private Data Format. */
#ifdef _BIG_ENDIAN
typedef struct ibcm_ip_pvtdata_s {
	uint8_t		ip_MajV:4,
			ip_MinV:4;
	uint8_t		ip_ipv:4,
			ip_rsvd:4;	/* 0-3: rsvd, 4-7: ipv */
	uint16_t	ip_srcport;	/* Source Port */
	in6_addr_t	ip_srcip;	/* Source IP address. */
	in6_addr_t	ip_dstip;	/* Remote IP address. */
#define	ip_srcv4	IBCM_V4_PART_OF_V6(ip_srcip)
#define	ip_dstv4	IBCM_V4_PART_OF_V6(ip_dstip)
#define	ip_srcv6	ip_srcip
#define	ip_dstv6	ip_dstip
} ibcm_ip_pvtdata_t;
#else
typedef struct ibcm_ip_pvtdata_s {
	uint8_t		ip_MinV:4,
			ip_MajV:4;
	uint8_t		ip_rsvd:4,
			ip_ipv:4;	/* 0-3: rsvd, 4-7: ipv */
	uint16_t	ip_srcport;	/* Source Port */
	in6_addr_t	ip_srcip;	/* Source IP address. */
	in6_addr_t	ip_dstip;	/* Remote IP address. */
#define	ip_srcv4	IBCM_V4_PART_OF_V6(ip_srcip)
#define	ip_dstv4	IBCM_V4_PART_OF_V6(ip_dstip)
#define	ip_srcv6	ip_srcip
#define	ip_dstv6	ip_dstip
} ibcm_ip_pvtdata_t;
#endif

/*
 * for debug purposes
 */
#ifdef	DEBUG
extern	int ibcm_test_mode;

void	ibcm_query_qp(ibmf_handle_t ibmf_hdl, ibmf_qp_handle_t ibmf_qp);
void	ibcm_dump_raw_message(uchar_t *);
void	ibcm_dump_srvrec(sa_service_record_t *);
void	ibcm_dump_pathrec(sa_path_record_t *);
void	ibcm_dump_noderec(sa_node_record_t *);

void	ibcm_query_classport_info(ibt_channel_hdl_t channel);

#define	IBCM_DUMP_RAW_MSG(x)		ibcm_dump_raw_message(x)
#define	IBCM_DUMP_SERVICE_REC(x)	ibcm_dump_srvrec(x)
#define	IBCM_DUMP_PATH_REC(x)		ibcm_dump_pathrec(x)
#define	IBCM_DUMP_NODE_REC(x)		ibcm_dump_noderec(x)
#else
#define	IBCM_DUMP_RAW_MSG(x)
#define	IBCM_DUMP_SERVICE_REC(x)
#define	IBCM_DUMP_PATH_REC(x)
#define	IBCM_DUMP_NODE_REC(x)
#endif

ibt_status_t ibcm_ibmf_analyze_error(int ibmf_status);

ibt_status_t ibcm_contact_sa_access(ibmf_saa_handle_t saa_handle,
    ibmf_saa_access_args_t *access_args, size_t *length, void **results_p);

ibt_status_t	ibcm_ibtl_node_info(ib_guid_t, uint8_t, ib_lid_t,
    ibt_node_info_t *node_info);

void ibcm_path_cache_init(void);
void ibcm_path_cache_fini(void);
void ibcm_path_cache_purge(void);

#ifdef	__cplusplus
}
#endif


#endif /* _SYS_IB_MGT_IBCM_IBCM_IMPL_H */