]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/net/mlx4/alloc.c
2 * Copyright (c) 2006, 2007 Cisco Systems, Inc. All rights reserved.
3 * Copyright (c) 2007, 2008 Mellanox Technologies. All rights reserved.
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:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
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.
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
34 #include <linux/errno.h>
35 #include <linux/slab.h>
36 #include <linux/bitmap.h>
37 #include <linux/dma-mapping.h>
38 #include <linux/vmalloc.h>
42 u32
mlx4_bitmap_alloc(struct mlx4_bitmap
*bitmap
)
46 spin_lock(&bitmap
->lock
);
48 obj
= find_next_zero_bit(bitmap
->table
, bitmap
->max
, bitmap
->last
);
49 if (obj
>= bitmap
->max
) {
50 bitmap
->top
= (bitmap
->top
+ bitmap
->max
) & bitmap
->mask
;
51 obj
= find_first_zero_bit(bitmap
->table
, bitmap
->max
);
54 if (obj
< bitmap
->max
) {
55 set_bit(obj
, bitmap
->table
);
56 bitmap
->last
= (obj
+ 1) & (bitmap
->max
- 1);
61 spin_unlock(&bitmap
->lock
);
66 void mlx4_bitmap_free(struct mlx4_bitmap
*bitmap
, u32 obj
)
68 obj
&= bitmap
->max
- 1;
70 spin_lock(&bitmap
->lock
);
71 clear_bit(obj
, bitmap
->table
);
72 bitmap
->last
= min(bitmap
->last
, obj
);
73 bitmap
->top
= (bitmap
->top
+ bitmap
->max
) & bitmap
->mask
;
74 spin_unlock(&bitmap
->lock
);
77 int mlx4_bitmap_init(struct mlx4_bitmap
*bitmap
, u32 num
, u32 mask
, u32 reserved
)
81 /* num must be a power of 2 */
82 if (num
!= roundup_pow_of_two(num
))
89 spin_lock_init(&bitmap
->lock
);
90 bitmap
->table
= kzalloc(BITS_TO_LONGS(num
) * sizeof (long), GFP_KERNEL
);
94 for (i
= 0; i
< reserved
; ++i
)
95 set_bit(i
, bitmap
->table
);
100 void mlx4_bitmap_cleanup(struct mlx4_bitmap
*bitmap
)
102 kfree(bitmap
->table
);
106 * Handling for queue buffers -- we allocate a bunch of memory and
107 * register it in a memory region at HCA virtual address 0. If the
108 * requested size is > max_direct, we split the allocation into
109 * multiple pages, so we don't require too much contiguous memory.
112 int mlx4_buf_alloc(struct mlx4_dev
*dev
, int size
, int max_direct
,
113 struct mlx4_buf
*buf
)
117 if (size
<= max_direct
) {
120 buf
->page_shift
= get_order(size
) + PAGE_SHIFT
;
121 buf
->direct
.buf
= dma_alloc_coherent(&dev
->pdev
->dev
,
122 size
, &t
, GFP_KERNEL
);
123 if (!buf
->direct
.buf
)
128 while (t
& ((1 << buf
->page_shift
) - 1)) {
133 memset(buf
->direct
.buf
, 0, size
);
137 buf
->nbufs
= (size
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
138 buf
->npages
= buf
->nbufs
;
139 buf
->page_shift
= PAGE_SHIFT
;
140 buf
->page_list
= kzalloc(buf
->nbufs
* sizeof *buf
->page_list
,
145 for (i
= 0; i
< buf
->nbufs
; ++i
) {
146 buf
->page_list
[i
].buf
=
147 dma_alloc_coherent(&dev
->pdev
->dev
, PAGE_SIZE
,
149 if (!buf
->page_list
[i
].buf
)
152 buf
->page_list
[i
].map
= t
;
154 memset(buf
->page_list
[i
].buf
, 0, PAGE_SIZE
);
157 if (BITS_PER_LONG
== 64) {
159 pages
= kmalloc(sizeof *pages
* buf
->nbufs
, GFP_KERNEL
);
162 for (i
= 0; i
< buf
->nbufs
; ++i
)
163 pages
[i
] = virt_to_page(buf
->page_list
[i
].buf
);
164 buf
->direct
.buf
= vmap(pages
, buf
->nbufs
, VM_MAP
, PAGE_KERNEL
);
166 if (!buf
->direct
.buf
)
174 mlx4_buf_free(dev
, size
, buf
);
178 EXPORT_SYMBOL_GPL(mlx4_buf_alloc
);
180 void mlx4_buf_free(struct mlx4_dev
*dev
, int size
, struct mlx4_buf
*buf
)
185 dma_free_coherent(&dev
->pdev
->dev
, size
, buf
->direct
.buf
,
188 if (BITS_PER_LONG
== 64)
189 vunmap(buf
->direct
.buf
);
191 for (i
= 0; i
< buf
->nbufs
; ++i
)
192 if (buf
->page_list
[i
].buf
)
193 dma_free_coherent(&dev
->pdev
->dev
, PAGE_SIZE
,
194 buf
->page_list
[i
].buf
,
195 buf
->page_list
[i
].map
);
196 kfree(buf
->page_list
);
199 EXPORT_SYMBOL_GPL(mlx4_buf_free
);
201 static struct mlx4_db_pgdir
*mlx4_alloc_db_pgdir(struct device
*dma_device
)
203 struct mlx4_db_pgdir
*pgdir
;
205 pgdir
= kzalloc(sizeof *pgdir
, GFP_KERNEL
);
209 bitmap_fill(pgdir
->order1
, MLX4_DB_PER_PAGE
/ 2);
210 pgdir
->bits
[0] = pgdir
->order0
;
211 pgdir
->bits
[1] = pgdir
->order1
;
212 pgdir
->db_page
= dma_alloc_coherent(dma_device
, PAGE_SIZE
,
213 &pgdir
->db_dma
, GFP_KERNEL
);
214 if (!pgdir
->db_page
) {
222 static int mlx4_alloc_db_from_pgdir(struct mlx4_db_pgdir
*pgdir
,
223 struct mlx4_db
*db
, int order
)
228 for (o
= order
; o
<= 1; ++o
) {
229 i
= find_first_bit(pgdir
->bits
[o
], MLX4_DB_PER_PAGE
>> o
);
230 if (i
< MLX4_DB_PER_PAGE
>> o
)
237 clear_bit(i
, pgdir
->bits
[o
]);
242 set_bit(i
^ 1, pgdir
->bits
[order
]);
246 db
->db
= pgdir
->db_page
+ db
->index
;
247 db
->dma
= pgdir
->db_dma
+ db
->index
* 4;
253 int mlx4_db_alloc(struct mlx4_dev
*dev
, struct mlx4_db
*db
, int order
)
255 struct mlx4_priv
*priv
= mlx4_priv(dev
);
256 struct mlx4_db_pgdir
*pgdir
;
259 mutex_lock(&priv
->pgdir_mutex
);
261 list_for_each_entry(pgdir
, &priv
->pgdir_list
, list
)
262 if (!mlx4_alloc_db_from_pgdir(pgdir
, db
, order
))
265 pgdir
= mlx4_alloc_db_pgdir(&(dev
->pdev
->dev
));
271 list_add(&pgdir
->list
, &priv
->pgdir_list
);
273 /* This should never fail -- we just allocated an empty page: */
274 WARN_ON(mlx4_alloc_db_from_pgdir(pgdir
, db
, order
));
277 mutex_unlock(&priv
->pgdir_mutex
);
281 EXPORT_SYMBOL_GPL(mlx4_db_alloc
);
283 void mlx4_db_free(struct mlx4_dev
*dev
, struct mlx4_db
*db
)
285 struct mlx4_priv
*priv
= mlx4_priv(dev
);
289 mutex_lock(&priv
->pgdir_mutex
);
294 if (db
->order
== 0 && test_bit(i
^ 1, db
->u
.pgdir
->order0
)) {
295 clear_bit(i
^ 1, db
->u
.pgdir
->order0
);
299 set_bit(i
, db
->u
.pgdir
->bits
[o
]);
301 if (bitmap_full(db
->u
.pgdir
->order1
, MLX4_DB_PER_PAGE
/ 2)) {
302 dma_free_coherent(&(dev
->pdev
->dev
), PAGE_SIZE
,
303 db
->u
.pgdir
->db_page
, db
->u
.pgdir
->db_dma
);
304 list_del(&db
->u
.pgdir
->list
);
308 mutex_unlock(&priv
->pgdir_mutex
);
310 EXPORT_SYMBOL_GPL(mlx4_db_free
);
312 int mlx4_alloc_hwq_res(struct mlx4_dev
*dev
, struct mlx4_hwq_resources
*wqres
,
313 int size
, int max_direct
)
317 err
= mlx4_db_alloc(dev
, &wqres
->db
, 1);
323 err
= mlx4_buf_alloc(dev
, size
, max_direct
, &wqres
->buf
);
327 err
= mlx4_mtt_init(dev
, wqres
->buf
.npages
, wqres
->buf
.page_shift
,
332 err
= mlx4_buf_write_mtt(dev
, &wqres
->mtt
, &wqres
->buf
);
339 mlx4_mtt_cleanup(dev
, &wqres
->mtt
);
341 mlx4_buf_free(dev
, size
, &wqres
->buf
);
343 mlx4_db_free(dev
, &wqres
->db
);
347 EXPORT_SYMBOL_GPL(mlx4_alloc_hwq_res
);
349 void mlx4_free_hwq_res(struct mlx4_dev
*dev
, struct mlx4_hwq_resources
*wqres
,
352 mlx4_mtt_cleanup(dev
, &wqres
->mtt
);
353 mlx4_buf_free(dev
, size
, &wqres
->buf
);
354 mlx4_db_free(dev
, &wqres
->db
);
356 EXPORT_SYMBOL_GPL(mlx4_free_hwq_res
);