2 * Copyright (c) 2006 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 "cxio_resource.h"
42 static struct kfifo rhdl_fifo;
43 static spinlock_t rhdl_fifo_lock;
45 #define RANDOM_SIZE 16
47 static int __cxio_init_resource_fifo(struct kfifo *fifo,
48 spinlock_t *fifo_lock,
53 u32 i, j, entry = 0, idx;
56 spin_lock_init(fifo_lock);
58 if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL, fifo_lock))
61 for (i = 0; i < skip_low + skip_high; i++)
62 __kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32));
65 random_bytes = random32();
66 for (i = 0; i < RANDOM_SIZE; i++)
67 rarray[i] = i + skip_low;
68 for (i = skip_low + RANDOM_SIZE; i < nr - skip_high; i++) {
69 if (j >= RANDOM_SIZE) {
71 random_bytes = random32();
73 idx = (random_bytes >> (j * 2)) & 0xF;
75 (unsigned char *) &rarray[idx],
80 for (i = 0; i < RANDOM_SIZE; i++)
82 (unsigned char *) &rarray[i],
85 for (i = skip_low; i < nr - skip_high; i++)
86 __kfifo_put(fifo, (unsigned char *) &i, sizeof(u32));
88 for (i = 0; i < skip_low + skip_high; i++)
89 kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32));
93 static int cxio_init_resource_fifo(struct kfifo *fifo, spinlock_t * fifo_lock,
94 u32 nr, u32 skip_low, u32 skip_high)
96 return (__cxio_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
100 static int cxio_init_resource_fifo_random(struct kfifo *fifo,
101 spinlock_t * fifo_lock,
102 u32 nr, u32 skip_low, u32 skip_high)
105 return (__cxio_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
109 static int cxio_init_qpid_fifo(struct cxio_rdev *rdev_p)
113 spin_lock_init(&rdev_p->rscp->qpid_fifo_lock);
115 if (kfifo_alloc(&rdev_p->rscp->qpid_fifo, T3_MAX_NUM_QP * sizeof(u32),
117 &rdev_p->rscp->qpid_fifo_lock))
120 for (i = 16; i < T3_MAX_NUM_QP; i++)
121 if (!(i & rdev_p->qpmask))
122 __kfifo_put(&rdev_p->rscp->qpid_fifo,
123 (unsigned char *) &i, sizeof(u32));
127 int cxio_hal_init_rhdl_resource(u32 nr_rhdl)
129 return cxio_init_resource_fifo(&rhdl_fifo, &rhdl_fifo_lock, nr_rhdl, 1,
133 void cxio_hal_destroy_rhdl_resource(void)
135 kfifo_free(&rhdl_fifo);
138 /* nr_* must be power of 2 */
139 int cxio_hal_init_resource(struct cxio_rdev *rdev_p,
140 u32 nr_tpt, u32 nr_pbl,
141 u32 nr_rqt, u32 nr_qpid, u32 nr_cqid, u32 nr_pdid)
144 struct cxio_hal_resource *rscp;
146 rscp = kmalloc(sizeof(*rscp), GFP_KERNEL);
150 err = cxio_init_resource_fifo_random(&rscp->tpt_fifo,
151 &rscp->tpt_fifo_lock,
155 err = cxio_init_qpid_fifo(rdev_p);
158 err = cxio_init_resource_fifo(&rscp->cqid_fifo, &rscp->cqid_fifo_lock,
162 err = cxio_init_resource_fifo(&rscp->pdid_fifo, &rscp->pdid_fifo_lock,
168 kfifo_free(&rscp->cqid_fifo);
170 kfifo_free(&rscp->qpid_fifo);
172 kfifo_free(&rscp->tpt_fifo);
178 * returns 0 if no resource available
180 static u32 cxio_hal_get_resource(struct kfifo *fifo)
183 if (kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32)))
186 return 0; /* fifo emptry */
189 static void cxio_hal_put_resource(struct kfifo *fifo, u32 entry)
191 BUG_ON(kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32)) == 0);
194 u32 cxio_hal_get_stag(struct cxio_hal_resource *rscp)
196 return cxio_hal_get_resource(&rscp->tpt_fifo);
199 void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
201 cxio_hal_put_resource(&rscp->tpt_fifo, stag);
204 u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
206 u32 qpid = cxio_hal_get_resource(&rscp->qpid_fifo);
207 PDBG("%s qpid 0x%x\n", __func__, qpid);
211 void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
213 PDBG("%s qpid 0x%x\n", __func__, qpid);
214 cxio_hal_put_resource(&rscp->qpid_fifo, qpid);
217 u32 cxio_hal_get_cqid(struct cxio_hal_resource *rscp)
219 return cxio_hal_get_resource(&rscp->cqid_fifo);
222 void cxio_hal_put_cqid(struct cxio_hal_resource *rscp, u32 cqid)
224 cxio_hal_put_resource(&rscp->cqid_fifo, cqid);
227 u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp)
229 return cxio_hal_get_resource(&rscp->pdid_fifo);
232 void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
234 cxio_hal_put_resource(&rscp->pdid_fifo, pdid);
237 void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
239 kfifo_free(&rscp->tpt_fifo);
240 kfifo_free(&rscp->cqid_fifo);
241 kfifo_free(&rscp->qpid_fifo);
242 kfifo_free(&rscp->pdid_fifo);
247 * PBL Memory Manager. Uses Linux generic allocator.
250 #define MIN_PBL_SHIFT 8 /* 256B == min PBL size (32 entries) */
252 u32 cxio_hal_pblpool_alloc(struct cxio_rdev *rdev_p, int size)
254 unsigned long addr = gen_pool_alloc(rdev_p->pbl_pool, size);
255 PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
259 void cxio_hal_pblpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
261 PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
262 gen_pool_free(rdev_p->pbl_pool, (unsigned long)addr, size);
265 int cxio_hal_pblpool_create(struct cxio_rdev *rdev_p)
267 unsigned pbl_start, pbl_chunk;
269 rdev_p->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
270 if (!rdev_p->pbl_pool)
273 pbl_start = rdev_p->rnic_info.pbl_base;
274 pbl_chunk = rdev_p->rnic_info.pbl_top - pbl_start + 1;
276 while (pbl_start < rdev_p->rnic_info.pbl_top) {
277 pbl_chunk = min(rdev_p->rnic_info.pbl_top - pbl_start + 1,
279 if (gen_pool_add(rdev_p->pbl_pool, pbl_start, pbl_chunk, -1)) {
280 PDBG("%s failed to add PBL chunk (%x/%x)\n",
281 __func__, pbl_start, pbl_chunk);
282 if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) {
283 printk(KERN_WARNING MOD "%s: Failed to add all PBL chunks (%x/%x)\n",
284 __func__, pbl_start, rdev_p->rnic_info.pbl_top - pbl_start);
289 PDBG("%s added PBL chunk (%x/%x)\n",
290 __func__, pbl_start, pbl_chunk);
291 pbl_start += pbl_chunk;
298 void cxio_hal_pblpool_destroy(struct cxio_rdev *rdev_p)
300 gen_pool_destroy(rdev_p->pbl_pool);
304 * RQT Memory Manager. Uses Linux generic allocator.
307 #define MIN_RQT_SHIFT 10 /* 1KB == mini RQT size (16 entries) */
308 #define RQT_CHUNK 2*1024*1024
310 u32 cxio_hal_rqtpool_alloc(struct cxio_rdev *rdev_p, int size)
312 unsigned long addr = gen_pool_alloc(rdev_p->rqt_pool, size << 6);
313 PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size << 6);
317 void cxio_hal_rqtpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
319 PDBG("%s addr 0x%x size %d\n", __func__, addr, size << 6);
320 gen_pool_free(rdev_p->rqt_pool, (unsigned long)addr, size << 6);
323 int cxio_hal_rqtpool_create(struct cxio_rdev *rdev_p)
326 rdev_p->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
327 if (rdev_p->rqt_pool)
328 for (i = rdev_p->rnic_info.rqt_base;
329 i <= rdev_p->rnic_info.rqt_top - RQT_CHUNK + 1;
331 gen_pool_add(rdev_p->rqt_pool, i, RQT_CHUNK, -1);
332 return rdev_p->rqt_pool ? 0 : -ENOMEM;
335 void cxio_hal_rqtpool_destroy(struct cxio_rdev *rdev_p)
337 gen_pool_destroy(rdev_p->rqt_pool);