7395f0feb837741186a802060b7f62a9be235bc3
[mirror/winof/.git] / hw / mthca / kernel / mthca_provider.h
1 /*
2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 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  * $Id$
35  */
36
37 #ifndef MTHCA_PROVIDER_H
38 #define MTHCA_PROVIDER_H
39
40 #include <ib_verbs.h>
41 #include <ib_pack.h>
42 #include <iba/ib_ci.h>
43
44 typedef uint32_t mthca_mpt_access_t;
45 #define MTHCA_MPT_FLAG_ATOMIC        (1 << 14)
46 #define MTHCA_MPT_FLAG_REMOTE_WRITE  (1 << 13)
47 #define MTHCA_MPT_FLAG_REMOTE_READ   (1 << 12)
48 #define MTHCA_MPT_FLAG_LOCAL_WRITE   (1 << 11)
49 #define MTHCA_MPT_FLAG_LOCAL_READ    (1 << 10)
50
51 union mthca_buf {
52         struct scatterlist direct;
53         struct scatterlist *page_list;
54 };
55
56 struct mthca_uar {
57         PFN_NUMBER pfn;
58         int           index;
59 };
60
61 struct mthca_user_db_table;
62
63 struct mthca_ucontext {
64         struct ib_ucontext          ibucontext;
65         struct mthca_uar            uar;
66         struct mthca_user_db_table *db_tab;
67         // for user UAR 
68         PMDL    mdl;
69         PVOID   kva;
70         SIZE_T uar_size;        
71 };
72
73 struct mthca_mtt;
74
75 struct mthca_mr {
76         //NB: the start of this structure is to be equal to mlnx_mro_t !
77         //NB: the structure was not inserted here for not to mix driver and provider structures
78         struct ib_mr      ibmr;
79         struct mthca_mtt *mtt;
80         int                     iobuf_used;
81         mt_iobuf_t      iobuf;
82         void *secure_handle;
83 };
84
85 struct mthca_fmr {
86         struct ib_fmr      ibfmr;
87         struct ib_fmr_attr attr;
88         struct mthca_mtt  *mtt;
89         int                maps;
90         union {
91                 struct {
92                         struct mthca_mpt_entry __iomem *mpt;
93                         u64 __iomem *mtts;
94                 } tavor;
95                 struct {
96                         struct mthca_mpt_entry *mpt;
97                         __be64 *mtts;
98                 } arbel;
99         } mem;
100 };
101
102 struct mthca_pd {
103         struct ib_pd    ibpd;
104         u32             pd_num;
105         atomic_t        sqp_count;
106         struct mthca_mr ntmr;
107         int             privileged;
108 };
109
110 struct mthca_eq {
111         struct mthca_dev      *dev;
112         int                    eqn;
113         int                    eq_num;
114         u32                    eqn_mask;
115         u32                    cons_index;
116         u16                    msi_x_vector;
117         u16                    msi_x_entry;
118         int                    have_irq;
119         int                    nent;
120         struct scatterlist *page_list;
121         struct mthca_mr        mr;
122         KDPC                            dpc;                    /* DPC for MSI-X interrupts */
123         spinlock_t  lock;                       /* spinlock for simult DPCs */
124 };
125
126 struct mthca_av;
127
128 enum mthca_ah_type {
129         MTHCA_AH_ON_HCA,
130         MTHCA_AH_PCI_POOL,
131         MTHCA_AH_KMALLOC
132 };
133
134 struct mthca_ah {
135         struct ib_ah       ibah;
136         enum mthca_ah_type type;
137         u32                key;
138         struct mthca_av   *av;
139         dma_addr_t         avdma;
140 };
141
142 /*
143  * Quick description of our CQ/QP locking scheme:
144  *
145  * We have one global lock that protects dev->cq/qp_table.  Each
146  * struct mthca_cq/qp also has its own lock.  An individual qp lock
147  * may be taken inside of an individual cq lock.  Both cqs attached to
148  * a qp may be locked, with the send cq locked first.  No other
149  * nesting should be done.
150  *
151  * Each struct mthca_cq/qp also has an atomic_t ref count.  The
152  * pointer from the cq/qp_table to the struct counts as one reference.
153  * This reference also is good for access through the consumer API, so
154  * modifying the CQ/QP etc doesn't need to take another reference.
155  * Access because of a completion being polled does need a reference.
156  *
157  * Finally, each struct mthca_cq/qp has a wait_queue_head_t for the
158  * destroy function to sleep on.
159  *
160  * This means that access from the consumer API requires nothing but
161  * taking the struct's lock.
162  *
163  * Access because of a completion event should go as follows:
164  * - lock cq/qp_table and look up struct
165  * - increment ref count in struct
166  * - drop cq/qp_table lock
167  * - lock struct, do your thing, and unlock struct
168  * - decrement ref count; if zero, wake up waiters
169  *
170  * To destroy a CQ/QP, we can do the following:
171  * - lock cq/qp_table, remove pointer, unlock cq/qp_table lock
172  * - decrement ref count
173  * - wait_event until ref count is zero
174  *
175  * It is the consumer's responsibilty to make sure that no QP
176  * operations (WQE posting or state modification) are pending when the
177  * QP is destroyed.  Also, the consumer must make sure that calls to
178  * qp_modify are serialized.
179  *
180  * Possible optimizations (wait for profile data to see if/where we
181  * have locks bouncing between CPUs):
182  * - split cq/qp table lock into n separate (cache-aligned) locks,
183  *   indexed (say) by the page in the table
184  * - split QP struct lock into three (one for common info, one for the
185  *   send queue and one for the receive queue)
186  */
187 //TODO: check correctness of the above requirement: "It is the consumer's responsibilty to make sure that no QP
188 // operations (WQE posting or state modification) are pending when the QP is destroyed"
189
190 struct mthca_cq {
191         struct ib_cq           ibcq;
192         void                                            *cq_context;    // leo: for IBAL shim
193         spinlock_t             lock;
194         atomic_t               refcount;
195         int                    cqn;
196         u32                    cons_index;
197         int                    is_direct;
198         int                    is_kernel;
199
200         /* Next fields are Arbel only */
201         int                    set_ci_db_index;
202         __be32                *set_ci_db;
203         int                    arm_db_index;
204         __be32                *arm_db;
205         int                    arm_sn;
206         int                    u_arm_db_index;
207         int                *p_u_arm_sn;
208
209         union mthca_buf        queue;
210         struct mthca_mr        mr;
211         wait_queue_head_t      wait;
212         KMUTEX                      mutex;
213 };
214
215 struct mthca_srq {
216         struct ib_srq           ibsrq;
217         spinlock_t              lock;
218         atomic_t                refcount;
219         int                     srqn;
220         int                     max;
221         int                     max_gs;
222         int                     wqe_shift;
223         int                     first_free;
224         int                     last_free;
225         u16                     counter;  /* Arbel only */
226         int                     db_index; /* Arbel only */
227         __be32                 *db;       /* Arbel only */
228         void                   *last;
229
230         int                     is_direct;
231         u64                    *wrid;
232         union mthca_buf         queue;
233         struct mthca_mr         mr;
234
235         wait_queue_head_t       wait;
236         KMUTEX                  mutex;
237         void                            *srq_context;   
238 };
239
240 struct mthca_wq {
241         spinlock_t lock;
242         int        max;
243         unsigned   next_ind;
244         unsigned   last_comp;
245         unsigned   head;
246         unsigned   tail;
247         void      *last;
248         int        max_gs;
249         int        wqe_shift;
250
251         int        db_index;    /* Arbel only */
252         __be32    *db;
253 };
254
255 struct mthca_qp {
256         struct ib_qp           ibqp;
257         void                                            *qp_context;    // leo: for IBAL shim
258         //TODO: added just because absense of ibv_query_qp
259         // thereafter it may be worth to be replaced by struct ib_qp_attr qp_attr;
260         struct ib_qp_init_attr qp_init_attr;    // leo: for query_qp
261         atomic_t               refcount;
262         u32                    qpn;
263         int                    is_direct;
264         u8                     transport;
265         u8                     state;
266         u8                     atomic_rd_en;
267         u8                     resp_depth;
268
269         struct mthca_mr        mr;
270
271         struct mthca_wq        rq;
272         struct mthca_wq        sq;
273         enum ib_sig_type       sq_policy;
274         int                    send_wqe_offset;
275         int                    max_inline_data;
276
277         u64                   *wrid;
278         union mthca_buf        queue;
279
280         wait_queue_head_t      wait;
281         KMUTEX                      mutex;
282 };
283
284 struct mthca_sqp {
285         struct mthca_qp qp;
286         int             port;
287         int             pkey_index;
288         u32             qkey;
289         u32             send_psn;
290         struct ib_ud_header ud_header;
291         struct scatterlist sg;
292 };
293
294 static inline struct mthca_ucontext *to_mucontext(struct ib_ucontext *ibucontext)
295 {
296         return container_of(ibucontext, struct mthca_ucontext, ibucontext);
297 }
298
299 static inline struct mthca_fmr *to_mfmr(struct ib_fmr *ibfmr)
300 {
301         return container_of(ibfmr, struct mthca_fmr, ibfmr);
302 }
303
304 static inline struct mthca_mr *to_mmr(struct ib_mr *ibmr)
305 {
306         return container_of(ibmr, struct mthca_mr, ibmr);
307 }
308
309 static inline struct mthca_pd *to_mpd(struct ib_pd *ibpd)
310 {
311         return container_of(ibpd, struct mthca_pd, ibpd);
312 }
313
314 static inline struct mthca_ah *to_mah(struct ib_ah *ibah)
315 {
316         return container_of(ibah, struct mthca_ah, ibah);
317 }
318
319 static inline struct mthca_cq *to_mcq(struct ib_cq *ibcq)
320 {
321         return container_of(ibcq, struct mthca_cq, ibcq);
322 }
323
324 static inline struct mthca_srq *to_msrq(struct ib_srq *ibsrq)
325 {
326         return container_of(ibsrq, struct mthca_srq, ibsrq);
327 }
328
329 static inline struct mthca_qp *to_mqp(struct ib_qp *ibqp)
330 {
331         return container_of(ibqp, struct mthca_qp, ibqp);
332 }
333
334 static inline struct mthca_sqp *to_msqp(struct mthca_qp *qp)
335 {
336         return container_of(qp, struct mthca_sqp, qp);
337 }
338
339 static inline uint8_t start_port(struct ib_device *device)
340 {
341         return device->node_type == IB_NODE_SWITCH ? 0 : 1;
342 }
343
344 static inline uint8_t end_port(struct ib_device *device)
345 {
346         return device->node_type == IB_NODE_SWITCH ? 0 : device->phys_port_cnt;
347 }
348
349 static inline int ib_copy_from_umv_buf(void *dest, ci_umv_buf_t* const p_umv_buf, size_t len)
350 {
351         RtlCopyMemory(dest, p_umv_buf->p_inout_buf,  len);
352         return 0;
353 }
354
355 static inline int ib_copy_to_umv_buf(ci_umv_buf_t* const p_umv_buf, void *src, size_t len)
356 {
357         if (p_umv_buf->output_size < len) {
358                 p_umv_buf->status = IB_INSUFFICIENT_MEMORY;
359                 p_umv_buf->output_size = 0;
360                 return -EFAULT;
361         }
362         RtlCopyMemory(p_umv_buf->p_inout_buf,  src, len);
363         p_umv_buf->status = IB_SUCCESS;
364         p_umv_buf->output_size = (uint32_t)len;
365         return 0;
366 }
367
368
369
370 // API
371 int mthca_query_device(struct ib_device *ibdev,
372                               struct ib_device_attr *props);
373
374 int mthca_query_port(struct ib_device *ibdev,
375                             u8 port, struct ib_port_attr *props);
376
377 int mthca_modify_port(struct ib_device *ibdev,
378                              u8 port, int port_modify_mask,
379                              struct ib_port_modify *props);
380
381 struct ib_pd *mthca_alloc_pd(struct ib_device *ibdev,
382                                     struct ib_ucontext *context,
383                                     ci_umv_buf_t* const                 p_umv_buf);
384
385 int mthca_dealloc_pd(struct ib_pd *pd);
386
387 int mthca_dereg_mr(struct ib_mr *mr);
388
389 int mthca_query_srq(struct ib_srq *ibsrq, ib_srq_attr_t *srq_attr);
390
391 struct ib_ucontext *mthca_alloc_ucontext(struct ib_device *ibdev,
392                                                 ci_umv_buf_t* const                     p_umv_buf);
393
394 int mthca_dealloc_ucontext(struct ib_ucontext *context);
395
396 struct ib_mr *mthca_get_dma_mr(struct ib_pd *pd, mthca_qp_access_t acc);
397
398 int mthca_poll_cq_list(
399         IN              struct ib_cq *ibcq, 
400         IN      OUT                     ib_wc_t** const                         pp_free_wclist,
401                 OUT                     ib_wc_t** const                         pp_done_wclist );
402
403
404 #endif /* MTHCA_PROVIDER_H */