drivers/infiniband/hw/cxgb4/resource.c - kernel/msm - Gitiles

 /*
  * Copyright (c) 2009-2010 Chelsio, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
  * General Public License (GPL) Version 2, available from the file
  * COPYING in the main directory of this source tree, or the
  * OpenIB.org BSD license below:
  *
  *     Redistribution and use in source and binary forms, with or
  *     without modification, are permitted provided that the following
  *     conditions are met:
  *
  *      - Redistributions of source code must retain the above
  *        copyright notice, this list of conditions and the following
  *        disclaimer.
  *
  *      - Redistributions in binary form must reproduce the above
  *        copyright notice, this list of conditions and the following
  *        disclaimer in the documentation and/or other materials
  *        provided with the distribution.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 /* Crude resource management */
 #include <linux/kernel.h>
 #include <linux/random.h>
 #include <linux/slab.h>
 #include <linux/kfifo.h>
 #include <linux/spinlock.h>
 #include <linux/errno.h>
 #include <linux/genalloc.h>
 #include "iw_cxgb4.h"

 #define RANDOM_SIZE 16

 static int __c4iw_init_resource_fifo(struct kfifo *fifo,
 				   spinlock_t *fifo_lock,
 				   u32 nr, u32 skip_low,
 				   u32 skip_high,
 				   int random)
 {
 	u32 i, j, entry = 0, idx;
 	u32 random_bytes;
 	u32 rarray[16];
 	spin_lock_init(fifo_lock);

 	if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL))
 		return -ENOMEM;

 	for (i = 0; i < skip_low + skip_high; i++)
 		kfifo_in(fifo, (unsigned char *) &entry, sizeof(u32));
 	if (random) {
 		j = 0;
 		random_bytes = random32();
 		for (i = 0; i < RANDOM_SIZE; i++)
 			rarray[i] = i + skip_low;
 		for (i = skip_low + RANDOM_SIZE; i < nr - skip_high; i++) {
 			if (j >= RANDOM_SIZE) {
 				j = 0;
 				random_bytes = random32();
 			}
 			idx = (random_bytes >> (j * 2)) & 0xF;
 			kfifo_in(fifo,
 				(unsigned char *) &rarray[idx],
 				sizeof(u32));
 			rarray[idx] = i;
 			j++;
 		}
 		for (i = 0; i < RANDOM_SIZE; i++)
 			kfifo_in(fifo,
 				(unsigned char *) &rarray[i],
 				sizeof(u32));
 	} else
 		for (i = skip_low; i < nr - skip_high; i++)
 			kfifo_in(fifo, (unsigned char *) &i, sizeof(u32));

 	for (i = 0; i < skip_low + skip_high; i++)
 		if (kfifo_out_locked(fifo, (unsigned char *) &entry,
 				     sizeof(u32), fifo_lock))
 			break;
 	return 0;
 }

 static int c4iw_init_resource_fifo(struct kfifo *fifo, spinlock_t * fifo_lock,
 				   u32 nr, u32 skip_low, u32 skip_high)
 {
 	return __c4iw_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
 					  skip_high, 0);
 }

 static int c4iw_init_resource_fifo_random(struct kfifo *fifo,
 				   spinlock_t *fifo_lock,
 				   u32 nr, u32 skip_low, u32 skip_high)
 {
 	return __c4iw_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
 					  skip_high, 1);
 }

 static int c4iw_init_qid_fifo(struct c4iw_rdev *rdev)
 {
 	u32 i;

 	spin_lock_init(&rdev->resource.qid_fifo_lock);

 	if (kfifo_alloc(&rdev->resource.qid_fifo, T4_MAX_QIDS * sizeof(u32),
 			GFP_KERNEL))
 		return -ENOMEM;

 	for (i = T4_QID_BASE; i < T4_QID_BASE + T4_MAX_QIDS; i++)
 		if (!(i & rdev->qpmask))
 			kfifo_in(&rdev->resource.qid_fifo,
 				    (unsigned char *) &i, sizeof(u32));
 	return 0;
 }

 /* nr_* must be power of 2 */
 int c4iw_init_resource(struct c4iw_rdev *rdev, u32 nr_tpt, u32 nr_pdid)
 {
 	int err = 0;
 	err = c4iw_init_resource_fifo_random(&rdev->resource.tpt_fifo,
 					     &rdev->resource.tpt_fifo_lock,
 					     nr_tpt, 1, 0);
 	if (err)
 		goto tpt_err;
 	err = c4iw_init_qid_fifo(rdev);
 	if (err)
 		goto qid_err;
 	err = c4iw_init_resource_fifo(&rdev->resource.pdid_fifo,
 				      &rdev->resource.pdid_fifo_lock,
 				      nr_pdid, 1, 0);
 	if (err)
 		goto pdid_err;
 	return 0;
 pdid_err:
 	kfifo_free(&rdev->resource.qid_fifo);
 qid_err:
 	kfifo_free(&rdev->resource.tpt_fifo);
 tpt_err:
 	return -ENOMEM;
 }

 /*
  * returns 0 if no resource available
  */
 u32 c4iw_get_resource(struct kfifo *fifo, spinlock_t *lock)
 {
 	u32 entry;
 	if (kfifo_out_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
 		return entry;
 	else
 		return 0;
 }

 void c4iw_put_resource(struct kfifo *fifo, u32 entry, spinlock_t *lock)
 {
 	PDBG("%s entry 0x%x\n", __func__, entry);
 	kfifo_in_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock);
 }

 u32 c4iw_get_cqid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
 {
 	struct c4iw_qid_list *entry;
 	u32 qid;
 	int i;

 	mutex_lock(&uctx->lock);
 	if (!list_empty(&uctx->cqids)) {
 		entry = list_entry(uctx->cqids.next, struct c4iw_qid_list,
 				   entry);
 		list_del(&entry->entry);
 		qid = entry->qid;
 		kfree(entry);
 	} else {
 		qid = c4iw_get_resource(&rdev->resource.qid_fifo,
 					&rdev->resource.qid_fifo_lock);
 		if (!qid)
 			goto out;
 		for (i = qid+1; i & rdev->qpmask; i++) {
 			entry = kmalloc(sizeof *entry, GFP_KERNEL);
 			if (!entry)
 				goto out;
 			entry->qid = i;
 			list_add_tail(&entry->entry, &uctx->cqids);
 		}

 		/*
 		 * now put the same ids on the qp list since they all
 		 * map to the same db/gts page.
 		 */
 		entry = kmalloc(sizeof *entry, GFP_KERNEL);
 		if (!entry)
 			goto out;
 		entry->qid = qid;
 		list_add_tail(&entry->entry, &uctx->qpids);
 		for (i = qid+1; i & rdev->qpmask; i++) {
 			entry = kmalloc(sizeof *entry, GFP_KERNEL);
 			if (!entry)
 				goto out;
 			entry->qid = i;
 			list_add_tail(&entry->entry, &uctx->qpids);
 		}
 	}
 out:
 	mutex_unlock(&uctx->lock);
 	PDBG("%s qid 0x%x\n", __func__, qid);
 	return qid;
 }

 void c4iw_put_cqid(struct c4iw_rdev *rdev, u32 qid,
 		   struct c4iw_dev_ucontext *uctx)
 {
 	struct c4iw_qid_list *entry;

 	entry = kmalloc(sizeof *entry, GFP_KERNEL);
 	if (!entry)
 		return;
 	PDBG("%s qid 0x%x\n", __func__, qid);
 	entry->qid = qid;
 	mutex_lock(&uctx->lock);
 	list_add_tail(&entry->entry, &uctx->cqids);
 	mutex_unlock(&uctx->lock);
 }

 u32 c4iw_get_qpid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
 {
 	struct c4iw_qid_list *entry;
 	u32 qid;
 	int i;

 	mutex_lock(&uctx->lock);
 	if (!list_empty(&uctx->qpids)) {
 		entry = list_entry(uctx->qpids.next, struct c4iw_qid_list,
 				   entry);
 		list_del(&entry->entry);
 		qid = entry->qid;
 		kfree(entry);
 	} else {
 		qid = c4iw_get_resource(&rdev->resource.qid_fifo,
 					&rdev->resource.qid_fifo_lock);
 		if (!qid)
 			goto out;
 		for (i = qid+1; i & rdev->qpmask; i++) {
 			entry = kmalloc(sizeof *entry, GFP_KERNEL);
 			if (!entry)
 				goto out;
 			entry->qid = i;
 			list_add_tail(&entry->entry, &uctx->qpids);
 		}

 		/*
 		 * now put the same ids on the cq list since they all
 		 * map to the same db/gts page.
 		 */
 		entry = kmalloc(sizeof *entry, GFP_KERNEL);
 		if (!entry)
 			goto out;
 		entry->qid = qid;
 		list_add_tail(&entry->entry, &uctx->cqids);
 		for (i = qid; i & rdev->qpmask; i++) {
 			entry = kmalloc(sizeof *entry, GFP_KERNEL);
 			if (!entry)
 				goto out;
 			entry->qid = i;
 			list_add_tail(&entry->entry, &uctx->cqids);
 		}
 	}
 out:
 	mutex_unlock(&uctx->lock);
 	PDBG("%s qid 0x%x\n", __func__, qid);
 	return qid;
 }

 void c4iw_put_qpid(struct c4iw_rdev *rdev, u32 qid,
 		   struct c4iw_dev_ucontext *uctx)
 {
 	struct c4iw_qid_list *entry;

 	entry = kmalloc(sizeof *entry, GFP_KERNEL);
 	if (!entry)
 		return;
 	PDBG("%s qid 0x%x\n", __func__, qid);
 	entry->qid = qid;
 	mutex_lock(&uctx->lock);
 	list_add_tail(&entry->entry, &uctx->qpids);
 	mutex_unlock(&uctx->lock);
 }

 void c4iw_destroy_resource(struct c4iw_resource *rscp)
 {
 	kfifo_free(&rscp->tpt_fifo);
 	kfifo_free(&rscp->qid_fifo);
 	kfifo_free(&rscp->pdid_fifo);
 }

 /*
  * PBL Memory Manager.  Uses Linux generic allocator.
  */

 #define MIN_PBL_SHIFT 8			/* 256B == min PBL size (32 entries) */

 u32 c4iw_pblpool_alloc(struct c4iw_rdev *rdev, int size)
 {
 	unsigned long addr = gen_pool_alloc(rdev->pbl_pool, size);
 	PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
 	return (u32)addr;
 }

 void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 {
 	PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
 	gen_pool_free(rdev->pbl_pool, (unsigned long)addr, size);
 }

 int c4iw_pblpool_create(struct c4iw_rdev *rdev)
 {
 	unsigned pbl_start, pbl_chunk, pbl_top;

 	rdev->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
 	if (!rdev->pbl_pool)
 		return -ENOMEM;

 	pbl_start = rdev->lldi.vr->pbl.start;
 	pbl_chunk = rdev->lldi.vr->pbl.size;
 	pbl_top = pbl_start + pbl_chunk;

 	while (pbl_start < pbl_top) {
 		pbl_chunk = min(pbl_top - pbl_start + 1, pbl_chunk);
 		if (gen_pool_add(rdev->pbl_pool, pbl_start, pbl_chunk, -1)) {
 			PDBG("%s failed to add PBL chunk (%x/%x)\n",
 			     __func__, pbl_start, pbl_chunk);
 			if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) {
 				printk(KERN_WARNING MOD
 				       "Failed to add all PBL chunks (%x/%x)\n",
 				       pbl_start,
 				       pbl_top - pbl_start);
 				return 0;
 			}
 			pbl_chunk >>= 1;
 		} else {
 			PDBG("%s added PBL chunk (%x/%x)\n",
 			     __func__, pbl_start, pbl_chunk);
 			pbl_start += pbl_chunk;
 		}
 	}

 	return 0;
 }

 void c4iw_pblpool_destroy(struct c4iw_rdev *rdev)
 {
 	gen_pool_destroy(rdev->pbl_pool);
 }

 /*
  * RQT Memory Manager.  Uses Linux generic allocator.
  */

 #define MIN_RQT_SHIFT 10	/* 1KB == min RQT size (16 entries) */

 u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size)
 {
 	unsigned long addr = gen_pool_alloc(rdev->rqt_pool, size << 6);
 	PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size << 6);
 	return (u32)addr;
 }

 void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 {
 	PDBG("%s addr 0x%x size %d\n", __func__, addr, size << 6);
 	gen_pool_free(rdev->rqt_pool, (unsigned long)addr, size << 6);
 }

 int c4iw_rqtpool_create(struct c4iw_rdev *rdev)
 {
 	unsigned rqt_start, rqt_chunk, rqt_top;

 	rdev->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
 	if (!rdev->rqt_pool)
 		return -ENOMEM;

 	rqt_start = rdev->lldi.vr->rq.start;
 	rqt_chunk = rdev->lldi.vr->rq.size;
 	rqt_top = rqt_start + rqt_chunk;

 	while (rqt_start < rqt_top) {
 		rqt_chunk = min(rqt_top - rqt_start + 1, rqt_chunk);
 		if (gen_pool_add(rdev->rqt_pool, rqt_start, rqt_chunk, -1)) {
 			PDBG("%s failed to add RQT chunk (%x/%x)\n",
 			     __func__, rqt_start, rqt_chunk);
 			if (rqt_chunk <= 1024 << MIN_RQT_SHIFT) {
 				printk(KERN_WARNING MOD
 				       "Failed to add all RQT chunks (%x/%x)\n",
 				       rqt_start, rqt_top - rqt_start);
 				return 0;
 			}
 			rqt_chunk >>= 1;
 		} else {
 			PDBG("%s added RQT chunk (%x/%x)\n",
 			     __func__, rqt_start, rqt_chunk);
 			rqt_start += rqt_chunk;
 		}
 	}
 	return 0;
 }

 void c4iw_rqtpool_destroy(struct c4iw_rdev *rdev)
 {
 	gen_pool_destroy(rdev->rqt_pool);
 }
	/*
	* Copyright (c) 2009-2010 Chelsio, Inc. All rights reserved.
	*
	* This software is available to you under a choice of one of two
	* licenses. You may choose to be licensed under the terms of the GNU
	* General Public License (GPL) Version 2, available from the file
	* COPYING in the main directory of this source tree, or the
	* OpenIB.org BSD license below:
	*
	* Redistribution and use in source and binary forms, with or
	* without modification, are permitted provided that the following
	* conditions are met:
	*
	* - Redistributions of source code must retain the above
	* copyright notice, this list of conditions and the following
	* disclaimer.
	*
	* - Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials
	* provided with the distribution.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	* SOFTWARE.
	*/
	/* Crude resource management */
	#include <linux/kernel.h>
	#include <linux/random.h>
	#include <linux/slab.h>
	#include <linux/kfifo.h>
	#include <linux/spinlock.h>
	#include <linux/errno.h>
	#include <linux/genalloc.h>
	#include "iw_cxgb4.h"

	#define RANDOM_SIZE 16

	static int __c4iw_init_resource_fifo(struct kfifo *fifo,
	spinlock_t *fifo_lock,
	u32 nr, u32 skip_low,
	u32 skip_high,
	int random)
	{
	u32 i, j, entry = 0, idx;
	u32 random_bytes;
	u32 rarray[16];
	spin_lock_init(fifo_lock);

	if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL))
	return -ENOMEM;

	for (i = 0; i < skip_low + skip_high; i++)
	kfifo_in(fifo, (unsigned char *) &entry, sizeof(u32));
	if (random) {
	j = 0;
	random_bytes = random32();
	for (i = 0; i < RANDOM_SIZE; i++)
	rarray[i] = i + skip_low;
	for (i = skip_low + RANDOM_SIZE; i < nr - skip_high; i++) {
	if (j >= RANDOM_SIZE) {
	j = 0;
	random_bytes = random32();
	}
	idx = (random_bytes >> (j * 2)) & 0xF;
	kfifo_in(fifo,
	(unsigned char *) &rarray[idx],
	sizeof(u32));
	rarray[idx] = i;
	j++;
	}
	for (i = 0; i < RANDOM_SIZE; i++)
	kfifo_in(fifo,
	(unsigned char *) &rarray[i],
	sizeof(u32));
	} else
	for (i = skip_low; i < nr - skip_high; i++)
	kfifo_in(fifo, (unsigned char *) &i, sizeof(u32));

	for (i = 0; i < skip_low + skip_high; i++)
	if (kfifo_out_locked(fifo, (unsigned char *) &entry,
	sizeof(u32), fifo_lock))
	break;
	return 0;
	}

	static int c4iw_init_resource_fifo(struct kfifo fifo, spinlock_t fifo_lock,
	u32 nr, u32 skip_low, u32 skip_high)
	{
	return __c4iw_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
	skip_high, 0);
	}

	static int c4iw_init_resource_fifo_random(struct kfifo *fifo,
	spinlock_t *fifo_lock,
	u32 nr, u32 skip_low, u32 skip_high)
	{
	return __c4iw_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
	skip_high, 1);
	}

	static int c4iw_init_qid_fifo(struct c4iw_rdev *rdev)
	{
	u32 i;

	spin_lock_init(&rdev->resource.qid_fifo_lock);

	if (kfifo_alloc(&rdev->resource.qid_fifo, T4_MAX_QIDS * sizeof(u32),
	GFP_KERNEL))
	return -ENOMEM;

	for (i = T4_QID_BASE; i < T4_QID_BASE + T4_MAX_QIDS; i++)
	if (!(i & rdev->qpmask))
	kfifo_in(&rdev->resource.qid_fifo,
	(unsigned char *) &i, sizeof(u32));
	return 0;
	}

	/* nr_* must be power of 2 */
	int c4iw_init_resource(struct c4iw_rdev *rdev, u32 nr_tpt, u32 nr_pdid)
	{
	int err = 0;
	err = c4iw_init_resource_fifo_random(&rdev->resource.tpt_fifo,
	&rdev->resource.tpt_fifo_lock,
	nr_tpt, 1, 0);
	if (err)
	goto tpt_err;
	err = c4iw_init_qid_fifo(rdev);
	if (err)
	goto qid_err;
	err = c4iw_init_resource_fifo(&rdev->resource.pdid_fifo,
	&rdev->resource.pdid_fifo_lock,
	nr_pdid, 1, 0);
	if (err)
	goto pdid_err;
	return 0;
	pdid_err:
	kfifo_free(&rdev->resource.qid_fifo);
	qid_err:
	kfifo_free(&rdev->resource.tpt_fifo);
	tpt_err:
	return -ENOMEM;
	}

	/*
	* returns 0 if no resource available
	*/
	u32 c4iw_get_resource(struct kfifo fifo, spinlock_t lock)
	{
	u32 entry;
	if (kfifo_out_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
	return entry;
	else
	return 0;
	}

	void c4iw_put_resource(struct kfifo fifo, u32 entry, spinlock_t lock)
	{
	PDBG("%s entry 0x%x\n", __func__, entry);
	kfifo_in_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock);
	}

	u32 c4iw_get_cqid(struct c4iw_rdev rdev, struct c4iw_dev_ucontext uctx)
	{
	struct c4iw_qid_list *entry;
	u32 qid;
	int i;

	mutex_lock(&uctx->lock);
	if (!list_empty(&uctx->cqids)) {
	entry = list_entry(uctx->cqids.next, struct c4iw_qid_list,
	entry);
	list_del(&entry->entry);
	qid = entry->qid;
	kfree(entry);
	} else {
	qid = c4iw_get_resource(&rdev->resource.qid_fifo,
	&rdev->resource.qid_fifo_lock);
	if (!qid)
	goto out;
	for (i = qid+1; i & rdev->qpmask; i++) {
	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	goto out;
	entry->qid = i;
	list_add_tail(&entry->entry, &uctx->cqids);
	}

	/*
	* now put the same ids on the qp list since they all
	* map to the same db/gts page.
	*/
	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	goto out;
	entry->qid = qid;
	list_add_tail(&entry->entry, &uctx->qpids);
	for (i = qid+1; i & rdev->qpmask; i++) {
	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	goto out;
	entry->qid = i;
	list_add_tail(&entry->entry, &uctx->qpids);
	}
	}
	out:
	mutex_unlock(&uctx->lock);
	PDBG("%s qid 0x%x\n", __func__, qid);
	return qid;
	}

	void c4iw_put_cqid(struct c4iw_rdev *rdev, u32 qid,
	struct c4iw_dev_ucontext *uctx)
	{
	struct c4iw_qid_list *entry;

	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	return;
	PDBG("%s qid 0x%x\n", __func__, qid);
	entry->qid = qid;
	mutex_lock(&uctx->lock);
	list_add_tail(&entry->entry, &uctx->cqids);
	mutex_unlock(&uctx->lock);
	}

	u32 c4iw_get_qpid(struct c4iw_rdev rdev, struct c4iw_dev_ucontext uctx)
	{
	struct c4iw_qid_list *entry;
	u32 qid;
	int i;

	mutex_lock(&uctx->lock);
	if (!list_empty(&uctx->qpids)) {
	entry = list_entry(uctx->qpids.next, struct c4iw_qid_list,
	entry);
	list_del(&entry->entry);
	qid = entry->qid;
	kfree(entry);
	} else {
	qid = c4iw_get_resource(&rdev->resource.qid_fifo,
	&rdev->resource.qid_fifo_lock);
	if (!qid)
	goto out;
	for (i = qid+1; i & rdev->qpmask; i++) {
	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	goto out;
	entry->qid = i;
	list_add_tail(&entry->entry, &uctx->qpids);
	}

	/*
	* now put the same ids on the cq list since they all
	* map to the same db/gts page.
	*/
	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	goto out;
	entry->qid = qid;
	list_add_tail(&entry->entry, &uctx->cqids);
	for (i = qid; i & rdev->qpmask; i++) {
	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	goto out;
	entry->qid = i;
	list_add_tail(&entry->entry, &uctx->cqids);
	}
	}
	out:
	mutex_unlock(&uctx->lock);
	PDBG("%s qid 0x%x\n", __func__, qid);
	return qid;
	}

	void c4iw_put_qpid(struct c4iw_rdev *rdev, u32 qid,
	struct c4iw_dev_ucontext *uctx)
	{
	struct c4iw_qid_list *entry;

	entry = kmalloc(sizeof *entry, GFP_KERNEL);
	if (!entry)
	return;
	PDBG("%s qid 0x%x\n", __func__, qid);
	entry->qid = qid;
	mutex_lock(&uctx->lock);
	list_add_tail(&entry->entry, &uctx->qpids);
	mutex_unlock(&uctx->lock);
	}

	void c4iw_destroy_resource(struct c4iw_resource *rscp)
	{
	kfifo_free(&rscp->tpt_fifo);
	kfifo_free(&rscp->qid_fifo);
	kfifo_free(&rscp->pdid_fifo);
	}

	/*
	* PBL Memory Manager. Uses Linux generic allocator.
	*/

	#define MIN_PBL_SHIFT 8 /* 256B == min PBL size (32 entries) */

	u32 c4iw_pblpool_alloc(struct c4iw_rdev *rdev, int size)
	{
	unsigned long addr = gen_pool_alloc(rdev->pbl_pool, size);
	PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
	return (u32)addr;
	}

	void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
	{
	PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
	gen_pool_free(rdev->pbl_pool, (unsigned long)addr, size);
	}

	int c4iw_pblpool_create(struct c4iw_rdev *rdev)
	{
	unsigned pbl_start, pbl_chunk, pbl_top;

	rdev->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
	if (!rdev->pbl_pool)
	return -ENOMEM;

	pbl_start = rdev->lldi.vr->pbl.start;
	pbl_chunk = rdev->lldi.vr->pbl.size;
	pbl_top = pbl_start + pbl_chunk;

	while (pbl_start < pbl_top) {
	pbl_chunk = min(pbl_top - pbl_start + 1, pbl_chunk);
	if (gen_pool_add(rdev->pbl_pool, pbl_start, pbl_chunk, -1)) {
	PDBG("%s failed to add PBL chunk (%x/%x)\n",
	__func__, pbl_start, pbl_chunk);
	if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) {
	printk(KERN_WARNING MOD
	"Failed to add all PBL chunks (%x/%x)\n",
	pbl_start,
	pbl_top - pbl_start);
	return 0;
	}
	pbl_chunk >>= 1;
	} else {
	PDBG("%s added PBL chunk (%x/%x)\n",
	__func__, pbl_start, pbl_chunk);
	pbl_start += pbl_chunk;
	}
	}

	return 0;
	}

	void c4iw_pblpool_destroy(struct c4iw_rdev *rdev)
	{
	gen_pool_destroy(rdev->pbl_pool);
	}

	/*
	* RQT Memory Manager. Uses Linux generic allocator.
	*/

	#define MIN_RQT_SHIFT 10 /* 1KB == min RQT size (16 entries) */

	u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size)
	{
	unsigned long addr = gen_pool_alloc(rdev->rqt_pool, size << 6);
	PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size << 6);
	return (u32)addr;
	}

	void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
	{
	PDBG("%s addr 0x%x size %d\n", __func__, addr, size << 6);
	gen_pool_free(rdev->rqt_pool, (unsigned long)addr, size << 6);
	}

	int c4iw_rqtpool_create(struct c4iw_rdev *rdev)
	{
	unsigned rqt_start, rqt_chunk, rqt_top;

	rdev->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
	if (!rdev->rqt_pool)
	return -ENOMEM;

	rqt_start = rdev->lldi.vr->rq.start;
	rqt_chunk = rdev->lldi.vr->rq.size;
	rqt_top = rqt_start + rqt_chunk;

	while (rqt_start < rqt_top) {
	rqt_chunk = min(rqt_top - rqt_start + 1, rqt_chunk);
	if (gen_pool_add(rdev->rqt_pool, rqt_start, rqt_chunk, -1)) {
	PDBG("%s failed to add RQT chunk (%x/%x)\n",
	__func__, rqt_start, rqt_chunk);
	if (rqt_chunk <= 1024 << MIN_RQT_SHIFT) {
	printk(KERN_WARNING MOD
	"Failed to add all RQT chunks (%x/%x)\n",
	rqt_start, rqt_top - rqt_start);
	return 0;
	}
	rqt_chunk >>= 1;
	} else {
	PDBG("%s added RQT chunk (%x/%x)\n",
	__func__, rqt_start, rqt_chunk);
	rqt_start += rqt_chunk;
	}
	}
	return 0;
	}

	void c4iw_rqtpool_destroy(struct c4iw_rdev *rdev)
	{
	gen_pool_destroy(rdev->rqt_pool);
	}