1 /*
2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005, 2006 Cisco Systems.  All rights reserved.
4  * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  */
34 
35 #ifndef MTHCA_PROVIDER_H
36 #define MTHCA_PROVIDER_H
37 
38 #include <rdma/ib_verbs.h>
39 #include <rdma/ib_pack.h>
40 
41 #define MTHCA_MPT_FLAG_ATOMIC        (1 << 14)
42 #define MTHCA_MPT_FLAG_REMOTE_WRITE  (1 << 13)
43 #define MTHCA_MPT_FLAG_REMOTE_READ   (1 << 12)
44 #define MTHCA_MPT_FLAG_LOCAL_WRITE   (1 << 11)
45 #define MTHCA_MPT_FLAG_LOCAL_READ    (1 << 10)
46 
47 struct mthca_buf_list {
48 	void *buf;
49 	DEFINE_DMA_UNMAP_ADDR(mapping);
50 };
51 
52 union mthca_buf {
53 	struct mthca_buf_list direct;
54 	struct mthca_buf_list *page_list;
55 };
56 
57 struct mthca_uar {
58 	unsigned long pfn;
59 	int           index;
60 };
61 
62 struct mthca_user_db_table;
63 
64 struct mthca_ucontext {
65 	struct ib_ucontext          ibucontext;
66 	struct mthca_uar            uar;
67 	struct mthca_user_db_table *db_tab;
68 	int			    reg_mr_warned;
69 };
70 
71 struct mthca_mtt;
72 
73 struct mthca_mr {
74 	struct ib_mr      ibmr;
75 	struct ib_umem   *umem;
76 	struct mthca_mtt *mtt;
77 };
78 
79 struct mthca_pd {
80 	struct ib_pd    ibpd;
81 	u32             pd_num;
82 	atomic_t        sqp_count;
83 	struct mthca_mr ntmr;
84 	int             privileged;
85 };
86 
87 struct mthca_eq {
88 	struct mthca_dev      *dev;
89 	int                    eqn;
90 	u32                    eqn_mask;
91 	u32                    cons_index;
92 	u16                    msi_x_vector;
93 	u16                    msi_x_entry;
94 	int                    have_irq;
95 	int                    nent;
96 	struct mthca_buf_list *page_list;
97 	struct mthca_mr        mr;
98 	char		       irq_name[IB_DEVICE_NAME_MAX];
99 };
100 
101 struct mthca_av;
102 
103 enum mthca_ah_type {
104 	MTHCA_AH_ON_HCA,
105 	MTHCA_AH_PCI_POOL,
106 	MTHCA_AH_KMALLOC
107 };
108 
109 struct mthca_ah {
110 	struct ib_ah       ibah;
111 	enum mthca_ah_type type;
112 	u32                key;
113 	struct mthca_av   *av;
114 	dma_addr_t         avdma;
115 };
116 
117 /*
118  * Quick description of our CQ/QP locking scheme:
119  *
120  * We have one global lock that protects dev->cq/qp_table.  Each
121  * struct mthca_cq/qp also has its own lock.  An individual qp lock
122  * may be taken inside of an individual cq lock.  Both cqs attached to
123  * a qp may be locked, with the cq with the lower cqn locked first.
124  * No other nesting should be done.
125  *
126  * Each struct mthca_cq/qp also has an ref count, protected by the
127  * corresponding table lock.  The pointer from the cq/qp_table to the
128  * struct counts as one reference.  This reference also is good for
129  * access through the consumer API, so modifying the CQ/QP etc doesn't
130  * need to take another reference.  Access to a QP because of a
131  * completion being polled does not need a reference either.
132  *
133  * Finally, each struct mthca_cq/qp has a wait_queue_head_t for the
134  * destroy function to sleep on.
135  *
136  * This means that access from the consumer API requires nothing but
137  * taking the struct's lock.
138  *
139  * Access because of a completion event should go as follows:
140  * - lock cq/qp_table and look up struct
141  * - increment ref count in struct
142  * - drop cq/qp_table lock
143  * - lock struct, do your thing, and unlock struct
144  * - decrement ref count; if zero, wake up waiters
145  *
146  * To destroy a CQ/QP, we can do the following:
147  * - lock cq/qp_table
148  * - remove pointer and decrement ref count
149  * - unlock cq/qp_table lock
150  * - wait_event until ref count is zero
151  *
152  * It is the consumer's responsibilty to make sure that no QP
153  * operations (WQE posting or state modification) are pending when a
154  * QP is destroyed.  Also, the consumer must make sure that calls to
155  * qp_modify are serialized.  Similarly, the consumer is responsible
156  * for ensuring that no CQ resize operations are pending when a CQ
157  * is destroyed.
158  *
159  * Possible optimizations (wait for profile data to see if/where we
160  * have locks bouncing between CPUs):
161  * - split cq/qp table lock into n separate (cache-aligned) locks,
162  *   indexed (say) by the page in the table
163  * - split QP struct lock into three (one for common info, one for the
164  *   send queue and one for the receive queue)
165  */
166 
167 struct mthca_cq_buf {
168 	union mthca_buf		queue;
169 	struct mthca_mr		mr;
170 	int			is_direct;
171 };
172 
173 struct mthca_cq_resize {
174 	struct mthca_cq_buf	buf;
175 	int			cqe;
176 	enum {
177 		CQ_RESIZE_ALLOC,
178 		CQ_RESIZE_READY,
179 		CQ_RESIZE_SWAPPED
180 	}			state;
181 };
182 
183 struct mthca_cq {
184 	struct ib_cq		ibcq;
185 	spinlock_t		lock;
186 	int			refcount;
187 	int			cqn;
188 	u32			cons_index;
189 	struct mthca_cq_buf	buf;
190 	struct mthca_cq_resize *resize_buf;
191 	int			is_kernel;
192 
193 	/* Next fields are Arbel only */
194 	int			set_ci_db_index;
195 	__be32		       *set_ci_db;
196 	int			arm_db_index;
197 	__be32		       *arm_db;
198 	int			arm_sn;
199 
200 	wait_queue_head_t	wait;
201 	struct mutex		mutex;
202 };
203 
204 struct mthca_srq {
205 	struct ib_srq		ibsrq;
206 	spinlock_t		lock;
207 	int			refcount;
208 	int			srqn;
209 	int			max;
210 	int			max_gs;
211 	int			wqe_shift;
212 	int			first_free;
213 	int			last_free;
214 	u16			counter;  /* Arbel only */
215 	int			db_index; /* Arbel only */
216 	__be32		       *db;       /* Arbel only */
217 	void		       *last;
218 
219 	int			is_direct;
220 	u64		       *wrid;
221 	union mthca_buf		queue;
222 	struct mthca_mr		mr;
223 
224 	wait_queue_head_t	wait;
225 	struct mutex		mutex;
226 };
227 
228 struct mthca_wq {
229 	spinlock_t lock;
230 	int        max;
231 	unsigned   next_ind;
232 	unsigned   last_comp;
233 	unsigned   head;
234 	unsigned   tail;
235 	void      *last;
236 	int        max_gs;
237 	int        wqe_shift;
238 
239 	int        db_index;	/* Arbel only */
240 	__be32    *db;
241 };
242 
243 struct mthca_sqp {
244 	int             pkey_index;
245 	u32             qkey;
246 	u32             send_psn;
247 	struct ib_ud_header ud_header;
248 	int             header_buf_size;
249 	void           *header_buf;
250 	dma_addr_t      header_dma;
251 };
252 
253 struct mthca_qp {
254 	struct ib_qp           ibqp;
255 	int                    refcount;
256 	u32                    qpn;
257 	int                    is_direct;
258 	u8                     port; /* for SQP and memfree use only */
259 	u8                     alt_port; /* for memfree use only */
260 	u8                     transport;
261 	u8                     state;
262 	u8                     atomic_rd_en;
263 	u8                     resp_depth;
264 
265 	struct mthca_mr        mr;
266 
267 	struct mthca_wq        rq;
268 	struct mthca_wq        sq;
269 	enum ib_sig_type       sq_policy;
270 	int                    send_wqe_offset;
271 	int                    max_inline_data;
272 
273 	u64                   *wrid;
274 	union mthca_buf	       queue;
275 
276 	wait_queue_head_t      wait;
277 	struct mutex	       mutex;
278 	struct mthca_sqp *sqp;
279 };
280 
281 static inline struct mthca_ucontext *to_mucontext(struct ib_ucontext *ibucontext)
282 {
283 	return container_of(ibucontext, struct mthca_ucontext, ibucontext);
284 }
285 
286 static inline struct mthca_mr *to_mmr(struct ib_mr *ibmr)
287 {
288 	return container_of(ibmr, struct mthca_mr, ibmr);
289 }
290 
291 static inline struct mthca_pd *to_mpd(struct ib_pd *ibpd)
292 {
293 	return container_of(ibpd, struct mthca_pd, ibpd);
294 }
295 
296 static inline struct mthca_ah *to_mah(struct ib_ah *ibah)
297 {
298 	return container_of(ibah, struct mthca_ah, ibah);
299 }
300 
301 static inline struct mthca_cq *to_mcq(struct ib_cq *ibcq)
302 {
303 	return container_of(ibcq, struct mthca_cq, ibcq);
304 }
305 
306 static inline struct mthca_srq *to_msrq(struct ib_srq *ibsrq)
307 {
308 	return container_of(ibsrq, struct mthca_srq, ibsrq);
309 }
310 
311 static inline struct mthca_qp *to_mqp(struct ib_qp *ibqp)
312 {
313 	return container_of(ibqp, struct mthca_qp, ibqp);
314 }
315 
316 #endif /* MTHCA_PROVIDER_H */
317