/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _DAPL_IF_H_
#define _DAPL_IF_H_

#ifdef __cplusplus
extern "C" {
#endif

/* change this "version" everytime the interface changes */
#define DAPL_IF_VERSION                 (0x05302007)

#define DAPL_IOC                        (0x0da9 << 16)
#define DAPL_TYPE_IA                    (DAPL_IOC | 0x11 << 8)
#define DAPL_TYPE_EVD                   (DAPL_IOC | 0x12 << 8)
#define DAPL_TYPE_EP                    (DAPL_IOC | 0x13 << 8)
#define DAPL_TYPE_MR                    (DAPL_IOC | 0x14 << 8)
#define DAPL_TYPE_PD                    (DAPL_IOC | 0x15 << 8)
#define DAPL_TYPE_SP                    (DAPL_IOC | 0x16 << 8)
#define DAPL_TYPE_CNO                   (DAPL_IOC | 0x17 << 8)
#define DAPL_TYPE_MW                    (DAPL_IOC | 0x18 << 8)
#define DAPL_TYPE_MISC                  (DAPL_IOC | 0x19 << 8)
#define DAPL_TYPE_SRQ                   (DAPL_IOC | 0x1a << 8)
#define DAPL_TYPE_NONE                  (DAPL_IOC | 0x1f << 8)
#define DAPL_TYPE_MASK                  (0xffffff00)

/* NONE */
#define DAPL_IA_CREATE                  (DAPL_TYPE_NONE | 0x01)

/* MISC */
#define DAPL_CR_ACCEPT                  (DAPL_TYPE_MISC | 0x01)
#define DAPL_CR_REJECT                  (DAPL_TYPE_MISC | 0x02)
#define DAPL_IA_QUERY                   (DAPL_TYPE_MISC | 0x03)
#define DAPL_CR_HANDOFF                 (DAPL_TYPE_MISC | 0x04)

/* EP */
#define DAPL_EP_CREATE                  (DAPL_TYPE_EP | 0x01)
#define DAPL_EP_FREE                    (DAPL_TYPE_EP | 0x02)
#define DAPL_EP_CONNECT                 (DAPL_TYPE_EP | 0x03)
#define DAPL_EP_MODIFY                  (DAPL_TYPE_EP | 0x04)
#define DAPL_EP_DISCONNECT              (DAPL_TYPE_EP | 0x05)
#define DAPL_EP_REINIT                  (DAPL_TYPE_EP | 0x06)

/* EVD */
#define DAPL_EVD_CREATE                 (DAPL_TYPE_EVD | 0x01)
#define DAPL_CQ_RESIZE                  (DAPL_TYPE_EVD | 0x02)
#define DAPL_EVD_FREE                   (DAPL_TYPE_EVD | 0x03)
#define DAPL_EVENT_POLL                 (DAPL_TYPE_EVD | 0x04)
#define DAPL_EVENT_WAKEUP               (DAPL_TYPE_EVD | 0x05)
#define DAPL_EVD_MODIFY_CNO             (DAPL_TYPE_EVD | 0x06)

/* MR */
#define DAPL_MR_REGISTER                (DAPL_TYPE_MR | 0x01)
#define DAPL_MR_REGISTER_LMR            (DAPL_TYPE_MR | 0x02)
#define DAPL_MR_REGISTER_SHARED         (DAPL_TYPE_MR | 0x03)
#define DAPL_MR_DEREGISTER              (DAPL_TYPE_MR | 0x04)
#define DAPL_MR_SYNC                    (DAPL_TYPE_MR | 0x05)

/* MW */
#define DAPL_MW_ALLOC                   (DAPL_TYPE_MW | 0x01)
#define DAPL_MW_FREE                    (DAPL_TYPE_MW | 0x02)

/* CNO */
#define DAPL_CNO_ALLOC                  (DAPL_TYPE_CNO | 0x01)
#define DAPL_CNO_FREE                   (DAPL_TYPE_CNO | 0x02)
#define DAPL_CNO_WAIT                   (DAPL_TYPE_CNO | 0x03)

/* PD */
#define DAPL_PD_ALLOC                   (DAPL_TYPE_PD | 0x01)
#define DAPL_PD_FREE                    (DAPL_TYPE_PD | 0x02)

/* SP */
#define DAPL_SERVICE_REGISTER           (DAPL_TYPE_SP | 0x01)
#define DAPL_SERVICE_DEREGISTER         (DAPL_TYPE_SP | 0x02)

/* SRQ */
#define DAPL_SRQ_CREATE                 (DAPL_TYPE_SRQ  | 0x01)
#define DAPL_SRQ_FREE                   (DAPL_TYPE_SRQ  | 0x02)
#define DAPL_SRQ_RESIZE                 (DAPL_TYPE_SRQ  | 0x03)

/*
 * Drivers name and minor name.
 */
#define DAPLKA_DRV_NAME         "daplt"
#define DAPLKA_MINOR_NAME       "daplt"
#define DAPLKA_DEFAULT_PATH     "/devices/ib/daplt@0:daplt"
#define DAPLKA_DRIVER_MINOR     0

/*
 * Upper limit on number of events that can be polled per event_poll ioctl
 * Since we allocate memory in kernel there needs to be an upper bound.
 */
#define DAPL_EVD_MAX_EVENTS     16384
/*
 * Number of events that we generally poll for in event_poll.
 */
#define NUM_EVENTS_PER_POLL     16

/* duplicated from dat.h */
#ifndef _DAT_H_
typedef enum dat_evd_flags {
        DAT_EVD_SOFTWARE_FLAG   = 0x01,
        DAT_EVD_CR_FLAG         = 0x10,
        DAT_EVD_DTO_FLAG        = 0x20,
        DAT_EVD_CONNECTION_FLAG = 0x40,
        DAT_EVD_RMR_BIND_FLAG   = 0x80,
        DAT_EVD_ASYNC_FLAG      = 0x100,
        /* DAT events only, no software events */
        DAT_EVD_DEFAULT_FLAG    = 0x1F0
} DAT_EVD_FLAGS;
#endif /* _DAT_H_ */

#define DAPL_MAX_PRIVATE_DATA_SIZE      IBT_MAX_PRIV_DATA_SZ
#define DAPL_ATS_NBYTES                 16      /* SA record data length */

/*
 * All structures defined herein are used for ioctls. On amd64,
 * use pack(4) to make structures match the x86 alignment rules.
 */

#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack(4)
#endif

/*
 *                                    Byte     Offset
 * uDAPL client's private data          64      00
 * Base Sockets Direct Header (BSDH)     4      64
 * Extended Header                              68
 *  Hello Message (HH)                  24
 *
 *   bits       32-24           23-16           15-8    7-0
 * bytes
 * 00-63        uDAPL client's private data
 * 64-67        MID             client_msg_len  checksum
 * 68-72        MajV MinV       IPV             rsvd1
 * 73-75        rsvd2                           LocalPort
 * 76-79        SrcIP(127-96)
 * 80-83        SrcIP(95-64)
 * 84-87        SrcIP(63-32)
 * 88-92        SrcIP(31-00)
 *
 */
typedef union dapl_ia_addr_s {
        struct {
                uint32_t        iad_pad[3];
                struct in_addr  iad_v4data;
        } iad_v4_s;                     /* IPv4 format */
        in6_addr_t      iad_v6data;     /* IPv6 format */
        uint8_t         iad_sadata[DAPL_ATS_NBYTES]; /* SA format */
        uint32_t        iad_src;        /* alignment */
} dapl_ia_addr_t;
#define iad_v4          iad_v4_s.iad_v4data
#define iad_v4pad       iad_v4_s.iad_pad
#define iad_v6          iad_v6data
#define iad_sa          iad_sadata

typedef struct dapl_hello_msg {
        uint16_t        hi_checksum;    /* checksum */
        uint8_t         hi_clen;        /* client private data len */
        uint8_t         hi_mid;         /* command - not use */
        uint16_t        hi_rsvd1;
        uint8_t         hi_ipv;         /* IP family ipv4 or ipv6 */
        uint8_t         hi_vers;        /* hello message version number */
        in_port_t       hi_port;        /* IP port number */
        uint16_t        hi_rsvd2;
        dapl_ia_addr_t  _hi_ipaddr;     /* IP address */
} DAPL_HELLO_MSG;
/* different views of the address field */
#define hi_v4ipaddr     _hi_ipaddr.iad_v4       /* IPv4 */
#define hi_v4pad        _hi_ipaddr.iad_v4pad
#define hi_v6ipaddr     _hi_ipaddr.iad_v6       /* IPv6 */
#define hi_saaddr       _hi_ipaddr.iad_sa       /* 16 bytes SA record */

#define DAPL_CHECKSUM           0xbeef          /* use as magic number */
#define DAPL_HELLO_MSG_VERS     0x10            /* major 1 minor 0 */
/* DAPL_PRIVATE used to pass private data in a connection */
#define DAPL_CONSUMER_MAX_PRIVATE_DATA_SIZE     64
typedef struct dapl_private {
        unsigned char private_data[DAPL_CONSUMER_MAX_PRIVATE_DATA_SIZE];
        DAPL_HELLO_MSG hello_msg;
} DAPL_PRIVATE;

/* EP ioctl interfaces */

/*
 * Definitions used by DAPL for HCA specific "data out" information.  This
 * data is opaque to daplt, and is consumed by HCA specific code in the
 * userland library.
 *
 * The sizes (in units of uint64_t) need to be big enough for all HCAs
 * supported.  Although 16 is large enough, since we never want to have
 * to change our interface version just because we undersized this, we
 * have chosen 24.
 */
#define DAPL_CQ_DATA_OUT_SIZE   24
#define DAPL_QP_DATA_OUT_SIZE   24
#define DAPL_SRQ_DATA_OUT_SIZE  24

typedef uint64_t dapl_cq_data_out_t[DAPL_QP_DATA_OUT_SIZE];
typedef uint64_t dapl_qp_data_out_t[DAPL_CQ_DATA_OUT_SIZE];
typedef uint64_t dapl_srq_data_out_t[DAPL_SRQ_DATA_OUT_SIZE];

/*
 * Channel sizes struct, copy of ibt_chan_sizes_t so that it can work
 * fine for both 32/64 bit library
 */
typedef struct dapl_chan_sizes_s {
        uint_t  dcs_sq;         /* SendQ size. */
        uint_t  dcs_rq;         /* ReceiveQ size. */
        uint_t  dcs_sq_sgl;     /* Max SGL elements in a SQ WR. */
        uint_t  dcs_rq_sgl;     /* Max SGL elements in a RQ Wr. */
} dapl_chan_sizes_t;

/*
 * EP create ioctl message structure
 */
typedef struct dapl_ep_create_s {
        uint64_t                ep_hkey;          /* hash key of the EP */
        uint64_t                ep_pd_hkey;       /* PD hash key */
        uint64_t                ep_rcv_evd_hkey;  /* Recv evd hash key */
        uint64_t                ep_snd_evd_hkey;  /* Send evd hash key */
        uint64_t                ep_conn_evd_hkey; /* Conn evd hash key */
        uint64_t                ep_srq_hkey;      /* SRQ hash key       */
        uint32_t                ep_srq_attached;  /* EP with SRQ - 1 or 0 */
        uint64_t                ep_cookie;        /* Userland EP pointer */
        dapl_chan_sizes_t       ep_ch_sizes;      /* Requested RC params */
        dapl_chan_sizes_t       ep_ch_real_sizes; /* Allocated RC params */
        dapl_qp_data_out_t      ep_qp_data_out;
} dapl_ep_create_t;

/*
 * Modify is not yet completely implemented
 */
typedef struct dapl_ep_modify_s {
        uint64_t                epm_hkey;
        ibt_cep_modify_flags_t  epm_flags;
        uint8_t                 epm_rdma_ra_out;
        uint8_t                 epm_rdma_ra_in;
} dapl_ep_modify_t;

/*
 * EP Connect ioctl message
 */
typedef struct dapl_ep_connect_s {
        uint64_t                epc_hkey;       /* EP hash key          */
        ib_gid_t                epc_dgid;       /* destination gid      */
        uint64_t                epc_sid;        /* service id           */
        uint64_t                epc_timeout;    /* timeout              */
        uint32_t                epc_priv_sz;    /* private data size    */
        dapl_ia_addr_t          epc_raddr_sadata; /* remote addr in SA format */
        uchar_t                 epc_priv[DAPL_MAX_PRIVATE_DATA_SIZE];
} dapl_ep_connect_t;

typedef struct dapl_ep_disconnect_s {
        uint64_t                epd_hkey;       /* EP hash key */
} dapl_ep_disconnect_t;

/*
 * EP reinit ioctl called to recycle the RC
 */
typedef struct dapl_ep_reinit_s {
        uint64_t                epri_hkey;       /* EP hash key */
        uint64_t                epri_map_offset; /* Mapping offset of new QP */
        uint64_t                epri_map_len;    /* Map len of new QP   */
        uint32_t                epri_qpnum;      /* QPnum of the new QP */
        uint32_t                epri_rq_offset;  /* New RecvQ offset in buf */
        uint32_t                epri_rq_desc_addr; /* New RecvQ kernel addr */
        uint32_t                epri_rq_numwqe;
        uint32_t                epri_rq_wqesz;
        uint32_t                epri_sq_offset;  /* New SendQ offset in buf */
        uint32_t                epri_sq_desc_addr; /* New SendQ kernel addr */
        uint32_t                epri_sq_numwqe;
        uint32_t                epri_sq_wqesz;
} dapl_ep_reinit_t;

typedef struct dapl_ep_free_s {
        uint64_t                epf_hkey;       /* EP hash key */
} dapl_ep_free_t;

/* EVD ioctl interfaces */

/*
 * EVD create ioctl
 */
typedef struct dapl_evd_create_s {
        uint64_t                evd_hkey;       /* EVD hash key */
        DAT_EVD_FLAGS           evd_flags;      /* EVD streams flag */
        uint64_t                evd_cookie;     /* userland EVD pointer */
        uint64_t                evd_cno_hkey;   /* CNO hash key */
        uint32_t                evd_cq_size;    /* Requested CQ Size */
        uint32_t                evd_cq_real_size;  /* Allocated CQ size */
        dapl_cq_data_out_t      evd_cq_data_out;
} dapl_evd_create_t;

/*
 * If an EVD has a CQ this ioctl message is used to resize the CQ
 */
typedef struct dapl_cq_resize_s {
        uint64_t                cqr_evd_hkey;     /* EVD hash key */
        uint32_t                cqr_cq_new_size;  /* New requested CQ size */
        uint32_t                cqr_cq_real_size; /* Allocated CQ size */
        dapl_cq_data_out_t      cqr_cq_data_out;
} dapl_cq_resize_t;

/*
 * Event type used while returning events from the kernel
 */
typedef enum {
        /* event family for the Async events */
        DAPL_ASYNC_EVENTS = 0x01,
        /* event family for events posted by the PASSIVE side cm_handler */
        DAPL_CR_EVENTS = 0x02,
        /* event family for events posted by the PASSIVE side cm_handler */
        DAPL_PASSIVE_CONNECTION_EVENTS = 0x04,
        /* event family for events posted by the ACTIVE side cm_handler */
        DAPL_ACTIVE_CONNECTION_EVENTS = 0x08
} dapl_event_family_t;

/*
 * Async event structure
 */
typedef struct dapl_ib_async_event_s {
        ibt_async_code_t        ibae_type;
        ib_guid_t               ibae_hca_guid; /* HCA node GUID */
        uint64_t                ibae_cookie; /* ep or cq pointer */
        uint8_t                 ibae_port; /* HCA Port num unaffiliated evnt */
} dapl_ib_async_event_t;

/*
 * CM events definitions used to translate IBTF CM events to DAPL CM events
 */
typedef enum {
        /* IBT_CM_EVENT_CONN_EST */
        DAPL_IB_CME_CONNECTED = 1,
        /* IBT_CM_EVENT_CONN_CLOSED */
        DAPL_IB_CME_DISCONNECTED,
        /* IBT_CM_EVENT_REQ_RCV */
        DAPL_IB_CME_CONNECTION_REQUEST_PENDING,
        DAPL_IB_CME_CONNECTION_REQUEST_PENDING_PRIVATE_DATA,
        /* IBT_CM_EVENT_FAILURE */
        DAPL_IB_CME_DESTINATION_REJECT,
        DAPL_IB_CME_DESTINATION_REJECT_PRIVATE_DATA,
        /* Currently not mapped to IBTF CM events */
        DAPL_IB_CME_DESTINATION_UNREACHABLE,
        DAPL_IB_CME_TOO_MANY_CONNECTION_REQUESTS,
        DAPL_IB_CME_LOCAL_FAILURE,
        DAPL_IB_CME_TIMED_OUT,
        DAPL_IB_CME_DISCONNECTED_ON_LINK_DOWN,
        /*
         * Not really a CM event but library uses CM events as reject reasons
         * so to avoid any overlaps, make it part of this enum
         */
        DAPL_IB_CM_REJ_REASON_CONSUMER_REJ
} dapl_ib_cm_event_type_t;

/*
 * CM event structure
 */
typedef struct dapl_ib_cm_event_s {
        dapl_ib_cm_event_type_t ibce_event;
        /* Userland PSP ptr for CR, EP ptr for CONNECTION */
        uint64_t                ibce_cookie;
        /* Unique CR cookie: tmstamp + Index in the connection pending table */
        uint64_t                ibce_psep_cookie;
        uint32_t                ibce_priv_data_size;
        uchar_t                 ibce_priv_data_ptr[DAPL_MAX_PRIVATE_DATA_SIZE];
} dapl_ib_cm_event_t;

/*
 * Kernel Events structure used for returning CM or Async events
 */
typedef struct dapl_ib_event_s {
        dapl_event_family_t     ibe_ev_family;
        union {
                dapl_ib_async_event_t   ibe_async; /* Async event */
                dapl_ib_cm_event_t      ibe_ce;    /* CM event    */
        } ev_data;
#define ibe_async       ev_data.ibe_async
#define ibe_ce          ev_data.ibe_ce
} dapl_ib_event_t;

/*
 * Event poll ioctl message
 */
typedef struct dapl_event_poll_s {
        uint64_t                evp_evd_hkey;  /* EVD hash key          */
        uint64_t                evp_timeout;   /* Timeout value         */
        uint_t                  evp_threshold; /* Threshold passed in   */
        dapl_ib_event_t         *evp_ep;    /* array of events to be filled */
        uint_t                  evp_num_ev; /* array sz, possbly > threshold */
        uint_t                  evp_num_polled; /* number of elements filled */
} dapl_event_poll_t;

/*
 * Event poll ioctl message
 */
typedef struct dapl_event_poll32_s {
        uint64_t                evp_evd_hkey;  /* EVD hash key          */
        uint64_t                evp_timeout;   /* Timeout value         */
        uint_t                  evp_threshold; /* Threshold passed in   */
        caddr32_t               evp_ep;    /* array of events to be filled */
        uint_t                  evp_num_ev; /* array sz, possbly > threshold */
        uint_t                  evp_num_polled; /* number of elements filled */
} dapl_event_poll32_t;

/*
 * EVD hash key to wakeup
 */
typedef struct dapl_event_wakeup_s {
        uint64_t                evw_hkey;       /* EVD hash key */
} dapl_event_wakeup_t;

/*
 * modify EVD to CNO association
 */
typedef struct dapl_evd_modify_cno_s {
        uint64_t                evmc_hkey;      /* EVD hash key */
        uint64_t                evmc_cno_hkey;  /* new CNO hash key */
} dapl_evd_modify_cno_t;


/*
 * EVD hash key to free
 */
typedef struct dapl_evd_free_s {
        uint64_t                evf_hkey;       /* EVD hash key */
} dapl_evd_free_t;

/* MR ioctl interfaces */

/*
 * MR register ioctl message
 */
typedef struct dapl_mr_register_s {
        uint64_t                mr_hkey;    /* MR hash key               */
        uint64_t                mr_pd_hkey; /* PD hash key               */
        ib_vaddr_t              mr_vaddr; /* Virtual address to register */
        ib_memlen_t             mr_len;   /* Length of region to register */
        ibt_mr_flags_t          mr_flags;
        ibt_lkey_t              mr_lkey;  /* Lkey returned from mr_register */
        ibt_rkey_t              mr_rkey;  /* Rkey returned from mr_register */
} dapl_mr_register_t;

/*
 * Shared MR cookie
 */
typedef union dapl_mr_cookie_u {
        uint64_t                mc_uint_arr[5];
        uchar_t                 mc_byte_arr[40];
} dapl_mr_cookie_t;

/*
 * Shared MR register ioctl message
 */
typedef struct dapl_mr_register_shared_s {
        uint64_t                mrs_hkey;    /* MR hash key              */
        uint64_t                mrs_pd_hkey; /* PD hash key              */
        ib_vaddr_t              mrs_vaddr; /* Virtual address to register */
        ib_memlen_t             mrs_len;   /* Length of region to register */
        ibt_mr_flags_t          mrs_flags;
        ibt_lkey_t              mrs_lkey;  /* Lkey returned from mr_register */
        ibt_rkey_t              mrs_rkey;  /* Rkey returned from mr_register */
        dapl_mr_cookie_t        mrs_shm_cookie; /* shared mem cookie */
} dapl_mr_register_shared_t;

/*
 * MR based MR register ioctl message
 */
typedef struct dapl_mr_register_lmr_s {
        uint64_t                mrl_hkey; /* MR hash key */
        uint64_t                mrl_orig_hkey; /* hash key of Original MR */
        ibt_mr_flags_t          mrl_flags;
        ibt_lkey_t              mrl_lkey; /* Lkey returned from mr_register */
        ibt_rkey_t              mrl_rkey; /* Rkey returned from mr_register */
} dapl_mr_register_lmr_t;

/*
 * MR deregister ioctl message
 */
typedef struct dapl_mr_deregister_s {
        uint64_t                mrd_hkey; /* MR hash key */
} dapl_mr_deregister_t;

/*
 * MR RDMA sync ioctl message
 */

#define DAPL_MR_PER_SYNC 16
#define DAPL_MR_SYNC_RDMA_RD 0
#define DAPL_MR_SYNC_RDMA_WR 1

typedef struct dapl_mr_sync_vec_s {
        uint64_t        mrsv_hkey;      /* MR hash key */
        uint64_t        mrsv_va;        /* MR sync virtual addr */
        uint64_t        mrsv_len;       /* MR sync length */
} dapl_mr_sync_vec_t;

typedef struct dapl_mr_sync_s {
        uint32_t                mrs_flags;      /* MR sync direction */
        uint64_t                mrs_numseg;     /* number of MR's */
        dapl_mr_sync_vec_t      mrs_vec[DAPL_MR_PER_SYNC]; /* sync elements */
} dapl_mr_sync_t;

/* IA ioctl interfaces */

/*
 * IA create ioctl message
 */
typedef struct dapl_ia_create_s {
        uint32_t                ia_version; /* ioctl interface version  */
        ib_guid_t               ia_guid;    /* HCA guid                 */
        uint32_t                ia_port;    /* port number              */
        uint32_t                ia_pkey;    /* pkey of the ibd instance */
        uint32_t                ia_resnum;  /* resource num in resrc table */
        uint8_t                 ia_sadata[DAPL_ATS_NBYTES]; /* SA data record */
} dapl_ia_create_t;

/*
 * This structure is pretty much a copy of ibt_hca_attr_t but only
 * relevant fields are present and the data types are such that
 * its safe to use it in both in 32 and 64 bit libraries
 * For detailed description refer to ibt_hca_attr_t in ibtl_types.h
 */
typedef struct dapl_hca_attr_s {
        uint32_t        dhca_vendor_id:24;
        uint16_t        dhca_device_id;
        uint32_t        dhca_version_id;
        uint_t          dhca_max_chans;
        uint_t          dhca_max_chan_sz;
        uint_t          dhca_max_sgl;
        uint_t          dhca_max_cq;
        uint_t          dhca_max_cq_sz;
        uint_t          dhca_max_memr;
        ib_memlen_t     dhca_max_memr_len;
        uint_t          dhca_max_mem_win;
        uint8_t         dhca_max_rdma_in_chan;
        uint8_t         dhca_max_rdma_out_chan;
        uint16_t        dhca_max_partitions;
        uint8_t         dhca_nports;
        ib_guid_t       dhca_node_guid;
        uint_t          dhca_max_pd;
        uint_t          dhca_max_srqs;
        uint_t          dhca_max_srqs_sz;
        uint_t          dhca_max_srq_sgl;
} dapl_hca_attr_t;

/*
 * IA query ioctl message
 */
typedef struct dapl_ia_query_s {
        dapl_hca_attr_t         hca_attr;
} dapl_ia_query_t;

#define DAPL_MAX_IA     64
/*
 * IA enum ioctl message
 */
typedef struct dapl_ia_enum_s {
        uint32_t                ia_count;       /* number of IAs */
        uint16_t                ia_devnum[DAPL_MAX_IA]; /* devnum of IAs */
} dapl_ia_enum_t;

/* PD ioctl interfaces */

typedef struct dapl_pd_alloc_s {
        uint64_t                pda_hkey;
} dapl_pd_alloc_t;

typedef struct dapl_pd_free_s {
        uint64_t                pdf_hkey;
} dapl_pd_free_t;

/* MW ioctl interfaces */

typedef struct dapl_mw_alloc_s {
        uint64_t                mw_pd_hkey;
        uint64_t                mw_hkey;
        ibt_rkey_t              mw_rkey;
} dapl_mw_alloc_t;

typedef struct dapl_mw_free_s {
        uint64_t                mw_hkey;
} dapl_mw_free_t;

/* Passive Side ioctl interfaces */

/*
 * Service register ioctl message
 */
typedef struct dapl_service_register_s {
        ib_svc_id_t             sr_sid;         /* Requested service id */
        uint64_t                sr_evd_hkey;    /* CR EVD hash key      */
        uint64_t                sr_sp_hkey;     /* SP hash key          */
        uint64_t                sr_sp_cookie;   /* Userland xSP ptr     */
        ib_svc_id_t             sr_retsid;      /* Returned service id  */
} dapl_service_register_t;

/*
 * Service deregister ioctl message
 */
typedef struct dapl_service_deregister_s {
        uint64_t                sdr_sp_hkey;
} dapl_service_deregister_t;

/*
 * Connection request accept ioctl message
 */
typedef struct dapl_cr_accept_s {
        uint64_t        cra_sp_hkey;    /* xSP hash key */
        uint64_t        cra_ep_hkey;    /* EP hash key */
        uint64_t        cra_bkl_cookie; /* CR timestamp + SP backlog index */
        uint32_t        cra_priv_sz;    /* private data and size */
        uchar_t         cra_priv[DAPL_MAX_PRIVATE_DATA_SIZE];
} dapl_cr_accept_t;

/*
 * Connection request reject ioctl message
 */
typedef struct dapl_cr_reject_s {
        uint64_t        crr_sp_hkey;    /* xSP hash key */
        uint64_t        crr_bkl_cookie;  /* CR timestamp + SP backlog index */
        int             crr_reason;     /* Reason for rejecting the CR */
} dapl_cr_reject_t;

/*
 * Connection request handoff ioctl message
 */
typedef struct dapl_cr_handoff_s {
        uint64_t        crh_sp_hkey;    /* xSP hash key */
        uint64_t        crh_bkl_cookie;  /* CR timestamp + SP backlog index */
        ib_svc_id_t     crh_conn_qual;  /* Service id of destination SP */
} dapl_cr_handoff_t;

/* CNO ioctl interfaces */

/*
 * CNO alloc ioctl message
 */
typedef struct dapl_cno_alloc_s {
        uint64_t        cno_hkey;       /* CNO hash key */
} dapl_cno_alloc_t;

/*
 * CNO free ioctl message
 */
typedef struct dapl_cno_free_s {
        uint64_t        cnf_hkey;       /* CNO hash key */
} dapl_cno_free_t;

/*
 * CNO wait ioctl message
 */
typedef struct dapl_cno_wait_s {
        uint64_t        cnw_hkey;       /* CNO hash key */
        uint64_t        cnw_timeout;    /* CNO timeout */
        uint64_t        cnw_evd_cookie;
} dapl_cno_wait_t;

/*
 * SRQ related structures
 */
typedef struct dapl_srq_sizes_s {
        uint_t  srqs_sz;
        uint_t  srqs_sgl;
} dapl_srq_sizes_t;

/*
 * SRQ create ioctl message
 */
typedef struct dapl_srq_create_s {
        uint64_t                srqc_pd_hkey;   /* hash key of the assoc PD */
        dapl_srq_sizes_t        srqc_sizes;     /* Requested SRQ params */
        uint64_t                srqc_hkey;      /* hash key of allocated SRQ */
        dapl_srq_sizes_t        srqc_real_sizes; /* Allocated SRQ params */
        dapl_srq_data_out_t     srqc_data_out;
} dapl_srq_create_t;

/*
 * SRQ resize ioctl message
 */
typedef struct dapl_srq_resize_s {
        uint64_t                srqr_hkey;      /* hash key of the SRQ */
        uint32_t                srqr_new_size;  /* New SRQ size         */
        uint32_t                srqr_real_size; /* Actual SRQ size      */
        dapl_srq_data_out_t     srqr_data_out;
} dapl_srq_resize_t;

/*
 * SRQ free ioctl message
 */
typedef struct dapl_srq_free_s {
        uint64_t        srqf_hkey; /* hash key of the SRQ being freed */
} dapl_srq_free_t;

#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack()
#endif

#ifdef __cplusplus
}
#endif

#endif  /* _DAPL_IF_H_ */