cfg80211 API for channels/bitrates, mac80211 and driver conversion

This patch creates new cfg80211 wiphy API for channel and bitrate
registration and converts mac80211 and drivers to the new API. The
old mac80211 API is completely ripped out. All drivers (except ath5k)
are updated to the new API, in many cases I expect that optimisations
can be done.

Along with the regulatory code I've also ripped out the
IEEE80211_HW_DEFAULT_REG_DOMAIN_CONFIGURED flag, I believe it to be
unnecessary if the hardware simply gives us whatever channels it wants
to support and we then enable/disable them as required, which is pretty
much required for travelling.

Additionally, the patch adds proper "basic" rate handling for STA
mode interface, AP mode interface will have to have new API added
to allow userspace to set the basic rate set, currently it'll be
empty... However, the basic rate handling will need to be moved to
the BSS conf stuff.

I do expect there to be bugs in this, especially wrt. transmit
power handling where I'm basically clueless about how it should work.

Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

4 files changed, 105 insertions, 189 deletions

diff --git a/drivers/net/wireless/b43/b43.h b/drivers/net/wireless/b43/b43.h
index f13346ba9dd2..3e40323cd43f 100644
--- a/drivers/net/wireless/b43/b43.h
+++ b/drivers/net/wireless/b43/b43.h
@@ -468,10 +468,6 @@ struct b43_phy {
         u8 possible_phymodes;
         /* GMODE bit enabled? */
         bool gmode;
-        /* Possible ieee80211 subsystem hwmodes for this PHY.
-         * Which mode is selected, depends on thr GMODE enabled bit */
-#define B43_MAX_PHYHWMODES      2
-        struct ieee80211_hw_mode hwmodes[B43_MAX_PHYHWMODES];
 
         /* Analog Type */
         u8 analog;
@@ -727,7 +723,6 @@ struct b43_wldev {
 
         bool bad_frames_preempt;        /* Use "Bad Frames Preemption" (default off) */
         bool dfq_valid;         /* Directed frame queue valid (IBSS PS mode, ATIM) */
-        bool short_preamble;    /* TRUE, if short preamble is enabled. */
         bool short_slot;        /* TRUE, if short slot timing is enabled. */
         bool radio_hw_enable;   /* saved state of radio hardware enabled state */
         bool suspend_in_progress;       /* TRUE, if we are in a suspend/resume cycle */
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 51dfce16178a..017a041d07d0 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -96,25 +96,29 @@ MODULE_DEVICE_TABLE(ssb, b43_ssb_tbl);
  * data in there. This data is the same for all devices, so we don't
  * get concurrency issues */
 #define RATETAB_ENT(_rateid, _flags) \
-        {                                                       \
-                .rate   = B43_RATE_TO_BASE100KBPS(_rateid),     \
-                .val    = (_rateid),                            \
-                .val2   = (_rateid),                            \
-                .flags  = (_flags),                             \
+        {                                                               \
+                .bitrate        = B43_RATE_TO_BASE100KBPS(_rateid),     \
+                .hw_value       = (_rateid),                            \
+                .flags          = (_flags),                             \
         }
+
+/*
+ * NOTE: When changing this, sync with xmit.c's
+ *       b43_plcp_get_bitrate_idx_* functions!
+ */
 static struct ieee80211_rate __b43_ratetable[] = {
-        RATETAB_ENT(B43_CCK_RATE_1MB, IEEE80211_RATE_CCK),
-        RATETAB_ENT(B43_CCK_RATE_2MB, IEEE80211_RATE_CCK_2),
-        RATETAB_ENT(B43_CCK_RATE_5MB, IEEE80211_RATE_CCK_2),
-        RATETAB_ENT(B43_CCK_RATE_11MB, IEEE80211_RATE_CCK_2),
-        RATETAB_ENT(B43_OFDM_RATE_6MB, IEEE80211_RATE_OFDM),
-        RATETAB_ENT(B43_OFDM_RATE_9MB, IEEE80211_RATE_OFDM),
-        RATETAB_ENT(B43_OFDM_RATE_12MB, IEEE80211_RATE_OFDM),
-        RATETAB_ENT(B43_OFDM_RATE_18MB, IEEE80211_RATE_OFDM),
-        RATETAB_ENT(B43_OFDM_RATE_24MB, IEEE80211_RATE_OFDM),
-        RATETAB_ENT(B43_OFDM_RATE_36MB, IEEE80211_RATE_OFDM),
-        RATETAB_ENT(B43_OFDM_RATE_48MB, IEEE80211_RATE_OFDM),
-        RATETAB_ENT(B43_OFDM_RATE_54MB, IEEE80211_RATE_OFDM),
+        RATETAB_ENT(B43_CCK_RATE_1MB, 0),
+        RATETAB_ENT(B43_CCK_RATE_2MB, IEEE80211_RATE_SHORT_PREAMBLE),
+        RATETAB_ENT(B43_CCK_RATE_5MB, IEEE80211_RATE_SHORT_PREAMBLE),
+        RATETAB_ENT(B43_CCK_RATE_11MB, IEEE80211_RATE_SHORT_PREAMBLE),
+        RATETAB_ENT(B43_OFDM_RATE_6MB, 0),
+        RATETAB_ENT(B43_OFDM_RATE_9MB, 0),
+        RATETAB_ENT(B43_OFDM_RATE_12MB, 0),
+        RATETAB_ENT(B43_OFDM_RATE_18MB, 0),
+        RATETAB_ENT(B43_OFDM_RATE_24MB, 0),
+        RATETAB_ENT(B43_OFDM_RATE_36MB, 0),
+        RATETAB_ENT(B43_OFDM_RATE_48MB, 0),
+        RATETAB_ENT(B43_OFDM_RATE_54MB, 0),
 };
 
 #define b43_a_ratetable         (__b43_ratetable + 4)
@@ -126,14 +130,8 @@ static struct ieee80211_rate __b43_ratetable[] = {
 
 #define CHANTAB_ENT(_chanid, _freq) \
         {                                                       \
-                .chan   = (_chanid),                            \
-                .freq   = (_freq),                              \
-                .val    = (_chanid),                            \
-                .flag   = IEEE80211_CHAN_W_SCAN |               \
-                          IEEE80211_CHAN_W_ACTIVE_SCAN |        \
-                          IEEE80211_CHAN_W_IBSS,                \
-                .power_level    = 0xFF,                         \
-                .antenna_max    = 0xFF,                         \
+                .center_freq    = (_freq),                      \
+                .hw_value       = (_chanid),                    \
         }
 static struct ieee80211_channel b43_2ghz_chantable[] = {
         CHANTAB_ENT(1, 2412),
@@ -151,9 +149,8 @@ static struct ieee80211_channel b43_2ghz_chantable[] = {
         CHANTAB_ENT(13, 2472),
         CHANTAB_ENT(14, 2484),
 };
-#define b43_2ghz_chantable_size ARRAY_SIZE(b43_2ghz_chantable)
 
-#if 0
+#ifdef NOTYET
 static struct ieee80211_channel b43_5ghz_chantable[] = {
         CHANTAB_ENT(36, 5180),
         CHANTAB_ENT(40, 5200),
@@ -169,9 +166,22 @@ static struct ieee80211_channel b43_5ghz_chantable[] = {
         CHANTAB_ENT(161, 5805),
         CHANTAB_ENT(165, 5825),
 };
-#define b43_5ghz_chantable_size ARRAY_SIZE(b43_5ghz_chantable)
+
+static struct ieee80211_supported_band b43_band_5GHz = {
+        .channels = b43_5ghz_chantable,
+        .n_channels = ARRAY_SIZE(b43_5ghz_chantable),
+        .bitrates = b43_a_ratetable,
+        .n_bitrates = b43_a_ratetable_size,
+};
 #endif
 
+static struct ieee80211_supported_band b43_band_2GHz = {
+        .channels = b43_2ghz_chantable,
+        .n_channels = ARRAY_SIZE(b43_2ghz_chantable),
+        .bitrates = b43_g_ratetable,
+        .n_bitrates = b43_g_ratetable_size,
+};
+
 static void b43_wireless_core_exit(struct b43_wldev *dev);
 static int b43_wireless_core_init(struct b43_wldev *dev);
 static void b43_wireless_core_stop(struct b43_wldev *dev);
@@ -1222,17 +1232,18 @@ static void b43_write_beacon_template(struct b43_wldev *dev,
 }
 
 static void b43_write_probe_resp_plcp(struct b43_wldev *dev,
-                                      u16 shm_offset, u16 size, u8 rate)
+                                      u16 shm_offset, u16 size,
+                                      struct ieee80211_rate *rate)
 {
         struct b43_plcp_hdr4 plcp;
         u32 tmp;
         __le16 dur;
 
         plcp.data = 0;
-        b43_generate_plcp_hdr(&plcp, size + FCS_LEN, rate);
+        b43_generate_plcp_hdr(&plcp, size + FCS_LEN, rate->hw_value);
         dur = ieee80211_generic_frame_duration(dev->wl->hw,
                                                dev->wl->vif, size,
-                                               B43_RATE_TO_BASE100KBPS(rate));
+                                               rate);
         /* Write PLCP in two parts and timing for packet transfer */
         tmp = le32_to_cpu(plcp.data);
         b43_shm_write16(dev, B43_SHM_SHARED, shm_offset, tmp & 0xFFFF);
@@ -1247,7 +1258,8 @@ static void b43_write_probe_resp_plcp(struct b43_wldev *dev,
  * 3) Stripping TIM
  */
 static const u8 * b43_generate_probe_resp(struct b43_wldev *dev,
-                                          u16 *dest_size, u8 rate)
+                                          u16 *dest_size,
+                                          struct ieee80211_rate *rate)
 {
         const u8 *src_data;
         u8 *dest_data;
@@ -1292,7 +1304,7 @@ static const u8 * b43_generate_probe_resp(struct b43_wldev *dev,
                                          IEEE80211_STYPE_PROBE_RESP);
         dur = ieee80211_generic_frame_duration(dev->wl->hw,
                                                dev->wl->vif, *dest_size,
-                                               B43_RATE_TO_BASE100KBPS(rate));
+                                               rate);
         hdr->duration_id = dur;
 
         return dest_data;
@@ -1300,7 +1312,8 @@ static const u8 * b43_generate_probe_resp(struct b43_wldev *dev,
 
 static void b43_write_probe_resp_template(struct b43_wldev *dev,
                                           u16 ram_offset,
-                                          u16 shm_size_offset, u8 rate)
+                                          u16 shm_size_offset,
+                                          struct ieee80211_rate *rate)
 {
         const u8 *probe_resp_data;
         u16 size;
@@ -1313,14 +1326,15 @@ static void b43_write_probe_resp_template(struct b43_wldev *dev,
         /* Looks like PLCP headers plus packet timings are stored for
          * all possible basic rates
          */
-        b43_write_probe_resp_plcp(dev, 0x31A, size, B43_CCK_RATE_1MB);
-        b43_write_probe_resp_plcp(dev, 0x32C, size, B43_CCK_RATE_2MB);
-        b43_write_probe_resp_plcp(dev, 0x33E, size, B43_CCK_RATE_5MB);
-        b43_write_probe_resp_plcp(dev, 0x350, size, B43_CCK_RATE_11MB);
+        b43_write_probe_resp_plcp(dev, 0x31A, size, &b43_b_ratetable[0]);
+        b43_write_probe_resp_plcp(dev, 0x32C, size, &b43_b_ratetable[1]);
+        b43_write_probe_resp_plcp(dev, 0x33E, size, &b43_b_ratetable[2]);
+        b43_write_probe_resp_plcp(dev, 0x350, size, &b43_b_ratetable[3]);
 
         size = min((size_t) size, 0x200 - sizeof(struct b43_plcp_hdr6));
         b43_write_template_common(dev, probe_resp_data,
-                                  size, ram_offset, shm_size_offset, rate);
+                                  size, ram_offset, shm_size_offset,
+                                  rate->hw_value);
         kfree(probe_resp_data);
 }
 
@@ -1388,7 +1402,7 @@ static void handle_irq_beacon(struct b43_wldev *dev)
                         b43_write_beacon_template(dev, 0x68, 0x18,
                                                   B43_CCK_RATE_1MB);
                         b43_write_probe_resp_template(dev, 0x268, 0x4A,
-                                                      B43_CCK_RATE_11MB);
+                                                      &__b43_ratetable[3]);
                         wl->beacon0_uploaded = 1;
                 }
                 cmd |= B43_MACCMD_BEACON0_VALID;
@@ -2830,14 +2844,11 @@ static int b43_op_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
         mutex_lock(&wl->mutex);
 
         /* Switch the PHY mode (if necessary). */
-        switch (conf->phymode) {
-        case MODE_IEEE80211A:
+        switch (conf->channel->band) {
+        case IEEE80211_BAND_5GHZ:
                 new_phymode = B43_PHYMODE_A;
                 break;
-        case MODE_IEEE80211B:
-                new_phymode = B43_PHYMODE_B;
-                break;
-        case MODE_IEEE80211G:
+        case IEEE80211_BAND_2GHZ:
                 new_phymode = B43_PHYMODE_G;
                 break;
         default:
@@ -2863,8 +2874,8 @@ static int b43_op_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
 
         /* Switch to the requested channel.
          * The firmware takes care of races with the TX handler. */
-        if (conf->channel_val != phy->channel)
-                b43_radio_selectchannel(dev, conf->channel_val, 0);
+        if (conf->channel->hw_value != phy->channel)
+                b43_radio_selectchannel(dev, conf->channel->hw_value, 0);
 
         /* Enable/Disable ShortSlot timing. */
         if ((!!(conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME)) !=
@@ -3810,9 +3821,7 @@ static int b43_setup_modes(struct b43_wldev *dev,
                            bool have_2ghz_phy, bool have_5ghz_phy)
 {
         struct ieee80211_hw *hw = dev->wl->hw;
-        struct ieee80211_hw_mode *mode;
         struct b43_phy *phy = &dev->phy;
-        int err;
 
         /* XXX: This function will go away soon, when mac80211
          *      band stuff is rewritten. So this is just a hack.
@@ -3821,15 +3830,7 @@ static int b43_setup_modes(struct b43_wldev *dev,
          *      This assumption is OK, as any B, N or A PHY will already
          *      have died a horrible sanity check death earlier. */
 
-        mode = &phy->hwmodes[0];
-        mode->mode = MODE_IEEE80211G;
-        mode->num_channels = b43_2ghz_chantable_size;
-        mode->channels = b43_2ghz_chantable;
-        mode->num_rates = b43_g_ratetable_size;
-        mode->rates = b43_g_ratetable;
-        err = ieee80211_register_hwmode(hw, mode);
-        if (err)
-                return err;
+        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &b43_band_2GHz;
         phy->possible_phymodes |= B43_PHYMODE_G;
 
         return 0;
diff --git a/drivers/net/wireless/b43/sysfs.c b/drivers/net/wireless/b43/sysfs.c
index f4faff6a7d6c..275095b8cbe7 100644
--- a/drivers/net/wireless/b43/sysfs.c
+++ b/drivers/net/wireless/b43/sysfs.c
@@ -47,29 +47,6 @@ static int get_integer(const char *buf, size_t count)
         return ret;
 }
 
-static int get_boolean(const char *buf, size_t count)
-{
-        if (count != 0) {
-                if (buf[0] == '1')
-                        return 1;
-                if (buf[0] == '0')
-                        return 0;
-                if (count >= 4 && memcmp(buf, "true", 4) == 0)
-                        return 1;
-                if (count >= 5 && memcmp(buf, "false", 5) == 0)
-                        return 0;
-                if (count >= 3 && memcmp(buf, "yes", 3) == 0)
-                        return 1;
-                if (count >= 2 && memcmp(buf, "no", 2) == 0)
-                        return 0;
-                if (count >= 2 && memcmp(buf, "on", 2) == 0)
-                        return 1;
-                if (count >= 3 && memcmp(buf, "off", 3) == 0)
-                        return 0;
-        }
-        return -EINVAL;
-}
-
 static ssize_t b43_attr_interfmode_show(struct device *dev,
                                         struct device_attribute *attr,
                                         char *buf)
@@ -155,82 +132,18 @@ static ssize_t b43_attr_interfmode_store(struct device *dev,
 static DEVICE_ATTR(interference, 0644,
                    b43_attr_interfmode_show, b43_attr_interfmode_store);
 
-static ssize_t b43_attr_preamble_show(struct device *dev,
-                                      struct device_attribute *attr, char *buf)
-{
-        struct b43_wldev *wldev = dev_to_b43_wldev(dev);
-        ssize_t count;
-
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
-
-        mutex_lock(&wldev->wl->mutex);
-
-        if (wldev->short_preamble)
-                count =
-                    snprintf(buf, PAGE_SIZE, "1 (Short Preamble enabled)\n");
-        else
-                count =
-                    snprintf(buf, PAGE_SIZE, "0 (Short Preamble disabled)\n");
-
-        mutex_unlock(&wldev->wl->mutex);
-
-        return count;
-}
-
-static ssize_t b43_attr_preamble_store(struct device *dev,
-                                       struct device_attribute *attr,
-                                       const char *buf, size_t count)
-{
-        struct b43_wldev *wldev = dev_to_b43_wldev(dev);
-        unsigned long flags;
-        int value;
-
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
-
-        value = get_boolean(buf, count);
-        if (value < 0)
-                return value;
-        mutex_lock(&wldev->wl->mutex);
-        spin_lock_irqsave(&wldev->wl->irq_lock, flags);
-
-        wldev->short_preamble = !!value;
-
-        spin_unlock_irqrestore(&wldev->wl->irq_lock, flags);
-        mutex_unlock(&wldev->wl->mutex);
-
-        return count;
-}
-
-static DEVICE_ATTR(shortpreamble, 0644,
-                   b43_attr_preamble_show, b43_attr_preamble_store);
-
 int b43_sysfs_register(struct b43_wldev *wldev)
 {
         struct device *dev = wldev->dev->dev;
-        int err;
 
         B43_WARN_ON(b43_status(wldev) != B43_STAT_INITIALIZED);
 
-        err = device_create_file(dev, &dev_attr_interference);
-        if (err)
-                goto out;
-        err = device_create_file(dev, &dev_attr_shortpreamble);
-        if (err)
-                goto err_remove_interfmode;
-
-      out:
-        return err;
-      err_remove_interfmode:
-        device_remove_file(dev, &dev_attr_interference);
-        goto out;
+        return device_create_file(dev, &dev_attr_interference);
 }
 
 void b43_sysfs_unregister(struct b43_wldev *wldev)
 {
         struct device *dev = wldev->dev->dev;
 
-        device_remove_file(dev, &dev_attr_shortpreamble);
         device_remove_file(dev, &dev_attr_interference);
 }
diff --git a/drivers/net/wireless/b43/xmit.c b/drivers/net/wireless/b43/xmit.c
index 7caa26eb4105..4014b6c8272b 100644
--- a/drivers/net/wireless/b43/xmit.c
+++ b/drivers/net/wireless/b43/xmit.c
@@ -32,46 +32,48 @@
 #include "dma.h"
 
 
-/* Extract the bitrate out of a CCK PLCP header. */
-static u8 b43_plcp_get_bitrate_cck(struct b43_plcp_hdr6 *plcp)
+/* Extract the bitrate index out of a CCK PLCP header. */
+static int b43_plcp_get_bitrate_idx_cck(struct b43_plcp_hdr6 *plcp)
 {
         switch (plcp->raw[0]) {
         case 0x0A:
-                return B43_CCK_RATE_1MB;
+                return 0;
         case 0x14:
-                return B43_CCK_RATE_2MB;
+                return 1;
         case 0x37:
-                return B43_CCK_RATE_5MB;
+                return 2;
         case 0x6E:
-                return B43_CCK_RATE_11MB;
+                return 3;
         }
         B43_WARN_ON(1);
-        return 0;
+        return -1;
 }
 
-/* Extract the bitrate out of an OFDM PLCP header. */
-static u8 b43_plcp_get_bitrate_ofdm(struct b43_plcp_hdr6 *plcp)
+/* Extract the bitrate index out of an OFDM PLCP header. */
+static u8 b43_plcp_get_bitrate_idx_ofdm(struct b43_plcp_hdr6 *plcp, bool aphy)
 {
+        int base = aphy ? 0 : 4;
+
         switch (plcp->raw[0] & 0xF) {
         case 0xB:
-                return B43_OFDM_RATE_6MB;
+                return base + 0;
         case 0xF:
-                return B43_OFDM_RATE_9MB;
+                return base + 1;
         case 0xA:
-                return B43_OFDM_RATE_12MB;
+                return base + 2;
         case 0xE:
-                return B43_OFDM_RATE_18MB;
+                return base + 3;
         case 0x9:
-                return B43_OFDM_RATE_24MB;
+                return base + 4;
         case 0xD:
-                return B43_OFDM_RATE_36MB;
+                return base + 5;
         case 0x8:
-                return B43_OFDM_RATE_48MB;
+                return base + 6;
         case 0xC:
-                return B43_OFDM_RATE_54MB;
+                return base + 7;
         }
         B43_WARN_ON(1);
-        return 0;
+        return -1;
 }
 
 u8 b43_plcp_get_ratecode_cck(const u8 bitrate)
@@ -191,6 +193,7 @@ int b43_generate_txhdr(struct b43_wldev *dev,
             (const struct ieee80211_hdr *)fragment_data;
         int use_encryption = (!(txctl->flags & IEEE80211_TXCTL_DO_NOT_ENCRYPT));
         u16 fctl = le16_to_cpu(wlhdr->frame_control);
+        struct ieee80211_rate *fbrate;
         u8 rate, rate_fb;
         int rate_ofdm, rate_fb_ofdm;
         unsigned int plcp_fragment_len;
@@ -200,9 +203,11 @@ int b43_generate_txhdr(struct b43_wldev *dev,
 
         memset(txhdr, 0, sizeof(*txhdr));
 
-        rate = txctl->tx_rate;
+        WARN_ON(!txctl->tx_rate);
+        rate = txctl->tx_rate ? txctl->tx_rate->hw_value : B43_CCK_RATE_1MB;
         rate_ofdm = b43_is_ofdm_rate(rate);
-        rate_fb = (txctl->alt_retry_rate == -1) ? rate : txctl->alt_retry_rate;
+        fbrate = txctl->alt_retry_rate ? : txctl->tx_rate;
+        rate_fb = fbrate->hw_value;
         rate_fb_ofdm = b43_is_ofdm_rate(rate_fb);
 
         if (rate_ofdm)
@@ -221,11 +226,10 @@ int b43_generate_txhdr(struct b43_wldev *dev,
                  * use the original dur_id field. */
                 txhdr->dur_fb = wlhdr->duration_id;
         } else {
-                int fbrate_base100kbps = B43_RATE_TO_BASE100KBPS(rate_fb);
                 txhdr->dur_fb = ieee80211_generic_frame_duration(dev->wl->hw,
                                                                  txctl->vif,
                                                                  fragment_len,
-                                                                 fbrate_base100kbps);
+                                                                 fbrate);
         }
 
         plcp_fragment_len = fragment_len + FCS_LEN;
@@ -287,7 +291,7 @@ int b43_generate_txhdr(struct b43_wldev *dev,
                 phy_ctl |= B43_TXH_PHY_ENC_OFDM;
         else
                 phy_ctl |= B43_TXH_PHY_ENC_CCK;
-        if (dev->short_preamble)
+        if (txctl->flags & IEEE80211_TXCTL_SHORT_PREAMBLE)
                 phy_ctl |= B43_TXH_PHY_SHORTPRMBL;
 
         switch (b43_ieee80211_antenna_sanitize(dev, txctl->antenna_sel_tx)) {
@@ -332,7 +336,8 @@ int b43_generate_txhdr(struct b43_wldev *dev,
                 int rts_rate_ofdm, rts_rate_fb_ofdm;
                 struct b43_plcp_hdr6 *plcp;
 
-                rts_rate = txctl->rts_cts_rate;
+                WARN_ON(!txctl->rts_cts_rate);
+                rts_rate = txctl->rts_cts_rate ? txctl->rts_cts_rate->hw_value : B43_CCK_RATE_1MB;
                 rts_rate_ofdm = b43_is_ofdm_rate(rts_rate);
                 rts_rate_fb = b43_calc_fallback_rate(rts_rate);
                 rts_rate_fb_ofdm = b43_is_ofdm_rate(rts_rate_fb);
@@ -506,6 +511,7 @@ void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
         u16 phystat0, phystat3, chanstat, mactime;
         u32 macstat;
         u16 chanid;
+        u16 phytype;
         u8 jssi;
         int padding;
 
@@ -518,6 +524,7 @@ void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
         macstat = le32_to_cpu(rxhdr->mac_status);
         mactime = le16_to_cpu(rxhdr->mac_time);
         chanstat = le16_to_cpu(rxhdr->channel);
+        phytype = chanstat & B43_RX_CHAN_PHYTYPE;
 
         if (macstat & B43_RX_MAC_FCSERR)
                 dev->wl->ieee_stats.dot11FCSErrorCount++;
@@ -575,9 +582,10 @@ void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
         /* the next line looks wrong, but is what mac80211 wants */
         status.signal = (jssi * 100) / B43_RX_MAX_SSI;
         if (phystat0 & B43_RX_PHYST0_OFDM)
-                status.rate = b43_plcp_get_bitrate_ofdm(plcp);
+                status.rate_idx = b43_plcp_get_bitrate_idx_ofdm(plcp,
+                                                phytype == B43_PHYTYPE_A);
         else
-                status.rate = b43_plcp_get_bitrate_cck(plcp);
+                status.rate_idx = b43_plcp_get_bitrate_idx_cck(plcp);
         status.antenna = !!(phystat0 & B43_RX_PHYST0_ANT);
 
         /*
@@ -601,29 +609,28 @@ void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
         chanid = (chanstat & B43_RX_CHAN_ID) >> B43_RX_CHAN_ID_SHIFT;
         switch (chanstat & B43_RX_CHAN_PHYTYPE) {
         case B43_PHYTYPE_A:
-                status.phymode = MODE_IEEE80211A;
+                status.band = IEEE80211_BAND_5GHZ;
                 B43_WARN_ON(1);
                 /* FIXME: We don't really know which value the "chanid" contains.
                  *        So the following assignment might be wrong. */
-                status.channel = chanid;
-                status.freq = b43_channel_to_freq_5ghz(status.channel);
+                status.freq = b43_channel_to_freq_5ghz(chanid);
                 break;
         case B43_PHYTYPE_G:
-                status.phymode = MODE_IEEE80211G;
+                status.band = IEEE80211_BAND_2GHZ;
                 /* chanid is the radio channel cookie value as used
                  * to tune the radio. */
                 status.freq = chanid + 2400;
-                status.channel = b43_freq_to_channel_2ghz(status.freq);
                 break;
         case B43_PHYTYPE_N:
-                status.phymode = 0xDEAD /*FIXME MODE_IEEE80211N*/;
                 /* chanid is the SHM channel cookie. Which is the plain
                  * channel number in b43. */
-                status.channel = chanid;
-                if (chanstat & B43_RX_CHAN_5GHZ)
-                        status.freq = b43_freq_to_channel_5ghz(status.freq);
-                else
-                        status.freq = b43_freq_to_channel_2ghz(status.freq);
+                if (chanstat & B43_RX_CHAN_5GHZ) {
+                        status.band = IEEE80211_BAND_5GHZ;
+                        status.freq = b43_freq_to_channel_5ghz(chanid);
+                } else {
+                        status.band = IEEE80211_BAND_2GHZ;
+                        status.freq = b43_freq_to_channel_2ghz(chanid);
+                }
                 break;
         default:
                 B43_WARN_ON(1);