52ee7a93eee350ec8e33ae18e80b4e6b48584586
[mirror/winof/.git] / hw / mthca / user / mlnx_uvp_ah.c
1 /*
2  * Copyright (c) 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: ah.c 4001 2005-11-09 18:26:28Z roland $
33  */
34
35 #include "mt_l2w.h"
36 #include "mlnx_uvp.h"
37 #include "mx_abi.h"
38
39 struct mthca_ah_page {
40         struct mthca_ah_page *prev, *next;
41         void                 *buf;
42         struct ibv_mr        mr;
43         int                   use_cnt;
44         unsigned              free[0];
45 };
46
47 static struct mthca_ah_page *__add_page(struct mthca_pd *pd, int per_page)
48 {
49         struct mthca_ah_page *page;
50         int i;
51
52         page = cl_malloc(sizeof *page + per_page * sizeof (int));
53         if (!page)
54                 return NULL;
55
56         page->use_cnt = 0;
57         for (i = 0; i < per_page; ++i)
58                 page->free[i] = ~0;
59
60         page->prev = NULL;
61         page->next = pd->ah_list;
62         pd->ah_list = page;
63         if (page->next)
64                 page->next->prev = page;
65
66         return page;
67 }
68
69 int mthca_alloc_av(struct mthca_pd *pd, struct ibv_ah_attr *attr,
70                    struct mthca_ah *ah, struct ibv_create_ah_resp *resp)
71 {
72         if (mthca_is_memfree(pd->ibv_pd.context)) {
73                 ah->av = cl_malloc(sizeof *ah->av);
74                 if (!ah->av)
75                         return -ENOMEM;
76         } else {
77                 struct mthca_ah_page *page;
78                 int ps;
79                 int pp;
80                 int i, j;
81
82                 ps = g_page_size;
83                 pp = ps / (sizeof *ah->av * 8 * sizeof (int));
84
85                 WaitForSingleObject( pd->ah_mutex, INFINITE );
86                 for (page = pd->ah_list; page; page = page->next)
87                         if (page->use_cnt < ps / (int)(sizeof *ah->av))
88                                 for (i = 0; i < pp; ++i)
89                                         if (page->free[i])
90                                                 goto found;
91
92                 page = __add_page(pd, pp);
93                 if (!page) {
94                         ReleaseMutex( pd->ah_mutex );
95                         return -ENOMEM;
96                 }
97
98         found:
99
100                 // fill mr parameters
101                 page->buf = (void*)(ULONG_PTR)resp->start;
102                 page->mr.handle = resp->mr.mr_handle;
103                 page->mr.lkey = resp->mr.lkey;
104                 page->mr.rkey = resp->mr.rkey;
105                 page->mr.pd = (struct ibv_pd*)pd;
106                 page->mr.context = pd->ibv_pd.context;
107                 
108                 ++page->use_cnt;
109
110                 for (i = 0, j = -1; i < pp; ++i)
111                         if (page->free[i]) {
112                                 j = ffs(page->free[i]);
113                                 page->free[i] &= ~(1 << (j - 1));
114                                 ah->av = (struct mthca_av *)((uint8_t*)page->buf +
115                                         (i * 8 * sizeof (int) + (j - 1)) * sizeof *ah->av);
116                                 break;
117                         }
118
119                 ah->key  = page->mr.lkey;
120                 ah->page = page;
121
122                 ReleaseMutex( pd->ah_mutex );
123         }
124
125         memset(ah->av, 0, sizeof *ah->av);
126
127         ah->av->port_pd = cl_hton32(pd->pdn | (attr->port_num << 24));
128         ah->av->g_slid  = attr->src_path_bits;
129         ah->av->dlid    = cl_hton16(attr->dlid);
130         ah->av->msg_sr  = (3 << 4) | /* 2K message */
131         attr->static_rate;
132         ah->av->sl_tclass_flowlabel = cl_hton32(attr->sl << 28);
133         if (attr->is_global) {
134                 ah->av->g_slid |= 0x80;
135                 /* XXX get gid_table length */
136                 ah->av->gid_index = (attr->port_num - 1) * 32 +
137                         attr->grh.sgid_index;
138                 ah->av->hop_limit = attr->grh.hop_limit;
139                 ah->av->sl_tclass_flowlabel |=
140                         cl_hton32((attr->grh.traffic_class << 20) |
141                                     attr->grh.flow_label);
142                 memcpy(ah->av->dgid, attr->grh.dgid.raw, 16);
143         } else {
144                 /* Arbel workaround -- low byte of GID must be 2 */
145                 ah->av->dgid[3] = cl_hton32(2);
146         }
147
148         return 0;
149 }
150
151 void mthca_free_av(struct mthca_ah *ah)
152 {
153         if (mthca_is_memfree(ah->ibv_ah.pd->context)) {
154                 cl_free(ah->av);
155         } else {
156                 struct mthca_pd *pd = to_mpd(ah->ibv_ah.pd);
157                 struct mthca_ah_page *page;
158                 int i;
159
160                 WaitForSingleObject( pd->ah_mutex, INFINITE );
161                 page = ah->page;
162                 i = ((uint8_t *)ah->av - (uint8_t *)page->buf) / sizeof *ah->av;
163                 page->free[i / (8 * sizeof (int))] |= 1 << (i % (8 * sizeof (int)));
164
165                 if (!--page->use_cnt) {
166                         if (page->prev)
167                                 page->prev->next = page->next;
168                         else
169                                 pd->ah_list = page->next;
170                         if (page->next)
171                                 page->next->prev = page->prev;
172
173 #ifdef NOT_USE_VIRTUAL_ALLOC    
174                         cl_free(page->buf);
175 #else
176                         VirtualFree( page->buf, 0, MEM_RELEASE);
177 #endif
178                         
179                         cl_free(page);
180                 }
181
182                 ReleaseMutex( pd->ah_mutex );
183         }
184 }
185
186 //NB: temporary, for support of modify_qp
187 void mthca_set_av_params(       struct mthca_ah *ah_p, struct ibv_ah_attr *ah_attr )
188 {
189         struct mthca_av *av      = ah_p->av;
190         struct ibv_ah *ib_ah_p = (struct ibv_ah *)ah_p;
191         struct mthca_pd *pd = (struct mthca_pd *)ib_ah_p->pd;
192
193         // taken from mthca_alloc_av
194         //TODO: why cl_hton32 ?
195         av->port_pd = cl_hton32(pd->pdn | (ah_attr->port_num << 24));
196         av->g_slid      = ah_attr->src_path_bits;
197         //TODO: why cl_hton16 ?
198         av->dlid                = cl_hton16(ah_attr->dlid);
199         av->msg_sr      = (3 << 4) | /* 2K message */
200                 ah_attr->static_rate;
201         //TODO: why cl_hton32 ?
202         av->sl_tclass_flowlabel = cl_hton32(ah_attr->sl << 28);
203         if (ah_attr->is_global) {
204                 av->g_slid |= 0x80;
205                 av->gid_index = (ah_attr->port_num - 1) * 32 +
206                         ah_attr->grh.sgid_index;
207                 av->hop_limit = ah_attr->grh.hop_limit;
208                 av->sl_tclass_flowlabel |= cl_hton32((ah_attr->grh.traffic_class << 20) |
209                         ah_attr->grh.flow_label);
210                 memcpy(av->dgid, ah_attr->grh.dgid.raw, 16);
211         } else {
212                 /* Arbel workaround -- low byte of GID must be 2 */
213                 //TODO: why cl_hton32 ?
214                 av->dgid[3] = cl_hton32(2);
215         }
216 }
217