Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8d03e772 authored by Gabor Juhos's avatar Gabor Juhos Committed by John W. Linville
Browse files

rt2x00: rt2800pci: move interrupt functions to the rt2800mmio module 



Move the functions into a separate module, in order
to make those usable from other modules.

Signed-off-by: default avatarGabor Juhos <juhosg@openwrt.org>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent b5cfde3f

drivers/net/wireless/rt2x00/rt2800mmio.c

+396 −0
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 


#include "rt2x00.h"

#include "rt2x00mmio.h"

#include "rt2800.h"

#include "rt2800lib.h"

#include "rt2800mmio.h"
@@ -156,6 +157,401 @@ void rt2800mmio_fill_rxdone(struct queue_entry *entry, 
}

EXPORT_SYMBOL_GPL(rt2800mmio_fill_rxdone);



/*

 * Interrupt functions.

 */

static void rt2800mmio_wakeup(struct rt2x00_dev *rt2x00dev)

{

	struct ieee80211_conf conf = { .flags = 0 };

	struct rt2x00lib_conf libconf = { .conf = &conf };



	rt2800_config(rt2x00dev, &libconf, IEEE80211_CONF_CHANGE_PS);

}



static bool rt2800mmio_txdone_entry_check(struct queue_entry *entry, u32 status)

{

	__le32 *txwi;

	u32 word;

	int wcid, tx_wcid;



	wcid = rt2x00_get_field32(status, TX_STA_FIFO_WCID);



	txwi = rt2800_drv_get_txwi(entry);

	rt2x00_desc_read(txwi, 1, &word);

	tx_wcid = rt2x00_get_field32(word, TXWI_W1_WIRELESS_CLI_ID);



	return (tx_wcid == wcid);

}



static bool rt2800mmio_txdone_find_entry(struct queue_entry *entry, void *data)

{

	u32 status = *(u32 *)data;



	/*

	 * rt2800pci hardware might reorder frames when exchanging traffic

	 * with multiple BA enabled STAs.

	 *

	 * For example, a tx queue

	 *    [ STA1 | STA2 | STA1 | STA2 ]

	 * can result in tx status reports

	 *    [ STA1 | STA1 | STA2 | STA2 ]

	 * when the hw decides to aggregate the frames for STA1 into one AMPDU.

	 *

	 * To mitigate this effect, associate the tx status to the first frame

	 * in the tx queue with a matching wcid.

	 */

	if (rt2800mmio_txdone_entry_check(entry, status) &&

	    !test_bit(ENTRY_DATA_STATUS_SET, &entry->flags)) {

		/*

		 * Got a matching frame, associate the tx status with

		 * the frame

		 */

		entry->status = status;

		set_bit(ENTRY_DATA_STATUS_SET, &entry->flags);

		return true;

	}



	/* Check the next frame */

	return false;

}



static bool rt2800mmio_txdone_match_first(struct queue_entry *entry, void *data)

{

	u32 status = *(u32 *)data;



	/*

	 * Find the first frame without tx status and assign this status to it

	 * regardless if it matches or not.

	 */

	if (!test_bit(ENTRY_DATA_STATUS_SET, &entry->flags)) {

		/*

		 * Got a matching frame, associate the tx status with

		 * the frame

		 */

		entry->status = status;

		set_bit(ENTRY_DATA_STATUS_SET, &entry->flags);

		return true;

	}



	/* Check the next frame */

	return false;

}

static bool rt2800mmio_txdone_release_entries(struct queue_entry *entry,

					      void *data)

{

	if (test_bit(ENTRY_DATA_STATUS_SET, &entry->flags)) {

		rt2800_txdone_entry(entry, entry->status,

				    rt2800mmio_get_txwi(entry));

		return false;

	}



	/* No more frames to release */

	return true;

}



static bool rt2800mmio_txdone(struct rt2x00_dev *rt2x00dev)

{

	struct data_queue *queue;

	u32 status;

	u8 qid;

	int max_tx_done = 16;



	while (kfifo_get(&rt2x00dev->txstatus_fifo, &status)) {

		qid = rt2x00_get_field32(status, TX_STA_FIFO_PID_QUEUE);

		if (unlikely(qid >= QID_RX)) {

			/*

			 * Unknown queue, this shouldn't happen. Just drop

			 * this tx status.

			 */

			rt2x00_warn(rt2x00dev, "Got TX status report with unexpected pid %u, dropping\n",

				    qid);

			break;

		}



		queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);

		if (unlikely(queue == NULL)) {

			/*

			 * The queue is NULL, this shouldn't happen. Stop

			 * processing here and drop the tx status

			 */

			rt2x00_warn(rt2x00dev, "Got TX status for an unavailable queue %u, dropping\n",

				    qid);

			break;

		}



		if (unlikely(rt2x00queue_empty(queue))) {

			/*

			 * The queue is empty. Stop processing here

			 * and drop the tx status.

			 */

			rt2x00_warn(rt2x00dev, "Got TX status for an empty queue %u, dropping\n",

				    qid);

			break;

		}



		/*

		 * Let's associate this tx status with the first

		 * matching frame.

		 */

		if (!rt2x00queue_for_each_entry(queue, Q_INDEX_DONE,

						Q_INDEX, &status,

						rt2800mmio_txdone_find_entry)) {

			/*

			 * We cannot match the tx status to any frame, so just

			 * use the first one.

			 */

			if (!rt2x00queue_for_each_entry(queue, Q_INDEX_DONE,

							Q_INDEX, &status,

							rt2800mmio_txdone_match_first)) {

				rt2x00_warn(rt2x00dev, "No frame found for TX status on queue %u, dropping\n",

					    qid);

				break;

			}

		}



		/*

		 * Release all frames with a valid tx status.

		 */

		rt2x00queue_for_each_entry(queue, Q_INDEX_DONE,

					   Q_INDEX, NULL,

					   rt2800mmio_txdone_release_entries);



		if (--max_tx_done == 0)

			break;

	}



	return !max_tx_done;

}



static inline void rt2800mmio_enable_interrupt(struct rt2x00_dev *rt2x00dev,

					       struct rt2x00_field32 irq_field)

{

	u32 reg;



	/*

	 * Enable a single interrupt. The interrupt mask register

	 * access needs locking.

	 */

	spin_lock_irq(&rt2x00dev->irqmask_lock);

	rt2x00mmio_register_read(rt2x00dev, INT_MASK_CSR, &reg);

	rt2x00_set_field32(&reg, irq_field, 1);

	rt2x00mmio_register_write(rt2x00dev, INT_MASK_CSR, reg);

	spin_unlock_irq(&rt2x00dev->irqmask_lock);

}



void rt2800mmio_txstatus_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	if (rt2800mmio_txdone(rt2x00dev))

		tasklet_schedule(&rt2x00dev->txstatus_tasklet);



	/*

	 * No need to enable the tx status interrupt here as we always

	 * leave it enabled to minimize the possibility of a tx status

	 * register overflow. See comment in interrupt handler.

	 */

}

EXPORT_SYMBOL_GPL(rt2800mmio_txstatus_tasklet);



void rt2800mmio_pretbtt_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	rt2x00lib_pretbtt(rt2x00dev);

	if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev, INT_MASK_CSR_PRE_TBTT);

}

EXPORT_SYMBOL_GPL(rt2800mmio_pretbtt_tasklet);



void rt2800mmio_tbtt_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	struct rt2800_drv_data *drv_data = rt2x00dev->drv_data;

	u32 reg;



	rt2x00lib_beacondone(rt2x00dev);



	if (rt2x00dev->intf_ap_count) {

		/*

		 * The rt2800pci hardware tbtt timer is off by 1us per tbtt

		 * causing beacon skew and as a result causing problems with

		 * some powersaving clients over time. Shorten the beacon

		 * interval every 64 beacons by 64us to mitigate this effect.

		 */

		if (drv_data->tbtt_tick == (BCN_TBTT_OFFSET - 2)) {

			rt2x00mmio_register_read(rt2x00dev, BCN_TIME_CFG, &reg);

			rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL,

					   (rt2x00dev->beacon_int * 16) - 1);

			rt2x00mmio_register_write(rt2x00dev, BCN_TIME_CFG, reg);

		} else if (drv_data->tbtt_tick == (BCN_TBTT_OFFSET - 1)) {

			rt2x00mmio_register_read(rt2x00dev, BCN_TIME_CFG, &reg);

			rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL,

					   (rt2x00dev->beacon_int * 16));

			rt2x00mmio_register_write(rt2x00dev, BCN_TIME_CFG, reg);

		}

		drv_data->tbtt_tick++;

		drv_data->tbtt_tick %= BCN_TBTT_OFFSET;

	}



	if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev, INT_MASK_CSR_TBTT);

}

EXPORT_SYMBOL_GPL(rt2800mmio_tbtt_tasklet);



void rt2800mmio_rxdone_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	if (rt2x00mmio_rxdone(rt2x00dev))

		tasklet_schedule(&rt2x00dev->rxdone_tasklet);

	else if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev, INT_MASK_CSR_RX_DONE);

}

EXPORT_SYMBOL_GPL(rt2800mmio_rxdone_tasklet);



void rt2800mmio_autowake_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	rt2800mmio_wakeup(rt2x00dev);

	if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev,

					    INT_MASK_CSR_AUTO_WAKEUP);

}

EXPORT_SYMBOL_GPL(rt2800mmio_autowake_tasklet);



static void rt2800mmio_txstatus_interrupt(struct rt2x00_dev *rt2x00dev)

{

	u32 status;

	int i;



	/*

	 * The TX_FIFO_STATUS interrupt needs special care. We should

	 * read TX_STA_FIFO but we should do it immediately as otherwise

	 * the register can overflow and we would lose status reports.

	 *

	 * Hence, read the TX_STA_FIFO register and copy all tx status

	 * reports into a kernel FIFO which is handled in the txstatus

	 * tasklet. We use a tasklet to process the tx status reports

	 * because we can schedule the tasklet multiple times (when the

	 * interrupt fires again during tx status processing).

	 *

	 * Furthermore we don't disable the TX_FIFO_STATUS

	 * interrupt here but leave it enabled so that the TX_STA_FIFO

	 * can also be read while the tx status tasklet gets executed.

	 *

	 * Since we have only one producer and one consumer we don't

	 * need to lock the kfifo.

	 */

	for (i = 0; i < rt2x00dev->tx->limit; i++) {

		rt2x00mmio_register_read(rt2x00dev, TX_STA_FIFO, &status);



		if (!rt2x00_get_field32(status, TX_STA_FIFO_VALID))

			break;



		if (!kfifo_put(&rt2x00dev->txstatus_fifo, &status)) {

			rt2x00_warn(rt2x00dev, "TX status FIFO overrun, drop tx status report\n");

			break;

		}

	}



	/* Schedule the tasklet for processing the tx status. */

	tasklet_schedule(&rt2x00dev->txstatus_tasklet);

}



irqreturn_t rt2800mmio_interrupt(int irq, void *dev_instance)

{

	struct rt2x00_dev *rt2x00dev = dev_instance;

	u32 reg, mask;



	/* Read status and ACK all interrupts */

	rt2x00mmio_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);

	rt2x00mmio_register_write(rt2x00dev, INT_SOURCE_CSR, reg);



	if (!reg)

		return IRQ_NONE;



	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		return IRQ_HANDLED;



	/*

	 * Since INT_MASK_CSR and INT_SOURCE_CSR use the same bits

	 * for interrupts and interrupt masks we can just use the value of

	 * INT_SOURCE_CSR to create the interrupt mask.

	 */

	mask = ~reg;



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TX_FIFO_STATUS)) {

		rt2800mmio_txstatus_interrupt(rt2x00dev);

		/*

		 * Never disable the TX_FIFO_STATUS interrupt.

		 */

		rt2x00_set_field32(&mask, INT_MASK_CSR_TX_FIFO_STATUS, 1);

	}



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_PRE_TBTT))

		tasklet_hi_schedule(&rt2x00dev->pretbtt_tasklet);



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TBTT))

		tasklet_hi_schedule(&rt2x00dev->tbtt_tasklet);



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE))

		tasklet_schedule(&rt2x00dev->rxdone_tasklet);



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_AUTO_WAKEUP))

		tasklet_schedule(&rt2x00dev->autowake_tasklet);



	/*

	 * Disable all interrupts for which a tasklet was scheduled right now,

	 * the tasklet will reenable the appropriate interrupts.

	 */

	spin_lock(&rt2x00dev->irqmask_lock);

	rt2x00mmio_register_read(rt2x00dev, INT_MASK_CSR, &reg);

	reg &= mask;

	rt2x00mmio_register_write(rt2x00dev, INT_MASK_CSR, reg);

	spin_unlock(&rt2x00dev->irqmask_lock);



	return IRQ_HANDLED;

}

EXPORT_SYMBOL_GPL(rt2800mmio_interrupt);



void rt2800mmio_toggle_irq(struct rt2x00_dev *rt2x00dev,

			   enum dev_state state)

{

	u32 reg;

	unsigned long flags;



	/*

	 * When interrupts are being enabled, the interrupt registers

	 * should clear the register to assure a clean state.

	 */

	if (state == STATE_RADIO_IRQ_ON) {

		rt2x00mmio_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);

		rt2x00mmio_register_write(rt2x00dev, INT_SOURCE_CSR, reg);

	}



	spin_lock_irqsave(&rt2x00dev->irqmask_lock, flags);

	reg = 0;

	if (state == STATE_RADIO_IRQ_ON) {

		rt2x00_set_field32(&reg, INT_MASK_CSR_RX_DONE, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_TBTT, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_PRE_TBTT, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_TX_FIFO_STATUS, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_AUTO_WAKEUP, 1);

	}

	rt2x00mmio_register_write(rt2x00dev, INT_MASK_CSR, reg);

	spin_unlock_irqrestore(&rt2x00dev->irqmask_lock, flags);



	if (state == STATE_RADIO_IRQ_OFF) {

		/*

		 * Wait for possibly running tasklets to finish.

		 */

		tasklet_kill(&rt2x00dev->txstatus_tasklet);

		tasklet_kill(&rt2x00dev->rxdone_tasklet);

		tasklet_kill(&rt2x00dev->autowake_tasklet);

		tasklet_kill(&rt2x00dev->tbtt_tasklet);

		tasklet_kill(&rt2x00dev->pretbtt_tasklet);

	}

}

EXPORT_SYMBOL_GPL(rt2800mmio_toggle_irq);



MODULE_AUTHOR(DRV_PROJECT);

MODULE_VERSION(DRV_VERSION);

MODULE_DESCRIPTION("rt2800 MMIO library");

drivers/net/wireless/rt2x00/rt2800mmio.h

+9 −0
Original line number Diff line number Diff line
@@ -128,5 +128,14 @@ void rt2800mmio_write_tx_desc(struct queue_entry *entry, 
void rt2800mmio_fill_rxdone(struct queue_entry *entry,

			    struct rxdone_entry_desc *rxdesc);



/* Interrupt functions */

void rt2800mmio_txstatus_tasklet(unsigned long data);

void rt2800mmio_pretbtt_tasklet(unsigned long data);

void rt2800mmio_tbtt_tasklet(unsigned long data);

void rt2800mmio_rxdone_tasklet(unsigned long data);

void rt2800mmio_autowake_tasklet(unsigned long data);

irqreturn_t rt2800mmio_interrupt(int irq, void *dev_instance);

void rt2800mmio_toggle_irq(struct rt2x00_dev *rt2x00dev,

			   enum dev_state state);



#endif /* RT2800MMIO_H */

drivers/net/wireless/rt2x00/rt2800pci.c

+0 −388
Original line number Diff line number Diff line
@@ -448,45 +448,6 @@ static int rt2800pci_init_queues(struct rt2x00_dev *rt2x00dev) 
/*

 * Device state switch handlers.

 */

static void rt2800mmio_toggle_irq(struct rt2x00_dev *rt2x00dev,

				  enum dev_state state)

{

	u32 reg;

	unsigned long flags;



	/*

	 * When interrupts are being enabled, the interrupt registers

	 * should clear the register to assure a clean state.

	 */

	if (state == STATE_RADIO_IRQ_ON) {

		rt2x00mmio_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);

		rt2x00mmio_register_write(rt2x00dev, INT_SOURCE_CSR, reg);

	}



	spin_lock_irqsave(&rt2x00dev->irqmask_lock, flags);

	reg = 0;

	if (state == STATE_RADIO_IRQ_ON) {

		rt2x00_set_field32(&reg, INT_MASK_CSR_RX_DONE, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_TBTT, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_PRE_TBTT, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_TX_FIFO_STATUS, 1);

		rt2x00_set_field32(&reg, INT_MASK_CSR_AUTO_WAKEUP, 1);

	}

	rt2x00mmio_register_write(rt2x00dev, INT_MASK_CSR, reg);

	spin_unlock_irqrestore(&rt2x00dev->irqmask_lock, flags);



	if (state == STATE_RADIO_IRQ_OFF) {

		/*

		 * Wait for possibly running tasklets to finish.

		 */

		tasklet_kill(&rt2x00dev->txstatus_tasklet);

		tasklet_kill(&rt2x00dev->rxdone_tasklet);

		tasklet_kill(&rt2x00dev->autowake_tasklet);

		tasklet_kill(&rt2x00dev->tbtt_tasklet);

		tasklet_kill(&rt2x00dev->pretbtt_tasklet);

	}

}



static int rt2800pci_init_registers(struct rt2x00_dev *rt2x00dev)

{

	u32 reg;
@@ -627,355 +588,6 @@ static int rt2800pci_set_device_state(struct rt2x00_dev *rt2x00dev, 
	return retval;

}



/*

 * Interrupt functions.

 */

static void rt2800mmio_wakeup(struct rt2x00_dev *rt2x00dev)

{

	struct ieee80211_conf conf = { .flags = 0 };

	struct rt2x00lib_conf libconf = { .conf = &conf };



	rt2800_config(rt2x00dev, &libconf, IEEE80211_CONF_CHANGE_PS);

}



static bool rt2800mmio_txdone_entry_check(struct queue_entry *entry, u32 status)

{

	__le32 *txwi;

	u32 word;

	int wcid, tx_wcid;



	wcid = rt2x00_get_field32(status, TX_STA_FIFO_WCID);



	txwi = rt2800_drv_get_txwi(entry);

	rt2x00_desc_read(txwi, 1, &word);

	tx_wcid = rt2x00_get_field32(word, TXWI_W1_WIRELESS_CLI_ID);



	return (tx_wcid == wcid);

}



static bool rt2800mmio_txdone_find_entry(struct queue_entry *entry, void *data)

{

	u32 status = *(u32 *)data;



	/*

	 * rt2800pci hardware might reorder frames when exchanging traffic

	 * with multiple BA enabled STAs.

	 *

	 * For example, a tx queue

	 *    [ STA1 | STA2 | STA1 | STA2 ]

	 * can result in tx status reports

	 *    [ STA1 | STA1 | STA2 | STA2 ]

	 * when the hw decides to aggregate the frames for STA1 into one AMPDU.

	 *

	 * To mitigate this effect, associate the tx status to the first frame

	 * in the tx queue with a matching wcid.

	 */

	if (rt2800mmio_txdone_entry_check(entry, status) &&

	    !test_bit(ENTRY_DATA_STATUS_SET, &entry->flags)) {

		/*

		 * Got a matching frame, associate the tx status with

		 * the frame

		 */

		entry->status = status;

		set_bit(ENTRY_DATA_STATUS_SET, &entry->flags);

		return true;

	}



	/* Check the next frame */

	return false;

}



static bool rt2800mmio_txdone_match_first(struct queue_entry *entry, void *data)

{

	u32 status = *(u32 *)data;



	/*

	 * Find the first frame without tx status and assign this status to it

	 * regardless if it matches or not.

	 */

	if (!test_bit(ENTRY_DATA_STATUS_SET, &entry->flags)) {

		/*

		 * Got a matching frame, associate the tx status with

		 * the frame

		 */

		entry->status = status;

		set_bit(ENTRY_DATA_STATUS_SET, &entry->flags);

		return true;

	}



	/* Check the next frame */

	return false;

}

static bool rt2800mmio_txdone_release_entries(struct queue_entry *entry,

					      void *data)

{

	if (test_bit(ENTRY_DATA_STATUS_SET, &entry->flags)) {

		rt2800_txdone_entry(entry, entry->status,

				    rt2800mmio_get_txwi(entry));

		return false;

	}



	/* No more frames to release */

	return true;

}



static bool rt2800mmio_txdone(struct rt2x00_dev *rt2x00dev)

{

	struct data_queue *queue;

	u32 status;

	u8 qid;

	int max_tx_done = 16;



	while (kfifo_get(&rt2x00dev->txstatus_fifo, &status)) {

		qid = rt2x00_get_field32(status, TX_STA_FIFO_PID_QUEUE);

		if (unlikely(qid >= QID_RX)) {

			/*

			 * Unknown queue, this shouldn't happen. Just drop

			 * this tx status.

			 */

			rt2x00_warn(rt2x00dev, "Got TX status report with unexpected pid %u, dropping\n",

				    qid);

			break;

		}



		queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);

		if (unlikely(queue == NULL)) {

			/*

			 * The queue is NULL, this shouldn't happen. Stop

			 * processing here and drop the tx status

			 */

			rt2x00_warn(rt2x00dev, "Got TX status for an unavailable queue %u, dropping\n",

				    qid);

			break;

		}



		if (unlikely(rt2x00queue_empty(queue))) {

			/*

			 * The queue is empty. Stop processing here

			 * and drop the tx status.

			 */

			rt2x00_warn(rt2x00dev, "Got TX status for an empty queue %u, dropping\n",

				    qid);

			break;

		}



		/*

		 * Let's associate this tx status with the first

		 * matching frame.

		 */

		if (!rt2x00queue_for_each_entry(queue, Q_INDEX_DONE,

						Q_INDEX, &status,

						rt2800mmio_txdone_find_entry)) {

			/*

			 * We cannot match the tx status to any frame, so just

			 * use the first one.

			 */

			if (!rt2x00queue_for_each_entry(queue, Q_INDEX_DONE,

							Q_INDEX, &status,

							rt2800mmio_txdone_match_first)) {

				rt2x00_warn(rt2x00dev, "No frame found for TX status on queue %u, dropping\n",

					    qid);

				break;

			}

		}



		/*

		 * Release all frames with a valid tx status.

		 */

		rt2x00queue_for_each_entry(queue, Q_INDEX_DONE,

					   Q_INDEX, NULL,

					   rt2800mmio_txdone_release_entries);



		if (--max_tx_done == 0)

			break;

	}



	return !max_tx_done;

}



static inline void rt2800mmio_enable_interrupt(struct rt2x00_dev *rt2x00dev,

					       struct rt2x00_field32 irq_field)

{

	u32 reg;



	/*

	 * Enable a single interrupt. The interrupt mask register

	 * access needs locking.

	 */

	spin_lock_irq(&rt2x00dev->irqmask_lock);

	rt2x00mmio_register_read(rt2x00dev, INT_MASK_CSR, &reg);

	rt2x00_set_field32(&reg, irq_field, 1);

	rt2x00mmio_register_write(rt2x00dev, INT_MASK_CSR, reg);

	spin_unlock_irq(&rt2x00dev->irqmask_lock);

}



static void rt2800mmio_txstatus_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	if (rt2800mmio_txdone(rt2x00dev))

		tasklet_schedule(&rt2x00dev->txstatus_tasklet);



	/*

	 * No need to enable the tx status interrupt here as we always

	 * leave it enabled to minimize the possibility of a tx status

	 * register overflow. See comment in interrupt handler.

	 */

}



static void rt2800mmio_pretbtt_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	rt2x00lib_pretbtt(rt2x00dev);

	if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev, INT_MASK_CSR_PRE_TBTT);

}



static void rt2800mmio_tbtt_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	struct rt2800_drv_data *drv_data = rt2x00dev->drv_data;

	u32 reg;



	rt2x00lib_beacondone(rt2x00dev);



	if (rt2x00dev->intf_ap_count) {

		/*

		 * The rt2800pci hardware tbtt timer is off by 1us per tbtt

		 * causing beacon skew and as a result causing problems with

		 * some powersaving clients over time. Shorten the beacon

		 * interval every 64 beacons by 64us to mitigate this effect.

		 */

		if (drv_data->tbtt_tick == (BCN_TBTT_OFFSET - 2)) {

			rt2x00mmio_register_read(rt2x00dev, BCN_TIME_CFG, &reg);

			rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL,

					   (rt2x00dev->beacon_int * 16) - 1);

			rt2x00mmio_register_write(rt2x00dev, BCN_TIME_CFG, reg);

		} else if (drv_data->tbtt_tick == (BCN_TBTT_OFFSET - 1)) {

			rt2x00mmio_register_read(rt2x00dev, BCN_TIME_CFG, &reg);

			rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL,

					   (rt2x00dev->beacon_int * 16));

			rt2x00mmio_register_write(rt2x00dev, BCN_TIME_CFG, reg);

		}

		drv_data->tbtt_tick++;

		drv_data->tbtt_tick %= BCN_TBTT_OFFSET;

	}



	if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev, INT_MASK_CSR_TBTT);

}



static void rt2800mmio_rxdone_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	if (rt2x00mmio_rxdone(rt2x00dev))

		tasklet_schedule(&rt2x00dev->rxdone_tasklet);

	else if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev, INT_MASK_CSR_RX_DONE);

}



static void rt2800mmio_autowake_tasklet(unsigned long data)

{

	struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;

	rt2800mmio_wakeup(rt2x00dev);

	if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		rt2800mmio_enable_interrupt(rt2x00dev,

					    INT_MASK_CSR_AUTO_WAKEUP);

}



static void rt2800mmio_txstatus_interrupt(struct rt2x00_dev *rt2x00dev)

{

	u32 status;

	int i;



	/*

	 * The TX_FIFO_STATUS interrupt needs special care. We should

	 * read TX_STA_FIFO but we should do it immediately as otherwise

	 * the register can overflow and we would lose status reports.

	 *

	 * Hence, read the TX_STA_FIFO register and copy all tx status

	 * reports into a kernel FIFO which is handled in the txstatus

	 * tasklet. We use a tasklet to process the tx status reports

	 * because we can schedule the tasklet multiple times (when the

	 * interrupt fires again during tx status processing).

	 *

	 * Furthermore we don't disable the TX_FIFO_STATUS

	 * interrupt here but leave it enabled so that the TX_STA_FIFO

	 * can also be read while the tx status tasklet gets executed.

	 *

	 * Since we have only one producer and one consumer we don't

	 * need to lock the kfifo.

	 */

	for (i = 0; i < rt2x00dev->tx->limit; i++) {

		rt2x00mmio_register_read(rt2x00dev, TX_STA_FIFO, &status);



		if (!rt2x00_get_field32(status, TX_STA_FIFO_VALID))

			break;



		if (!kfifo_put(&rt2x00dev->txstatus_fifo, &status)) {

			rt2x00_warn(rt2x00dev, "TX status FIFO overrun, drop tx status report\n");

			break;

		}

	}



	/* Schedule the tasklet for processing the tx status. */

	tasklet_schedule(&rt2x00dev->txstatus_tasklet);

}



static irqreturn_t rt2800mmio_interrupt(int irq, void *dev_instance)

{

	struct rt2x00_dev *rt2x00dev = dev_instance;

	u32 reg, mask;



	/* Read status and ACK all interrupts */

	rt2x00mmio_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);

	rt2x00mmio_register_write(rt2x00dev, INT_SOURCE_CSR, reg);



	if (!reg)

		return IRQ_NONE;



	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))

		return IRQ_HANDLED;



	/*

	 * Since INT_MASK_CSR and INT_SOURCE_CSR use the same bits

	 * for interrupts and interrupt masks we can just use the value of

	 * INT_SOURCE_CSR to create the interrupt mask.

	 */

	mask = ~reg;



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TX_FIFO_STATUS)) {

		rt2800mmio_txstatus_interrupt(rt2x00dev);

		/*

		 * Never disable the TX_FIFO_STATUS interrupt.

		 */

		rt2x00_set_field32(&mask, INT_MASK_CSR_TX_FIFO_STATUS, 1);

	}



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_PRE_TBTT))

		tasklet_hi_schedule(&rt2x00dev->pretbtt_tasklet);



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TBTT))

		tasklet_hi_schedule(&rt2x00dev->tbtt_tasklet);



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE))

		tasklet_schedule(&rt2x00dev->rxdone_tasklet);



	if (rt2x00_get_field32(reg, INT_SOURCE_CSR_AUTO_WAKEUP))

		tasklet_schedule(&rt2x00dev->autowake_tasklet);



	/*

	 * Disable all interrupts for which a tasklet was scheduled right now,

	 * the tasklet will reenable the appropriate interrupts.

	 */

	spin_lock(&rt2x00dev->irqmask_lock);

	rt2x00mmio_register_read(rt2x00dev, INT_MASK_CSR, &reg);

	reg &= mask;

	rt2x00mmio_register_write(rt2x00dev, INT_MASK_CSR, reg);

	spin_unlock(&rt2x00dev->irqmask_lock);



	return IRQ_HANDLED;

}



/*

 * Device probe functions.

 */