5 files changed, 104 insertions, 135 deletions

diff --git a/drivers/net/wireless/rt2x00/rt2x00.h b/drivers/net/wireless/rt2x00/rt2x00.h
index b0e4ea7c9dca..4fa762bdb734 100644
--- a/drivers/net/wireless/rt2x00/rt2x00.h
+++ b/drivers/net/wireless/rt2x00/rt2x00.h
@@ -390,6 +390,10 @@ static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif)
         return (struct rt2x00_intf *)vif->drv_priv;
 }
 
+#define HWMODE_B        0
+#define HWMODE_G        1
+#define HWMODE_A        2
+
 /*
  * Details about the supported modes, rates and channels
  * of a particular chipset. This is used by rt2x00lib
@@ -644,11 +648,8 @@ struct rt2x00_dev {
          * IEEE80211 control structure.
          */
         struct ieee80211_hw *hw;
-        struct ieee80211_hw_mode *hwmodes;
-        unsigned int curr_hwmode;
-#define HWMODE_B        0
-#define HWMODE_G        1
-#define HWMODE_A        2
+        struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+        enum ieee80211_band curr_band;
 
         /*
          * rfkill structure for RF state switching support.
diff --git a/drivers/net/wireless/rt2x00/rt2x00config.c b/drivers/net/wireless/rt2x00/rt2x00config.c
index 20231e0c53fa..9fba485a40ac 100644
--- a/drivers/net/wireless/rt2x00/rt2x00config.c
+++ b/drivers/net/wireless/rt2x00/rt2x00config.c
@@ -152,7 +152,7 @@ void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
                       struct ieee80211_conf *conf, const int force_config)
 {
         struct rt2x00lib_conf libconf;
-        struct ieee80211_hw_mode *mode;
+        struct ieee80211_supported_band *band;
         struct ieee80211_rate *rate;
         struct antenna_setup *default_ant = &rt2x00dev->default_ant;
         struct antenna_setup *active_ant = &rt2x00dev->link.ant.active;
@@ -172,9 +172,9 @@ void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
          * Check which configuration options have been
          * updated and should be send to the device.
          */
-        if (rt2x00dev->rx_status.phymode != conf->phymode)
+        if (rt2x00dev->rx_status.band != conf->channel->band)
                 flags |= CONFIG_UPDATE_PHYMODE;
-        if (rt2x00dev->rx_status.channel != conf->channel)
+        if (rt2x00dev->rx_status.freq != conf->channel->center_freq)
                 flags |= CONFIG_UPDATE_CHANNEL;
         if (rt2x00dev->tx_power != conf->power_level)
                 flags |= CONFIG_UPDATE_TXPOWER;
@@ -229,33 +229,31 @@ config:
         memset(&libconf, 0, sizeof(libconf));
 
         if (flags & CONFIG_UPDATE_PHYMODE) {
-                switch (conf->phymode) {
-                case MODE_IEEE80211A:
+                switch (conf->channel->band) {
+                case IEEE80211_BAND_5GHZ:
                         libconf.phymode = HWMODE_A;
                         break;
-                case MODE_IEEE80211B:
-                        libconf.phymode = HWMODE_B;
-                        break;
-                case MODE_IEEE80211G:
+                case IEEE80211_BAND_2GHZ:
+                        /* Uh oh. what about B? */
                         libconf.phymode = HWMODE_G;
                         break;
                 default:
                         ERROR(rt2x00dev,
                               "Attempt to configure unsupported mode (%d)"
-                              "Defaulting to 802.11b", conf->phymode);
+                              "Defaulting to 802.11b", conf->channel->band);
                         libconf.phymode = HWMODE_B;
                 }
 
-                mode = &rt2x00dev->hwmodes[libconf.phymode];
-                rate = &mode->rates[mode->num_rates - 1];
+                band = &rt2x00dev->bands[conf->channel->band];
+                rate = &band->bitrates[band->n_bitrates - 1];
 
                 libconf.basic_rates =
-                    DEVICE_GET_RATE_FIELD(rate->val, RATEMASK) & DEV_BASIC_RATEMASK;
+                    DEVICE_GET_RATE_FIELD(rate->hw_value, RATEMASK) & DEV_BASIC_RATEMASK;
         }
 
         if (flags & CONFIG_UPDATE_CHANNEL) {
                 memcpy(&libconf.rf,
-                       &rt2x00dev->spec.channels[conf->channel_val],
+                       &rt2x00dev->spec.channels[conf->channel->hw_value],
                        sizeof(libconf.rf));
         }
 
@@ -301,12 +299,11 @@ config:
                 rt2x00lib_reset_link_tuner(rt2x00dev);
 
         if (flags & CONFIG_UPDATE_PHYMODE) {
-                rt2x00dev->curr_hwmode = libconf.phymode;
-                rt2x00dev->rx_status.phymode = conf->phymode;
+                rt2x00dev->curr_band = conf->channel->band;
+                rt2x00dev->rx_status.band = conf->channel->band;
         }
 
-        rt2x00dev->rx_status.freq = conf->freq;
-        rt2x00dev->rx_status.channel = conf->channel;
+        rt2x00dev->rx_status.freq = conf->channel->center_freq;
         rt2x00dev->tx_power = conf->power_level;
 
         if (flags & CONFIG_UPDATE_ANTENNA) {
diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c
index 0df8062b1a8e..83a72ae36638 100644
--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
@@ -550,19 +550,19 @@ void rt2x00lib_rxdone(struct queue_entry *entry,
 {
         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
         struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
-        struct ieee80211_hw_mode *mode;
+        struct ieee80211_supported_band *sband;
         struct ieee80211_rate *rate;
         struct ieee80211_hdr *hdr;
         unsigned int i;
-        int val = 0;
+        int val = 0, idx = -1;
         u16 fc;
 
         /*
          * Update RX statistics.
          */
-        mode = &rt2x00dev->hwmodes[rt2x00dev->curr_hwmode];
-        for (i = 0; i < mode->num_rates; i++) {
-                rate = &mode->rates[i];
+        sband = &rt2x00dev->bands[rt2x00dev->curr_band];
+        for (i = 0; i < sband->n_bitrates; i++) {
+                rate = &sband->bitrates[i];
 
                 /*
                  * When frame was received with an OFDM bitrate,
@@ -570,12 +570,12 @@ void rt2x00lib_rxdone(struct queue_entry *entry,
                  * a CCK bitrate the signal is the rate in 0.5kbit/s.
                  */
                 if (!rxdesc->ofdm)
-                        val = DEVICE_GET_RATE_FIELD(rate->val, RATE);
+                        val = DEVICE_GET_RATE_FIELD(rate->hw_value, RATE);
                 else
-                        val = DEVICE_GET_RATE_FIELD(rate->val, PLCP);
+                        val = DEVICE_GET_RATE_FIELD(rate->hw_value, PLCP);
 
                 if (val == rxdesc->signal) {
-                        val = rate->val;
+                        idx = i;
                         break;
                 }
         }
@@ -590,7 +590,7 @@ void rt2x00lib_rxdone(struct queue_entry *entry,
 
         rt2x00dev->link.qual.rx_success++;
 
-        rx_status->rate = val;
+        rx_status->rate_idx = idx;
         rx_status->signal =
             rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc->rssi);
         rx_status->ssi = rxdesc->rssi;
@@ -639,7 +639,7 @@ void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
         frame_control = le16_to_cpu(ieee80211hdr->frame_control);
         seq_ctrl = le16_to_cpu(ieee80211hdr->seq_ctrl);
 
-        tx_rate = control->tx_rate;
+        tx_rate = control->tx_rate->hw_value;
 
         /*
          * Check whether this frame is to be acked
@@ -658,7 +658,7 @@ void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
                 } else
                         __clear_bit(ENTRY_TXD_ACK, &txdesc.flags);
                 if (control->rts_cts_rate)
-                        tx_rate = control->rts_cts_rate;
+                        tx_rate = control->rts_cts_rate->hw_value;
         }
 
         /*
@@ -760,54 +760,45 @@ static void rt2x00lib_channel(struct ieee80211_channel *entry,
                               const int channel, const int tx_power,
                               const int value)
 {
-        entry->chan = channel;
         if (channel <= 14)
-                entry->freq = 2407 + (5 * channel);
+                entry->center_freq = 2407 + (5 * channel);
         else
-                entry->freq = 5000 + (5 * channel);
-        entry->val = value;
-        entry->flag =
-            IEEE80211_CHAN_W_IBSS |
-            IEEE80211_CHAN_W_ACTIVE_SCAN |
-            IEEE80211_CHAN_W_SCAN;
-        entry->power_level = tx_power;
-        entry->antenna_max = 0xff;
+                entry->center_freq = 5000 + (5 * channel);
+        entry->hw_value = value;
+        entry->max_power = tx_power;
+        entry->max_antenna_gain = 0xff;
 }
 
 static void rt2x00lib_rate(struct ieee80211_rate *entry,
                            const int rate, const int mask,
                            const int plcp, const int flags)
 {
-        entry->rate = rate;
-        entry->val =
+        entry->bitrate = rate;
+        entry->hw_value =
             DEVICE_SET_RATE_FIELD(rate, RATE) |
             DEVICE_SET_RATE_FIELD(mask, RATEMASK) |
             DEVICE_SET_RATE_FIELD(plcp, PLCP);
         entry->flags = flags;
-        entry->val2 = entry->val;
-        if (entry->flags & IEEE80211_RATE_PREAMBLE2)
-                entry->val2 |= DEVICE_SET_RATE_FIELD(1, PREAMBLE);
-        entry->min_rssi_ack = 0;
-        entry->min_rssi_ack_delta = 0;
+        entry->hw_value_short = entry->hw_value;
+        if (entry->flags & IEEE80211_RATE_SHORT_PREAMBLE)
+                entry->hw_value_short |= DEVICE_SET_RATE_FIELD(1, PREAMBLE);
 }
 
 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
                                     struct hw_mode_spec *spec)
 {
         struct ieee80211_hw *hw = rt2x00dev->hw;
-        struct ieee80211_hw_mode *hwmodes;
+        struct ieee80211_supported_band *sbands;
         struct ieee80211_channel *channels;
         struct ieee80211_rate *rates;
         unsigned int i;
         unsigned char tx_power;
 
-        hwmodes = kzalloc(sizeof(*hwmodes) * spec->num_modes, GFP_KERNEL);
-        if (!hwmodes)
-                goto exit;
+        sbands = &rt2x00dev->bands[0];
 
         channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
         if (!channels)
-                goto exit_free_modes;
+                return -ENOMEM;
 
         rates = kzalloc(sizeof(*rates) * spec->num_rates, GFP_KERNEL);
         if (!rates)
@@ -817,31 +808,31 @@ static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
          * Initialize Rate list.
          */
         rt2x00lib_rate(&rates[0], 10, DEV_RATEMASK_1MB,
-                       0x00, IEEE80211_RATE_CCK);
+                       0x00, 0);
         rt2x00lib_rate(&rates[1], 20, DEV_RATEMASK_2MB,
-                       0x01, IEEE80211_RATE_CCK_2);
+                       0x01, IEEE80211_RATE_SHORT_PREAMBLE);
         rt2x00lib_rate(&rates[2], 55, DEV_RATEMASK_5_5MB,
-                       0x02, IEEE80211_RATE_CCK_2);
+                       0x02, IEEE80211_RATE_SHORT_PREAMBLE);
         rt2x00lib_rate(&rates[3], 110, DEV_RATEMASK_11MB,
-                       0x03, IEEE80211_RATE_CCK_2);
+                       0x03, IEEE80211_RATE_SHORT_PREAMBLE);
 
         if (spec->num_rates > 4) {
                 rt2x00lib_rate(&rates[4], 60, DEV_RATEMASK_6MB,
-                               0x0b, IEEE80211_RATE_OFDM);
+                               0x0b, 0);
                 rt2x00lib_rate(&rates[5], 90, DEV_RATEMASK_9MB,
-                               0x0f, IEEE80211_RATE_OFDM);
+                               0x0f, 0);
                 rt2x00lib_rate(&rates[6], 120, DEV_RATEMASK_12MB,
-                               0x0a, IEEE80211_RATE_OFDM);
+                               0x0a, 0);
                 rt2x00lib_rate(&rates[7], 180, DEV_RATEMASK_18MB,
-                               0x0e, IEEE80211_RATE_OFDM);
+                               0x0e, 0);
                 rt2x00lib_rate(&rates[8], 240, DEV_RATEMASK_24MB,
-                               0x09, IEEE80211_RATE_OFDM);
+                               0x09, 0);
                 rt2x00lib_rate(&rates[9], 360, DEV_RATEMASK_36MB,
-                               0x0d, IEEE80211_RATE_OFDM);
+                               0x0d, 0);
                 rt2x00lib_rate(&rates[10], 480, DEV_RATEMASK_48MB,
-                               0x08, IEEE80211_RATE_OFDM);
+                               0x08, 0);
                 rt2x00lib_rate(&rates[11], 540, DEV_RATEMASK_54MB,
-                               0x0c, IEEE80211_RATE_OFDM);
+                               0x0c, 0);
         }
 
         /*
@@ -862,27 +853,27 @@ static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
         /*
          * Intitialize 802.11b
          * Rates: CCK.
-         * Channels: OFDM.
+         * Channels: 2.4 GHz
          */
         if (spec->num_modes > HWMODE_B) {
-                hwmodes[HWMODE_B].mode = MODE_IEEE80211B;
-                hwmodes[HWMODE_B].num_channels = 14;
-                hwmodes[HWMODE_B].num_rates = 4;
-                hwmodes[HWMODE_B].channels = channels;
-                hwmodes[HWMODE_B].rates = rates;
+                sbands[IEEE80211_BAND_2GHZ].n_channels = 14;
+                sbands[IEEE80211_BAND_2GHZ].n_bitrates = 4;
+                sbands[IEEE80211_BAND_2GHZ].channels = channels;
+                sbands[IEEE80211_BAND_2GHZ].bitrates = rates;
+                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
         }
 
         /*
          * Intitialize 802.11g
          * Rates: CCK, OFDM.
-         * Channels: OFDM.
+         * Channels: 2.4 GHz
          */
         if (spec->num_modes > HWMODE_G) {
-                hwmodes[HWMODE_G].mode = MODE_IEEE80211G;
-                hwmodes[HWMODE_G].num_channels = 14;
-                hwmodes[HWMODE_G].num_rates = spec->num_rates;
-                hwmodes[HWMODE_G].channels = channels;
-                hwmodes[HWMODE_G].rates = rates;
+                sbands[IEEE80211_BAND_2GHZ].n_channels = 14;
+                sbands[IEEE80211_BAND_2GHZ].n_bitrates = spec->num_rates;
+                sbands[IEEE80211_BAND_2GHZ].channels = channels;
+                sbands[IEEE80211_BAND_2GHZ].bitrates = rates;
+                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
         }
 
         /*
@@ -891,39 +882,17 @@ static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
          * Channels: OFDM, UNII, HiperLAN2.
          */
         if (spec->num_modes > HWMODE_A) {
-                hwmodes[HWMODE_A].mode = MODE_IEEE80211A;
-                hwmodes[HWMODE_A].num_channels = spec->num_channels - 14;
-                hwmodes[HWMODE_A].num_rates = spec->num_rates - 4;
-                hwmodes[HWMODE_A].channels = &channels[14];
-                hwmodes[HWMODE_A].rates = &rates[4];
+                sbands[IEEE80211_BAND_5GHZ].n_channels = spec->num_channels - 14;
+                sbands[IEEE80211_BAND_5GHZ].n_bitrates = spec->num_rates - 4;
+                sbands[IEEE80211_BAND_5GHZ].channels = &channels[14];
+                sbands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
+                hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
         }
 
-        if (spec->num_modes > HWMODE_G &&
-            ieee80211_register_hwmode(hw, &hwmodes[HWMODE_G]))
-                goto exit_free_rates;
-
-        if (spec->num_modes > HWMODE_B &&
-            ieee80211_register_hwmode(hw, &hwmodes[HWMODE_B]))
-                goto exit_free_rates;
-
-        if (spec->num_modes > HWMODE_A &&
-            ieee80211_register_hwmode(hw, &hwmodes[HWMODE_A]))
-                goto exit_free_rates;
-
-        rt2x00dev->hwmodes = hwmodes;
-
         return 0;
 
-exit_free_rates:
-        kfree(rates);
-
-exit_free_channels:
+ exit_free_channels:
         kfree(channels);
-
-exit_free_modes:
-        kfree(hwmodes);
-
-exit:
         ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
         return -ENOMEM;
 }
@@ -933,11 +902,11 @@ static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
         if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
                 ieee80211_unregister_hw(rt2x00dev->hw);
 
-        if (likely(rt2x00dev->hwmodes)) {
-                kfree(rt2x00dev->hwmodes->channels);
-                kfree(rt2x00dev->hwmodes->rates);
-                kfree(rt2x00dev->hwmodes);
-                rt2x00dev->hwmodes = NULL;
+        if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
+                kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
+                kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
+                rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
+                rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
         }
 }
 
diff --git a/drivers/net/wireless/rt2x00/rt61pci.c b/drivers/net/wireless/rt2x00/rt61pci.c
index 59e87a1d96a4..1dd30510ed1e 100644
--- a/drivers/net/wireless/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/rt2x00/rt61pci.c
@@ -426,12 +426,12 @@ static void rt61pci_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         case ANTENNA_HW_DIVERSITY:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 2);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END,
-                                  (rt2x00dev->curr_hwmode != HWMODE_A));
+                                  (rt2x00dev->curr_band != IEEE80211_BAND_5GHZ));
                 break;
         case ANTENNA_A:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_hwmode == HWMODE_A)
+                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
@@ -446,7 +446,7 @@ static void rt61pci_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         case ANTENNA_B:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_hwmode == HWMODE_A)
+                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
@@ -602,7 +602,7 @@ static void rt61pci_config_antenna(struct rt2x00_dev *rt2x00dev,
         unsigned int i;
         u32 reg;
 
-        if (rt2x00dev->curr_hwmode == HWMODE_A) {
+        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
                 sel = antenna_sel_a;
                 lna = test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
         } else {
@@ -616,10 +616,9 @@ static void rt61pci_config_antenna(struct rt2x00_dev *rt2x00dev,
         rt2x00pci_register_read(rt2x00dev, PHY_CSR0, &reg);
 
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_BG,
-                           (rt2x00dev->curr_hwmode == HWMODE_B ||
-                            rt2x00dev->curr_hwmode == HWMODE_G));
+                           rt2x00dev->curr_band == IEEE80211_BAND_2GHZ);
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_A,
-                           (rt2x00dev->curr_hwmode == HWMODE_A));
+                           rt2x00dev->curr_band == IEEE80211_BAND_5GHZ);
 
         rt2x00pci_register_write(rt2x00dev, PHY_CSR0, reg);
 
@@ -698,9 +697,9 @@ static void rt61pci_enable_led(struct rt2x00_dev *rt2x00dev)
 
         rt2x00_set_field16(&rt2x00dev->led_reg, MCU_LEDCS_RADIO_STATUS, 1);
         rt2x00_set_field16(&rt2x00dev->led_reg, MCU_LEDCS_LINK_A_STATUS,
-                           (rt2x00dev->rx_status.phymode == MODE_IEEE80211A));
+                           rt2x00dev->rx_status.band == IEEE80211_BAND_5GHZ);
         rt2x00_set_field16(&rt2x00dev->led_reg, MCU_LEDCS_LINK_BG_STATUS,
-                           (rt2x00dev->rx_status.phymode != MODE_IEEE80211A));
+                           rt2x00dev->rx_status.band != IEEE80211_BAND_5GHZ);
 
         arg0 = rt2x00dev->led_reg & 0xff;
         arg1 = (rt2x00dev->led_reg >> 8) & 0xff;
@@ -798,7 +797,7 @@ static void rt61pci_link_tuner(struct rt2x00_dev *rt2x00dev)
         /*
          * Determine r17 bounds.
          */
-        if (rt2x00dev->rx_status.phymode == MODE_IEEE80211A) {
+        if (rt2x00dev->rx_status.band == IEEE80211_BAND_2GHZ) {
                 low_bound = 0x28;
                 up_bound = 0x48;
                 if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) {
@@ -1544,8 +1543,10 @@ static void rt61pci_write_tx_desc(struct rt2x00_dev *rt2x00dev,
         rt2x00_desc_write(txd, 2, word);
 
         rt2x00_desc_read(txd, 5, &word);
+/* XXX: removed for now
         rt2x00_set_field32(&word, TXD_W5_TX_POWER,
                            TXPOWER_TO_DEV(control->power_level));
+ */
         rt2x00_set_field32(&word, TXD_W5_WAITING_DMA_DONE_INT, 1);
         rt2x00_desc_write(txd, 5, word);
 
@@ -1637,7 +1638,7 @@ static int rt61pci_agc_to_rssi(struct rt2x00_dev *rt2x00dev, int rxd_w1)
                 return 0;
         }
 
-        if (rt2x00dev->rx_status.phymode == MODE_IEEE80211A) {
+        if (rt2x00dev->rx_status.band == IEEE80211_BAND_5GHZ) {
                 if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags))
                         offset += 14;
 
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index 4b5bde8b53de..9cbc879da037 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -439,13 +439,13 @@ static void rt73usb_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         case ANTENNA_HW_DIVERSITY:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 2);
                 temp = !test_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags)
-                       && (rt2x00dev->curr_hwmode != HWMODE_A);
+                       && (rt2x00dev->curr_band != IEEE80211_BAND_5GHZ);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, temp);
                 break;
         case ANTENNA_A:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_hwmode == HWMODE_A)
+                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
@@ -460,7 +460,7 @@ static void rt73usb_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         case ANTENNA_B:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_hwmode == HWMODE_A)
+                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
@@ -555,7 +555,7 @@ static void rt73usb_config_antenna(struct rt2x00_dev *rt2x00dev,
         unsigned int i;
         u32 reg;
 
-        if (rt2x00dev->curr_hwmode == HWMODE_A) {
+        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
                 sel = antenna_sel_a;
                 lna = test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags);
         } else {
@@ -569,10 +569,9 @@ static void rt73usb_config_antenna(struct rt2x00_dev *rt2x00dev,
         rt73usb_register_read(rt2x00dev, PHY_CSR0, &reg);
 
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_BG,
-                           (rt2x00dev->curr_hwmode == HWMODE_B ||
-                            rt2x00dev->curr_hwmode == HWMODE_G));
+                           (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ));
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_A,
-                           (rt2x00dev->curr_hwmode == HWMODE_A));
+                           (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ));
 
         rt73usb_register_write(rt2x00dev, PHY_CSR0, reg);
 
@@ -644,9 +643,9 @@ static void rt73usb_enable_led(struct rt2x00_dev *rt2x00dev)
 
         rt2x00_set_field16(&rt2x00dev->led_reg, MCU_LEDCS_RADIO_STATUS, 1);
         rt2x00_set_field16(&rt2x00dev->led_reg, MCU_LEDCS_LINK_A_STATUS,
-                           (rt2x00dev->rx_status.phymode == MODE_IEEE80211A));
+                           (rt2x00dev->rx_status.band == IEEE80211_BAND_5GHZ));
         rt2x00_set_field16(&rt2x00dev->led_reg, MCU_LEDCS_LINK_BG_STATUS,
-                           (rt2x00dev->rx_status.phymode != MODE_IEEE80211A));
+                           (rt2x00dev->rx_status.band != IEEE80211_BAND_5GHZ));
 
         rt2x00usb_vendor_request_sw(rt2x00dev, USB_LED_CONTROL, 0x0000,
                                     rt2x00dev->led_reg, REGISTER_TIMEOUT);
@@ -736,7 +735,7 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev)
         /*
          * Determine r17 bounds.
          */
-        if (rt2x00dev->rx_status.phymode == MODE_IEEE80211A) {
+        if (rt2x00dev->rx_status.band == IEEE80211_BAND_5GHZ) {
                 low_bound = 0x28;
                 up_bound = 0x48;
 
@@ -1278,8 +1277,10 @@ static void rt73usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
         rt2x00_desc_write(txd, 2, word);
 
         rt2x00_desc_read(txd, 5, &word);
+/* XXX: removed for now
         rt2x00_set_field32(&word, TXD_W5_TX_POWER,
                            TXPOWER_TO_DEV(control->power_level));
+ */
         rt2x00_set_field32(&word, TXD_W5_WAITING_DMA_DONE_INT, 1);
         rt2x00_desc_write(txd, 5, word);
 
@@ -1370,7 +1371,7 @@ static int rt73usb_agc_to_rssi(struct rt2x00_dev *rt2x00dev, int rxd_w1)
                 return 0;
         }
 
-        if (rt2x00dev->rx_status.phymode == MODE_IEEE80211A) {
+        if (rt2x00dev->rx_status.band == IEEE80211_BAND_5GHZ) {
                 if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) {
                         if (lna == 3 || lna == 2)
                                 offset += 10;