1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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"
40#include "cxio_hal.h"
41
42static struct kfifo *rhdl_fifo;
43static spinlock_t rhdl_fifo_lock;
44
45#define RANDOM_SIZE 16
46
47static int __cxio_init_resource_fifo(struct kfifo **fifo,
48 spinlock_t *fifo_lock,
49 u32 nr, u32 skip_low,
50 u32 skip_high,
51 int random)
52{
53 u32 i, j, entry = 0, idx;
54 u32 random_bytes;
55 u32 rarray[16];
56 spin_lock_init(fifo_lock);
57
58 *fifo = kfifo_alloc(nr * sizeof(u32), GFP_KERNEL, fifo_lock);
59 if (IS_ERR(*fifo))
60 return -ENOMEM;
61
62 for (i = 0; i < skip_low + skip_high; i++)
63 __kfifo_put(*fifo, (unsigned char *) &entry, sizeof(u32));
64 if (random) {
65 j = 0;
66 random_bytes = random32();
67 for (i = 0; i < RANDOM_SIZE; i++)
68 rarray[i] = i + skip_low;
69 for (i = skip_low + RANDOM_SIZE; i < nr - skip_high; i++) {
70 if (j >= RANDOM_SIZE) {
71 j = 0;
72 random_bytes = random32();
73 }
74 idx = (random_bytes >> (j * 2)) & 0xF;
75 __kfifo_put(*fifo,
76 (unsigned char *) &rarray[idx],
77 sizeof(u32));
78 rarray[idx] = i;
79 j++;
80 }
81 for (i = 0; i < RANDOM_SIZE; i++)
82 __kfifo_put(*fifo,
83 (unsigned char *) &rarray[i],
84 sizeof(u32));
85 } else
86 for (i = skip_low; i < nr - skip_high; i++)
87 __kfifo_put(*fifo, (unsigned char *) &i, sizeof(u32));
88
89 for (i = 0; i < skip_low + skip_high; i++)
90 kfifo_get(*fifo, (unsigned char *) &entry, sizeof(u32));
91 return 0;
92}
93
94static int cxio_init_resource_fifo(struct kfifo **fifo, spinlock_t * fifo_lock,
95 u32 nr, u32 skip_low, u32 skip_high)
96{
97 return (__cxio_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
98 skip_high, 0));
99}
100
101static int cxio_init_resource_fifo_random(struct kfifo **fifo,
102 spinlock_t * fifo_lock,
103 u32 nr, u32 skip_low, u32 skip_high)
104{
105
106 return (__cxio_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
107 skip_high, 1));
108}
109
110static int cxio_init_qpid_fifo(struct cxio_rdev *rdev_p)
111{
112 u32 i;
113
114 spin_lock_init(&rdev_p->rscp->qpid_fifo_lock);
115
116 rdev_p->rscp->qpid_fifo = kfifo_alloc(T3_MAX_NUM_QP * sizeof(u32),
117 GFP_KERNEL,
118 &rdev_p->rscp->qpid_fifo_lock);
119 if (IS_ERR(rdev_p->rscp->qpid_fifo))
120 return -ENOMEM;
121
122 for (i = 16; i < T3_MAX_NUM_QP; i++)
123 if (!(i & rdev_p->qpmask))
124 __kfifo_put(rdev_p->rscp->qpid_fifo,
125 (unsigned char *) &i, sizeof(u32));
126 return 0;
127}
128
129int cxio_hal_init_rhdl_resource(u32 nr_rhdl)
130{
131 return cxio_init_resource_fifo(&rhdl_fifo, &rhdl_fifo_lock, nr_rhdl, 1,
132 0);
133}
134
135void cxio_hal_destroy_rhdl_resource(void)
136{
137 kfifo_free(rhdl_fifo);
138}
139
140
141int cxio_hal_init_resource(struct cxio_rdev *rdev_p,
142 u32 nr_tpt, u32 nr_pbl,
143 u32 nr_rqt, u32 nr_qpid, u32 nr_cqid, u32 nr_pdid)
144{
145 int err = 0;
146 struct cxio_hal_resource *rscp;
147
148 rscp = kmalloc(sizeof(*rscp), GFP_KERNEL);
149 if (!rscp)
150 return -ENOMEM;
151 rdev_p->rscp = rscp;
152 err = cxio_init_resource_fifo_random(&rscp->tpt_fifo,
153 &rscp->tpt_fifo_lock,
154 nr_tpt, 1, 0);
155 if (err)
156 goto tpt_err;
157 err = cxio_init_qpid_fifo(rdev_p);
158 if (err)
159 goto qpid_err;
160 err = cxio_init_resource_fifo(&rscp->cqid_fifo, &rscp->cqid_fifo_lock,
161 nr_cqid, 1, 0);
162 if (err)
163 goto cqid_err;
164 err = cxio_init_resource_fifo(&rscp->pdid_fifo, &rscp->pdid_fifo_lock,
165 nr_pdid, 1, 0);
166 if (err)
167 goto pdid_err;
168 return 0;
169pdid_err:
170 kfifo_free(rscp->cqid_fifo);
171cqid_err:
172 kfifo_free(rscp->qpid_fifo);
173qpid_err:
174 kfifo_free(rscp->tpt_fifo);
175tpt_err:
176 return -ENOMEM;
177}
178
179
180
181
182static u32 cxio_hal_get_resource(struct kfifo *fifo)
183{
184 u32 entry;
185 if (kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32)))
186 return entry;
187 else
188 return 0;
189}
190
191static void cxio_hal_put_resource(struct kfifo *fifo, u32 entry)
192{
193 BUG_ON(kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32)) == 0);
194}
195
196u32 cxio_hal_get_stag(struct cxio_hal_resource *rscp)
197{
198 return cxio_hal_get_resource(rscp->tpt_fifo);
199}
200
201void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
202{
203 cxio_hal_put_resource(rscp->tpt_fifo, stag);
204}
205
206u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
207{
208 u32 qpid = cxio_hal_get_resource(rscp->qpid_fifo);
209 PDBG("%s qpid 0x%x\n", __func__, qpid);
210 return qpid;
211}
212
213void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
214{
215 PDBG("%s qpid 0x%x\n", __func__, qpid);
216 cxio_hal_put_resource(rscp->qpid_fifo, qpid);
217}
218
219u32 cxio_hal_get_cqid(struct cxio_hal_resource *rscp)
220{
221 return cxio_hal_get_resource(rscp->cqid_fifo);
222}
223
224void cxio_hal_put_cqid(struct cxio_hal_resource *rscp, u32 cqid)
225{
226 cxio_hal_put_resource(rscp->cqid_fifo, cqid);
227}
228
229u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp)
230{
231 return cxio_hal_get_resource(rscp->pdid_fifo);
232}
233
234void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
235{
236 cxio_hal_put_resource(rscp->pdid_fifo, pdid);
237}
238
239void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
240{
241 kfifo_free(rscp->tpt_fifo);
242 kfifo_free(rscp->cqid_fifo);
243 kfifo_free(rscp->qpid_fifo);
244 kfifo_free(rscp->pdid_fifo);
245 kfree(rscp);
246}
247
248
249
250
251
252#define MIN_PBL_SHIFT 8
253
254u32 cxio_hal_pblpool_alloc(struct cxio_rdev *rdev_p, int size)
255{
256 unsigned long addr = gen_pool_alloc(rdev_p->pbl_pool, size);
257 PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
258 return (u32)addr;
259}
260
261void cxio_hal_pblpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
262{
263 PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
264 gen_pool_free(rdev_p->pbl_pool, (unsigned long)addr, size);
265}
266
267int cxio_hal_pblpool_create(struct cxio_rdev *rdev_p)
268{
269 unsigned pbl_start, pbl_chunk;
270
271 rdev_p->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
272 if (!rdev_p->pbl_pool)
273 return -ENOMEM;
274
275 pbl_start = rdev_p->rnic_info.pbl_base;
276 pbl_chunk = rdev_p->rnic_info.pbl_top - pbl_start + 1;
277
278 while (pbl_start < rdev_p->rnic_info.pbl_top) {
279 pbl_chunk = min(rdev_p->rnic_info.pbl_top - pbl_start + 1,
280 pbl_chunk);
281 if (gen_pool_add(rdev_p->pbl_pool, pbl_start, pbl_chunk, -1)) {
282 PDBG("%s failed to add PBL chunk (%x/%x)\n",
283 __func__, pbl_start, pbl_chunk);
284 if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) {
285 printk(KERN_WARNING MOD "%s: Failed to add all PBL chunks (%x/%x)\n",
286 __func__, pbl_start, rdev_p->rnic_info.pbl_top - pbl_start);
287 return 0;
288 }
289 pbl_chunk >>= 1;
290 } else {
291 PDBG("%s added PBL chunk (%x/%x)\n",
292 __func__, pbl_start, pbl_chunk);
293 pbl_start += pbl_chunk;
294 }
295 }
296
297 return 0;
298}
299
300void cxio_hal_pblpool_destroy(struct cxio_rdev *rdev_p)
301{
302 gen_pool_destroy(rdev_p->pbl_pool);
303}
304
305
306
307
308
309#define MIN_RQT_SHIFT 10
310#define RQT_CHUNK 2*1024*1024
311
312u32 cxio_hal_rqtpool_alloc(struct cxio_rdev *rdev_p, int size)
313{
314 unsigned long addr = gen_pool_alloc(rdev_p->rqt_pool, size << 6);
315 PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size << 6);
316 return (u32)addr;
317}
318
319void cxio_hal_rqtpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
320{
321 PDBG("%s addr 0x%x size %d\n", __func__, addr, size << 6);
322 gen_pool_free(rdev_p->rqt_pool, (unsigned long)addr, size << 6);
323}
324
325int cxio_hal_rqtpool_create(struct cxio_rdev *rdev_p)
326{
327 unsigned long i;
328 rdev_p->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
329 if (rdev_p->rqt_pool)
330 for (i = rdev_p->rnic_info.rqt_base;
331 i <= rdev_p->rnic_info.rqt_top - RQT_CHUNK + 1;
332 i += RQT_CHUNK)
333 gen_pool_add(rdev_p->rqt_pool, i, RQT_CHUNK, -1);
334 return rdev_p->rqt_pool ? 0 : -ENOMEM;
335}
336
337void cxio_hal_rqtpool_destroy(struct cxio_rdev *rdev_p)
338{
339 gen_pool_destroy(rdev_p->rqt_pool);
340}
341
