2e71579efa040da441a9b6fca796e2b7bbfef2c6
[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: mthca_provider.h 3047 2005-08-10 03:59:35Z roland $
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 #ifdef WIN_TO_BE_REMOVED
80         mt_iobuf_t              iobuf;
81 #endif
82         struct mthca_mtt *mtt;
83         struct ib_umem umem;
84 };
85
86 struct mthca_fmr {
87         struct ib_fmr      ibmr;
88         struct ib_fmr_attr attr;
89         struct mthca_mtt  *mtt;
90         int                maps;
91         union {
92                 struct {
93                         struct mthca_mpt_entry __iomem *mpt;
94                         u64 __iomem *mtts;
95                 } tavor;
96                 struct {
97                         struct mthca_mpt_entry *mpt;
98                         __be64 *mtts;
99                 } arbel;
100         } mem;
101 };
102
103 struct mthca_pd {
104         struct ib_pd    ibpd;
105         u32             pd_num;
106         atomic_t        sqp_count;
107         struct mthca_mr ntmr;
108         int             privileged;
109 };
110
111 struct mthca_eq {
112         struct mthca_dev      *dev;
113         int                    eqn;
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
207         union mthca_buf        queue;
208         struct mthca_mr        mr;
209         wait_queue_head_t      wait;
210 };
211
212 struct mthca_srq {
213         struct ib_srq           ibsrq;
214         spinlock_t              lock;
215         atomic_t                refcount;
216         int                     srqn;
217         int                     max;
218         int                     max_gs;
219         int                     wqe_shift;
220         int                     first_free;
221         int                     last_free;
222         u16                     counter;  /* Arbel only */
223         int                     db_index; /* Arbel only */
224         __be32                 *db;       /* Arbel only */
225         void                   *last;
226
227         int                     is_direct;
228         u64                    *wrid;
229         union mthca_buf         queue;
230         struct mthca_mr         mr;
231
232         wait_queue_head_t       wait;
233 };
234
235 struct mthca_wq {
236         spinlock_t lock;
237         int        max;
238         unsigned   next_ind;
239         unsigned   last_comp;
240         unsigned   head;
241         unsigned   tail;
242         void      *last;
243         int        max_gs;
244         int        wqe_shift;
245
246         int        db_index;    /* Arbel only */
247         __be32    *db;
248 };
249
250 struct mthca_qp {
251         struct ib_qp           ibqp;
252         void                                            *qp_context;    // leo: for IBAL shim
253         //TODO: added just because absense of ibv_query_qp
254         // thereafter it may be worth to be replaced by struct ib_qp_attr qp_attr;
255         struct ib_qp_init_attr qp_init_attr;    // leo: for query_qp
256         atomic_t               refcount;
257         u32                    qpn;
258         int                    is_direct;
259         u8                     transport;
260         u8                     state;
261         u8                     atomic_rd_en;
262         u8                     resp_depth;
263
264         struct mthca_mr        mr;
265
266         struct mthca_wq        rq;
267         struct mthca_wq        sq;
268         enum ib_sig_type       sq_policy;
269         int                    send_wqe_offset;
270         int                    max_inline_data;
271
272         u64                   *wrid;
273         union mthca_buf        queue;
274
275         wait_queue_head_t      wait;
276 };
277
278 struct mthca_sqp {
279         struct mthca_qp qp;
280         int             port;
281         int             pkey_index;
282         u32             qkey;
283         u32             send_psn;
284         struct ib_ud_header ud_header;
285         struct scatterlist sg;
286 };
287
288 static inline struct mthca_ucontext *to_mucontext(struct ib_ucontext *ibucontext)
289 {
290         return container_of(ibucontext, struct mthca_ucontext, ibucontext);
291 }
292
293 static inline struct mthca_fmr *to_mfmr(struct ib_fmr *ibmr)
294 {
295         return container_of(ibmr, struct mthca_fmr, ibmr);
296 }
297
298 static inline struct mthca_mr *to_mmr(struct ib_mr *ibmr)
299 {
300         return container_of(ibmr, struct mthca_mr, ibmr);
301 }
302
303 static inline struct mthca_pd *to_mpd(struct ib_pd *ibpd)
304 {
305         return container_of(ibpd, struct mthca_pd, ibpd);
306 }
307
308 static inline struct mthca_ah *to_mah(struct ib_ah *ibah)
309 {
310         return container_of(ibah, struct mthca_ah, ibah);
311 }
312
313 static inline struct mthca_cq *to_mcq(struct ib_cq *ibcq)
314 {
315         return container_of(ibcq, struct mthca_cq, ibcq);
316 }
317
318 static inline struct mthca_srq *to_msrq(struct ib_srq *ibsrq)
319 {
320         return container_of(ibsrq, struct mthca_srq, ibsrq);
321 }
322
323 static inline struct mthca_qp *to_mqp(struct ib_qp *ibqp)
324 {
325         return container_of(ibqp, struct mthca_qp, ibqp);
326 }
327
328 static inline struct mthca_sqp *to_msqp(struct mthca_qp *qp)
329 {
330         return container_of(qp, struct mthca_sqp, qp);
331 }
332
333 static inline uint8_t start_port(struct ib_device *device)
334 {
335         return device->node_type == IB_NODE_SWITCH ? 0 : 1;
336 }
337
338 static inline uint8_t end_port(struct ib_device *device)
339 {
340         return device->node_type == IB_NODE_SWITCH ? 0 : device->phys_port_cnt;
341 }
342
343 static inline int ib_copy_from_umv_buf(void *dest, ci_umv_buf_t* const p_umv_buf, size_t len)
344 {
345         RtlCopyMemory(dest, p_umv_buf->p_inout_buf,  len);
346         return 0;
347 }
348
349 static inline int ib_copy_to_umv_buf(ci_umv_buf_t* const p_umv_buf, void *src, size_t len)
350 {
351         if (p_umv_buf->output_size < len) {
352                 p_umv_buf->status = IB_INSUFFICIENT_MEMORY;
353                 p_umv_buf->output_size = 0;
354                 return -EFAULT;
355         }
356         RtlCopyMemory(p_umv_buf->p_inout_buf,  src, len);
357         p_umv_buf->status = IB_SUCCESS;
358         p_umv_buf->output_size = (uint32_t)len;
359         return 0;
360 }
361
362
363
364 // API
365 int mthca_query_device(struct ib_device *ibdev,
366                                          struct ib_device_attr *props);
367
368 int mthca_query_port(struct ib_device *ibdev,
369                             u8 port, struct ib_port_attr *props);
370
371 int mthca_modify_port(struct ib_device *ibdev,
372                              u8 port, int port_modify_mask,
373                              struct ib_port_modify *props);
374
375 int mthca_query_pkey(struct ib_device *ibdev,
376                             u8 port, u16 index, u16 *pkey);
377
378 int mthca_query_gid(struct ib_device *ibdev, u8 port,
379                            int index, union ib_gid *gid);
380
381 struct ib_ucontext *mthca_alloc_ucontext(struct ib_device *ibdev,
382                                                 ci_umv_buf_t* const                     p_umv_buf);
383
384 int mthca_dealloc_ucontext(struct ib_ucontext *context);
385
386 struct ib_pd *mthca_alloc_pd(struct ib_device *ibdev,
387                                     struct ib_ucontext *context,
388                                     ci_umv_buf_t* const                 p_umv_buf);
389
390 int mthca_dealloc_pd(struct ib_pd *pd);
391
392 struct ib_ah *mthca_ah_create(struct ib_pd *pd,
393                                      struct ib_ah_attr *ah_attr);
394
395 int mthca_ah_destroy(struct ib_ah *ah);
396
397 struct ib_srq *mthca_create_srq(struct ib_pd *pd,
398                                        struct ib_srq_init_attr *init_attr,
399                                        ci_umv_buf_t* const                      p_umv_buf);
400
401 int mthca_destroy_srq(struct ib_srq *srq);
402
403 struct ib_qp *mthca_create_qp(struct ib_pd *pd,
404                                      struct ib_qp_init_attr *init_attr,
405                                      ci_umv_buf_t* const                        p_umv_buf);
406
407 int mthca_destroy_qp(struct ib_qp *qp);
408
409 struct ib_cq *mthca_create_cq(struct ib_device *ibdev, int entries,
410                                      struct ib_ucontext *context,
411                                      ci_umv_buf_t* const                        p_umv_buf);
412
413 int mthca_destroy_cq(struct ib_cq *cq);
414
415 struct ib_mr *mthca_get_dma_mr(struct ib_pd *pd, mthca_qp_access_t acc);
416
417 struct ib_mr *mthca_reg_phys_mr(struct ib_pd       *pd,
418                                        struct ib_phys_buf *buffer_list,
419                                        int                 num_phys_buf,
420                                        mthca_qp_access_t                 acc,
421                                        u64                *iova_start);
422
423 struct ib_mr *mthca_reg_user_mr(struct ib_pd *pd, 
424          void* __ptr64  vaddr, uint64_t length, uint64_t hca_va, mthca_qp_access_t acc);
425
426 int mthca_dereg_mr(struct ib_mr *mr);
427
428 struct ib_fmr *mthca_alloc_fmr(struct ib_pd *pd, mthca_qp_access_t acc,
429                                       struct ib_fmr_attr *fmr_attr);
430
431 int mthca_dealloc_fmr(struct ib_fmr *fmr);
432
433 int mthca_unmap_fmr(struct list_head *fmr_list);
434
435 int mthca_poll_cq_list(
436         IN              struct ib_cq *ibcq, 
437         IN      OUT                     ib_wc_t** const                         pp_free_wclist,
438                 OUT                     ib_wc_t** const                         pp_done_wclist );
439
440
441 #endif /* MTHCA_PROVIDER_H */