[MTHCA] 1. A revised version of AV creation/destroy mechanism.
[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 "mlnx_ual_data.h"
38 #include "mx_abi.h"
39
40 static struct mthca_ah_page *__add_page(
41         struct mthca_pd *pd,  int page_size, int per_page)
42 {
43         struct mthca_ah_page *page;
44         int i;
45
46         page = cl_malloc(sizeof *page + per_page * sizeof (int));
47         if (!page)
48                 return NULL;
49
50         if (posix_memalign(&page->buf, page_size, page_size)) {
51                 cl_free(page);
52                 return NULL;
53         }
54
55         page->use_cnt = 0;
56         for (i = 0; i < per_page; ++i)
57                 page->free[i] = ~0;
58
59         page->prev = NULL;
60         page->next = pd->ah_list;
61         pd->ah_list = page;
62         if (page->next)
63                 page->next->prev = page;
64
65         return page;
66 }
67
68 int mthca_alloc_av(struct mthca_pd *pd, struct ibv_ah_attr *attr,
69                    struct mthca_ah *ah, struct ibv_create_ah_resp *resp)
70 {
71         int added_page = FALSE;
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, ps, pp);
93                 if (!page) {
94                         ReleaseMutex( pd->ah_mutex );
95                         return -ENOMEM;
96                 }
97                 added_page = TRUE;
98
99         found:
100                 ++page->use_cnt;
101
102                 for (i = 0, j = -1; i < pp; ++i)
103                         if (page->free[i]) {
104                                 j = ffs(page->free[i]);
105                                 page->free[i] &= ~(1 << (j - 1));
106                                 ah->av = (struct mthca_av *)((uint8_t*)page->buf +
107                                         (i * 8 * sizeof (int) + (j - 1)) * sizeof *ah->av);
108                                 break;
109                         }
110
111                 ah->page = page;
112
113                 ReleaseMutex( pd->ah_mutex );
114         }
115
116         memset(ah->av, 0, sizeof *ah->av);
117
118         ah->av->port_pd = cl_hton32(pd->pdn | (attr->port_num << 24));
119         ah->av->g_slid  = attr->src_path_bits;
120         ah->av->dlid    = cl_hton16(attr->dlid);
121         ah->av->msg_sr  = (3 << 4) | /* 2K message */
122         attr->static_rate;
123         ah->av->sl_tclass_flowlabel = cl_hton32(attr->sl << 28);
124         if (attr->is_global) {
125                 ah->av->g_slid |= 0x80;
126                 /* XXX get gid_table length */
127                 ah->av->gid_index = (attr->port_num - 1) * 32 +
128                         attr->grh.sgid_index;
129                 ah->av->hop_limit = attr->grh.hop_limit;
130                 ah->av->sl_tclass_flowlabel |=
131                         cl_hton32((attr->grh.traffic_class << 20) |
132                                     attr->grh.flow_label);
133                 memcpy(ah->av->dgid, attr->grh.dgid.raw, 16);
134         } else {
135                 /* Arbel workaround -- low byte of GID must be 2 */
136                 ah->av->dgid[3] = cl_hton32(2);
137         }
138
139         if (added_page)
140                 return -EAGAIN;
141         else
142                 return 0;
143 }
144
145 void mthca_free_av(struct mthca_ah *ah)
146 {
147         mlnx_ual_pd_info_t *p_pd = (mlnx_ual_pd_info_t *)ah->h_uvp_pd;
148         if (mthca_is_memfree(p_pd->ibv_pd->context)) {
149                 cl_free(ah->av);
150         } else {
151                 struct mthca_pd *pd = to_mpd(p_pd->ibv_pd);
152                 struct mthca_ah_page *page;
153                 int i;
154
155                 WaitForSingleObject( pd->ah_mutex, INFINITE );
156                 page = ah->page;
157                 i = ((uint8_t *)ah->av - (uint8_t *)page->buf) / sizeof *ah->av;
158                 page->free[i / (8 * sizeof (int))] |= 1 << (i % (8 * sizeof (int)));
159
160                 if (!--page->use_cnt) {
161                         if (page->prev)
162                                 page->prev->next = page->next;
163                         else
164                                 pd->ah_list = page->next;
165                         if (page->next)
166                                 page->next->prev = page->prev;
167
168 #ifdef NOT_USE_VIRTUAL_ALLOC    
169                         cl_free(page->buf);
170 #else
171                         VirtualFree( page->buf, 0, MEM_RELEASE);
172 #endif
173                         
174                         cl_free(page);
175                 }
176
177                 ReleaseMutex( pd->ah_mutex );
178         }
179 }
180
181 //NB: temporary, for support of modify_qp
182 void mthca_set_av_params(       struct mthca_ah *ah_p, struct ibv_ah_attr *ah_attr )
183 {
184         struct mthca_av *av      = ah_p->av;
185         mlnx_ual_pd_info_t *p_pd = (mlnx_ual_pd_info_t *)ah_p->h_uvp_pd;
186         struct mthca_pd *pd =to_mpd(p_pd->ibv_pd);
187
188         // taken from mthca_alloc_av
189         //TODO: why cl_hton32 ?
190         av->port_pd = cl_hton32(pd->pdn | (ah_attr->port_num << 24));
191         av->g_slid      = ah_attr->src_path_bits;
192         //TODO: why cl_hton16 ?
193         av->dlid                = cl_hton16(ah_attr->dlid);
194         av->msg_sr      = (3 << 4) | /* 2K message */
195                 ah_attr->static_rate;
196         //TODO: why cl_hton32 ?
197         av->sl_tclass_flowlabel = cl_hton32(ah_attr->sl << 28);
198         if (ah_attr->is_global) {
199                 av->g_slid |= 0x80;
200                 av->gid_index = (ah_attr->port_num - 1) * 32 +
201                         ah_attr->grh.sgid_index;
202                 av->hop_limit = ah_attr->grh.hop_limit;
203                 av->sl_tclass_flowlabel |= cl_hton32((ah_attr->grh.traffic_class << 20) |
204                         ah_attr->grh.flow_label);
205                 memcpy(av->dgid, ah_attr->grh.dgid.raw, 16);
206         } else {
207                 /* Arbel workaround -- low byte of GID must be 2 */
208                 //TODO: why cl_hton32 ?
209                 av->dgid[3] = cl_hton32(2);
210         }
211 }
212