RDMA/cxgb3: cleanups
[linux-2.6.git] / drivers / infiniband / hw / cxgb3 / cxio_resource.c
1 /*
2  * Copyright (c) 2006 Chelsio, Inc. All rights reserved.
3  *
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:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
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.
22  *
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
30  * SOFTWARE.
31  */
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"
40 #include "cxio_hal.h"
41
42 static struct kfifo *rhdl_fifo;
43 static spinlock_t rhdl_fifo_lock;
44
45 #define RANDOM_SIZE 16
46
47 static 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
94 static 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
101 static 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
110 static 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
129 int 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
135 void cxio_hal_destroy_rhdl_resource(void)
136 {
137         kfifo_free(rhdl_fifo);
138 }
139
140 /* nr_* must be power of 2 */
141 int 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;
169 pdid_err:
170         kfifo_free(rscp->cqid_fifo);
171 cqid_err:
172         kfifo_free(rscp->qpid_fifo);
173 qpid_err:
174         kfifo_free(rscp->tpt_fifo);
175 tpt_err:
176         return -ENOMEM;
177 }
178
179 /*
180  * returns 0 if no resource available
181  */
182 static 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;       /* fifo emptry */
189 }
190
191 static 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
196 u32 cxio_hal_get_stag(struct cxio_hal_resource *rscp)
197 {
198         return cxio_hal_get_resource(rscp->tpt_fifo);
199 }
200
201 void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
202 {
203         cxio_hal_put_resource(rscp->tpt_fifo, stag);
204 }
205
206 u32 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", __FUNCTION__, qpid);
210         return qpid;
211 }
212
213 void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
214 {
215         PDBG("%s qpid 0x%x\n", __FUNCTION__, qpid);
216         cxio_hal_put_resource(rscp->qpid_fifo, qpid);
217 }
218
219 u32 cxio_hal_get_cqid(struct cxio_hal_resource *rscp)
220 {
221         return cxio_hal_get_resource(rscp->cqid_fifo);
222 }
223
224 void cxio_hal_put_cqid(struct cxio_hal_resource *rscp, u32 cqid)
225 {
226         cxio_hal_put_resource(rscp->cqid_fifo, cqid);
227 }
228
229 u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp)
230 {
231         return cxio_hal_get_resource(rscp->pdid_fifo);
232 }
233
234 void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
235 {
236         cxio_hal_put_resource(rscp->pdid_fifo, pdid);
237 }
238
239 void 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  * PBL Memory Manager.  Uses Linux generic allocator.
250  */
251
252 #define MIN_PBL_SHIFT 8                 /* 256B == min PBL size (32 entries) */
253 #define PBL_CHUNK 2*1024*1024
254
255 u32 cxio_hal_pblpool_alloc(struct cxio_rdev *rdev_p, int size)
256 {
257         unsigned long addr = gen_pool_alloc(rdev_p->pbl_pool, size);
258         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, (u32)addr, size);
259         return (u32)addr;
260 }
261
262 void cxio_hal_pblpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
263 {
264         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, addr, size);
265         gen_pool_free(rdev_p->pbl_pool, (unsigned long)addr, size);
266 }
267
268 int cxio_hal_pblpool_create(struct cxio_rdev *rdev_p)
269 {
270         unsigned long i;
271         rdev_p->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
272         if (rdev_p->pbl_pool)
273                 for (i = rdev_p->rnic_info.pbl_base;
274                      i <= rdev_p->rnic_info.pbl_top - PBL_CHUNK + 1;
275                      i += PBL_CHUNK)
276                         gen_pool_add(rdev_p->pbl_pool, i, PBL_CHUNK, -1);
277         return rdev_p->pbl_pool ? 0 : -ENOMEM;
278 }
279
280 void cxio_hal_pblpool_destroy(struct cxio_rdev *rdev_p)
281 {
282         gen_pool_destroy(rdev_p->pbl_pool);
283 }
284
285 /*
286  * RQT Memory Manager.  Uses Linux generic allocator.
287  */
288
289 #define MIN_RQT_SHIFT 10        /* 1KB == mini RQT size (16 entries) */
290 #define RQT_CHUNK 2*1024*1024
291
292 u32 cxio_hal_rqtpool_alloc(struct cxio_rdev *rdev_p, int size)
293 {
294         unsigned long addr = gen_pool_alloc(rdev_p->rqt_pool, size << 6);
295         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, (u32)addr, size << 6);
296         return (u32)addr;
297 }
298
299 void cxio_hal_rqtpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
300 {
301         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, addr, size << 6);
302         gen_pool_free(rdev_p->rqt_pool, (unsigned long)addr, size << 6);
303 }
304
305 int cxio_hal_rqtpool_create(struct cxio_rdev *rdev_p)
306 {
307         unsigned long i;
308         rdev_p->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
309         if (rdev_p->rqt_pool)
310                 for (i = rdev_p->rnic_info.rqt_base;
311                      i <= rdev_p->rnic_info.rqt_top - RQT_CHUNK + 1;
312                      i += RQT_CHUNK)
313                         gen_pool_add(rdev_p->rqt_pool, i, RQT_CHUNK, -1);
314         return rdev_p->rqt_pool ? 0 : -ENOMEM;
315 }
316
317 void cxio_hal_rqtpool_destroy(struct cxio_rdev *rdev_p)
318 {
319         gen_pool_destroy(rdev_p->rqt_pool);
320 }