1 files changed, 107 insertions, 60 deletions

diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.h b/drivers/net/wireless/rt2x00/rt2x00queue.h
index 191e7775a9c0..167d45873dca 100644
--- a/drivers/net/wireless/rt2x00/rt2x00queue.h
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.h
@@ -1,5 +1,5 @@
 /*
-        Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
+        Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
         <http://rt2x00.serialmonkey.com>
 
         This program is free software; you can redistribute it and/or modify
@@ -43,28 +43,12 @@
 #define AGGREGATION_SIZE        3840
 
 /**
- * DOC: Number of entries per queue
- *
- * Under normal load without fragmentation, 12 entries are sufficient
- * without the queue being filled up to the maximum. When using fragmentation
- * and the queue threshold code, we need to add some additional margins to
- * make sure the queue will never (or only under extreme load) fill up
- * completely.
- * Since we don't use preallocated DMA, having a large number of queue entries
- * will have minimal impact on the memory requirements for the queue.
- */
-#define RX_ENTRIES      24
-#define TX_ENTRIES      24
-#define BEACON_ENTRIES  1
-#define ATIM_ENTRIES    8
-
-/**
  * enum data_queue_qid: Queue identification
  *
+ * @QID_AC_VO: AC VO queue
+ * @QID_AC_VI: AC VI queue
  * @QID_AC_BE: AC BE queue
  * @QID_AC_BK: AC BK queue
- * @QID_AC_VI: AC VI queue
- * @QID_AC_VO: AC VO queue
  * @QID_HCCA: HCCA queue
  * @QID_MGMT: MGMT queue (prio queue)
  * @QID_RX: RX queue
@@ -73,10 +57,10 @@
  * @QID_ATIM: Atim queue (value unspeficied, don't send it to device)
  */
 enum data_queue_qid {
-        QID_AC_BE = 0,
-        QID_AC_BK = 1,
-        QID_AC_VI = 2,
-        QID_AC_VO = 3,
+        QID_AC_VO = 0,
+        QID_AC_VI = 1,
+        QID_AC_BE = 2,
+        QID_AC_BK = 3,
         QID_HCCA = 4,
         QID_MGMT = 13,
         QID_RX = 14,
@@ -233,6 +217,7 @@ enum txdone_entry_desc_flags {
         TXDONE_FALLBACK,
         TXDONE_FAILURE,
         TXDONE_EXCESSIVE_RETRY,
+        TXDONE_AMPDU,
 };
 
 /**
@@ -268,6 +253,7 @@ struct txdone_entry_desc {
  * @ENTRY_TXD_HT_AMPDU: This frame is part of an AMPDU.
  * @ENTRY_TXD_HT_BW_40: Use 40MHz Bandwidth.
  * @ENTRY_TXD_HT_SHORT_GI: Use short GI.
+ * @ENTRY_TXD_HT_MIMO_PS: The receiving STA is in dynamic SM PS mode.
  */
 enum txentry_desc_flags {
         ENTRY_TXD_RTS_FRAME,
@@ -286,6 +272,7 @@ enum txentry_desc_flags {
         ENTRY_TXD_HT_AMPDU,
         ENTRY_TXD_HT_BW_40,
         ENTRY_TXD_HT_SHORT_GI,
+        ENTRY_TXD_HT_MIMO_PS,
 };
 
 /**
@@ -294,7 +281,6 @@ enum txentry_desc_flags {
  * Summary of information for the frame descriptor before sending a TX frame.
  *
  * @flags: Descriptor flags (See &enum queue_entry_flags).
- * @queue: Queue identification (See &enum data_queue_qid).
  * @length: Length of the entire frame.
  * @header_length: Length of 802.11 header.
  * @length_high: PLCP length high word.
@@ -307,11 +293,8 @@ enum txentry_desc_flags {
  * @rate_mode: Rate mode (See @enum rate_modulation).
  * @mpdu_density: MDPU density.
  * @retry_limit: Max number of retries.
- * @aifs: AIFS value.
  * @ifs: IFS value.
  * @txop: IFS value for 11n capable chips.
- * @cw_min: cwmin value.
- * @cw_max: cwmax value.
  * @cipher: Cipher type used for encryption.
  * @key_idx: Key index used for encryption.
  * @iv_offset: Position where IV should be inserted by hardware.
@@ -320,28 +303,30 @@ enum txentry_desc_flags {
 struct txentry_desc {
         unsigned long flags;
 
-        enum data_queue_qid queue;
-
         u16 length;
         u16 header_length;
 
-        u16 length_high;
-        u16 length_low;
-        u16 signal;
-        u16 service;
-
-        u16 mcs;
-        u16 stbc;
-        u16 ba_size;
-        u16 rate_mode;
-        u16 mpdu_density;
+        union {
+                struct {
+                        u16 length_high;
+                        u16 length_low;
+                        u16 signal;
+                        u16 service;
+                        enum ifs ifs;
+                } plcp;
+
+                struct {
+                        u16 mcs;
+                        u8 stbc;
+                        u8 ba_size;
+                        u8 mpdu_density;
+                        enum txop txop;
+                } ht;
+        } u;
+
+        enum rate_modulation rate_mode;
 
         short retry_limit;
-        short aifs;
-        short ifs;
-        short txop;
-        short cw_min;
-        short cw_max;
 
         enum cipher cipher;
         u16 key_idx;
@@ -358,32 +343,38 @@ struct txentry_desc {
  * @ENTRY_OWNER_DEVICE_DATA: This entry is owned by the device for data
  *      transfer (either TX or RX depending on the queue). The entry should
  *      only be touched after the device has signaled it is done with it.
- * @ENTRY_OWNER_DEVICE_CRYPTO: This entry is owned by the device for data
- *      encryption or decryption. The entry should only be touched after
- *      the device has signaled it is done with it.
  * @ENTRY_DATA_PENDING: This entry contains a valid frame and is waiting
  *      for the signal to start sending.
+ * @ENTRY_DATA_IO_FAILED: Hardware indicated that an IO error occurred
+ *      while transferring the data to the hardware. No TX status report will
+ *      be expected from the hardware.
+ * @ENTRY_DATA_STATUS_PENDING: The entry has been send to the device and
+ *      returned. It is now waiting for the status reporting before the
+ *      entry can be reused again.
  */
 enum queue_entry_flags {
         ENTRY_BCN_ASSIGNED,
         ENTRY_OWNER_DEVICE_DATA,
-        ENTRY_OWNER_DEVICE_CRYPTO,
         ENTRY_DATA_PENDING,
+        ENTRY_DATA_IO_FAILED,
+        ENTRY_DATA_STATUS_PENDING,
 };
 
 /**
  * struct queue_entry: Entry inside the &struct data_queue
  *
  * @flags: Entry flags, see &enum queue_entry_flags.
+ * @last_action: Timestamp of last change.
  * @queue: The data queue (&struct data_queue) to which this entry belongs.
  * @skb: The buffer which is currently being transmitted (for TX queue),
- *      or used to directly recieve data in (for RX queue).
+ *      or used to directly receive data in (for RX queue).
  * @entry_idx: The entry index number.
  * @priv_data: Private data belonging to this queue entry. The pointer
  *      points to data specific to a particular driver and queue type.
  */
 struct queue_entry {
         unsigned long flags;
+        unsigned long last_action;
 
         struct data_queue *queue;
 
@@ -399,29 +390,49 @@ struct queue_entry {
  *
  * @Q_INDEX: Index pointer to the current entry in the queue, if this entry is
  *      owned by the hardware then the queue is considered to be full.
+ * @Q_INDEX_DMA_DONE: Index pointer for the next entry which will have been
+ *      transferred to the hardware.
  * @Q_INDEX_DONE: Index pointer to the next entry which will be completed by
  *      the hardware and for which we need to run the txdone handler. If this
  *      entry is not owned by the hardware the queue is considered to be empty.
- * @Q_INDEX_CRYPTO: Index pointer to the next entry which encryption/decription
- *      will be completed by the hardware next.
  * @Q_INDEX_MAX: Keep last, used in &struct data_queue to determine the size
  *      of the index array.
  */
 enum queue_index {
         Q_INDEX,
+        Q_INDEX_DMA_DONE,
         Q_INDEX_DONE,
-        Q_INDEX_CRYPTO,
         Q_INDEX_MAX,
 };
 
 /**
+ * enum data_queue_flags: Status flags for data queues
+ *
+ * @QUEUE_STARTED: The queue has been started. Fox RX queues this means the
+ *      device might be DMA'ing skbuffers. TX queues will accept skbuffers to
+ *      be transmitted and beacon queues will start beaconing the configured
+ *      beacons.
+ * @QUEUE_PAUSED: The queue has been started but is currently paused.
+ *      When this bit is set, the queue has been stopped in mac80211,
+ *      preventing new frames to be enqueued. However, a few frames
+ *      might still appear shortly after the pausing...
+ */
+enum data_queue_flags {
+        QUEUE_STARTED,
+        QUEUE_PAUSED,
+};
+
+/**
  * struct data_queue: Data queue
  *
  * @rt2x00dev: Pointer to main &struct rt2x00dev where this queue belongs to.
  * @entries: Base address of the &struct queue_entry which are
  *      part of this queue.
  * @qid: The queue identification, see &enum data_queue_qid.
- * @lock: Spinlock to protect index handling. Whenever @index, @index_done or
+ * @flags: Entry flags, see &enum queue_entry_flags.
+ * @status_lock: The mutex for protecting the start/stop/flush
+ *      handling on this queue.
+ * @index_lock: Spinlock to protect index handling. Whenever @index, @index_done or
  *      @index_crypt needs to be changed this lock should be grabbed to prevent
  *      index corruption due to concurrency.
  * @count: Number of frames handled in the queue.
@@ -444,10 +455,11 @@ struct data_queue {
         struct queue_entry *entries;
 
         enum data_queue_qid qid;
+        unsigned long flags;
+
+        struct mutex status_lock;
+        spinlock_t index_lock;
 
-        spinlock_t lock;
-        unsigned long last_index;
-        unsigned long last_index_done;
         unsigned int count;
         unsigned short limit;
         unsigned short threshold;
@@ -565,6 +577,28 @@ struct data_queue_desc {
         queue_loop(__entry, (__dev)->tx, queue_end(__dev))
 
 /**
+ * rt2x00queue_for_each_entry - Loop through all entries in the queue
+ * @queue: Pointer to @data_queue
+ * @start: &enum queue_index Pointer to start index
+ * @end: &enum queue_index Pointer to end index
+ * @data: Data to pass to the callback function
+ * @fn: The function to call for each &struct queue_entry
+ *
+ * This will walk through all entries in the queue, in chronological
+ * order. This means it will start at the current @start pointer
+ * and will walk through the queue until it reaches the @end pointer.
+ *
+ * If fn returns true for an entry rt2x00queue_for_each_entry will stop
+ * processing and return true as well.
+ */
+bool rt2x00queue_for_each_entry(struct data_queue *queue,
+                                enum queue_index start,
+                                enum queue_index end,
+                                void *data,
+                                bool (*fn)(struct queue_entry *entry,
+                                           void *data));
+
+/**
  * rt2x00queue_empty - Check if the queue is empty.
  * @queue: Queue to check if empty.
  */
@@ -601,12 +635,25 @@ static inline int rt2x00queue_threshold(struct data_queue *queue)
 }
 
 /**
- * rt2x00queue_timeout - Check if a timeout occured for this queue
- * @queue: Queue to check.
+ * rt2x00queue_status_timeout - Check if a timeout occurred for STATUS reports
+ * @entry: Queue entry to check.
+ */
+static inline int rt2x00queue_status_timeout(struct queue_entry *entry)
+{
+        if (!test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
+                return false;
+        return time_after(jiffies, entry->last_action + msecs_to_jiffies(100));
+}
+
+/**
+ * rt2x00queue_dma_timeout - Check if a timeout occurred for DMA transfers
+ * @entry: Queue entry to check.
  */
-static inline int rt2x00queue_timeout(struct data_queue *queue)
+static inline int rt2x00queue_dma_timeout(struct queue_entry *entry)
 {
-        return time_after(queue->last_index, queue->last_index_done + (HZ / 10));
+        if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+                return false;
+        return time_after(jiffies, entry->last_action + msecs_to_jiffies(100));
 }
 
 /**