2 * Copyright (c) 2009-2010 Chelsio, Inc. All rights reserved.
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:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
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.
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
32 /* Crude resource management */
33 #include <linux/kernel.h>
34 #include <linux/random.h>
35 #include <linux/slab.h>
36 #include <linux/kfifo.h>
37 #include <linux/spinlock.h>
38 #include <linux/errno.h>
39 #include <linux/genalloc.h>
42 #define RANDOM_SIZE 16
44 static int __c4iw_init_resource_fifo(struct kfifo
*fifo
,
45 spinlock_t
*fifo_lock
,
50 u32 i
, j
, entry
= 0, idx
;
53 spin_lock_init(fifo_lock
);
55 if (kfifo_alloc(fifo
, nr
* sizeof(u32
), GFP_KERNEL
))
58 for (i
= 0; i
< skip_low
+ skip_high
; i
++)
59 kfifo_in(fifo
, (unsigned char *) &entry
, sizeof(u32
));
62 random_bytes
= random32();
63 for (i
= 0; i
< RANDOM_SIZE
; i
++)
64 rarray
[i
] = i
+ skip_low
;
65 for (i
= skip_low
+ RANDOM_SIZE
; i
< nr
- skip_high
; i
++) {
66 if (j
>= RANDOM_SIZE
) {
68 random_bytes
= random32();
70 idx
= (random_bytes
>> (j
* 2)) & 0xF;
72 (unsigned char *) &rarray
[idx
],
77 for (i
= 0; i
< RANDOM_SIZE
; i
++)
79 (unsigned char *) &rarray
[i
],
82 for (i
= skip_low
; i
< nr
- skip_high
; i
++)
83 kfifo_in(fifo
, (unsigned char *) &i
, sizeof(u32
));
85 for (i
= 0; i
< skip_low
+ skip_high
; i
++)
86 if (kfifo_out_locked(fifo
, (unsigned char *) &entry
,
87 sizeof(u32
), fifo_lock
))
92 static int c4iw_init_resource_fifo(struct kfifo
*fifo
, spinlock_t
* fifo_lock
,
93 u32 nr
, u32 skip_low
, u32 skip_high
)
95 return __c4iw_init_resource_fifo(fifo
, fifo_lock
, nr
, skip_low
,
99 static int c4iw_init_resource_fifo_random(struct kfifo
*fifo
,
100 spinlock_t
*fifo_lock
,
101 u32 nr
, u32 skip_low
, u32 skip_high
)
103 return __c4iw_init_resource_fifo(fifo
, fifo_lock
, nr
, skip_low
,
107 static int c4iw_init_qid_fifo(struct c4iw_rdev
*rdev
)
111 spin_lock_init(&rdev
->resource
.qid_fifo_lock
);
113 if (kfifo_alloc(&rdev
->resource
.qid_fifo
, T4_MAX_QIDS
* sizeof(u32
),
117 for (i
= T4_QID_BASE
; i
< T4_QID_BASE
+ T4_MAX_QIDS
; i
++)
118 if (!(i
& rdev
->qpmask
))
119 kfifo_in(&rdev
->resource
.qid_fifo
,
120 (unsigned char *) &i
, sizeof(u32
));
124 /* nr_* must be power of 2 */
125 int c4iw_init_resource(struct c4iw_rdev
*rdev
, u32 nr_tpt
, u32 nr_pdid
)
128 err
= c4iw_init_resource_fifo_random(&rdev
->resource
.tpt_fifo
,
129 &rdev
->resource
.tpt_fifo_lock
,
133 err
= c4iw_init_qid_fifo(rdev
);
136 err
= c4iw_init_resource_fifo(&rdev
->resource
.pdid_fifo
,
137 &rdev
->resource
.pdid_fifo_lock
,
143 kfifo_free(&rdev
->resource
.qid_fifo
);
145 kfifo_free(&rdev
->resource
.tpt_fifo
);
151 * returns 0 if no resource available
153 u32
c4iw_get_resource(struct kfifo
*fifo
, spinlock_t
*lock
)
156 if (kfifo_out_locked(fifo
, (unsigned char *) &entry
, sizeof(u32
), lock
))
162 void c4iw_put_resource(struct kfifo
*fifo
, u32 entry
, spinlock_t
*lock
)
164 PDBG("%s entry 0x%x\n", __func__
, entry
);
165 kfifo_in_locked(fifo
, (unsigned char *) &entry
, sizeof(u32
), lock
);
168 u32
c4iw_get_cqid(struct c4iw_rdev
*rdev
, struct c4iw_dev_ucontext
*uctx
)
170 struct c4iw_qid_list
*entry
;
174 mutex_lock(&uctx
->lock
);
175 if (!list_empty(&uctx
->cqids
)) {
176 entry
= list_entry(uctx
->cqids
.next
, struct c4iw_qid_list
,
178 list_del(&entry
->entry
);
182 qid
= c4iw_get_resource(&rdev
->resource
.qid_fifo
,
183 &rdev
->resource
.qid_fifo_lock
);
186 for (i
= qid
+1; i
& rdev
->qpmask
; i
++) {
187 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
191 list_add_tail(&entry
->entry
, &uctx
->cqids
);
195 * now put the same ids on the qp list since they all
196 * map to the same db/gts page.
198 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
202 list_add_tail(&entry
->entry
, &uctx
->qpids
);
203 for (i
= qid
+1; i
& rdev
->qpmask
; i
++) {
204 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
208 list_add_tail(&entry
->entry
, &uctx
->qpids
);
212 mutex_unlock(&uctx
->lock
);
213 PDBG("%s qid 0x%x\n", __func__
, qid
);
217 void c4iw_put_cqid(struct c4iw_rdev
*rdev
, u32 qid
,
218 struct c4iw_dev_ucontext
*uctx
)
220 struct c4iw_qid_list
*entry
;
222 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
225 PDBG("%s qid 0x%x\n", __func__
, qid
);
227 mutex_lock(&uctx
->lock
);
228 list_add_tail(&entry
->entry
, &uctx
->cqids
);
229 mutex_unlock(&uctx
->lock
);
232 u32
c4iw_get_qpid(struct c4iw_rdev
*rdev
, struct c4iw_dev_ucontext
*uctx
)
234 struct c4iw_qid_list
*entry
;
238 mutex_lock(&uctx
->lock
);
239 if (!list_empty(&uctx
->qpids
)) {
240 entry
= list_entry(uctx
->qpids
.next
, struct c4iw_qid_list
,
242 list_del(&entry
->entry
);
246 qid
= c4iw_get_resource(&rdev
->resource
.qid_fifo
,
247 &rdev
->resource
.qid_fifo_lock
);
250 for (i
= qid
+1; i
& rdev
->qpmask
; i
++) {
251 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
255 list_add_tail(&entry
->entry
, &uctx
->qpids
);
259 * now put the same ids on the cq list since they all
260 * map to the same db/gts page.
262 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
266 list_add_tail(&entry
->entry
, &uctx
->cqids
);
267 for (i
= qid
; i
& rdev
->qpmask
; i
++) {
268 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
272 list_add_tail(&entry
->entry
, &uctx
->cqids
);
276 mutex_unlock(&uctx
->lock
);
277 PDBG("%s qid 0x%x\n", __func__
, qid
);
281 void c4iw_put_qpid(struct c4iw_rdev
*rdev
, u32 qid
,
282 struct c4iw_dev_ucontext
*uctx
)
284 struct c4iw_qid_list
*entry
;
286 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
289 PDBG("%s qid 0x%x\n", __func__
, qid
);
291 mutex_lock(&uctx
->lock
);
292 list_add_tail(&entry
->entry
, &uctx
->qpids
);
293 mutex_unlock(&uctx
->lock
);
296 void c4iw_destroy_resource(struct c4iw_resource
*rscp
)
298 kfifo_free(&rscp
->tpt_fifo
);
299 kfifo_free(&rscp
->qid_fifo
);
300 kfifo_free(&rscp
->pdid_fifo
);
304 * PBL Memory Manager. Uses Linux generic allocator.
307 #define MIN_PBL_SHIFT 8 /* 256B == min PBL size (32 entries) */
309 u32
c4iw_pblpool_alloc(struct c4iw_rdev
*rdev
, int size
)
311 unsigned long addr
= gen_pool_alloc(rdev
->pbl_pool
, size
);
312 PDBG("%s addr 0x%x size %d\n", __func__
, (u32
)addr
, size
);
316 void c4iw_pblpool_free(struct c4iw_rdev
*rdev
, u32 addr
, int size
)
318 PDBG("%s addr 0x%x size %d\n", __func__
, addr
, size
);
319 gen_pool_free(rdev
->pbl_pool
, (unsigned long)addr
, size
);
322 int c4iw_pblpool_create(struct c4iw_rdev
*rdev
)
324 unsigned pbl_start
, pbl_chunk
, pbl_top
;
326 rdev
->pbl_pool
= gen_pool_create(MIN_PBL_SHIFT
, -1);
330 pbl_start
= rdev
->lldi
.vr
->pbl
.start
;
331 pbl_chunk
= rdev
->lldi
.vr
->pbl
.size
;
332 pbl_top
= pbl_start
+ pbl_chunk
;
334 while (pbl_start
< pbl_top
) {
335 pbl_chunk
= min(pbl_top
- pbl_start
+ 1, pbl_chunk
);
336 if (gen_pool_add(rdev
->pbl_pool
, pbl_start
, pbl_chunk
, -1)) {
337 PDBG("%s failed to add PBL chunk (%x/%x)\n",
338 __func__
, pbl_start
, pbl_chunk
);
339 if (pbl_chunk
<= 1024 << MIN_PBL_SHIFT
) {
340 printk(KERN_WARNING MOD
341 "Failed to add all PBL chunks (%x/%x)\n",
343 pbl_top
- pbl_start
);
348 PDBG("%s added PBL chunk (%x/%x)\n",
349 __func__
, pbl_start
, pbl_chunk
);
350 pbl_start
+= pbl_chunk
;
357 void c4iw_pblpool_destroy(struct c4iw_rdev
*rdev
)
359 gen_pool_destroy(rdev
->pbl_pool
);
363 * RQT Memory Manager. Uses Linux generic allocator.
366 #define MIN_RQT_SHIFT 10 /* 1KB == min RQT size (16 entries) */
368 u32
c4iw_rqtpool_alloc(struct c4iw_rdev
*rdev
, int size
)
370 unsigned long addr
= gen_pool_alloc(rdev
->rqt_pool
, size
<< 6);
371 PDBG("%s addr 0x%x size %d\n", __func__
, (u32
)addr
, size
<< 6);
375 void c4iw_rqtpool_free(struct c4iw_rdev
*rdev
, u32 addr
, int size
)
377 PDBG("%s addr 0x%x size %d\n", __func__
, addr
, size
<< 6);
378 gen_pool_free(rdev
->rqt_pool
, (unsigned long)addr
, size
<< 6);
381 int c4iw_rqtpool_create(struct c4iw_rdev
*rdev
)
383 unsigned rqt_start
, rqt_chunk
, rqt_top
;
385 rdev
->rqt_pool
= gen_pool_create(MIN_RQT_SHIFT
, -1);
389 rqt_start
= rdev
->lldi
.vr
->rq
.start
;
390 rqt_chunk
= rdev
->lldi
.vr
->rq
.size
;
391 rqt_top
= rqt_start
+ rqt_chunk
;
393 while (rqt_start
< rqt_top
) {
394 rqt_chunk
= min(rqt_top
- rqt_start
+ 1, rqt_chunk
);
395 if (gen_pool_add(rdev
->rqt_pool
, rqt_start
, rqt_chunk
, -1)) {
396 PDBG("%s failed to add RQT chunk (%x/%x)\n",
397 __func__
, rqt_start
, rqt_chunk
);
398 if (rqt_chunk
<= 1024 << MIN_RQT_SHIFT
) {
399 printk(KERN_WARNING MOD
400 "Failed to add all RQT chunks (%x/%x)\n",
401 rqt_start
, rqt_top
- rqt_start
);
406 PDBG("%s added RQT chunk (%x/%x)\n",
407 __func__
, rqt_start
, rqt_chunk
);
408 rqt_start
+= rqt_chunk
;
414 void c4iw_rqtpool_destroy(struct c4iw_rdev
*rdev
)
416 gen_pool_destroy(rdev
->rqt_pool
);
This page took 0.040172 seconds and 6 git commands to generate.