1 files changed, 342 insertions, 178 deletions

diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index ff3a36622d1b..8f90f6268077 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -1,5 +1,6 @@
 /*
-        Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
+        Copyright (C) 2010 Willow Garage <http://www.willowgarage.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
@@ -164,221 +165,399 @@ int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read);
 
-/*
- * TX data handlers.
- */
-static void rt2x00usb_interrupt_txdone(struct urb *urb)
+
+struct rt2x00_async_read_data {
+        __le32 reg;
+        struct usb_ctrlrequest cr;
+        struct rt2x00_dev *rt2x00dev;
+        bool (*callback)(struct rt2x00_dev *, int, u32);
+};
+
+static void rt2x00usb_register_read_async_cb(struct urb *urb)
 {
-        struct queue_entry *entry = (struct queue_entry *)urb->context;
-        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
-        struct txdone_entry_desc txdesc;
+        struct rt2x00_async_read_data *rd = urb->context;
+        if (rd->callback(rd->rt2x00dev, urb->status, le32_to_cpu(rd->reg))) {
+                if (usb_submit_urb(urb, GFP_ATOMIC) < 0)
+                        kfree(rd);
+        } else
+                kfree(rd);
+}
+
+void rt2x00usb_register_read_async(struct rt2x00_dev *rt2x00dev,
+                                   const unsigned int offset,
+                                   bool (*callback)(struct rt2x00_dev*, int, u32))
+{
+        struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
+        struct urb *urb;
+        struct rt2x00_async_read_data *rd;
+
+        rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
+        if (!rd)
+                return;
 
-        if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
-            !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+        urb = usb_alloc_urb(0, GFP_ATOMIC);
+        if (!urb) {
+                kfree(rd);
                 return;
+        }
 
+        rd->rt2x00dev = rt2x00dev;
+        rd->callback = callback;
+        rd->cr.bRequestType = USB_VENDOR_REQUEST_IN;
+        rd->cr.bRequest = USB_MULTI_READ;
+        rd->cr.wValue = 0;
+        rd->cr.wIndex = cpu_to_le16(offset);
+        rd->cr.wLength = cpu_to_le16(sizeof(u32));
+
+        usb_fill_control_urb(urb, usb_dev, usb_rcvctrlpipe(usb_dev, 0),
+                             (unsigned char *)(&rd->cr), &rd->reg, sizeof(rd->reg),
+                             rt2x00usb_register_read_async_cb, rd);
+        if (usb_submit_urb(urb, GFP_ATOMIC) < 0)
+                kfree(rd);
+        usb_free_urb(urb);
+}
+EXPORT_SYMBOL_GPL(rt2x00usb_register_read_async);
+
+/*
+ * TX data handlers.
+ */
+static void rt2x00usb_work_txdone_entry(struct queue_entry *entry)
+{
         /*
-         * Obtain the status about this packet.
-         * Note that when the status is 0 it does not mean the
+         * If the transfer to hardware succeeded, it does not mean the
          * frame was send out correctly. It only means the frame
-         * was succesfully pushed to the hardware, we have no
+         * was successfully pushed to the hardware, we have no
          * way to determine the transmission status right now.
          * (Only indirectly by looking at the failed TX counters
          * in the register).
          */
-        txdesc.flags = 0;
-        if (!urb->status)
-                __set_bit(TXDONE_UNKNOWN, &txdesc.flags);
+        if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
+                rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE);
         else
-                __set_bit(TXDONE_FAILURE, &txdesc.flags);
-        txdesc.retry = 0;
-
-        rt2x00lib_txdone(entry, &txdesc);
+                rt2x00lib_txdone_noinfo(entry, TXDONE_UNKNOWN);
 }
 
-static inline void rt2x00usb_kick_tx_entry(struct queue_entry *entry)
+static void rt2x00usb_work_txdone(struct work_struct *work)
 {
-        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
-        struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
-        struct queue_entry_priv_usb *entry_priv = entry->priv_data;
-        u32 length;
+        struct rt2x00_dev *rt2x00dev =
+            container_of(work, struct rt2x00_dev, txdone_work);
+        struct data_queue *queue;
+        struct queue_entry *entry;
 
-        if (test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags)) {
-                /*
-                 * USB devices cannot blindly pass the skb->len as the
-                 * length of the data to usb_fill_bulk_urb. Pass the skb
-                 * to the driver to determine what the length should be.
-                 */
-                length = rt2x00dev->ops->lib->get_tx_data_len(entry);
+        tx_queue_for_each(rt2x00dev, queue) {
+                while (!rt2x00queue_empty(queue)) {
+                        entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
 
-                usb_fill_bulk_urb(entry_priv->urb, usb_dev,
-                                  usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint),
-                                  entry->skb->data, length,
-                                  rt2x00usb_interrupt_txdone, entry);
+                        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
+                            !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
+                                break;
 
-                usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
+                        rt2x00usb_work_txdone_entry(entry);
+                }
         }
 }
 
-void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
-                             const enum data_queue_qid qid)
+static void rt2x00usb_interrupt_txdone(struct urb *urb)
 {
-        struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
-        unsigned long irqflags;
-        unsigned int index;
-        unsigned int index_done;
-        unsigned int i;
+        struct queue_entry *entry = (struct queue_entry *)urb->context;
+        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
+
+        if (!test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+                return;
+
+        if (rt2x00dev->ops->lib->tx_dma_done)
+                rt2x00dev->ops->lib->tx_dma_done(entry);
 
         /*
-         * 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.
+         * Report the frame as DMA done
          */
-        spin_lock_irqsave(&queue->lock, irqflags);
-        index = queue->index[Q_INDEX];
-        index_done = queue->index[Q_INDEX_DONE];
-        spin_unlock_irqrestore(&queue->lock, irqflags);
+        rt2x00lib_dmadone(entry);
 
         /*
-         * Start from the TX done pointer, this guarentees that we will
-         * send out all frames in the correct order.
+         * Check if the frame was correctly uploaded
          */
-        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]);
+        if (urb->status)
+                set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
 
-                for (i = 0; i < index; i++)
-                        rt2x00usb_kick_tx_entry(&queue->entries[i]);
-        }
+        /*
+         * Schedule the delayed work for reading the TX status
+         * from the device.
+         */
+        if (!test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags) ||
+            !kfifo_is_empty(&rt2x00dev->txstatus_fifo))
+                queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work);
 }
-EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue);
 
-void rt2x00usb_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
-                             const enum data_queue_qid qid)
+static bool rt2x00usb_kick_tx_entry(struct queue_entry *entry, void* data)
 {
-        struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
-        struct queue_entry_priv_usb *entry_priv;
-        struct queue_entry_priv_usb_bcn *bcn_priv;
-        unsigned int i;
-        bool kill_guard;
+        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
+        struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
+        struct queue_entry_priv_usb *entry_priv = entry->priv_data;
+        u32 length;
+        int status;
 
-        /*
-         * When killing the beacon queue, we must also kill
-         * the beacon guard byte.
-         */
-        kill_guard =
-            (qid == QID_BEACON) &&
-            (test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags));
+        if (!test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags) ||
+            test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
+                return false;
 
         /*
-         * Cancel all entries.
+         * USB devices cannot blindly pass the skb->len as the
+         * length of the data to usb_fill_bulk_urb. Pass the skb
+         * to the driver to determine what the length should be.
          */
-        for (i = 0; i < queue->limit; i++) {
-                entry_priv = queue->entries[i].priv_data;
-                usb_kill_urb(entry_priv->urb);
+        length = rt2x00dev->ops->lib->get_tx_data_len(entry);
+
+        usb_fill_bulk_urb(entry_priv->urb, usb_dev,
+                          usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint),
+                          entry->skb->data, length,
+                          rt2x00usb_interrupt_txdone, entry);
+
+        status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
+        if (status) {
+                if (status == -ENODEV)
+                        clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
+                set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
+                rt2x00lib_dmadone(entry);
+        }
+
+        return false;
+}
+
+/*
+ * RX data handlers.
+ */
+static void rt2x00usb_work_rxdone(struct work_struct *work)
+{
+        struct rt2x00_dev *rt2x00dev =
+            container_of(work, struct rt2x00_dev, rxdone_work);
+        struct queue_entry *entry;
+        struct skb_frame_desc *skbdesc;
+        u8 rxd[32];
+
+        while (!rt2x00queue_empty(rt2x00dev->rx)) {
+                entry = rt2x00queue_get_entry(rt2x00dev->rx, Q_INDEX_DONE);
+
+                if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
+                    !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
+                        break;
 
                 /*
-                 * Kill guardian urb (if required by driver).
+                 * Fill in desc fields of the skb descriptor
                  */
-                if (kill_guard) {
-                        bcn_priv = queue->entries[i].priv_data;
-                        usb_kill_urb(bcn_priv->guardian_urb);
-                }
+                skbdesc = get_skb_frame_desc(entry->skb);
+                skbdesc->desc = rxd;
+                skbdesc->desc_len = entry->queue->desc_size;
+
+                /*
+                 * Send the frame to rt2x00lib for further processing.
+                 */
+                rt2x00lib_rxdone(entry);
         }
 }
-EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue);
 
-static void rt2x00usb_watchdog_reset_tx(struct data_queue *queue)
+static void rt2x00usb_interrupt_rxdone(struct urb *urb)
 {
-        struct queue_entry_priv_usb *entry_priv;
-        unsigned short threshold = queue->threshold;
+        struct queue_entry *entry = (struct queue_entry *)urb->context;
+        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
 
-        WARNING(queue->rt2x00dev, "TX queue %d timed out, invoke reset", queue->qid);
+        if (!test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+                return;
 
         /*
-         * Temporarily disable the TX queue, this will force mac80211
-         * to use the other queues until this queue has been restored.
-         *
-         * Set the queue threshold to the queue limit. This prevents the
-         * queue from being enabled during the txdone handler.
+         * Report the frame as DMA done
          */
-        queue->threshold = queue->limit;
-        ieee80211_stop_queue(queue->rt2x00dev->hw, queue->qid);
+        rt2x00lib_dmadone(entry);
 
         /*
-         * Reset all currently uploaded TX frames.
+         * Check if the received data is simply too small
+         * to be actually valid, or if the urb is signaling
+         * a problem.
          */
-        while (!rt2x00queue_empty(queue)) {
-                entry_priv = rt2x00queue_get_entry(queue, Q_INDEX_DONE)->priv_data;
-                usb_kill_urb(entry_priv->urb);
-
-                /*
-                 * We need a short delay here to wait for
-                 * the URB to be canceled and invoked the tx_done handler.
-                 */
-                udelay(200);
-        }
+        if (urb->actual_length < entry->queue->desc_size || urb->status)
+                set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
 
         /*
-         * The queue has been reset, and mac80211 is allowed to use the
-         * queue again.
+         * Schedule the delayed work for reading the RX status
+         * from the device.
          */
-        queue->threshold = threshold;
-        ieee80211_wake_queue(queue->rt2x00dev->hw, queue->qid);
+        queue_work(rt2x00dev->workqueue, &rt2x00dev->rxdone_work);
 }
 
-void rt2x00usb_watchdog(struct rt2x00_dev *rt2x00dev)
+static bool rt2x00usb_kick_rx_entry(struct queue_entry *entry, void* data)
 {
-        struct data_queue *queue;
+        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
+        struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
+        struct queue_entry_priv_usb *entry_priv = entry->priv_data;
+        int status;
 
-        tx_queue_for_each(rt2x00dev, queue) {
-                if (rt2x00queue_timeout(queue))
-                        rt2x00usb_watchdog_reset_tx(queue);
+        if (test_and_set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
+            test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
+                return false;
+
+        rt2x00lib_dmastart(entry);
+
+        usb_fill_bulk_urb(entry_priv->urb, usb_dev,
+                          usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint),
+                          entry->skb->data, entry->skb->len,
+                          rt2x00usb_interrupt_rxdone, entry);
+
+        status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
+        if (status) {
+                if (status == -ENODEV)
+                        clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
+                set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
+                rt2x00lib_dmadone(entry);
         }
+
+        return false;
 }
-EXPORT_SYMBOL_GPL(rt2x00usb_watchdog);
 
-/*
- * RX data handlers.
- */
-static void rt2x00usb_interrupt_rxdone(struct urb *urb)
+void rt2x00usb_kick_queue(struct data_queue *queue)
+{
+        switch (queue->qid) {
+        case QID_AC_VO:
+        case QID_AC_VI:
+        case QID_AC_BE:
+        case QID_AC_BK:
+                if (!rt2x00queue_empty(queue))
+                        rt2x00queue_for_each_entry(queue,
+                                                   Q_INDEX_DONE,
+                                                   Q_INDEX,
+                                                   NULL,
+                                                   rt2x00usb_kick_tx_entry);
+                break;
+        case QID_RX:
+                if (!rt2x00queue_full(queue))
+                        rt2x00queue_for_each_entry(queue,
+                                                   Q_INDEX_DONE,
+                                                   Q_INDEX,
+                                                   NULL,
+                                                   rt2x00usb_kick_rx_entry);
+                break;
+        default:
+                break;
+        }
+}
+EXPORT_SYMBOL_GPL(rt2x00usb_kick_queue);
+
+static bool rt2x00usb_flush_entry(struct queue_entry *entry, void* data)
 {
-        struct queue_entry *entry = (struct queue_entry *)urb->context;
         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
-        struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
-        u8 rxd[32];
+        struct queue_entry_priv_usb *entry_priv = entry->priv_data;
+        struct queue_entry_priv_usb_bcn *bcn_priv = entry->priv_data;
 
-        if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
-            !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
-                return;
+        if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+                return false;
 
-        /*
-         * Check if the received data is simply too small
-         * to be actually valid, or if the urb is signaling
-         * a problem.
-         */
-        if (urb->actual_length < entry->queue->desc_size || urb->status) {
-                set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
-                usb_submit_urb(urb, GFP_ATOMIC);
-                return;
-        }
+        usb_kill_urb(entry_priv->urb);
 
         /*
-         * Fill in desc fields of the skb descriptor
+         * Kill guardian urb (if required by driver).
          */
-        skbdesc->desc = rxd;
-        skbdesc->desc_len = entry->queue->desc_size;
+        if ((entry->queue->qid == QID_BEACON) &&
+            (test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags)))
+                usb_kill_urb(bcn_priv->guardian_urb);
+
+        return false;
+}
+
+void rt2x00usb_flush_queue(struct data_queue *queue, bool drop)
+{
+        struct work_struct *completion;
+        unsigned int i;
+
+        if (drop)
+                rt2x00queue_for_each_entry(queue, Q_INDEX_DONE, Q_INDEX, NULL,
+                                           rt2x00usb_flush_entry);
 
         /*
-         * Send the frame to rt2x00lib for further processing.
+         * Obtain the queue completion handler
          */
-        rt2x00lib_rxdone(rt2x00dev, entry);
+        switch (queue->qid) {
+        case QID_AC_VO:
+        case QID_AC_VI:
+        case QID_AC_BE:
+        case QID_AC_BK:
+                completion = &queue->rt2x00dev->txdone_work;
+                break;
+        case QID_RX:
+                completion = &queue->rt2x00dev->rxdone_work;
+                break;
+        default:
+                return;
+        }
+
+        for (i = 0; i < 10; i++) {
+                /*
+                 * Check if the driver is already done, otherwise we
+                 * have to sleep a little while to give the driver/hw
+                 * the oppurtunity to complete interrupt process itself.
+                 */
+                if (rt2x00queue_empty(queue))
+                        break;
+
+                /*
+                 * Schedule the completion handler manually, when this
+                 * worker function runs, it should cleanup the queue.
+                 */
+                queue_work(queue->rt2x00dev->workqueue, completion);
+
+                /*
+                 * Wait for a little while to give the driver
+                 * the oppurtunity to recover itself.
+                 */
+                msleep(10);
+        }
+}
+EXPORT_SYMBOL_GPL(rt2x00usb_flush_queue);
+
+static void rt2x00usb_watchdog_tx_dma(struct data_queue *queue)
+{
+        WARNING(queue->rt2x00dev, "TX queue %d DMA timed out,"
+                " invoke forced forced reset\n", queue->qid);
+
+        rt2x00queue_flush_queue(queue, true);
+}
+
+static void rt2x00usb_watchdog_tx_status(struct data_queue *queue)
+{
+        WARNING(queue->rt2x00dev, "TX queue %d status timed out,"
+                " invoke forced tx handler\n", queue->qid);
+
+        queue_work(queue->rt2x00dev->workqueue, &queue->rt2x00dev->txdone_work);
 }
 
+static int rt2x00usb_status_timeout(struct data_queue *queue)
+{
+        struct queue_entry *entry;
+
+        entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
+        return rt2x00queue_status_timeout(entry);
+}
+
+static int rt2x00usb_dma_timeout(struct data_queue *queue)
+{
+        struct queue_entry *entry;
+
+        entry = rt2x00queue_get_entry(queue, Q_INDEX_DMA_DONE);
+        return rt2x00queue_dma_timeout(entry);
+}
+
+void rt2x00usb_watchdog(struct rt2x00_dev *rt2x00dev)
+{
+        struct data_queue *queue;
+
+        tx_queue_for_each(rt2x00dev, queue) {
+                if (!rt2x00queue_empty(queue)) {
+                        if (rt2x00usb_dma_timeout(queue))
+                                rt2x00usb_watchdog_tx_dma(queue);
+                        if (rt2x00usb_status_timeout(queue))
+                                rt2x00usb_watchdog_tx_status(queue);
+                }
+        }
+}
+EXPORT_SYMBOL_GPL(rt2x00usb_watchdog);
+
 /*
  * Radio handlers
  */
@@ -386,12 +565,6 @@ void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
 {
         rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
                                     REGISTER_TIMEOUT);
-
-        /*
-         * The USB version of kill_tx_queue also works
-         * on the RX queue.
-         */
-        rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev, QID_RX);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
 
@@ -400,22 +573,10 @@ EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
  */
 void rt2x00usb_clear_entry(struct queue_entry *entry)
 {
-        struct usb_device *usb_dev =
-            to_usb_device_intf(entry->queue->rt2x00dev->dev);
-        struct queue_entry_priv_usb *entry_priv = entry->priv_data;
-        int pipe;
-
-        if (entry->queue->qid == QID_RX) {
-                pipe = usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint);
-                usb_fill_bulk_urb(entry_priv->urb, usb_dev, pipe,
-                                entry->skb->data, entry->skb->len,
-                                rt2x00usb_interrupt_rxdone, entry);
+        entry->flags = 0;
 
-                set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
-                usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
-        } else {
-                entry->flags = 0;
-        }
+        if (entry->queue->qid == QID_RX)
+                rt2x00usb_kick_rx_entry(entry, NULL);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry);
 
@@ -489,9 +650,9 @@ static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
         return 0;
 }
 
-static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
-                               struct data_queue *queue)
+static int rt2x00usb_alloc_entries(struct data_queue *queue)
 {
+        struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
         struct queue_entry_priv_usb *entry_priv;
         struct queue_entry_priv_usb_bcn *bcn_priv;
         unsigned int i;
@@ -508,8 +669,8 @@ static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
          * no guardian byte was required for the beacon,
          * then we are done.
          */
-        if (rt2x00dev->bcn != queue ||
-            !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
+        if (queue->qid != QID_BEACON ||
+            !test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags))
                 return 0;
 
         for (i = 0; i < queue->limit; i++) {
@@ -522,9 +683,9 @@ static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
         return 0;
 }
 
-static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
-                               struct data_queue *queue)
+static void rt2x00usb_free_entries(struct data_queue *queue)
 {
+        struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
         struct queue_entry_priv_usb *entry_priv;
         struct queue_entry_priv_usb_bcn *bcn_priv;
         unsigned int i;
@@ -543,8 +704,8 @@ static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
          * no guardian byte was required for the beacon,
          * then we are done.
          */
-        if (rt2x00dev->bcn != queue ||
-            !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
+        if (queue->qid != QID_BEACON ||
+            !test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags))
                 return;
 
         for (i = 0; i < queue->limit; i++) {
@@ -570,7 +731,7 @@ int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
          * Allocate DMA
          */
         queue_for_each(rt2x00dev, queue) {
-                status = rt2x00usb_alloc_urb(rt2x00dev, queue);
+                status = rt2x00usb_alloc_entries(queue);
                 if (status)
                         goto exit;
         }
@@ -589,7 +750,7 @@ void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
         struct data_queue *queue;
 
         queue_for_each(rt2x00dev, queue)
-                rt2x00usb_free_urb(rt2x00dev, queue);
+                rt2x00usb_free_entries(queue);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
 
@@ -633,10 +794,9 @@ exit:
 }
 
 int rt2x00usb_probe(struct usb_interface *usb_intf,
-                    const struct usb_device_id *id)
+                    const struct rt2x00_ops *ops)
 {
         struct usb_device *usb_dev = interface_to_usbdev(usb_intf);
-        struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info;
         struct ieee80211_hw *hw;
         struct rt2x00_dev *rt2x00dev;
         int retval;
@@ -659,6 +819,10 @@ int rt2x00usb_probe(struct usb_interface *usb_intf,
 
         rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_USB);
 
+        INIT_WORK(&rt2x00dev->rxdone_work, rt2x00usb_work_rxdone);
+        INIT_WORK(&rt2x00dev->txdone_work, rt2x00usb_work_txdone);
+        init_timer(&rt2x00dev->txstatus_timer);
+
         retval = rt2x00usb_alloc_reg(rt2x00dev);
         if (retval)
                 goto exit_free_device;