path: root/drivers/infiniband/hw/amso1100/c2_wr.h

/*
 * Copyright (c) 2005 Ammasso, Inc. All rights reserved.
 * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef _C2_WR_H_
#define _C2_WR_H_

#ifdef CCDEBUG
#define CCWR_MAGIC		0xb07700b0
#endif

#define C2_QP_NO_ATTR_CHANGE 0xFFFFFFFF

/* Maximum allowed size in bytes of private_data exchange
 * on connect.
 */
#define C2_MAX_PRIVATE_DATA_SIZE 200

/*
 * These types are shared among the adapter, host, and CCIL consumer.
 */
enum c2_cq_notification_type {
	C2_CQ_NOTIFICATION_TYPE_NONE = 1,
	C2_CQ_NOTIFICATION_TYPE_NEXT,
	C2_CQ_NOTIFICATION_TYPE_NEXT_SE
};

enum c2_setconfig_cmd {
	C2_CFG_ADD_ADDR = 1,
	C2_CFG_DEL_ADDR = 2,
	C2_CFG_ADD_ROUTE = 3,
	C2_CFG_DEL_ROUTE = 4
};

enum c2_getconfig_cmd {
	C2_GETCONFIG_ROUTES = 1,
	C2_GETCONFIG_ADDRS
};

/*
 *  CCIL Work Request Identifiers
 */
enum c2wr_ids {
	CCWR_RNIC_OPEN = 1,
	CCWR_RNIC_QUERY,
	CCWR_RNIC_SETCONFIG,
	CCWR_RNIC_GETCONFIG,
	CCWR_RNIC_CLOSE,
	CCWR_CQ_CREATE,
	CCWR_CQ_QUERY,
	CCWR_CQ_MODIFY,
	CCWR_CQ_DESTROY,
	CCWR_QP_CONNECT,
	CCWR_PD_ALLOC,
	CCWR_PD_DEALLOC,
	CCWR_SRQ_CREATE,
	CCWR_SRQ_QUERY,
	CCWR_SRQ_MODIFY,
	CCWR_SRQ_DESTROY,
	CCWR_QP_CREATE,
	CCWR_QP_QUERY,
	CCWR_QP_MODIFY,
	CCWR_QP_DESTROY,
	CCWR_NSMR_STAG_ALLOC,
	CCWR_NSMR_REGISTER,
	CCWR_NSMR_PBL,
	CCWR_STAG_DEALLOC,
	CCWR_NSMR_REREGISTER,
	CCWR_SMR_REGISTER,
	CCWR_MR_QUERY,
	CCWR_MW_ALLOC,
	CCWR_MW_QUERY,
	CCWR_EP_CREATE,
	CCWR_EP_GETOPT,
	CCWR_EP_SETOPT,
	CCWR_EP_DESTROY,
	CCWR_EP_BIND,
	CCWR_EP_CONNECT,
	CCWR_EP_LISTEN,
	CCWR_EP_SHUTDOWN,
	CCWR_EP_LISTEN_CREATE,
	CCWR_EP_LISTEN_DESTROY,
	CCWR_EP_QUERY,
	CCWR_CR_ACCEPT,
	CCWR_CR_REJECT,
	CCWR_CONSOLE,
	CCWR_TERM,
	CCWR_FLASH_INIT,
	CCWR_FLASH,
	CCWR_BUF_ALLOC,
	CCWR_BUF_FREE,
	CCWR_FLASH_WRITE,
	CCWR_INIT,		/* WARNING: Don't move this ever again! */



	/* Add new IDs here */



	/*
	 * WARNING: CCWR_LAST must always be the last verbs id defined!
	 *          All the preceding IDs are fixed, and must not change.
	 *          You can add new IDs, but must not remove or reorder
	 *          any IDs. If you do, YOU will ruin any hope of
	 *          compatability between versions.
	 */
	CCWR_LAST,

	/*
	 * Start over at 1 so that arrays indexed by user wr id's
	 * begin at 1.  This is OK since the verbs and user wr id's
	 * are always used on disjoint sets of queues.
	 */
	/*
	 * The order of the CCWR_SEND_XX verbs must
	 * match the order of the RDMA_OPs
	 */
	CCWR_SEND = 1,
	CCWR_SEND_INV,
	CCWR_SEND_SE,
	CCWR_SEND_SE_INV,
	CCWR_RDMA_WRITE,
	CCWR_RDMA_READ,
	CCWR_RDMA_READ_INV,
	CCWR_MW_BIND,
	CCWR_NSMR_FASTREG,
	CCWR_STAG_INVALIDATE,
	CCWR_RECV,
	CCWR_NOP,
	CCWR_UNIMPL,
/* WARNING: This must always be the last user wr id defined! */
};
#define RDMA_SEND_OPCODE_FROM_WR_ID(x)   (x+2)

/*
 * SQ/RQ Work Request Types
 */
enum c2_wr_type {
	C2_WR_TYPE_SEND = CCWR_SEND,
	C2_WR_TYPE_SEND_SE = CCWR_SEND_SE,
	C2_WR_TYPE_SEND_INV = CCWR_SEND_INV,
	C2_WR_TYPE_SEND_SE_INV = CCWR_SEND_SE_INV,
	C2_WR_TYPE_RDMA_WRITE = CCWR_RDMA_WRITE,
	C2_WR_TYPE_RDMA_READ = CCWR_RDMA_READ,
	C2_WR_TYPE_RDMA_READ_INV_STAG = CCWR_RDMA_READ_INV,
	C2_WR_TYPE_BIND_MW = CCWR_MW_BIND,
	C2_WR_TYPE_FASTREG_NSMR = CCWR_NSMR_FASTREG,
	C2_WR_TYPE_INV_STAG = CCWR_STAG_INVALIDATE,
	C2_WR_TYPE_RECV = CCWR_RECV,
	C2_WR_TYPE_NOP = CCWR_NOP,
};

struct c2_netaddr {
	u32 ip_addr;
	u32 netmask;
	u32 mtu;
};

struct c2_route {
	u32 ip_addr;		/* 0 indicates the default route */
	u32 netmask;		/* netmask associated with dst */
	u32 flags;
	union {
		u32 ipaddr;	/* address of the nexthop interface */
		u8 enaddr[6];
	} nexthop;
};

/*
 * A Scatter Gather Entry.
 */
struct c2_data_addr {
	u32 stag;
	u32 length;
	u64 to;
};

/*
 * MR and MW flags used by the consumer, RI, and RNIC.
 */
enum c2_mm_flags {
	MEM_REMOTE = 0x0001,	/* allow mw binds with remote access. */
	MEM_VA_BASED = 0x0002,	/* Not Zero-based */
	MEM_PBL_COMPLETE = 0x0004,	/* PBL array is complete in this msg */
	MEM_LOCAL_READ = 0x0008,	/* allow local reads */
	MEM_LOCAL_WRITE = 0x0010,	/* allow local writes */
	MEM_REMOTE_READ = 0x0020,	/* allow remote reads */
	MEM_REMOTE_WRITE = 0x0040,	/* allow remote writes */
	MEM_WINDOW_BIND = 0x0080,	/* binds allowed */
	MEM_SHARED = 0x0100,	/* set if MR is shared */
	MEM_STAG_VALID = 0x0200	/* set if STAG is in valid state */
};

/*
 * CCIL API ACF flags defined in terms of the low level mem flags.
 * This minimizes translation needed in the user API
 */
enum c2_acf {
	C2_ACF_LOCAL_READ = MEM_LOCAL_READ,
	C2_ACF_LOCAL_WRITE = MEM_LOCAL_WRITE,
	C2_ACF_REMOTE_READ = MEM_REMOTE_READ,
	C2_ACF_REMOTE_WRITE = MEM_REMOTE_WRITE,
	C2_ACF_WINDOW_BIND = MEM_WINDOW_BIND
};

/*
 * Image types of objects written to flash
 */
#define C2_FLASH_IMG_BITFILE 1
#define C2_FLASH_IMG_OPTION_ROM 2
#define C2_FLASH_IMG_VPD 3

/*
 *  to fix bug 1815 we define the max size allowable of the
 *  terminate message (per the IETF spec).Refer to the IETF
 *  protocal specification, section 12.1.6, page 64)
 *  The message is prefixed by 20 types of DDP info.
 *
 *  Then the message has 6 bytes for the terminate control
 *  and DDP segment length info plus a DDP header (either
 *  14 or 18 byts) plus 28 bytes for the RDMA header.
 *  Thus the max size in:
 *  20 + (6 + 18 + 28) = 72
 */
#define C2_MAX_TERMINATE_MESSAGE_SIZE (72)

/*
 * Build String Length.  It must be the same as C2_BUILD_STR_LEN in ccil_api.h
 */
#define WR_BUILD_STR_LEN 64

/*
 * WARNING:  All of these structs need to align any 64bit types on
 * 64 bit boundaries!  64bit types include u64 and u64.
 */

/*
 * Clustercore Work Request Header.  Be sensitive to field layout
 * and alignment.
 */
struct c2wr_hdr {
	/* wqe_count is part of the cqe.  It is put here so the
	 * adapter can write to it while the wr is pending without
	 * clobbering part of the wr.  This word need not be dma'd
	 * from the host to adapter by libccil, but we copy it anyway
	 * to make the memcpy to the adapter better aligned.
	 */
	u32 wqe_count;

	/* Put these fields next so that later 32- and 64-bit
	 * quantities are naturally aligned.
	 */
	u8 id;
	u8 result;		/* adapter -> host */
	u8 sge_count;		/* host -> adapter */
	u8 flags;		/* host -> adapter */

	u64 context;
#ifdef CCMSGMAGIC
	u32 magic;
	u32 pad;
#endif
} __attribute__((packed));

/*
 *------------------------ RNIC ------------------------
 */

/*
 * WR_RNIC_OPEN
 */

/*
 * Flags for the RNIC WRs
 */
enum c2_rnic_flags {
	RNIC_IRD_STATIC = 0x0001,
	RNIC_ORD_STATIC = 0x0002,
	RNIC_QP_STATIC = 0x0004,
	RNIC_SRQ_SUPPORTED = 0x0008,
	RNIC_PBL_BLOCK_MODE = 0x0010,
	RNIC_SRQ_MODEL_ARRIVAL = 0x0020,
	RNIC_CQ_OVF_DETECTED = 0x0040,
	RNIC_PRIV_MODE = 0x0080
};

struct c2wr_rnic_open_req {
	struct c2wr_hdr hdr;
	u64 user_context;
	u16 flags;		/* See enum c2_rnic_flags */
	u16 port_num;
} __attribute__((packed));

struct c2wr_rnic_open_rep {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
} __attribute__((packed));

union c2wr_rnic_open {
	struct c2wr_rnic_open_req req;
	struct c2wr_rnic_open_rep rep;
} __attribute__((packed));

struct c2wr_rnic_query_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
} __attribute__((packed));

/*
 * WR_RNIC_QUERY
 */
struct c2wr_rnic_query_rep {
	struct c2wr_hdr hdr;
	u64 user_context;
	u32 vendor_id;
	u32 part_number;
	u32 hw_version;
	u32 fw_ver_major;
	u32 fw_ver_minor;
	u32 fw_ver_patch;
	char fw_ver_build_str[WR_BUILD_STR_LEN];
	u32 max_qps;
	u32 max_qp_depth;
	u32 max_srq_depth;
	u32 max_send_sgl_depth;
	u32 max_rdma_sgl_depth;
	u32 max_cqs;
	u32 max_cq_depth;
	u32 max_cq_event_handlers;
	u32 max_mrs;
	u32 max_pbl_depth;
	u32 max_pds;
	u32 max_global_ird;
	u32 max_global_ord;
	u32 max_qp_ird;
	u32 max_qp_ord;
	u32 flags;
	u32 max_mws;
	u32 pbe_range_low;
	u32 pbe_range_high;
	u32 max_srqs;
	u32 page_size;
} __attribute__((packed));

union c2wr_rnic_query {
	struct c2wr_rnic_query_req req;
	struct c2wr_rnic_query_rep rep;
} __attribute__((packed));

/*
 * WR_RNIC_GETCONFIG
 */

struct c2wr_rnic_getconfig_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 option;		/* see c2_getconfig_cmd_t */
	u64 reply_buf;
	u32 reply_buf_len;
} __attribute__((packed)) ;

struct c2wr_rnic_getconfig_rep {
	struct c2wr_hdr hdr;
	u32 option;		/* see c2_getconfig_cmd_t */
	u32 count_len;		/* length of the number of addresses configured */
} __attribute__((packed)) ;

union c2wr_rnic_getconfig {
	struct c2wr_rnic_getconfig_req req;
	struct c2wr_rnic_getconfig_rep rep;
} __attribute__((packed)) ;

/*
 * WR_RNIC_SETCONFIG
 */
struct c2wr_rnic_setconfig_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 option;		/* See c2_setconfig_cmd_t */
	/* variable data and pad. See c2_netaddr and c2_route */
	u8 data[0];
} __attribute__((packed)) ;

struct c2wr_rnic_setconfig_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_rnic_setconfig {
	struct c2wr_rnic_setconfig_req req;
	struct c2wr_rnic_setconfig_rep rep;
} __attribute__((packed)) ;

/*
 * WR_RNIC_CLOSE
 */
struct c2wr_rnic_close_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
} __attribute__((packed)) ;

struct c2wr_rnic_close_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_rnic_close {
	struct c2wr_rnic_close_req req;
	struct c2wr_rnic_close_rep rep;
} __attribute__((packed)) ;

/*
 *------------------------ CQ ------------------------
 */
struct c2wr_cq_create_req {
	struct c2wr_hdr hdr;
	u64 shared_ht;
	u64 user_context;
	u64 msg_pool;
	u32 rnic_handle;
	u32 msg_size;
	u32 depth;
} __attribute__((packed)) ;

struct c2wr_cq_create_rep {
	struct c2wr_hdr hdr;
	u32 mq_index;
	u32 adapter_shared;
	u32 cq_handle;
} __attribute__((packed)) ;

union c2wr_cq_create {
	struct c2wr_cq_create_req req;
	struct c2wr_cq_create_rep rep;
} __attribute__((packed)) ;

struct c2wr_cq_modify_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 cq_handle;
	u32 new_depth;
	u64 new_msg_pool;
} __attribute__((packed)) ;

struct c2wr_cq_modify_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_cq_modify {
	struct c2wr_cq_modify_req req;
	struct c2wr_cq_modify_rep rep;
} __attribute__((packed)) ;

struct c2wr_cq_destroy_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 cq_handle;
} __attribute__((packed)) ;

struct c2wr_cq_destroy_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_cq_destroy {
	struct c2wr_cq_destroy_req req;
	struct c2wr_cq_destroy_rep rep;
} __attribute__((packed)) ;

/*
 *------------------------ PD ------------------------
 */
struct c2wr_pd_alloc_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 pd_id;
} __attribute__((packed)) ;

struct c2wr_pd_alloc_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_pd_alloc {
	struct c2wr_pd_alloc_req req;
	struct c2wr_pd_alloc_rep rep;
} __attribute__((packed)) ;

struct c2wr_pd_dealloc_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 pd_id;
} __attribute__((packed)) ;

struct c2wr_pd_dealloc_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_pd_dealloc {
	struct c2wr_pd_dealloc_req req;
	struct c2wr_pd_dealloc_rep rep;
} __attribute__((packed)) ;

/*
 *------------------------ SRQ ------------------------
 */
struct c2wr_srq_create_req {
	struct c2wr_hdr hdr;
	u64 shared_ht;
	u64 user_context;
	u32 rnic_handle;
	u32 srq_depth;
	u32 srq_limit;
	u32 sgl_depth;
	u32 pd_id;
} __attribute__((packed)) ;

struct c2wr_srq_create_rep {
	struct c2wr_hdr hdr;
	u32 srq_depth;
	u32 sgl_depth;
	u32 msg_size;
	u32 mq_index;
	u32 mq_start;
	u32 srq_handle;
} __attribute__((packed)) ;

union c2wr_srq_create {
	struct c2wr_srq_create_req req;
	struct c2wr_srq_create_rep rep;
} __attribute__((packed)) ;

struct c2wr_srq_destroy_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 srq_handle;
} __attribute__((packed)) ;

struct c2wr_srq_destroy_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_srq_destroy {
	struct c2wr_srq_destroy_req req;
	struct c2wr_srq_destroy_rep rep;
} __attribute__((packed)) ;

/*
 *------------------------ QP ------------------------
 */
enum c2wr_qp_flags {
	QP_RDMA_READ = 0x00000001,	/* RDMA read enabled? */
	QP_RDMA_WRITE = 0x00000002,	/* RDMA write enabled? */
	QP_MW_BIND = 0x00000004,	/* MWs enabled */
	QP_ZERO_STAG = 0x00000008,	/* enabled? */
	QP_REMOTE_TERMINATION = 0x00000010,	/* remote end terminated */
	QP_RDMA_READ_RESPONSE = 0x00000020	/* Remote RDMA read  */
	    /* enabled? */
};

struct c2wr_qp_create_req {
	struct c2wr_hdr hdr;
	u64 shared_sq_ht;
	u64 shared_rq_ht;
	u64 user_context;
	u32 rnic_handle;
	u32 sq_cq_handle;
	u32 rq_cq_handle;
	u32 sq_depth;
	u32 rq_depth;
	u32 srq_handle;
	u32 srq_limit;
	u32 flags;		/* see enum c2wr_qp_flags */
	u32 send_sgl_depth;
	u32 recv_sgl_depth;
	u32 rdma_write_sgl_depth;
	u32 ord;
	u32 ird;
	u32 pd_id;
} __attribute__((packed)) ;

struct c2wr_qp_create_rep {
	struct c2wr_hdr hdr;
	u32 sq_depth;
	u32 rq_depth;
	u32 send_sgl_depth;
	u32 recv_sgl_depth;
	u32 rdma_write_sgl_depth;
	u32 ord;
	u32 ird;
	u32 sq_msg_size;
	u32 sq_mq_index;
	u32 sq_mq_start;
	u32 rq_msg_size;
	u32 rq_mq_index;
	u32 rq_mq_start;
	u32 qp_handle;
} __attribute__((packed)) ;

union c2wr_qp_create {
	struct c2wr_qp_create_req req;
	struct c2wr_qp_create_rep rep;
} __attribute__((packed)) ;

struct c2wr_qp_query_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 qp_handle;
} __attribute__((packed)) ;

struct c2wr_qp_query_rep {
	struct c2wr_hdr hdr;
	u64 user_context;
	u32 rnic_handle;
	u32 sq_depth;
	u32 rq_depth;
	u32 send_sgl_depth;
	u32 rdma_write_sgl_depth;
	u32 recv_sgl_depth;
	u32 ord;
	u32 ird;
	u16 qp_state;
	u16 flags;		/* see c2wr_qp_flags_t */
	u32 qp_id;
	u32 local_addr;
	u32 remote_addr;
	u16 local_port;
	u16 remote_port;
	u32 terminate_msg_length;	/* 0 if not present */
	u8 data[0];
	/* Terminate Message in-line here. */
} __attribute__((packed)) ;

union c2wr_qp_query {
	struct c2wr_qp_query_req req;
	struct c2wr_qp_query_rep rep;
} __attribute__((packed)) ;

struct c2wr_qp_modify_req {
	struct c2wr_hdr hdr;
	u64 stream_msg;
	u32 stream_msg_length;
	u32 rnic_handle;
	u32 qp_handle;
	u32 next_qp_state;
	u32 ord;
	u32 ird;
	u32 sq_depth;
	u32 rq_depth;
	u32 llp_ep_handle;
} __attribute__((packed)) ;

struct c2wr_qp_modify_rep {
	struct c2wr_hdr hdr;
	u32 ord;
	u32 ird;
	u32 sq_depth;
	u32 rq_depth;
	u32 sq_msg_size;
	u32 sq_mq_index;
	u32 sq_mq_start;
	u32 rq_msg_size;
	u32 rq_mq_index;
	u32 rq_mq_start;
} __attribute__((packed)) ;

union c2wr_qp_modify {
	struct c2wr_qp_modify_req req;
	struct c2wr_qp_modify_rep rep;
} __attribute__((packed)) ;

struct c2wr_qp_destroy_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 qp_handle;
} __attribute__((packed)) ;

struct c2wr_qp_destroy_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_qp_destroy {
	struct c2wr_qp_destroy_req req;
	struct c2wr_qp_destroy_rep rep;
} __attribute__((packed)) ;

/*
 * The CCWR_QP_CONNECT msg is posted on the verbs request queue.  It can
 * only be posted when a QP is in IDLE state.  After the connect request is
 * submitted to the LLP, the adapter moves the QP to CONNECT_PENDING state.
 * No synchronous reply from adapter to this WR.  The results of
 * connection are passed back in an async event CCAE_ACTIVE_CONNECT_RESULTS
 * See c2wr_ae_active_connect_results_t
 */
struct c2wr_qp_connect_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 qp_handle;
	u32 remote_addr;
	u16 remote_port;
	u16 pad;
	u32 private_data_length;
	u8 private_data[0];	/* Private data in-line. */
} __attribute__((packed)) ;

struct c2wr_qp_connect {
	struct c2wr_qp_connect_req req;
	/* no synchronous reply.         */
} __attribute__((packed)) ;


/*
 *------------------------ MM ------------------------
 */

struct c2wr_nsmr_stag_alloc_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 pbl_depth;
	u32 pd_id;
	u32 flags;
} __attribute__((packed)) ;

struct c2wr_nsmr_stag_alloc_rep {
	struct c2wr_hdr hdr;
	u32 pbl_depth;
	u32 stag_index;
} __attribute__((packed)) ;

union c2wr_nsmr_stag_alloc {
	struct c2wr_nsmr_stag_alloc_req req;
	struct c2wr_nsmr_stag_alloc_rep rep;
} __attribute__((packed)) ;

struct c2wr_nsmr_register_req {
	struct c2wr_hdr hdr;
	u64 va;
	u32 rnic_handle;
	u16 flags;
	u8 stag_key;
	u8 pad;
	u32 pd_id;
	u32 pbl_depth;
	u32 pbe_size;
	u32 fbo;
	u32 length;
	u32 addrs_length;
	/* array of paddrs (must be aligned on a 64bit boundary) */
	u64 paddrs[0];
} __attribute__((packed)) ;

struct c2wr_nsmr_register_rep {
	struct c2wr_hdr hdr;
	u32 pbl_depth;
	u32 stag_index;
} __attribute__((packed)) ;

union c2wr_nsmr_register {
	struct c2wr_nsmr_register_req req;
	struct c2wr_nsmr_register_rep rep;
} __attribute__((packed)) ;

struct c2wr_nsmr_pbl_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 flags;
	u32 stag_index;
	u32 addrs_length;
	/* array of paddrs (must be aligned on a 64bit boundary) */
	u64 paddrs[0];
} __attribute__((packed)) ;

struct c2wr_nsmr_pbl_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_nsmr_pbl {
	struct c2wr_nsmr_pbl_req req;
	struct c2wr_nsmr_pbl_rep rep;
} __attribute__((packed)) ;

struct c2wr_mr_query_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 stag_index;
} __attribute__((packed)) ;

struct c2wr_mr_query_rep {
	struct c2wr_hdr hdr;
	u8 stag_key;
	u8 pad[3];
	u32 pd_id;
	u32 flags;
	u32 pbl_depth;
} __attribute__((packed)) ;

union c2wr_mr_query {
	struct c2wr_mr_query_req req;
	struct c2wr_mr_query_rep rep;
} __attribute__((packed)) ;

struct c2wr_mw_query_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 stag_index;
} __attribute__((packed)) ;

struct c2wr_mw_query_rep {
	struct c2wr_hdr hdr;
	u8 stag_key;
	u8 pad[3];
	u32 pd_id;
	u32 flags;
} __attribute__((packed)) ;

union c2wr_mw_query {
	struct c2wr_mw_query_req req;
	struct c2wr_mw_query_rep rep;
} __attribute__((packed)) ;


struct c2wr_stag_dealloc_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 stag_index;
} __attribute__((packed)) ;

struct c2wr_stag_dealloc_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed)) ;

union c2wr_stag_dealloc {
	struct c2wr_stag_dealloc_req req;
	struct c2wr_stag_dealloc_rep rep;
} __attribute__((packed)) ;

struct c2wr_nsmr_reregister_req {
	struct c2wr_hdr hdr;
	u64 va;
	u32 rnic_handle;
	u16 flags;
	u8 stag_key;
	u8 pad;
	u32 stag_index;
	u32 pd_id;
	u32 pbl_depth;
	u32 pbe_size;
	u32 fbo;
	u32 length;
	u32 addrs_length;
	u32 pad1;
	/* array of paddrs (must be aligned on a 64bit boundary) */
	u64 paddrs[0];
} __attribute__((packed)) ;

struct c2wr_nsmr_reregister_rep {
	struct c2wr_hdr hdr;
	u32 pbl_depth;
	u32 stag_index;
} __attribute__((packed)) ;

union c2wr_nsmr_reregister {
	struct c2wr_nsmr_reregister_req req;
	struct c2wr_nsmr_reregister_rep rep;
} __attribute__((packed)) ;

struct c2wr_smr_register_req {
	struct c2wr_hdr hdr;
	u64 va;
	u32 rnic_handle;
	u16 flags;
	u8 stag_key;
	u8 pad;
	u32 stag_index;
	u32 pd_id;
} __attribute__((packed)) ;

struct c2wr_smr_register_rep {
	struct c2wr_hdr hdr;
	u32 stag_index;
} __attribute__((packed)) ;

union c2wr_smr_register {
	struct c2wr_smr_register_req req;
	struct c2wr_smr_register_rep rep;
} __attribute__((packed)) ;

struct c2wr_mw_alloc_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 pd_id;
} __attribute__((packed)) ;

struct c2wr_mw_alloc_rep {
	struct c2wr_hdr hdr;
	u32 stag_index;
} __attribute__((packed)) ;

union c2wr_mw_alloc {
	struct c2wr_mw_alloc_req req;
	struct c2wr_mw_alloc_rep rep;
} __attribute__((packed)) ;

/*
 *------------------------ WRs -----------------------
 */

struct c2wr_user_hdr {
	struct c2wr_hdr hdr;		/* Has status and WR Type */
} __attribute__((packed)) ;

enum c2_qp_state {
	C2_QP_STATE_IDLE = 0x01,
	C2_QP_STATE_CONNECTING = 0x02,
	C2_QP_STATE_RTS = 0x04,
	C2_QP_STATE_CLOSING = 0x08,
	C2_QP_STATE_TERMINATE = 0x10,
	C2_QP_STATE_ERROR = 0x20,
};

/* Completion queue entry. */
struct c2wr_ce {
	struct c2wr_hdr hdr;		/* Has status and WR Type */
	u64 qp_user_context;	/* c2_user_qp_t * */
	u32 qp_state;		/* Current QP State */
	u32 handle;		/* QPID or EP Handle */
	u32 bytes_rcvd;		/* valid for RECV WCs */
	u32 stag;
} __attribute__((packed)) ;


/*
 * Flags used for all post-sq WRs.  These must fit in the flags
 * field of the struct c2wr_hdr (eight bits).
 */
enum {
	SQ_SIGNALED = 0x01,
	SQ_READ_FENCE = 0x02,
	SQ_FENCE = 0x04,
};

/*
 * Common fields for all post-sq WRs.  Namely the standard header and a
 * secondary header with fields common to all post-sq WRs.
 */
struct c2_sq_hdr {
	struct c2wr_user_hdr user_hdr;
} __attribute__((packed));

/*
 * Same as above but for post-rq WRs.
 */
struct c2_rq_hdr {
	struct c2wr_user_hdr user_hdr;
} __attribute__((packed));

/*
 * use the same struct for all sends.
 */
struct c2wr_send_req {
	struct c2_sq_hdr sq_hdr;
	u32 sge_len;
	u32 remote_stag;
	u8 data[0];		/* SGE array */
} __attribute__((packed));

union c2wr_send {
	struct c2wr_send_req req;
	struct c2wr_ce rep;
} __attribute__((packed));

struct c2wr_rdma_write_req {
	struct c2_sq_hdr sq_hdr;
	u64 remote_to;
	u32 remote_stag;
	u32 sge_len;
	u8 data[0];		/* SGE array */
} __attribute__((packed));

union c2wr_rdma_write {
	struct c2wr_rdma_write_req req;
	struct c2wr_ce rep;
} __attribute__((packed));

struct c2wr_rdma_read_req {
	struct c2_sq_hdr sq_hdr;
	u64 local_to;
	u64 remote_to;
	u32 local_stag;
	u32 remote_stag;
	u32 length;
} __attribute__((packed));

union c2wr_rdma_read {
	struct c2wr_rdma_read_req req;
	struct c2wr_ce rep;
} __attribute__((packed));

struct c2wr_mw_bind_req {
	struct c2_sq_hdr sq_hdr;
	u64 va;
	u8 stag_key;
	u8 pad[3];
	u32 mw_stag_index;
	u32 mr_stag_index;
	u32 length;
	u32 flags;
} __attribute__((packed));

union c2wr_mw_bind {
	struct c2wr_mw_bind_req req;
	struct c2wr_ce rep;
} __attribute__((packed));

struct c2wr_nsmr_fastreg_req {
	struct c2_sq_hdr sq_hdr;
	u64 va;
	u8 stag_key;
	u8 pad[3];
	u32 stag_index;
	u32 pbe_size;
	u32 fbo;
	u32 length;
	u32 addrs_length;
	/* array of paddrs (must be aligned on a 64bit boundary) */
	u64 paddrs[0];
} __attribute__((packed));

union c2wr_nsmr_fastreg {
	struct c2wr_nsmr_fastreg_req req;
	struct c2wr_ce rep;
} __attribute__((packed));

struct c2wr_stag_invalidate_req {
	struct c2_sq_hdr sq_hdr;
	u8 stag_key;
	u8 pad[3];
	u32 stag_index;
} __attribute__((packed));

union c2wr_stag_invalidate {
	struct c2wr_stag_invalidate_req req;
	struct c2wr_ce rep;
} __attribute__((packed));

union c2wr_sqwr {
	struct c2_sq_hdr sq_hdr;
	struct c2wr_send_req send;
	struct c2wr_send_req send_se;
	struct c2wr_send_req send_inv;
	struct c2wr_send_req send_se_inv;
	struct c2wr_rdma_write_req rdma_write;
	struct c2wr_rdma_read_req rdma_read;
	struct c2wr_mw_bind_req mw_bind;
	struct c2wr_nsmr_fastreg_req nsmr_fastreg;
	struct c2wr_stag_invalidate_req stag_inv;
} __attribute__((packed));


/*
 * RQ WRs
 */
struct c2wr_rqwr {
	struct c2_rq_hdr rq_hdr;
	u8 data[0];		/* array of SGEs */
} __attribute__((packed));

union c2wr_recv {
	struct c2wr_rqwr req;
	struct c2wr_ce rep;
} __attribute__((packed));

/*
 * All AEs start with this header.  Most AEs only need to convey the
 * information in the header.  Some, like LLP connection events, need
 * more info.  The union typdef c2wr_ae_t has all the possible AEs.
 *
 * hdr.context is the user_context from the rnic_open WR.  NULL If this
 * is not affiliated with an rnic
 *
 * hdr.id is the AE identifier (eg;  CCAE_REMOTE_SHUTDOWN,
 * CCAE_LLP_CLOSE_COMPLETE)
 *
 * resource_type is one of:  C2_RES_IND_QP, C2_RES_IND_CQ, C2_RES_IND_SRQ
 *
 * user_context is the context passed down when the host created the resource.
 */
struct c2wr_ae_hdr {
	struct c2wr_hdr hdr;
	u64 user_context;	/* user context for this res. */
	u32 resource_type;	/* see enum c2_resource_indicator */
	u32 resource;		/* handle for resource */
	u32 qp_state;		/* current QP State */
} __attribute__((packed));

/*
 * After submitting the CCAE_ACTIVE_CONNECT_RESULTS message on the AEQ,
 * the adapter moves the QP into RTS state
 */
struct c2wr_ae_active_connect_results {
	struct c2wr_ae_hdr ae_hdr;
	u32 laddr;
	u32 raddr;
	u16 lport;
	u16 rport;
	u32 private_data_length;
	u8 private_data[0];	/* data is in-line in the msg. */
} __attribute__((packed));

/*
 * When connections are established by the stack (and the private data
 * MPA frame is received), the adapter will generate an event to the host.
 * The details of the connection, any private data, and the new connection
 * request handle is passed up via the CCAE_CONNECTION_REQUEST msg on the
 * AE queue:
 */
struct c2wr_ae_connection_request {
	struct c2wr_ae_hdr ae_hdr;
	u32 cr_handle;		/* connreq handle (sock ptr) */
	u32 laddr;
	u32 raddr;
	u16 lport;
	u16 rport;
	u32 private_data_length;
	u8 private_data[0];	/* data is in-line in the msg. */
} __attribute__((packed));

union c2wr_ae {
	struct c2wr_ae_hdr ae_generic;
	struct c2wr_ae_active_connect_results ae_active_connect_results;
	struct c2wr_ae_connection_request ae_connection_request;
} __attribute__((packed));

struct c2wr_init_req {
	struct c2wr_hdr hdr;
	u64 hint_count;
	u64 q0_host_shared;
	u64 q1_host_shared;
	u64 q1_host_msg_pool;
	u64 q2_host_shared;
	u64 q2_host_msg_pool;
} __attribute__((packed));

struct c2wr_init_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed));

union c2wr_init {
	struct c2wr_init_req req;
	struct c2wr_init_rep rep;
} __attribute__((packed));

/*
 * For upgrading flash.
 */

struct c2wr_flash_init_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
} __attribute__((packed));

struct c2wr_flash_init_rep {
	struct c2wr_hdr hdr;
	u32 adapter_flash_buf_offset;
	u32 adapter_flash_len;
} __attribute__((packed));

union c2wr_flash_init {
	struct c2wr_flash_init_req req;
	struct c2wr_flash_init_rep rep;
} __attribute__((packed));

struct c2wr_flash_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 len;
} __attribute__((packed));

struct c2wr_flash_rep {
	struct c2wr_hdr hdr;
	u32 status;
} __attribute__((packed));

union c2wr_flash {
	struct c2wr_flash_req req;
	struct c2wr_flash_rep rep;
} __attribute__((packed));

struct c2wr_buf_alloc_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 size;
} __attribute__((packed));

struct c2wr_buf_alloc_rep {
	struct c2wr_hdr hdr;
	u32 offset;		/* 0 if mem not available */
	u32 size;		/* 0 if mem not available */
} __attribute__((packed));

union c2wr_buf_alloc {
	struct c2wr_buf_alloc_req req;
	struct c2wr_buf_alloc_rep rep;
} __attribute__((packed));

struct c2wr_buf_free_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 offset;		/* Must match value from alloc */
	u32 size;		/* Must match value from alloc */
} __attribute__((packed));

struct c2wr_buf_free_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed));

union c2wr_buf_free {
	struct c2wr_buf_free_req req;
	struct c2wr_ce rep;
} __attribute__((packed));

struct c2wr_flash_write_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 offset;
	u32 size;
	u32 type;
	u32 flags;
} __attribute__((packed));

struct c2wr_flash_write_rep {
	struct c2wr_hdr hdr;
	u32 status;
} __attribute__((packed));

union c2wr_flash_write {
	struct c2wr_flash_write_req req;
	struct c2wr_flash_write_rep rep;
} __attribute__((packed));

/*
 * Messages for LLP connection setup.
 */

/*
 * Listen Request.  This allocates a listening endpoint to allow passive
 * connection setup.  Newly established LLP connections are passed up
 * via an AE.  See c2wr_ae_connection_request_t
 */
struct c2wr_ep_listen_create_req {
	struct c2wr_hdr hdr;
	u64 user_context;	/* returned in AEs. */
	u32 rnic_handle;
	u32 local_addr;		/* local addr, or 0  */
	u16 local_port;		/* 0 means "pick one" */
	u16 pad;
	u32 backlog;		/* tradional tcp listen bl */
} __attribute__((packed));

struct c2wr_ep_listen_create_rep {
	struct c2wr_hdr hdr;
	u32 ep_handle;		/* handle to new listening ep */
	u16 local_port;		/* resulting port... */
	u16 pad;
} __attribute__((packed));

union c2wr_ep_listen_create {
	struct c2wr_ep_listen_create_req req;
	struct c2wr_ep_listen_create_rep rep;
} __attribute__((packed));

struct c2wr_ep_listen_destroy_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 ep_handle;
} __attribute__((packed));

struct c2wr_ep_listen_destroy_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed));

union c2wr_ep_listen_destroy {
	struct c2wr_ep_listen_destroy_req req;
	struct c2wr_ep_listen_destroy_rep rep;
} __attribute__((packed));

struct c2wr_ep_query_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 ep_handle;
} __attribute__((packed));

struct c2wr_ep_query_rep {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 local_addr;
	u32 remote_addr;
	u16 local_port;
	u16 remote_port;
} __attribute__((packed));

union c2wr_ep_query {
	struct c2wr_ep_query_req req;
	struct c2wr_ep_query_rep rep;
} __attribute__((packed));


/*
 * The host passes this down to indicate acceptance of a pending iWARP
 * connection.  The cr_handle was obtained from the CONNECTION_REQUEST
 * AE passed up by the adapter.  See c2wr_ae_connection_request_t.
 */
struct c2wr_cr_accept_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 qp_handle;		/* QP to bind to this LLP conn */
	u32 ep_handle;		/* LLP  handle to accept */
	u32 private_data_length;
	u8 private_data[0];	/* data in-line in msg. */
} __attribute__((packed));

/*
 * adapter sends reply when private data is successfully submitted to
 * the LLP.
 */
struct c2wr_cr_accept_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed));

union c2wr_cr_accept {
	struct c2wr_cr_accept_req req;
	struct c2wr_cr_accept_rep rep;
} __attribute__((packed));

/*
 * The host sends this down if a given iWARP connection request was
 * rejected by the consumer.  The cr_handle was obtained from a
 * previous c2wr_ae_connection_request_t AE sent by the adapter.
 */
struct  c2wr_cr_reject_req {
	struct c2wr_hdr hdr;
	u32 rnic_handle;
	u32 ep_handle;		/* LLP handle to reject */
} __attribute__((packed));

/*
 * Dunno if this is needed, but we'll add it for now.  The adapter will
 * send the reject_reply after the LLP endpoint has been destroyed.
 */
struct  c2wr_cr_reject_rep {
	struct c2wr_hdr hdr;
} __attribute__((packed));

union c2wr_cr_reject {
	struct c2wr_cr_reject_req req;
	struct c2wr_cr_reject_rep rep;
} __attribute__((packed));

/*
 * console command.  Used to implement a debug console over the verbs
 * request and reply queues.
 */

/*
 * Console request message.  It contains:
 *	- message hdr with id = CCWR_CONSOLE
 *	- the physaddr/len of host memory to be used for the reply.
 *	- the command string.  eg:  "netstat -s" or "zoneinfo"
 */
struct c2wr_console_req {
	struct c2wr_hdr hdr;		/* id = CCWR_CONSOLE */
	u64 reply_buf;		/* pinned host buf for reply */
	u32 reply_buf_len;	/* length of reply buffer */
	u8 command[0];		/* NUL terminated ascii string */
	/* containing the command req */
} __attribute__((packed));

/*
 * flags used in the console reply.
 */
enum c2_console_flags {
	CONS_REPLY_TRUNCATED = 0x00000001	/* reply was truncated */
} __attribute__((packed));

/*
 * Console reply message.
 * hdr.result contains the c2_status_t error if the reply was _not_ generated,
 * or C2_OK if the reply was generated.
 */
struct c2wr_console_rep {
	struct c2wr_hdr hdr;		/* id = CCWR_CONSOLE */
	u32 flags;
} __attribute__((packed));

union c2wr_console {
	struct c2wr_console_req req;
	struct c2wr_console_rep rep;
} __attribute__((packed));


/*
 * Giant union with all WRs.  Makes life easier...
 */
union c2wr {
	struct c2wr_hdr hdr;
	struct c2wr_user_hdr user_hdr;
	union c2wr_rnic_open rnic_open;
	union c2wr_rnic_query rnic_query;
	union c2wr_rnic_getconfig rnic_getconfig;
	union c2wr_rnic_setconfig rnic_setconfig;
	union c2wr_rnic_close rnic_close;
	union c2wr_cq_create cq_create;
	union c2wr_cq_modify cq_modify;
	union c2wr_cq_destroy cq_destroy;
	union c2wr_pd_alloc pd_alloc;
	union c2wr_pd_dealloc pd_dealloc;
	union c2wr_srq_create srq_create;
	union c2wr_srq_destroy srq_destroy;
	union c2wr_qp_create qp_create;
	union c2wr_qp_query qp_query;
	union c2wr_qp_modify qp_modify;
	union c2wr_qp_destroy qp_destroy;
	struct c2wr_qp_connect qp_connect;
	union c2wr_nsmr_stag_alloc nsmr_stag_alloc;
	union c2wr_nsmr_register nsmr_register;
	union c2wr_nsmr_pbl nsmr_pbl;
	union c2wr_mr_query mr_query;
	union c2wr_mw_query mw_query;
	union c2wr_stag_dealloc stag_dealloc;
	union c2wr_sqwr sqwr;
	struct c2wr_rqwr rqwr;
	struct c2wr_ce ce;
	union c2wr_ae ae;
	union c2wr_init init;
	union c2wr_ep_listen_create ep_listen_create;
	union c2wr_ep_listen_destroy ep_listen_destroy;
	union c2wr_cr_accept cr_accept;
	union c2wr_cr_reject cr_reject;
	union c2wr_console console;
	union c2wr_flash_init flash_init;
	union c2wr_flash flash;
	union c2wr_buf_alloc buf_alloc;
	union c2wr_buf_free buf_free;
	union c2wr_flash_write flash_write;
} __attribute__((packed));


/*
 * Accessors for the wr fields that are packed together tightly to
 * reduce the wr message size.  The wr arguments are void* so that
 * either a struct c2wr*, a struct c2wr_hdr*, or a pointer to any of the types
 * in the struct c2wr union can be passed in.
 */
static __inline__ u8 c2_wr_get_id(void *wr)
{
	return ((struct c2wr_hdr *) wr)->id;
}
static __inline__ void c2_wr_set_id(void *wr, u8 id)
{
	((struct c2wr_hdr *) wr)->id = id;
}
static __inline__ u8 c2_wr_get_result(void *wr)
{
	return ((struct c2wr_hdr *) wr)->result;
}
static __inline__ void c2_wr_set_result(void *wr, u8 result)
{
	((struct c2wr_hdr *) wr)->result = result;
}
static __inline__ u8 c2_wr_get_flags(void *wr)
{
	return ((struct c2wr_hdr *) wr)->flags;
}
static __inline__ void c2_wr_set_flags(void *wr, u8 flags)
{
	((struct c2wr_hdr *) wr)->flags = flags;
}
static __inline__ u8 c2_wr_get_sge_count(void *wr)
{
	return ((struct c2wr_hdr *) wr)->sge_count;
}
static __inline__ void c2_wr_set_sge_count(void *wr, u8 sge_count)
{
	((struct c2wr_hdr *) wr)->sge_count = sge_count;
}
static __inline__ u32 c2_wr_get_wqe_count(void *wr)
{
	return ((struct c2wr_hdr *) wr)->wqe_count;
}
static __inline__ void c2_wr_set_wqe_count(void *wr, u32 wqe_count)
{
	((struct c2wr_hdr *) wr)->wqe_count = wqe_count;
}

#endif				/* _C2_WR_H_ */