[MTHCA, IBAL] added FMR support; [MTHCA] 1. fixed (and now works) "livefish" support;
[mirror/winof/.git] / hw / mthca / user / mlnx_uvp.h
1 /*
2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 Cisco Systems.  All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  *
33  * $Id: mthca.h 4182 2005-11-28 21:14:30Z roland $
34  */
35
36 #ifndef MTHCA_H
37 #define MTHCA_H
38
39 #include <cl_spinlock.h>
40 #include <mlnx_uvp_verbs.h>
41 #include <arch.h>
42 #include "mlnx_uvp_debug.h"
43
44 #define PFX             "mthca: "
45
46 enum mthca_hca_type {
47         MTHCA_TAVOR,
48         MTHCA_ARBEL,
49         MTHCA_LIVEFISH
50 };
51
52 enum {
53         MTHCA_CQ_ENTRY_SIZE = 0x20
54 };
55
56 enum {
57         MTHCA_QP_TABLE_BITS = 8,
58         MTHCA_QP_TABLE_SIZE = 1 << MTHCA_QP_TABLE_BITS,
59         MTHCA_QP_TABLE_MASK = MTHCA_QP_TABLE_SIZE - 1
60 };
61
62 enum {
63         MTHCA_DB_REC_PAGE_SIZE = 4096,
64         MTHCA_DB_REC_PER_PAGE  = MTHCA_DB_REC_PAGE_SIZE / 8
65 };
66
67 enum mthca_db_type {
68         MTHCA_DB_TYPE_INVALID   = 0x0,
69         MTHCA_DB_TYPE_CQ_SET_CI = 0x1,
70         MTHCA_DB_TYPE_CQ_ARM    = 0x2,
71         MTHCA_DB_TYPE_SQ        = 0x3,
72         MTHCA_DB_TYPE_RQ        = 0x4,
73         MTHCA_DB_TYPE_SRQ       = 0x5,
74         MTHCA_DB_TYPE_GROUP_SEP = 0x7
75 };
76
77 enum {
78         MTHCA_OPCODE_NOP            = 0x00,
79         MTHCA_OPCODE_RDMA_WRITE     = 0x08,
80         MTHCA_OPCODE_RDMA_WRITE_IMM = 0x09,
81         MTHCA_OPCODE_SEND           = 0x0a,
82         MTHCA_OPCODE_SEND_IMM       = 0x0b,
83         MTHCA_OPCODE_RDMA_READ      = 0x10,
84         MTHCA_OPCODE_ATOMIC_CS      = 0x11,
85         MTHCA_OPCODE_ATOMIC_FA      = 0x12,
86         MTHCA_OPCODE_BIND_MW        = 0x18,
87         MTHCA_OPCODE_INVALID        = 0xff
88 };
89
90 struct mthca_ah_page;
91
92 struct mthca_db_table;
93
94 struct mthca_context {
95         struct ibv_context     ibv_ctx;
96         void                  *uar;
97         cl_spinlock_t     uar_lock;
98         struct mthca_db_table *db_tab;
99         struct ibv_pd         *pd;
100         struct {
101                 struct mthca_qp **table;
102                 int               refcnt;
103         }                      qp_table[MTHCA_QP_TABLE_SIZE];
104         HANDLE        qp_table_mutex;
105         int                    num_qps;
106         int                    qp_table_shift;
107         int                    qp_table_mask;
108         enum mthca_hca_type hca_type;
109 };
110
111 struct mthca_pd {
112         struct ibv_pd         ibv_pd;
113         struct mthca_ah_page *ah_list;
114         HANDLE       ah_mutex;
115         uint32_t              pdn;
116 };
117
118 struct mthca_cq {
119         struct ibv_cq      ibv_cq;
120         void              *buf;
121         cl_spinlock_t lock;
122         struct ibv_mr     mr;
123         uint32_t           cqn;
124         uint32_t           cons_index;
125
126         /* Next fields are mem-free only */
127         int                set_ci_db_index;
128         uint32_t          *set_ci_db;
129         int                arm_db_index;
130         uint32_t          *arm_db;
131         int                u_arm_db_index;
132         uint32_t          *p_u_arm_sn;
133 };
134
135 struct mthca_srq {
136         struct ibv_srq     ibv_srq;
137         void              *buf;
138         void              *last;
139         cl_spinlock_t lock;
140         struct ibv_mr     *mr;
141         uint64_t          *wrid;
142         uint32_t           srqn;
143         int                max;
144         int                max_gs;
145         int                wqe_shift;
146         int                first_free;
147         int                last_free;
148         int                buf_size;
149
150         /* Next fields are mem-free only */
151         int                db_index;
152         uint32_t          *db;
153         uint16_t           counter;
154 };
155
156 struct mthca_wq {
157         cl_spinlock_t lock;
158         int                max;
159         unsigned           next_ind;
160         unsigned           last_comp;
161         unsigned           head;
162         unsigned           tail;
163         void              *last;
164         int                max_gs;
165         int                wqe_shift;
166
167         /* Next fields are mem-free only */
168         int                db_index;
169         uint32_t          *db;
170 };
171
172 struct mthca_qp {
173         struct ibv_qp    ibv_qp;
174         uint8_t            *buf;
175         uint64_t        *wrid;
176         int              send_wqe_offset;
177         int              max_inline_data;
178         int              buf_size;
179         struct mthca_wq  sq;
180         struct mthca_wq  rq;
181         struct ibv_mr   mr;
182         int              sq_sig_all;
183 };
184
185 struct mthca_av {
186         uint32_t port_pd;
187         uint8_t  reserved1;
188         uint8_t  g_slid;
189         uint16_t dlid;
190         uint8_t  reserved2;
191         uint8_t  gid_index;
192         uint8_t  msg_sr;
193         uint8_t  hop_limit;
194         uint32_t sl_tclass_flowlabel;
195         uint32_t dgid[4];
196 };
197
198 struct mthca_ah {
199         struct mthca_av      *av;
200         ib_av_attr_t            av_attr;
201         ib_pd_handle_t  h_uvp_pd;
202         struct mthca_ah_page *page;
203         uint32_t              key;
204         int     in_kernel;
205 };
206
207 struct mthca_ah_page {
208         struct mthca_ah_page *prev, *next;
209         void                 *buf;
210         struct ibv_mr        mr;
211         int                   use_cnt;
212         unsigned              free[0];
213 };
214
215 static inline unsigned long align(unsigned long val, unsigned long align)
216 {
217         return (val + align - 1) & ~(align - 1);
218 }
219
220 static inline uintptr_t db_align(uint32_t *db)
221 {
222         return (uintptr_t) db & ~((uintptr_t) MTHCA_DB_REC_PAGE_SIZE - 1);
223 }
224
225 #define to_mxxx(xxx, type)                                              \
226         ((struct mthca_##type *)                                        \
227          ((uint8_t *) ib##xxx - offsetof(struct mthca_##type, ibv_##xxx)))
228
229 static inline struct mthca_context *to_mctx(struct ibv_context *ibctx)
230 {
231         return to_mxxx(ctx, context);
232 }
233
234 static inline struct mthca_pd *to_mpd(struct ibv_pd *ibpd)
235 {
236         return to_mxxx(pd, pd);
237 }
238
239 static inline struct mthca_cq *to_mcq(struct ibv_cq *ibcq)
240 {
241         return to_mxxx(cq, cq);
242 }
243
244 static inline struct mthca_srq *to_msrq(struct ibv_srq *ibsrq)
245 {
246         return to_mxxx(srq, srq);
247 }
248
249 static inline struct mthca_qp *to_mqp(struct ibv_qp *ibqp)
250 {
251         return to_mxxx(qp, qp);
252 }
253
254 static inline int mthca_is_memfree(struct ibv_context *ibctx)
255 {
256         return to_mctx(ibctx)->hca_type == MTHCA_ARBEL;
257 }
258
259 int mthca_alloc_db(struct mthca_db_table *db_tab, enum mthca_db_type type,
260                           uint32_t **db);
261 void mthca_set_db_qn(uint32_t *db, enum mthca_db_type type, uint32_t qn);
262 void mthca_free_db(struct mthca_db_table *db_tab, enum mthca_db_type type, int db_index);
263 struct mthca_db_table *mthca_alloc_db_tab(int uarc_size);
264 void mthca_free_db_tab(struct mthca_db_table *db_tab);
265
266 int mthca_query_device(struct ibv_context *context,
267                               struct ibv_device_attr *attr);
268 int mthca_query_port(struct ibv_context *context, uint8_t port,
269                             struct ibv_port_attr *attr);
270
271         struct ibv_pd *mthca_alloc_pd(struct ibv_context *context, 
272         struct ibv_alloc_pd_resp *resp_p);
273
274 int mthca_free_pd(struct ibv_pd *pd);
275
276 struct ibv_cq *mthca_create_cq_pre(struct ibv_context *context, int *cqe,
277                                  struct ibv_create_cq *req);
278 struct ibv_cq *mthca_create_cq_post(struct ibv_context *context, 
279                                  struct ibv_create_cq_resp *resp);
280 int mthca_destroy_cq(struct ibv_cq *cq);
281 int mthca_poll_cq(struct ibv_cq *cq, int ne, struct _ib_wc *wc);
282 int mthca_poll_cq_list(struct ibv_cq *ibcq, 
283         struct _ib_wc** const pp_free_wclist,
284         struct _ib_wc** const pp_done_wclist );
285 int mthca_tavor_arm_cq(struct ibv_cq *cq, int solicited);
286 int mthca_arbel_arm_cq(struct ibv_cq *cq, int solicited);
287 void mthca_cq_clean(struct mthca_cq *cq, uint32_t qpn,
288                            struct mthca_srq *srq);
289 void mthca_init_cq_buf(struct mthca_cq *cq, int nent);
290
291 struct ibv_srq *mthca_create_srq(struct ibv_pd *pd,
292                                         struct ibv_srq_init_attr *attr);
293 int mthca_modify_srq(struct ibv_srq *srq,
294                             struct ibv_srq_attr *attr,
295                             enum ibv_srq_attr_mask mask);
296 int mthca_destroy_srq(struct ibv_srq *srq);
297 int mthca_alloc_srq_buf(struct ibv_pd *pd, struct ibv_srq_attr *attr,
298                                struct mthca_srq *srq);
299 void mthca_free_srq_wqe(struct mthca_srq *srq, int ind);
300 int mthca_tavor_post_srq_recv(struct ibv_srq *ibsrq,
301                                      struct _ib_recv_wr *wr,
302                                      struct _ib_recv_wr **bad_wr);
303 int mthca_arbel_post_srq_recv(struct ibv_srq *ibsrq,
304                                      struct _ib_recv_wr *wr,
305                                      struct _ib_recv_wr **bad_wr);
306 struct ibv_qp *mthca_create_qp_pre(struct ibv_pd *pd, 
307         struct ibv_qp_init_attr *attr, struct ibv_create_qp *req);
308 struct ibv_qp *mthca_create_qp_post(struct ibv_pd *pd, 
309         struct ibv_create_qp_resp *resp);
310 int mthca_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr,
311                            enum ibv_qp_attr_mask attr_mask);
312 void mthca_destroy_qp_pre(struct ibv_qp *qp);
313 void mthca_destroy_qp_post(struct ibv_qp *qp, int ret);
314 void mthca_init_qp_indices(struct mthca_qp *qp);
315 int mthca_tavor_post_send(struct ibv_qp *ibqp, struct _ib_send_wr *wr,
316                                  struct _ib_send_wr **bad_wr);
317 int mthca_tavor_post_recv(struct ibv_qp *ibqp, struct _ib_recv_wr *wr,
318                                  struct _ib_recv_wr **bad_wr);
319 int mthca_arbel_post_send(struct ibv_qp *ibqp, struct _ib_send_wr *wr,
320                                  struct _ib_send_wr **bad_wr);
321 int mthca_arbel_post_recv(struct ibv_qp *ibqp, struct _ib_recv_wr *wr,
322                                  struct _ib_recv_wr **bad_wr);
323 int mthca_alloc_qp_buf(struct ibv_pd *pd, struct ibv_qp_cap *cap,
324                               ib_qp_type_t type, struct mthca_qp *qp);
325 struct mthca_qp *mthca_find_qp(struct mthca_context *ctx, uint32_t qpn);
326 int mthca_store_qp(struct mthca_context *ctx, uint32_t qpn, struct mthca_qp *qp);
327 void mthca_clear_qp(struct mthca_context *ctx, uint32_t qpn);
328 int mthca_free_err_wqe(struct mthca_qp *qp, int is_send,
329                               int index, int *dbd, uint32_t *new_wqe);
330 int mthca_alloc_av(struct mthca_pd *pd, struct ibv_ah_attr *attr,
331                           struct mthca_ah *ah, struct ibv_create_ah_resp *resp);
332 void mthca_free_av(struct mthca_ah *ah);
333 int mthca_attach_mcast(struct ibv_qp *qp, union ibv_gid *gid, uint16_t lid);
334 int mthca_detach_mcast(struct ibv_qp *qp, union ibv_gid *gid, uint16_t lid);
335 struct ibv_context *mthca_alloc_context(struct ibv_get_context_resp *resp_p);
336 void mthca_free_context(struct ibv_context *ibctx);
337
338 #endif /* MTHCA_H */