mlx4: /dev/ -> /dev_vfs/
[akaros.git] / kern / drivers / net / mlx4 / pd.c
1 /*
2  * Copyright (c) 2006, 2007 Cisco Systems, Inc.  All rights reserved.
3  * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/errno.h>
35 #include "mlx4.h"
36 #include "icm.h"
37
38 enum {
39         MLX4_NUM_RESERVED_UARS = 8
40 };
41
42 int mlx4_pd_alloc(struct mlx4_dev *dev, uint32_t *pdn)
43 {
44         struct mlx4_priv *priv = mlx4_priv(dev);
45
46         *pdn = mlx4_bitmap_alloc(&priv->pd_bitmap);
47         if (*pdn == -1)
48                 return -ENOMEM;
49
50         return 0;
51 }
52 EXPORT_SYMBOL_GPL(mlx4_pd_alloc);
53
54 void mlx4_pd_free(struct mlx4_dev *dev, uint32_t pdn)
55 {
56         mlx4_bitmap_free(&mlx4_priv(dev)->pd_bitmap, pdn, MLX4_USE_RR);
57 }
58 EXPORT_SYMBOL_GPL(mlx4_pd_free);
59
60 int __mlx4_xrcd_alloc(struct mlx4_dev *dev, uint32_t *xrcdn)
61 {
62         struct mlx4_priv *priv = mlx4_priv(dev);
63
64         *xrcdn = mlx4_bitmap_alloc(&priv->xrcd_bitmap);
65         if (*xrcdn == -1)
66                 return -ENOMEM;
67
68         return 0;
69 }
70
71 int mlx4_xrcd_alloc(struct mlx4_dev *dev, uint32_t *xrcdn)
72 {
73         uint64_t out_param;
74         int err;
75
76         if (mlx4_is_mfunc(dev)) {
77                 err = mlx4_cmd_imm(dev, 0, &out_param,
78                                    RES_XRCD, RES_OP_RESERVE,
79                                    MLX4_CMD_ALLOC_RES,
80                                    MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
81                 if (err)
82                         return err;
83
84                 *xrcdn = get_param_l(&out_param);
85                 return 0;
86         }
87         return __mlx4_xrcd_alloc(dev, xrcdn);
88 }
89 EXPORT_SYMBOL_GPL(mlx4_xrcd_alloc);
90
91 void __mlx4_xrcd_free(struct mlx4_dev *dev, uint32_t xrcdn)
92 {
93         mlx4_bitmap_free(&mlx4_priv(dev)->xrcd_bitmap, xrcdn, MLX4_USE_RR);
94 }
95
96 void mlx4_xrcd_free(struct mlx4_dev *dev, uint32_t xrcdn)
97 {
98         uint64_t in_param = 0;
99         int err;
100
101         if (mlx4_is_mfunc(dev)) {
102                 set_param_l(&in_param, xrcdn);
103                 err = mlx4_cmd(dev, in_param, RES_XRCD,
104                                RES_OP_RESERVE, MLX4_CMD_FREE_RES,
105                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
106                 if (err)
107                         mlx4_warn(dev, "Failed to release xrcdn %d\n", xrcdn);
108         } else
109                 __mlx4_xrcd_free(dev, xrcdn);
110 }
111 EXPORT_SYMBOL_GPL(mlx4_xrcd_free);
112
113 int mlx4_init_pd_table(struct mlx4_dev *dev)
114 {
115         struct mlx4_priv *priv = mlx4_priv(dev);
116
117         return mlx4_bitmap_init(&priv->pd_bitmap, dev->caps.num_pds,
118                                 (1 << NOT_MASKED_PD_BITS) - 1,
119                                  dev->caps.reserved_pds, 0);
120 }
121
122 void mlx4_cleanup_pd_table(struct mlx4_dev *dev)
123 {
124         mlx4_bitmap_cleanup(&mlx4_priv(dev)->pd_bitmap);
125 }
126
127 int mlx4_init_xrcd_table(struct mlx4_dev *dev)
128 {
129         struct mlx4_priv *priv = mlx4_priv(dev);
130
131         return mlx4_bitmap_init(&priv->xrcd_bitmap, (1 << 16),
132                                 (1 << 16) - 1, dev->caps.reserved_xrcds + 1, 0);
133 }
134
135 void mlx4_cleanup_xrcd_table(struct mlx4_dev *dev)
136 {
137         mlx4_bitmap_cleanup(&mlx4_priv(dev)->xrcd_bitmap);
138 }
139
140 int mlx4_uar_alloc(struct mlx4_dev *dev, struct mlx4_uar *uar)
141 {
142         int offset;
143
144         uar->index = mlx4_bitmap_alloc(&mlx4_priv(dev)->uar_table.bitmap);
145         if (uar->index == -1)
146                 return -ENOMEM;
147
148         if (mlx4_is_slave(dev))
149                 offset = uar->index % ((int)pci_resource_len(dev->persist->pdev,
150                                                              2) /
151                                        dev->caps.uar_page_size);
152         else
153                 offset = uar->index;
154 #if 0 // AKAROS_PORT
155         uar->pfn = (pci_resource_start(dev->persist->pdev, 2) >> PAGE_SHIFT)
156 #else
157         uar->pfn = ((uintptr_t)pci_resource_start(dev->persist->pdev, 2) >> PAGE_SHIFT)
158 #endif
159                     + offset;
160         uar->map = NULL;
161         return 0;
162 }
163 EXPORT_SYMBOL_GPL(mlx4_uar_alloc);
164
165 void mlx4_uar_free(struct mlx4_dev *dev, struct mlx4_uar *uar)
166 {
167         mlx4_bitmap_free(&mlx4_priv(dev)->uar_table.bitmap, uar->index, MLX4_USE_RR);
168 }
169 EXPORT_SYMBOL_GPL(mlx4_uar_free);
170
171 int mlx4_bf_alloc(struct mlx4_dev *dev, struct mlx4_bf *bf, int node)
172 {
173         panic("Disabled");
174 #if 0 // AKAROS_PORT
175         struct mlx4_priv *priv = mlx4_priv(dev);
176         struct mlx4_uar *uar;
177         int err = 0;
178         int idx;
179
180         if (!priv->bf_mapping)
181                 return -ENOMEM;
182
183         qlock(&priv->bf_mutex);
184         if (!list_empty(&priv->bf_list))
185                 uar = list_entry(priv->bf_list.next, struct mlx4_uar, bf_list);
186         else {
187                 if (mlx4_bitmap_avail(&priv->uar_table.bitmap) < MLX4_NUM_RESERVED_UARS) {
188                         err = -ENOMEM;
189                         goto out;
190                 }
191                 uar = kmalloc_node(sizeof(*uar), MEM_WAIT, node);
192                 if (!uar) {
193                         uar = kmalloc(sizeof(*uar), MEM_WAIT);
194                         if (!uar) {
195                                 err = -ENOMEM;
196                                 goto out;
197                         }
198                 }
199                 err = mlx4_uar_alloc(dev, uar);
200                 if (err)
201                         goto free_kmalloc;
202
203                 uar->map = ioremap(uar->pfn << PAGE_SHIFT, PAGE_SIZE);
204                 if (!uar->map) {
205                         err = -ENOMEM;
206                         goto free_uar;
207                 }
208
209                 uar->bf_map = io_mapping_map_wc(priv->bf_mapping, uar->index << PAGE_SHIFT);
210                 if (!uar->bf_map) {
211                         err = -ENOMEM;
212                         goto unamp_uar;
213                 }
214                 uar->free_bf_bmap = 0;
215                 list_add(&uar->bf_list, &priv->bf_list);
216         }
217
218         idx = ffz(uar->free_bf_bmap);
219         uar->free_bf_bmap |= 1 << idx;
220         bf->uar = uar;
221         bf->offset = 0;
222         bf->buf_size = dev->caps.bf_reg_size / 2;
223         bf->reg = uar->bf_map + idx * dev->caps.bf_reg_size;
224         if (uar->free_bf_bmap == (1 << dev->caps.bf_regs_per_page) - 1)
225                 list_del_init(&uar->bf_list);
226
227         goto out;
228
229 unamp_uar:
230         bf->uar = NULL;
231         iounmap(uar->map);
232
233 free_uar:
234         mlx4_uar_free(dev, uar);
235
236 free_kmalloc:
237         kfree(uar);
238
239 out:
240         qunlock(&priv->bf_mutex);
241         return err;
242 #endif
243 }
244 EXPORT_SYMBOL_GPL(mlx4_bf_alloc);
245
246 void mlx4_bf_free(struct mlx4_dev *dev, struct mlx4_bf *bf)
247 {
248         panic("Disabled");
249 #if 0 // AKAROS_PORT
250         struct mlx4_priv *priv = mlx4_priv(dev);
251         int idx;
252
253         if (!bf->uar || !bf->uar->bf_map)
254                 return;
255
256         qlock(&priv->bf_mutex);
257         idx = (bf->reg - bf->uar->bf_map) / dev->caps.bf_reg_size;
258         bf->uar->free_bf_bmap &= ~(1 << idx);
259         if (!bf->uar->free_bf_bmap) {
260                 if (!list_empty(&bf->uar->bf_list))
261                         list_del(&bf->uar->bf_list);
262
263                 io_mapping_unmap(bf->uar->bf_map);
264                 iounmap(bf->uar->map);
265                 mlx4_uar_free(dev, bf->uar);
266                 kfree(bf->uar);
267         } else if (list_empty(&bf->uar->bf_list))
268                 list_add(&bf->uar->bf_list, &priv->bf_list);
269
270         qunlock(&priv->bf_mutex);
271 #endif
272 }
273 EXPORT_SYMBOL_GPL(mlx4_bf_free);
274
275 int mlx4_init_uar_table(struct mlx4_dev *dev)
276 {
277         if (dev->caps.num_uars <= 128) {
278                 mlx4_err(dev, "Only %d UAR pages (need more than 128)\n",
279                          dev->caps.num_uars);
280                 mlx4_err(dev, "Increase firmware log2_uar_bar_megabytes?\n");
281                 return -ENODEV;
282         }
283
284         return mlx4_bitmap_init(&mlx4_priv(dev)->uar_table.bitmap,
285                                 dev->caps.num_uars, dev->caps.num_uars - 1,
286                                 dev->caps.reserved_uars, 0);
287 }
288
289 void mlx4_cleanup_uar_table(struct mlx4_dev *dev)
290 {
291         mlx4_bitmap_cleanup(&mlx4_priv(dev)->uar_table.bitmap);
292 }