docs/how-to-build.md: use proper markup for directory names

[unleashed/tickless.git] / include / sys / ib / adapters / tavor / tavor_qp.h

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

#ifndef _SYS_IB_ADAPTERS_TAVOR_QP_H
#define _SYS_IB_ADAPTERS_TAVOR_QP_H

/*
 * tavor_qp.h
 *    Contains all of the prototypes, #defines, and structures necessary
 *    for all of the Queue Pair Processing routines.
 *    Specifically it contains the various flags, structures used for managing
 *    Tavor queue pairs, and prototypes for many of the functions consumed by
 *    other parts of the Tavor driver (including those routines directly
 *    exposed through the IBTF CI interface).
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

#ifdef __cplusplus
extern "C" {
#endif


/*
 * The following defines specify the default number of Queue Pairs (QP) and
 * their maximum size.  Settings exist for the supported DDR DIMM sizes of
 * 128MB and 256MB.  If a DIMM greater than 256 is found, then the 256MB
 * profile is used.  See tavor_cfg.c for more discussion on config profiles.
 *
 * For manual configuration (not using config profiles), these values are
 * controllable through the "tavor_log_max_qp_sz" and "tavor_log_num_qp"
 * configuration variables, respectively. To override config profile settings
 * the 'tavor_alt_config_enable' configuration variable must first be set.
 *
 * Note: We also have a define for the minimum size of a QP.  QPs allocated
 * with size 0, 1, 2, or 3 will always get back a QP of size 4.  This is the
 * smallest size that Tavor hardware and software can correctly handle.
 */
#define TAVOR_NUM_QP_SHIFT_128          0x10
#define TAVOR_NUM_QP_SHIFT_256          0x11
#define TAVOR_QP_SZ_SHIFT               0x10
#define TAVOR_QP_SZ                     (1 << TAVOR_QP_SZ_SHIFT)
#define TAVOR_QP_MIN_SIZE               0x4

/*
 * Minimal configuration values.
 */
#define TAVOR_NUM_QP_SHIFT_MIN          0xD
#define TAVOR_QP_SZ_SHIFT_MIN           0x9

/*
 * The following macro determines whether the contents of QP memory (WQEs)
 * need to be sync'd (with ddi_dma_sync()).  This decision is based on whether
 * the QP memory is in DDR memory (no sync) or system memory (sync required).
 * And it also supports the possibility that if a CQ in system memory is mapped
 * DDI_DMA_CONSISTENT, it can be configured to not be sync'd because of the
 * "sync override" parameter in the config profile.
 */
#define TAVOR_QP_IS_SYNC_REQ(state, wqinfo)                             \
        ((((((state)->ts_cfg_profile->cp_streaming_consistent) &&       \
        ((state)->ts_cfg_profile->cp_consistent_syncoverride))) ||      \
        ((wqinfo).qa_location == TAVOR_QUEUE_LOCATION_INDDR))           \
        ? 0 : 1)

/*
 * The following defines specify the size of the individual Queue Pair
 * Context (QPC) entries.  Below we also specify the size of the "Extended
 * QPC entries as well.
 */
#define TAVOR_QPC_SIZE_SHIFT            0x8
#define TAVOR_QPC_SIZE                  (1 << TAVOR_QPC_SIZE_SHIFT)
#define TAVOR_EQPC_SIZE_SHIFT           0x5
#define TAVOR_EQPC_SIZE                 (1 << TAVOR_EQPC_SIZE_SHIFT)

/*
 * The following defines specify the default number of Tavor RDMA Backing
 * entries (RDB).  Settings exist for the supported DDR DIMM sizes of 128MB and
 * 256MB.  If a DIMM greater than 256 is found, then the 256MB profile is used.
 * See tavor_cfg.c for more discussion on config profiles.
 *
 * For manual configuration (not using config profiles), this value is
 * controllable through the "tavor_log_num_rdb" configuration variable.  To
 * override config profile settings the 'tavor_alt_config_enable' configuration
 * variable must first be set.
 *
 * Below we also include the defines that are used to specify four (4)
 * outstanding RDMA Reads/Atomics per QP.
 */

#define TAVOR_NUM_RDB_SHIFT_128         0x12
#define TAVOR_NUM_RDB_SHIFT_256         0x13

#define TAVOR_HCA_MAX_RDMA_IN_QP        0x4
#define TAVOR_HCA_MAX_RDMA_OUT_QP       0x4

/*
 * Minimal configuration value.
 */
#define TAVOR_NUM_RDB_SHIFT_MIN         0xC

/*
 * The following defines specify the size of the individual RDMA Backing
 * entries (RDB).
 */
#define TAVOR_RDB_SIZE_SHIFT            0x5
#define TAVOR_RDB_SIZE                  (1 << TAVOR_RDB_SIZE_SHIFT)

/*
 * This defines the maximum number of SGLs per WQE.  This value is
 * controllable through the "tavor_wqe_max_sgl" configuration variable (but
 * should not be set larger than this value).
 */
#define TAVOR_NUM_WQE_SGL               0x10

/* Define for maximum QP number mask (QP number is 24 bits) */
#define TAVOR_QP_MAXNUMBER_MSK          0xFFFFFF

/*
 * This define and the following macro are used to find a schedule queue for
 * a new QP based on its queue pair number.  Note:  This is a rather simple
 * method that we use today.  We simply choose from the schedule queue based
 * on the 4 least significant bits of the QP number.
 */
#define TAVOR_QP_TO_SCHEDQ_MASK         0xF
#define TAVOR_QP_SCHEDQ_GET(qpnum)      ((qpnum) & TAVOR_QP_TO_SCHEDQ_MASK)

/*
 * This define determines the frequency with which the AckReq bit will be
 * set in outgoing RC packets.  By default it is set to five (5) or 2^5 = 32.
 * So AckReq will be set once every 32 packets sent.  This value is
 * controllable through the "tavor_qp_ackreq_freq" configuration variable.
 */
#define TAVOR_QP_ACKREQ_FREQ            0x5

/*
 * Define the maximum message size (log 2).  Note: This value corresponds
 * to the maximum allowable message sized as defined by the IBA spec.
 */
#define TAVOR_QP_LOG_MAX_MSGSZ          0x1F

/*
 * This macro is used to determine the appropriate alignment for a Tavor
 * work queue (see tavor_qp_alloc() and tavor_special_qp_alloc()).  Note:
 * Tavor work queues are aligned on their combined size (i.e. combined size
 * of send queue and receive queue) because of certain hardware limitations
 * (i.e. work queue memory cannot cross a 32-bit boundary).
 */
#define TAVOR_QP_WQ_ALIGN(qp_size)                                      \
        (1 << ((((qp_size) & ((qp_size) - 1)) == 0) ?                   \
        highbit((qp_size)) - 1 : highbit((qp_size))))

/*
 * This macro is used to determine if the tavor known QP type (qp_serv) is the
 * same as the caller passed in IBT type (qp_trans).  This is used in QP modify
 * to ensure the types match.
 */
#define TAVOR_QP_TYPE_VALID(qp_trans, qp_serv)                          \
        ((qp_trans == IBT_UD_SRV && qp_serv == TAVOR_QP_UD) ||          \
        (qp_trans == IBT_RC_SRV && qp_serv == TAVOR_QP_RC) ||           \
        (qp_trans == IBT_UC_SRV && qp_serv == TAVOR_QP_UC))

/*
 * The following enumerated type is used to capture all the various types
 * of Tavor work queue types.  Note: It is specifically used as an argument
 * to the tavor_qp_sgl_to_logwqesz() routine.
 * The defines below are also used by the tavor_qp_sgl_to_logwqesz() routine
 * they indicate the amount of overhead (in WQE header size) consumed by
 * each of the following types of WQEs.  This information is used to round
 * the WQE size to the next largest power-of-2 (and to determine the number
 * of SGLs that are supported for the given WQE type).  There is also a define
 * below used to specify the minimum size for a WQE.  The minimum size is set
 * to 64 bytes (a single cacheline).
 */
typedef enum {
        TAVOR_QP_WQ_TYPE_SENDQ,
        TAVOR_QP_WQ_TYPE_RECVQ,
        TAVOR_QP_WQ_TYPE_SENDMLX_QP0,
        TAVOR_QP_WQ_TYPE_SENDMLX_QP1
} tavor_qp_wq_type_t;
#define TAVOR_QP_WQE_MAX_SIZE           0x3F0
#define TAVOR_QP_WQE_MLX_SND_HDRS       0x40
#define TAVOR_QP_WQE_MLX_RCV_HDRS       0x10
#define TAVOR_QP_WQE_MLX_QP0_HDRS       0x40
#define TAVOR_QP_WQE_MLX_QP1_HDRS       0x70
#define TAVOR_QP_WQE_LOG_MINIMUM        0x6


/*
 * The tavor_qp_info_t structure is used internally by the Tavor driver to
 * pass information to and from the tavor_qp_alloc() and
 * tavor_special_qp_alloc() routines.  It contains placeholders for all of the
 * potential inputs and outputs that either routine can take.
 */
typedef struct tavor_qp_info_s {
        ibt_qp_alloc_attr_t     *qpi_attrp;
        uint_t                  qpi_type;
        uint_t                  qpi_port;
        ibtl_qp_hdl_t           qpi_ibt_qphdl;
        ibt_chan_sizes_t        *qpi_queueszp;
        ib_qpn_t                *qpi_qpn;
        tavor_qphdl_t           qpi_qphdl;
} tavor_qp_info_t;

/*
 * The QPN entry which is stored in the AVL tree
 */
typedef struct tavor_qpn_entry_s {
        avl_node_t              qpn_avlnode;
        uint_t                  qpn_refcnt;
        uint_t                  qpn_counter;
        uint_t                  qpn_indx;
        tavor_rsrc_t            *qpn_qpc;
} tavor_qpn_entry_t;
#define TAVOR_QPN_NOFLAG                0x0
#define TAVOR_QPN_RELEASE               0x1
#define TAVOR_QPN_FREE_ONLY             0x2

/*
 * The tavor_sw_qp_s structure is also referred to using the "tavor_qphdl_t"
 * typedef (see tavor_typedef.h).  It encodes all the information necessary
 * to track the various resources needed to allocate, query, modify, and
 * (later) free both normal QP and special QP.
 *
 * Specifically, it has a lock to ensure single threaded access to the QP.
 * It has QP state, type, and number, pointers to the PD, MR, and CQ handles
 * associated with the QP, and pointers to the buffer where the work queues
 * come from.
 *
 * It has two pointers (one per work queue) to the workQ headers for the WRID
 * list, as well as pointers to the last WQE on each chain (used when
 * connecting a new chain of WQEs to a previously executing chain - see
 * tavor_wr.c).  It's also got the real WQE size, real number of SGL per WQE,
 * and the size of each of the work queues (in number of WQEs).
 *
 * Additionally, it has pointers to the resources associated with the QP
 * (including the obligatory backpointer to the resource for the QP handle
 * itself.  But it also has some flags, like "qp_forward_sqd_event" and
 * "qp_sqd_still_draining" (which are used to indicate whether a Send Queue
 * Drained Event should be forwarded to the IBTF) or "qp_is_special",
 * "qp_portnum", and "qp_pkeyindx" (which are used by special QP to store
 * necessary information about the type of the QP, which port it's connected
 * to, and what its current PKey index is set to).
 */
struct tavor_sw_qp_s {
        kmutex_t                qp_lock;
        uint_t                  qp_state;
        uint32_t                qp_qpnum;
        tavor_pdhdl_t           qp_pdhdl;
        uint_t                  qp_serv_type;
        uint_t                  qp_sync;
        tavor_mrhdl_t           qp_mrhdl;
        uint_t                  qp_sq_sigtype;
        uint_t                  qp_is_special;
        uint_t                  qp_is_umap;
        uint32_t                qp_uarpg;
        devmap_cookie_t         qp_umap_dhp;
        uint_t                  qp_portnum;
        uint_t                  qp_pkeyindx;

        /* Send Work Queue */
        tavor_cqhdl_t           qp_sq_cqhdl;
        uint64_t                *qp_sq_lastwqeaddr;
        tavor_workq_hdr_t       *qp_sq_wqhdr;
        uint32_t                *qp_sq_buf;
        uint32_t                qp_sq_bufsz;
        uint32_t                qp_sq_log_wqesz;
        uint32_t                qp_sq_sgl;

        /* Receive Work Queue */
        tavor_cqhdl_t           qp_rq_cqhdl;
        uint64_t                *qp_rq_lastwqeaddr;
        tavor_workq_hdr_t       *qp_rq_wqhdr;
        uint32_t                *qp_rq_buf;
        uint32_t                qp_rq_bufsz;
        uint32_t                qp_rq_log_wqesz;
        uint32_t                qp_rq_sgl;

        uint64_t                qp_desc_off;

        tavor_rsrc_t            *qp_qpcrsrcp;
        tavor_rsrc_t            *qp_rsrcp;
        void                    *qp_hdlrarg;
        tavor_rsrc_t            *qp_rdbrsrcp;
        uint64_t                qp_rdb_ddraddr;
        uint_t                  qp_forward_sqd_event;
        uint_t                  qp_sqd_still_draining;

        /* Shared Receive Queue */
        tavor_srqhdl_t          qp_srqhdl;
        uint_t                  qp_srq_en;

        /* Refcnt of QP belongs to an MCG */
        uint_t                  qp_mcg_refcnt;

        /* save the mtu & srate from init2rtr for future use */
        uint_t                  qp_save_mtu;
        ibt_srate_t             qp_save_srate;
        tavor_qpn_entry_t       *qp_qpn_hdl;

        struct tavor_qalloc_info_s qp_wqinfo;

        struct tavor_hw_qpc_s qpc;
};
_NOTE(READ_ONLY_DATA(tavor_sw_qp_s::qp_qpnum
    tavor_sw_qp_s::qp_sync
    tavor_sw_qp_s::qp_sq_buf
    tavor_sw_qp_s::qp_sq_log_wqesz
    tavor_sw_qp_s::qp_sq_bufsz
    tavor_sw_qp_s::qp_sq_sgl
    tavor_sw_qp_s::qp_rq_buf
    tavor_sw_qp_s::qp_rq_log_wqesz
    tavor_sw_qp_s::qp_rq_bufsz
    tavor_sw_qp_s::qp_rq_sgl
    tavor_sw_qp_s::qp_desc_off
    tavor_sw_qp_s::qp_mrhdl
    tavor_sw_qp_s::qp_wqinfo
    tavor_sw_qp_s::qp_qpcrsrcp
    tavor_sw_qp_s::qp_rsrcp
    tavor_sw_qp_s::qp_hdlrarg
    tavor_sw_qp_s::qp_pdhdl
    tavor_sw_qp_s::qp_sq_cqhdl
    tavor_sw_qp_s::qp_rq_cqhdl
    tavor_sw_qp_s::qp_sq_sigtype
    tavor_sw_qp_s::qp_serv_type
    tavor_sw_qp_s::qp_is_special
    tavor_sw_qp_s::qp_is_umap
    tavor_sw_qp_s::qp_uarpg
    tavor_sw_qp_s::qp_portnum
    tavor_sw_qp_s::qp_qpn_hdl))
_NOTE(MUTEX_PROTECTS_DATA(tavor_sw_qp_s::qp_lock,
    tavor_sw_qp_s::qp_sq_wqhdr
    tavor_sw_qp_s::qp_sq_lastwqeaddr
    tavor_sw_qp_s::qp_rq_wqhdr
    tavor_sw_qp_s::qp_rq_lastwqeaddr
    tavor_sw_qp_s::qp_state
    tavor_sw_qp_s::qp_rdbrsrcp
    tavor_sw_qp_s::qp_rdb_ddraddr
    tavor_sw_qp_s::qpc
    tavor_sw_qp_s::qp_forward_sqd_event
    tavor_sw_qp_s::qp_sqd_still_draining
    tavor_sw_qp_s::qp_mcg_refcnt
    tavor_sw_qp_s::qp_save_mtu
    tavor_sw_qp_s::qp_umap_dhp))

/*
 * The following defines are used to indicate whether a QP is special or
 * not (and what type it is).  They are used in the "qp_is_special" field
 * above.
 */
#define TAVOR_QP_SMI                    0x1
#define TAVOR_QP_GSI                    0x2

/*
 * The tavor_qp_options_t structure is used in the Tavor QP allocation
 * routines to provide additional option functionality.  When a NULL pointer
 * is passed in place of a pointer to this struct, it is a way of specifying
 * the "default" behavior.  Using this structure, however, is a way of
 * controlling any extended behavior.
 *
 * Currently, the only defined "extended" behavior is for specifying whether
 * a given QP's work queues should be allocated from kernel system memory
 * (TAVOR_QUEUE_LOCATION_NORMAL) or should be allocated from local DDR memory
 * (TAVOR_QUEUE_LOCATION_INDDR).  This defaults today to always allocating
 * from kernel system memory but can be changed by using the
 * "tavor_qp_wq_inddr" configuration variable.
 */
typedef struct tavor_qp_options_s {
        uint_t                  qpo_wq_loc;
} tavor_qp_options_t;


/* Defined in tavor_qp.c */
int tavor_qp_alloc(tavor_state_t *state, tavor_qp_info_t *qpinfo,
    uint_t sleepflag, tavor_qp_options_t *op);
int tavor_special_qp_alloc(tavor_state_t *state, tavor_qp_info_t *qpinfo,
    uint_t sleepflag, tavor_qp_options_t *op);
int tavor_qp_free(tavor_state_t *state, tavor_qphdl_t *qphdl,
    ibc_free_qp_flags_t free_qp_flags, ibc_qpn_hdl_t *qpnh, uint_t sleepflag);
int tavor_qp_query(tavor_state_t *state, tavor_qphdl_t qphdl,
    ibt_qp_query_attr_t *attr_p);
tavor_qphdl_t tavor_qphdl_from_qpnum(tavor_state_t *state, uint_t qpnum);
void tavor_qp_release_qpn(tavor_state_t *state, tavor_qpn_entry_t *entry,
    int flags);
void tavor_qpn_avl_init(tavor_state_t *state);
void tavor_qpn_avl_fini(tavor_state_t *state);

/* Defined in tavor_qpmod.c */
int tavor_qp_modify(tavor_state_t *state, tavor_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p,
    ibt_queue_sizes_t *actual_sz);
int tavor_qp_to_reset(tavor_state_t *state, tavor_qphdl_t qp);

#ifdef __cplusplus
}
#endif

#endif  /* _SYS_IB_ADAPTERS_TAVOR_QP_H */