include/sys/ib/adapters/hermon/hermon_wr.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #ifndef _SYS_IB_ADAPTERS_HERMON_WR_H
  28 #define _SYS_IB_ADAPTERS_HERMON_WR_H
  29
  30 /*
  31  * hermon_wr.h
  32  *    Contains all of the prototypes, #defines, and structures necessary
  33  *    for the Hermon Work Request Processing Routines
  34  *    Specifically it contains #defines, macros, and prototypes for each of
  35  *    building each of the various types of WQE and for managing the WRID
  36  *    tracking mechanisms.
  37  */
  38
  39 #include <sys/types.h>
  40 #include <sys/conf.h>
  41 #include <sys/ddi.h>
  42 #include <sys/sunddi.h>
  43
  44 #ifdef __cplusplus
  45 extern "C" {
  46 #endif
  47
  48 /*
  49  * WQEADDRSZ is a bit of a misnomer, it's really a token for the
  50  * WRID processing.  We simply use the wqe_counter.
  51  */
  52 #define HERMON_QP_WQEADDRSZ(wcnt, qpn)  (wcnt) & 0xFFFF
  53
  54 /* And put the get from the CQ here as well     */
  55 #define HERMON_CQE_WQEADDRSZ_GET(cq, cqe)                               \
  56         ((uint32_t)((((uint8_t *)(cqe))[0x18]) << 8) | ((uint8_t *)(cqe))[0x19])
  57
  58
  59 /*
  60  * The following macro sets the owner bit in the Control Segment of the
  61  * WQE, based on the wqe_counter value passed in
  62  */
  63 #define HERMON_SET_SEND_WQE_OWNER(qp, desc, opcode)                     \
  64         *(uint32_t *)desc = htonl((((*(uint8_t *)desc & 0x80) ^ 0x80) << 24) | \
  65             opcode);
  66
  67 /*
  68  * The following macros are used to calculate pointers to the Send or Receive
  69  * (or SRQ) WQEs on a given QP, respectively
  70  */
  71 #define HERMON_QP_SQ_ENTRY(qp, tail)                                    \
  72         ((uint64_t *)((uintptr_t)((qp)->qp_sq_buf) +                    \
  73         ((tail) << (qp)->qp_sq_log_wqesz)))
  74 #define HERMON_QP_RQ_ENTRY(qp, tail)                                    \
  75         ((uint64_t *)((uintptr_t)((qp)->qp_rq_buf) +                    \
  76         ((tail) << (qp)->qp_rq_log_wqesz)))
  77 #define HERMON_SRQ_WQ_ENTRY(srq, tail)                                  \
  78         ((uint64_t *)((uintptr_t)((srq)->srq_wq_buf) +                  \
  79         ((tail) << (srq)->srq_wq_log_wqesz)))
  80
  81 /*
  82  * The following macro is used to calculate the 'wqe_index' field during SRQ
  83  * operation.  This returns the index based on the WQE size, that can be used
  84  * to reference WQEs in an SRQ.
  85  */
  86 #define HERMON_SRQ_WQE_INDEX(srq_base_addr, wqe_addr, log_wqesz)        \
  87         (((uint32_t)(uintptr_t)wqe_addr -                               \
  88         (uint32_t)(uintptr_t)srq_base_addr) >> log_wqesz)
  89 /*
  90  * The following macro is used to calculate the 'wqe_addr' during SRQ
  91  * operation.  This returns the addr based on the WQE size and index,
  92  * that can be used to reference WQEs in an SRQ.
  93  */
  94
  95 #define HERMON_SRQ_WQE_ADDR(srq, wqe_index)                             \
  96         ((uint64_t *)((uintptr_t)srq->srq_wq_buf +                      \
  97         (wqe_index << srq->srq_wq_log_wqesz)))
  98
  99 /*
 100  * The following macros are used to access specific fields in Directed Route
 101  * MAD packets.  We can extract the MgmtClass, "hop pointer", and "hop count".
 102  * We can also update the "hop pointer" as appropriate.  Note:  Again, because
 103  * of the limited amount of direct handling the Hermon hardware does on special
 104  * QP request (specifically on Directed Route MADs), the driver needs to
 105  * update (as necessary) the "hop pointer" value depending on whether a MAD
 106  * is outbound or inbound (i.e. depending on the relationship between "hop
 107  * pointer" and "hop count" in the given MAD)
 108  */
 109 #define HERMON_SPECIAL_QP_DRMAD_GET_MGMTCLASS(mgmtclass, offset, va, len) \
 110         if (((mgmtclass) == NULL) && ((offset) + (len) > 1)) {           \
 111             (mgmtclass) = &((uint8_t *)(uintptr_t)(va))[1 - (offset)];   \
 112         }
 113 #define HERMON_SPECIAL_QP_DRMAD_GET_HOPPOINTER(hp, offset, va, len)     \
 114         if (((hp) == NULL) &&                                           \
 115             ((offset) + (len) > 6)) {                                   \
 116             (hp) = &((uint8_t *)(uintptr_t)(va))[6 - (offset)];         \
 117         }
 118 #define HERMON_SPECIAL_QP_DRMAD_GET_HOPCOUNT(hc, offset, va, len)       \
 119         if (((hc) == NULL) &&                                           \
 120             ((offset) + (len) > 7)) {                                   \
 121             (hc) = &((uint8_t *)(uintptr_t)(va))[7 - (offset)];         \
 122         }
 123 #define HERMON_SPECIAL_QP_DRMAD_DO_HOPPOINTER_MODIFY(mgmtclass, hp, hc) \
 124         if ((mgmtclass) == 0x81) {                                      \
 125                 if ((hp) < (hc)) {                                      \
 126                         (hp) = (hp) + 1;                                \
 127                 } else if ((hp) > (hc)) {                               \
 128                         (hp) = (hp) - 1;                                \
 129                 }                                                       \
 130         }
 131
 132 /*
 133  * The hermon_workq_hdr_s structure is used internally by the Hermon driver
 134  * to track the information necessary to manage the work queues (send, recv,
 135  * or shared recv).  The hermon_workq_avl_s is used for each association of
 136  * a work queue with a given completion queue, where SRQs can be associated
 137  * with multiple queue pairs and their associated completion queues.
 138  */
 139 struct hermon_workq_hdr_s {
 140         uint32_t                wq_size;
 141         uint32_t                wq_mask;
 142         ibt_wrid_t              *wq_wrid;
 143         uint32_t                wq_head;
 144         uint32_t                wq_tail;
 145         uint32_t                wq_full;
 146 };
 147
 148 _NOTE(SCHEME_PROTECTS_DATA("safe sharing",
 149     hermon_workq_hdr_s::wq_wrid
 150     hermon_workq_hdr_s::wq_head
 151     hermon_workq_hdr_s::wq_tail
 152     hermon_workq_hdr_s::wq_full))
 153
 154 struct hermon_workq_avl_s {
 155         avl_node_t              wqa_link;
 156         uint32_t                wqa_qpn;
 157         uint32_t                wqa_type;       /* send or recv */
 158         struct hermon_workq_hdr_s *wqa_wq;
 159
 160         /* For SRQ, this is needed to add the wqe to the free list */
 161         uint_t                  wqa_srq_en;
 162         hermon_srqhdl_t         wqa_srq;
 163 };
 164
 165 #define HERMON_WR_RECV                  0x0
 166 #define HERMON_WR_SEND                  0x1
 167 #define HERMON_WR_SRQ                   0x2
 168
 169 extern int hermon_wrid_workq_compare(const void *p1, const void *p2);
 170 typedef struct hermon_workq_compare_s {
 171         uint32_t cmp_type;
 172         uint32_t cmp_qpn;
 173 } hermon_workq_compare_t;
 174
 175 /* For Work Request posting */
 176 int hermon_post_send(hermon_state_t *state, hermon_qphdl_t qphdl,
 177     ibt_send_wr_t *wr_p, uint_t num_wr, uint_t *num_posted);
 178 int hermon_post_recv(hermon_state_t *state, hermon_qphdl_t qphdl,
 179     ibt_recv_wr_t *wr_p, uint_t num_wr, uint_t *num_posted);
 180 int hermon_post_srq(hermon_state_t *state, hermon_srqhdl_t srqhdl,
 181     ibt_recv_wr_t *wr_p, uint_t num_wr, uint_t *num_posted);
 182
 183 /* For WRID handling */
 184 int hermon_wrid_from_reset_handling(hermon_state_t *state, hermon_qphdl_t qp);
 185 int hermon_wrid_to_reset_handling(hermon_state_t *state, hermon_qphdl_t qp);
 186 ibt_wrid_t hermon_wrid_get_entry(hermon_cqhdl_t cqhdl, hermon_hw_cqe_t *cqe);
 187 hermon_workq_hdr_t *hermon_wrid_wqhdr_create(int bufsz);
 188 void hermon_wrid_wqhdr_destroy(hermon_workq_hdr_t *wqhdr);
 189
 190 /* debug routine */
 191 void hermon_check_qp_debug(hermon_state_t *state, hermon_qphdl_t qp);
 192
 193
 194 #ifdef __cplusplus
 195 }
 196 #endif
 197
 198 #endif  /* _SYS_IB_ADAPTERS_HERMON_WR_H */