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
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/* nr_* must be power of 2 */
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 * returns 0 if no resource available
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;	/* fifo emptry */
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", __FUNCTION__, 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", __FUNCTION__, 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 * 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
255u32 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
262void 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
268int 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
280void 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
292u32 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
299void 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
305int 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
317void cxio_hal_rqtpool_destroy(struct cxio_rdev *rdev_p)
318{
319	gen_pool_destroy(rdev_p->rqt_pool);
320}
321