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