drivers/net/wireless/rt2x00/rt2x00queue.c - maze/linux - Git at Google

 /*
 	Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
 	<http://rt2x00.serialmonkey.com>

 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
 	the Free Software Foundation; either version 2 of the License, or
 	(at your option) any later version.

 	This program is distributed in the hope that it will be useful,
 	but WITHOUT ANY WARRANTY; without even the implied warranty of
 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 	GNU General Public License for more details.

 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the
 	Free Software Foundation, Inc.,
 	59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */

 /*
 	Module: rt2x00lib
 	Abstract: rt2x00 queue specific routines.
  */

 #include <linux/kernel.h>
 #include <linux/module.h>

 #include "rt2x00.h"
 #include "rt2x00lib.h"

 struct data_queue *rt2x00queue_get_queue(struct rt2x00_dev *rt2x00dev,
 					 const unsigned int queue)
 {
 	int atim = test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);

 	if (queue < rt2x00dev->hw->queues && rt2x00dev->tx)
 		return &rt2x00dev->tx[queue];

 	if (!rt2x00dev->bcn)
 		return NULL;

 	if (queue == RT2X00_BCN_QUEUE_BEACON)
 		return &rt2x00dev->bcn[0];
 	else if (queue == RT2X00_BCN_QUEUE_ATIM && atim)
 		return &rt2x00dev->bcn[1];

 	return NULL;
 }
 EXPORT_SYMBOL_GPL(rt2x00queue_get_queue);

 struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue,
 					  enum queue_index index)
 {
 	struct queue_entry *entry;
 	unsigned long irqflags;

 	if (unlikely(index >= Q_INDEX_MAX)) {
 		ERROR(queue->rt2x00dev,
 		      "Entry requested from invalid index type (%d)\n", index);
 		return NULL;
 	}

 	spin_lock_irqsave(&queue->lock, irqflags);

 	entry = &queue->entries[queue->index[index]];

 	spin_unlock_irqrestore(&queue->lock, irqflags);

 	return entry;
 }
 EXPORT_SYMBOL_GPL(rt2x00queue_get_entry);

 void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index)
 {
 	unsigned long irqflags;

 	if (unlikely(index >= Q_INDEX_MAX)) {
 		ERROR(queue->rt2x00dev,
 		      "Index change on invalid index type (%d)\n", index);
 		return;
 	}

 	spin_lock_irqsave(&queue->lock, irqflags);

 	queue->index[index]++;
 	if (queue->index[index] >= queue->limit)
 		queue->index[index] = 0;

 	if (index == Q_INDEX) {
 		queue->length++;
 	} else if (index == Q_INDEX_DONE) {
 		queue->length--;
 		queue->count ++;
 	}

 	spin_unlock_irqrestore(&queue->lock, irqflags);
 }
 EXPORT_SYMBOL_GPL(rt2x00queue_index_inc);

 static void rt2x00queue_reset(struct data_queue *queue)
 {
 	unsigned long irqflags;

 	spin_lock_irqsave(&queue->lock, irqflags);

 	queue->count = 0;
 	queue->length = 0;
 	memset(queue->index, 0, sizeof(queue->index));

 	spin_unlock_irqrestore(&queue->lock, irqflags);
 }

 void rt2x00queue_init_rx(struct rt2x00_dev *rt2x00dev)
 {
 	struct data_queue *queue = rt2x00dev->rx;
 	unsigned int i;

 	rt2x00queue_reset(queue);

 	if (!rt2x00dev->ops->lib->init_rxentry)
 		return;

 	for (i = 0; i < queue->limit; i++)
 		rt2x00dev->ops->lib->init_rxentry(rt2x00dev,
 						  &queue->entries[i]);
 }

 void rt2x00queue_init_tx(struct rt2x00_dev *rt2x00dev)
 {
 	struct data_queue *queue;
 	unsigned int i;

 	txall_queue_for_each(rt2x00dev, queue) {
 		rt2x00queue_reset(queue);

 		if (!rt2x00dev->ops->lib->init_txentry)
 			continue;

 		for (i = 0; i < queue->limit; i++)
 			rt2x00dev->ops->lib->init_txentry(rt2x00dev,
 							  &queue->entries[i]);
 	}
 }

 static int rt2x00queue_alloc_entries(struct data_queue *queue,
 				     const struct data_queue_desc *qdesc)
 {
 	struct queue_entry *entries;
 	unsigned int entry_size;
 	unsigned int i;

 	rt2x00queue_reset(queue);

 	queue->limit = qdesc->entry_num;
 	queue->data_size = qdesc->data_size;
 	queue->desc_size = qdesc->desc_size;

 	/*
 	 * Allocate all queue entries.
 	 */
 	entry_size = sizeof(*entries) + qdesc->priv_size;
 	entries = kzalloc(queue->limit * entry_size, GFP_KERNEL);
 	if (!entries)
 		return -ENOMEM;

 #define QUEUE_ENTRY_PRIV_OFFSET(__base, __index, __limit, __esize, __psize) \
 	( ((char *)(__base)) + ((__limit) * (__esize)) + \
 	    ((__index) * (__psize)) )

 	for (i = 0; i < queue->limit; i++) {
 		entries[i].flags = 0;
 		entries[i].queue = queue;
 		entries[i].skb = NULL;
 		entries[i].entry_idx = i;
 		entries[i].priv_data =
 		    QUEUE_ENTRY_PRIV_OFFSET(entries, i, queue->limit,
 					    sizeof(*entries), qdesc->priv_size);
 	}

 #undef QUEUE_ENTRY_PRIV_OFFSET

 	queue->entries = entries;

 	return 0;
 }

 int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev)
 {
 	struct data_queue *queue;
 	int status;


 	status = rt2x00queue_alloc_entries(rt2x00dev->rx, rt2x00dev->ops->rx);
 	if (status)
 		goto exit;

 	tx_queue_for_each(rt2x00dev, queue) {
 		status = rt2x00queue_alloc_entries(queue, rt2x00dev->ops->tx);
 		if (status)
 			goto exit;
 	}

 	status = rt2x00queue_alloc_entries(rt2x00dev->bcn, rt2x00dev->ops->bcn);
 	if (status)
 		goto exit;

 	if (!test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags))
 		return 0;

 	status = rt2x00queue_alloc_entries(&rt2x00dev->bcn[1],
 					   rt2x00dev->ops->atim);
 	if (status)
 		goto exit;

 	return 0;

 exit:
 	ERROR(rt2x00dev, "Queue entries allocation failed.\n");

 	rt2x00queue_uninitialize(rt2x00dev);

 	return status;
 }

 void rt2x00queue_uninitialize(struct rt2x00_dev *rt2x00dev)
 {
 	struct data_queue *queue;

 	queue_for_each(rt2x00dev, queue) {
 		kfree(queue->entries);
 		queue->entries = NULL;
 	}
 }

 static void rt2x00queue_init(struct rt2x00_dev *rt2x00dev,
 			     struct data_queue *queue, enum data_queue_qid qid)
 {
 	spin_lock_init(&queue->lock);

 	queue->rt2x00dev = rt2x00dev;
 	queue->qid = qid;
 	queue->aifs = 2;
 	queue->cw_min = 5;
 	queue->cw_max = 10;
 }

 int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev)
 {
 	struct data_queue *queue;
 	enum data_queue_qid qid;
 	unsigned int req_atim =
 	    !!test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);

 	/*
 	 * We need the following queues:
 	 * RX: 1
 	 * TX: hw->queues
 	 * Beacon: 1
 	 * Atim: 1 (if required)
 	 */
 	rt2x00dev->data_queues = 2 + rt2x00dev->hw->queues + req_atim;

 	queue = kzalloc(rt2x00dev->data_queues * sizeof(*queue), GFP_KERNEL);
 	if (!queue) {
 		ERROR(rt2x00dev, "Queue allocation failed.\n");
 		return -ENOMEM;
 	}

 	/*
 	 * Initialize pointers
 	 */
 	rt2x00dev->rx = queue;
 	rt2x00dev->tx = &queue[1];
 	rt2x00dev->bcn = &queue[1 + rt2x00dev->hw->queues];

 	/*
 	 * Initialize queue parameters.
 	 * RX: qid = QID_RX
 	 * TX: qid = QID_AC_BE + index
 	 * TX: cw_min: 2^5 = 32.
 	 * TX: cw_max: 2^10 = 1024.
 	 * BCN & Atim: qid = QID_MGMT
 	 */
 	rt2x00queue_init(rt2x00dev, rt2x00dev->rx, QID_RX);

 	qid = QID_AC_BE;
 	tx_queue_for_each(rt2x00dev, queue)
 		rt2x00queue_init(rt2x00dev, queue, qid++);

 	rt2x00queue_init(rt2x00dev, &rt2x00dev->bcn[0], QID_MGMT);
 	if (req_atim)
 		rt2x00queue_init(rt2x00dev, &rt2x00dev->bcn[1], QID_MGMT);

 	return 0;
 }

 void rt2x00queue_free(struct rt2x00_dev *rt2x00dev)
 {
 	kfree(rt2x00dev->rx);
 	rt2x00dev->rx = NULL;
 	rt2x00dev->tx = NULL;
 	rt2x00dev->bcn = NULL;
 }
	/*
	Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
	<http://rt2x00.serialmonkey.com>

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the
	Free Software Foundation, Inc.,
	59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	*/

	/*
	Module: rt2x00lib
	Abstract: rt2x00 queue specific routines.
	*/

	#include <linux/kernel.h>
	#include <linux/module.h>

	#include "rt2x00.h"
	#include "rt2x00lib.h"

	struct data_queue rt2x00queue_get_queue(struct rt2x00_dev rt2x00dev,
	const unsigned int queue)
	{
	int atim = test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);

	if (queue < rt2x00dev->hw->queues && rt2x00dev->tx)
	return &rt2x00dev->tx[queue];

	if (!rt2x00dev->bcn)
	return NULL;

	if (queue == RT2X00_BCN_QUEUE_BEACON)
	return &rt2x00dev->bcn[0];
	else if (queue == RT2X00_BCN_QUEUE_ATIM && atim)
	return &rt2x00dev->bcn[1];

	return NULL;
	}
	EXPORT_SYMBOL_GPL(rt2x00queue_get_queue);

	struct queue_entry rt2x00queue_get_entry(struct data_queue queue,
	enum queue_index index)
	{
	struct queue_entry *entry;
	unsigned long irqflags;

	if (unlikely(index >= Q_INDEX_MAX)) {
	ERROR(queue->rt2x00dev,
	"Entry requested from invalid index type (%d)\n", index);
	return NULL;
	}

	spin_lock_irqsave(&queue->lock, irqflags);

	entry = &queue->entries[queue->index[index]];

	spin_unlock_irqrestore(&queue->lock, irqflags);

	return entry;
	}
	EXPORT_SYMBOL_GPL(rt2x00queue_get_entry);

	void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index)
	{
	unsigned long irqflags;

	if (unlikely(index >= Q_INDEX_MAX)) {
	ERROR(queue->rt2x00dev,
	"Index change on invalid index type (%d)\n", index);
	return;
	}

	spin_lock_irqsave(&queue->lock, irqflags);

	queue->index[index]++;
	if (queue->index[index] >= queue->limit)
	queue->index[index] = 0;

	if (index == Q_INDEX) {
	queue->length++;
	} else if (index == Q_INDEX_DONE) {
	queue->length--;
	queue->count ++;
	}

	spin_unlock_irqrestore(&queue->lock, irqflags);
	}
	EXPORT_SYMBOL_GPL(rt2x00queue_index_inc);

	static void rt2x00queue_reset(struct data_queue *queue)
	{
	unsigned long irqflags;

	spin_lock_irqsave(&queue->lock, irqflags);

	queue->count = 0;
	queue->length = 0;
	memset(queue->index, 0, sizeof(queue->index));

	spin_unlock_irqrestore(&queue->lock, irqflags);
	}

	void rt2x00queue_init_rx(struct rt2x00_dev *rt2x00dev)
	{
	struct data_queue *queue = rt2x00dev->rx;
	unsigned int i;

	rt2x00queue_reset(queue);

	if (!rt2x00dev->ops->lib->init_rxentry)
	return;

	for (i = 0; i < queue->limit; i++)
	rt2x00dev->ops->lib->init_rxentry(rt2x00dev,
	&queue->entries[i]);
	}

	void rt2x00queue_init_tx(struct rt2x00_dev *rt2x00dev)
	{
	struct data_queue *queue;
	unsigned int i;

	txall_queue_for_each(rt2x00dev, queue) {
	rt2x00queue_reset(queue);

	if (!rt2x00dev->ops->lib->init_txentry)
	continue;

	for (i = 0; i < queue->limit; i++)
	rt2x00dev->ops->lib->init_txentry(rt2x00dev,
	&queue->entries[i]);
	}
	}

	static int rt2x00queue_alloc_entries(struct data_queue *queue,
	const struct data_queue_desc *qdesc)
	{
	struct queue_entry *entries;
	unsigned int entry_size;
	unsigned int i;

	rt2x00queue_reset(queue);

	queue->limit = qdesc->entry_num;
	queue->data_size = qdesc->data_size;
	queue->desc_size = qdesc->desc_size;

	/*
	* Allocate all queue entries.
	*/
	entry_size = sizeof(*entries) + qdesc->priv_size;
	entries = kzalloc(queue->limit * entry_size, GFP_KERNEL);
	if (!entries)
	return -ENOMEM;

	#define QUEUE_ENTRY_PRIV_OFFSET(__base, __index, __limit, __esize, __psize) \
	( ((char )(__base)) + ((__limit) (__esize)) + \
	((__index) * (__psize)) )

	for (i = 0; i < queue->limit; i++) {
	entries[i].flags = 0;
	entries[i].queue = queue;
	entries[i].skb = NULL;
	entries[i].entry_idx = i;
	entries[i].priv_data =
	QUEUE_ENTRY_PRIV_OFFSET(entries, i, queue->limit,
	sizeof(*entries), qdesc->priv_size);
	}

	#undef QUEUE_ENTRY_PRIV_OFFSET

	queue->entries = entries;

	return 0;
	}

	int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev)
	{
	struct data_queue *queue;
	int status;


	status = rt2x00queue_alloc_entries(rt2x00dev->rx, rt2x00dev->ops->rx);
	if (status)
	goto exit;

	tx_queue_for_each(rt2x00dev, queue) {
	status = rt2x00queue_alloc_entries(queue, rt2x00dev->ops->tx);
	if (status)
	goto exit;
	}

	status = rt2x00queue_alloc_entries(rt2x00dev->bcn, rt2x00dev->ops->bcn);
	if (status)
	goto exit;

	if (!test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags))
	return 0;

	status = rt2x00queue_alloc_entries(&rt2x00dev->bcn[1],
	rt2x00dev->ops->atim);
	if (status)
	goto exit;

	return 0;

	exit:
	ERROR(rt2x00dev, "Queue entries allocation failed.\n");

	rt2x00queue_uninitialize(rt2x00dev);

	return status;
	}

	void rt2x00queue_uninitialize(struct rt2x00_dev *rt2x00dev)
	{
	struct data_queue *queue;

	queue_for_each(rt2x00dev, queue) {
	kfree(queue->entries);
	queue->entries = NULL;
	}
	}

	static void rt2x00queue_init(struct rt2x00_dev *rt2x00dev,
	struct data_queue *queue, enum data_queue_qid qid)
	{
	spin_lock_init(&queue->lock);

	queue->rt2x00dev = rt2x00dev;
	queue->qid = qid;
	queue->aifs = 2;
	queue->cw_min = 5;
	queue->cw_max = 10;
	}

	int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev)
	{
	struct data_queue *queue;
	enum data_queue_qid qid;
	unsigned int req_atim =
	!!test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);

	/*
	* We need the following queues:
	* RX: 1
	* TX: hw->queues
	* Beacon: 1
	* Atim: 1 (if required)
	*/
	rt2x00dev->data_queues = 2 + rt2x00dev->hw->queues + req_atim;

	queue = kzalloc(rt2x00dev->data_queues * sizeof(*queue), GFP_KERNEL);
	if (!queue) {
	ERROR(rt2x00dev, "Queue allocation failed.\n");
	return -ENOMEM;
	}

	/*
	* Initialize pointers
	*/
	rt2x00dev->rx = queue;
	rt2x00dev->tx = &queue[1];
	rt2x00dev->bcn = &queue[1 + rt2x00dev->hw->queues];

	/*
	* Initialize queue parameters.
	* RX: qid = QID_RX
	* TX: qid = QID_AC_BE + index
	* TX: cw_min: 2^5 = 32.
	* TX: cw_max: 2^10 = 1024.
	* BCN & Atim: qid = QID_MGMT
	*/
	rt2x00queue_init(rt2x00dev, rt2x00dev->rx, QID_RX);

	qid = QID_AC_BE;
	tx_queue_for_each(rt2x00dev, queue)
	rt2x00queue_init(rt2x00dev, queue, qid++);

	rt2x00queue_init(rt2x00dev, &rt2x00dev->bcn[0], QID_MGMT);
	if (req_atim)
	rt2x00queue_init(rt2x00dev, &rt2x00dev->bcn[1], QID_MGMT);

	return 0;
	}

	void rt2x00queue_free(struct rt2x00_dev *rt2x00dev)
	{
	kfree(rt2x00dev->rx);
	rt2x00dev->rx = NULL;
	rt2x00dev->tx = NULL;
	rt2x00dev->bcn = NULL;
	}