rt2x00: Implement rt2x00usb_kick_tx_queue()

rt2x00usb_kick_tx_queue() will loop over all entries
within the INDEX_DONE->INDEX range and kick each entry
which is pending to be kicked. This makes the kick_tx_queue
approach work the same as with the PCI drivers which
will allow for more code generalisation into rt2x00lib.

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

diff --git a/drivers/net/wireless/rt2x00/rt2500usb.c b/drivers/net/wireless/rt2x00/rt2500usb.c
index 0d51b748c5b75dc615d70abf2c6e7e909fe19824..6abb4c5338f5c6e46549e990b699fcaa34b3df3e 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt2500usb.c
+++ b/drivers/net/wireless/rt2x00/rt2500usb.c
@@ -1116,8 +1116,10 @@ static void rt2500usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
 {
        u16 reg;
 
-       if (queue != QID_BEACON)
+       if (queue != QID_BEACON) {
+               rt2x00usb_kick_tx_queue(rt2x00dev, queue);
                return;
+       }
 
        rt2500usb_register_read(rt2x00dev, TXRX_CSR19, &reg);
        if (!rt2x00_get_field16(reg, TXRX_CSR19_BEACON_GEN)) {

diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.h b/drivers/net/wireless/rt2x00/rt2x00queue.h
index 4d00ced14cc7c8a4e4f64743a4fae4f8f28f3211..303d5568470d2d61758b150985645f4172d353e8 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt2x00queue.h
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.h
@@ -260,11 +260,14 @@ struct txentry_desc {
  * @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.
  */
 enum queue_entry_flags {
        ENTRY_BCN_ASSIGNED,
        ENTRY_OWNER_DEVICE_DATA,
        ENTRY_OWNER_DEVICE_CRYPTO,
+       ENTRY_DATA_PENDING,
 };
 
 /**

diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index 66f15e6c7d255f04aca3d91734b0142c35ff1f4c..cdac9280fe4286f213b03f0624de8d54ce9a24a2 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -232,9 +232,10 @@ int rt2x00usb_write_tx_data(struct rt2x00_dev *rt2x00dev,
         * Initialize URB and send the frame to the device.
         */
        __set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
+       __set_bit(ENTRY_DATA_PENDING, &entry->flags);
+
        usb_fill_bulk_urb(entry_priv->urb, usb_dev, usb_sndbulkpipe(usb_dev, 1),
                          skb->data, length, rt2x00usb_interrupt_txdone, entry);
-       usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
 
        rt2x00queue_index_inc(queue, Q_INDEX);
 
@@ -242,6 +243,51 @@ int rt2x00usb_write_tx_data(struct rt2x00_dev *rt2x00dev,
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data);
 
+static inline void rt2x00usb_kick_tx_entry(struct queue_entry *entry)
+{
+       struct queue_entry_priv_usb *entry_priv = entry->priv_data;
+
+       if (__test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags))
+               usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
+}
+
+void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
+                            const enum data_queue_qid qid)
+{
+       struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
+       unsigned long irqflags;
+       unsigned int index;
+       unsigned int index_done;
+       unsigned int i;
+
+       /*
+        * Only protect the range we are going to loop over,
+        * if during our loop a extra entry is set to pending
+        * it should not be kicked during this run, since it
+        * is part of another TX operation.
+        */
+       spin_lock_irqsave(&queue->lock, irqflags);
+       index = queue->index[Q_INDEX];
+       index_done = queue->index[Q_INDEX_DONE];
+       spin_unlock_irqrestore(&queue->lock, irqflags);
+
+       /*
+        * Start from the TX done pointer, this guarentees that we will
+        * send out all frames in the correct order.
+        */
+       if (index_done < index) {
+               for (i = index_done; i < index; i++)
+                       rt2x00usb_kick_tx_entry(&queue->entries[i]);
+       } else {
+               for (i = index_done; i < queue->limit; i++)
+                       rt2x00usb_kick_tx_entry(&queue->entries[i]);
+
+               for (i = 0; i < index; i++)
+                       rt2x00usb_kick_tx_entry(&queue->entries[i]);
+       }
+}
+EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue);
+
 /*
  * RX data handlers.
  */

diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.h b/drivers/net/wireless/rt2x00/rt2x00usb.h
index 26f53f868af67e01440a1239741403c441b590cd..460d32c444d136c902096c17efd84707123cd6b9 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt2x00usb.h
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.h
@@ -245,6 +245,17 @@ struct queue_entry_priv_usb_bcn {
        struct urb *guardian_urb;
 };
 
+/**
+ * rt2x00usb_kick_tx_queue - Kick data queue
+ * @rt2x00dev: Pointer to &struct rt2x00_dev
+ * @qid: Data queue to kick
+ *
+ * This will walk through all entries of the queue and push all pending
+ * frames to the hardware as a single burst.
+ */
+void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
+                            const enum data_queue_qid qid);
+
 /*
  * Device initialization handlers.
  */

diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index db1fc136cda411bc39f0f34d1ee7f8d9f9b4dc75..5e5f6034383ab6673ba799cd42e8e22b04041fc4 100644 (file)
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -1350,8 +1350,10 @@ static void rt73usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
 {
        u32 reg;
 
-       if (queue != QID_BEACON)
+       if (queue != QID_BEACON) {
+               rt2x00usb_kick_tx_queue(rt2x00dev, queue);
                return;
+       }
 
        /*
         * For Wi-Fi faily generated beacons between participating stations.