rt2x00: Queue handling overhaul

This introduces a big queue handling overhaul, this also
renames "ring" to "queues".

Move queue handling into rt2x00queue.c and the matching header,
use Kerneldoc to improve rt2x00 library documentation.

Access to the queues is now protected under a spinlock, this
to prevent race conditions which could corrupt the indexing
system of the queue.

Each queue entry allocates x bytes for driver/device specific data,
this cleans up the queue structure significantly and improves
code readability.

rt2500usb no longer needs 2 entries in the beacon queue to correctly
send out the guardian byte. This is now handled in the entry specific
structure.

rt61 and rt73 now use the correct descriptor size for beacon frames,
since this data is written into the registers not the entire TXD
descriptor was used but instead of a subset of it named TXINFO.

Finally this also fixes numerous other bugs related to incorrect
beacon handling or beacon related code.

Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 163 insertions, 127 deletions

diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index 47cd0a5bf17c..fc606448908e 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -40,8 +40,7 @@ int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev,
                              void *buffer, const u16 buffer_length,
                              const int timeout)
 {
-        struct usb_device *usb_dev =
-            interface_to_usbdev(rt2x00dev_usb(rt2x00dev));
+        struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev);
         int status;
         unsigned int i;
         unsigned int pipe =
@@ -128,15 +127,15 @@ EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
  */
 static void rt2x00usb_interrupt_txdone(struct urb *urb)
 {
-        struct data_entry *entry = (struct data_entry *)urb->context;
-        struct data_ring *ring = entry->ring;
-        struct rt2x00_dev *rt2x00dev = ring->rt2x00dev;
+        struct queue_entry *entry = (struct queue_entry *)urb->context;
+        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
+        struct queue_entry_priv_usb_tx *priv_tx = entry->priv_data;
+        struct txdone_entry_desc txdesc;
         __le32 *txd = (__le32 *)entry->skb->data;
         u32 word;
-        int tx_status;
 
         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
-            !__test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags))
+            !__test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
                 return;
 
         rt2x00_desc_read(txd, 0, &word);
@@ -144,45 +143,46 @@ static void rt2x00usb_interrupt_txdone(struct urb *urb)
         /*
          * Remove the descriptor data from the buffer.
          */
-        skb_pull(entry->skb, ring->desc_size);
+        skb_pull(entry->skb, entry->queue->desc_size);
 
         /*
          * Obtain the status about this packet.
          */
-        tx_status = !urb->status ? TX_SUCCESS : TX_FAIL_RETRY;
+        txdesc.status = !urb->status ? TX_SUCCESS : TX_FAIL_RETRY;
+        txdesc.retry = 0;
+        txdesc.control = &priv_tx->control;
 
-        rt2x00lib_txdone(entry, tx_status, 0);
+        rt2x00lib_txdone(entry, &txdesc);
 
         /*
          * Make this entry available for reuse.
          */
         entry->flags = 0;
-        rt2x00_ring_index_done_inc(entry->ring);
+        rt2x00queue_index_inc(entry->queue, Q_INDEX_DONE);
 
         /*
-         * If the data ring was full before the txdone handler
+         * If the data queue was full before the txdone handler
          * we must make sure the packet queue in the mac80211 stack
          * is reenabled when the txdone handler has finished.
          */
-        if (!rt2x00_ring_full(ring))
-                ieee80211_wake_queue(rt2x00dev->hw,
-                                     entry->tx_status.control.queue);
+        if (!rt2x00queue_full(entry->queue))
+                ieee80211_wake_queue(rt2x00dev->hw, priv_tx->control.queue);
 }
 
 int rt2x00usb_write_tx_data(struct rt2x00_dev *rt2x00dev,
-                            struct data_ring *ring, struct sk_buff *skb,
+                            struct data_queue *queue, struct sk_buff *skb,
                             struct ieee80211_tx_control *control)
 {
-        struct usb_device *usb_dev =
-            interface_to_usbdev(rt2x00dev_usb(rt2x00dev));
-        struct data_entry *entry = rt2x00_get_data_entry(ring);
-        struct skb_desc *desc;
+        struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev);
+        struct queue_entry *entry = rt2x00queue_get_entry(queue, Q_INDEX);
+        struct queue_entry_priv_usb_tx *priv_tx = entry->priv_data;
+        struct skb_frame_desc *skbdesc;
         u32 length;
 
-        if (rt2x00_ring_full(ring))
+        if (rt2x00queue_full(queue))
                 return -EINVAL;
 
-        if (test_bit(ENTRY_OWNER_NIC, &entry->flags)) {
+        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags)) {
                 ERROR(rt2x00dev,
                       "Arrived at non-free entry in the non-full queue %d.\n"
                       "Please file bug report to %s.\n",
@@ -193,19 +193,19 @@ int rt2x00usb_write_tx_data(struct rt2x00_dev *rt2x00dev,
         /*
          * Add the descriptor in front of the skb.
          */
-        skb_push(skb, ring->desc_size);
-        memset(skb->data, 0, ring->desc_size);
+        skb_push(skb, queue->desc_size);
+        memset(skb->data, 0, queue->desc_size);
 
         /*
          * Fill in skb descriptor
          */
-        desc = get_skb_desc(skb);
-        desc->desc_len = ring->desc_size;
-        desc->data_len = skb->len - ring->desc_size;
-        desc->desc = skb->data;
-        desc->data = skb->data + ring->desc_size;
-        desc->ring = ring;
-        desc->entry = entry;
+        skbdesc = get_skb_frame_desc(skb);
+        memset(skbdesc, 0, sizeof(*skbdesc));
+        skbdesc->data = skb->data + queue->desc_size;
+        skbdesc->data_len = queue->data_size;
+        skbdesc->desc = skb->data;
+        skbdesc->desc_len = queue->desc_size;
+        skbdesc->entry = entry;
 
         rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
 
@@ -219,12 +219,12 @@ int rt2x00usb_write_tx_data(struct rt2x00_dev *rt2x00dev,
         /*
          * Initialize URB and send the frame to the device.
          */
-        __set_bit(ENTRY_OWNER_NIC, &entry->flags);
-        usb_fill_bulk_urb(entry->priv, usb_dev, usb_sndbulkpipe(usb_dev, 1),
+        __set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
+        usb_fill_bulk_urb(priv_tx->urb, usb_dev, usb_sndbulkpipe(usb_dev, 1),
                           skb->data, length, rt2x00usb_interrupt_txdone, entry);
-        usb_submit_urb(entry->priv, GFP_ATOMIC);
+        usb_submit_urb(priv_tx->urb, GFP_ATOMIC);
 
-        rt2x00_ring_index_inc(ring);
+        rt2x00queue_index_inc(queue, Q_INDEX);
 
         return 0;
 }
@@ -233,20 +233,41 @@ EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data);
 /*
  * RX data handlers.
  */
+static struct sk_buff* rt2x00usb_alloc_rxskb(struct data_queue *queue)
+{
+        struct sk_buff *skb;
+        unsigned int frame_size;
+
+        /*
+         * As alignment we use 2 and not NET_IP_ALIGN because we need
+         * to be sure we have 2 bytes room in the head. (NET_IP_ALIGN
+         * can be 0 on some hardware). We use these 2 bytes for frame
+         * alignment later, we assume that the chance that
+         * header_size % 4 == 2 is bigger then header_size % 2 == 0
+         * and thus optimize alignment by reserving the 2 bytes in
+         * advance.
+         */
+        frame_size = queue->data_size + queue->desc_size;
+        skb = dev_alloc_skb(frame_size + 2);
+        if (!skb)
+                return NULL;
+
+        skb_reserve(skb, 2);
+        skb_put(skb, frame_size);
+
+        return skb;
+}
+
 static void rt2x00usb_interrupt_rxdone(struct urb *urb)
 {
-        struct data_entry *entry = (struct data_entry *)urb->context;
-        struct data_ring *ring = entry->ring;
-        struct rt2x00_dev *rt2x00dev = ring->rt2x00dev;
+        struct queue_entry *entry = (struct queue_entry *)urb->context;
+        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
         struct sk_buff *skb;
-        struct ieee80211_hdr *hdr;
-        struct skb_desc *skbdesc;
-        struct rxdata_entry_desc desc;
-        int header_size;
-        int frame_size;
+        struct skb_frame_desc *skbdesc;
+        struct rxdone_entry_desc rxdesc;
 
         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
-            !test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags))
+            !test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
                 return;
 
         /*
@@ -254,67 +275,32 @@ static void rt2x00usb_interrupt_rxdone(struct urb *urb)
          * to be actually valid, or if the urb is signaling
          * a problem.
          */
-        if (urb->actual_length < entry->ring->desc_size || urb->status)
+        if (urb->actual_length < entry->queue->desc_size || urb->status)
                 goto skip_entry;
 
         /*
          * Fill in skb descriptor
          */
-        skbdesc = get_skb_desc(entry->skb);
-        skbdesc->ring = ring;
+        skbdesc = get_skb_frame_desc(entry->skb);
+        memset(skbdesc, 0, sizeof(*skbdesc));
         skbdesc->entry = entry;
 
-        memset(&desc, 0, sizeof(desc));
-        rt2x00dev->ops->lib->fill_rxdone(entry, &desc);
+        memset(&rxdesc, 0, sizeof(rxdesc));
+        rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
 
         /*
          * Allocate a new sk buffer to replace the current one.
          * If allocation fails, we should drop the current frame
          * so we can recycle the existing sk buffer for the new frame.
-         * As alignment we use 2 and not NET_IP_ALIGN because we need
-         * to be sure we have 2 bytes room in the head. (NET_IP_ALIGN
-         * can be 0 on some hardware). We use these 2 bytes for frame
-         * alignment later, we assume that the chance that
-         * header_size % 4 == 2 is bigger then header_size % 2 == 0
-         * and thus optimize alignment by reserving the 2 bytes in
-         * advance.
          */
-        frame_size = entry->ring->data_size + entry->ring->desc_size;
-        skb = dev_alloc_skb(frame_size + 2);
+        skb = rt2x00usb_alloc_rxskb(entry->queue);
         if (!skb)
                 goto skip_entry;
 
-        skb_reserve(skb, 2);
-        skb_put(skb, frame_size);
-
-        /*
-         * The data behind the ieee80211 header must be
-         * aligned on a 4 byte boundary.
-         */
-        hdr = (struct ieee80211_hdr *)entry->skb->data;
-        header_size =
-            ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_control));
-
-        if (header_size % 4 == 0) {
-                skb_push(entry->skb, 2);
-                memmove(entry->skb->data, entry->skb->data + 2, skb->len - 2);
-        }
-
-        /*
-         * Trim the entire buffer down to only contain the valid frame data
-         * excluding the device descriptor. The position of the descriptor
-         * varies. This means that we should check where the descriptor is
-         * and decide if we need to pull the data pointer to exclude the
-         * device descriptor.
-         */
-        if (skbdesc->data > skbdesc->desc)
-                skb_pull(entry->skb, skbdesc->desc_len);
-        skb_trim(entry->skb, desc.size);
-
         /*
          * Send the frame to rt2x00lib for further processing.
          */
-        rt2x00lib_rxdone(entry, entry->skb, &desc);
+        rt2x00lib_rxdone(entry, &rxdesc);
 
         /*
          * Replace current entry's skb with the newly allocated one,
@@ -325,12 +311,12 @@ static void rt2x00usb_interrupt_rxdone(struct urb *urb)
         urb->transfer_buffer_length = entry->skb->len;
 
 skip_entry:
-        if (test_bit(DEVICE_ENABLED_RADIO, &ring->rt2x00dev->flags)) {
-                __set_bit(ENTRY_OWNER_NIC, &entry->flags);
+        if (test_bit(DEVICE_ENABLED_RADIO, &entry->queue->rt2x00dev->flags)) {
+                __set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
                 usb_submit_urb(urb, GFP_ATOMIC);
         }
 
-        rt2x00_ring_index_inc(ring);
+        rt2x00queue_index_inc(entry->queue, Q_INDEX);
 }
 
 /*
@@ -338,18 +324,27 @@ skip_entry:
  */
 void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
 {
-        struct data_ring *ring;
+        struct queue_entry_priv_usb_rx *priv_rx;
+        struct queue_entry_priv_usb_tx *priv_tx;
+        struct data_queue *queue;
         unsigned int i;
 
         rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0x0000, 0x0000,
                                     REGISTER_TIMEOUT);
 
         /*
-         * Cancel all rings.
+         * Cancel all queues.
          */
-        ring_for_each(rt2x00dev, ring) {
-                for (i = 0; i < ring->stats.limit; i++)
-                        usb_kill_urb(ring->entry[i].priv);
+        for (i = 0; i < rt2x00dev->rx->limit; i++) {
+                priv_rx = rt2x00dev->rx->entries[i].priv_data;
+                usb_kill_urb(priv_rx->urb);
+        }
+
+        txall_queue_for_each(rt2x00dev, queue) {
+                for (i = 0; i < queue->limit; i++) {
+                        priv_tx = queue->entries[i].priv_data;
+                        usb_kill_urb(priv_tx->urb);
+                }
         }
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
@@ -358,64 +353,108 @@ EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
  * Device initialization handlers.
  */
 void rt2x00usb_init_rxentry(struct rt2x00_dev *rt2x00dev,
-                            struct data_entry *entry)
+                            struct queue_entry *entry)
 {
-        struct usb_device *usb_dev =
-             interface_to_usbdev(rt2x00dev_usb(rt2x00dev));
+        struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev);
+        struct queue_entry_priv_usb_rx *priv_rx = entry->priv_data;
 
-        usb_fill_bulk_urb(entry->priv, usb_dev,
+        usb_fill_bulk_urb(priv_rx->urb, usb_dev,
                           usb_rcvbulkpipe(usb_dev, 1),
                           entry->skb->data, entry->skb->len,
                           rt2x00usb_interrupt_rxdone, entry);
 
-        __set_bit(ENTRY_OWNER_NIC, &entry->flags);
-        usb_submit_urb(entry->priv, GFP_ATOMIC);
+        __set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
+        usb_submit_urb(priv_rx->urb, GFP_ATOMIC);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_init_rxentry);
 
 void rt2x00usb_init_txentry(struct rt2x00_dev *rt2x00dev,
-                            struct data_entry *entry)
+                            struct queue_entry *entry)
 {
         entry->flags = 0;
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_init_txentry);
 
 static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
-                               struct data_ring *ring)
+                               struct data_queue *queue)
 {
+        struct queue_entry_priv_usb_rx *priv_rx;
+        struct queue_entry_priv_usb_tx *priv_tx;
+        struct queue_entry_priv_usb_bcn *priv_bcn;
+        struct urb *urb;
+        unsigned int guardian =
+            test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags);
         unsigned int i;
 
         /*
          * Allocate the URB's
          */
-        for (i = 0; i < ring->stats.limit; i++) {
-                ring->entry[i].priv = usb_alloc_urb(0, GFP_KERNEL);
-                if (!ring->entry[i].priv)
+        for (i = 0; i < queue->limit; i++) {
+                urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!urb)
                         return -ENOMEM;
+
+                if (queue->qid == QID_RX) {
+                        priv_rx = queue->entries[i].priv_data;
+                        priv_rx->urb = urb;
+                } else if (queue->qid == QID_MGMT && guardian) {
+                        priv_bcn = queue->entries[i].priv_data;
+                        priv_bcn->urb = urb;
+
+                        urb = usb_alloc_urb(0, GFP_KERNEL);
+                        if (!urb)
+                                return -ENOMEM;
+
+                        priv_bcn->guardian_urb = urb;
+                } else {
+                        priv_tx = queue->entries[i].priv_data;
+                        priv_tx->urb = urb;
+                }
         }
 
         return 0;
 }
 
 static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
-                               struct data_ring *ring)
+                               struct data_queue *queue)
 {
+        struct queue_entry_priv_usb_rx *priv_rx;
+        struct queue_entry_priv_usb_tx *priv_tx;
+        struct queue_entry_priv_usb_bcn *priv_bcn;
+        struct urb *urb;
+        unsigned int guardian =
+            test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags);
         unsigned int i;
 
-        if (!ring->entry)
+        if (!queue->entries)
                 return;
 
-        for (i = 0; i < ring->stats.limit; i++) {
-                usb_kill_urb(ring->entry[i].priv);
-                usb_free_urb(ring->entry[i].priv);
-                if (ring->entry[i].skb)
-                        kfree_skb(ring->entry[i].skb);
+        for (i = 0; i < queue->limit; i++) {
+                if (queue->qid == QID_RX) {
+                        priv_rx = queue->entries[i].priv_data;
+                        urb = priv_rx->urb;
+                } else if (queue->qid == QID_MGMT && guardian) {
+                        priv_bcn = queue->entries[i].priv_data;
+
+                        usb_kill_urb(priv_bcn->guardian_urb);
+                        usb_free_urb(priv_bcn->guardian_urb);
+
+                        urb = priv_bcn->urb;
+                } else {
+                        priv_tx = queue->entries[i].priv_data;
+                        urb = priv_tx->urb;
+                }
+
+                usb_kill_urb(urb);
+                usb_free_urb(urb);
+                if (queue->entries[i].skb)
+                        kfree_skb(queue->entries[i].skb);
         }
 }
 
 int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
 {
-        struct data_ring *ring;
+        struct data_queue *queue;
         struct sk_buff *skb;
         unsigned int entry_size;
         unsigned int i;
@@ -424,25 +463,22 @@ int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
         /*
          * Allocate DMA
          */
-        ring_for_each(rt2x00dev, ring) {
-                status = rt2x00usb_alloc_urb(rt2x00dev, ring);
+        queue_for_each(rt2x00dev, queue) {
+                status = rt2x00usb_alloc_urb(rt2x00dev, queue);
                 if (status)
                         goto exit;
         }
 
         /*
-         * For the RX ring, skb's should be allocated.
+         * For the RX queue, skb's should be allocated.
          */
         entry_size = rt2x00dev->rx->data_size + rt2x00dev->rx->desc_size;
-        for (i = 0; i < rt2x00dev->rx->stats.limit; i++) {
-                skb = dev_alloc_skb(NET_IP_ALIGN + entry_size);
+        for (i = 0; i < rt2x00dev->rx->limit; i++) {
+                skb = rt2x00usb_alloc_rxskb(rt2x00dev->rx);
                 if (!skb)
                         goto exit;
 
-                skb_reserve(skb, NET_IP_ALIGN);
-                skb_put(skb, entry_size);
-
-                rt2x00dev->rx->entry[i].skb = skb;
+                rt2x00dev->rx->entries[i].skb = skb;
         }
 
         return 0;
@@ -456,10 +492,10 @@ EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
 
 void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
 {
-        struct data_ring *ring;
+        struct data_queue *queue;
 
-        ring_for_each(rt2x00dev, ring)
-                rt2x00usb_free_urb(rt2x00dev, ring);
+        queue_for_each(rt2x00dev, queue)
+                rt2x00usb_free_urb(rt2x00dev, queue);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
 
@@ -627,9 +663,9 @@ EXPORT_SYMBOL_GPL(rt2x00usb_resume);
 #endif /* CONFIG_PM */
 
 /*
- * rt2x00pci module information.
+ * rt2x00usb module information.
  */
 MODULE_AUTHOR(DRV_PROJECT);
 MODULE_VERSION(DRV_VERSION);
-MODULE_DESCRIPTION("rt2x00 library");
+MODULE_DESCRIPTION("rt2x00 usb library");
 MODULE_LICENSE("GPL");