1 files changed, 265 insertions, 180 deletions

diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index aa9de18fd410..ad20953cbf05 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -40,7 +40,7 @@
 /*
  * Allow hardware encryption to be disabled.
  */
-static int modparam_nohwcrypt = 0;
+static int modparam_nohwcrypt;
 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
 
@@ -502,26 +502,14 @@ static void rt73usb_config_intf(struct rt2x00_dev *rt2x00dev,
                                 struct rt2x00intf_conf *conf,
                                 const unsigned int flags)
 {
-        unsigned int beacon_base;
         u32 reg;
 
         if (flags & CONFIG_UPDATE_TYPE) {
                 /*
-                 * Clear current synchronisation setup.
-                 * For the Beacon base registers we only need to clear
-                 * the first byte since that byte contains the VALID and OWNER
-                 * bits which (when set to 0) will invalidate the entire beacon.
-                 */
-                beacon_base = HW_BEACON_OFFSET(intf->beacon->entry_idx);
-                rt2x00usb_register_write(rt2x00dev, beacon_base, 0);
-
-                /*
                  * Enable synchronisation.
                  */
                 rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
-                rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
                 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_SYNC, conf->sync);
-                rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 1);
                 rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
         }
 
@@ -545,7 +533,8 @@ static void rt73usb_config_intf(struct rt2x00_dev *rt2x00dev,
 }
 
 static void rt73usb_config_erp(struct rt2x00_dev *rt2x00dev,
-                               struct rt2x00lib_erp *erp)
+                               struct rt2x00lib_erp *erp,
+                               u32 changed)
 {
         u32 reg;
 
@@ -554,28 +543,36 @@ static void rt73usb_config_erp(struct rt2x00_dev *rt2x00dev,
         rt2x00_set_field32(&reg, TXRX_CSR0_TSF_OFFSET, IEEE80211_HEADER);
         rt2x00usb_register_write(rt2x00dev, TXRX_CSR0, reg);
 
-        rt2x00usb_register_read(rt2x00dev, TXRX_CSR4, &reg);
-        rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_ENABLE, 1);
-        rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_PREAMBLE,
-                           !!erp->short_preamble);
-        rt2x00usb_register_write(rt2x00dev, TXRX_CSR4, reg);
+        if (changed & BSS_CHANGED_ERP_PREAMBLE) {
+                rt2x00usb_register_read(rt2x00dev, TXRX_CSR4, &reg);
+                rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_ENABLE, 1);
+                rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_PREAMBLE,
+                                   !!erp->short_preamble);
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR4, reg);
+        }
 
-        rt2x00usb_register_write(rt2x00dev, TXRX_CSR5, erp->basic_rates);
+        if (changed & BSS_CHANGED_BASIC_RATES)
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR5,
+                                         erp->basic_rates);
 
-        rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
-        rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_INTERVAL,
-                           erp->beacon_int * 16);
-        rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
+        if (changed & BSS_CHANGED_BEACON_INT) {
+                rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
+                rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_INTERVAL,
+                                   erp->beacon_int * 16);
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
+        }
 
-        rt2x00usb_register_read(rt2x00dev, MAC_CSR9, &reg);
-        rt2x00_set_field32(&reg, MAC_CSR9_SLOT_TIME, erp->slot_time);
-        rt2x00usb_register_write(rt2x00dev, MAC_CSR9, reg);
+        if (changed & BSS_CHANGED_ERP_SLOT) {
+                rt2x00usb_register_read(rt2x00dev, MAC_CSR9, &reg);
+                rt2x00_set_field32(&reg, MAC_CSR9_SLOT_TIME, erp->slot_time);
+                rt2x00usb_register_write(rt2x00dev, MAC_CSR9, reg);
 
-        rt2x00usb_register_read(rt2x00dev, MAC_CSR8, &reg);
-        rt2x00_set_field32(&reg, MAC_CSR8_SIFS, erp->sifs);
-        rt2x00_set_field32(&reg, MAC_CSR8_SIFS_AFTER_RX_OFDM, 3);
-        rt2x00_set_field32(&reg, MAC_CSR8_EIFS, erp->eifs);
-        rt2x00usb_register_write(rt2x00dev, MAC_CSR8, reg);
+                rt2x00usb_register_read(rt2x00dev, MAC_CSR8, &reg);
+                rt2x00_set_field32(&reg, MAC_CSR8_SIFS, erp->sifs);
+                rt2x00_set_field32(&reg, MAC_CSR8_SIFS_AFTER_RX_OFDM, 3);
+                rt2x00_set_field32(&reg, MAC_CSR8_EIFS, erp->eifs);
+                rt2x00usb_register_write(rt2x00dev, MAC_CSR8, reg);
+        }
 }
 
 static void rt73usb_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
@@ -598,7 +595,7 @@ static void rt73usb_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         switch (ant->rx) {
         case ANTENNA_HW_DIVERSITY:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 2);
-                temp = !test_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags)
+                temp = !test_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags)
                        && (rt2x00dev->curr_band != IEEE80211_BAND_5GHZ);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, temp);
                 break;
@@ -639,7 +636,7 @@ static void rt73usb_config_antenna_2x(struct rt2x00_dev *rt2x00dev,
 
         rt2x00_set_field8(&r3, BBP_R3_SMART_MODE, 0);
         rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END,
-                          !test_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags));
+                          !test_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags));
 
         /*
          * Configure the RX antenna.
@@ -712,10 +709,10 @@ static void rt73usb_config_ant(struct rt2x00_dev *rt2x00dev,
 
         if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
                 sel = antenna_sel_a;
-                lna = test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
+                lna = test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags);
         } else {
                 sel = antenna_sel_bg;
-                lna = test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
+                lna = test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags);
         }
 
         for (i = 0; i < ARRAY_SIZE(antenna_sel_a); i++)
@@ -743,7 +740,7 @@ static void rt73usb_config_lna_gain(struct rt2x00_dev *rt2x00dev,
         short lna_gain = 0;
 
         if (libconf->conf->channel->band == IEEE80211_BAND_2GHZ) {
-                if (test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags))
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags))
                         lna_gain += 14;
 
                 rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_OFFSET_BG, &eeprom);
@@ -929,11 +926,11 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev,
         /*
          * Determine r17 bounds.
          */
-        if (rt2x00dev->rx_status.band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
                 low_bound = 0x28;
                 up_bound = 0x48;
 
-                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags)) {
                         low_bound += 0x10;
                         up_bound += 0x10;
                 }
@@ -949,7 +946,7 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev,
                         up_bound = 0x1c;
                 }
 
-                if (test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags)) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags)) {
                         low_bound += 0x14;
                         up_bound += 0x10;
                 }
@@ -1022,6 +1019,55 @@ dynamic_cca_tune:
 }
 
 /*
+ * Queue handlers.
+ */
+static void rt73usb_start_queue(struct data_queue *queue)
+{
+        struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
+        u32 reg;
+
+        switch (queue->qid) {
+        case QID_RX:
+                rt2x00usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
+                rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX, 0);
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR0, reg);
+                break;
+        case QID_BEACON:
+                rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
+                rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
+                rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 1);
+                rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 1);
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
+                break;
+        default:
+                break;
+        }
+}
+
+static void rt73usb_stop_queue(struct data_queue *queue)
+{
+        struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
+        u32 reg;
+
+        switch (queue->qid) {
+        case QID_RX:
+                rt2x00usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
+                rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX, 1);
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR0, reg);
+                break;
+        case QID_BEACON:
+                rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
+                rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 0);
+                rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 0);
+                rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
+                break;
+        default:
+                break;
+        }
+}
+
+/*
  * Firmware functions
  */
 static char *rt73usb_get_firmware_name(struct rt2x00_dev *rt2x00dev)
@@ -1315,18 +1361,6 @@ static int rt73usb_init_bbp(struct rt2x00_dev *rt2x00dev)
 /*
  * Device state switch handlers.
  */
-static void rt73usb_toggle_rx(struct rt2x00_dev *rt2x00dev,
-                              enum dev_state state)
-{
-        u32 reg;
-
-        rt2x00usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
-        rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX,
-                           (state == STATE_RADIO_RX_OFF) ||
-                           (state == STATE_RADIO_RX_OFF_LINK));
-        rt2x00usb_register_write(rt2x00dev, TXRX_CSR0, reg);
-}
-
 static int rt73usb_enable_radio(struct rt2x00_dev *rt2x00dev)
 {
         /*
@@ -1393,16 +1427,8 @@ static int rt73usb_set_device_state(struct rt2x00_dev *rt2x00dev,
         case STATE_RADIO_OFF:
                 rt73usb_disable_radio(rt2x00dev);
                 break;
-        case STATE_RADIO_RX_ON:
-        case STATE_RADIO_RX_ON_LINK:
-        case STATE_RADIO_RX_OFF:
-        case STATE_RADIO_RX_OFF_LINK:
-                rt73usb_toggle_rx(rt2x00dev, state);
-                break;
         case STATE_RADIO_IRQ_ON:
-        case STATE_RADIO_IRQ_ON_ISR:
         case STATE_RADIO_IRQ_OFF:
-        case STATE_RADIO_IRQ_OFF_ISR:
                 /* No support, but no error either */
                 break;
         case STATE_DEEP_SLEEP:
@@ -1426,12 +1452,11 @@ static int rt73usb_set_device_state(struct rt2x00_dev *rt2x00dev,
 /*
  * TX descriptor initialization
  */
-static void rt73usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
-                                  struct sk_buff *skb,
+static void rt73usb_write_tx_desc(struct queue_entry *entry,
                                   struct txentry_desc *txdesc)
 {
-        struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
-        __le32 *txd = (__le32 *) skb->data;
+        struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
+        __le32 *txd = (__le32 *) entry->skb->data;
         u32 word;
 
         /*
@@ -1449,7 +1474,7 @@ static void rt73usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
                            test_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc->flags));
         rt2x00_set_field32(&word, TXD_W0_OFDM,
                            (txdesc->rate_mode == RATE_MODE_OFDM));
-        rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->ifs);
+        rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->u.plcp.ifs);
         rt2x00_set_field32(&word, TXD_W0_RETRY_MODE,
                            test_bit(ENTRY_TXD_RETRY_MODE, &txdesc->flags));
         rt2x00_set_field32(&word, TXD_W0_TKIP_MIC,
@@ -1464,20 +1489,22 @@ static void rt73usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
         rt2x00_desc_write(txd, 0, word);
 
         rt2x00_desc_read(txd, 1, &word);
-        rt2x00_set_field32(&word, TXD_W1_HOST_Q_ID, txdesc->queue);
-        rt2x00_set_field32(&word, TXD_W1_AIFSN, txdesc->aifs);
-        rt2x00_set_field32(&word, TXD_W1_CWMIN, txdesc->cw_min);
-        rt2x00_set_field32(&word, TXD_W1_CWMAX, txdesc->cw_max);
+        rt2x00_set_field32(&word, TXD_W1_HOST_Q_ID, entry->queue->qid);
+        rt2x00_set_field32(&word, TXD_W1_AIFSN, entry->queue->aifs);
+        rt2x00_set_field32(&word, TXD_W1_CWMIN, entry->queue->cw_min);
+        rt2x00_set_field32(&word, TXD_W1_CWMAX, entry->queue->cw_max);
         rt2x00_set_field32(&word, TXD_W1_IV_OFFSET, txdesc->iv_offset);
         rt2x00_set_field32(&word, TXD_W1_HW_SEQUENCE,
                            test_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags));
         rt2x00_desc_write(txd, 1, word);
 
         rt2x00_desc_read(txd, 2, &word);
-        rt2x00_set_field32(&word, TXD_W2_PLCP_SIGNAL, txdesc->signal);
-        rt2x00_set_field32(&word, TXD_W2_PLCP_SERVICE, txdesc->service);
-        rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_LOW, txdesc->length_low);
-        rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_HIGH, txdesc->length_high);
+        rt2x00_set_field32(&word, TXD_W2_PLCP_SIGNAL, txdesc->u.plcp.signal);
+        rt2x00_set_field32(&word, TXD_W2_PLCP_SERVICE, txdesc->u.plcp.service);
+        rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_LOW,
+                           txdesc->u.plcp.length_low);
+        rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_HIGH,
+                           txdesc->u.plcp.length_high);
         rt2x00_desc_write(txd, 2, word);
 
         if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags)) {
@@ -1487,7 +1514,7 @@ static void rt73usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
 
         rt2x00_desc_read(txd, 5, &word);
         rt2x00_set_field32(&word, TXD_W5_TX_POWER,
-                           TXPOWER_TO_DEV(rt2x00dev->tx_power));
+                           TXPOWER_TO_DEV(entry->queue->rt2x00dev->tx_power));
         rt2x00_set_field32(&word, TXD_W5_WAITING_DMA_DONE_INT, 1);
         rt2x00_desc_write(txd, 5, word);
 
@@ -1507,13 +1534,15 @@ static void rt73usb_write_beacon(struct queue_entry *entry,
 {
         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
         unsigned int beacon_base;
-        u32 reg;
+        unsigned int padding_len;
+        u32 orig_reg, reg;
 
         /*
          * Disable beaconing while we are reloading the beacon data,
          * otherwise we might be sending out invalid data.
          */
         rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
+        orig_reg = reg;
         rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
         rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
 
@@ -1526,7 +1555,7 @@ static void rt73usb_write_beacon(struct queue_entry *entry,
         /*
          * Write the TX descriptor for the beacon.
          */
-        rt73usb_write_tx_desc(rt2x00dev, entry->skb, txdesc);
+        rt73usb_write_tx_desc(entry, txdesc);
 
         /*
          * Dump beacon to userspace through debugfs.
@@ -1534,11 +1563,20 @@ static void rt73usb_write_beacon(struct queue_entry *entry,
         rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_BEACON, entry->skb);
 
         /*
-         * Write entire beacon with descriptor to register.
+         * Write entire beacon with descriptor and padding to register.
          */
+        padding_len = roundup(entry->skb->len, 4) - entry->skb->len;
+        if (padding_len && skb_pad(entry->skb, padding_len)) {
+                ERROR(rt2x00dev, "Failure padding beacon, aborting\n");
+                /* skb freed by skb_pad() on failure */
+                entry->skb = NULL;
+                rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, orig_reg);
+                return;
+        }
+
         beacon_base = HW_BEACON_OFFSET(entry->entry_idx);
-        rt2x00usb_register_multiwrite(rt2x00dev, beacon_base,
-                                      entry->skb->data, entry->skb->len);
+        rt2x00usb_register_multiwrite(rt2x00dev, beacon_base, entry->skb->data,
+                                      entry->skb->len + padding_len);
 
         /*
          * Enable beaconing again.
@@ -1548,8 +1586,6 @@ static void rt73usb_write_beacon(struct queue_entry *entry,
          */
         rt2x00usb_register_write(rt2x00dev, TXRX_CSR10, 0x00001008);
 
-        rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
-        rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 1);
         rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 1);
         rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
 
@@ -1560,6 +1596,33 @@ static void rt73usb_write_beacon(struct queue_entry *entry,
         entry->skb = NULL;
 }
 
+static void rt73usb_clear_beacon(struct queue_entry *entry)
+{
+        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
+        unsigned int beacon_base;
+        u32 reg;
+
+        /*
+         * Disable beaconing while we are reloading the beacon data,
+         * otherwise we might be sending out invalid data.
+         */
+        rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
+        rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
+        rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
+
+        /*
+         * Clear beacon.
+         */
+        beacon_base = HW_BEACON_OFFSET(entry->entry_idx);
+        rt2x00usb_register_write(rt2x00dev, beacon_base, 0);
+
+        /*
+         * Enable beaconing again.
+         */
+        rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 1);
+        rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
+}
+
 static int rt73usb_get_tx_data_len(struct queue_entry *entry)
 {
         int length;
@@ -1597,8 +1660,8 @@ static int rt73usb_agc_to_rssi(struct rt2x00_dev *rt2x00dev, int rxd_w1)
                 return 0;
         }
 
-        if (rt2x00dev->rx_status.band == IEEE80211_BAND_5GHZ) {
-                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) {
+        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags)) {
                         if (lna == 3 || lna == 2)
                                 offset += 10;
                 } else {
@@ -1656,9 +1719,8 @@ static void rt73usb_fill_rxdone(struct queue_entry *entry,
                 rxdesc->flags |= RX_FLAG_IV_STRIPPED;
 
                 /*
-                 * FIXME: Legacy driver indicates that the frame does
-                 * contain the Michael Mic. Unfortunately, in rt2x00
-                 * the MIC seems to be missing completely...
+                 * The hardware has already checked the Michael Mic and has
+                 * stripped it from the frame. Signal this to mac80211.
                  */
                 rxdesc->flags |= RX_FLAG_MMIC_STRIPPED;
 
@@ -1837,13 +1899,13 @@ static int rt73usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
          * Read the Frame type.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_FRAME_TYPE))
-                __set_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_FRAME_TYPE, &rt2x00dev->cap_flags);
 
         /*
          * Detect if this device has an hardware controlled radio.
          */
         if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
-                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
 
         /*
          * Read frequency offset.
@@ -1857,8 +1919,8 @@ static int rt73usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
         rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &eeprom);
 
         if (rt2x00_get_field16(eeprom, EEPROM_NIC_EXTERNAL_LNA)) {
-                __set_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
-                __set_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags);
+                __set_bit(CAPABILITY_EXTERNAL_LNA_BG, &rt2x00dev->cap_flags);
         }
 
         /*
@@ -2047,9 +2109,14 @@ static int rt73usb_probe_hw_mode(struct rt2x00_dev *rt2x00dev)
 
         /*
          * Initialize all hw fields.
+         *
+         * Don't set IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING unless we are
+         * capable of sending the buffered frames out after the DTIM
+         * transmission using rt2x00lib_beacondone. This will send out
+         * multicast and broadcast traffic immediately instead of buffering it
+         * infinitly and thus dropping it after some time.
          */
         rt2x00dev->hw->flags =
-            IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
             IEEE80211_HW_SIGNAL_DBM |
             IEEE80211_HW_SUPPORTS_PS |
             IEEE80211_HW_PS_NULLFUNC_STACK;
@@ -2084,20 +2151,24 @@ static int rt73usb_probe_hw_mode(struct rt2x00_dev *rt2x00dev)
         /*
          * Create channel information array
          */
-        info = kzalloc(spec->num_channels * sizeof(*info), GFP_KERNEL);
+        info = kcalloc(spec->num_channels, sizeof(*info), GFP_KERNEL);
         if (!info)
                 return -ENOMEM;
 
         spec->channels_info = info;
 
         tx_power = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_G_START);
-        for (i = 0; i < 14; i++)
-                info[i].tx_power1 = TXPOWER_FROM_DEV(tx_power[i]);
+        for (i = 0; i < 14; i++) {
+                info[i].max_power = MAX_TXPOWER;
+                info[i].default_power1 = TXPOWER_FROM_DEV(tx_power[i]);
+        }
 
         if (spec->num_channels > 14) {
                 tx_power = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_A_START);
-                for (i = 14; i < spec->num_channels; i++)
-                        info[i].tx_power1 = TXPOWER_FROM_DEV(tx_power[i]);
+                for (i = 14; i < spec->num_channels; i++) {
+                        info[i].max_power = MAX_TXPOWER;
+                        info[i].default_power1 = TXPOWER_FROM_DEV(tx_power[i]);
+                }
         }
 
         return 0;
@@ -2129,16 +2200,16 @@ static int rt73usb_probe_hw(struct rt2x00_dev *rt2x00dev)
          * This device has multiple filters for control frames,
          * but has no a separate filter for PS Poll frames.
          */
-        __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags);
+        __set_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags);
 
         /*
          * This device requires firmware.
          */
-        __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags);
+        __set_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags);
         if (!modparam_nohwcrypt)
-                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
-        __set_bit(DRIVER_SUPPORT_WATCHDOG, &rt2x00dev->flags);
+                __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
+        __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
+        __set_bit(REQUIRE_PS_AUTOWAKE, &rt2x00dev->cap_flags);
 
         /*
          * Set the rssi offset.
@@ -2178,7 +2249,7 @@ static int rt73usb_conf_tx(struct ieee80211_hw *hw, u16 queue_idx,
         if (queue_idx >= 4)
                 return 0;
 
-        queue = rt2x00queue_get_queue(rt2x00dev, queue_idx);
+        queue = rt2x00queue_get_tx_queue(rt2x00dev, queue_idx);
 
         /* Update WMM TXOP register */
         offset = AC_TXOP_CSR0 + (sizeof(u32) * (!!(queue_idx & 2)));
@@ -2239,6 +2310,10 @@ static const struct ieee80211_ops rt73usb_mac80211_ops = {
         .conf_tx                = rt73usb_conf_tx,
         .get_tsf                = rt73usb_get_tsf,
         .rfkill_poll            = rt2x00mac_rfkill_poll,
+        .flush                  = rt2x00mac_flush,
+        .set_antenna            = rt2x00mac_set_antenna,
+        .get_antenna            = rt2x00mac_get_antenna,
+        .get_ringparam          = rt2x00mac_get_ringparam,
 };
 
 static const struct rt2x00lib_ops rt73usb_rt2x00_ops = {
@@ -2255,11 +2330,14 @@ static const struct rt2x00lib_ops rt73usb_rt2x00_ops = {
         .reset_tuner            = rt73usb_reset_tuner,
         .link_tuner             = rt73usb_link_tuner,
         .watchdog               = rt2x00usb_watchdog,
+        .start_queue            = rt73usb_start_queue,
+        .kick_queue             = rt2x00usb_kick_queue,
+        .stop_queue             = rt73usb_stop_queue,
+        .flush_queue            = rt2x00usb_flush_queue,
         .write_tx_desc          = rt73usb_write_tx_desc,
         .write_beacon           = rt73usb_write_beacon,
+        .clear_beacon           = rt73usb_clear_beacon,
         .get_tx_data_len        = rt73usb_get_tx_data_len,
-        .kick_tx_queue          = rt2x00usb_kick_tx_queue,
-        .kill_tx_queue          = rt2x00usb_kill_tx_queue,
         .fill_rxdone            = rt73usb_fill_rxdone,
         .config_shared_key      = rt73usb_config_shared_key,
         .config_pairwise_key    = rt73usb_config_pairwise_key,
@@ -2271,21 +2349,21 @@ static const struct rt2x00lib_ops rt73usb_rt2x00_ops = {
 };
 
 static const struct data_queue_desc rt73usb_queue_rx = {
-        .entry_num              = RX_ENTRIES,
+        .entry_num              = 32,
         .data_size              = DATA_FRAME_SIZE,
         .desc_size              = RXD_DESC_SIZE,
         .priv_size              = sizeof(struct queue_entry_priv_usb),
 };
 
 static const struct data_queue_desc rt73usb_queue_tx = {
-        .entry_num              = TX_ENTRIES,
+        .entry_num              = 32,
         .data_size              = DATA_FRAME_SIZE,
         .desc_size              = TXD_DESC_SIZE,
         .priv_size              = sizeof(struct queue_entry_priv_usb),
 };
 
 static const struct data_queue_desc rt73usb_queue_bcn = {
-        .entry_num              = 4 * BEACON_ENTRIES,
+        .entry_num              = 4,
         .data_size              = MGMT_FRAME_SIZE,
         .desc_size              = TXINFO_SIZE,
         .priv_size              = sizeof(struct queue_entry_priv_usb),
@@ -2314,112 +2392,113 @@ static const struct rt2x00_ops rt73usb_ops = {
  */
 static struct usb_device_id rt73usb_device_table[] = {
         /* AboCom */
-        { USB_DEVICE(0x07b8, 0xb21b), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x07b8, 0xb21c), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x07b8, 0xb21d), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x07b8, 0xb21e), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x07b8, 0xb21f), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x07b8, 0xb21b) },
+        { USB_DEVICE(0x07b8, 0xb21c) },
+        { USB_DEVICE(0x07b8, 0xb21d) },
+        { USB_DEVICE(0x07b8, 0xb21e) },
+        { USB_DEVICE(0x07b8, 0xb21f) },
         /* AL */
-        { USB_DEVICE(0x14b2, 0x3c10), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x14b2, 0x3c10) },
         /* Amigo */
-        { USB_DEVICE(0x148f, 0x9021), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0eb0, 0x9021), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x148f, 0x9021) },
+        { USB_DEVICE(0x0eb0, 0x9021) },
         /* AMIT  */
-        { USB_DEVICE(0x18c5, 0x0002), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x18c5, 0x0002) },
         /* Askey */
-        { USB_DEVICE(0x1690, 0x0722), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1690, 0x0722) },
         /* ASUS */
-        { USB_DEVICE(0x0b05, 0x1723), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0b05, 0x1724), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0b05, 0x1723) },
+        { USB_DEVICE(0x0b05, 0x1724) },
         /* Belkin */
-        { USB_DEVICE(0x050d, 0x7050), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x050d, 0x705a), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x050d, 0x905b), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x050d, 0x905c), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x050d, 0x705a) },
+        { USB_DEVICE(0x050d, 0x905b) },
+        { USB_DEVICE(0x050d, 0x905c) },
         /* Billionton */
-        { USB_DEVICE(0x1631, 0xc019), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x08dd, 0x0120), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1631, 0xc019) },
+        { USB_DEVICE(0x08dd, 0x0120) },
         /* Buffalo */
-        { USB_DEVICE(0x0411, 0x00d8), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0411, 0x00d9), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0411, 0x00f4), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0411, 0x0116), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0411, 0x0119), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0411, 0x00d8) },
+        { USB_DEVICE(0x0411, 0x00d9) },
+        { USB_DEVICE(0x0411, 0x00f4) },
+        { USB_DEVICE(0x0411, 0x0116) },
+        { USB_DEVICE(0x0411, 0x0119) },
+        { USB_DEVICE(0x0411, 0x0137) },
         /* CEIVA */
-        { USB_DEVICE(0x178d, 0x02be), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x178d, 0x02be) },
         /* CNet */
-        { USB_DEVICE(0x1371, 0x9022), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x1371, 0x9032), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1371, 0x9022) },
+        { USB_DEVICE(0x1371, 0x9032) },
         /* Conceptronic */
-        { USB_DEVICE(0x14b2, 0x3c22), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x14b2, 0x3c22) },
         /* Corega */
-        { USB_DEVICE(0x07aa, 0x002e), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x07aa, 0x002e) },
         /* D-Link */
-        { USB_DEVICE(0x07d1, 0x3c03), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x07d1, 0x3c04), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x07d1, 0x3c06), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x07d1, 0x3c07), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x07d1, 0x3c03) },
+        { USB_DEVICE(0x07d1, 0x3c04) },
+        { USB_DEVICE(0x07d1, 0x3c06) },
+        { USB_DEVICE(0x07d1, 0x3c07) },
         /* Edimax */
-        { USB_DEVICE(0x7392, 0x7318), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x7392, 0x7618), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x7392, 0x7318) },
+        { USB_DEVICE(0x7392, 0x7618) },
         /* EnGenius */
-        { USB_DEVICE(0x1740, 0x3701), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1740, 0x3701) },
         /* Gemtek */
-        { USB_DEVICE(0x15a9, 0x0004), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x15a9, 0x0004) },
         /* Gigabyte */
-        { USB_DEVICE(0x1044, 0x8008), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x1044, 0x800a), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1044, 0x8008) },
+        { USB_DEVICE(0x1044, 0x800a) },
         /* Huawei-3Com */
-        { USB_DEVICE(0x1472, 0x0009), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1472, 0x0009) },
         /* Hercules */
-        { USB_DEVICE(0x06f8, 0xe002), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x06f8, 0xe010), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x06f8, 0xe020), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x06f8, 0xe002) },
+        { USB_DEVICE(0x06f8, 0xe010) },
+        { USB_DEVICE(0x06f8, 0xe020) },
         /* Linksys */
-        { USB_DEVICE(0x13b1, 0x0020), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x13b1, 0x0023), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x13b1, 0x0028), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x13b1, 0x0020) },
+        { USB_DEVICE(0x13b1, 0x0023) },
+        { USB_DEVICE(0x13b1, 0x0028) },
         /* MSI */
-        { USB_DEVICE(0x0db0, 0x4600), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0db0, 0x6877), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0db0, 0x6874), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0db0, 0xa861), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0db0, 0xa874), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0db0, 0x4600) },
+        { USB_DEVICE(0x0db0, 0x6877) },
+        { USB_DEVICE(0x0db0, 0x6874) },
+        { USB_DEVICE(0x0db0, 0xa861) },
+        { USB_DEVICE(0x0db0, 0xa874) },
         /* Ovislink */
-        { USB_DEVICE(0x1b75, 0x7318), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1b75, 0x7318) },
         /* Ralink */
-        { USB_DEVICE(0x04bb, 0x093d), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x148f, 0x2573), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x148f, 0x2671), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x04bb, 0x093d) },
+        { USB_DEVICE(0x148f, 0x2573) },
+        { USB_DEVICE(0x148f, 0x2671) },
+        { USB_DEVICE(0x0812, 0x3101) },
         /* Qcom */
-        { USB_DEVICE(0x18e8, 0x6196), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x18e8, 0x6229), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x18e8, 0x6238), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x18e8, 0x6196) },
+        { USB_DEVICE(0x18e8, 0x6229) },
+        { USB_DEVICE(0x18e8, 0x6238) },
         /* Samsung */
-        { USB_DEVICE(0x04e8, 0x4471), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x04e8, 0x4471) },
         /* Senao */
-        { USB_DEVICE(0x1740, 0x7100), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x1740, 0x7100) },
         /* Sitecom */
-        { USB_DEVICE(0x0df6, 0x0024), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0df6, 0x0027), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0df6, 0x002f), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0df6, 0x90ac), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x0df6, 0x9712), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0df6, 0x0024) },
+        { USB_DEVICE(0x0df6, 0x0027) },
+        { USB_DEVICE(0x0df6, 0x002f) },
+        { USB_DEVICE(0x0df6, 0x90ac) },
+        { USB_DEVICE(0x0df6, 0x9712) },
         /* Surecom */
-        { USB_DEVICE(0x0769, 0x31f3), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0769, 0x31f3) },
         /* Tilgin */
-        { USB_DEVICE(0x6933, 0x5001), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x6933, 0x5001) },
         /* Philips */
-        { USB_DEVICE(0x0471, 0x200a), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0471, 0x200a) },
         /* Planex */
-        { USB_DEVICE(0x2019, 0xab01), USB_DEVICE_DATA(&rt73usb_ops) },
-        { USB_DEVICE(0x2019, 0xab50), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x2019, 0xab01) },
+        { USB_DEVICE(0x2019, 0xab50) },
         /* WideTell */
-        { USB_DEVICE(0x7167, 0x3840), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x7167, 0x3840) },
         /* Zcom */
-        { USB_DEVICE(0x0cde, 0x001c), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0cde, 0x001c) },
         /* ZyXEL */
-        { USB_DEVICE(0x0586, 0x3415), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x0586, 0x3415) },
         { 0, }
 };
 
@@ -2431,10 +2510,16 @@ MODULE_DEVICE_TABLE(usb, rt73usb_device_table);
 MODULE_FIRMWARE(FIRMWARE_RT2571);
 MODULE_LICENSE("GPL");
 
+static int rt73usb_probe(struct usb_interface *usb_intf,
+                         const struct usb_device_id *id)
+{
+        return rt2x00usb_probe(usb_intf, &rt73usb_ops);
+}
+
 static struct usb_driver rt73usb_driver = {
         .name           = KBUILD_MODNAME,
         .id_table       = rt73usb_device_table,
-        .probe          = rt2x00usb_probe,
+        .probe          = rt73usb_probe,
         .disconnect     = rt2x00usb_disconnect,
         .suspend        = rt2x00usb_suspend,
         .resume         = rt2x00usb_resume,