[MTHCA] 1. bugfix: gid lookup use wrong port number;
[mirror/winof/.git] / hw / mthca / user / mlnx_uvp.c
1 /*
2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  * $Id: mthca.c 3670 2005-10-05 19:51:57Z roland $
33  */
34
35 #include "mt_l2w.h"
36 #include "mlnx_uvp.h"
37
38 #if defined(EVENT_TRACING)
39 #include "mlnx_uvp.tmh"
40 #endif
41
42 #include "mx_abi.h"
43
44 size_t g_page_size = 0;
45
46 #ifndef PCI_VENDOR_ID_MELLANOX
47 #define PCI_VENDOR_ID_MELLANOX                  0x15b3
48 #endif
49
50 #ifndef PCI_DEVICE_ID_MELLANOX_TAVOR
51 #define PCI_DEVICE_ID_MELLANOX_TAVOR            0x5a44
52 #endif
53
54 #ifndef PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT
55 #define PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT     0x6278
56 #endif
57
58 #ifndef PCI_DEVICE_ID_MELLANOX_ARBEL
59 #define PCI_DEVICE_ID_MELLANOX_ARBEL            0x6282
60 #endif
61
62 #ifndef PCI_DEVICE_ID_MELLANOX_SINAI_OLD
63 #define PCI_DEVICE_ID_MELLANOX_SINAI_OLD        0x5e8c
64 #endif
65
66 #ifndef PCI_DEVICE_ID_MELLANOX_SINAI
67 #define PCI_DEVICE_ID_MELLANOX_SINAI            0x6274
68 #endif
69
70 #ifndef PCI_VENDOR_ID_TOPSPIN
71 #define PCI_VENDOR_ID_TOPSPIN                   0x1867
72 #endif
73
74 #define HCA(v, d, t) \
75         { PCI_VENDOR_ID_##v,    PCI_DEVICE_ID_MELLANOX_##d, MTHCA_##t }
76
77 static struct pci_device_id {
78         unsigned                vendor;
79         unsigned                device;
80         enum mthca_hca_type     type;
81 } mthca_pci_table[] = {
82         HCA( MELLANOX,  TAVOR,                          TAVOR),
83         HCA( MELLANOX,  ARBEL_COMPAT,   TAVOR),
84         HCA( MELLANOX,  ARBEL,                                  ARBEL),
85         HCA( MELLANOX,  SINAI_OLD,              ARBEL),
86         HCA( MELLANOX,  SINAI,                                  ARBEL),
87         HCA( TOPSPIN,           TAVOR,                          TAVOR),
88         HCA( TOPSPIN,           ARBEL_COMPAT,   TAVOR),
89         HCA( TOPSPIN,           ARBEL,                                  ARBEL),
90         HCA( TOPSPIN,           SINAI_OLD,                      ARBEL),
91         HCA( TOPSPIN,           SINAI,                                  ARBEL),
92 };
93
94 static struct ibv_context_ops mthca_ctx_ops = {
95         NULL,   // mthca_query_device,
96         NULL,   // mthca_query_port,
97         mthca_alloc_pd,
98         mthca_free_pd,
99         NULL,   // mthca_reg_mr,
100         NULL,   // mthca_dereg_mr,
101         mthca_create_cq_pre,
102         mthca_create_cq_post,
103         mthca_poll_cq,
104         mthca_poll_cq_list,
105         NULL,   /* req_notify_cq */
106         mthca_destroy_cq,
107         NULL,   // mthca_create_srq,
108         NULL,   // mthca_modify_srq,
109         NULL,   // mthca_destroy_srq,
110         NULL,   /* post_srq_recv */
111         mthca_create_qp_pre,
112         mthca_create_qp_post,
113         mthca_modify_qp,
114         mthca_destroy_qp,
115         NULL,   /* post_send */
116         NULL,   /* post_recv */
117         mthca_attach_mcast,
118         mthca_detach_mcast
119 };
120
121 struct ibv_context *mthca_alloc_context(struct ibv_get_context_resp *resp_p)
122 {
123         struct mthca_context    *       context;
124         struct ibv_alloc_pd_resp        pd_resp;
125         int                                             i;
126
127         /* allocate context */
128         context = cl_malloc(sizeof *context);
129         if (!context)
130                 return NULL;
131
132         /* find page size  */
133         if (!g_page_size) {
134                 SYSTEM_INFO sys_info;
135                 GetSystemInfo(&sys_info);
136                 g_page_size     = sys_info.dwPageSize;
137         }
138
139         /* calculate device type */
140         for (i = 0; i < sizeof mthca_pci_table / sizeof mthca_pci_table[0]; ++i) 
141                 if (resp_p->vend_id == mthca_pci_table[i].vendor &&
142                         resp_p->dev_id == mthca_pci_table[i].device) 
143                         goto found;
144         goto err_dev_type;
145
146 found:
147         context->hca_type = mthca_pci_table[i].type;
148         context->uar = (void*)(UINT_PTR)resp_p->uar_addr;
149         context->num_qps        = resp_p->qp_tab_size;
150         context->qp_table_shift = ffs(context->num_qps) - 1 - MTHCA_QP_TABLE_BITS;
151         context->qp_table_mask  = (1 << context->qp_table_shift) - 1;
152
153         if (mthca_is_memfree(&context->ibv_ctx)) {
154                 context->db_tab = mthca_alloc_db_tab(resp_p->uarc_size);
155                 if (!context->db_tab)
156                         goto err_alloc_db_tab;
157         } else
158                 context->db_tab = NULL;
159
160         context->qp_table_mutex = CreateMutex( NULL, FALSE, NULL );
161         if (!context->qp_table_mutex)
162                 goto err_mutex;
163         for (i = 0; i < MTHCA_QP_TABLE_SIZE; ++i)
164                 context->qp_table[i].refcnt = 0;
165
166         cl_spinlock_construct(&context->uar_lock);
167         if (cl_spinlock_init(&context->uar_lock))
168                 goto err_spinlock;
169
170         pd_resp.pd_handle = resp_p->pd_handle;
171         pd_resp.pdn = resp_p->pdn;
172         context->pd = mthca_alloc_pd(&context->ibv_ctx, &pd_resp);
173         if (!context->pd)
174                 goto err_unmap;
175
176         context->ibv_ctx.ops = mthca_ctx_ops;
177
178         if (mthca_is_memfree(&context->ibv_ctx)) {
179                 context->ibv_ctx.ops.req_notify_cq = mthca_arbel_arm_cq;
180                 context->ibv_ctx.ops.post_send     = mthca_arbel_post_send;
181                 context->ibv_ctx.ops.post_recv     = mthca_arbel_post_recv;
182                 context->ibv_ctx.ops.post_srq_recv = mthca_arbel_post_srq_recv;
183         } else {
184                 context->ibv_ctx.ops.req_notify_cq = mthca_tavor_arm_cq;
185                 context->ibv_ctx.ops.post_send     = mthca_tavor_post_send;
186                 context->ibv_ctx.ops.post_recv     = mthca_tavor_post_recv;
187                 context->ibv_ctx.ops.post_srq_recv = mthca_tavor_post_srq_recv;
188         }
189
190         return &context->ibv_ctx;
191
192 err_unmap:
193 err_spinlock:
194 err_mutex:
195         mthca_free_db_tab(context->db_tab);
196
197 err_alloc_db_tab:
198 err_dev_type:
199         cl_free(context);
200         return NULL;
201 }
202
203 void mthca_free_context(struct ibv_context *ibctx)
204 {
205         struct mthca_context *context = to_mctx(ibctx);
206
207         cl_spinlock_destroy(&context->uar_lock);
208         mthca_free_pd(context->pd);
209         mthca_free_db_tab(context->db_tab);
210         cl_free(context);
211 }