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