iwlwifi: add missing rcu_read_lock
[safe/jmp/linux-2.6] / drivers / net / wireless / mwl8k.c
index d8eff68..808adb9 100644 (file)
@@ -2,7 +2,7 @@
  * drivers/net/wireless/mwl8k.c
  * Driver for Marvell TOPDOG 802.11 Wireless cards
  *
- * Copyright (C) 2008-2009 Marvell Semiconductor Inc.
+ * Copyright (C) 2008, 2009, 2010 Marvell Semiconductor Inc.
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2.  This program is licensed "as is" without any
@@ -19,6 +19,7 @@
 #include <linux/delay.h>
 #include <linux/completion.h>
 #include <linux/etherdevice.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
@@ -26,7 +27,7 @@
 
 #define MWL8K_DESC     "Marvell TOPDOG(R) 802.11 Wireless Network Driver"
 #define MWL8K_NAME     KBUILD_MODNAME
-#define MWL8K_VERSION  "0.11"
+#define MWL8K_VERSION  "0.12"
 
 /* Register definitions */
 #define MWL8K_HIU_GEN_PTR                      0x00000c10
@@ -119,7 +120,7 @@ struct mwl8k_tx_queue {
        /* sw appends here */
        int tail;
 
-       struct ieee80211_tx_queue_stats stats;
+       unsigned int len;
        struct mwl8k_tx_desc *txd;
        dma_addr_t txd_dma;
        struct sk_buff **skb;
@@ -141,6 +142,14 @@ struct mwl8k_priv {
        /* hardware/firmware parameters */
        bool ap_fw;
        struct rxd_ops *rxd_ops;
+       struct ieee80211_supported_band band_24;
+       struct ieee80211_channel channels_24[14];
+       struct ieee80211_rate rates_24[14];
+       struct ieee80211_supported_band band_50;
+       struct ieee80211_channel channels_50[4];
+       struct ieee80211_rate rates_50[9];
+       u32 ap_macids_supported;
+       u32 sta_macids_supported;
 
        /* firmware access */
        struct mutex fw_mutex;
@@ -154,9 +163,9 @@ struct mwl8k_priv {
        /* TX quiesce completion, protected by fw_mutex and tx_lock */
        struct completion *tx_wait;
 
-       struct ieee80211_vif *vif;
-
-       struct ieee80211_channel *current_channel;
+       /* List of interfaces.  */
+       u32 macids_used;
+       struct list_head vif_list;
 
        /* power management status cookie from firmware */
        u32 *cookie;
@@ -175,20 +184,11 @@ struct mwl8k_priv {
        struct mwl8k_rx_queue rxq[MWL8K_RX_QUEUES];
        struct mwl8k_tx_queue txq[MWL8K_TX_QUEUES];
 
-       /* PHY parameters */
-       struct ieee80211_supported_band band;
-       struct ieee80211_channel channels[14];
-       struct ieee80211_rate rates[14];
-
        bool radio_on;
        bool radio_short_preamble;
        bool sniffer_enabled;
        bool wmm_enabled;
 
-       struct work_struct sta_notify_worker;
-       spinlock_t sta_notify_list_lock;
-       struct list_head sta_notify_list;
-
        /* XXX need to convert this to handle multiple interfaces */
        bool capture_beacon;
        u8 capture_bssid[ETH_ALEN];
@@ -202,16 +202,22 @@ struct mwl8k_priv {
         */
        struct work_struct finalize_join_worker;
 
-       /* Tasklet to reclaim TX descriptors and buffers after tx */
-       struct tasklet_struct tx_reclaim_task;
+       /* Tasklet to perform TX reclaim.  */
+       struct tasklet_struct poll_tx_task;
+
+       /* Tasklet to perform RX.  */
+       struct tasklet_struct poll_rx_task;
 };
 
 /* Per interface specific private data */
 struct mwl8k_vif {
-       /* Local MAC address.  */
-       u8 mac_addr[ETH_ALEN];
+       struct list_head list;
+       struct ieee80211_vif *vif;
 
-       /* Non AMPDU sequence number assigned by driver */
+       /* Firmware macid for this vif.  */
+       int macid;
+
+       /* Non AMPDU sequence number assigned by driver.  */
        u16 seqno;
 };
 #define MWL8K_VIF(_vif) ((struct mwl8k_vif *)&((_vif)->drv_priv))
@@ -222,7 +228,7 @@ struct mwl8k_sta {
 };
 #define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))
 
-static const struct ieee80211_channel mwl8k_channels[] = {
+static const struct ieee80211_channel mwl8k_channels_24[] = {
        { .center_freq = 2412, .hw_value = 1, },
        { .center_freq = 2417, .hw_value = 2, },
        { .center_freq = 2422, .hw_value = 3, },
@@ -239,7 +245,7 @@ static const struct ieee80211_channel mwl8k_channels[] = {
        { .center_freq = 2484, .hw_value = 14, },
 };
 
-static const struct ieee80211_rate mwl8k_rates[] = {
+static const struct ieee80211_rate mwl8k_rates_24[] = {
        { .bitrate = 10, .hw_value = 2, },
        { .bitrate = 20, .hw_value = 4, },
        { .bitrate = 55, .hw_value = 11, },
@@ -256,6 +262,25 @@ static const struct ieee80211_rate mwl8k_rates[] = {
        { .bitrate = 720, .hw_value = 144, },
 };
 
+static const struct ieee80211_channel mwl8k_channels_50[] = {
+       { .center_freq = 5180, .hw_value = 36, },
+       { .center_freq = 5200, .hw_value = 40, },
+       { .center_freq = 5220, .hw_value = 44, },
+       { .center_freq = 5240, .hw_value = 48, },
+};
+
+static const struct ieee80211_rate mwl8k_rates_50[] = {
+       { .bitrate = 60, .hw_value = 12, },
+       { .bitrate = 90, .hw_value = 18, },
+       { .bitrate = 120, .hw_value = 24, },
+       { .bitrate = 180, .hw_value = 36, },
+       { .bitrate = 240, .hw_value = 48, },
+       { .bitrate = 360, .hw_value = 72, },
+       { .bitrate = 480, .hw_value = 96, },
+       { .bitrate = 540, .hw_value = 108, },
+       { .bitrate = 720, .hw_value = 144, },
+};
+
 /* Set or get info from Firmware */
 #define MWL8K_CMD_SET                  0x0001
 #define MWL8K_CMD_GET                  0x0000
@@ -269,6 +294,7 @@ static const struct ieee80211_rate mwl8k_rates[] = {
 #define MWL8K_CMD_RADIO_CONTROL                0x001c
 #define MWL8K_CMD_RF_TX_POWER          0x001e
 #define MWL8K_CMD_RF_ANTENNA           0x0020
+#define MWL8K_CMD_SET_BEACON           0x0100          /* per-vif */
 #define MWL8K_CMD_SET_PRE_SCAN         0x0107
 #define MWL8K_CMD_SET_POST_SCAN                0x0108
 #define MWL8K_CMD_SET_RF_CHANNEL       0x010a
@@ -282,8 +308,10 @@ static const struct ieee80211_rate mwl8k_rates[] = {
 #define MWL8K_CMD_MIMO_CONFIG          0x0125
 #define MWL8K_CMD_USE_FIXED_RATE       0x0126
 #define MWL8K_CMD_ENABLE_SNIFFER       0x0150
-#define MWL8K_CMD_SET_MAC_ADDR         0x0202
+#define MWL8K_CMD_SET_MAC_ADDR         0x0202          /* per-vif */
 #define MWL8K_CMD_SET_RATEADAPT_MODE   0x0203
+#define MWL8K_CMD_BSS_START            0x1100          /* per-vif */
+#define MWL8K_CMD_SET_NEW_STN          0x1111          /* per-vif */
 #define MWL8K_CMD_UPDATE_STADB         0x1123
 
 static const char *mwl8k_cmd_name(u16 cmd, char *buf, int bufsize)
@@ -301,6 +329,7 @@ static const char *mwl8k_cmd_name(u16 cmd, char *buf, int bufsize)
                MWL8K_CMDNAME(RADIO_CONTROL);
                MWL8K_CMDNAME(RF_TX_POWER);
                MWL8K_CMDNAME(RF_ANTENNA);
+               MWL8K_CMDNAME(SET_BEACON);
                MWL8K_CMDNAME(SET_PRE_SCAN);
                MWL8K_CMDNAME(SET_POST_SCAN);
                MWL8K_CMDNAME(SET_RF_CHANNEL);
@@ -316,6 +345,8 @@ static const char *mwl8k_cmd_name(u16 cmd, char *buf, int bufsize)
                MWL8K_CMDNAME(ENABLE_SNIFFER);
                MWL8K_CMDNAME(SET_MAC_ADDR);
                MWL8K_CMDNAME(SET_RATEADAPT_MODE);
+               MWL8K_CMDNAME(BSS_START);
+               MWL8K_CMDNAME(SET_NEW_STN);
                MWL8K_CMDNAME(UPDATE_STADB);
        default:
                snprintf(buf, bufsize, "0x%x", cmd);
@@ -388,13 +419,11 @@ static int mwl8k_request_firmware(struct mwl8k_priv *priv)
        return 0;
 }
 
-MODULE_FIRMWARE("mwl8k/helper_8687.fw");
-MODULE_FIRMWARE("mwl8k/fmimage_8687.fw");
-
 struct mwl8k_cmd_pkt {
        __le16  code;
        __le16  length;
-       __le16  seq_num;
+       __u8    seq_num;
+       __u8    macid;
        __le16  result;
        char    payload[0];
 } __attribute__((packed));
@@ -452,6 +481,7 @@ static int mwl8k_load_fw_image(struct mwl8k_priv *priv,
 
        cmd->code = cpu_to_le16(MWL8K_CMD_CODE_DNLD);
        cmd->seq_num = 0;
+       cmd->macid = 0;
        cmd->result = 0;
 
        done = 0;
@@ -720,7 +750,6 @@ mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
        memset(status, 0, sizeof(*status));
 
        status->signal = -rxd->rssi;
-       status->noise = -rxd->noise_floor;
 
        if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
                status->flag |= RX_FLAG_HT;
@@ -730,15 +759,21 @@ mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
        } else {
                int i;
 
-               for (i = 0; i < ARRAY_SIZE(mwl8k_rates); i++) {
-                       if (mwl8k_rates[i].hw_value == rxd->rate) {
+               for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) {
+                       if (mwl8k_rates_24[i].hw_value == rxd->rate) {
                                status->rate_idx = i;
                                break;
                        }
                }
        }
 
-       status->band = IEEE80211_BAND_2GHZ;
+       if (rxd->channel > 14) {
+               status->band = IEEE80211_BAND_5GHZ;
+               if (!(status->flag & RX_FLAG_HT))
+                       status->rate_idx -= 5;
+       } else {
+               status->band = IEEE80211_BAND_2GHZ;
+       }
        status->freq = ieee80211_channel_to_frequency(rxd->channel);
 
        *qos = rxd->qos_control;
@@ -816,7 +851,6 @@ mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
        memset(status, 0, sizeof(*status));
 
        status->signal = -rxd->rssi;
-       status->noise = -rxd->noise_level;
        status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
        status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
 
@@ -829,7 +863,13 @@ mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
        if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
                status->flag |= RX_FLAG_HT;
 
-       status->band = IEEE80211_BAND_2GHZ;
+       if (rxd->channel > 14) {
+               status->band = IEEE80211_BAND_5GHZ;
+               if (!(status->flag & RX_FLAG_HT))
+                       status->rate_idx -= 5;
+       } else {
+               status->band = IEEE80211_BAND_2GHZ;
+       }
        status->freq = ieee80211_channel_to_frequency(rxd->channel);
 
        *qos = rxd->qos_control;
@@ -1091,8 +1131,7 @@ static int mwl8k_txq_init(struct ieee80211_hw *hw, int index)
        int size;
        int i;
 
-       memset(&txq->stats, 0, sizeof(struct ieee80211_tx_queue_stats));
-       txq->stats.limit = MWL8K_TX_DESCS;
+       txq->len = 0;
        txq->head = 0;
        txq->tail = 0;
 
@@ -1168,7 +1207,7 @@ static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
                printk(KERN_ERR "%s: txq[%d] len=%d head=%d tail=%d "
                       "fw_owned=%d drv_owned=%d unused=%d\n",
                       wiphy_name(hw->wiphy), i,
-                      txq->stats.len, txq->head, txq->tail,
+                      txq->len, txq->head, txq->tail,
                       fw_owned, drv_owned, unused);
        }
 }
@@ -1176,7 +1215,7 @@ static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
 /*
  * Must be called with priv->fw_mutex held and tx queues stopped.
  */
-#define MWL8K_TX_WAIT_TIMEOUT_MS       1000
+#define MWL8K_TX_WAIT_TIMEOUT_MS       5000
 
 static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
 {
@@ -1246,13 +1285,15 @@ static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
                     MWL8K_TXD_STATUS_OK_RETRY |                \
                     MWL8K_TXD_STATUS_OK_MORE_RETRY))
 
-static void mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int force)
+static int
+mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)
 {
        struct mwl8k_priv *priv = hw->priv;
        struct mwl8k_tx_queue *txq = priv->txq + index;
-       int wake = 0;
+       int processed;
 
-       while (txq->stats.len > 0) {
+       processed = 0;
+       while (txq->len > 0 && limit--) {
                int tx;
                struct mwl8k_tx_desc *tx_desc;
                unsigned long addr;
@@ -1274,8 +1315,8 @@ static void mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int force)
                }
 
                txq->head = (tx + 1) % MWL8K_TX_DESCS;
-               BUG_ON(txq->stats.len == 0);
-               txq->stats.len--;
+               BUG_ON(txq->len == 0);
+               txq->len--;
                priv->pending_tx_pkts--;
 
                addr = le32_to_cpu(tx_desc->pkt_phys_addr);
@@ -1299,11 +1340,13 @@ static void mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int force)
 
                ieee80211_tx_status_irqsafe(hw, skb);
 
-               wake = 1;
+               processed++;
        }
 
-       if (wake && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
+       if (processed && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
                ieee80211_wake_queue(hw, index);
+
+       return processed;
 }
 
 /* must be called only when the card's transmit is completely halted */
@@ -1312,7 +1355,7 @@ static void mwl8k_txq_deinit(struct ieee80211_hw *hw, int index)
        struct mwl8k_priv *priv = hw->priv;
        struct mwl8k_tx_queue *txq = priv->txq + index;
 
-       mwl8k_txq_reclaim(hw, index, 1);
+       mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
 
        kfree(txq->skb);
        txq->skb = NULL;
@@ -1350,11 +1393,9 @@ mwl8k_txq_xmit(struct ieee80211_hw *hw, int index, struct sk_buff *skb)
        mwl8k_vif = MWL8K_VIF(tx_info->control.vif);
 
        if (tx_info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
-               u16 seqno = mwl8k_vif->seqno;
-
                wh->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
-               wh->seq_ctrl |= cpu_to_le16(seqno << 4);
-               mwl8k_vif->seqno = seqno++ % 4096;
+               wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
+               mwl8k_vif->seqno += 0x10;
        }
 
        /* Setup firmware control bit fields for each frame type.  */
@@ -1407,8 +1448,7 @@ mwl8k_txq_xmit(struct ieee80211_hw *hw, int index, struct sk_buff *skb)
        wmb();
        tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);
 
-       txq->stats.count++;
-       txq->stats.len++;
+       txq->len++;
        priv->pending_tx_pkts++;
 
        txq->tail++;
@@ -1556,6 +1596,56 @@ static int mwl8k_post_cmd(struct ieee80211_hw *hw, struct mwl8k_cmd_pkt *cmd)
        return rc;
 }
 
+static int mwl8k_post_pervif_cmd(struct ieee80211_hw *hw,
+                                struct ieee80211_vif *vif,
+                                struct mwl8k_cmd_pkt *cmd)
+{
+       if (vif != NULL)
+               cmd->macid = MWL8K_VIF(vif)->macid;
+       return mwl8k_post_cmd(hw, cmd);
+}
+
+/*
+ * Setup code shared between STA and AP firmware images.
+ */
+static void mwl8k_setup_2ghz_band(struct ieee80211_hw *hw)
+{
+       struct mwl8k_priv *priv = hw->priv;
+
+       BUILD_BUG_ON(sizeof(priv->channels_24) != sizeof(mwl8k_channels_24));
+       memcpy(priv->channels_24, mwl8k_channels_24, sizeof(mwl8k_channels_24));
+
+       BUILD_BUG_ON(sizeof(priv->rates_24) != sizeof(mwl8k_rates_24));
+       memcpy(priv->rates_24, mwl8k_rates_24, sizeof(mwl8k_rates_24));
+
+       priv->band_24.band = IEEE80211_BAND_2GHZ;
+       priv->band_24.channels = priv->channels_24;
+       priv->band_24.n_channels = ARRAY_SIZE(mwl8k_channels_24);
+       priv->band_24.bitrates = priv->rates_24;
+       priv->band_24.n_bitrates = ARRAY_SIZE(mwl8k_rates_24);
+
+       hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band_24;
+}
+
+static void mwl8k_setup_5ghz_band(struct ieee80211_hw *hw)
+{
+       struct mwl8k_priv *priv = hw->priv;
+
+       BUILD_BUG_ON(sizeof(priv->channels_50) != sizeof(mwl8k_channels_50));
+       memcpy(priv->channels_50, mwl8k_channels_50, sizeof(mwl8k_channels_50));
+
+       BUILD_BUG_ON(sizeof(priv->rates_50) != sizeof(mwl8k_rates_50));
+       memcpy(priv->rates_50, mwl8k_rates_50, sizeof(mwl8k_rates_50));
+
+       priv->band_50.band = IEEE80211_BAND_5GHZ;
+       priv->band_50.channels = priv->channels_50;
+       priv->band_50.n_channels = ARRAY_SIZE(mwl8k_channels_50);
+       priv->band_50.bitrates = priv->rates_50;
+       priv->band_50.n_bitrates = ARRAY_SIZE(mwl8k_rates_50);
+
+       hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &priv->band_50;
+}
+
 /*
  * CMD_GET_HW_SPEC (STA version).
  */
@@ -1578,6 +1668,89 @@ struct mwl8k_cmd_get_hw_spec_sta {
        __le32 total_rxd;
 } __attribute__((packed));
 
+#define MWL8K_CAP_MAX_AMSDU            0x20000000
+#define MWL8K_CAP_GREENFIELD           0x08000000
+#define MWL8K_CAP_AMPDU                        0x04000000
+#define MWL8K_CAP_RX_STBC              0x01000000
+#define MWL8K_CAP_TX_STBC              0x00800000
+#define MWL8K_CAP_SHORTGI_40MHZ                0x00400000
+#define MWL8K_CAP_SHORTGI_20MHZ                0x00200000
+#define MWL8K_CAP_RX_ANTENNA_MASK      0x000e0000
+#define MWL8K_CAP_TX_ANTENNA_MASK      0x0001c000
+#define MWL8K_CAP_DELAY_BA             0x00003000
+#define MWL8K_CAP_MIMO                 0x00000200
+#define MWL8K_CAP_40MHZ                        0x00000100
+#define MWL8K_CAP_BAND_MASK            0x00000007
+#define MWL8K_CAP_5GHZ                 0x00000004
+#define MWL8K_CAP_2GHZ4                        0x00000001
+
+static void
+mwl8k_set_ht_caps(struct ieee80211_hw *hw,
+                 struct ieee80211_supported_band *band, u32 cap)
+{
+       int rx_streams;
+       int tx_streams;
+
+       band->ht_cap.ht_supported = 1;
+
+       if (cap & MWL8K_CAP_MAX_AMSDU)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
+       if (cap & MWL8K_CAP_GREENFIELD)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
+       if (cap & MWL8K_CAP_AMPDU) {
+               hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
+               band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
+               band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
+       }
+       if (cap & MWL8K_CAP_RX_STBC)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
+       if (cap & MWL8K_CAP_TX_STBC)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
+       if (cap & MWL8K_CAP_SHORTGI_40MHZ)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
+       if (cap & MWL8K_CAP_SHORTGI_20MHZ)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
+       if (cap & MWL8K_CAP_DELAY_BA)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
+       if (cap & MWL8K_CAP_40MHZ)
+               band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
+
+       rx_streams = hweight32(cap & MWL8K_CAP_RX_ANTENNA_MASK);
+       tx_streams = hweight32(cap & MWL8K_CAP_TX_ANTENNA_MASK);
+
+       band->ht_cap.mcs.rx_mask[0] = 0xff;
+       if (rx_streams >= 2)
+               band->ht_cap.mcs.rx_mask[1] = 0xff;
+       if (rx_streams >= 3)
+               band->ht_cap.mcs.rx_mask[2] = 0xff;
+       band->ht_cap.mcs.rx_mask[4] = 0x01;
+       band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
+
+       if (rx_streams != tx_streams) {
+               band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
+               band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
+                               IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
+       }
+}
+
+static void
+mwl8k_set_caps(struct ieee80211_hw *hw, u32 caps)
+{
+       struct mwl8k_priv *priv = hw->priv;
+
+       if ((caps & MWL8K_CAP_2GHZ4) || !(caps & MWL8K_CAP_BAND_MASK)) {
+               mwl8k_setup_2ghz_band(hw);
+               if (caps & MWL8K_CAP_MIMO)
+                       mwl8k_set_ht_caps(hw, &priv->band_24, caps);
+       }
+
+       if (caps & MWL8K_CAP_5GHZ) {
+               mwl8k_setup_5ghz_band(hw);
+               if (caps & MWL8K_CAP_MIMO)
+                       mwl8k_set_ht_caps(hw, &priv->band_50, caps);
+       }
+}
+
 static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
 {
        struct mwl8k_priv *priv = hw->priv;
@@ -1608,6 +1781,9 @@ static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
                priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs);
                priv->fw_rev = le32_to_cpu(cmd->fw_rev);
                priv->hw_rev = cmd->hw_rev;
+               mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
+               priv->ap_macids_supported = 0x00000000;
+               priv->sta_macids_supported = 0x00000001;
        }
 
        kfree(cmd);
@@ -1661,6 +1837,9 @@ static int mwl8k_cmd_get_hw_spec_ap(struct ieee80211_hw *hw)
                priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs);
                priv->fw_rev = le32_to_cpu(cmd->fw_rev);
                priv->hw_rev = cmd->hw_rev;
+               mwl8k_setup_2ghz_band(hw);
+               priv->ap_macids_supported = 0x000000ff;
+               priv->sta_macids_supported = 0x00000000;
 
                off = le32_to_cpu(cmd->wcbbase0) & 0xffff;
                iowrite32(cpu_to_le32(priv->txq[0].txd_dma), priv->sram + off);
@@ -1706,7 +1885,9 @@ struct mwl8k_cmd_set_hw_spec {
        __le32 total_rxd;
 } __attribute__((packed));
 
-#define MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT  0x00000080
+#define MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT          0x00000080
+#define MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP      0x00000020
+#define MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON         0x00000010
 
 static int mwl8k_cmd_set_hw_spec(struct ieee80211_hw *hw)
 {
@@ -1727,7 +1908,9 @@ static int mwl8k_cmd_set_hw_spec(struct ieee80211_hw *hw)
        cmd->num_tx_queues = cpu_to_le32(MWL8K_TX_QUEUES);
        for (i = 0; i < MWL8K_TX_QUEUES; i++)
                cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
-       cmd->flags = cpu_to_le32(MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT);
+       cmd->flags = cpu_to_le32(MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT |
+                                MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP |
+                                MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON);
        cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
        cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
 
@@ -1754,11 +1937,15 @@ struct mwl8k_cmd_mac_multicast_adr {
 
 static struct mwl8k_cmd_pkt *
 __mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
-                             int mc_count, struct dev_addr_list *mclist)
+                             struct netdev_hw_addr_list *mc_list)
 {
        struct mwl8k_priv *priv = hw->priv;
        struct mwl8k_cmd_mac_multicast_adr *cmd;
        int size;
+       int mc_count = 0;
+
+       if (mc_list)
+               mc_count = netdev_hw_addr_list_count(mc_list);
 
        if (allmulti || mc_count > priv->num_mcaddrs) {
                allmulti = 1;
@@ -1779,17 +1966,13 @@ __mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
        if (allmulti) {
                cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_ALL_MULTICAST);
        } else if (mc_count) {
-               int i;
+               struct netdev_hw_addr *ha;
+               int i = 0;
 
                cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
                cmd->numaddr = cpu_to_le16(mc_count);
-               for (i = 0; i < mc_count && mclist; i++) {
-                       if (mclist->da_addrlen != ETH_ALEN) {
-                               kfree(cmd);
-                               return NULL;
-                       }
-                       memcpy(cmd->addr[i], mclist->da_addr, ETH_ALEN);
-                       mclist = mclist->next;
+               netdev_hw_addr_list_for_each(ha, mc_list) {
+                       memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
                }
        }
 
@@ -1965,6 +2148,36 @@ mwl8k_cmd_rf_antenna(struct ieee80211_hw *hw, int antenna, int mask)
 }
 
 /*
+ * CMD_SET_BEACON.
+ */
+struct mwl8k_cmd_set_beacon {
+       struct mwl8k_cmd_pkt header;
+       __le16 beacon_len;
+       __u8 beacon[0];
+};
+
+static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
+                               struct ieee80211_vif *vif, u8 *beacon, int len)
+{
+       struct mwl8k_cmd_set_beacon *cmd;
+       int rc;
+
+       cmd = kzalloc(sizeof(*cmd) + len, GFP_KERNEL);
+       if (cmd == NULL)
+               return -ENOMEM;
+
+       cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_BEACON);
+       cmd->header.length = cpu_to_le16(sizeof(*cmd) + len);
+       cmd->beacon_len = cpu_to_le16(len);
+       memcpy(cmd->beacon, beacon, len);
+
+       rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
+       kfree(cmd);
+
+       return rc;
+}
+
+/*
  * CMD_SET_PRE_SCAN.
  */
 struct mwl8k_cmd_set_pre_scan {
@@ -2030,8 +2243,9 @@ struct mwl8k_cmd_set_rf_channel {
 } __attribute__((packed));
 
 static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
-                                   struct ieee80211_channel *channel)
+                                   struct ieee80211_conf *conf)
 {
+       struct ieee80211_channel *channel = conf->channel;
        struct mwl8k_cmd_set_rf_channel *cmd;
        int rc;
 
@@ -2043,10 +2257,19 @@ static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
        cmd->header.length = cpu_to_le16(sizeof(*cmd));
        cmd->action = cpu_to_le16(MWL8K_CMD_SET);
        cmd->current_channel = channel->hw_value;
+
        if (channel->band == IEEE80211_BAND_2GHZ)
-               cmd->channel_flags = cpu_to_le32(0x00000081);
-       else
-               cmd->channel_flags = cpu_to_le32(0x00000000);
+               cmd->channel_flags |= cpu_to_le32(0x00000001);
+       else if (channel->band == IEEE80211_BAND_5GHZ)
+               cmd->channel_flags |= cpu_to_le32(0x00000004);
+
+       if (conf->channel_type == NL80211_CHAN_NO_HT ||
+           conf->channel_type == NL80211_CHAN_HT20)
+               cmd->channel_flags |= cpu_to_le32(0x00000080);
+       else if (conf->channel_type == NL80211_CHAN_HT40MINUS)
+               cmd->channel_flags |= cpu_to_le32(0x000001900);
+       else if (conf->channel_type == NL80211_CHAN_HT40PLUS)
+               cmd->channel_flags |= cpu_to_le32(0x000000900);
 
        rc = mwl8k_post_cmd(hw, &cmd->header);
        kfree(cmd);
@@ -2084,7 +2307,7 @@ static void legacy_rate_mask_to_array(u8 *rates, u32 mask)
 
        for (i = 0, j = 0; i < 14; i++) {
                if (mask & (1 << i))
-                       rates[j++] = mwl8k_rates[i].hw_value;
+                       rates[j++] = mwl8k_rates_24[i].hw_value;
        }
 }
 
@@ -2145,7 +2368,7 @@ struct mwl8k_cmd_set_rate {
 
 static int
 mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                  u32 legacy_rate_mask)
+                  u32 legacy_rate_mask, u8 *mcs_rates)
 {
        struct mwl8k_cmd_set_rate *cmd;
        int rc;
@@ -2157,6 +2380,7 @@ mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
        cmd->header.length = cpu_to_le16(sizeof(*cmd));
        legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
+       memcpy(cmd->mcs_set, mcs_rates, 16);
 
        rc = mwl8k_post_cmd(hw, &cmd->header);
        kfree(cmd);
@@ -2214,8 +2438,8 @@ struct mwl8k_cmd_set_rts_threshold {
        __le16 threshold;
 } __attribute__((packed));
 
-static int mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw,
-                                      u16 action, u16 threshold)
+static int
+mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
 {
        struct mwl8k_cmd_set_rts_threshold *cmd;
        int rc;
@@ -2226,8 +2450,8 @@ static int mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw,
 
        cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
        cmd->header.length = cpu_to_le16(sizeof(*cmd));
-       cmd->action = cpu_to_le16(action);
-       cmd->threshold = cpu_to_le16(threshold);
+       cmd->action = cpu_to_le16(MWL8K_CMD_SET);
+       cmd->threshold = cpu_to_le16(rts_thresh);
 
        rc = mwl8k_post_cmd(hw, &cmd->header);
        kfree(cmd);
@@ -2327,12 +2551,6 @@ mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
        if (cmd == NULL)
                return -ENOMEM;
 
-       /*
-        * Queues 0 (BE) and 1 (BK) are swapped in hardware for
-        * this call.
-        */
-       qnum ^= !(qnum >> 1);
-
        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_EDCA_PARAMS);
        cmd->header.length = cpu_to_le16(sizeof(*cmd));
        cmd->action = cpu_to_le16(MWL8K_SET_EDCA_ALL);
@@ -2418,49 +2636,70 @@ static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
 }
 
 /*
- * CMD_USE_FIXED_RATE.
+ * CMD_USE_FIXED_RATE (STA version).
  */
-#define MWL8K_RATE_TABLE_SIZE  8
-#define MWL8K_UCAST_RATE       0
-#define MWL8K_USE_AUTO_RATE    0x0002
+struct mwl8k_cmd_use_fixed_rate_sta {
+       struct mwl8k_cmd_pkt header;
+       __le32 action;
+       __le32 allow_rate_drop;
+       __le32 num_rates;
+       struct {
+               __le32 is_ht_rate;
+               __le32 enable_retry;
+               __le32 rate;
+               __le32 retry_count;
+       } rate_entry[8];
+       __le32 rate_type;
+       __le32 reserved1;
+       __le32 reserved2;
+} __attribute__((packed));
 
-struct mwl8k_rate_entry {
-       /* Set to 1 if HT rate, 0 if legacy.  */
-       __le32  is_ht_rate;
+#define MWL8K_USE_AUTO_RATE    0x0002
+#define MWL8K_UCAST_RATE       0
 
-       /* Set to 1 to use retry_count field.  */
-       __le32  enable_retry;
+static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
+{
+       struct mwl8k_cmd_use_fixed_rate_sta *cmd;
+       int rc;
 
-       /* Specified legacy rate or MCS.  */
-       __le32  rate;
+       cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+       if (cmd == NULL)
+               return -ENOMEM;
 
-       /* Number of allowed retries.  */
-       __le32  retry_count;
-} __attribute__((packed));
+       cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE);
+       cmd->header.length = cpu_to_le16(sizeof(*cmd));
+       cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
+       cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
 
-struct mwl8k_rate_table {
-       /* 1 to allow specified rate and below */
-       __le32  allow_rate_drop;
-       __le32  num_rates;
-       struct mwl8k_rate_entry rate_entry[MWL8K_RATE_TABLE_SIZE];
-} __attribute__((packed));
+       rc = mwl8k_post_cmd(hw, &cmd->header);
+       kfree(cmd);
 
-struct mwl8k_cmd_use_fixed_rate {
-       struct  mwl8k_cmd_pkt header;
-       __le32  action;
-       struct mwl8k_rate_table rate_table;
+       return rc;
+}
 
-       /* Unicast, Broadcast or Multicast */
-       __le32  rate_type;
-       __le32  reserved1;
-       __le32  reserved2;
+/*
+ * CMD_USE_FIXED_RATE (AP version).
+ */
+struct mwl8k_cmd_use_fixed_rate_ap {
+       struct mwl8k_cmd_pkt header;
+       __le32 action;
+       __le32 allow_rate_drop;
+       __le32 num_rates;
+       struct mwl8k_rate_entry_ap {
+               __le32 is_ht_rate;
+               __le32 enable_retry;
+               __le32 rate;
+               __le32 retry_count;
+       } rate_entry[4];
+       u8 multicast_rate;
+       u8 multicast_rate_type;
+       u8 management_rate;
 } __attribute__((packed));
 
-static int mwl8k_cmd_use_fixed_rate(struct ieee80211_hw *hw,
-       u32 action, u32 rate_type, struct mwl8k_rate_table *rate_table)
+static int
+mwl8k_cmd_use_fixed_rate_ap(struct ieee80211_hw *hw, int mcast, int mgmt)
 {
-       struct mwl8k_cmd_use_fixed_rate *cmd;
-       int count;
+       struct mwl8k_cmd_use_fixed_rate_ap *cmd;
        int rc;
 
        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
@@ -2469,32 +2708,9 @@ static int mwl8k_cmd_use_fixed_rate(struct ieee80211_hw *hw,
 
        cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE);
        cmd->header.length = cpu_to_le16(sizeof(*cmd));
-
-       cmd->action = cpu_to_le32(action);
-       cmd->rate_type = cpu_to_le32(rate_type);
-
-       if (rate_table != NULL) {
-               /*
-                * Copy over each field manually so that endian
-                * conversion can be done.
-                */
-               cmd->rate_table.allow_rate_drop =
-                               cpu_to_le32(rate_table->allow_rate_drop);
-               cmd->rate_table.num_rates =
-                               cpu_to_le32(rate_table->num_rates);
-
-               for (count = 0; count < rate_table->num_rates; count++) {
-                       struct mwl8k_rate_entry *dst =
-                               &cmd->rate_table.rate_entry[count];
-                       struct mwl8k_rate_entry *src =
-                               &rate_table->rate_entry[count];
-
-                       dst->is_ht_rate = cpu_to_le32(src->is_ht_rate);
-                       dst->enable_retry = cpu_to_le32(src->enable_retry);
-                       dst->rate = cpu_to_le32(src->rate);
-                       dst->retry_count = cpu_to_le32(src->retry_count);
-               }
-       }
+       cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
+       cmd->multicast_rate = mcast;
+       cmd->management_rate = mgmt;
 
        rc = mwl8k_post_cmd(hw, &cmd->header);
        kfree(cmd);
@@ -2543,12 +2759,33 @@ struct mwl8k_cmd_set_mac_addr {
        };
 } __attribute__((packed));
 
-static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw, u8 *mac)
+#define MWL8K_MAC_TYPE_PRIMARY_CLIENT          0
+#define MWL8K_MAC_TYPE_SECONDARY_CLIENT                1
+#define MWL8K_MAC_TYPE_PRIMARY_AP              2
+#define MWL8K_MAC_TYPE_SECONDARY_AP            3
+
+static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
+                                 struct ieee80211_vif *vif, u8 *mac)
 {
        struct mwl8k_priv *priv = hw->priv;
+       struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
        struct mwl8k_cmd_set_mac_addr *cmd;
+       int mac_type;
        int rc;
 
+       mac_type = MWL8K_MAC_TYPE_PRIMARY_AP;
+       if (vif != NULL && vif->type == NL80211_IFTYPE_STATION) {
+               if (mwl8k_vif->macid + 1 == ffs(priv->sta_macids_supported))
+                       mac_type = MWL8K_MAC_TYPE_PRIMARY_CLIENT;
+               else
+                       mac_type = MWL8K_MAC_TYPE_SECONDARY_CLIENT;
+       } else if (vif != NULL && vif->type == NL80211_IFTYPE_AP) {
+               if (mwl8k_vif->macid + 1 == ffs(priv->ap_macids_supported))
+                       mac_type = MWL8K_MAC_TYPE_PRIMARY_AP;
+               else
+                       mac_type = MWL8K_MAC_TYPE_SECONDARY_AP;
+       }
+
        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
        if (cmd == NULL)
                return -ENOMEM;
@@ -2556,13 +2793,13 @@ static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw, u8 *mac)
        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_MAC_ADDR);
        cmd->header.length = cpu_to_le16(sizeof(*cmd));
        if (priv->ap_fw) {
-               cmd->mbss.mac_type = 0;
+               cmd->mbss.mac_type = cpu_to_le16(mac_type);
                memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
        } else {
                memcpy(cmd->mac_addr, mac, ETH_ALEN);
        }
 
-       rc = mwl8k_post_cmd(hw, &cmd->header);
+       rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
        kfree(cmd);
 
        return rc;
@@ -2598,6 +2835,143 @@ static int mwl8k_cmd_set_rateadapt_mode(struct ieee80211_hw *hw, __u16 mode)
 }
 
 /*
+ * CMD_BSS_START.
+ */
+struct mwl8k_cmd_bss_start {
+       struct mwl8k_cmd_pkt header;
+       __le32 enable;
+} __attribute__((packed));
+
+static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
+                              struct ieee80211_vif *vif, int enable)
+{
+       struct mwl8k_cmd_bss_start *cmd;
+       int rc;
+
+       cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+       if (cmd == NULL)
+               return -ENOMEM;
+
+       cmd->header.code = cpu_to_le16(MWL8K_CMD_BSS_START);
+       cmd->header.length = cpu_to_le16(sizeof(*cmd));
+       cmd->enable = cpu_to_le32(enable);
+
+       rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
+       kfree(cmd);
+
+       return rc;
+}
+
+/*
+ * CMD_SET_NEW_STN.
+ */
+struct mwl8k_cmd_set_new_stn {
+       struct mwl8k_cmd_pkt header;
+       __le16 aid;
+       __u8 mac_addr[6];
+       __le16 stn_id;
+       __le16 action;
+       __le16 rsvd;
+       __le32 legacy_rates;
+       __u8 ht_rates[4];
+       __le16 cap_info;
+       __le16 ht_capabilities_info;
+       __u8 mac_ht_param_info;
+       __u8 rev;
+       __u8 control_channel;
+       __u8 add_channel;
+       __le16 op_mode;
+       __le16 stbc;
+       __u8 add_qos_info;
+       __u8 is_qos_sta;
+       __le32 fw_sta_ptr;
+} __attribute__((packed));
+
+#define MWL8K_STA_ACTION_ADD           0
+#define MWL8K_STA_ACTION_REMOVE                2
+
+static int mwl8k_cmd_set_new_stn_add(struct ieee80211_hw *hw,
+                                    struct ieee80211_vif *vif,
+                                    struct ieee80211_sta *sta)
+{
+       struct mwl8k_cmd_set_new_stn *cmd;
+       u32 rates;
+       int rc;
+
+       cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+       if (cmd == NULL)
+               return -ENOMEM;
+
+       cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
+       cmd->header.length = cpu_to_le16(sizeof(*cmd));
+       cmd->aid = cpu_to_le16(sta->aid);
+       memcpy(cmd->mac_addr, sta->addr, ETH_ALEN);
+       cmd->stn_id = cpu_to_le16(sta->aid);
+       cmd->action = cpu_to_le16(MWL8K_STA_ACTION_ADD);
+       if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
+               rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
+       else
+               rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
+       cmd->legacy_rates = cpu_to_le32(rates);
+       if (sta->ht_cap.ht_supported) {
+               cmd->ht_rates[0] = sta->ht_cap.mcs.rx_mask[0];
+               cmd->ht_rates[1] = sta->ht_cap.mcs.rx_mask[1];
+               cmd->ht_rates[2] = sta->ht_cap.mcs.rx_mask[2];
+               cmd->ht_rates[3] = sta->ht_cap.mcs.rx_mask[3];
+               cmd->ht_capabilities_info = cpu_to_le16(sta->ht_cap.cap);
+               cmd->mac_ht_param_info = (sta->ht_cap.ampdu_factor & 3) |
+                       ((sta->ht_cap.ampdu_density & 7) << 2);
+               cmd->is_qos_sta = 1;
+       }
+
+       rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
+       kfree(cmd);
+
+       return rc;
+}
+
+static int mwl8k_cmd_set_new_stn_add_self(struct ieee80211_hw *hw,
+                                         struct ieee80211_vif *vif)
+{
+       struct mwl8k_cmd_set_new_stn *cmd;
+       int rc;
+
+       cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+       if (cmd == NULL)
+               return -ENOMEM;
+
+       cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
+       cmd->header.length = cpu_to_le16(sizeof(*cmd));
+       memcpy(cmd->mac_addr, vif->addr, ETH_ALEN);
+
+       rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
+       kfree(cmd);
+
+       return rc;
+}
+
+static int mwl8k_cmd_set_new_stn_del(struct ieee80211_hw *hw,
+                                    struct ieee80211_vif *vif, u8 *addr)
+{
+       struct mwl8k_cmd_set_new_stn *cmd;
+       int rc;
+
+       cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+       if (cmd == NULL)
+               return -ENOMEM;
+
+       cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
+       cmd->header.length = cpu_to_le16(sizeof(*cmd));
+       memcpy(cmd->mac_addr, addr, ETH_ALEN);
+       cmd->action = cpu_to_le16(MWL8K_STA_ACTION_REMOVE);
+
+       rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
+       kfree(cmd);
+
+       return rc;
+}
+
+/*
  * CMD_UPDATE_STADB.
  */
 struct ewc_ht_info {
@@ -2658,10 +3032,11 @@ struct mwl8k_cmd_update_stadb {
 
 static int mwl8k_cmd_update_stadb_add(struct ieee80211_hw *hw,
                                      struct ieee80211_vif *vif,
-                                     u8 *addr, u32 legacy_rate_mask)
+                                     struct ieee80211_sta *sta)
 {
        struct mwl8k_cmd_update_stadb *cmd;
        struct peer_capability_info *p;
+       u32 rates;
        int rc;
 
        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
@@ -2671,12 +3046,21 @@ static int mwl8k_cmd_update_stadb_add(struct ieee80211_hw *hw,
        cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB);
        cmd->header.length = cpu_to_le16(sizeof(*cmd));
        cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
-       memcpy(cmd->peer_addr, addr, ETH_ALEN);
+       memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
 
        p = &cmd->peer_info;
        p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
        p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
-       legacy_rate_mask_to_array(p->legacy_rates, legacy_rate_mask);
+       p->ht_support = sta->ht_cap.ht_supported;
+       p->ht_caps = sta->ht_cap.cap;
+       p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
+               ((sta->ht_cap.ampdu_density & 7) << 2);
+       if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
+               rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
+       else
+               rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
+       legacy_rate_mask_to_array(p->legacy_rates, rates);
+       memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
        p->interop = 1;
        p->amsdu_enabled = 0;
 
@@ -2718,19 +3102,22 @@ static irqreturn_t mwl8k_interrupt(int irq, void *dev_id)
        u32 status;
 
        status = ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
-       iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
-
        if (!status)
                return IRQ_NONE;
 
-       if (status & MWL8K_A2H_INT_TX_DONE)
-               tasklet_schedule(&priv->tx_reclaim_task);
+       if (status & MWL8K_A2H_INT_TX_DONE) {
+               status &= ~MWL8K_A2H_INT_TX_DONE;
+               tasklet_schedule(&priv->poll_tx_task);
+       }
 
        if (status & MWL8K_A2H_INT_RX_READY) {
-               while (rxq_process(hw, 0, 1))
-                       rxq_refill(hw, 0, 1);
+               status &= ~MWL8K_A2H_INT_RX_READY;
+               tasklet_schedule(&priv->poll_rx_task);
        }
 
+       if (status)
+               iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+
        if (status & MWL8K_A2H_INT_OPC_DONE) {
                if (priv->hostcmd_wait != NULL)
                        complete(priv->hostcmd_wait);
@@ -2745,6 +3132,53 @@ static irqreturn_t mwl8k_interrupt(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
 
+static void mwl8k_tx_poll(unsigned long data)
+{
+       struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
+       struct mwl8k_priv *priv = hw->priv;
+       int limit;
+       int i;
+
+       limit = 32;
+
+       spin_lock_bh(&priv->tx_lock);
+
+       for (i = 0; i < MWL8K_TX_QUEUES; i++)
+               limit -= mwl8k_txq_reclaim(hw, i, limit, 0);
+
+       if (!priv->pending_tx_pkts && priv->tx_wait != NULL) {
+               complete(priv->tx_wait);
+               priv->tx_wait = NULL;
+       }
+
+       spin_unlock_bh(&priv->tx_lock);
+
+       if (limit) {
+               writel(~MWL8K_A2H_INT_TX_DONE,
+                      priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+       } else {
+               tasklet_schedule(&priv->poll_tx_task);
+       }
+}
+
+static void mwl8k_rx_poll(unsigned long data)
+{
+       struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
+       struct mwl8k_priv *priv = hw->priv;
+       int limit;
+
+       limit = 32;
+       limit -= rxq_process(hw, 0, limit);
+       limit -= rxq_refill(hw, 0, limit);
+
+       if (limit) {
+               writel(~MWL8K_A2H_INT_RX_READY,
+                      priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+       } else {
+               tasklet_schedule(&priv->poll_rx_task);
+       }
+}
+
 
 /*
  * Core driver operations.
@@ -2755,7 +3189,7 @@ static int mwl8k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
        int index = skb_get_queue_mapping(skb);
        int rc;
 
-       if (priv->current_channel == NULL) {
+       if (!priv->radio_on) {
                printk(KERN_DEBUG "%s: dropped TX frame since radio "
                       "disabled\n", wiphy_name(hw->wiphy));
                dev_kfree_skb(skb);
@@ -2780,8 +3214,9 @@ static int mwl8k_start(struct ieee80211_hw *hw)
                return -EIO;
        }
 
-       /* Enable tx reclaim tasklet */
-       tasklet_enable(&priv->tx_reclaim_task);
+       /* Enable TX reclaim and RX tasklets.  */
+       tasklet_enable(&priv->poll_tx_task);
+       tasklet_enable(&priv->poll_rx_task);
 
        /* Enable interrupts */
        iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
@@ -2814,7 +3249,8 @@ static int mwl8k_start(struct ieee80211_hw *hw)
        if (rc) {
                iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
                free_irq(priv->pdev->irq, hw);
-               tasklet_disable(&priv->tx_reclaim_task);
+               tasklet_disable(&priv->poll_tx_task);
+               tasklet_disable(&priv->poll_rx_task);
        }
 
        return rc;
@@ -2838,36 +3274,27 @@ static void mwl8k_stop(struct ieee80211_hw *hw)
        if (priv->beacon_skb != NULL)
                dev_kfree_skb(priv->beacon_skb);
 
-       /* Stop tx reclaim tasklet */
-       tasklet_disable(&priv->tx_reclaim_task);
+       /* Stop TX reclaim and RX tasklets.  */
+       tasklet_disable(&priv->poll_tx_task);
+       tasklet_disable(&priv->poll_rx_task);
 
        /* Return all skbs to mac80211 */
        for (i = 0; i < MWL8K_TX_QUEUES; i++)
-               mwl8k_txq_reclaim(hw, i, 1);
+               mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
 }
 
 static int mwl8k_add_interface(struct ieee80211_hw *hw,
-                               struct ieee80211_vif *vif)
+                              struct ieee80211_vif *vif)
 {
        struct mwl8k_priv *priv = hw->priv;
        struct mwl8k_vif *mwl8k_vif;
-
-       /*
-        * We only support one active interface at a time.
-        */
-       if (priv->vif != NULL)
-               return -EBUSY;
-
-       /*
-        * We only support managed interfaces for now.
-        */
-       if (vif->type != NL80211_IFTYPE_STATION)
-               return -EINVAL;
+       u32 macids_supported;
+       int macid;
 
        /*
         * Reject interface creation if sniffer mode is active, as
         * STA operation is mutually exclusive with hardware sniffer
-        * mode.
+        * mode.  (Sniffer mode is only used on STA firmware.)
         */
        if (priv->sniffer_enabled) {
                printk(KERN_INFO "%s: unable to create STA "
@@ -2876,19 +3303,37 @@ static int mwl8k_add_interface(struct ieee80211_hw *hw,
                return -EINVAL;
        }
 
-       /* Clean out driver private area */
+
+       switch (vif->type) {
+       case NL80211_IFTYPE_AP:
+               macids_supported = priv->ap_macids_supported;
+               break;
+       case NL80211_IFTYPE_STATION:
+               macids_supported = priv->sta_macids_supported;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       macid = ffs(macids_supported & ~priv->macids_used);
+       if (!macid--)
+               return -EBUSY;
+
+       /* Setup driver private area. */
        mwl8k_vif = MWL8K_VIF(vif);
        memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
+       mwl8k_vif->vif = vif;
+       mwl8k_vif->macid = macid;
+       mwl8k_vif->seqno = 0;
 
-       /* Set and save the mac address */
-       mwl8k_cmd_set_mac_addr(hw, vif->addr);
-       memcpy(mwl8k_vif->mac_addr, vif->addr, ETH_ALEN);
+       /* Set the mac address.  */
+       mwl8k_cmd_set_mac_addr(hw, vif, vif->addr);
 
-       /* Set Initial sequence number to zero */
-       mwl8k_vif->seqno = 0;
+       if (priv->ap_fw)
+               mwl8k_cmd_set_new_stn_add_self(hw, vif);
 
-       priv->vif = vif;
-       priv->current_channel = NULL;
+       priv->macids_used |= 1 << mwl8k_vif->macid;
+       list_add_tail(&mwl8k_vif->list, &priv->vif_list);
 
        return 0;
 }
@@ -2897,13 +3342,15 @@ static void mwl8k_remove_interface(struct ieee80211_hw *hw,
                                   struct ieee80211_vif *vif)
 {
        struct mwl8k_priv *priv = hw->priv;
+       struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
 
-       if (priv->vif == NULL)
-               return;
+       if (priv->ap_fw)
+               mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);
 
-       mwl8k_cmd_set_mac_addr(hw, "\x00\x00\x00\x00\x00\x00");
+       mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
 
-       priv->vif = NULL;
+       priv->macids_used &= ~(1 << mwl8k_vif->macid);
+       list_del(&mwl8k_vif->list);
 }
 
 static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
@@ -2914,7 +3361,6 @@ static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
 
        if (conf->flags & IEEE80211_CONF_IDLE) {
                mwl8k_cmd_radio_disable(hw);
-               priv->current_channel = NULL;
                return 0;
        }
 
@@ -2926,12 +3372,10 @@ static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
        if (rc)
                goto out;
 
-       rc = mwl8k_cmd_set_rf_channel(hw, conf->channel);
+       rc = mwl8k_cmd_set_rf_channel(hw, conf);
        if (rc)
                goto out;
 
-       priv->current_channel = conf->channel;
-
        if (conf->power_level > 18)
                conf->power_level = 18;
        rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
@@ -2952,63 +3396,82 @@ out:
        return rc;
 }
 
-static void mwl8k_bss_info_changed(struct ieee80211_hw *hw,
-                                  struct ieee80211_vif *vif,
-                                  struct ieee80211_bss_conf *info,
-                                  u32 changed)
+static void
+mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                          struct ieee80211_bss_conf *info, u32 changed)
 {
        struct mwl8k_priv *priv = hw->priv;
+       u32 ap_legacy_rates;
+       u8 ap_mcs_rates[16];
        int rc;
 
-       if ((changed & BSS_CHANGED_ASSOC) == 0)
+       if (mwl8k_fw_lock(hw))
                return;
 
-       priv->capture_beacon = false;
-
-       rc = mwl8k_fw_lock(hw);
-       if (rc)
-               return;
+       /*
+        * No need to capture a beacon if we're no longer associated.
+        */
+       if ((changed & BSS_CHANGED_ASSOC) && !vif->bss_conf.assoc)
+               priv->capture_beacon = false;
 
+       /*
+        * Get the AP's legacy and MCS rates.
+        */
        if (vif->bss_conf.assoc) {
                struct ieee80211_sta *ap;
-               u32 legacy_rate_mask;
 
                rcu_read_lock();
-               ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
-               if (ap != NULL)
-                       legacy_rate_mask = ap->supp_rates[IEEE80211_BAND_2GHZ];
-               rcu_read_unlock();
 
-               if (ap == NULL)
+               ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
+               if (ap == NULL) {
+                       rcu_read_unlock();
                        goto out;
+               }
+
+               if (hw->conf.channel->band == IEEE80211_BAND_2GHZ) {
+                       ap_legacy_rates = ap->supp_rates[IEEE80211_BAND_2GHZ];
+               } else {
+                       ap_legacy_rates =
+                               ap->supp_rates[IEEE80211_BAND_5GHZ] << 5;
+               }
+               memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
+
+               rcu_read_unlock();
+       }
 
-               /* Install rates */
-               rc = mwl8k_cmd_set_rate(hw, vif, legacy_rate_mask);
+       if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
+               rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
                if (rc)
                        goto out;
 
-               /* Turn on rate adaptation */
-               rc = mwl8k_cmd_use_fixed_rate(hw, MWL8K_USE_AUTO_RATE,
-                       MWL8K_UCAST_RATE, NULL);
+               rc = mwl8k_cmd_use_fixed_rate_sta(hw);
                if (rc)
                        goto out;
+       }
 
-               /* Set radio preamble */
+       if (changed & BSS_CHANGED_ERP_PREAMBLE) {
                rc = mwl8k_set_radio_preamble(hw,
                                vif->bss_conf.use_short_preamble);
                if (rc)
                        goto out;
+       }
 
-               /* Set slot time */
+       if (changed & BSS_CHANGED_ERP_SLOT) {
                rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
                if (rc)
                        goto out;
+       }
 
-               /* Set AID */
-               rc = mwl8k_cmd_set_aid(hw, vif, legacy_rate_mask);
+       if (vif->bss_conf.assoc &&
+           (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
+                       BSS_CHANGED_HT))) {
+               rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
                if (rc)
                        goto out;
+       }
 
+       if (vif->bss_conf.assoc &&
+           (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
                /*
                 * Finalize the join.  Tell rx handler to process
                 * next beacon from our BSSID.
@@ -3021,8 +3484,74 @@ out:
        mwl8k_fw_unlock(hw);
 }
 
+static void
+mwl8k_bss_info_changed_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                         struct ieee80211_bss_conf *info, u32 changed)
+{
+       int rc;
+
+       if (mwl8k_fw_lock(hw))
+               return;
+
+       if (changed & BSS_CHANGED_ERP_PREAMBLE) {
+               rc = mwl8k_set_radio_preamble(hw,
+                               vif->bss_conf.use_short_preamble);
+               if (rc)
+                       goto out;
+       }
+
+       if (changed & BSS_CHANGED_BASIC_RATES) {
+               int idx;
+               int rate;
+
+               /*
+                * Use lowest supported basic rate for multicasts
+                * and management frames (such as probe responses --
+                * beacons will always go out at 1 Mb/s).
+                */
+               idx = ffs(vif->bss_conf.basic_rates);
+               if (idx)
+                       idx--;
+
+               if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
+                       rate = mwl8k_rates_24[idx].hw_value;
+               else
+                       rate = mwl8k_rates_50[idx].hw_value;
+
+               mwl8k_cmd_use_fixed_rate_ap(hw, rate, rate);
+       }
+
+       if (changed & (BSS_CHANGED_BEACON_INT | BSS_CHANGED_BEACON)) {
+               struct sk_buff *skb;
+
+               skb = ieee80211_beacon_get(hw, vif);
+               if (skb != NULL) {
+                       mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
+                       kfree_skb(skb);
+               }
+       }
+
+       if (changed & BSS_CHANGED_BEACON_ENABLED)
+               mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
+
+out:
+       mwl8k_fw_unlock(hw);
+}
+
+static void
+mwl8k_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                      struct ieee80211_bss_conf *info, u32 changed)
+{
+       struct mwl8k_priv *priv = hw->priv;
+
+       if (!priv->ap_fw)
+               mwl8k_bss_info_changed_sta(hw, vif, info, changed);
+       else
+               mwl8k_bss_info_changed_ap(hw, vif, info, changed);
+}
+
 static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
-                                  int mc_count, struct dev_addr_list *mclist)
+                                  struct netdev_hw_addr_list *mc_list)
 {
        struct mwl8k_cmd_pkt *cmd;
 
@@ -3033,7 +3562,7 @@ static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
         * we'll end up throwing this packet away and creating a new
         * one in mwl8k_configure_filter().
         */
-       cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_count, mclist);
+       cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
 
        return (unsigned long)cmd;
 }
@@ -3050,7 +3579,7 @@ mwl8k_configure_filter_sniffer(struct ieee80211_hw *hw,
         * operation, so refuse to enable sniffer mode if a STA
         * interface is active.
         */
-       if (priv->vif != NULL) {
+       if (!list_empty(&priv->vif_list)) {
                if (net_ratelimit())
                        printk(KERN_INFO "%s: not enabling sniffer "
                               "mode because STA interface is active\n",
@@ -3071,6 +3600,14 @@ mwl8k_configure_filter_sniffer(struct ieee80211_hw *hw,
        return 1;
 }
 
+static struct mwl8k_vif *mwl8k_first_vif(struct mwl8k_priv *priv)
+{
+       if (!list_empty(&priv->vif_list))
+               return list_entry(priv->vif_list.next, struct mwl8k_vif, list);
+
+       return NULL;
+}
+
 static void mwl8k_configure_filter(struct ieee80211_hw *hw,
                                   unsigned int changed_flags,
                                   unsigned int *total_flags,
@@ -3102,8 +3639,10 @@ static void mwl8k_configure_filter(struct ieee80211_hw *hw,
        /* Clear unsupported feature flags */
        *total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
 
-       if (mwl8k_fw_lock(hw))
+       if (mwl8k_fw_lock(hw)) {
+               kfree(cmd);
                return;
+       }
 
        if (priv->sniffer_enabled) {
                mwl8k_cmd_enable_sniffer(hw, 0);
@@ -3117,6 +3656,7 @@ static void mwl8k_configure_filter(struct ieee80211_hw *hw,
                         */
                        mwl8k_cmd_set_pre_scan(hw);
                } else {
+                       struct mwl8k_vif *mwl8k_vif;
                        const u8 *bssid;
 
                        /*
@@ -3127,9 +3667,11 @@ static void mwl8k_configure_filter(struct ieee80211_hw *hw,
                         * (where the OUI part needs to be nonzero for
                         * the BSSID to be accepted by POST_SCAN).
                         */
-                       bssid = "\x01\x00\x00\x00\x00\x00";
-                       if (priv->vif != NULL)
-                               bssid = priv->vif->bss_conf.bssid;
+                       mwl8k_vif = mwl8k_first_vif(priv);
+                       if (mwl8k_vif != NULL)
+                               bssid = mwl8k_vif->vif->bss_conf.bssid;
+                       else
+                               bssid = "\x01\x00\x00\x00\x00\x00";
 
                        mwl8k_cmd_set_post_scan(hw, bssid);
                }
@@ -3143,7 +3685,7 @@ static void mwl8k_configure_filter(struct ieee80211_hw *hw,
         */
        if (*total_flags & FIF_ALLMULTI) {
                kfree(cmd);
-               cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, 0, NULL);
+               cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
        }
 
        if (cmd != NULL) {
@@ -3156,82 +3698,39 @@ static void mwl8k_configure_filter(struct ieee80211_hw *hw,
 
 static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
 {
-       return mwl8k_cmd_set_rts_threshold(hw, MWL8K_CMD_SET, value);
+       return mwl8k_cmd_set_rts_threshold(hw, value);
 }
 
-struct mwl8k_sta_notify_item
+static int mwl8k_sta_remove(struct ieee80211_hw *hw,
+                           struct ieee80211_vif *vif,
+                           struct ieee80211_sta *sta)
 {
-       struct list_head list;
-       struct ieee80211_vif *vif;
-       enum sta_notify_cmd cmd;
-       u8 addr[ETH_ALEN];
-       u32 legacy_rate_mask;
-};
-
-static void mwl8k_sta_notify_worker(struct work_struct *work)
-{
-       struct mwl8k_priv *priv =
-               container_of(work, struct mwl8k_priv, sta_notify_worker);
-       struct ieee80211_hw *hw = priv->hw;
-
-       spin_lock_bh(&priv->sta_notify_list_lock);
-       while (!list_empty(&priv->sta_notify_list)) {
-               struct mwl8k_sta_notify_item *s;
-
-               s = list_entry(priv->sta_notify_list.next,
-                              struct mwl8k_sta_notify_item, list);
-               list_del(&s->list);
-
-               spin_unlock_bh(&priv->sta_notify_list_lock);
-
-               if (s->cmd == STA_NOTIFY_ADD) {
-                       int rc;
-
-                       rc = mwl8k_cmd_update_stadb_add(hw, s->vif,
-                                               s->addr, s->legacy_rate_mask);
-                       if (rc >= 0) {
-                               struct ieee80211_sta *sta;
-
-                               rcu_read_lock();
-                               sta = ieee80211_find_sta(s->vif, s->addr);
-                               if (sta != NULL)
-                                       MWL8K_STA(sta)->peer_id = rc;
-                               rcu_read_unlock();
-                       }
-               } else {
-                       mwl8k_cmd_update_stadb_del(hw, s->vif, s->addr);
-               }
-
-               kfree(s);
+       struct mwl8k_priv *priv = hw->priv;
 
-               spin_lock_bh(&priv->sta_notify_list_lock);
-       }
-       spin_unlock_bh(&priv->sta_notify_list_lock);
+       if (priv->ap_fw)
+               return mwl8k_cmd_set_new_stn_del(hw, vif, sta->addr);
+       else
+               return mwl8k_cmd_update_stadb_del(hw, vif, sta->addr);
 }
 
-static void
-mwl8k_sta_notify(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                enum sta_notify_cmd cmd, struct ieee80211_sta *sta)
+static int mwl8k_sta_add(struct ieee80211_hw *hw,
+                        struct ieee80211_vif *vif,
+                        struct ieee80211_sta *sta)
 {
        struct mwl8k_priv *priv = hw->priv;
-       struct mwl8k_sta_notify_item *s;
-
-       if (cmd != STA_NOTIFY_ADD && cmd != STA_NOTIFY_REMOVE)
-               return;
-
-       s = kmalloc(sizeof(*s), GFP_ATOMIC);
-       if (s != NULL) {
-               s->vif = vif;
-               s->cmd = cmd;
-               memcpy(s->addr, sta->addr, ETH_ALEN);
-               s->legacy_rate_mask = sta->supp_rates[IEEE80211_BAND_2GHZ];
+       int ret;
 
-               spin_lock(&priv->sta_notify_list_lock);
-               list_add_tail(&s->list, &priv->sta_notify_list);
-               spin_unlock(&priv->sta_notify_list_lock);
+       if (!priv->ap_fw) {
+               ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
+               if (ret >= 0) {
+                       MWL8K_STA(sta)->peer_id = ret;
+                       return 0;
+               }
 
-               ieee80211_queue_work(hw, &priv->sta_notify_worker);
+               return ret;
        }
+
+       return mwl8k_cmd_set_new_stn_add(hw, vif, sta);
 }
 
 static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
@@ -3258,30 +3757,28 @@ static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
        return rc;
 }
 
-static int mwl8k_get_tx_stats(struct ieee80211_hw *hw,
-                             struct ieee80211_tx_queue_stats *stats)
-{
-       struct mwl8k_priv *priv = hw->priv;
-       struct mwl8k_tx_queue *txq;
-       int index;
-
-       spin_lock_bh(&priv->tx_lock);
-       for (index = 0; index < MWL8K_TX_QUEUES; index++) {
-               txq = priv->txq + index;
-               memcpy(&stats[index], &txq->stats,
-                       sizeof(struct ieee80211_tx_queue_stats));
-       }
-       spin_unlock_bh(&priv->tx_lock);
-
-       return 0;
-}
-
 static int mwl8k_get_stats(struct ieee80211_hw *hw,
                           struct ieee80211_low_level_stats *stats)
 {
        return mwl8k_cmd_get_stat(hw, stats);
 }
 
+static int
+mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                  enum ieee80211_ampdu_mlme_action action,
+                  struct ieee80211_sta *sta, u16 tid, u16 *ssn)
+{
+       switch (action) {
+       case IEEE80211_AMPDU_RX_START:
+       case IEEE80211_AMPDU_RX_STOP:
+               if (!(hw->flags & IEEE80211_HW_AMPDU_AGGREGATION))
+                       return -ENOTSUPP;
+               return 0;
+       default:
+               return -ENOTSUPP;
+       }
+}
+
 static const struct ieee80211_ops mwl8k_ops = {
        .tx                     = mwl8k_tx,
        .start                  = mwl8k_start,
@@ -3293,48 +3790,45 @@ static const struct ieee80211_ops mwl8k_ops = {
        .prepare_multicast      = mwl8k_prepare_multicast,
        .configure_filter       = mwl8k_configure_filter,
        .set_rts_threshold      = mwl8k_set_rts_threshold,
-       .sta_notify             = mwl8k_sta_notify,
+       .sta_add                = mwl8k_sta_add,
+       .sta_remove             = mwl8k_sta_remove,
        .conf_tx                = mwl8k_conf_tx,
-       .get_tx_stats           = mwl8k_get_tx_stats,
        .get_stats              = mwl8k_get_stats,
+       .ampdu_action           = mwl8k_ampdu_action,
 };
 
-static void mwl8k_tx_reclaim_handler(unsigned long data)
-{
-       int i;
-       struct ieee80211_hw *hw = (struct ieee80211_hw *) data;
-       struct mwl8k_priv *priv = hw->priv;
-
-       spin_lock_bh(&priv->tx_lock);
-       for (i = 0; i < MWL8K_TX_QUEUES; i++)
-               mwl8k_txq_reclaim(hw, i, 0);
-
-       if (priv->tx_wait != NULL && !priv->pending_tx_pkts) {
-               complete(priv->tx_wait);
-               priv->tx_wait = NULL;
-       }
-       spin_unlock_bh(&priv->tx_lock);
-}
-
 static void mwl8k_finalize_join_worker(struct work_struct *work)
 {
        struct mwl8k_priv *priv =
                container_of(work, struct mwl8k_priv, finalize_join_worker);
        struct sk_buff *skb = priv->beacon_skb;
+       struct ieee80211_mgmt *mgmt = (void *)skb->data;
+       int len = skb->len - offsetof(struct ieee80211_mgmt, u.beacon.variable);
+       const u8 *tim = cfg80211_find_ie(WLAN_EID_TIM,
+                                        mgmt->u.beacon.variable, len);
+       int dtim_period = 1;
 
-       mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len,
-                               priv->vif->bss_conf.dtim_period);
-       dev_kfree_skb(skb);
+       if (tim && tim[1] >= 2)
+               dtim_period = tim[3];
+
+       mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
 
+       dev_kfree_skb(skb);
        priv->beacon_skb = NULL;
 }
 
 enum {
-       MWL8687 = 0,
+       MWL8363 = 0,
+       MWL8687,
        MWL8366,
 };
 
 static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
+       [MWL8363] = {
+               .part_name      = "88w8363",
+               .helper_image   = "mwl8k/helper_8363.fw",
+               .fw_image       = "mwl8k/fmimage_8363.fw",
+       },
        [MWL8687] = {
                .part_name      = "88w8687",
                .helper_image   = "mwl8k/helper_8687.fw",
@@ -3348,10 +3842,21 @@ static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
        },
 };
 
+MODULE_FIRMWARE("mwl8k/helper_8363.fw");
+MODULE_FIRMWARE("mwl8k/fmimage_8363.fw");
+MODULE_FIRMWARE("mwl8k/helper_8687.fw");
+MODULE_FIRMWARE("mwl8k/fmimage_8687.fw");
+MODULE_FIRMWARE("mwl8k/helper_8366.fw");
+MODULE_FIRMWARE("mwl8k/fmimage_8366.fw");
+
 static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
+       { PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, },
+       { PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
+       { PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
        { PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
        { PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
        { PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
+       { PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
        { },
 };
 MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);
@@ -3466,17 +3971,6 @@ static int __devinit mwl8k_probe(struct pci_dev *pdev,
        priv->pending_tx_pkts = 0;
 
 
-       memcpy(priv->channels, mwl8k_channels, sizeof(mwl8k_channels));
-       priv->band.band = IEEE80211_BAND_2GHZ;
-       priv->band.channels = priv->channels;
-       priv->band.n_channels = ARRAY_SIZE(mwl8k_channels);
-       priv->band.bitrates = priv->rates;
-       priv->band.n_bitrates = ARRAY_SIZE(mwl8k_rates);
-       hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
-
-       BUILD_BUG_ON(sizeof(priv->rates) != sizeof(mwl8k_rates));
-       memcpy(priv->rates, mwl8k_rates, sizeof(mwl8k_rates));
-
        /*
         * Extra headroom is the size of the required DMA header
         * minus the size of the smallest 802.11 frame (CTS frame).
@@ -3488,28 +3982,26 @@ static int __devinit mwl8k_probe(struct pci_dev *pdev,
 
        hw->queues = MWL8K_TX_QUEUES;
 
-       /* Set rssi and noise values to dBm */
-       hw->flags |= IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_NOISE_DBM;
+       /* Set rssi values to dBm */
+       hw->flags |= IEEE80211_HW_SIGNAL_DBM;
        hw->vif_data_size = sizeof(struct mwl8k_vif);
        hw->sta_data_size = sizeof(struct mwl8k_sta);
-       priv->vif = NULL;
+
+       priv->macids_used = 0;
+       INIT_LIST_HEAD(&priv->vif_list);
 
        /* Set default radio state and preamble */
        priv->radio_on = 0;
        priv->radio_short_preamble = 0;
 
-       /* Station database handling */
-       INIT_WORK(&priv->sta_notify_worker, mwl8k_sta_notify_worker);
-       spin_lock_init(&priv->sta_notify_list_lock);
-       INIT_LIST_HEAD(&priv->sta_notify_list);
-
        /* Finalize join worker */
        INIT_WORK(&priv->finalize_join_worker, mwl8k_finalize_join_worker);
 
-       /* TX reclaim tasklet */
-       tasklet_init(&priv->tx_reclaim_task,
-                       mwl8k_tx_reclaim_handler, (unsigned long)hw);
-       tasklet_disable(&priv->tx_reclaim_task);
+       /* TX reclaim and RX tasklets.  */
+       tasklet_init(&priv->poll_tx_task, mwl8k_tx_poll, (unsigned long)hw);
+       tasklet_disable(&priv->poll_tx_task);
+       tasklet_init(&priv->poll_rx_task, mwl8k_rx_poll, (unsigned long)hw);
+       tasklet_disable(&priv->poll_rx_task);
 
        /* Power management cookie */
        priv->cookie = pci_alloc_consistent(priv->pdev, 4, &priv->cookie_dma);
@@ -3538,7 +4030,8 @@ static int __devinit mwl8k_probe(struct pci_dev *pdev,
 
        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
-       iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
+       iowrite32(MWL8K_A2H_INT_TX_DONE | MWL8K_A2H_INT_RX_READY,
+                 priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
        iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);
 
        rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
@@ -3551,7 +4044,7 @@ static int __devinit mwl8k_probe(struct pci_dev *pdev,
 
        /*
         * Temporarily enable interrupts.  Initial firmware host
-        * commands use interrupts and avoids polling.  Disable
+        * commands use interrupts and avoid polling.  Disable
         * interrupts when done.
         */
        iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
@@ -3563,8 +4056,6 @@ static int __devinit mwl8k_probe(struct pci_dev *pdev,
                        rc = mwl8k_cmd_set_hw_spec(hw);
        } else {
                rc = mwl8k_cmd_get_hw_spec_sta(hw);
-
-               hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
        }
        if (rc) {
                printk(KERN_ERR "%s: Cannot initialise firmware\n",
@@ -3572,6 +4063,13 @@ static int __devinit mwl8k_probe(struct pci_dev *pdev,
                goto err_free_irq;
        }
 
+       hw->wiphy->interface_modes = 0;
+       if (priv->ap_macids_supported)
+               hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP);
+       if (priv->sta_macids_supported)
+               hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_STATION);
+
+
        /* Turn radio off */
        rc = mwl8k_cmd_radio_disable(hw);
        if (rc) {
@@ -3580,7 +4078,7 @@ static int __devinit mwl8k_probe(struct pci_dev *pdev,
        }
 
        /* Clear MAC address */
-       rc = mwl8k_cmd_set_mac_addr(hw, "\x00\x00\x00\x00\x00\x00");
+       rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
        if (rc) {
                printk(KERN_ERR "%s: Cannot clear MAC address\n",
                       wiphy_name(hw->wiphy));
@@ -3663,15 +4161,16 @@ static void __devexit mwl8k_remove(struct pci_dev *pdev)
 
        ieee80211_unregister_hw(hw);
 
-       /* Remove tx reclaim tasklet */
-       tasklet_kill(&priv->tx_reclaim_task);
+       /* Remove TX reclaim and RX tasklets.  */
+       tasklet_kill(&priv->poll_tx_task);
+       tasklet_kill(&priv->poll_rx_task);
 
        /* Stop hardware */
        mwl8k_hw_reset(priv);
 
        /* Return all skbs to mac80211 */
        for (i = 0; i < MWL8K_TX_QUEUES; i++)
-               mwl8k_txq_reclaim(hw, i, 1);
+               mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
 
        for (i = 0; i < MWL8K_TX_QUEUES; i++)
                mwl8k_txq_deinit(hw, i);