dc544bc9cb
Signed-off-by: Roland Dreier <rolandd@cisco.com> Acked-by: Steve Wise <swise@opengridcomputing.com>
1520 lines
35 KiB
C
1520 lines
35 KiB
C
/*
|
|
* 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 {
|
|
__be32 ip_addr;
|
|
__be32 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 {
|
|
__be32 stag;
|
|
__be32 length;
|
|
__be64 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.
|
|
*/
|
|
__be32 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;
|
|
__be16 flags; /* See enum c2_rnic_flags */
|
|
__be16 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;
|
|
__be32 vendor_id;
|
|
__be32 part_number;
|
|
__be32 hw_version;
|
|
__be32 fw_ver_major;
|
|
__be32 fw_ver_minor;
|
|
__be32 fw_ver_patch;
|
|
char fw_ver_build_str[WR_BUILD_STR_LEN];
|
|
__be32 max_qps;
|
|
__be32 max_qp_depth;
|
|
u32 max_srq_depth;
|
|
u32 max_send_sgl_depth;
|
|
u32 max_rdma_sgl_depth;
|
|
__be32 max_cqs;
|
|
__be32 max_cq_depth;
|
|
u32 max_cq_event_handlers;
|
|
__be32 max_mrs;
|
|
u32 max_pbl_depth;
|
|
__be32 max_pds;
|
|
__be32 max_global_ird;
|
|
u32 max_global_ord;
|
|
__be32 max_qp_ird;
|
|
__be32 max_qp_ord;
|
|
u32 flags;
|
|
__be32 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;
|
|
__be32 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;
|
|
__be64 shared_ht;
|
|
u64 user_context;
|
|
__be64 msg_pool;
|
|
u32 rnic_handle;
|
|
__be32 msg_size;
|
|
__be32 depth;
|
|
} __attribute__((packed)) ;
|
|
|
|
struct c2wr_cq_create_rep {
|
|
struct c2wr_hdr hdr;
|
|
__be32 mq_index;
|
|
__be32 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;
|
|
__be64 shared_sq_ht;
|
|
__be64 shared_rq_ht;
|
|
u64 user_context;
|
|
u32 rnic_handle;
|
|
u32 sq_cq_handle;
|
|
u32 rq_cq_handle;
|
|
__be32 sq_depth;
|
|
__be32 rq_depth;
|
|
u32 srq_handle;
|
|
u32 srq_limit;
|
|
__be32 flags; /* see enum c2wr_qp_flags */
|
|
__be32 send_sgl_depth;
|
|
__be32 recv_sgl_depth;
|
|
__be32 rdma_write_sgl_depth;
|
|
__be32 ord;
|
|
__be32 ird;
|
|
u32 pd_id;
|
|
} __attribute__((packed)) ;
|
|
|
|
struct c2wr_qp_create_rep {
|
|
struct c2wr_hdr hdr;
|
|
__be32 sq_depth;
|
|
__be32 rq_depth;
|
|
u32 send_sgl_depth;
|
|
u32 recv_sgl_depth;
|
|
u32 rdma_write_sgl_depth;
|
|
u32 ord;
|
|
u32 ird;
|
|
__be32 sq_msg_size;
|
|
__be32 sq_mq_index;
|
|
__be32 sq_mq_start;
|
|
__be32 rq_msg_size;
|
|
__be32 rq_mq_index;
|
|
__be32 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;
|
|
__be32 next_qp_state;
|
|
__be32 ord;
|
|
__be32 ird;
|
|
__be32 sq_depth;
|
|
__be32 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;
|
|
__be32 remote_addr;
|
|
__be16 remote_port;
|
|
u16 pad;
|
|
__be32 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;
|
|
__be64 va;
|
|
u32 rnic_handle;
|
|
__be16 flags;
|
|
u8 stag_key;
|
|
u8 pad;
|
|
u32 pd_id;
|
|
__be32 pbl_depth;
|
|
__be32 pbe_size;
|
|
__be32 fbo;
|
|
__be32 length;
|
|
__be32 addrs_length;
|
|
/* array of paddrs (must be aligned on a 64bit boundary) */
|
|
__be64 paddrs[0];
|
|
} __attribute__((packed)) ;
|
|
|
|
struct c2wr_nsmr_register_rep {
|
|
struct c2wr_hdr hdr;
|
|
u32 pbl_depth;
|
|
__be32 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;
|
|
__be32 flags;
|
|
__be32 stag_index;
|
|
__be32 addrs_length;
|
|
/* array of paddrs (must be aligned on a 64bit boundary) */
|
|
__be64 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;
|
|
__be32 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 */
|
|
__be32 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;
|
|
__be32 sge_len;
|
|
__be32 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;
|
|
__be64 remote_to;
|
|
__be32 remote_stag;
|
|
__be32 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;
|
|
__be64 local_to;
|
|
__be64 remote_to;
|
|
__be32 local_stag;
|
|
__be32 remote_stag;
|
|
__be32 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. */
|
|
__be32 resource_type; /* see enum c2_resource_indicator */
|
|
__be32 resource; /* handle for resource */
|
|
__be32 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;
|
|
__be32 laddr;
|
|
__be32 raddr;
|
|
__be16 lport;
|
|
__be16 rport;
|
|
__be32 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) */
|
|
__be32 laddr;
|
|
__be32 raddr;
|
|
__be16 lport;
|
|
__be16 rport;
|
|
__be32 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;
|
|
__be64 hint_count;
|
|
__be64 q0_host_shared;
|
|
__be64 q1_host_shared;
|
|
__be64 q1_host_msg_pool;
|
|
__be64 q2_host_shared;
|
|
__be64 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;
|
|
__be32 local_addr; /* local addr, or 0 */
|
|
__be16 local_port; /* 0 means "pick one" */
|
|
u16 pad;
|
|
__be32 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 */
|
|
__be32 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__ __be32 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_ */
|