Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

69 files changed, 11564 insertions, 15772 deletions

diff --git a/drivers/net/wireless/wl12xx/Kconfig b/drivers/net/wireless/wl12xx/Kconfig
index 2f98058be451..35ce7b0f4a60 100644
--- a/drivers/net/wireless/wl12xx/Kconfig
+++ b/drivers/net/wireless/wl12xx/Kconfig
@@ -1,77 +1,68 @@
-menuconfig WL12XX
+menuconfig WL12XX_MENU
         tristate "TI wl12xx driver support"
         depends on MAC80211 && EXPERIMENTAL
         ---help---
-          This will enable TI wl12xx driver support. The drivers make
-          use of the mac80211 stack.
+          This will enable TI wl12xx driver support for the following chips:
+          wl1271, wl1273, wl1281 and wl1283.
+          The drivers make use of the mac80211 stack.
 
-config WL1251
-        tristate "TI wl1251 support"
-        depends on WL12XX && GENERIC_HARDIRQS
-        select FW_LOADER
-        select CRC7
-        ---help---
-          This module adds support for wireless adapters based on
-          TI wl1251 chipset.
-
-          If you choose to build a module, it'll be called wl1251. Say
-          N if unsure.
-
-config WL1251_SPI
-        tristate "TI wl1251 SPI support"
-        depends on WL1251 && SPI_MASTER
-        ---help---
-          This module adds support for the SPI interface of adapters using
-          TI wl1251 chipset.  Select this if your platform is using
-          the SPI bus.
-
-          If you choose to build a module, it'll be called wl1251_spi.
-          Say N if unsure.
-
-config WL1251_SDIO
-        tristate "TI wl1251 SDIO support"
-        depends on WL1251 && MMC
-        ---help---
-          This module adds support for the SDIO interface of adapters using
-          TI wl1251 chipset.  Select this if your platform is using
-          the SDIO bus.
-
-          If you choose to build a module, it'll be called
-          wl1251_sdio. Say N if unsure.
-
-config WL1271
-        tristate "TI wl1271 support"
-        depends on WL12XX && GENERIC_HARDIRQS
+config WL12XX
+        tristate "TI wl12xx support"
+        depends on WL12XX_MENU && GENERIC_HARDIRQS
         depends on INET
         select FW_LOADER
         select CRC7
         ---help---
-          This module adds support for wireless adapters based on the
-          TI wl1271 chipset.
+          This module adds support for wireless adapters based on TI wl1271 and
+          TI wl1273 chipsets. This module does *not* include support for wl1251.
+          For wl1251 support, use the separate homonymous driver instead.
 
-          If you choose to build a module, it'll be called wl1271. Say N if
+          If you choose to build a module, it will be called wl12xx. Say N if
           unsure.
 
-config WL1271_SPI
-        tristate "TI wl1271 SPI support"
-        depends on WL1271 && SPI_MASTER
+config WL12XX_HT
+        bool "TI wl12xx 802.11 HT support (EXPERIMENTAL)"
+        depends on WL12XX && EXPERIMENTAL
+        default n
+        ---help---
+          This will enable 802.11 HT support in the wl12xx module.
+
+          That configuration is temporary due to the code incomplete and
+          still in testing process.
+
+config WL12XX_SPI
+        tristate "TI wl12xx SPI support"
+        depends on WL12XX && SPI_MASTER
         ---help---
           This module adds support for the SPI interface of adapters using
-          TI wl1271 chipset.  Select this if your platform is using
+          TI wl12xx chipsets.  Select this if your platform is using
           the SPI bus.
 
-          If you choose to build a module, it'll be called wl1251_spi.
+          If you choose to build a module, it'll be called wl12xx_spi.
           Say N if unsure.
 
-config WL1271_SDIO
-        tristate "TI wl1271 SDIO support"
-        depends on WL1271 && MMC
+config WL12XX_SDIO
+        tristate "TI wl12xx SDIO support"
+        depends on WL12XX && MMC
         ---help---
           This module adds support for the SDIO interface of adapters using
-          TI wl1271 chipset.  Select this if your platform is using
+          TI wl12xx chipsets.  Select this if your platform is using
           the SDIO bus.
 
-          If you choose to build a module, it'll be called
-          wl1271_sdio. Say N if unsure.
+          If you choose to build a module, it'll be called wl12xx_sdio.
+          Say N if unsure.
 
+config WL12XX_SDIO_TEST
+        tristate "TI wl12xx SDIO testing support"
+        depends on WL12XX && MMC && WL12XX_SDIO
+        default n
+        ---help---
+          This module adds support for the SDIO bus testing with the
+          TI wl12xx chipsets.  You probably don't want this unless you are
+          testing a new hardware platform.  Select this if you want to test the
+          SDIO bus which is connected to the wl12xx chip.
 
+config WL12XX_PLATFORM_DATA
+        bool
+        depends on WL12XX_SDIO != n || WL1251_SDIO != n
+        default y
diff --git a/drivers/net/wireless/wl12xx/Makefile b/drivers/net/wireless/wl12xx/Makefile
index 078b4398ac1f..521c0414e52e 100644
--- a/drivers/net/wireless/wl12xx/Makefile
+++ b/drivers/net/wireless/wl12xx/Makefile
@@ -1,18 +1,16 @@
-wl1251-objs             = wl1251_main.o wl1251_event.o \
-                          wl1251_tx.o wl1251_rx.o wl1251_ps.o wl1251_cmd.o \
-                          wl1251_acx.o wl1251_boot.o wl1251_init.o \
-                          wl1251_debugfs.o wl1251_io.o
+wl12xx-objs             = main.o cmd.o io.o event.o tx.o rx.o ps.o acx.o \
+                          boot.o init.o debugfs.o scan.o
 
-obj-$(CONFIG_WL1251)    += wl1251.o
-obj-$(CONFIG_WL1251_SPI)        += wl1251_spi.o
-obj-$(CONFIG_WL1251_SDIO)       += wl1251_sdio.o
+wl12xx_spi-objs = spi.o
+wl12xx_sdio-objs        = sdio.o
+wl12xx_sdio_test-objs = sdio_test.o
 
-wl1271-objs             = wl1271_main.o  wl1271_cmd.o wl1271_io.o \
-                          wl1271_event.o wl1271_tx.o  wl1271_rx.o   \
-                          wl1271_ps.o    wl1271_acx.o wl1271_boot.o \
-                          wl1271_init.o  wl1271_debugfs.o wl1271_scan.o
+wl12xx-$(CONFIG_NL80211_TESTMODE)       += testmode.o
+obj-$(CONFIG_WL12XX)                    += wl12xx.o
+obj-$(CONFIG_WL12XX_SPI)                += wl12xx_spi.o
+obj-$(CONFIG_WL12XX_SDIO)               += wl12xx_sdio.o
 
-wl1271-$(CONFIG_NL80211_TESTMODE)       += wl1271_testmode.o
-obj-$(CONFIG_WL1271)    += wl1271.o
-obj-$(CONFIG_WL1271_SPI)        += wl1271_spi.o
-obj-$(CONFIG_WL1271_SDIO)       += wl1271_sdio.o
+obj-$(CONFIG_WL12XX_SDIO_TEST)  += wl12xx_sdio_test.o
+
+# small builtin driver bit
+obj-$(CONFIG_WL12XX_PLATFORM_DATA)      += wl12xx_platform_data.o
diff --git a/drivers/net/wireless/wl12xx/wl1271_acx.c b/drivers/net/wireless/wl12xx/acx.c
index bb245f05af49..c6ee530e5bf7 100644
--- a/drivers/net/wireless/wl12xx/wl1271_acx.c
+++ b/drivers/net/wireless/wl12xx/acx.c
@@ -21,7 +21,7 @@
  *
  */
 
-#include "wl1271_acx.h"
+#include "acx.h"
 
 #include <linux/module.h>
 #include <linux/platform_device.h>
@@ -29,10 +29,10 @@
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 
-#include "wl1271.h"
+#include "wl12xx.h"
 #include "wl12xx_80211.h"
-#include "wl1271_reg.h"
-#include "wl1271_ps.h"
+#include "reg.h"
+#include "ps.h"
 
 int wl1271_acx_wake_up_conditions(struct wl1271 *wl)
 {
@@ -86,40 +86,6 @@ out:
         return ret;
 }
 
-int wl1271_acx_fw_version(struct wl1271 *wl, char *buf, size_t len)
-{
-        struct acx_revision *rev;
-        int ret;
-
-        wl1271_debug(DEBUG_ACX, "acx fw rev");
-
-        rev = kzalloc(sizeof(*rev), GFP_KERNEL);
-        if (!rev) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = wl1271_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
-        if (ret < 0) {
-                wl1271_warning("ACX_FW_REV interrogate failed");
-                goto out;
-        }
-
-        /* be careful with the buffer sizes */
-        strncpy(buf, rev->fw_version, min(len, sizeof(rev->fw_version)));
-
-        /*
-         * if the firmware version string is exactly
-         * sizeof(rev->fw_version) long or fw_len is less than
-         * sizeof(rev->fw_version) it won't be null terminated
-         */
-        buf[min(len, sizeof(rev->fw_version)) - 1] = '\0';
-
-out:
-        kfree(rev);
-        return ret;
-}
-
 int wl1271_acx_tx_power(struct wl1271 *wl, int power)
 {
         struct acx_current_tx_power *acx;
@@ -269,7 +235,7 @@ int wl1271_acx_pd_threshold(struct wl1271 *wl)
 
 out:
         kfree(pd);
-        return 0;
+        return ret;
 }
 
 int wl1271_acx_slot(struct wl1271 *wl, enum acx_slot_type slot_time)
@@ -359,12 +325,19 @@ out:
         return ret;
 }
 
-int wl1271_acx_rts_threshold(struct wl1271 *wl, u16 rts_threshold)
+int wl1271_acx_rts_threshold(struct wl1271 *wl, u32 rts_threshold)
 {
         struct acx_rts_threshold *rts;
         int ret;
 
-        wl1271_debug(DEBUG_ACX, "acx rts threshold");
+        /*
+         * If the RTS threshold is not configured or out of range, use the
+         * default value.
+         */
+        if (rts_threshold > IEEE80211_MAX_RTS_THRESHOLD)
+                rts_threshold = wl->conf.rx.rts_threshold;
+
+        wl1271_debug(DEBUG_ACX, "acx rts threshold: %d", rts_threshold);
 
         rts = kzalloc(sizeof(*rts), GFP_KERNEL);
         if (!rts) {
@@ -372,7 +345,7 @@ int wl1271_acx_rts_threshold(struct wl1271 *wl, u16 rts_threshold)
                 goto out;
         }
 
-        rts->threshold = cpu_to_le16(rts_threshold);
+        rts->threshold = cpu_to_le16((u16)rts_threshold);
 
         ret = wl1271_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
         if (ret < 0) {
@@ -574,13 +547,13 @@ out:
         return ret;
 }
 
-int wl1271_acx_sg_cfg(struct wl1271 *wl)
+int wl1271_acx_sta_sg_cfg(struct wl1271 *wl)
 {
-        struct acx_bt_wlan_coex_param *param;
+        struct acx_sta_bt_wlan_coex_param *param;
         struct conf_sg_settings *c = &wl->conf.sg;
         int i, ret;
 
-        wl1271_debug(DEBUG_ACX, "acx sg cfg");
+        wl1271_debug(DEBUG_ACX, "acx sg sta cfg");
 
         param = kzalloc(sizeof(*param), GFP_KERNEL);
         if (!param) {
@@ -589,8 +562,38 @@ int wl1271_acx_sg_cfg(struct wl1271 *wl)
         }
 
         /* BT-WLAN coext parameters */
-        for (i = 0; i < CONF_SG_PARAMS_MAX; i++)
-                param->params[i] = cpu_to_le32(c->params[i]);
+        for (i = 0; i < CONF_SG_STA_PARAMS_MAX; i++)
+                param->params[i] = cpu_to_le32(c->sta_params[i]);
+        param->param_idx = CONF_SG_PARAMS_ALL;
+
+        ret = wl1271_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
+        if (ret < 0) {
+                wl1271_warning("failed to set sg config: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(param);
+        return ret;
+}
+
+int wl1271_acx_ap_sg_cfg(struct wl1271 *wl)
+{
+        struct acx_ap_bt_wlan_coex_param *param;
+        struct conf_sg_settings *c = &wl->conf.sg;
+        int i, ret;
+
+        wl1271_debug(DEBUG_ACX, "acx sg ap cfg");
+
+        param = kzalloc(sizeof(*param), GFP_KERNEL);
+        if (!param) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* BT-WLAN coext parameters */
+        for (i = 0; i < CONF_SG_AP_PARAMS_MAX; i++)
+                param->params[i] = cpu_to_le32(c->ap_params[i]);
         param->param_idx = CONF_SG_PARAMS_ALL;
 
         ret = wl1271_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
@@ -785,10 +788,10 @@ int wl1271_acx_statistics(struct wl1271 *wl, struct acx_statistics *stats)
         return 0;
 }
 
-int wl1271_acx_rate_policies(struct wl1271 *wl)
+int wl1271_acx_sta_rate_policies(struct wl1271 *wl)
 {
-        struct acx_rate_policy *acx;
-        struct conf_tx_rate_class *c = &wl->conf.tx.rc_conf;
+        struct acx_sta_rate_policy *acx;
+        struct conf_tx_rate_class *c = &wl->conf.tx.sta_rc_conf;
         int idx = 0;
         int ret = 0;
 
@@ -817,6 +820,10 @@ int wl1271_acx_rate_policies(struct wl1271 *wl)
 
         acx->rate_class_cnt = cpu_to_le32(ACX_TX_RATE_POLICY_CNT);
 
+        wl1271_debug(DEBUG_ACX, "basic_rate: 0x%x, full_rate: 0x%x",
+                acx->rate_class[ACX_TX_BASIC_RATE].enabled_rates,
+                acx->rate_class[ACX_TX_AP_FULL_RATE].enabled_rates);
+
         ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
         if (ret < 0) {
                 wl1271_warning("Setting of rate policies failed: %d", ret);
@@ -828,6 +835,39 @@ out:
         return ret;
 }
 
+int wl1271_acx_ap_rate_policy(struct wl1271 *wl, struct conf_tx_rate_class *c,
+                      u8 idx)
+{
+        struct acx_ap_rate_policy *acx;
+        int ret = 0;
+
+        wl1271_debug(DEBUG_ACX, "acx ap rate policy %d rates 0x%x",
+                     idx, c->enabled_rates);
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        acx->rate_policy.enabled_rates = cpu_to_le32(c->enabled_rates);
+        acx->rate_policy.short_retry_limit = c->short_retry_limit;
+        acx->rate_policy.long_retry_limit = c->long_retry_limit;
+        acx->rate_policy.aflags = c->aflags;
+
+        acx->rate_policy_idx = cpu_to_le32(idx);
+
+        ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("Setting of ap rate policy failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
 int wl1271_acx_ac_cfg(struct wl1271 *wl, u8 ac, u8 cw_min, u16 cw_max,
                       u8 aifsn, u16 txop)
 {
@@ -896,12 +936,19 @@ out:
         return ret;
 }
 
-int wl1271_acx_frag_threshold(struct wl1271 *wl)
+int wl1271_acx_frag_threshold(struct wl1271 *wl, u32 frag_threshold)
 {
         struct acx_frag_threshold *acx;
         int ret = 0;
 
-        wl1271_debug(DEBUG_ACX, "acx frag threshold");
+        /*
+         * If the fragmentation is not configured or out of range, use the
+         * default value.
+         */
+        if (frag_threshold > IEEE80211_MAX_FRAG_THRESHOLD)
+                frag_threshold = wl->conf.tx.frag_threshold;
+
+        wl1271_debug(DEBUG_ACX, "acx frag threshold: %d", frag_threshold);
 
         acx = kzalloc(sizeof(*acx), GFP_KERNEL);
 
@@ -910,7 +957,7 @@ int wl1271_acx_frag_threshold(struct wl1271 *wl)
                 goto out;
         }
 
-        acx->frag_threshold = cpu_to_le16(wl->conf.tx.frag_threshold);
+        acx->frag_threshold = cpu_to_le16((u16)frag_threshold);
         ret = wl1271_cmd_configure(wl, ACX_FRAG_CFG, acx, sizeof(*acx));
         if (ret < 0) {
                 wl1271_warning("Setting of frag threshold failed: %d", ret);
@@ -949,9 +996,10 @@ out:
         return ret;
 }
 
-int wl1271_acx_mem_cfg(struct wl1271 *wl)
+int wl1271_acx_ap_mem_cfg(struct wl1271 *wl)
 {
-        struct wl1271_acx_config_memory *mem_conf;
+        struct wl1271_acx_ap_config_memory *mem_conf;
+        struct conf_memory_settings *mem;
         int ret;
 
         wl1271_debug(DEBUG_ACX, "wl1271 mem cfg");
@@ -962,11 +1010,21 @@ int wl1271_acx_mem_cfg(struct wl1271 *wl)
                 goto out;
         }
 
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                /*
+                 * FIXME: The 128x AP FW does not yet support dynamic memory.
+                 * Use the base memory configuration for 128x for now. This
+                 * should be fine tuned in the future.
+                 */
+                mem = &wl->conf.mem_wl128x;
+        else
+                mem = &wl->conf.mem_wl127x;
+
         /* memory config */
-        mem_conf->num_stations = DEFAULT_NUM_STATIONS;
-        mem_conf->rx_mem_block_num = ACX_RX_MEM_BLOCKS;
-        mem_conf->tx_min_mem_block_num = ACX_TX_MIN_MEM_BLOCKS;
-        mem_conf->num_ssid_profiles = ACX_NUM_SSID_PROFILES;
+        mem_conf->num_stations = mem->num_stations;
+        mem_conf->rx_mem_block_num = mem->rx_block_num;
+        mem_conf->tx_min_mem_block_num = mem->tx_min_block_num;
+        mem_conf->num_ssid_profiles = mem->ssid_profiles;
         mem_conf->total_tx_descriptors = cpu_to_le32(ACX_TX_DESCRIPTORS);
 
         ret = wl1271_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
@@ -981,13 +1039,77 @@ out:
         return ret;
 }
 
-int wl1271_acx_init_mem_config(struct wl1271 *wl)
+int wl1271_acx_sta_mem_cfg(struct wl1271 *wl)
 {
+        struct wl1271_acx_sta_config_memory *mem_conf;
+        struct conf_memory_settings *mem;
         int ret;
 
-        ret = wl1271_acx_mem_cfg(wl);
-        if (ret < 0)
-                return ret;
+        wl1271_debug(DEBUG_ACX, "wl1271 mem cfg");
+
+        mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
+        if (!mem_conf) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                mem = &wl->conf.mem_wl128x;
+        else
+                mem = &wl->conf.mem_wl127x;
+
+        /* memory config */
+        mem_conf->num_stations = mem->num_stations;
+        mem_conf->rx_mem_block_num = mem->rx_block_num;
+        mem_conf->tx_min_mem_block_num = mem->tx_min_block_num;
+        mem_conf->num_ssid_profiles = mem->ssid_profiles;
+        mem_conf->total_tx_descriptors = cpu_to_le32(ACX_TX_DESCRIPTORS);
+        mem_conf->dyn_mem_enable = mem->dynamic_memory;
+        mem_conf->tx_free_req = mem->min_req_tx_blocks;
+        mem_conf->rx_free_req = mem->min_req_rx_blocks;
+        mem_conf->tx_min = mem->tx_min;
+
+        ret = wl1271_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
+                                   sizeof(*mem_conf));
+        if (ret < 0) {
+                wl1271_warning("wl1271 mem config failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(mem_conf);
+        return ret;
+}
+
+int wl1271_acx_host_if_cfg_bitmap(struct wl1271 *wl, u32 host_cfg_bitmap)
+{
+        struct wl1271_acx_host_config_bitmap *bitmap_conf;
+        int ret;
+
+        bitmap_conf = kzalloc(sizeof(*bitmap_conf), GFP_KERNEL);
+        if (!bitmap_conf) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        bitmap_conf->host_cfg_bitmap = cpu_to_le32(host_cfg_bitmap);
+
+        ret = wl1271_cmd_configure(wl, ACX_HOST_IF_CFG_BITMAP,
+                                   bitmap_conf, sizeof(*bitmap_conf));
+        if (ret < 0) {
+                wl1271_warning("wl1271 bitmap config opt failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(bitmap_conf);
+
+        return ret;
+}
+
+int wl1271_acx_init_mem_config(struct wl1271 *wl)
+{
+        int ret;
 
         wl->target_mem_map = kzalloc(sizeof(struct wl1271_acx_mem_map),
                                      GFP_KERNEL);
@@ -1075,7 +1197,7 @@ out:
         return ret;
 }
 
-int wl1271_acx_arp_ip_filter(struct wl1271 *wl, bool enable, __be32 address)
+int wl1271_acx_arp_ip_filter(struct wl1271 *wl, u8 enable, __be32 address)
 {
         struct wl1271_acx_arp_filter *acx;
         int ret;
@@ -1091,7 +1213,7 @@ int wl1271_acx_arp_ip_filter(struct wl1271 *wl, bool enable, __be32 address)
         acx->version = ACX_IPV4_VERSION;
         acx->enable = enable;
 
-        if (enable == true)
+        if (enable)
                 memcpy(acx->address, &address, ACX_IPV4_ADDR_SIZE);
 
         ret = wl1271_cmd_configure(wl, ACX_ARP_IP_FILTER,
@@ -1260,6 +1382,175 @@ out:
         return ret;
 }
 
+int wl1271_acx_set_ht_capabilities(struct wl1271 *wl,
+                                    struct ieee80211_sta_ht_cap *ht_cap,
+                                    bool allow_ht_operation)
+{
+        struct wl1271_acx_ht_capabilities *acx;
+        u8 mac_address[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+        int ret = 0;
+        u32 ht_capabilites = 0;
+
+        wl1271_debug(DEBUG_ACX, "acx ht capabilities setting");
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* Allow HT Operation ? */
+        if (allow_ht_operation) {
+                ht_capabilites =
+                        WL1271_ACX_FW_CAP_HT_OPERATION;
+                if (ht_cap->cap & IEEE80211_HT_CAP_GRN_FLD)
+                        ht_capabilites |=
+                                WL1271_ACX_FW_CAP_GREENFIELD_FRAME_FORMAT;
+                if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
+                        ht_capabilites |=
+                                WL1271_ACX_FW_CAP_SHORT_GI_FOR_20MHZ_PACKETS;
+                if (ht_cap->cap & IEEE80211_HT_CAP_LSIG_TXOP_PROT)
+                        ht_capabilites |=
+                                WL1271_ACX_FW_CAP_LSIG_TXOP_PROTECTION;
+
+                /* get data from A-MPDU parameters field */
+                acx->ampdu_max_length = ht_cap->ampdu_factor;
+                acx->ampdu_min_spacing = ht_cap->ampdu_density;
+        }
+
+        memcpy(acx->mac_address, mac_address, ETH_ALEN);
+        acx->ht_capabilites = cpu_to_le32(ht_capabilites);
+
+        ret = wl1271_cmd_configure(wl, ACX_PEER_HT_CAP, acx, sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("acx ht capabilities setting failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
+int wl1271_acx_set_ht_information(struct wl1271 *wl,
+                                   u16 ht_operation_mode)
+{
+        struct wl1271_acx_ht_information *acx;
+        int ret = 0;
+
+        wl1271_debug(DEBUG_ACX, "acx ht information setting");
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        acx->ht_protection =
+                (u8)(ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION);
+        acx->rifs_mode = 0;
+        acx->gf_protection =
+                !!(ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
+        acx->ht_tx_burst_limit = 0;
+        acx->dual_cts_protection = 0;
+
+        ret = wl1271_cmd_configure(wl, ACX_HT_BSS_OPERATION, acx, sizeof(*acx));
+
+        if (ret < 0) {
+                wl1271_warning("acx ht information setting failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
+/* Configure BA session initiator/receiver parameters setting in the FW. */
+int wl1271_acx_set_ba_session(struct wl1271 *wl,
+                               enum ieee80211_back_parties direction,
+                               u8 tid_index, u8 policy)
+{
+        struct wl1271_acx_ba_session_policy *acx;
+        int ret;
+
+        wl1271_debug(DEBUG_ACX, "acx ba session setting");
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* ANY role */
+        acx->role_id = 0xff;
+        acx->tid = tid_index;
+        acx->enable = policy;
+        acx->ba_direction = direction;
+
+        switch (direction) {
+        case WLAN_BACK_INITIATOR:
+                acx->win_size = wl->conf.ht.tx_ba_win_size;
+                acx->inactivity_timeout = wl->conf.ht.inactivity_timeout;
+                break;
+        case WLAN_BACK_RECIPIENT:
+                acx->win_size = RX_BA_WIN_SIZE;
+                acx->inactivity_timeout = 0;
+                break;
+        default:
+                wl1271_error("Incorrect acx command id=%x\n", direction);
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ret = wl1271_cmd_configure(wl,
+                                   ACX_BA_SESSION_POLICY_CFG,
+                                   acx,
+                                   sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("acx ba session setting failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
+/* setup BA session receiver setting in the FW. */
+int wl1271_acx_set_ba_receiver_session(struct wl1271 *wl, u8 tid_index, u16 ssn,
+                                        bool enable)
+{
+        struct wl1271_acx_ba_receiver_setup *acx;
+        int ret;
+
+        wl1271_debug(DEBUG_ACX, "acx ba receiver session setting");
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* Single link for now */
+        acx->link_id = 1;
+        acx->tid = tid_index;
+        acx->enable = enable;
+        acx->win_size = 0;
+        acx->ssn = ssn;
+
+        ret = wl1271_cmd_configure(wl, ACX_BA_SESSION_RX_SETUP, acx,
+                                   sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("acx ba receiver session failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
 int wl1271_acx_tsf_info(struct wl1271 *wl, u64 *mactime)
 {
         struct wl1271_acx_fw_tsf_information *tsf_info;
@@ -1285,3 +1576,147 @@ out:
         kfree(tsf_info);
         return ret;
 }
+
+int wl1271_acx_max_tx_retry(struct wl1271 *wl)
+{
+        struct wl1271_acx_max_tx_retry *acx = NULL;
+        int ret;
+
+        wl1271_debug(DEBUG_ACX, "acx max tx retry");
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx)
+                return -ENOMEM;
+
+        acx->max_tx_retry = cpu_to_le16(wl->conf.tx.ap_max_tx_retries);
+
+        ret = wl1271_cmd_configure(wl, ACX_MAX_TX_FAILURE, acx, sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("acx max tx retry failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
+int wl1271_acx_config_ps(struct wl1271 *wl)
+{
+        struct wl1271_acx_config_ps *config_ps;
+        int ret;
+
+        wl1271_debug(DEBUG_ACX, "acx config ps");
+
+        config_ps = kzalloc(sizeof(*config_ps), GFP_KERNEL);
+        if (!config_ps) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        config_ps->exit_retries = wl->conf.conn.psm_exit_retries;
+        config_ps->enter_retries = wl->conf.conn.psm_entry_retries;
+        config_ps->null_data_rate = cpu_to_le32(wl->basic_rate);
+
+        ret = wl1271_cmd_configure(wl, ACX_CONFIG_PS, config_ps,
+                                   sizeof(*config_ps));
+
+        if (ret < 0) {
+                wl1271_warning("acx config ps failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(config_ps);
+        return ret;
+}
+
+int wl1271_acx_set_inconnection_sta(struct wl1271 *wl, u8 *addr)
+{
+        struct wl1271_acx_inconnection_sta *acx = NULL;
+        int ret;
+
+        wl1271_debug(DEBUG_ACX, "acx set inconnaction sta %pM", addr);
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx)
+                return -ENOMEM;
+
+        memcpy(acx->addr, addr, ETH_ALEN);
+
+        ret = wl1271_cmd_configure(wl, ACX_UPDATE_INCONNECTION_STA_LIST,
+                                   acx, sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("acx set inconnaction sta failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
+int wl1271_acx_set_ap_beacon_filter(struct wl1271 *wl, bool enable)
+{
+        struct acx_ap_beacon_filter *acx = NULL;
+        int ret;
+
+        wl1271_debug(DEBUG_ACX, "acx set ap beacon filter: %d", enable);
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx)
+                return -ENOMEM;
+
+        acx->enable = enable ? 1 : 0;
+
+        ret = wl1271_cmd_configure(wl, ACX_AP_BEACON_FILTER_OPT,
+                                   acx, sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("acx set ap beacon filter failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
+
+int wl1271_acx_fm_coex(struct wl1271 *wl)
+{
+        struct wl1271_acx_fm_coex *acx;
+        int ret;
+
+        wl1271_debug(DEBUG_ACX, "acx fm coex setting");
+
+        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
+        if (!acx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        acx->enable = wl->conf.fm_coex.enable;
+        acx->swallow_period = wl->conf.fm_coex.swallow_period;
+        acx->n_divider_fref_set_1 = wl->conf.fm_coex.n_divider_fref_set_1;
+        acx->n_divider_fref_set_2 = wl->conf.fm_coex.n_divider_fref_set_2;
+        acx->m_divider_fref_set_1 =
+                cpu_to_le16(wl->conf.fm_coex.m_divider_fref_set_1);
+        acx->m_divider_fref_set_2 =
+                cpu_to_le16(wl->conf.fm_coex.m_divider_fref_set_2);
+        acx->coex_pll_stabilization_time =
+                cpu_to_le32(wl->conf.fm_coex.coex_pll_stabilization_time);
+        acx->ldo_stabilization_time =
+                cpu_to_le16(wl->conf.fm_coex.ldo_stabilization_time);
+        acx->fm_disturbed_band_margin =
+                wl->conf.fm_coex.fm_disturbed_band_margin;
+        acx->swallow_clk_diff = wl->conf.fm_coex.swallow_clk_diff;
+
+        ret = wl1271_cmd_configure(wl, ACX_FM_COEX_CFG, acx, sizeof(*acx));
+        if (ret < 0) {
+                wl1271_warning("acx fm coex setting failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(acx);
+        return ret;
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_acx.h b/drivers/net/wireless/wl12xx/acx.h
index 4235bc56f750..9a895e3cc613 100644
--- a/drivers/net/wireless/wl12xx/wl1271_acx.h
+++ b/drivers/net/wireless/wl12xx/acx.h
@@ -22,11 +22,11 @@
  *
  */
 
-#ifndef __WL1271_ACX_H__
-#define __WL1271_ACX_H__
+#ifndef __ACX_H__
+#define __ACX_H__
 
-#include "wl1271.h"
-#include "wl1271_cmd.h"
+#include "wl12xx.h"
+#include "cmd.h"
 
 /*************************************************************************
 
@@ -47,9 +47,9 @@
 #define WL1271_ACX_INTR_HW_AVAILABLE       BIT(5)
 /* The MISC bit is used for aggregation of RX, TxComplete and TX rate update */
 #define WL1271_ACX_INTR_DATA               BIT(6)
-/* Trace meassge on MBOX #A */
+/* Trace message on MBOX #A */
 #define WL1271_ACX_INTR_TRACE_A            BIT(7)
-/* Trace meassge on MBOX #B */
+/* Trace message on MBOX #B */
 #define WL1271_ACX_INTR_TRACE_B            BIT(8)
 
 #define WL1271_ACX_INTR_ALL                0xFFFFFFFF
@@ -61,7 +61,8 @@
                                             WL1271_ACX_INTR_HW_AVAILABLE  | \
                                             WL1271_ACX_INTR_DATA)
 
-#define WL1271_INTR_MASK                   (WL1271_ACX_INTR_EVENT_A      | \
+#define WL1271_INTR_MASK                   (WL1271_ACX_INTR_WATCHDOG     | \
+                                            WL1271_ACX_INTR_EVENT_A      | \
                                             WL1271_ACX_INTR_EVENT_B      | \
                                             WL1271_ACX_INTR_HW_AVAILABLE | \
                                             WL1271_ACX_INTR_DATA)
@@ -100,35 +101,6 @@ struct acx_error_counter {
         __le32 seq_num_miss;
 } __packed;
 
-struct acx_revision {
-        struct acx_header header;
-
-        /*
-         * The WiLink firmware version, an ASCII string x.x.x.x,
-         * that uniquely identifies the current firmware.
-         * The left most digit is incremented each time a
-         * significant change is made to the firmware, such as
-         * code redesign or new platform support.
-         * The second digit is incremented when major enhancements
-         * are added or major fixes are made.
-         * The third digit is incremented for each GA release.
-         * The fourth digit is incremented for each build.
-         * The first two digits identify a firmware release version,
-         * in other words, a unique set of features.
-         * The first three digits identify a GA release.
-         */
-        char fw_version[20];
-
-        /*
-         * This 4 byte field specifies the WiLink hardware version.
-         * bits 0  - 15: Reserved.
-         * bits 16 - 23: Version ID - The WiLink version ID
-         *              (1 = first spin, 2 = second spin, and so on).
-         * bits 24 - 31: Chip ID - The WiLink chip ID.
-         */
-        __le32 hw_version;
-} __packed;
-
 enum wl1271_psm_mode {
         /* Active mode */
         WL1271_PSM_CAM = 0,
@@ -161,7 +133,6 @@ enum {
 
 #define DEFAULT_UCAST_PRIORITY          0
 #define DEFAULT_RX_Q_PRIORITY           0
-#define DEFAULT_NUM_STATIONS            1
 #define DEFAULT_RXQ_PRIORITY            0 /* low 0 .. 15 high  */
 #define DEFAULT_RXQ_TYPE                0x07    /* All frames, Data/Ctrl/Mgmt */
 #define TRACE_BUFFER_MAX_SIZE           256
@@ -332,7 +303,6 @@ struct acx_beacon_filter_option {
         struct acx_header header;
 
         u8 enable;
-
         /*
          * The number of beacons without the unicast TIM
          * bit set that the firmware buffers before
@@ -399,14 +369,23 @@ struct acx_bt_wlan_coex {
         u8 pad[3];
 } __packed;
 
-struct acx_bt_wlan_coex_param {
+struct acx_sta_bt_wlan_coex_param {
         struct acx_header header;
 
-        __le32 params[CONF_SG_PARAMS_MAX];
+        __le32 params[CONF_SG_STA_PARAMS_MAX];
         u8 param_idx;
         u8 padding[3];
 } __packed;
 
+struct acx_ap_bt_wlan_coex_param {
+        struct acx_header header;
+
+        __le32 params[CONF_SG_AP_PARAMS_MAX];
+        u8 param_idx;
+        u8 padding[3];
+} __packed;
+
+
 struct acx_dco_itrim_params {
         struct acx_header header;
 
@@ -775,13 +754,23 @@ struct acx_rate_class {
 #define ACX_TX_BASIC_RATE      0
 #define ACX_TX_AP_FULL_RATE    1
 #define ACX_TX_RATE_POLICY_CNT 2
-struct acx_rate_policy {
+struct acx_sta_rate_policy {
         struct acx_header header;
 
         __le32 rate_class_cnt;
         struct acx_rate_class rate_class[CONF_TX_MAX_RATE_CLASSES];
 } __packed;
 
+
+#define ACX_TX_AP_MODE_MGMT_RATE 4
+#define ACX_TX_AP_MODE_BCST_RATE 5
+struct acx_ap_rate_policy {
+        struct acx_header header;
+
+        __le32 rate_policy_idx;
+        struct acx_rate_class rate_policy;
+} __packed;
+
 struct acx_ac_cfg {
         struct acx_header header;
         u8 ac;
@@ -815,12 +804,19 @@ struct acx_tx_config_options {
         __le16 tx_compl_threshold;   /* number of packets */
 } __packed;
 
-#define ACX_RX_MEM_BLOCKS     70
-#define ACX_TX_MIN_MEM_BLOCKS 40
 #define ACX_TX_DESCRIPTORS    32
-#define ACX_NUM_SSID_PROFILES 1
 
-struct wl1271_acx_config_memory {
+struct wl1271_acx_ap_config_memory {
+        struct acx_header header;
+
+        u8 rx_mem_block_num;
+        u8 tx_min_mem_block_num;
+        u8 num_stations;
+        u8 num_ssid_profiles;
+        __le32 total_tx_descriptors;
+} __packed;
+
+struct wl1271_acx_sta_config_memory {
         struct acx_header header;
 
         u8 rx_mem_block_num;
@@ -828,6 +824,10 @@ struct wl1271_acx_config_memory {
         u8 num_stations;
         u8 num_ssid_profiles;
         __le32 total_tx_descriptors;
+        u8 dyn_mem_enable;
+        u8 tx_free_req;
+        u8 rx_free_req;
+        u8 tx_min;
 } __packed;
 
 struct wl1271_acx_mem_map {
@@ -896,10 +896,15 @@ struct wl1271_acx_bet_enable {
 #define ACX_IPV4_VERSION 4
 #define ACX_IPV6_VERSION 6
 #define ACX_IPV4_ADDR_SIZE 4
+
+/* bitmap of enabled arp_filter features */
+#define ACX_ARP_FILTER_ARP_FILTERING    BIT(0)
+#define ACX_ARP_FILTER_AUTO_ARP         BIT(1)
+
 struct wl1271_acx_arp_filter {
         struct acx_header header;
         u8 version;         /* ACX_IPV4_VERSION, ACX_IPV6_VERSION */
-        u8 enable;          /* 1 to enable ARP filtering, 0 to disable */
+        u8 enable;          /* bitmap of enabled ARP filtering features */
         u8 padding[2];
         u8 address[16];     /* The configured device IP address - all ARP
                                requests directed to this IP address will pass
@@ -942,6 +947,16 @@ struct wl1271_acx_keep_alive_config {
         u8 padding;
 } __packed;
 
+#define HOST_IF_CFG_RX_FIFO_ENABLE     BIT(0)
+#define HOST_IF_CFG_TX_EXTRA_BLKS_SWAP BIT(1)
+#define HOST_IF_CFG_TX_PAD_TO_SDIO_BLK BIT(3)
+
+struct wl1271_acx_host_config_bitmap {
+        struct acx_header header;
+
+        __le32 host_cfg_bitmap;
+} __packed;
+
 enum {
         WL1271_ACX_TRIG_TYPE_LEVEL = 0,
         WL1271_ACX_TRIG_TYPE_EDGE,
@@ -993,6 +1008,140 @@ struct wl1271_acx_rssi_snr_avg_weights {
         u8 snr_data;
 };
 
+/*
+ * ACX_PEER_HT_CAP
+ * Configure HT capabilities - declare the capabilities of the peer
+ * we are connected to.
+ */
+struct wl1271_acx_ht_capabilities {
+        struct acx_header header;
+
+        /*
+         * bit 0 - Allow HT Operation
+         * bit 1 - Allow Greenfield format in TX
+         * bit 2 - Allow Short GI in TX
+         * bit 3 - Allow L-SIG TXOP Protection in TX
+         * bit 4 - Allow HT Control fields in TX.
+         *         Note, driver will still leave space for HT control in packets
+         *         regardless of the value of this field. FW will be responsible
+         *         to drop the HT field from any frame when this Bit set to 0.
+         * bit 5 - Allow RD initiation in TXOP. FW is allowed to initate RD.
+         *         Exact policy setting for this feature is TBD.
+         *         Note, this bit can only be set to 1 if bit 3 is set to 1.
+         */
+        __le32 ht_capabilites;
+
+        /*
+         * Indicates to which peer these capabilities apply.
+         * For infrastructure use ff:ff:ff:ff:ff:ff that indicates relevance
+         * for all peers.
+         * Only valid for IBSS/DLS operation.
+         */
+        u8 mac_address[ETH_ALEN];
+
+        /*
+         * This the maximum A-MPDU length supported by the AP. The FW may not
+         * exceed this length when sending A-MPDUs
+         */
+        u8 ampdu_max_length;
+
+        /* This is the minimal spacing required when sending A-MPDUs to the AP*/
+        u8 ampdu_min_spacing;
+} __packed;
+
+/* HT Capabilites Fw Bit Mask Mapping */
+#define WL1271_ACX_FW_CAP_HT_OPERATION                 BIT(0)
+#define WL1271_ACX_FW_CAP_GREENFIELD_FRAME_FORMAT      BIT(1)
+#define WL1271_ACX_FW_CAP_SHORT_GI_FOR_20MHZ_PACKETS   BIT(2)
+#define WL1271_ACX_FW_CAP_LSIG_TXOP_PROTECTION         BIT(3)
+#define WL1271_ACX_FW_CAP_HT_CONTROL_FIELDS            BIT(4)
+#define WL1271_ACX_FW_CAP_RD_INITIATION                BIT(5)
+
+
+/*
+ * ACX_HT_BSS_OPERATION
+ * Configure HT capabilities - AP rules for behavior in the BSS.
+ */
+struct wl1271_acx_ht_information {
+        struct acx_header header;
+
+        /* Values: 0 - RIFS not allowed, 1 - RIFS allowed */
+        u8 rifs_mode;
+
+        /* Values: 0 - 3 like in spec */
+        u8 ht_protection;
+
+        /* Values: 0 - GF protection not required, 1 - GF protection required */
+        u8 gf_protection;
+
+        /*Values: 0 - TX Burst limit not required, 1 - TX Burst Limit required*/
+        u8 ht_tx_burst_limit;
+
+        /*
+         * Values: 0 - Dual CTS protection not required,
+         *         1 - Dual CTS Protection required
+         * Note: When this value is set to 1 FW will protect all TXOP with RTS
+         * frame and will not use CTS-to-self regardless of the value of the
+         * ACX_CTS_PROTECTION information element
+         */
+        u8 dual_cts_protection;
+
+        u8 padding[3];
+} __packed;
+
+#define RX_BA_WIN_SIZE 8
+
+struct wl1271_acx_ba_session_policy {
+        struct acx_header header;
+        /*
+         * Specifies role Id, Range 0-7, 0xFF means ANY role.
+         * Future use. For now this field is irrelevant
+         */
+        u8 role_id;
+        /*
+         * Specifies Link Id, Range 0-31, 0xFF means ANY  Link Id.
+         * Not applicable if Role Id is set to ANY.
+         */
+        u8 link_id;
+
+        u8 tid;
+
+        u8 enable;
+
+        /* Windows size in number of packets */
+        u16 win_size;
+
+        /*
+         * As initiator inactivity timeout in time units(TU) of 1024us.
+         * As receiver reserved
+         */
+        u16 inactivity_timeout;
+
+        /* Initiator = 1/Receiver = 0 */
+        u8 ba_direction;
+
+        u8 padding[3];
+} __packed;
+
+struct wl1271_acx_ba_receiver_setup {
+        struct acx_header header;
+
+        /* Specifies Link Id, Range 0-31, 0xFF means ANY  Link Id */
+        u8 link_id;
+
+        u8 tid;
+
+        u8 enable;
+
+        u8 padding[1];
+
+        /* Windows size in number of packets */
+        u16 win_size;
+
+        /* BA session starting sequence number.  RANGE 0-FFF */
+        u16 ssn;
+} __packed;
+
 struct wl1271_acx_fw_tsf_information {
         struct acx_header header;
 
@@ -1004,6 +1153,99 @@ struct wl1271_acx_fw_tsf_information {
         u8 padding[3];
 } __packed;
 
+struct wl1271_acx_max_tx_retry {
+        struct acx_header header;
+
+        /*
+         * the number of frames transmission failures before
+         * issuing the aging event.
+         */
+        __le16 max_tx_retry;
+        u8 padding_1[2];
+} __packed;
+
+struct wl1271_acx_config_ps {
+        struct acx_header header;
+
+        u8 exit_retries;
+        u8 enter_retries;
+        u8 padding[2];
+        __le32 null_data_rate;
+} __packed;
+
+struct wl1271_acx_inconnection_sta {
+        struct acx_header header;
+
+        u8 addr[ETH_ALEN];
+        u8 padding1[2];
+} __packed;
+
+struct acx_ap_beacon_filter {
+        struct acx_header header;
+
+        u8 enable;
+        u8 pad[3];
+} __packed;
+
+/*
+ * ACX_FM_COEX_CFG
+ * set the FM co-existence parameters.
+ */
+struct wl1271_acx_fm_coex {
+        struct acx_header header;
+        /* enable(1) / disable(0) the FM Coex feature */
+        u8 enable;
+        /*
+         * Swallow period used in COEX PLL swallowing mechanism.
+         * 0xFF = use FW default
+         */
+        u8 swallow_period;
+        /*
+         * The N divider used in COEX PLL swallowing mechanism for Fref of
+         * 38.4/19.2 Mhz. 0xFF = use FW default
+         */
+        u8 n_divider_fref_set_1;
+        /*
+         * The N divider used in COEX PLL swallowing mechanism for Fref of
+         * 26/52 Mhz. 0xFF = use FW default
+         */
+        u8 n_divider_fref_set_2;
+        /*
+         * The M divider used in COEX PLL swallowing mechanism for Fref of
+         * 38.4/19.2 Mhz. 0xFFFF = use FW default
+         */
+        __le16 m_divider_fref_set_1;
+        /*
+         * The M divider used in COEX PLL swallowing mechanism for Fref of
+         * 26/52 Mhz. 0xFFFF = use FW default
+         */
+        __le16 m_divider_fref_set_2;
+        /*
+         * The time duration in uSec required for COEX PLL to stabilize.
+         * 0xFFFFFFFF = use FW default
+         */
+        __le32 coex_pll_stabilization_time;
+        /*
+         * The time duration in uSec required for LDO to stabilize.
+         * 0xFFFFFFFF = use FW default
+         */
+        __le16 ldo_stabilization_time;
+        /*
+         * The disturbed frequency band margin around the disturbed frequency
+         * center (single sided).
+         * For example, if 2 is configured, the following channels will be
+         * considered disturbed channel:
+         *   80 +- 0.1 MHz, 91 +- 0.1 MHz, 98 +- 0.1 MHz, 102 +- 0.1 MH
+         * 0xFF = use FW default
+         */
+        u8 fm_disturbed_band_margin;
+        /*
+         * The swallow clock difference of the swallowing mechanism.
+         * 0xFF = use FW default
+         */
+        u8 swallow_clk_diff;
+} __packed;
+
 enum {
         ACX_WAKE_UP_CONDITIONS      = 0x0002,
         ACX_MEM_CFG                 = 0x0003,
@@ -1022,6 +1264,7 @@ enum {
         ACX_TID_CFG                 = 0x001A,
         ACX_PS_RX_STREAMING         = 0x001B,
         ACX_BEACON_FILTER_OPT       = 0x001F,
+        ACX_AP_BEACON_FILTER_OPT    = 0x0020,
         ACX_NOISE_HIST              = 0x0021,
         ACX_HDK_VERSION             = 0x0022, /* ??? */
         ACX_PD_THRESHOLD            = 0x0023,
@@ -1033,6 +1276,7 @@ enum {
         ACX_BCN_DTIM_OPTIONS        = 0x0031,
         ACX_SG_ENABLE               = 0x0032,
         ACX_SG_CFG                  = 0x0033,
+        ACX_FM_COEX_CFG             = 0x0034,
         ACX_BEACON_FILTER_TABLE     = 0x0038,
         ACX_ARP_IP_FILTER           = 0x0039,
         ACX_ROAMING_STATISTICS_TBL  = 0x003B,
@@ -1055,29 +1299,29 @@ enum {
         ACX_RSSI_SNR_WEIGHTS        = 0x0052,
         ACX_KEEP_ALIVE_MODE         = 0x0053,
         ACX_SET_KEEP_ALIVE_CONFIG   = 0x0054,
-        ACX_BA_SESSION_RESPONDER_POLICY = 0x0055,
-        ACX_BA_SESSION_INITIATOR_POLICY = 0x0056,
+        ACX_BA_SESSION_POLICY_CFG   = 0x0055,
+        ACX_BA_SESSION_RX_SETUP     = 0x0056,
         ACX_PEER_HT_CAP             = 0x0057,
         ACX_HT_BSS_OPERATION        = 0x0058,
         ACX_COEX_ACTIVITY           = 0x0059,
-        ACX_SET_SMART_REFLEX_DEBUG  = 0x005A,
         ACX_SET_DCO_ITRIM_PARAMS    = 0x0061,
+        ACX_GEN_FW_CMD              = 0x0070,
+        ACX_HOST_IF_CFG_BITMAP      = 0x0071,
+        ACX_MAX_TX_FAILURE          = 0x0072,
+        ACX_UPDATE_INCONNECTION_STA_LIST = 0x0073,
         DOT11_RX_MSDU_LIFE_TIME     = 0x1004,
         DOT11_CUR_TX_PWR            = 0x100D,
         DOT11_RX_DOT11_MODE         = 0x1012,
         DOT11_RTS_THRESHOLD         = 0x1013,
         DOT11_GROUP_ADDRESS_TBL     = 0x1014,
         ACX_PM_CONFIG               = 0x1016,
-
-        MAX_DOT11_IE = DOT11_GROUP_ADDRESS_TBL,
-
-        MAX_IE = 0xFFFF
+        ACX_CONFIG_PS               = 0x1017,
+        ACX_CONFIG_HANGOVER         = 0x1018,
 };
 
 
 int wl1271_acx_wake_up_conditions(struct wl1271 *wl);
 int wl1271_acx_sleep_auth(struct wl1271 *wl, u8 sleep_auth);
-int wl1271_acx_fw_version(struct wl1271 *wl, char *buf, size_t len);
 int wl1271_acx_tx_power(struct wl1271 *wl, int power);
 int wl1271_acx_feature_cfg(struct wl1271 *wl);
 int wl1271_acx_mem_map(struct wl1271 *wl,
@@ -1089,13 +1333,14 @@ int wl1271_acx_slot(struct wl1271 *wl, enum acx_slot_type slot_time);
 int wl1271_acx_group_address_tbl(struct wl1271 *wl, bool enable,
                                  void *mc_list, u32 mc_list_len);
 int wl1271_acx_service_period_timeout(struct wl1271 *wl);
-int wl1271_acx_rts_threshold(struct wl1271 *wl, u16 rts_threshold);
+int wl1271_acx_rts_threshold(struct wl1271 *wl, u32 rts_threshold);
 int wl1271_acx_dco_itrim_params(struct wl1271 *wl);
 int wl1271_acx_beacon_filter_opt(struct wl1271 *wl, bool enable_filter);
 int wl1271_acx_beacon_filter_table(struct wl1271 *wl);
 int wl1271_acx_conn_monit_params(struct wl1271 *wl, bool enable);
 int wl1271_acx_sg_enable(struct wl1271 *wl, bool enable);
-int wl1271_acx_sg_cfg(struct wl1271 *wl);
+int wl1271_acx_sta_sg_cfg(struct wl1271 *wl);
+int wl1271_acx_ap_sg_cfg(struct wl1271 *wl);
 int wl1271_acx_cca_threshold(struct wl1271 *wl);
 int wl1271_acx_bcn_dtim_options(struct wl1271 *wl);
 int wl1271_acx_aid(struct wl1271 *wl, u16 aid);
@@ -1104,26 +1349,45 @@ int wl1271_acx_set_preamble(struct wl1271 *wl, enum acx_preamble_type preamble);
 int wl1271_acx_cts_protect(struct wl1271 *wl,
                            enum acx_ctsprotect_type ctsprotect);
 int wl1271_acx_statistics(struct wl1271 *wl, struct acx_statistics *stats);
-int wl1271_acx_rate_policies(struct wl1271 *wl);
+int wl1271_acx_sta_rate_policies(struct wl1271 *wl);
+int wl1271_acx_ap_rate_policy(struct wl1271 *wl, struct conf_tx_rate_class *c,
+                      u8 idx);
 int wl1271_acx_ac_cfg(struct wl1271 *wl, u8 ac, u8 cw_min, u16 cw_max,
                       u8 aifsn, u16 txop);
 int wl1271_acx_tid_cfg(struct wl1271 *wl, u8 queue_id, u8 channel_type,
                        u8 tsid, u8 ps_scheme, u8 ack_policy,
                        u32 apsd_conf0, u32 apsd_conf1);
-int wl1271_acx_frag_threshold(struct wl1271 *wl);
+int wl1271_acx_frag_threshold(struct wl1271 *wl, u32 frag_threshold);
 int wl1271_acx_tx_config_options(struct wl1271 *wl);
-int wl1271_acx_mem_cfg(struct wl1271 *wl);
+int wl1271_acx_ap_mem_cfg(struct wl1271 *wl);
+int wl1271_acx_sta_mem_cfg(struct wl1271 *wl);
 int wl1271_acx_init_mem_config(struct wl1271 *wl);
+int wl1271_acx_host_if_cfg_bitmap(struct wl1271 *wl, u32 host_cfg_bitmap);
 int wl1271_acx_init_rx_interrupt(struct wl1271 *wl);
 int wl1271_acx_smart_reflex(struct wl1271 *wl);
 int wl1271_acx_bet_enable(struct wl1271 *wl, bool enable);
-int wl1271_acx_arp_ip_filter(struct wl1271 *wl, bool enable, __be32 address);
+int wl1271_acx_arp_ip_filter(struct wl1271 *wl, u8 enable, __be32 address);
 int wl1271_acx_pm_config(struct wl1271 *wl);
 int wl1271_acx_keep_alive_mode(struct wl1271 *wl, bool enable);
 int wl1271_acx_keep_alive_config(struct wl1271 *wl, u8 index, u8 tpl_valid);
 int wl1271_acx_rssi_snr_trigger(struct wl1271 *wl, bool enable,
                                 s16 thold, u8 hyst);
 int wl1271_acx_rssi_snr_avg_weights(struct wl1271 *wl);
+int wl1271_acx_set_ht_capabilities(struct wl1271 *wl,
+                                    struct ieee80211_sta_ht_cap *ht_cap,
+                                    bool allow_ht_operation);
+int wl1271_acx_set_ht_information(struct wl1271 *wl,
+                                   u16 ht_operation_mode);
+int wl1271_acx_set_ba_session(struct wl1271 *wl,
+                              enum ieee80211_back_parties direction,
+                              u8 tid_index, u8 policy);
+int wl1271_acx_set_ba_receiver_session(struct wl1271 *wl, u8 tid_index, u16 ssn,
+                                       bool enable);
 int wl1271_acx_tsf_info(struct wl1271 *wl, u64 *mactime);
+int wl1271_acx_max_tx_retry(struct wl1271 *wl);
+int wl1271_acx_config_ps(struct wl1271 *wl);
+int wl1271_acx_set_inconnection_sta(struct wl1271 *wl, u8 *addr);
+int wl1271_acx_set_ap_beacon_filter(struct wl1271 *wl, bool enable);
+int wl1271_acx_fm_coex(struct wl1271 *wl);
 
 #endif /* __WL1271_ACX_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1271_boot.c b/drivers/net/wireless/wl12xx/boot.c
index f36430b0336d..b07f8b7e5f11 100644
--- a/drivers/net/wireless/wl12xx/wl1271_boot.c
+++ b/drivers/net/wireless/wl12xx/boot.c
@@ -21,14 +21,15 @@
  *
  */
 
-#include <linux/gpio.h>
 #include <linux/slab.h>
+#include <linux/wl12xx.h>
 
-#include "wl1271_acx.h"
-#include "wl1271_reg.h"
-#include "wl1271_boot.h"
-#include "wl1271_io.h"
-#include "wl1271_event.h"
+#include "acx.h"
+#include "reg.h"
+#include "boot.h"
+#include "io.h"
+#include "event.h"
+#include "rx.h"
 
 static struct wl1271_partition_set part_table[PART_TABLE_LEN] = {
         [PART_DOWN] = {
@@ -101,6 +102,22 @@ static void wl1271_boot_set_ecpu_ctrl(struct wl1271 *wl, u32 flag)
         wl1271_write32(wl, ACX_REG_ECPU_CONTROL, cpu_ctrl);
 }
 
+static void wl1271_parse_fw_ver(struct wl1271 *wl)
+{
+        int ret;
+
+        ret = sscanf(wl->chip.fw_ver_str + 4, "%u.%u.%u.%u.%u",
+                     &wl->chip.fw_ver[0], &wl->chip.fw_ver[1],
+                     &wl->chip.fw_ver[2], &wl->chip.fw_ver[3],
+                     &wl->chip.fw_ver[4]);
+
+        if (ret != 5) {
+                wl1271_warning("fw version incorrect value");
+                memset(wl->chip.fw_ver, 0, sizeof(wl->chip.fw_ver));
+                return;
+        }
+}
+
 static void wl1271_boot_fw_version(struct wl1271 *wl)
 {
         struct wl1271_static_data static_data;
@@ -108,11 +125,13 @@ static void wl1271_boot_fw_version(struct wl1271 *wl)
         wl1271_read(wl, wl->cmd_box_addr, &static_data, sizeof(static_data),
                     false);
 
-        strncpy(wl->chip.fw_ver, static_data.fw_version,
-                sizeof(wl->chip.fw_ver));
+        strncpy(wl->chip.fw_ver_str, static_data.fw_version,
+                sizeof(wl->chip.fw_ver_str));
 
         /* make sure the string is NULL-terminated */
-        wl->chip.fw_ver[sizeof(wl->chip.fw_ver) - 1] = '\0';
+        wl->chip.fw_ver_str[sizeof(wl->chip.fw_ver_str) - 1] = '\0';
+
+        wl1271_parse_fw_ver(wl);
 }
 
 static int wl1271_boot_upload_firmware_chunk(struct wl1271 *wl, void *buf,
@@ -225,9 +244,57 @@ static int wl1271_boot_upload_nvs(struct wl1271 *wl)
         if (wl->nvs == NULL)
                 return -ENODEV;
 
-        /* only the first part of the NVS needs to be uploaded */
-        nvs_len = sizeof(wl->nvs->nvs);
-        nvs_ptr = (u8 *)wl->nvs->nvs;
+        if (wl->chip.id == CHIP_ID_1283_PG20) {
+                struct wl128x_nvs_file *nvs = (struct wl128x_nvs_file *)wl->nvs;
+
+                if (wl->nvs_len == sizeof(struct wl128x_nvs_file)) {
+                        if (nvs->general_params.dual_mode_select)
+                                wl->enable_11a = true;
+                } else {
+                        wl1271_error("nvs size is not as expected: %zu != %zu",
+                                     wl->nvs_len,
+                                     sizeof(struct wl128x_nvs_file));
+                        kfree(wl->nvs);
+                        wl->nvs = NULL;
+                        wl->nvs_len = 0;
+                        return -EILSEQ;
+                }
+
+                /* only the first part of the NVS needs to be uploaded */
+                nvs_len = sizeof(nvs->nvs);
+                nvs_ptr = (u8 *)nvs->nvs;
+
+        } else {
+                struct wl1271_nvs_file *nvs =
+                        (struct wl1271_nvs_file *)wl->nvs;
+                /*
+                 * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz
+                 * band configurations) can be removed when those NVS files stop
+                 * floating around.
+                 */
+                if (wl->nvs_len == sizeof(struct wl1271_nvs_file) ||
+                    wl->nvs_len == WL1271_INI_LEGACY_NVS_FILE_SIZE) {
+                        /* for now 11a is unsupported in AP mode */
+                        if (wl->bss_type != BSS_TYPE_AP_BSS &&
+                            nvs->general_params.dual_mode_select)
+                                wl->enable_11a = true;
+                }
+
+                if (wl->nvs_len != sizeof(struct wl1271_nvs_file) &&
+                    (wl->nvs_len != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
+                     wl->enable_11a)) {
+                        wl1271_error("nvs size is not as expected: %zu != %zu",
+                                wl->nvs_len, sizeof(struct wl1271_nvs_file));
+                        kfree(wl->nvs);
+                        wl->nvs = NULL;
+                        wl->nvs_len = 0;
+                        return -EILSEQ;
+                }
+
+                /* only the first part of the NVS needs to be uploaded */
+                nvs_len = sizeof(nvs->nvs);
+                nvs_ptr = (u8 *) nvs->nvs;
+        }
 
         /* update current MAC address to NVS */
         nvs_ptr[11] = wl->mac_addr[0];
@@ -251,8 +318,10 @@ static int wl1271_boot_upload_nvs(struct wl1271 *wl)
                 burst_len = nvs_ptr[0];
                 dest_addr = (nvs_ptr[1] & 0xfe) | ((u32)(nvs_ptr[2] << 8));
 
-                /* FIXME: Due to our new wl1271_translate_reg_addr function,
-                   we need to add the REGISTER_BASE to the destination */
+                /*
+                 * Due to our new wl1271_translate_reg_addr function,
+                 * we need to add the REGISTER_BASE to the destination
+                 */
                 dest_addr += REGISTERS_BASE;
 
                 /* We move our pointer to the data */
@@ -274,31 +343,24 @@ static int wl1271_boot_upload_nvs(struct wl1271 *wl)
 
         /*
          * We've reached the first zero length, the first NVS table
-         * is 7 bytes further.
+         * is located at an aligned offset which is at least 7 bytes further.
+         * NOTE: The wl->nvs->nvs element must be first, in order to
+         * simplify the casting, we assume it is at the beginning of
+         * the wl->nvs structure.
          */
-        nvs_ptr += 7;
-        nvs_len -= nvs_ptr - (u8 *)wl->nvs->nvs;
-        nvs_len = ALIGN(nvs_len, 4);
+        nvs_ptr = (u8 *)wl->nvs +
+                        ALIGN(nvs_ptr - (u8 *)wl->nvs + 7, 4);
+        nvs_len -= nvs_ptr - (u8 *)wl->nvs;
 
-        /* FIXME: The driver sets the partition here, but this is not needed,
-           since it sets to the same one as currently in use */
         /* Now we must set the partition correctly */
         wl1271_set_partition(wl, &part_table[PART_WORK]);
 
         /* Copy the NVS tables to a new block to ensure alignment */
-        /* FIXME: We jump 3 more bytes before uploading the NVS.  It seems
-        that our NVS files have three extra zeros here.  I'm not sure whether
-        the problem is in our NVS generation or we should really jumpt these
-        3 bytes here */
-        nvs_ptr += 3;
-
-        nvs_aligned = kmemdup(nvs_ptr, nvs_len, GFP_KERNEL); if
-        (!nvs_aligned) return -ENOMEM;
+        nvs_aligned = kmemdup(nvs_ptr, nvs_len, GFP_KERNEL);
+        if (!nvs_aligned)
+                return -ENOMEM;
 
         /* And finally we upload the NVS tables */
-        /* FIXME: In wl1271, we upload everything at once.
-           No endianness handling needed here?! The ref driver doesn't do
-           anything about it at this point */
         wl1271_write(wl, CMD_MBOX_ADDRESS, nvs_aligned, nvs_len, false);
 
         kfree(nvs_aligned);
@@ -416,7 +478,14 @@ static int wl1271_boot_run_firmware(struct wl1271 *wl)
                 DISCONNECT_EVENT_COMPLETE_ID |
                 RSSI_SNR_TRIGGER_0_EVENT_ID |
                 PSPOLL_DELIVERY_FAILURE_EVENT_ID |
-                SOFT_GEMINI_SENSE_EVENT_ID;
+                SOFT_GEMINI_SENSE_EVENT_ID |
+                PERIODIC_SCAN_REPORT_EVENT_ID |
+                PERIODIC_SCAN_COMPLETE_EVENT_ID;
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS)
+                wl->event_mask |= STA_REMOVE_COMPLETE_EVENT_ID;
+        else
+                wl->event_mask |= DUMMY_PACKET_EVENT_ID;
 
         ret = wl1271_event_unmask(wl);
         if (ret < 0) {
@@ -451,23 +520,164 @@ static void wl1271_boot_hw_version(struct wl1271 *wl)
         fuse = (fuse & PG_VER_MASK) >> PG_VER_OFFSET;
 
         wl->hw_pg_ver = (s8)fuse;
+
+        if (((wl->hw_pg_ver & PG_MAJOR_VER_MASK) >> PG_MAJOR_VER_OFFSET) < 3)
+                wl->quirks |= WL12XX_QUIRK_END_OF_TRANSACTION;
 }
 
-int wl1271_boot(struct wl1271 *wl)
+static int wl128x_switch_tcxo_to_fref(struct wl1271 *wl)
 {
-        int ret = 0;
-        u32 tmp, clk, pause;
+        u16 spare_reg;
+
+        /* Mask bits [2] & [8:4] in the sys_clk_cfg register */
+        spare_reg = wl1271_top_reg_read(wl, WL_SPARE_REG);
+        if (spare_reg == 0xFFFF)
+                return -EFAULT;
+        spare_reg |= (BIT(3) | BIT(5) | BIT(6));
+        wl1271_top_reg_write(wl, WL_SPARE_REG, spare_reg);
+
+        /* Enable FREF_CLK_REQ & mux MCS and coex PLLs to FREF */
+        wl1271_top_reg_write(wl, SYS_CLK_CFG_REG,
+                             WL_CLK_REQ_TYPE_PG2 | MCS_PLL_CLK_SEL_FREF);
+
+        /* Delay execution for 15msec, to let the HW settle */
+        mdelay(15);
+
+        return 0;
+}
+
+static bool wl128x_is_tcxo_valid(struct wl1271 *wl)
+{
+        u16 tcxo_detection;
+
+        tcxo_detection = wl1271_top_reg_read(wl, TCXO_CLK_DETECT_REG);
+        if (tcxo_detection & TCXO_DET_FAILED)
+                return false;
+
+        return true;
+}
+
+static bool wl128x_is_fref_valid(struct wl1271 *wl)
+{
+        u16 fref_detection;
+
+        fref_detection = wl1271_top_reg_read(wl, FREF_CLK_DETECT_REG);
+        if (fref_detection & FREF_CLK_DETECT_FAIL)
+                return false;
+
+        return true;
+}
+
+static int wl128x_manually_configure_mcs_pll(struct wl1271 *wl)
+{
+        wl1271_top_reg_write(wl, MCS_PLL_M_REG, MCS_PLL_M_REG_VAL);
+        wl1271_top_reg_write(wl, MCS_PLL_N_REG, MCS_PLL_N_REG_VAL);
+        wl1271_top_reg_write(wl, MCS_PLL_CONFIG_REG, MCS_PLL_CONFIG_REG_VAL);
+
+        return 0;
+}
+
+static int wl128x_configure_mcs_pll(struct wl1271 *wl, int clk)
+{
+        u16 spare_reg;
+        u16 pll_config;
+        u8 input_freq;
+
+        /* Mask bits [3:1] in the sys_clk_cfg register */
+        spare_reg = wl1271_top_reg_read(wl, WL_SPARE_REG);
+        if (spare_reg == 0xFFFF)
+                return -EFAULT;
+        spare_reg |= BIT(2);
+        wl1271_top_reg_write(wl, WL_SPARE_REG, spare_reg);
+
+        /* Handle special cases of the TCXO clock */
+        if (wl->tcxo_clock == WL12XX_TCXOCLOCK_16_8 ||
+            wl->tcxo_clock == WL12XX_TCXOCLOCK_33_6)
+                return wl128x_manually_configure_mcs_pll(wl);
+
+        /* Set the input frequency according to the selected clock source */
+        input_freq = (clk & 1) + 1;
+
+        pll_config = wl1271_top_reg_read(wl, MCS_PLL_CONFIG_REG);
+        if (pll_config == 0xFFFF)
+                return -EFAULT;
+        pll_config |= (input_freq << MCS_SEL_IN_FREQ_SHIFT);
+        pll_config |= MCS_PLL_ENABLE_HP;
+        wl1271_top_reg_write(wl, MCS_PLL_CONFIG_REG, pll_config);
+
+        return 0;
+}
+
+/*
+ * WL128x has two clocks input - TCXO and FREF.
+ * TCXO is the main clock of the device, while FREF is used to sync
+ * between the GPS and the cellular modem.
+ * In cases where TCXO is 32.736MHz or 16.368MHz, the FREF will be used
+ * as the WLAN/BT main clock.
+ */
+static int wl128x_boot_clk(struct wl1271 *wl, int *selected_clock)
+{
+        u16 sys_clk_cfg;
+
+        /* For XTAL-only modes, FREF will be used after switching from TCXO */
+        if (wl->ref_clock == WL12XX_REFCLOCK_26_XTAL ||
+            wl->ref_clock == WL12XX_REFCLOCK_38_XTAL) {
+                if (!wl128x_switch_tcxo_to_fref(wl))
+                        return -EINVAL;
+                goto fref_clk;
+        }
+
+        /* Query the HW, to determine which clock source we should use */
+        sys_clk_cfg = wl1271_top_reg_read(wl, SYS_CLK_CFG_REG);
+        if (sys_clk_cfg == 0xFFFF)
+                return -EINVAL;
+        if (sys_clk_cfg & PRCM_CM_EN_MUX_WLAN_FREF)
+                goto fref_clk;
+
+        /* If TCXO is either 32.736MHz or 16.368MHz, switch to FREF */
+        if (wl->tcxo_clock == WL12XX_TCXOCLOCK_16_368 ||
+            wl->tcxo_clock == WL12XX_TCXOCLOCK_32_736) {
+                if (!wl128x_switch_tcxo_to_fref(wl))
+                        return -EINVAL;
+                goto fref_clk;
+        }
+
+        /* TCXO clock is selected */
+        if (!wl128x_is_tcxo_valid(wl))
+                return -EINVAL;
+        *selected_clock = wl->tcxo_clock;
+        goto config_mcs_pll;
+
+fref_clk:
+        /* FREF clock is selected */
+        if (!wl128x_is_fref_valid(wl))
+                return -EINVAL;
+        *selected_clock = wl->ref_clock;
+
+config_mcs_pll:
+        return wl128x_configure_mcs_pll(wl, *selected_clock);
+}
+
+static int wl127x_boot_clk(struct wl1271 *wl)
+{
+        u32 pause;
+        u32 clk;
 
         wl1271_boot_hw_version(wl);
 
-        if (REF_CLOCK == 0 || REF_CLOCK == 2 || REF_CLOCK == 4)
+        if (wl->ref_clock == CONF_REF_CLK_19_2_E ||
+            wl->ref_clock == CONF_REF_CLK_38_4_E ||
+            wl->ref_clock == CONF_REF_CLK_38_4_M_XTAL)
                 /* ref clk: 19.2/38.4/38.4-XTAL */
                 clk = 0x3;
-        else if (REF_CLOCK == 1 || REF_CLOCK == 3)
+        else if (wl->ref_clock == CONF_REF_CLK_26_E ||
+                 wl->ref_clock == CONF_REF_CLK_52_E)
                 /* ref clk: 26/52 */
                 clk = 0x5;
+        else
+                return -EINVAL;
 
-        if (REF_CLOCK != 0) {
+        if (wl->ref_clock != CONF_REF_CLK_19_2_E) {
                 u16 val;
                 /* Set clock type (open drain) */
                 val = wl1271_top_reg_read(wl, OCP_REG_CLK_TYPE);
@@ -493,13 +703,30 @@ int wl1271_boot(struct wl1271 *wl)
 
         wl1271_debug(DEBUG_BOOT, "pause1 0x%x", pause);
 
-        pause &= ~(WU_COUNTER_PAUSE_VAL); /* FIXME: This should probably be
-                                           * WU_COUNTER_PAUSE_VAL instead of
-                                           * 0x3ff (magic number ).  How does
-                                           * this work?! */
+        pause &= ~(WU_COUNTER_PAUSE_VAL);
         pause |= WU_COUNTER_PAUSE_VAL;
         wl1271_write32(wl, WU_COUNTER_PAUSE, pause);
 
+        return 0;
+}
+
+/* uploads NVS and firmware */
+int wl1271_load_firmware(struct wl1271 *wl)
+{
+        int ret = 0;
+        u32 tmp, clk;
+        int selected_clock = -1;
+
+        if (wl->chip.id == CHIP_ID_1283_PG20) {
+                ret = wl128x_boot_clk(wl, &selected_clock);
+                if (ret < 0)
+                        goto out;
+        } else {
+                ret = wl127x_boot_clk(wl);
+                if (ret < 0)
+                        goto out;
+        }
+
         /* Continue the ELP wake up sequence */
         wl1271_write32(wl, WELP_ARM_COMMAND, WELP_ARM_COMMAND_VAL);
         udelay(500);
@@ -515,8 +742,12 @@ int wl1271_boot(struct wl1271 *wl)
 
         wl1271_debug(DEBUG_BOOT, "clk2 0x%x", clk);
 
-        /* 2 */
-        clk |= (REF_CLOCK << 1) << 4;
+        if (wl->chip.id == CHIP_ID_1283_PG20) {
+                clk |= ((selected_clock & 0x3) << 1) << 4;
+        } else {
+                clk |= (wl->ref_clock << 1) << 4;
+        }
+
         wl1271_write32(wl, DRPW_SCRATCH_START, clk);
 
         wl1271_set_partition(wl, &part_table[PART_WORK]);
@@ -546,32 +777,47 @@ int wl1271_boot(struct wl1271 *wl)
         /* 6. read the EEPROM parameters */
         tmp = wl1271_read32(wl, SCR_PAD2);
 
-        ret = wl1271_boot_write_irq_polarity(wl);
-        if (ret < 0)
-                goto out;
-
-        /* FIXME: Need to check whether this is really what we want */
-        wl1271_write32(wl, ACX_REG_INTERRUPT_MASK,
-                       WL1271_ACX_ALL_EVENTS_VECTOR);
-
         /* WL1271: The reference driver skips steps 7 to 10 (jumps directly
          * to upload_fw) */
 
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                wl1271_top_reg_write(wl, SDIO_IO_DS, wl->conf.hci_io_ds);
+
         ret = wl1271_boot_upload_firmware(wl);
         if (ret < 0)
                 goto out;
 
+out:
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wl1271_load_firmware);
+
+int wl1271_boot(struct wl1271 *wl)
+{
+        int ret;
+
+        /* upload NVS and firmware */
+        ret = wl1271_load_firmware(wl);
+        if (ret)
+                return ret;
+
         /* 10.5 start firmware */
         ret = wl1271_boot_run_firmware(wl);
         if (ret < 0)
                 goto out;
 
+        ret = wl1271_boot_write_irq_polarity(wl);
+        if (ret < 0)
+                goto out;
+
+        wl1271_write32(wl, ACX_REG_INTERRUPT_MASK,
+                       WL1271_ACX_ALL_EVENTS_VECTOR);
+
         /* Enable firmware interrupts now */
         wl1271_boot_enable_interrupts(wl);
 
         /* set the wl1271 default filters */
-        wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
-        wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
+        wl1271_set_default_filters(wl);
 
         wl1271_event_mbox_config(wl);
 
diff --git a/drivers/net/wireless/wl12xx/wl1271_boot.h b/drivers/net/wireless/wl12xx/boot.h
index f829699d597e..e8f8255bbabe 100644
--- a/drivers/net/wireless/wl12xx/wl1271_boot.h
+++ b/drivers/net/wireless/wl12xx/boot.h
@@ -24,9 +24,10 @@
 #ifndef __BOOT_H__
 #define __BOOT_H__
 
-#include "wl1271.h"
+#include "wl12xx.h"
 
 int wl1271_boot(struct wl1271 *wl);
+int wl1271_load_firmware(struct wl1271 *wl);
 
 #define WL1271_NO_SUBBANDS 8
 #define WL1271_NO_POWER_LEVELS 4
@@ -46,7 +47,6 @@ struct wl1271_static_data {
 /* delay between retries */
 #define INIT_LOOP_DELAY 50
 
-#define REF_CLOCK            2
 #define WU_COUNTER_PAUSE_VAL 0x3FF
 #define WELP_ARM_COMMAND_VAL 0x4
 
@@ -59,6 +59,11 @@ struct wl1271_static_data {
 #define PG_VER_MASK          0x3c
 #define PG_VER_OFFSET        2
 
+#define PG_MAJOR_VER_MASK    0x3
+#define PG_MAJOR_VER_OFFSET  0x0
+#define PG_MINOR_VER_MASK    0xc
+#define PG_MINOR_VER_OFFSET  0x2
+
 #define CMD_MBOX_ADDRESS     0x407B4
 
 #define POLARITY_LOW         BIT(1)
@@ -69,4 +74,56 @@ struct wl1271_static_data {
 #define FREF_CLK_POLARITY_BITS 0xfffff8ff
 #define CLK_REQ_OUTN_SEL       0x700
 
+/* PLL configuration algorithm for wl128x */
+#define SYS_CLK_CFG_REG              0x2200
+/* Bit[0]   -  0-TCXO,  1-FREF */
+#define MCS_PLL_CLK_SEL_FREF         BIT(0)
+/* Bit[3:2] - 01-TCXO, 10-FREF */
+#define WL_CLK_REQ_TYPE_FREF         BIT(3)
+#define WL_CLK_REQ_TYPE_PG2          (BIT(3) | BIT(2))
+/* Bit[4]   -  0-TCXO,  1-FREF */
+#define PRCM_CM_EN_MUX_WLAN_FREF     BIT(4)
+
+#define TCXO_ILOAD_INT_REG           0x2264
+#define TCXO_CLK_DETECT_REG          0x2266
+
+#define TCXO_DET_FAILED              BIT(4)
+
+#define FREF_ILOAD_INT_REG           0x2084
+#define FREF_CLK_DETECT_REG          0x2086
+#define FREF_CLK_DETECT_FAIL         BIT(4)
+
+/* Use this reg for masking during driver access */
+#define WL_SPARE_REG                 0x2320
+#define WL_SPARE_VAL                 BIT(2)
+/* Bit[6:5:3] -  mask wl write SYS_CLK_CFG[8:5:2:4] */
+#define WL_SPARE_MASK_8526           (BIT(6) | BIT(5) | BIT(3))
+
+#define PLL_LOCK_COUNTERS_REG        0xD8C
+#define PLL_LOCK_COUNTERS_COEX       0x0F
+#define PLL_LOCK_COUNTERS_MCS        0xF0
+#define MCS_PLL_OVERRIDE_REG         0xD90
+#define MCS_PLL_CONFIG_REG           0xD92
+#define MCS_SEL_IN_FREQ_MASK         0x0070
+#define MCS_SEL_IN_FREQ_SHIFT        4
+#define MCS_PLL_CONFIG_REG_VAL       0x73
+#define MCS_PLL_ENABLE_HP            (BIT(0) | BIT(1))
+
+#define MCS_PLL_M_REG                0xD94
+#define MCS_PLL_N_REG                0xD96
+#define MCS_PLL_M_REG_VAL            0xC8
+#define MCS_PLL_N_REG_VAL            0x07
+
+#define SDIO_IO_DS                   0xd14
+
+/* SDIO/wSPI DS configuration values */
+enum {
+        HCI_IO_DS_8MA = 0,
+        HCI_IO_DS_4MA = 1, /* default */
+        HCI_IO_DS_6MA = 2,
+        HCI_IO_DS_2MA = 3,
+};
+
+/* end PLL configuration algorithm for wl128x */
+
 #endif
diff --git a/drivers/net/wireless/wl12xx/wl1271_cmd.c b/drivers/net/wireless/wl12xx/cmd.c
index ce503ddd5a41..42935ac72663 100644
--- a/drivers/net/wireless/wl12xx/wl1271_cmd.c
+++ b/drivers/net/wireless/wl12xx/cmd.c
@@ -29,13 +29,14 @@
 #include <linux/ieee80211.h>
 #include <linux/slab.h>
 
-#include "wl1271.h"
-#include "wl1271_reg.h"
-#include "wl1271_io.h"
-#include "wl1271_acx.h"
+#include "wl12xx.h"
+#include "reg.h"
+#include "io.h"
+#include "acx.h"
 #include "wl12xx_80211.h"
-#include "wl1271_cmd.h"
-#include "wl1271_event.h"
+#include "cmd.h"
+#include "event.h"
+#include "tx.h"
 
 #define WL1271_CMD_FAST_POLL_COUNT       50
 
@@ -62,6 +63,7 @@ int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,
         cmd->status = 0;
 
         WARN_ON(len % 4 != 0);
+        WARN_ON(test_bit(WL1271_FLAG_IN_ELP, &wl->flags));
 
         wl1271_write(wl, wl->cmd_box_addr, buf, len, false);
 
@@ -74,7 +76,7 @@ int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,
                 if (time_after(jiffies, timeout)) {
                         wl1271_error("command complete timeout");
                         ret = -ETIMEDOUT;
-                        goto out;
+                        goto fail;
                 }
 
                 poll_count++;
@@ -95,18 +97,25 @@ int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,
         if (status != CMD_STATUS_SUCCESS) {
                 wl1271_error("command execute failure %d", status);
                 ret = -EIO;
+                goto fail;
         }
 
         wl1271_write32(wl, ACX_REG_INTERRUPT_ACK,
                        WL1271_ACX_INTR_CMD_COMPLETE);
+        return 0;
 
-out:
+fail:
+        WARN_ON(1);
+        ieee80211_queue_work(wl->hw, &wl->recovery_work);
         return ret;
 }
 
 int wl1271_cmd_general_parms(struct wl1271 *wl)
 {
         struct wl1271_general_parms_cmd *gen_parms;
+        struct wl1271_ini_general_params *gp =
+                &((struct wl1271_nvs_file *)wl->nvs)->general_params;
+        bool answer = false;
         int ret;
 
         if (!wl->nvs)
@@ -118,21 +127,79 @@ int wl1271_cmd_general_parms(struct wl1271 *wl)
 
         gen_parms->test.id = TEST_CMD_INI_FILE_GENERAL_PARAM;
 
-        memcpy(&gen_parms->general_params, &wl->nvs->general_params,
-               sizeof(struct wl1271_ini_general_params));
+        memcpy(&gen_parms->general_params, gp, sizeof(*gp));
 
-        ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), 0);
-        if (ret < 0)
+        if (gp->tx_bip_fem_auto_detect)
+                answer = true;
+
+        /* Override the REF CLK from the NVS with the one from platform data */
+        gen_parms->general_params.ref_clock = wl->ref_clock;
+
+        ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer);
+        if (ret < 0) {
                 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
+                goto out;
+        }
+
+        gp->tx_bip_fem_manufacturer =
+                gen_parms->general_params.tx_bip_fem_manufacturer;
+
+        wl1271_debug(DEBUG_CMD, "FEM autodetect: %s, manufacturer: %d\n",
+                     answer ? "auto" : "manual", gp->tx_bip_fem_manufacturer);
 
+out:
+        kfree(gen_parms);
+        return ret;
+}
+
+int wl128x_cmd_general_parms(struct wl1271 *wl)
+{
+        struct wl128x_general_parms_cmd *gen_parms;
+        struct wl128x_ini_general_params *gp =
+                &((struct wl128x_nvs_file *)wl->nvs)->general_params;
+        bool answer = false;
+        int ret;
+
+        if (!wl->nvs)
+                return -ENODEV;
+
+        gen_parms = kzalloc(sizeof(*gen_parms), GFP_KERNEL);
+        if (!gen_parms)
+                return -ENOMEM;
+
+        gen_parms->test.id = TEST_CMD_INI_FILE_GENERAL_PARAM;
+
+        memcpy(&gen_parms->general_params, gp, sizeof(*gp));
+
+        if (gp->tx_bip_fem_auto_detect)
+                answer = true;
+
+        /* Replace REF and TCXO CLKs with the ones from platform data */
+        gen_parms->general_params.ref_clock = wl->ref_clock;
+        gen_parms->general_params.tcxo_ref_clock = wl->tcxo_clock;
+
+        ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer);
+        if (ret < 0) {
+                wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
+                goto out;
+        }
+
+        gp->tx_bip_fem_manufacturer =
+                gen_parms->general_params.tx_bip_fem_manufacturer;
+
+        wl1271_debug(DEBUG_CMD, "FEM autodetect: %s, manufacturer: %d\n",
+                     answer ? "auto" : "manual", gp->tx_bip_fem_manufacturer);
+
+out:
         kfree(gen_parms);
         return ret;
 }
 
 int wl1271_cmd_radio_parms(struct wl1271 *wl)
 {
+        struct wl1271_nvs_file *nvs = (struct wl1271_nvs_file *)wl->nvs;
         struct wl1271_radio_parms_cmd *radio_parms;
-        struct wl1271_ini_general_params *gp = &wl->nvs->general_params;
+        struct wl1271_ini_general_params *gp = &nvs->general_params;
         int ret;
 
         if (!wl->nvs)
@@ -145,18 +212,18 @@ int wl1271_cmd_radio_parms(struct wl1271 *wl)
         radio_parms->test.id = TEST_CMD_INI_FILE_RADIO_PARAM;
 
         /* 2.4GHz parameters */
-        memcpy(&radio_parms->static_params_2, &wl->nvs->stat_radio_params_2,
+        memcpy(&radio_parms->static_params_2, &nvs->stat_radio_params_2,
                sizeof(struct wl1271_ini_band_params_2));
         memcpy(&radio_parms->dyn_params_2,
-               &wl->nvs->dyn_radio_params_2[gp->tx_bip_fem_manufacturer].params,
+               &nvs->dyn_radio_params_2[gp->tx_bip_fem_manufacturer].params,
                sizeof(struct wl1271_ini_fem_params_2));
 
         /* 5GHz parameters */
         memcpy(&radio_parms->static_params_5,
-               &wl->nvs->stat_radio_params_5,
+               &nvs->stat_radio_params_5,
                sizeof(struct wl1271_ini_band_params_5));
         memcpy(&radio_parms->dyn_params_5,
-               &wl->nvs->dyn_radio_params_5[gp->tx_bip_fem_manufacturer].params,
+               &nvs->dyn_radio_params_5[gp->tx_bip_fem_manufacturer].params,
                sizeof(struct wl1271_ini_fem_params_5));
 
         wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
@@ -170,11 +237,88 @@ int wl1271_cmd_radio_parms(struct wl1271 *wl)
         return ret;
 }
 
+int wl128x_cmd_radio_parms(struct wl1271 *wl)
+{
+        struct wl128x_nvs_file *nvs = (struct wl128x_nvs_file *)wl->nvs;
+        struct wl128x_radio_parms_cmd *radio_parms;
+        struct wl128x_ini_general_params *gp = &nvs->general_params;
+        int ret;
+
+        if (!wl->nvs)
+                return -ENODEV;
+
+        radio_parms = kzalloc(sizeof(*radio_parms), GFP_KERNEL);
+        if (!radio_parms)
+                return -ENOMEM;
+
+        radio_parms->test.id = TEST_CMD_INI_FILE_RADIO_PARAM;
+
+        /* 2.4GHz parameters */
+        memcpy(&radio_parms->static_params_2, &nvs->stat_radio_params_2,
+               sizeof(struct wl128x_ini_band_params_2));
+        memcpy(&radio_parms->dyn_params_2,
+               &nvs->dyn_radio_params_2[gp->tx_bip_fem_manufacturer].params,
+               sizeof(struct wl128x_ini_fem_params_2));
+
+        /* 5GHz parameters */
+        memcpy(&radio_parms->static_params_5,
+               &nvs->stat_radio_params_5,
+               sizeof(struct wl128x_ini_band_params_5));
+        memcpy(&radio_parms->dyn_params_5,
+               &nvs->dyn_radio_params_5[gp->tx_bip_fem_manufacturer].params,
+               sizeof(struct wl128x_ini_fem_params_5));
+
+        radio_parms->fem_vendor_and_options = nvs->fem_vendor_and_options;
+
+        wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
+                    radio_parms, sizeof(*radio_parms));
+
+        ret = wl1271_cmd_test(wl, radio_parms, sizeof(*radio_parms), 0);
+        if (ret < 0)
+                wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
+
+        kfree(radio_parms);
+        return ret;
+}
+
+int wl1271_cmd_ext_radio_parms(struct wl1271 *wl)
+{
+        struct wl1271_ext_radio_parms_cmd *ext_radio_parms;
+        struct conf_rf_settings *rf = &wl->conf.rf;
+        int ret;
+
+        if (!wl->nvs)
+                return -ENODEV;
+
+        ext_radio_parms = kzalloc(sizeof(*ext_radio_parms), GFP_KERNEL);
+        if (!ext_radio_parms)
+                return -ENOMEM;
+
+        ext_radio_parms->test.id = TEST_CMD_INI_FILE_RF_EXTENDED_PARAM;
+
+        memcpy(ext_radio_parms->tx_per_channel_power_compensation_2,
+               rf->tx_per_channel_power_compensation_2,
+               CONF_TX_PWR_COMPENSATION_LEN_2);
+        memcpy(ext_radio_parms->tx_per_channel_power_compensation_5,
+               rf->tx_per_channel_power_compensation_5,
+               CONF_TX_PWR_COMPENSATION_LEN_5);
+
+        wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_EXT_RADIO_PARAM: ",
+                    ext_radio_parms, sizeof(*ext_radio_parms));
+
+        ret = wl1271_cmd_test(wl, ext_radio_parms, sizeof(*ext_radio_parms), 0);
+        if (ret < 0)
+                wl1271_warning("TEST_CMD_INI_FILE_RF_EXTENDED_PARAM failed");
+
+        kfree(ext_radio_parms);
+        return ret;
+}
+
 /*
  * Poll the mailbox event field until any of the bits in the mask is set or a
  * timeout occurs (WL1271_EVENT_TIMEOUT in msecs)
  */
-static int wl1271_cmd_wait_for_event(struct wl1271 *wl, u32 mask)
+static int wl1271_cmd_wait_for_event_or_timeout(struct wl1271 *wl, u32 mask)
 {
         u32 events_vector, event;
         unsigned long timeout;
@@ -182,8 +326,11 @@ static int wl1271_cmd_wait_for_event(struct wl1271 *wl, u32 mask)
         timeout = jiffies + msecs_to_jiffies(WL1271_EVENT_TIMEOUT);
 
         do {
-                if (time_after(jiffies, timeout))
+                if (time_after(jiffies, timeout)) {
+                        wl1271_debug(DEBUG_CMD, "timeout waiting for event %d",
+                                     (int)mask);
                         return -ETIMEDOUT;
+                }
 
                 msleep(1);
 
@@ -199,6 +346,19 @@ static int wl1271_cmd_wait_for_event(struct wl1271 *wl, u32 mask)
         return 0;
 }
 
+static int wl1271_cmd_wait_for_event(struct wl1271 *wl, u32 mask)
+{
+        int ret;
+
+        ret = wl1271_cmd_wait_for_event_or_timeout(wl, mask);
+        if (ret != 0) {
+                ieee80211_queue_work(wl->hw, &wl->recovery_work);
+                return ret;
+        }
+
+        return 0;
+}
+
 int wl1271_cmd_join(struct wl1271 *wl, u8 bss_type)
 {
         struct wl1271_cmd_join *join;
@@ -222,6 +382,7 @@ int wl1271_cmd_join(struct wl1271 *wl, u8 bss_type)
         join->rx_filter_options = cpu_to_le32(wl->rx_filter);
         join->bss_type = bss_type;
         join->basic_rate_set = cpu_to_le32(wl->basic_rate_set);
+        join->supported_rate_set = cpu_to_le32(wl->rate_set);
 
         if (wl->band == IEEE80211_BAND_5GHZ)
                 join->bss_type |= WL1271_JOIN_CMD_BSS_TYPE_5GHZ;
@@ -239,6 +400,9 @@ int wl1271_cmd_join(struct wl1271 *wl, u8 bss_type)
         wl->tx_security_last_seq = 0;
         wl->tx_security_seq = 0;
 
+        wl1271_debug(DEBUG_CMD, "cmd join: basic_rate_set=0x%x, rate_set=0x%x",
+                join->basic_rate_set, join->supported_rate_set);
+
         ret = wl1271_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join), 0);
         if (ret < 0) {
                 wl1271_error("failed to initiate cmd join");
@@ -290,7 +454,7 @@ int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer)
  * @wl: wl struct
  * @id: acx id
  * @buf: buffer for the response, including all headers, must work with dma
- * @len: lenght of buf
+ * @len: length of buf
  */
 int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf, size_t len)
 {
@@ -390,18 +554,11 @@ out:
         return ret;
 }
 
-int wl1271_cmd_ps_mode(struct wl1271 *wl, u8 ps_mode, bool send)
+int wl1271_cmd_ps_mode(struct wl1271 *wl, u8 ps_mode)
 {
         struct wl1271_cmd_ps_params *ps_params = NULL;
         int ret = 0;
 
-        /* FIXME: this should be in ps.c */
-        ret = wl1271_acx_wake_up_conditions(wl);
-        if (ret < 0) {
-                wl1271_error("couldn't set wake up conditions");
-                goto out;
-        }
-
         wl1271_debug(DEBUG_CMD, "cmd set ps mode");
 
         ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
@@ -411,10 +568,6 @@ int wl1271_cmd_ps_mode(struct wl1271 *wl, u8 ps_mode, bool send)
         }
 
         ps_params->ps_mode = ps_mode;
-        ps_params->send_null_data = send;
-        ps_params->retries = 5;
-        ps_params->hang_over_period = 1;
-        ps_params->null_data_rate = cpu_to_le32(wl->basic_rate_set);
 
         ret = wl1271_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
                               sizeof(*ps_params), 0);
@@ -428,41 +581,6 @@ out:
         return ret;
 }
 
-int wl1271_cmd_read_memory(struct wl1271 *wl, u32 addr, void *answer,
-                           size_t len)
-{
-        struct cmd_read_write_memory *cmd;
-        int ret = 0;
-
-        wl1271_debug(DEBUG_CMD, "cmd read memory");
-
-        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
-        if (!cmd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        WARN_ON(len > MAX_READ_SIZE);
-        len = min_t(size_t, len, MAX_READ_SIZE);
-
-        cmd->addr = cpu_to_le32(addr);
-        cmd->size = cpu_to_le32(len);
-
-        ret = wl1271_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd),
-                              sizeof(*cmd));
-        if (ret < 0) {
-                wl1271_error("read memory command failed: %d", ret);
-                goto out;
-        }
-
-        /* the read command got in */
-        memcpy(answer, cmd->value, len);
-
-out:
-        kfree(cmd);
-        return ret;
-}
-
 int wl1271_cmd_template_set(struct wl1271 *wl, u16 template_id,
                             void *buf, size_t buf_len, int index, u32 rates)
 {
@@ -483,8 +601,8 @@ int wl1271_cmd_template_set(struct wl1271 *wl, u16 template_id,
         cmd->len = cpu_to_le16(buf_len);
         cmd->template_type = template_id;
         cmd->enabled_rates = cpu_to_le32(rates);
-        cmd->short_retry_limit = wl->conf.tx.rc_conf.short_retry_limit;
-        cmd->long_retry_limit = wl->conf.tx.rc_conf.long_retry_limit;
+        cmd->short_retry_limit = wl->conf.tx.tmpl_short_retry_limit;
+        cmd->long_retry_limit = wl->conf.tx.tmpl_long_retry_limit;
         cmd->index = index;
 
         if (buf)
@@ -523,7 +641,7 @@ int wl1271_cmd_build_null_data(struct wl1271 *wl)
         }
 
         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, ptr, size, 0,
-                                      WL1271_RATE_AUTOMATIC);
+                                      wl->basic_rate);
 
 out:
         dev_kfree_skb(skb);
@@ -546,7 +664,7 @@ int wl1271_cmd_build_klv_null_data(struct wl1271 *wl)
         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_KLV,
                                       skb->data, skb->len,
                                       CMD_TEMPL_KLV_IDX_NULL_DATA,
-                                      WL1271_RATE_AUTOMATIC);
+                                      wl->basic_rate);
 
 out:
         dev_kfree_skb(skb);
@@ -604,6 +722,75 @@ out:
         return ret;
 }
 
+struct sk_buff *wl1271_cmd_build_ap_probe_req(struct wl1271 *wl,
+                                              struct sk_buff *skb)
+{
+        int ret;
+
+        if (!skb)
+                skb = ieee80211_ap_probereq_get(wl->hw, wl->vif);
+        if (!skb)
+                goto out;
+
+        wl1271_dump(DEBUG_SCAN, "AP PROBE REQ: ", skb->data, skb->len);
+
+        if (wl->band == IEEE80211_BAND_2GHZ)
+                ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4,
+                                              skb->data, skb->len, 0,
+                                              wl->conf.tx.basic_rate);
+        else
+                ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_5,
+                                              skb->data, skb->len, 0,
+                                              wl->conf.tx.basic_rate_5);
+
+        if (ret < 0)
+                wl1271_error("Unable to set ap probe request template.");
+
+out:
+        return skb;
+}
+
+int wl1271_cmd_build_arp_rsp(struct wl1271 *wl, __be32 ip_addr)
+{
+        int ret;
+        struct wl12xx_arp_rsp_template tmpl;
+        struct ieee80211_hdr_3addr *hdr;
+        struct arphdr *arp_hdr;
+
+        memset(&tmpl, 0, sizeof(tmpl));
+
+        /* mac80211 header */
+        hdr = &tmpl.hdr;
+        hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
+                                         IEEE80211_STYPE_DATA |
+                                         IEEE80211_FCTL_TODS);
+        memcpy(hdr->addr1, wl->vif->bss_conf.bssid, ETH_ALEN);
+        memcpy(hdr->addr2, wl->vif->addr, ETH_ALEN);
+        memset(hdr->addr3, 0xff, ETH_ALEN);
+
+        /* llc layer */
+        memcpy(tmpl.llc_hdr, rfc1042_header, sizeof(rfc1042_header));
+        tmpl.llc_type = cpu_to_be16(ETH_P_ARP);
+
+        /* arp header */
+        arp_hdr = &tmpl.arp_hdr;
+        arp_hdr->ar_hrd = cpu_to_be16(ARPHRD_ETHER);
+        arp_hdr->ar_pro = cpu_to_be16(ETH_P_IP);
+        arp_hdr->ar_hln = ETH_ALEN;
+        arp_hdr->ar_pln = 4;
+        arp_hdr->ar_op = cpu_to_be16(ARPOP_REPLY);
+
+        /* arp payload */
+        memcpy(tmpl.sender_hw, wl->vif->addr, ETH_ALEN);
+        tmpl.sender_ip = ip_addr;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_ARP_RSP,
+                                      &tmpl, sizeof(tmpl), 0,
+                                      wl->basic_rate);
+
+        return ret;
+}
+
 int wl1271_build_qos_null_data(struct wl1271 *wl)
 {
         struct ieee80211_qos_hdr template;
@@ -623,12 +810,12 @@ int wl1271_build_qos_null_data(struct wl1271 *wl)
 
         return wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, &template,
                                        sizeof(template), 0,
-                                       WL1271_RATE_AUTOMATIC);
+                                       wl->basic_rate);
 }
 
-int wl1271_cmd_set_default_wep_key(struct wl1271 *wl, u8 id)
+int wl1271_cmd_set_sta_default_wep_key(struct wl1271 *wl, u8 id)
 {
-        struct wl1271_cmd_set_keys *cmd;
+        struct wl1271_cmd_set_sta_keys *cmd;
         int ret = 0;
 
         wl1271_debug(DEBUG_CMD, "cmd set_default_wep_key %d", id);
@@ -655,11 +842,42 @@ out:
         return ret;
 }
 
-int wl1271_cmd_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
+int wl1271_cmd_set_ap_default_wep_key(struct wl1271 *wl, u8 id)
+{
+        struct wl1271_cmd_set_ap_keys *cmd;
+        int ret = 0;
+
+        wl1271_debug(DEBUG_CMD, "cmd set_ap_default_wep_key %d", id);
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (!cmd) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        cmd->hlid = WL1271_AP_BROADCAST_HLID;
+        cmd->key_id = id;
+        cmd->lid_key_type = WEP_DEFAULT_LID_TYPE;
+        cmd->key_action = cpu_to_le16(KEY_SET_ID);
+        cmd->key_type = KEY_WEP;
+
+        ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_warning("cmd set_ap_default_wep_key failed: %d", ret);
+                goto out;
+        }
+
+out:
+        kfree(cmd);
+
+        return ret;
+}
+
+int wl1271_cmd_set_sta_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
                        u8 key_size, const u8 *key, const u8 *addr,
                        u32 tx_seq_32, u16 tx_seq_16)
 {
-        struct wl1271_cmd_set_keys *cmd;
+        struct wl1271_cmd_set_sta_keys *cmd;
         int ret = 0;
 
         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
@@ -712,6 +930,67 @@ out:
         return ret;
 }
 
+int wl1271_cmd_set_ap_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
+                        u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
+                        u16 tx_seq_16)
+{
+        struct wl1271_cmd_set_ap_keys *cmd;
+        int ret = 0;
+        u8 lid_type;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (!cmd)
+                return -ENOMEM;
+
+        if (hlid == WL1271_AP_BROADCAST_HLID) {
+                if (key_type == KEY_WEP)
+                        lid_type = WEP_DEFAULT_LID_TYPE;
+                else
+                        lid_type = BROADCAST_LID_TYPE;
+        } else {
+                lid_type = UNICAST_LID_TYPE;
+        }
+
+        wl1271_debug(DEBUG_CRYPT, "ap key action: %d id: %d lid: %d type: %d"
+                     " hlid: %d", (int)action, (int)id, (int)lid_type,
+                     (int)key_type, (int)hlid);
+
+        cmd->lid_key_type = lid_type;
+        cmd->hlid = hlid;
+        cmd->key_action = cpu_to_le16(action);
+        cmd->key_size = key_size;
+        cmd->key_type = key_type;
+        cmd->key_id = id;
+        cmd->ac_seq_num16[0] = cpu_to_le16(tx_seq_16);
+        cmd->ac_seq_num32[0] = cpu_to_le32(tx_seq_32);
+
+        if (key_type == KEY_TKIP) {
+                /*
+                 * We get the key in the following form:
+                 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
+                 * but the target is expecting:
+                 * TKIP - RX MIC - TX MIC
+                 */
+                memcpy(cmd->key, key, 16);
+                memcpy(cmd->key + 16, key + 24, 8);
+                memcpy(cmd->key + 24, key + 16, 8);
+        } else {
+                memcpy(cmd->key, key, key_size);
+        }
+
+        wl1271_dump(DEBUG_CRYPT, "TARGET AP KEY: ", cmd, sizeof(*cmd));
+
+        ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_warning("could not set ap keys");
+                goto out;
+        }
+
+out:
+        kfree(cmd);
+        return ret;
+}
+
 int wl1271_cmd_disconnect(struct wl1271 *wl)
 {
         struct wl1271_cmd_disconnect *cmd;
@@ -746,3 +1025,208 @@ out_free:
 out:
         return ret;
 }
+
+int wl1271_cmd_set_sta_state(struct wl1271 *wl)
+{
+        struct wl1271_cmd_set_sta_state *cmd;
+        int ret = 0;
+
+        wl1271_debug(DEBUG_CMD, "cmd set sta state");
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (!cmd) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        cmd->state = WL1271_CMD_STA_STATE_CONNECTED;
+
+        ret = wl1271_cmd_send(wl, CMD_SET_STA_STATE, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_error("failed to send set STA state command");
+                goto out_free;
+        }
+
+out_free:
+        kfree(cmd);
+
+out:
+        return ret;
+}
+
+int wl1271_cmd_start_bss(struct wl1271 *wl)
+{
+        struct wl1271_cmd_bss_start *cmd;
+        struct ieee80211_bss_conf *bss_conf = &wl->vif->bss_conf;
+        int ret;
+
+        wl1271_debug(DEBUG_CMD, "cmd start bss");
+
+        /*
+         * FIXME: We currently do not support hidden SSID. The real SSID
+         * should be fetched from mac80211 first.
+         */
+        if (wl->ssid_len == 0) {
+                wl1271_warning("Hidden SSID currently not supported for AP");
+                ret = -EINVAL;
+                goto out;
+        }
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (!cmd) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        memcpy(cmd->bssid, bss_conf->bssid, ETH_ALEN);
+
+        cmd->aging_period = cpu_to_le16(WL1271_AP_DEF_INACTIV_SEC);
+        cmd->bss_index = WL1271_AP_BSS_INDEX;
+        cmd->global_hlid = WL1271_AP_GLOBAL_HLID;
+        cmd->broadcast_hlid = WL1271_AP_BROADCAST_HLID;
+        cmd->basic_rate_set = cpu_to_le32(wl->basic_rate_set);
+        cmd->beacon_interval = cpu_to_le16(wl->beacon_int);
+        cmd->dtim_interval = bss_conf->dtim_period;
+        cmd->beacon_expiry = WL1271_AP_DEF_BEACON_EXP;
+        cmd->channel = wl->channel;
+        cmd->ssid_len = wl->ssid_len;
+        cmd->ssid_type = SSID_TYPE_PUBLIC;
+        memcpy(cmd->ssid, wl->ssid, wl->ssid_len);
+
+        switch (wl->band) {
+        case IEEE80211_BAND_2GHZ:
+                cmd->band = RADIO_BAND_2_4GHZ;
+                break;
+        case IEEE80211_BAND_5GHZ:
+                cmd->band = RADIO_BAND_5GHZ;
+                break;
+        default:
+                wl1271_warning("bss start - unknown band: %d", (int)wl->band);
+                cmd->band = RADIO_BAND_2_4GHZ;
+                break;
+        }
+
+        ret = wl1271_cmd_send(wl, CMD_BSS_START, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_error("failed to initiate cmd start bss");
+                goto out_free;
+        }
+
+out_free:
+        kfree(cmd);
+
+out:
+        return ret;
+}
+
+int wl1271_cmd_stop_bss(struct wl1271 *wl)
+{
+        struct wl1271_cmd_bss_start *cmd;
+        int ret;
+
+        wl1271_debug(DEBUG_CMD, "cmd stop bss");
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (!cmd) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        cmd->bss_index = WL1271_AP_BSS_INDEX;
+
+        ret = wl1271_cmd_send(wl, CMD_BSS_STOP, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_error("failed to initiate cmd stop bss");
+                goto out_free;
+        }
+
+out_free:
+        kfree(cmd);
+
+out:
+        return ret;
+}
+
+int wl1271_cmd_add_sta(struct wl1271 *wl, struct ieee80211_sta *sta, u8 hlid)
+{
+        struct wl1271_cmd_add_sta *cmd;
+        int ret;
+
+        wl1271_debug(DEBUG_CMD, "cmd add sta %d", (int)hlid);
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (!cmd) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* currently we don't support UAPSD */
+        cmd->sp_len = 0;
+
+        memcpy(cmd->addr, sta->addr, ETH_ALEN);
+        cmd->bss_index = WL1271_AP_BSS_INDEX;
+        cmd->aid = sta->aid;
+        cmd->hlid = hlid;
+
+        /*
+         * FIXME: Does STA support QOS? We need to propagate this info from
+         * hostapd. Currently not that important since this is only used for
+         * sending the correct flavor of null-data packet in response to a
+         * trigger.
+         */
+        cmd->wmm = 0;
+
+        cmd->supported_rates = cpu_to_le32(wl1271_tx_enabled_rates_get(wl,
+                                                sta->supp_rates[wl->band]));
+
+        wl1271_debug(DEBUG_CMD, "new sta rates: 0x%x", cmd->supported_rates);
+
+        ret = wl1271_cmd_send(wl, CMD_ADD_STA, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_error("failed to initiate cmd add sta");
+                goto out_free;
+        }
+
+out_free:
+        kfree(cmd);
+
+out:
+        return ret;
+}
+
+int wl1271_cmd_remove_sta(struct wl1271 *wl, u8 hlid)
+{
+        struct wl1271_cmd_remove_sta *cmd;
+        int ret;
+
+        wl1271_debug(DEBUG_CMD, "cmd remove sta %d", (int)hlid);
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (!cmd) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        cmd->hlid = hlid;
+        /* We never send a deauth, mac80211 is in charge of this */
+        cmd->reason_opcode = 0;
+        cmd->send_deauth_flag = 0;
+
+        ret = wl1271_cmd_send(wl, CMD_REMOVE_STA, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_error("failed to initiate cmd remove sta");
+                goto out_free;
+        }
+
+        /*
+         * We are ok with a timeout here. The event is sometimes not sent
+         * due to a firmware bug.
+         */
+        wl1271_cmd_wait_for_event_or_timeout(wl, STA_REMOVE_COMPLETE_EVENT_ID);
+
+out_free:
+        kfree(cmd);
+
+out:
+        return ret;
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_cmd.h b/drivers/net/wireless/wl12xx/cmd.h
index af577ee8eb02..5cac95d9480c 100644
--- a/drivers/net/wireless/wl12xx/wl1271_cmd.h
+++ b/drivers/net/wireless/wl12xx/cmd.h
@@ -22,23 +22,26 @@
  *
  */
 
-#ifndef __WL1271_CMD_H__
-#define __WL1271_CMD_H__
+#ifndef __CMD_H__
+#define __CMD_H__
 
-#include "wl1271.h"
+#include "wl12xx.h"
 
 struct acx_header;
 
 int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,
                     size_t res_len);
 int wl1271_cmd_general_parms(struct wl1271 *wl);
+int wl128x_cmd_general_parms(struct wl1271 *wl);
 int wl1271_cmd_radio_parms(struct wl1271 *wl);
+int wl128x_cmd_radio_parms(struct wl1271 *wl);
+int wl1271_cmd_ext_radio_parms(struct wl1271 *wl);
 int wl1271_cmd_join(struct wl1271 *wl, u8 bss_type);
 int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer);
 int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf, size_t len);
 int wl1271_cmd_configure(struct wl1271 *wl, u16 id, void *buf, size_t len);
 int wl1271_cmd_data_path(struct wl1271 *wl, bool enable);
-int wl1271_cmd_ps_mode(struct wl1271 *wl, u8 ps_mode, bool send);
+int wl1271_cmd_ps_mode(struct wl1271 *wl, u8 ps_mode);
 int wl1271_cmd_read_memory(struct wl1271 *wl, u32 addr, void *answer,
                            size_t len);
 int wl1271_cmd_template_set(struct wl1271 *wl, u16 template_id,
@@ -48,13 +51,25 @@ int wl1271_cmd_build_ps_poll(struct wl1271 *wl, u16 aid);
 int wl1271_cmd_build_probe_req(struct wl1271 *wl,
                                const u8 *ssid, size_t ssid_len,
                                const u8 *ie, size_t ie_len, u8 band);
+struct sk_buff *wl1271_cmd_build_ap_probe_req(struct wl1271 *wl,
+                                              struct sk_buff *skb);
+int wl1271_cmd_build_arp_rsp(struct wl1271 *wl, __be32 ip_addr);
 int wl1271_build_qos_null_data(struct wl1271 *wl);
 int wl1271_cmd_build_klv_null_data(struct wl1271 *wl);
-int wl1271_cmd_set_default_wep_key(struct wl1271 *wl, u8 id);
-int wl1271_cmd_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
-                       u8 key_size, const u8 *key, const u8 *addr,
-                       u32 tx_seq_32, u16 tx_seq_16);
+int wl1271_cmd_set_sta_default_wep_key(struct wl1271 *wl, u8 id);
+int wl1271_cmd_set_ap_default_wep_key(struct wl1271 *wl, u8 id);
+int wl1271_cmd_set_sta_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
+                           u8 key_size, const u8 *key, const u8 *addr,
+                           u32 tx_seq_32, u16 tx_seq_16);
+int wl1271_cmd_set_ap_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
+                          u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
+                          u16 tx_seq_16);
 int wl1271_cmd_disconnect(struct wl1271 *wl);
+int wl1271_cmd_set_sta_state(struct wl1271 *wl);
+int wl1271_cmd_start_bss(struct wl1271 *wl);
+int wl1271_cmd_stop_bss(struct wl1271 *wl);
+int wl1271_cmd_add_sta(struct wl1271 *wl, struct ieee80211_sta *sta, u8 hlid);
+int wl1271_cmd_remove_sta(struct wl1271 *wl, u8 hlid);
 
 enum wl1271_commands {
         CMD_INTERROGATE     = 1,    /*use this to read information elements*/
@@ -93,6 +108,12 @@ enum wl1271_commands {
         CMD_STOP_PERIODIC_SCAN       = 51,
         CMD_SET_STA_STATE            = 52,
 
+        /* AP mode commands */
+        CMD_BSS_START                = 60,
+        CMD_BSS_STOP                 = 61,
+        CMD_ADD_STA                  = 62,
+        CMD_REMOVE_STA               = 63,
+
         NUM_COMMANDS,
         MAX_COMMAND_ID = 0xFFFF,
 };
@@ -120,6 +141,15 @@ enum cmd_templ {
         CMD_TEMPL_CTS,           /*
                                   * For CTS-to-self (FastCTS) mechanism
                                   * for BT/WLAN coexistence (SoftGemini). */
+        CMD_TEMPL_ARP_RSP,
+        CMD_TEMPL_LINK_MEASUREMENT_REPORT,
+
+        /* AP-mode specific */
+        CMD_TEMPL_AP_BEACON = 13,
+        CMD_TEMPL_AP_PROBE_RESPONSE,
+        CMD_TEMPL_AP_ARP_RSP,
+        CMD_TEMPL_DEAUTH_AP,
+
         CMD_TEMPL_MAX = 0xff
 };
 
@@ -160,41 +190,6 @@ enum {
         MAX_COMMAND_STATUS              = 0xff
 };
 
-
-/*
- * CMD_READ_MEMORY
- *
- * The host issues this command to read the WiLink device memory/registers.
- *
- * Note: The Base Band address has special handling (16 bits registers and
- * addresses). For more information, see the hardware specification.
- */
-/*
- * CMD_WRITE_MEMORY
- *
- * The host issues this command to write the WiLink device memory/registers.
- *
- * The Base Band address has special handling (16 bits registers and
- * addresses). For more information, see the hardware specification.
- */
-#define MAX_READ_SIZE 256
-
-struct cmd_read_write_memory {
-        struct wl1271_cmd_header header;
-
-        /* The address of the memory to read from or write to.*/
-        __le32 addr;
-
-        /* The amount of data in bytes to read from or write to the WiLink
-         * device.*/
-        __le32 size;
-
-        /* The actual value read from or written to the Wilink. The source
-           of this field is the Host in WRITE command or the Wilink in READ
-           command. */
-        u8 value[MAX_READ_SIZE];
-} __packed;
-
 #define CMDMBOX_HEADER_LEN 4
 #define CMDMBOX_INFO_ELEM_HEADER_LEN 4
 
@@ -224,6 +219,7 @@ struct wl1271_cmd_join {
          * ACK or CTS frames).
          */
         __le32 basic_rate_set;
+        __le32 supported_rate_set;
         u8 dtim_interval;
         /*
          * bits 0-2: This bitwise field specifies the type
@@ -286,20 +282,11 @@ struct wl1271_cmd_ps_params {
         struct wl1271_cmd_header header;
 
         u8 ps_mode; /* STATION_* */
-        u8 send_null_data; /* Do we have to send NULL data packet ? */
-        u8 retries; /* Number of retires for the initial NULL data packet */
-
-         /*
-          * TUs during which the target stays awake after switching
-          * to power save mode.
-          */
-        u8 hang_over_period;
-        __le32 null_data_rate;
+        u8 padding[3];
 } __packed;
 
 /* HW encryption keys */
 #define NUM_ACCESS_CATEGORIES_COPY 4
-#define MAX_KEY_SIZE 32
 
 enum wl1271_cmd_key_action {
         KEY_ADD_OR_REPLACE = 1,
@@ -313,12 +300,12 @@ enum wl1271_cmd_key_type {
         KEY_WEP  = 1,
         KEY_TKIP = 2,
         KEY_AES  = 3,
-        KEY_GEM  = 4
+        KEY_GEM  = 4,
 };
 
 /* FIXME: Add description for key-types */
 
-struct wl1271_cmd_set_keys {
+struct wl1271_cmd_set_sta_keys {
         struct wl1271_cmd_header header;
 
         /* Ignored for default WEP key */
@@ -347,6 +334,57 @@ struct wl1271_cmd_set_keys {
         __le32 ac_seq_num32[NUM_ACCESS_CATEGORIES_COPY];
 } __packed;
 
+enum wl1271_cmd_lid_key_type {
+        UNICAST_LID_TYPE     = 0,
+        BROADCAST_LID_TYPE   = 1,
+        WEP_DEFAULT_LID_TYPE = 2
+};
+
+struct wl1271_cmd_set_ap_keys {
+        struct wl1271_cmd_header header;
+
+        /*
+         * Indicates whether the HLID is a unicast key set
+         * or broadcast key set. A special value 0xFF is
+         * used to indicate that the HLID is on WEP-default
+         * (multi-hlids). of type wl1271_cmd_lid_key_type.
+         */
+        u8 hlid;
+
+        /*
+         * In WEP-default network (hlid == 0xFF) used to
+         * indicate which network STA/IBSS/AP role should be
+         * changed
+         */
+        u8 lid_key_type;
+
+        /*
+         * Key ID - For TKIP and AES key types, this field
+         * indicates the value that should be inserted into
+         * the KeyID field of frames transmitted using this
+         * key entry. For broadcast keys the index use as a
+         * marker for TX/RX key.
+         * For WEP default network (HLID=0xFF), this field
+         * indicates the ID of the key to add or remove.
+         */
+        u8 key_id;
+        u8 reserved_1;
+
+        /* key_action_e */
+        __le16 key_action;
+
+        /* key size in bytes */
+        u8 key_size;
+
+        /* key_type_e */
+        u8 key_type;
+
+        /* This field holds the security key data to add to the STA table */
+        u8 key[MAX_KEY_SIZE];
+        __le16 ac_seq_num16[NUM_ACCESS_CATEGORIES_COPY];
+        __le32 ac_seq_num32[NUM_ACCESS_CATEGORIES_COPY];
+} __packed;
+
 struct wl1271_cmd_test_header {
         u8 id;
         u8 padding[3];
@@ -358,13 +396,11 @@ enum wl1271_channel_tune_bands {
         WL1271_CHANNEL_TUNE_BAND_4_9
 };
 
-#define WL1271_PD_REFERENCE_POINT_BAND_B_G 0
+#define WL1271_PD_REFERENCE_POINT_BAND_B_G  0
 
-#define TEST_CMD_P2G_CAL                   0x02
-#define TEST_CMD_CHANNEL_TUNE              0x0d
-#define TEST_CMD_UPDATE_PD_REFERENCE_POINT 0x1d
-#define TEST_CMD_INI_FILE_RADIO_PARAM      0x19
-#define TEST_CMD_INI_FILE_GENERAL_PARAM    0x1E
+#define TEST_CMD_INI_FILE_RADIO_PARAM       0x19
+#define TEST_CMD_INI_FILE_GENERAL_PARAM     0x1E
+#define TEST_CMD_INI_FILE_RF_EXTENDED_PARAM 0x26
 
 struct wl1271_general_parms_cmd {
         struct wl1271_cmd_header header;
@@ -381,6 +417,21 @@ struct wl1271_general_parms_cmd {
         u8 padding[3];
 } __packed;
 
+struct wl128x_general_parms_cmd {
+        struct wl1271_cmd_header header;
+
+        struct wl1271_cmd_test_header test;
+
+        struct wl128x_ini_general_params general_params;
+
+        u8 sr_debug_table[WL1271_INI_MAX_SMART_REFLEX_PARAM];
+        u8 sr_sen_n_p;
+        u8 sr_sen_n_p_gain;
+        u8 sr_sen_nrn;
+        u8 sr_sen_prn;
+        u8 padding[3];
+} __packed;
+
 struct wl1271_radio_parms_cmd {
         struct wl1271_cmd_header header;
 
@@ -397,51 +448,33 @@ struct wl1271_radio_parms_cmd {
         u8 padding3[2];
 } __packed;
 
-struct wl1271_cmd_cal_channel_tune {
+struct wl128x_radio_parms_cmd {
         struct wl1271_cmd_header header;
 
         struct wl1271_cmd_test_header test;
 
-        u8 band;
-        u8 channel;
-
-        __le16 radio_status;
-} __packed;
-
-struct wl1271_cmd_cal_update_ref_point {
-        struct wl1271_cmd_header header;
+        /* Static radio parameters */
+        struct wl128x_ini_band_params_2 static_params_2;
+        struct wl128x_ini_band_params_5 static_params_5;
 
-        struct wl1271_cmd_test_header test;
+        u8 fem_vendor_and_options;
 
-        __le32 ref_power;
-        __le32 ref_detector;
-        u8  sub_band;
-        u8  padding[3];
+        /* Dynamic radio parameters */
+        struct wl128x_ini_fem_params_2 dyn_params_2;
+        u8 padding2;
+        struct wl128x_ini_fem_params_5 dyn_params_5;
 } __packed;
 
-#define MAX_TLV_LENGTH         400
-#define MAX_NVS_VERSION_LENGTH 12
-
-#define WL1271_CAL_P2G_BAND_B_G BIT(0)
-
-struct wl1271_cmd_cal_p2g {
+struct wl1271_ext_radio_parms_cmd {
         struct wl1271_cmd_header header;
 
         struct wl1271_cmd_test_header test;
 
-        __le16 len;
-        u8  buf[MAX_TLV_LENGTH];
-        u8  type;
-        u8  padding;
-
-        __le16 radio_status;
-        u8  nvs_version[MAX_NVS_VERSION_LENGTH];
-
-        u8  sub_band_mask;
-        u8  padding2;
+        u8 tx_per_channel_power_compensation_2[CONF_TX_PWR_COMPENSATION_LEN_2];
+        u8 tx_per_channel_power_compensation_5[CONF_TX_PWR_COMPENSATION_LEN_5];
+        u8 padding[3];
 } __packed;
 
-
 /*
  * There are three types of disconnections:
  *
@@ -469,4 +502,77 @@ struct wl1271_cmd_disconnect {
         u8  padding;
 } __packed;
 
+#define WL1271_CMD_STA_STATE_CONNECTED  1
+
+struct wl1271_cmd_set_sta_state {
+        struct wl1271_cmd_header header;
+
+        u8 state;
+        u8 padding[3];
+} __packed;
+
+enum wl1271_ssid_type {
+        SSID_TYPE_PUBLIC = 0,
+        SSID_TYPE_HIDDEN = 1
+};
+
+struct wl1271_cmd_bss_start {
+        struct wl1271_cmd_header header;
+
+        /* wl1271_ssid_type */
+        u8 ssid_type;
+        u8 ssid_len;
+        u8 ssid[IW_ESSID_MAX_SIZE];
+        u8 padding_1[2];
+
+        /* Basic rate set */
+        __le32 basic_rate_set;
+        /* Aging period in seconds*/
+        __le16 aging_period;
+
+        /*
+         * This field specifies the time between target beacon
+         * transmission times (TBTTs), in time units (TUs).
+         * Valid values are 1 to 1024.
+         */
+        __le16 beacon_interval;
+        u8 bssid[ETH_ALEN];
+        u8 bss_index;
+        /* Radio band */
+        u8 band;
+        u8 channel;
+        /* The host link id for the AP's global queue */
+        u8 global_hlid;
+        /* The host link id for the AP's broadcast queue */
+        u8 broadcast_hlid;
+        /* DTIM count */
+        u8 dtim_interval;
+        /* Beacon expiry time in ms */
+        u8 beacon_expiry;
+        u8 padding_2[3];
+} __packed;
+
+struct wl1271_cmd_add_sta {
+        struct wl1271_cmd_header header;
+
+        u8 addr[ETH_ALEN];
+        u8 hlid;
+        u8 aid;
+        u8 psd_type[NUM_ACCESS_CATEGORIES_COPY];
+        __le32 supported_rates;
+        u8 bss_index;
+        u8 sp_len;
+        u8 wmm;
+        u8 padding1;
+} __packed;
+
+struct wl1271_cmd_remove_sta {
+        struct wl1271_cmd_header header;
+
+        u8 hlid;
+        u8 reason_opcode;
+        u8 send_deauth_flag;
+        u8 padding1;
+} __packed;
+
 #endif /* __WL1271_CMD_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1271_conf.h b/drivers/net/wireless/wl12xx/conf.h
index 0435ffda8f73..c83fefb6662f 100644
--- a/drivers/net/wireless/wl12xx/wl1271_conf.h
+++ b/drivers/net/wireless/wl12xx/conf.h
@@ -21,8 +21,8 @@
  *
  */
 
-#ifndef __WL1271_CONF_H__
-#define __WL1271_CONF_H__
+#ifndef __CONF_H__
+#define __CONF_H__
 
 enum {
         CONF_HW_BIT_RATE_1MBPS   = BIT(0),
@@ -396,12 +396,43 @@ enum {
         CONF_SG_TEMP_PARAM_3,
         CONF_SG_TEMP_PARAM_4,
         CONF_SG_TEMP_PARAM_5,
-        CONF_SG_PARAMS_MAX,
+
+        /*
+         * AP beacon miss
+         *
+         * Range: 0 - 255
+         */
+        CONF_SG_AP_BEACON_MISS_TX,
+
+        /*
+         * AP RX window length
+         *
+         * Range: 0 - 50
+         */
+        CONF_SG_RX_WINDOW_LENGTH,
+
+        /*
+         * AP connection protection time
+         *
+         * Range: 0 - 5000
+         */
+        CONF_SG_AP_CONNECTION_PROTECTION_TIME,
+
+        CONF_SG_TEMP_PARAM_6,
+        CONF_SG_TEMP_PARAM_7,
+        CONF_SG_TEMP_PARAM_8,
+        CONF_SG_TEMP_PARAM_9,
+        CONF_SG_TEMP_PARAM_10,
+
+        CONF_SG_STA_PARAMS_MAX = CONF_SG_TEMP_PARAM_5 + 1,
+        CONF_SG_AP_PARAMS_MAX = CONF_SG_TEMP_PARAM_10 + 1,
+
         CONF_SG_PARAMS_ALL = 0xff
 };
 
 struct conf_sg_settings {
-        u32 params[CONF_SG_PARAMS_MAX];
+        u32 sta_params[CONF_SG_STA_PARAMS_MAX];
+        u32 ap_params[CONF_SG_AP_PARAMS_MAX];
         u8 state;
 };
 
@@ -496,6 +527,39 @@ struct conf_rx_settings {
                                         CONF_HW_BIT_RATE_2MBPS)
 #define CONF_TX_RATE_RETRY_LIMIT       10
 
+/*
+ * Rates supported for data packets when operating as AP. Note the absence
+ * of the 22Mbps rate. There is a FW limitation on 12 rates so we must drop
+ * one. The rate dropped is not mandatory under any operating mode.
+ */
+#define CONF_TX_AP_ENABLED_RATES       (CONF_HW_BIT_RATE_1MBPS | \
+        CONF_HW_BIT_RATE_2MBPS | CONF_HW_BIT_RATE_5_5MBPS |      \
+        CONF_HW_BIT_RATE_6MBPS | CONF_HW_BIT_RATE_9MBPS |        \
+        CONF_HW_BIT_RATE_11MBPS | CONF_HW_BIT_RATE_12MBPS |      \
+        CONF_HW_BIT_RATE_18MBPS | CONF_HW_BIT_RATE_24MBPS |      \
+        CONF_HW_BIT_RATE_36MBPS | CONF_HW_BIT_RATE_48MBPS |      \
+        CONF_HW_BIT_RATE_54MBPS)
+
+#define CONF_TX_OFDM_RATES (CONF_HW_BIT_RATE_6MBPS |             \
+        CONF_HW_BIT_RATE_12MBPS | CONF_HW_BIT_RATE_24MBPS |      \
+        CONF_HW_BIT_RATE_36MBPS | CONF_HW_BIT_RATE_48MBPS |      \
+        CONF_HW_BIT_RATE_54MBPS)
+
+
+/*
+ * Default rates for management traffic when operating in AP mode. This
+ * should be configured according to the basic rate set of the AP
+ */
+#define CONF_TX_AP_DEFAULT_MGMT_RATES  (CONF_HW_BIT_RATE_1MBPS | \
+        CONF_HW_BIT_RATE_2MBPS | CONF_HW_BIT_RATE_5_5MBPS)
+
+/*
+ * Default rates for working as IBSS. use 11b rates
+ */
+#define CONF_TX_IBSS_DEFAULT_RATES  (CONF_HW_BIT_RATE_1MBPS |       \
+                CONF_HW_BIT_RATE_2MBPS | CONF_HW_BIT_RATE_5_5MBPS | \
+                CONF_HW_BIT_RATE_11MBPS);
+
 struct conf_tx_rate_class {
 
         /*
@@ -552,7 +616,7 @@ enum conf_tx_ac {
         CONF_TX_AC_BK = 1,         /* background */
         CONF_TX_AC_VI = 2,         /* video */
         CONF_TX_AC_VO = 3,         /* voice */
-        CONF_TX_AC_CTS2SELF = 4,   /* fictious AC, follows AC_VO */
+        CONF_TX_AC_CTS2SELF = 4,   /* fictitious AC, follows AC_VO */
         CONF_TX_AC_ANY_TID = 0x1f
 };
 
@@ -595,7 +659,7 @@ struct conf_tx_ac_category {
         u16 tx_op_limit;
 };
 
-#define CONF_TX_MAX_TID_COUNT 7
+#define CONF_TX_MAX_TID_COUNT 8
 
 enum {
         CONF_CHANNEL_TYPE_DCF = 0,   /* DC/LEGACY*/
@@ -636,9 +700,9 @@ struct conf_tx_settings {
 
         /*
          * Configuration for rate classes for TX (currently only one
-         * rate class supported.)
+         * rate class supported). Used in non-AP mode.
          */
-        struct conf_tx_rate_class rc_conf;
+        struct conf_tx_rate_class sta_rc_conf;
 
         /*
          * Configuration for access categories for TX rate control.
@@ -647,6 +711,12 @@ struct conf_tx_settings {
         struct conf_tx_ac_category ac_conf[CONF_TX_MAX_AC_COUNT];
 
         /*
+         * AP-mode - allow this number of TX retries to a station before an
+         * event is triggered from FW.
+         */
+        u16 ap_max_tx_retries;
+
+        /*
          * Configuration for TID parameters.
          */
         u8 tid_conf_count;
@@ -687,6 +757,12 @@ struct conf_tx_settings {
          * Range: CONF_HW_BIT_RATE_* bit mask
          */
         u32 basic_rate_5;
+
+        /*
+         * TX retry limits for templates
+         */
+        u8 tmpl_short_retry_limit;
+        u8 tmpl_long_retry_limit;
 };
 
 enum {
@@ -912,6 +988,30 @@ struct conf_conn_settings {
         u8 psm_entry_retries;
 
         /*
+         * Specifies the maximum number of times to try PSM exit if it fails
+         * (if sending the appropriate null-func message fails.)
+         *
+         * Range 0 - 255
+         */
+        u8 psm_exit_retries;
+
+        /*
+         * Specifies the maximum number of times to try transmit the PSM entry
+         * null-func frame for each PSM entry attempt
+         *
+         * Range 0 - 255
+         */
+        u8 psm_entry_nullfunc_retries;
+
+        /*
+         * Specifies the time to linger in active mode after successfully
+         * transmitting the PSM entry null-func frame.
+         *
+         * Range 0 - 255 TU's
+         */
+        u8 psm_entry_hangover_period;
+
+        /*
          *
          * Specifies the interval of the connection keep-alive null-func
          * frame in ms.
@@ -932,7 +1032,9 @@ enum {
         CONF_REF_CLK_19_2_E,
         CONF_REF_CLK_26_E,
         CONF_REF_CLK_38_4_E,
-        CONF_REF_CLK_52_E
+        CONF_REF_CLK_52_E,
+        CONF_REF_CLK_38_4_M_XTAL,
+        CONF_REF_CLK_26_M_XTAL,
 };
 
 enum single_dual_band_enum {
@@ -946,15 +1048,6 @@ enum single_dual_band_enum {
 #define CONF_NUMBER_OF_CHANNELS_2_4 14
 #define CONF_NUMBER_OF_CHANNELS_5   35
 
-struct conf_radio_parms {
-        /*
-         * FEM parameter set to use
-         *
-         * Range: 0 or 1
-         */
-        u8 fem;
-};
-
 struct conf_itrim_settings {
         /* enable dco itrim */
         u8 enable;
@@ -1016,6 +1109,145 @@ struct conf_roam_trigger_settings {
         u8 avg_weight_snr_data;
 };
 
+struct conf_scan_settings {
+        /*
+         * The minimum time to wait on each channel for active scans
+         *
+         * Range: u32 tu/1000
+         */
+        u32 min_dwell_time_active;
+
+        /*
+         * The maximum time to wait on each channel for active scans
+         *
+         * Range: u32 tu/1000
+         */
+        u32 max_dwell_time_active;
+
+        /*
+         * The minimum time to wait on each channel for passive scans
+         *
+         * Range: u32 tu/1000
+         */
+        u32 min_dwell_time_passive;
+
+        /*
+         * The maximum time to wait on each channel for passive scans
+         *
+         * Range: u32 tu/1000
+         */
+        u32 max_dwell_time_passive;
+
+        /*
+         * Number of probe requests to transmit on each active scan channel
+         *
+         * Range: u8
+         */
+        u16 num_probe_reqs;
+
+};
+
+struct conf_sched_scan_settings {
+        /* minimum time to wait on the channel for active scans (in TUs) */
+        u16 min_dwell_time_active;
+
+        /* maximum time to wait on the channel for active scans (in TUs) */
+        u16 max_dwell_time_active;
+
+        /* time to wait on the channel for passive scans (in TUs) */
+        u32 dwell_time_passive;
+
+        /* time to wait on the channel for DFS scans (in TUs) */
+        u32 dwell_time_dfs;
+
+        /* number of probe requests to send on each channel in active scans */
+        u8 num_probe_reqs;
+
+        /* RSSI threshold to be used for filtering */
+        s8 rssi_threshold;
+
+        /* SNR threshold to be used for filtering */
+        s8 snr_threshold;
+};
+
+/* these are number of channels on the band divided by two, rounded up */
+#define CONF_TX_PWR_COMPENSATION_LEN_2 7
+#define CONF_TX_PWR_COMPENSATION_LEN_5 18
+
+struct conf_rf_settings {
+        /*
+         * Per channel power compensation for 2.4GHz
+         *
+         * Range: s8
+         */
+        u8 tx_per_channel_power_compensation_2[CONF_TX_PWR_COMPENSATION_LEN_2];
+
+        /*
+         * Per channel power compensation for 5GHz
+         *
+         * Range: s8
+         */
+        u8 tx_per_channel_power_compensation_5[CONF_TX_PWR_COMPENSATION_LEN_5];
+};
+
+struct conf_ht_setting {
+        u16 tx_ba_win_size;
+        u16 inactivity_timeout;
+};
+
+struct conf_memory_settings {
+        /* Number of stations supported in IBSS mode */
+        u8 num_stations;
+
+        /* Number of ssid profiles used in IBSS mode */
+        u8 ssid_profiles;
+
+        /* Number of memory buffers allocated to rx pool */
+        u8 rx_block_num;
+
+        /* Minimum number of blocks allocated to tx pool */
+        u8 tx_min_block_num;
+
+        /* Disable/Enable dynamic memory */
+        u8 dynamic_memory;
+
+        /*
+         * Minimum required free tx memory blocks in order to assure optimum
+         * performance
+         *
+         * Range: 0-120
+         */
+        u8 min_req_tx_blocks;
+
+        /*
+         * Minimum required free rx memory blocks in order to assure optimum
+         * performance
+         *
+         * Range: 0-120
+         */
+        u8 min_req_rx_blocks;
+
+        /*
+         * Minimum number of mem blocks (free+used) guaranteed for TX
+         *
+         * Range: 0-120
+         */
+        u8 tx_min;
+};
+
+struct conf_fm_coex {
+        u8 enable;
+        u8 swallow_period;
+        u8 n_divider_fref_set_1;
+        u8 n_divider_fref_set_2;
+        u16 m_divider_fref_set_1;
+        u16 m_divider_fref_set_2;
+        u32 coex_pll_stabilization_time;
+        u16 ldo_stabilization_time;
+        u8 fm_disturbed_band_margin;
+        u8 swallow_clk_diff;
+};
+
 struct conf_drv_settings {
         struct conf_sg_settings sg;
         struct conf_rx_settings rx;
@@ -1024,6 +1256,14 @@ struct conf_drv_settings {
         struct conf_itrim_settings itrim;
         struct conf_pm_config_settings pm_config;
         struct conf_roam_trigger_settings roam_trigger;
+        struct conf_scan_settings scan;
+        struct conf_sched_scan_settings sched_scan;
+        struct conf_rf_settings rf;
+        struct conf_ht_setting ht;
+        struct conf_memory_settings mem_wl127x;
+        struct conf_memory_settings mem_wl128x;
+        struct conf_fm_coex fm_coex;
+        u8 hci_io_ds;
 };
 
 #endif
diff --git a/drivers/net/wireless/wl12xx/debugfs.c b/drivers/net/wireless/wl12xx/debugfs.c
new file mode 100644
index 000000000000..f1f8df9b6cd7
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/debugfs.c
@@ -0,0 +1,709 @@
+/*
+ * This file is part of wl1271
+ *
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * Contact: Luciano Coelho <luciano.coelho@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include "debugfs.h"
+
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+
+#include "wl12xx.h"
+#include "acx.h"
+#include "ps.h"
+#include "io.h"
+
+/* ms */
+#define WL1271_DEBUGFS_STATS_LIFETIME 1000
+
+/* debugfs macros idea from mac80211 */
+#define DEBUGFS_FORMAT_BUFFER_SIZE 100
+static int wl1271_format_buffer(char __user *userbuf, size_t count,
+                                    loff_t *ppos, char *fmt, ...)
+{
+        va_list args;
+        char buf[DEBUGFS_FORMAT_BUFFER_SIZE];
+        int res;
+
+        va_start(args, fmt);
+        res = vscnprintf(buf, sizeof(buf), fmt, args);
+        va_end(args);
+
+        return simple_read_from_buffer(userbuf, count, ppos, buf, res);
+}
+
+#define DEBUGFS_READONLY_FILE(name, fmt, value...)                      \
+static ssize_t name## _read(struct file *file, char __user *userbuf,    \
+                            size_t count, loff_t *ppos)                 \
+{                                                                       \
+        struct wl1271 *wl = file->private_data;                         \
+        return wl1271_format_buffer(userbuf, count, ppos,               \
+                                    fmt "\n", ##value);                 \
+}                                                                       \
+                                                                        \
+static const struct file_operations name## _ops = {                     \
+        .read = name## _read,                                           \
+        .open = wl1271_open_file_generic,                               \
+        .llseek = generic_file_llseek,                                  \
+};
+
+#define DEBUGFS_ADD(name, parent)                                       \
+        entry = debugfs_create_file(#name, 0400, parent,                \
+                                    wl, &name## _ops);                  \
+        if (!entry || IS_ERR(entry))                                    \
+                goto err;                                               \
+
+#define DEBUGFS_FWSTATS_FILE(sub, name, fmt)                            \
+static ssize_t sub## _ ##name## _read(struct file *file,                \
+                                      char __user *userbuf,             \
+                                      size_t count, loff_t *ppos)       \
+{                                                                       \
+        struct wl1271 *wl = file->private_data;                         \
+                                                                        \
+        wl1271_debugfs_update_stats(wl);                                \
+                                                                        \
+        return wl1271_format_buffer(userbuf, count, ppos, fmt "\n",     \
+                                    wl->stats.fw_stats->sub.name);      \
+}                                                                       \
+                                                                        \
+static const struct file_operations sub## _ ##name## _ops = {           \
+        .read = sub## _ ##name## _read,                                 \
+        .open = wl1271_open_file_generic,                               \
+        .llseek = generic_file_llseek,                                  \
+};
+
+#define DEBUGFS_FWSTATS_ADD(sub, name)                          \
+        DEBUGFS_ADD(sub## _ ##name, stats)
+
+static void wl1271_debugfs_update_stats(struct wl1271 *wl)
+{
+        int ret;
+
+        mutex_lock(&wl->mutex);
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        if (wl->state == WL1271_STATE_ON &&
+            time_after(jiffies, wl->stats.fw_stats_update +
+                       msecs_to_jiffies(WL1271_DEBUGFS_STATS_LIFETIME))) {
+                wl1271_acx_statistics(wl, wl->stats.fw_stats);
+                wl->stats.fw_stats_update = jiffies;
+        }
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+}
+
+static int wl1271_open_file_generic(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return 0;
+}
+
+DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, "%u");
+
+DEBUGFS_FWSTATS_FILE(rx, out_of_mem, "%u");
+DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, "%u");
+DEBUGFS_FWSTATS_FILE(rx, hw_stuck, "%u");
+DEBUGFS_FWSTATS_FILE(rx, dropped, "%u");
+DEBUGFS_FWSTATS_FILE(rx, fcs_err, "%u");
+DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, "%u");
+DEBUGFS_FWSTATS_FILE(rx, path_reset, "%u");
+DEBUGFS_FWSTATS_FILE(rx, reset_counter, "%u");
+
+DEBUGFS_FWSTATS_FILE(dma, rx_requested, "%u");
+DEBUGFS_FWSTATS_FILE(dma, rx_errors, "%u");
+DEBUGFS_FWSTATS_FILE(dma, tx_requested, "%u");
+DEBUGFS_FWSTATS_FILE(dma, tx_errors, "%u");
+
+DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, "%u");
+DEBUGFS_FWSTATS_FILE(isr, fiqs, "%u");
+DEBUGFS_FWSTATS_FILE(isr, rx_headers, "%u");
+DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, "%u");
+DEBUGFS_FWSTATS_FILE(isr, rx_rdys, "%u");
+DEBUGFS_FWSTATS_FILE(isr, irqs, "%u");
+DEBUGFS_FWSTATS_FILE(isr, tx_procs, "%u");
+DEBUGFS_FWSTATS_FILE(isr, decrypt_done, "%u");
+DEBUGFS_FWSTATS_FILE(isr, dma0_done, "%u");
+DEBUGFS_FWSTATS_FILE(isr, dma1_done, "%u");
+DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, "%u");
+DEBUGFS_FWSTATS_FILE(isr, commands, "%u");
+DEBUGFS_FWSTATS_FILE(isr, rx_procs, "%u");
+DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, "%u");
+DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, "%u");
+DEBUGFS_FWSTATS_FILE(isr, pci_pm, "%u");
+DEBUGFS_FWSTATS_FILE(isr, wakeups, "%u");
+DEBUGFS_FWSTATS_FILE(isr, low_rssi, "%u");
+
+DEBUGFS_FWSTATS_FILE(wep, addr_key_count, "%u");
+DEBUGFS_FWSTATS_FILE(wep, default_key_count, "%u");
+/* skipping wep.reserved */
+DEBUGFS_FWSTATS_FILE(wep, key_not_found, "%u");
+DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, "%u");
+DEBUGFS_FWSTATS_FILE(wep, packets, "%u");
+DEBUGFS_FWSTATS_FILE(wep, interrupt, "%u");
+
+DEBUGFS_FWSTATS_FILE(pwr, ps_enter, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, elp_enter, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, power_save_off, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, enable_ps, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, disable_ps, "%u");
+DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, "%u");
+/* skipping cont_miss_bcns_spread for now */
+DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, "%u");
+
+DEBUGFS_FWSTATS_FILE(mic, rx_pkts, "%u");
+DEBUGFS_FWSTATS_FILE(mic, calc_failure, "%u");
+
+DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, "%u");
+DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, "%u");
+DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, "%u");
+DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, "%u");
+DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, "%u");
+DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, "%u");
+
+DEBUGFS_FWSTATS_FILE(event, heart_beat, "%u");
+DEBUGFS_FWSTATS_FILE(event, calibration, "%u");
+DEBUGFS_FWSTATS_FILE(event, rx_mismatch, "%u");
+DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, "%u");
+DEBUGFS_FWSTATS_FILE(event, rx_pool, "%u");
+DEBUGFS_FWSTATS_FILE(event, oom_late, "%u");
+DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, "%u");
+DEBUGFS_FWSTATS_FILE(event, tx_stuck, "%u");
+
+DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, "%u");
+DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, "%u");
+DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, "%u");
+DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, "%u");
+DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, "%u");
+DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, "%u");
+DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, "%u");
+
+DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, "%u");
+DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, "%u");
+DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data, "%u");
+DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, "%u");
+DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, "%u");
+
+DEBUGFS_READONLY_FILE(retry_count, "%u", wl->stats.retry_count);
+DEBUGFS_READONLY_FILE(excessive_retries, "%u",
+                      wl->stats.excessive_retries);
+
+static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
+                                 size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        u32 queue_len;
+        char buf[20];
+        int res;
+
+        queue_len = wl->tx_queue_count;
+
+        res = scnprintf(buf, sizeof(buf), "%u\n", queue_len);
+        return simple_read_from_buffer(userbuf, count, ppos, buf, res);
+}
+
+static const struct file_operations tx_queue_len_ops = {
+        .read = tx_queue_len_read,
+        .open = wl1271_open_file_generic,
+        .llseek = default_llseek,
+};
+
+static ssize_t gpio_power_read(struct file *file, char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        bool state = test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
+
+        int res;
+        char buf[10];
+
+        res = scnprintf(buf, sizeof(buf), "%d\n", state);
+
+        return simple_read_from_buffer(user_buf, count, ppos, buf, res);
+}
+
+static ssize_t gpio_power_write(struct file *file,
+                           const char __user *user_buf,
+                           size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        char buf[10];
+        size_t len;
+        unsigned long value;
+        int ret;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len)) {
+                return -EFAULT;
+        }
+        buf[len] = '\0';
+
+        ret = kstrtoul(buf, 0, &value);
+        if (ret < 0) {
+                wl1271_warning("illegal value in gpio_power");
+                return -EINVAL;
+        }
+
+        mutex_lock(&wl->mutex);
+
+        if (value)
+                wl1271_power_on(wl);
+        else
+                wl1271_power_off(wl);
+
+        mutex_unlock(&wl->mutex);
+        return count;
+}
+
+static const struct file_operations gpio_power_ops = {
+        .read = gpio_power_read,
+        .write = gpio_power_write,
+        .open = wl1271_open_file_generic,
+        .llseek = default_llseek,
+};
+
+static ssize_t start_recovery_write(struct file *file,
+                                    const char __user *user_buf,
+                                    size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+
+        mutex_lock(&wl->mutex);
+        ieee80211_queue_work(wl->hw, &wl->recovery_work);
+        mutex_unlock(&wl->mutex);
+
+        return count;
+}
+
+static const struct file_operations start_recovery_ops = {
+        .write = start_recovery_write,
+        .open = wl1271_open_file_generic,
+        .llseek = default_llseek,
+};
+
+static ssize_t driver_state_read(struct file *file, char __user *user_buf,
+                                 size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        int res = 0;
+        char buf[1024];
+
+        mutex_lock(&wl->mutex);
+
+#define DRIVER_STATE_PRINT(x, fmt)   \
+        (res += scnprintf(buf + res, sizeof(buf) - res,\
+                          #x " = " fmt "\n", wl->x))
+
+#define DRIVER_STATE_PRINT_LONG(x) DRIVER_STATE_PRINT(x, "%ld")
+#define DRIVER_STATE_PRINT_INT(x)  DRIVER_STATE_PRINT(x, "%d")
+#define DRIVER_STATE_PRINT_STR(x)  DRIVER_STATE_PRINT(x, "%s")
+#define DRIVER_STATE_PRINT_LHEX(x) DRIVER_STATE_PRINT(x, "0x%lx")
+#define DRIVER_STATE_PRINT_HEX(x)  DRIVER_STATE_PRINT(x, "0x%x")
+
+        DRIVER_STATE_PRINT_INT(tx_blocks_available);
+        DRIVER_STATE_PRINT_INT(tx_allocated_blocks);
+        DRIVER_STATE_PRINT_INT(tx_frames_cnt);
+        DRIVER_STATE_PRINT_LHEX(tx_frames_map[0]);
+        DRIVER_STATE_PRINT_INT(tx_queue_count);
+        DRIVER_STATE_PRINT_INT(tx_packets_count);
+        DRIVER_STATE_PRINT_INT(tx_results_count);
+        DRIVER_STATE_PRINT_LHEX(flags);
+        DRIVER_STATE_PRINT_INT(tx_blocks_freed[0]);
+        DRIVER_STATE_PRINT_INT(tx_blocks_freed[1]);
+        DRIVER_STATE_PRINT_INT(tx_blocks_freed[2]);
+        DRIVER_STATE_PRINT_INT(tx_blocks_freed[3]);
+        DRIVER_STATE_PRINT_INT(tx_security_last_seq);
+        DRIVER_STATE_PRINT_INT(rx_counter);
+        DRIVER_STATE_PRINT_INT(session_counter);
+        DRIVER_STATE_PRINT_INT(state);
+        DRIVER_STATE_PRINT_INT(bss_type);
+        DRIVER_STATE_PRINT_INT(channel);
+        DRIVER_STATE_PRINT_HEX(rate_set);
+        DRIVER_STATE_PRINT_HEX(basic_rate_set);
+        DRIVER_STATE_PRINT_HEX(basic_rate);
+        DRIVER_STATE_PRINT_INT(band);
+        DRIVER_STATE_PRINT_INT(beacon_int);
+        DRIVER_STATE_PRINT_INT(psm_entry_retry);
+        DRIVER_STATE_PRINT_INT(ps_poll_failures);
+        DRIVER_STATE_PRINT_HEX(filters);
+        DRIVER_STATE_PRINT_HEX(rx_config);
+        DRIVER_STATE_PRINT_HEX(rx_filter);
+        DRIVER_STATE_PRINT_INT(power_level);
+        DRIVER_STATE_PRINT_INT(rssi_thold);
+        DRIVER_STATE_PRINT_INT(last_rssi_event);
+        DRIVER_STATE_PRINT_INT(sg_enabled);
+        DRIVER_STATE_PRINT_INT(enable_11a);
+        DRIVER_STATE_PRINT_INT(noise);
+        DRIVER_STATE_PRINT_LHEX(ap_hlid_map[0]);
+        DRIVER_STATE_PRINT_INT(last_tx_hlid);
+        DRIVER_STATE_PRINT_INT(ba_support);
+        DRIVER_STATE_PRINT_HEX(ba_rx_bitmap);
+        DRIVER_STATE_PRINT_HEX(ap_fw_ps_map);
+        DRIVER_STATE_PRINT_LHEX(ap_ps_map);
+        DRIVER_STATE_PRINT_HEX(quirks);
+        DRIVER_STATE_PRINT_HEX(irq);
+        DRIVER_STATE_PRINT_HEX(ref_clock);
+        DRIVER_STATE_PRINT_HEX(tcxo_clock);
+        DRIVER_STATE_PRINT_HEX(hw_pg_ver);
+        DRIVER_STATE_PRINT_HEX(platform_quirks);
+        DRIVER_STATE_PRINT_HEX(chip.id);
+        DRIVER_STATE_PRINT_STR(chip.fw_ver_str);
+        DRIVER_STATE_PRINT_INT(sched_scanning);
+
+#undef DRIVER_STATE_PRINT_INT
+#undef DRIVER_STATE_PRINT_LONG
+#undef DRIVER_STATE_PRINT_HEX
+#undef DRIVER_STATE_PRINT_LHEX
+#undef DRIVER_STATE_PRINT_STR
+#undef DRIVER_STATE_PRINT
+
+        mutex_unlock(&wl->mutex);
+
+        return simple_read_from_buffer(user_buf, count, ppos, buf, res);
+}
+
+static const struct file_operations driver_state_ops = {
+        .read = driver_state_read,
+        .open = wl1271_open_file_generic,
+        .llseek = default_llseek,
+};
+
+static ssize_t dtim_interval_read(struct file *file, char __user *user_buf,
+                                  size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        u8 value;
+
+        if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_DTIM ||
+            wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM)
+                value = wl->conf.conn.listen_interval;
+        else
+                value = 0;
+
+        return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
+}
+
+static ssize_t dtim_interval_write(struct file *file,
+                                   const char __user *user_buf,
+                                   size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        char buf[10];
+        size_t len;
+        unsigned long value;
+        int ret;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len))
+                return -EFAULT;
+        buf[len] = '\0';
+
+        ret = kstrtoul(buf, 0, &value);
+        if (ret < 0) {
+                wl1271_warning("illegal value for dtim_interval");
+                return -EINVAL;
+        }
+
+        if (value < 1 || value > 10) {
+                wl1271_warning("dtim value is not in valid range");
+                return -ERANGE;
+        }
+
+        mutex_lock(&wl->mutex);
+
+        wl->conf.conn.listen_interval = value;
+        /* for some reason there are different event types for 1 and >1 */
+        if (value == 1)
+                wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_DTIM;
+        else
+                wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM;
+
+        /*
+         * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
+         * take effect on the next time we enter psm.
+         */
+        mutex_unlock(&wl->mutex);
+        return count;
+}
+
+static const struct file_operations dtim_interval_ops = {
+        .read = dtim_interval_read,
+        .write = dtim_interval_write,
+        .open = wl1271_open_file_generic,
+        .llseek = default_llseek,
+};
+
+static ssize_t beacon_interval_read(struct file *file, char __user *user_buf,
+                                    size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        u8 value;
+
+        if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_BEACON ||
+            wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_BEACONS)
+                value = wl->conf.conn.listen_interval;
+        else
+                value = 0;
+
+        return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
+}
+
+static ssize_t beacon_interval_write(struct file *file,
+                                     const char __user *user_buf,
+                                     size_t count, loff_t *ppos)
+{
+        struct wl1271 *wl = file->private_data;
+        char buf[10];
+        size_t len;
+        unsigned long value;
+        int ret;
+
+        len = min(count, sizeof(buf) - 1);
+        if (copy_from_user(buf, user_buf, len))
+                return -EFAULT;
+        buf[len] = '\0';
+
+        ret = kstrtoul(buf, 0, &value);
+        if (ret < 0) {
+                wl1271_warning("illegal value for beacon_interval");
+                return -EINVAL;
+        }
+
+        if (value < 1 || value > 255) {
+                wl1271_warning("beacon interval value is not in valid range");
+                return -ERANGE;
+        }
+
+        mutex_lock(&wl->mutex);
+
+        wl->conf.conn.listen_interval = value;
+        /* for some reason there are different event types for 1 and >1 */
+        if (value == 1)
+                wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_BEACON;
+        else
+                wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_BEACONS;
+
+        /*
+         * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
+         * take effect on the next time we enter psm.
+         */
+        mutex_unlock(&wl->mutex);
+        return count;
+}
+
+static const struct file_operations beacon_interval_ops = {
+        .read = beacon_interval_read,
+        .write = beacon_interval_write,
+        .open = wl1271_open_file_generic,
+        .llseek = default_llseek,
+};
+
+static int wl1271_debugfs_add_files(struct wl1271 *wl,
+                                     struct dentry *rootdir)
+{
+        int ret = 0;
+        struct dentry *entry, *stats;
+
+        stats = debugfs_create_dir("fw-statistics", rootdir);
+        if (!stats || IS_ERR(stats)) {
+                entry = stats;
+                goto err;
+        }
+
+        DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow);
+
+        DEBUGFS_FWSTATS_ADD(rx, out_of_mem);
+        DEBUGFS_FWSTATS_ADD(rx, hdr_overflow);
+        DEBUGFS_FWSTATS_ADD(rx, hw_stuck);
+        DEBUGFS_FWSTATS_ADD(rx, dropped);
+        DEBUGFS_FWSTATS_ADD(rx, fcs_err);
+        DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig);
+        DEBUGFS_FWSTATS_ADD(rx, path_reset);
+        DEBUGFS_FWSTATS_ADD(rx, reset_counter);
+
+        DEBUGFS_FWSTATS_ADD(dma, rx_requested);
+        DEBUGFS_FWSTATS_ADD(dma, rx_errors);
+        DEBUGFS_FWSTATS_ADD(dma, tx_requested);
+        DEBUGFS_FWSTATS_ADD(dma, tx_errors);
+
+        DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt);
+        DEBUGFS_FWSTATS_ADD(isr, fiqs);
+        DEBUGFS_FWSTATS_ADD(isr, rx_headers);
+        DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow);
+        DEBUGFS_FWSTATS_ADD(isr, rx_rdys);
+        DEBUGFS_FWSTATS_ADD(isr, irqs);
+        DEBUGFS_FWSTATS_ADD(isr, tx_procs);
+        DEBUGFS_FWSTATS_ADD(isr, decrypt_done);
+        DEBUGFS_FWSTATS_ADD(isr, dma0_done);
+        DEBUGFS_FWSTATS_ADD(isr, dma1_done);
+        DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete);
+        DEBUGFS_FWSTATS_ADD(isr, commands);
+        DEBUGFS_FWSTATS_ADD(isr, rx_procs);
+        DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes);
+        DEBUGFS_FWSTATS_ADD(isr, host_acknowledges);
+        DEBUGFS_FWSTATS_ADD(isr, pci_pm);
+        DEBUGFS_FWSTATS_ADD(isr, wakeups);
+        DEBUGFS_FWSTATS_ADD(isr, low_rssi);
+
+        DEBUGFS_FWSTATS_ADD(wep, addr_key_count);
+        DEBUGFS_FWSTATS_ADD(wep, default_key_count);
+        /* skipping wep.reserved */
+        DEBUGFS_FWSTATS_ADD(wep, key_not_found);
+        DEBUGFS_FWSTATS_ADD(wep, decrypt_fail);
+        DEBUGFS_FWSTATS_ADD(wep, packets);
+        DEBUGFS_FWSTATS_ADD(wep, interrupt);
+
+        DEBUGFS_FWSTATS_ADD(pwr, ps_enter);
+        DEBUGFS_FWSTATS_ADD(pwr, elp_enter);
+        DEBUGFS_FWSTATS_ADD(pwr, missing_bcns);
+        DEBUGFS_FWSTATS_ADD(pwr, wake_on_host);
+        DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp);
+        DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps);
+        DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps);
+        DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons);
+        DEBUGFS_FWSTATS_ADD(pwr, power_save_off);
+        DEBUGFS_FWSTATS_ADD(pwr, enable_ps);
+        DEBUGFS_FWSTATS_ADD(pwr, disable_ps);
+        DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps);
+        /* skipping cont_miss_bcns_spread for now */
+        DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons);
+
+        DEBUGFS_FWSTATS_ADD(mic, rx_pkts);
+        DEBUGFS_FWSTATS_ADD(mic, calc_failure);
+
+        DEBUGFS_FWSTATS_ADD(aes, encrypt_fail);
+        DEBUGFS_FWSTATS_ADD(aes, decrypt_fail);
+        DEBUGFS_FWSTATS_ADD(aes, encrypt_packets);
+        DEBUGFS_FWSTATS_ADD(aes, decrypt_packets);
+        DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt);
+        DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt);
+
+        DEBUGFS_FWSTATS_ADD(event, heart_beat);
+        DEBUGFS_FWSTATS_ADD(event, calibration);
+        DEBUGFS_FWSTATS_ADD(event, rx_mismatch);
+        DEBUGFS_FWSTATS_ADD(event, rx_mem_empty);
+        DEBUGFS_FWSTATS_ADD(event, rx_pool);
+        DEBUGFS_FWSTATS_ADD(event, oom_late);
+        DEBUGFS_FWSTATS_ADD(event, phy_transmit_error);
+        DEBUGFS_FWSTATS_ADD(event, tx_stuck);
+
+        DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts);
+        DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts);
+        DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime);
+        DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn);
+        DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn);
+        DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization);
+        DEBUGFS_FWSTATS_ADD(ps, upsd_utilization);
+
+        DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop);
+        DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data);
+        DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
+        DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data);
+        DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data);
+
+        DEBUGFS_ADD(tx_queue_len, rootdir);
+        DEBUGFS_ADD(retry_count, rootdir);
+        DEBUGFS_ADD(excessive_retries, rootdir);
+
+        DEBUGFS_ADD(gpio_power, rootdir);
+        DEBUGFS_ADD(start_recovery, rootdir);
+        DEBUGFS_ADD(driver_state, rootdir);
+        DEBUGFS_ADD(dtim_interval, rootdir);
+        DEBUGFS_ADD(beacon_interval, rootdir);
+
+        return 0;
+
+err:
+        if (IS_ERR(entry))
+                ret = PTR_ERR(entry);
+        else
+                ret = -ENOMEM;
+
+        return ret;
+}
+
+void wl1271_debugfs_reset(struct wl1271 *wl)
+{
+        if (!wl->stats.fw_stats)
+                return;
+
+        memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
+        wl->stats.retry_count = 0;
+        wl->stats.excessive_retries = 0;
+}
+
+int wl1271_debugfs_init(struct wl1271 *wl)
+{
+        int ret;
+        struct dentry *rootdir;
+
+        rootdir = debugfs_create_dir(KBUILD_MODNAME,
+                                     wl->hw->wiphy->debugfsdir);
+
+        if (IS_ERR(rootdir)) {
+                ret = PTR_ERR(rootdir);
+                goto err;
+        }
+
+        wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats),
+                                      GFP_KERNEL);
+
+        if (!wl->stats.fw_stats) {
+                ret = -ENOMEM;
+                goto err_fw;
+        }
+
+        wl->stats.fw_stats_update = jiffies;
+
+        ret = wl1271_debugfs_add_files(wl, rootdir);
+
+        if (ret < 0)
+                goto err_file;
+
+        return 0;
+
+err_file:
+        kfree(wl->stats.fw_stats);
+        wl->stats.fw_stats = NULL;
+
+err_fw:
+        debugfs_remove_recursive(rootdir);
+
+err:
+        return ret;
+}
+
+void wl1271_debugfs_exit(struct wl1271 *wl)
+{
+        kfree(wl->stats.fw_stats);
+        wl->stats.fw_stats = NULL;
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_debugfs.h b/drivers/net/wireless/wl12xx/debugfs.h
index 00a45b2669ad..254c5b292cf6 100644
--- a/drivers/net/wireless/wl12xx/wl1271_debugfs.h
+++ b/drivers/net/wireless/wl12xx/debugfs.h
@@ -21,10 +21,10 @@
  *
  */
 
-#ifndef WL1271_DEBUGFS_H
-#define WL1271_DEBUGFS_H
+#ifndef __DEBUGFS_H__
+#define __DEBUGFS_H__
 
-#include "wl1271.h"
+#include "wl12xx.h"
 
 int wl1271_debugfs_init(struct wl1271 *wl);
 void wl1271_debugfs_exit(struct wl1271 *wl);
diff --git a/drivers/net/wireless/wl12xx/wl1271_event.c b/drivers/net/wireless/wl12xx/event.c
index 25ce2cd5e3f3..c3c554cd6580 100644
--- a/drivers/net/wireless/wl12xx/wl1271_event.c
+++ b/drivers/net/wireless/wl12xx/event.c
@@ -21,18 +21,19 @@
  *
  */
 
-#include "wl1271.h"
-#include "wl1271_reg.h"
-#include "wl1271_io.h"
-#include "wl1271_event.h"
-#include "wl1271_ps.h"
-#include "wl1271_scan.h"
+#include "wl12xx.h"
+#include "reg.h"
+#include "io.h"
+#include "event.h"
+#include "ps.h"
+#include "scan.h"
 #include "wl12xx_80211.h"
 
 void wl1271_pspoll_work(struct work_struct *work)
 {
         struct delayed_work *dwork;
         struct wl1271 *wl;
+        int ret;
 
         dwork = container_of(work, struct delayed_work, work);
         wl = container_of(dwork, struct wl1271, pspoll_work);
@@ -41,6 +42,9 @@ void wl1271_pspoll_work(struct work_struct *work)
 
         mutex_lock(&wl->mutex);
 
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
         if (!test_and_clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags))
                 goto out;
 
@@ -52,8 +56,13 @@ void wl1271_pspoll_work(struct work_struct *work)
          * delivery failure occurred, and no-one changed state since, so
          * we should go back to powersave.
          */
-        wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE, true);
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE, wl->basic_rate, true);
 
+        wl1271_ps_elp_sleep(wl);
 out:
         mutex_unlock(&wl->mutex);
 };
@@ -70,7 +79,8 @@ static void wl1271_event_pspoll_delivery_fail(struct wl1271 *wl)
 
         /* force active mode receive data from the AP */
         if (test_bit(WL1271_FLAG_PSM, &wl->flags)) {
-                ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE, true);
+                ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
+                                         wl->basic_rate, true);
                 if (ret < 0)
                         return;
                 set_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
@@ -91,6 +101,7 @@ static int wl1271_event_ps_report(struct wl1271 *wl,
                                   bool *beacon_loss)
 {
         int ret = 0;
+        u32 total_retries = wl->conf.conn.psm_entry_retries;
 
         wl1271_debug(DEBUG_EVENT, "ps_status: 0x%x", mbox->ps_status);
 
@@ -104,10 +115,10 @@ static int wl1271_event_ps_report(struct wl1271 *wl,
                         break;
                 }
 
-                if (wl->psm_entry_retry < wl->conf.conn.psm_entry_retries) {
+                if (wl->psm_entry_retry < total_retries) {
                         wl->psm_entry_retry++;
                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
-                                                 true);
+                                                 wl->basic_rate, true);
                 } else {
                         wl1271_info("No ack to nullfunc from AP.");
                         wl->psm_entry_retry = 0;
@@ -127,25 +138,11 @@ static int wl1271_event_ps_report(struct wl1271 *wl,
                 if (ret < 0)
                         break;
 
-                /* go to extremely low power mode */
-                wl1271_ps_elp_sleep(wl);
-                if (ret < 0)
-                        break;
-                break;
-        case EVENT_EXIT_POWER_SAVE_FAIL:
-                wl1271_debug(DEBUG_PSM, "PSM exit failed");
-
-                if (test_bit(WL1271_FLAG_PSM, &wl->flags)) {
-                        wl->psm_entry_retry = 0;
-                        break;
+                if (wl->ps_compl) {
+                        complete(wl->ps_compl);
+                        wl->ps_compl = NULL;
                 }
-
-                /* make sure the firmware goes to active mode - the frame to
-                   be sent next will indicate to the AP, that we are active. */
-                ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
-                                         false);
                 break;
-        case EVENT_EXIT_POWER_SAVE_SUCCESS:
         default:
                 break;
         }
@@ -183,6 +180,7 @@ static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
         int ret;
         u32 vector;
         bool beacon_loss = false;
+        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
 
         wl1271_event_mbox_dump(mbox);
 
@@ -197,6 +195,22 @@ static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
                 wl1271_scan_stm(wl);
         }
 
+        if (vector & PERIODIC_SCAN_REPORT_EVENT_ID) {
+                wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_REPORT_EVENT "
+                             "(status 0x%0x)", mbox->scheduled_scan_status);
+
+                wl1271_scan_sched_scan_results(wl);
+        }
+
+        if (vector & PERIODIC_SCAN_COMPLETE_EVENT_ID) {
+                wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_COMPLETE_EVENT "
+                             "(status 0x%0x)", mbox->scheduled_scan_status);
+                if (wl->sched_scanning) {
+                        wl1271_scan_sched_scan_stop(wl);
+                        ieee80211_sched_scan_stopped(wl->hw);
+                }
+        }
+
         /* disable dynamic PS when requested by the firmware */
         if (vector & SOFT_GEMINI_SENSE_EVENT_ID &&
             wl->bss_type == BSS_TYPE_STA_BSS) {
@@ -215,21 +229,21 @@ static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
          * BSS_LOSE_EVENT, beacon loss has to be reported to the stack.
          *
          */
-        if (vector & BSS_LOSE_EVENT_ID) {
+        if ((vector & BSS_LOSE_EVENT_ID) && !is_ap) {
                 wl1271_info("Beacon loss detected.");
 
                 /* indicate to the stack, that beacons have been lost */
                 beacon_loss = true;
         }
 
-        if (vector & PS_REPORT_EVENT_ID) {
+        if ((vector & PS_REPORT_EVENT_ID) && !is_ap) {
                 wl1271_debug(DEBUG_EVENT, "PS_REPORT_EVENT");
                 ret = wl1271_event_ps_report(wl, mbox, &beacon_loss);
                 if (ret < 0)
                         return ret;
         }
 
-        if (vector & PSPOLL_DELIVERY_FAILURE_EVENT_ID)
+        if ((vector & PSPOLL_DELIVERY_FAILURE_EVENT_ID) && !is_ap)
                 wl1271_event_pspoll_delivery_fail(wl);
 
         if (vector & RSSI_SNR_TRIGGER_0_EVENT_ID) {
@@ -238,6 +252,12 @@ static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
                         wl1271_event_rssi_trigger(wl, mbox);
         }
 
+        if ((vector & DUMMY_PACKET_EVENT_ID) && !is_ap) {
+                wl1271_debug(DEBUG_EVENT, "DUMMY_PACKET_ID_EVENT_ID");
+                if (wl->vif)
+                        wl1271_tx_dummy_packet(wl);
+        }
+
         if (wl->vif && beacon_loss)
                 ieee80211_connection_loss(wl->vif);
 
diff --git a/drivers/net/wireless/wl12xx/wl1271_event.h b/drivers/net/wireless/wl12xx/event.h
index e4751667cf5e..b6cf06e565a4 100644
--- a/drivers/net/wireless/wl12xx/wl1271_event.h
+++ b/drivers/net/wireless/wl12xx/event.h
@@ -22,8 +22,8 @@
  *
  */
 
-#ifndef __WL1271_EVENT_H__
-#define __WL1271_EVENT_H__
+#ifndef __EVENT_H__
+#define __EVENT_H__
 
 /*
  * Mbox events
@@ -59,6 +59,10 @@ enum {
         BSS_LOSE_EVENT_ID                        = BIT(18),
         REGAINED_BSS_EVENT_ID                    = BIT(19),
         ROAMING_TRIGGER_MAX_TX_RETRY_EVENT_ID    = BIT(20),
+        /* STA: dummy paket for dynamic mem blocks */
+        DUMMY_PACKET_EVENT_ID                    = BIT(21),
+        /* AP: STA remove complete */
+        STA_REMOVE_COMPLETE_EVENT_ID             = BIT(21),
         SOFT_GEMINI_SENSE_EVENT_ID               = BIT(22),
         SOFT_GEMINI_PREDICTION_EVENT_ID          = BIT(23),
         SOFT_GEMINI_AVALANCHE_EVENT_ID           = BIT(24),
@@ -74,8 +78,6 @@ enum {
 enum {
         EVENT_ENTER_POWER_SAVE_FAIL = 0,
         EVENT_ENTER_POWER_SAVE_SUCCESS,
-        EVENT_EXIT_POWER_SAVE_FAIL,
-        EVENT_EXIT_POWER_SAVE_SUCCESS,
 };
 
 struct event_debug_report {
@@ -115,7 +117,12 @@ struct event_mailbox {
         u8 scheduled_scan_status;
         u8 ps_status;
 
-        u8 reserved_5[29];
+        /* AP FW only */
+        u8 hlid_removed;
+        __le16 sta_aging_status;
+        __le16 sta_tx_retry_exceeded;
+
+        u8 reserved_5[24];
 } __packed;
 
 int wl1271_event_unmask(struct wl1271 *wl);
diff --git a/drivers/net/wireless/wl12xx/wl1271_ini.h b/drivers/net/wireless/wl12xx/ini.h
index 2313047d4015..1420c842b8f1 100644
--- a/drivers/net/wireless/wl12xx/wl1271_ini.h
+++ b/drivers/net/wireless/wl12xx/ini.h
@@ -21,8 +21,8 @@
  *
  */
 
-#ifndef __WL1271_INI_H__
-#define __WL1271_INI_H__
+#ifndef __INI_H__
+#define __INI_H__
 
 #define WL1271_INI_MAX_SMART_REFLEX_PARAM 16
 
@@ -41,6 +41,28 @@ struct wl1271_ini_general_params {
         u8 srf3[WL1271_INI_MAX_SMART_REFLEX_PARAM];
 } __packed;
 
+#define WL128X_INI_MAX_SETTINGS_PARAM 4
+
+struct wl128x_ini_general_params {
+        u8 ref_clock;
+        u8 settling_time;
+        u8 clk_valid_on_wakeup;
+        u8 tcxo_ref_clock;
+        u8 tcxo_settling_time;
+        u8 tcxo_valid_on_wakeup;
+        u8 tcxo_ldo_voltage;
+        u8 xtal_itrim_val;
+        u8 platform_conf;
+        u8 dual_mode_select;
+        u8 tx_bip_fem_auto_detect;
+        u8 tx_bip_fem_manufacturer;
+        u8 general_settings[WL128X_INI_MAX_SETTINGS_PARAM];
+        u8 sr_state;
+        u8 srf1[WL1271_INI_MAX_SMART_REFLEX_PARAM];
+        u8 srf2[WL1271_INI_MAX_SMART_REFLEX_PARAM];
+        u8 srf3[WL1271_INI_MAX_SMART_REFLEX_PARAM];
+} __packed;
+
 #define WL1271_INI_RSSI_PROCESS_COMPENS_SIZE 15
 
 struct wl1271_ini_band_params_2 {
@@ -49,9 +71,16 @@ struct wl1271_ini_band_params_2 {
         u8 rx_rssi_process_compens[WL1271_INI_RSSI_PROCESS_COMPENS_SIZE];
 } __packed;
 
-#define WL1271_INI_RATE_GROUP_COUNT 6
 #define WL1271_INI_CHANNEL_COUNT_2 14
 
+struct wl128x_ini_band_params_2 {
+        u8 rx_trace_insertion_loss;
+        u8 tx_trace_loss[WL1271_INI_CHANNEL_COUNT_2];
+        u8 rx_rssi_process_compens[WL1271_INI_RSSI_PROCESS_COMPENS_SIZE];
+} __packed;
+
+#define WL1271_INI_RATE_GROUP_COUNT 6
+
 struct wl1271_ini_fem_params_2 {
         __le16 tx_bip_ref_pd_voltage;
         u8 tx_bip_ref_power;
@@ -68,6 +97,28 @@ struct wl1271_ini_fem_params_2 {
         u8 normal_to_degraded_high_thr;
 } __packed;
 
+#define WL128X_INI_RATE_GROUP_COUNT 7
+/* low and high temperatures */
+#define WL128X_INI_PD_VS_TEMPERATURE_RANGES 2
+
+struct wl128x_ini_fem_params_2 {
+        __le16 tx_bip_ref_pd_voltage;
+        u8 tx_bip_ref_power;
+        u8 tx_bip_ref_offset;
+        u8 tx_per_rate_pwr_limits_normal[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_per_rate_pwr_limits_degraded[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_per_rate_pwr_limits_extreme[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_per_chan_pwr_limits_11b[WL1271_INI_CHANNEL_COUNT_2];
+        u8 tx_per_chan_pwr_limits_ofdm[WL1271_INI_CHANNEL_COUNT_2];
+        u8 tx_pd_vs_rate_offsets[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_ibias[WL128X_INI_RATE_GROUP_COUNT + 1];
+        u8 tx_pd_vs_chan_offsets[WL1271_INI_CHANNEL_COUNT_2];
+        u8 tx_pd_vs_temperature[WL128X_INI_PD_VS_TEMPERATURE_RANGES];
+        u8 rx_fem_insertion_loss;
+        u8 degraded_low_to_normal_thr;
+        u8 normal_to_degraded_high_thr;
+} __packed;
+
 #define WL1271_INI_CHANNEL_COUNT_5 35
 #define WL1271_INI_SUB_BAND_COUNT_5 7
 
@@ -77,6 +128,12 @@ struct wl1271_ini_band_params_5 {
         u8 rx_rssi_process_compens[WL1271_INI_RSSI_PROCESS_COMPENS_SIZE];
 } __packed;
 
+struct wl128x_ini_band_params_5 {
+        u8 rx_trace_insertion_loss[WL1271_INI_SUB_BAND_COUNT_5];
+        u8 tx_trace_loss[WL1271_INI_CHANNEL_COUNT_5];
+        u8 rx_rssi_process_compens[WL1271_INI_RSSI_PROCESS_COMPENS_SIZE];
+} __packed;
+
 struct wl1271_ini_fem_params_5 {
         __le16 tx_bip_ref_pd_voltage[WL1271_INI_SUB_BAND_COUNT_5];
         u8 tx_bip_ref_power[WL1271_INI_SUB_BAND_COUNT_5];
@@ -92,6 +149,23 @@ struct wl1271_ini_fem_params_5 {
         u8 normal_to_degraded_high_thr;
 } __packed;
 
+struct wl128x_ini_fem_params_5 {
+        __le16 tx_bip_ref_pd_voltage[WL1271_INI_SUB_BAND_COUNT_5];
+        u8 tx_bip_ref_power[WL1271_INI_SUB_BAND_COUNT_5];
+        u8 tx_bip_ref_offset[WL1271_INI_SUB_BAND_COUNT_5];
+        u8 tx_per_rate_pwr_limits_normal[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_per_rate_pwr_limits_degraded[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_per_rate_pwr_limits_extreme[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_per_chan_pwr_limits_ofdm[WL1271_INI_CHANNEL_COUNT_5];
+        u8 tx_pd_vs_rate_offsets[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_ibias[WL128X_INI_RATE_GROUP_COUNT];
+        u8 tx_pd_vs_chan_offsets[WL1271_INI_CHANNEL_COUNT_5];
+        u8 tx_pd_vs_temperature[WL1271_INI_SUB_BAND_COUNT_5 *
+                WL128X_INI_PD_VS_TEMPERATURE_RANGES];
+        u8 rx_fem_insertion_loss[WL1271_INI_SUB_BAND_COUNT_5];
+        u8 degraded_low_to_normal_thr;
+        u8 normal_to_degraded_high_thr;
+} __packed;
 
 /* NVS data structure */
 #define WL1271_INI_NVS_SECTION_SIZE                  468
@@ -100,7 +174,7 @@ struct wl1271_ini_fem_params_5 {
 #define WL1271_INI_LEGACY_NVS_FILE_SIZE              800
 
 struct wl1271_nvs_file {
-        /* NVS section */
+        /* NVS section - must be first! */
         u8 nvs[WL1271_INI_NVS_SECTION_SIZE];
 
         /* INI section */
@@ -120,4 +194,24 @@ struct wl1271_nvs_file {
         } dyn_radio_params_5[WL1271_INI_FEM_MODULE_COUNT];
 } __packed;
 
+struct wl128x_nvs_file {
+        /* NVS section - must be first! */
+        u8 nvs[WL1271_INI_NVS_SECTION_SIZE];
+
+        /* INI section */
+        struct wl128x_ini_general_params general_params;
+        u8 fem_vendor_and_options;
+        struct wl128x_ini_band_params_2 stat_radio_params_2;
+        u8 padding2;
+        struct {
+                struct wl128x_ini_fem_params_2 params;
+                u8 padding;
+        } dyn_radio_params_2[WL1271_INI_FEM_MODULE_COUNT];
+        struct wl128x_ini_band_params_5 stat_radio_params_5;
+        u8 padding3;
+        struct {
+                struct wl128x_ini_fem_params_5 params;
+                u8 padding;
+        } dyn_radio_params_5[WL1271_INI_FEM_MODULE_COUNT];
+} __packed;
 #endif
diff --git a/drivers/net/wireless/wl12xx/init.c b/drivers/net/wireless/wl12xx/init.c
new file mode 100644
index 000000000000..a8f4f156c055
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/init.c
@@ -0,0 +1,723 @@
+/*
+ * This file is part of wl1271
+ *
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * Contact: Luciano Coelho <luciano.coelho@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include "init.h"
+#include "wl12xx_80211.h"
+#include "acx.h"
+#include "cmd.h"
+#include "reg.h"
+#include "tx.h"
+#include "io.h"
+
+int wl1271_sta_init_templates_config(struct wl1271 *wl)
+{
+        int ret, i;
+
+        /* send empty templates for fw memory reservation */
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4, NULL,
+                                      WL1271_CMD_TEMPL_MAX_SIZE,
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_5,
+                                      NULL, WL1271_CMD_TEMPL_MAX_SIZE, 0,
+                                      WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, NULL,
+                                      sizeof(struct wl12xx_null_data_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PS_POLL, NULL,
+                                      sizeof(struct wl12xx_ps_poll_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, NULL,
+                                      sizeof
+                                      (struct wl12xx_qos_null_data_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE, NULL,
+                                      sizeof
+                                      (struct wl12xx_probe_resp_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON, NULL,
+                                      sizeof
+                                      (struct wl12xx_beacon_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_ARP_RSP, NULL,
+                                      sizeof
+                                      (struct wl12xx_arp_rsp_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) {
+                ret = wl1271_cmd_template_set(wl, CMD_TEMPL_KLV, NULL,
+                                              WL1271_CMD_TEMPL_MAX_SIZE, i,
+                                              WL1271_RATE_AUTOMATIC);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static int wl1271_ap_init_deauth_template(struct wl1271 *wl)
+{
+        struct wl12xx_disconn_template *tmpl;
+        int ret;
+
+        tmpl = kzalloc(sizeof(*tmpl), GFP_KERNEL);
+        if (!tmpl) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        tmpl->header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT |
+                                             IEEE80211_STYPE_DEAUTH);
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_DEAUTH_AP,
+                                      tmpl, sizeof(*tmpl), 0,
+                                      wl1271_tx_min_rate_get(wl));
+
+out:
+        kfree(tmpl);
+        return ret;
+}
+
+static int wl1271_ap_init_null_template(struct wl1271 *wl)
+{
+        struct ieee80211_hdr_3addr *nullfunc;
+        int ret;
+
+        nullfunc = kzalloc(sizeof(*nullfunc), GFP_KERNEL);
+        if (!nullfunc) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        nullfunc->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
+                                              IEEE80211_STYPE_NULLFUNC |
+                                              IEEE80211_FCTL_FROMDS);
+
+        /* nullfunc->addr1 is filled by FW */
+
+        memcpy(nullfunc->addr2, wl->mac_addr, ETH_ALEN);
+        memcpy(nullfunc->addr3, wl->mac_addr, ETH_ALEN);
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, nullfunc,
+                                      sizeof(*nullfunc), 0,
+                                      wl1271_tx_min_rate_get(wl));
+
+out:
+        kfree(nullfunc);
+        return ret;
+}
+
+static int wl1271_ap_init_qos_null_template(struct wl1271 *wl)
+{
+        struct ieee80211_qos_hdr *qosnull;
+        int ret;
+
+        qosnull = kzalloc(sizeof(*qosnull), GFP_KERNEL);
+        if (!qosnull) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        qosnull->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
+                                             IEEE80211_STYPE_QOS_NULLFUNC |
+                                             IEEE80211_FCTL_FROMDS);
+
+        /* qosnull->addr1 is filled by FW */
+
+        memcpy(qosnull->addr2, wl->mac_addr, ETH_ALEN);
+        memcpy(qosnull->addr3, wl->mac_addr, ETH_ALEN);
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, qosnull,
+                                      sizeof(*qosnull), 0,
+                                      wl1271_tx_min_rate_get(wl));
+
+out:
+        kfree(qosnull);
+        return ret;
+}
+
+static int wl1271_ap_init_templates_config(struct wl1271 *wl)
+{
+        int ret;
+
+        /*
+         * Put very large empty placeholders for all templates. These
+         * reserve memory for later.
+         */
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_AP_PROBE_RESPONSE, NULL,
+                                      sizeof
+                                      (struct wl12xx_probe_resp_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_AP_BEACON, NULL,
+                                      sizeof
+                                      (struct wl12xx_beacon_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_DEAUTH_AP, NULL,
+                                      sizeof
+                                      (struct wl12xx_disconn_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, NULL,
+                                      sizeof(struct wl12xx_null_data_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, NULL,
+                                      sizeof
+                                      (struct wl12xx_qos_null_data_template),
+                                      0, WL1271_RATE_AUTOMATIC);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int wl1271_init_rx_config(struct wl1271 *wl, u32 config, u32 filter)
+{
+        int ret;
+
+        ret = wl1271_acx_rx_msdu_life_time(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_rx_config(wl, config, filter);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+int wl1271_init_phy_config(struct wl1271 *wl)
+{
+        int ret;
+
+        ret = wl1271_acx_pd_threshold(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_slot(wl, DEFAULT_SLOT_TIME);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_service_period_timeout(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_rts_threshold(wl, wl->hw->wiphy->rts_threshold);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int wl1271_init_beacon_filter(struct wl1271 *wl)
+{
+        int ret;
+
+        /* disable beacon filtering at this stage */
+        ret = wl1271_acx_beacon_filter_opt(wl, false);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_beacon_filter_table(wl);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+int wl1271_init_pta(struct wl1271 *wl)
+{
+        int ret;
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS)
+                ret = wl1271_acx_ap_sg_cfg(wl);
+        else
+                ret = wl1271_acx_sta_sg_cfg(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_sg_enable(wl, wl->sg_enabled);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+int wl1271_init_energy_detection(struct wl1271 *wl)
+{
+        int ret;
+
+        ret = wl1271_acx_cca_threshold(wl);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int wl1271_init_beacon_broadcast(struct wl1271 *wl)
+{
+        int ret;
+
+        ret = wl1271_acx_bcn_dtim_options(wl);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int wl1271_sta_hw_init(struct wl1271 *wl)
+{
+        int ret;
+
+        if (wl->chip.id != CHIP_ID_1283_PG20) {
+                ret = wl1271_cmd_ext_radio_parms(wl);
+                if (ret < 0)
+                        return ret;
+        }
+
+        /* PS config */
+        ret = wl1271_acx_config_ps(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_sta_init_templates_config(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_group_address_tbl(wl, true, NULL, 0);
+        if (ret < 0)
+                return ret;
+
+        /* Initialize connection monitoring thresholds */
+        ret = wl1271_acx_conn_monit_params(wl, false);
+        if (ret < 0)
+                return ret;
+
+        /* Beacon filtering */
+        ret = wl1271_init_beacon_filter(wl);
+        if (ret < 0)
+                return ret;
+
+        /* FM WLAN coexistence */
+        ret = wl1271_acx_fm_coex(wl);
+        if (ret < 0)
+                return ret;
+
+        /* Beacons and broadcast settings */
+        ret = wl1271_init_beacon_broadcast(wl);
+        if (ret < 0)
+                return ret;
+
+        /* Configure for ELP power saving */
+        ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP);
+        if (ret < 0)
+                return ret;
+
+        /* Configure rssi/snr averaging weights */
+        ret = wl1271_acx_rssi_snr_avg_weights(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_sta_rate_policies(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_sta_mem_cfg(wl);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int wl1271_sta_hw_init_post_mem(struct wl1271 *wl)
+{
+        int ret, i;
+
+        ret = wl1271_cmd_set_sta_default_wep_key(wl, wl->default_key);
+        if (ret < 0) {
+                wl1271_warning("couldn't set default key");
+                return ret;
+        }
+
+        /* disable all keep-alive templates */
+        for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) {
+                ret = wl1271_acx_keep_alive_config(wl, i,
+                                                   ACX_KEEP_ALIVE_TPL_INVALID);
+                if (ret < 0)
+                        return ret;
+        }
+
+        /* disable the keep-alive feature */
+        ret = wl1271_acx_keep_alive_mode(wl, false);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int wl1271_ap_hw_init(struct wl1271 *wl)
+{
+        int ret;
+
+        ret = wl1271_ap_init_templates_config(wl);
+        if (ret < 0)
+                return ret;
+
+        /* Configure for power always on */
+        ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_init_ap_rates(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_max_tx_retry(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_ap_mem_cfg(wl);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+int wl1271_ap_init_templates(struct wl1271 *wl)
+{
+        int ret;
+
+        ret = wl1271_ap_init_deauth_template(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_ap_init_null_template(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_ap_init_qos_null_template(wl);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * when operating as AP we want to receive external beacons for
+         * configuring ERP protection.
+         */
+        ret = wl1271_acx_set_ap_beacon_filter(wl, false);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int wl1271_ap_hw_init_post_mem(struct wl1271 *wl)
+{
+        return wl1271_ap_init_templates(wl);
+}
+
+int wl1271_init_ap_rates(struct wl1271 *wl)
+{
+        int i, ret;
+        struct conf_tx_rate_class rc;
+        u32 supported_rates;
+
+        wl1271_debug(DEBUG_AP, "AP basic rate set: 0x%x", wl->basic_rate_set);
+
+        if (wl->basic_rate_set == 0)
+                return -EINVAL;
+
+        rc.enabled_rates = wl->basic_rate_set;
+        rc.long_retry_limit = 10;
+        rc.short_retry_limit = 10;
+        rc.aflags = 0;
+        ret = wl1271_acx_ap_rate_policy(wl, &rc, ACX_TX_AP_MODE_MGMT_RATE);
+        if (ret < 0)
+                return ret;
+
+        /* use the min basic rate for AP broadcast/multicast */
+        rc.enabled_rates = wl1271_tx_min_rate_get(wl);
+        rc.short_retry_limit = 10;
+        rc.long_retry_limit = 10;
+        rc.aflags = 0;
+        ret = wl1271_acx_ap_rate_policy(wl, &rc, ACX_TX_AP_MODE_BCST_RATE);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * If the basic rates contain OFDM rates, use OFDM only
+         * rates for unicast TX as well. Else use all supported rates.
+         */
+        if ((wl->basic_rate_set & CONF_TX_OFDM_RATES))
+                supported_rates = CONF_TX_OFDM_RATES;
+        else
+                supported_rates = CONF_TX_AP_ENABLED_RATES;
+
+        /* configure unicast TX rate classes */
+        for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
+                rc.enabled_rates = supported_rates;
+                rc.short_retry_limit = 10;
+                rc.long_retry_limit = 10;
+                rc.aflags = 0;
+                ret = wl1271_acx_ap_rate_policy(wl, &rc, i);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static void wl1271_check_ba_support(struct wl1271 *wl)
+{
+        /* validate FW cose ver x.x.x.50-60.x */
+        if ((wl->chip.fw_ver[3] >= WL12XX_BA_SUPPORT_FW_COST_VER2_START) &&
+            (wl->chip.fw_ver[3] < WL12XX_BA_SUPPORT_FW_COST_VER2_END)) {
+                wl->ba_support = true;
+                return;
+        }
+
+        wl->ba_support = false;
+}
+
+static int wl1271_set_ba_policies(struct wl1271 *wl)
+{
+        u8 tid_index;
+        int ret = 0;
+
+        /* Reset the BA RX indicators */
+        wl->ba_rx_bitmap = 0;
+
+        /* validate that FW support BA */
+        wl1271_check_ba_support(wl);
+
+        if (wl->ba_support)
+                /* 802.11n initiator BA session setting */
+                for (tid_index = 0; tid_index < CONF_TX_MAX_TID_COUNT;
+                     ++tid_index) {
+                        ret = wl1271_acx_set_ba_session(wl, WLAN_BACK_INITIATOR,
+                                                        tid_index, true);
+                        if (ret < 0)
+                                break;
+                }
+
+        return ret;
+}
+
+int wl1271_chip_specific_init(struct wl1271 *wl)
+{
+        int ret = 0;
+
+        if (wl->chip.id == CHIP_ID_1283_PG20) {
+                u32 host_cfg_bitmap = HOST_IF_CFG_RX_FIFO_ENABLE;
+
+                if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT)
+                        /* Enable SDIO padding */
+                        host_cfg_bitmap |= HOST_IF_CFG_TX_PAD_TO_SDIO_BLK;
+
+                /* Must be before wl1271_acx_init_mem_config() */
+                ret = wl1271_acx_host_if_cfg_bitmap(wl, host_cfg_bitmap);
+                if (ret < 0)
+                        goto out;
+        }
+out:
+        return ret;
+}
+
+
+int wl1271_hw_init(struct wl1271 *wl)
+{
+        struct conf_tx_ac_category *conf_ac;
+        struct conf_tx_tid *conf_tid;
+        int ret, i;
+        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                ret = wl128x_cmd_general_parms(wl);
+        else
+                ret = wl1271_cmd_general_parms(wl);
+        if (ret < 0)
+                return ret;
+
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                ret = wl128x_cmd_radio_parms(wl);
+        else
+                ret = wl1271_cmd_radio_parms(wl);
+        if (ret < 0)
+                return ret;
+
+        /* Chip-specific init */
+        ret = wl1271_chip_specific_init(wl);
+        if (ret < 0)
+                return ret;
+
+        /* Mode specific init */
+        if (is_ap)
+                ret = wl1271_ap_hw_init(wl);
+        else
+                ret = wl1271_sta_hw_init(wl);
+
+        if (ret < 0)
+                return ret;
+
+        /* Bluetooth WLAN coexistence */
+        ret = wl1271_init_pta(wl);
+        if (ret < 0)
+                return ret;
+
+        /* Default memory configuration */
+        ret = wl1271_acx_init_mem_config(wl);
+        if (ret < 0)
+                return ret;
+
+        /* RX config */
+        ret = wl1271_init_rx_config(wl,
+                                    RX_CFG_PROMISCUOUS | RX_CFG_TSF,
+                                    RX_FILTER_OPTION_DEF);
+        /* RX_CONFIG_OPTION_ANY_DST_ANY_BSS,
+           RX_FILTER_OPTION_FILTER_ALL); */
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* PHY layer config */
+        ret = wl1271_init_phy_config(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        ret = wl1271_acx_dco_itrim_params(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Configure TX patch complete interrupt behavior */
+        ret = wl1271_acx_tx_config_options(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* RX complete interrupt pacing */
+        ret = wl1271_acx_init_rx_interrupt(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Energy detection */
+        ret = wl1271_init_energy_detection(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Default fragmentation threshold */
+        ret = wl1271_acx_frag_threshold(wl, wl->hw->wiphy->frag_threshold);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Default TID/AC configuration */
+        BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
+        for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
+                conf_ac = &wl->conf.tx.ac_conf[i];
+                ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
+                                        conf_ac->cw_max, conf_ac->aifsn,
+                                        conf_ac->tx_op_limit);
+                if (ret < 0)
+                        goto out_free_memmap;
+
+                conf_tid = &wl->conf.tx.tid_conf[i];
+                ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
+                                         conf_tid->channel_type,
+                                         conf_tid->tsid,
+                                         conf_tid->ps_scheme,
+                                         conf_tid->ack_policy,
+                                         conf_tid->apsd_conf[0],
+                                         conf_tid->apsd_conf[1]);
+                if (ret < 0)
+                        goto out_free_memmap;
+        }
+
+        /* Enable data path */
+        ret = wl1271_cmd_data_path(wl, 1);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Configure HW encryption */
+        ret = wl1271_acx_feature_cfg(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* configure PM */
+        ret = wl1271_acx_pm_config(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Mode specific init - post mem init */
+        if (is_ap)
+                ret = wl1271_ap_hw_init_post_mem(wl);
+        else
+                ret = wl1271_sta_hw_init_post_mem(wl);
+
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Configure initiator BA sessions policies */
+        ret = wl1271_set_ba_policies(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        return 0;
+
+ out_free_memmap:
+        kfree(wl->target_mem_map);
+        wl->target_mem_map = NULL;
+
+        return ret;
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_init.h b/drivers/net/wireless/wl12xx/init.h
index bc26f8c53b91..3a3c230fd292 100644
--- a/drivers/net/wireless/wl12xx/wl1271_init.h
+++ b/drivers/net/wireless/wl12xx/init.h
@@ -21,16 +21,19 @@
  *
  */
 
-#ifndef __WL1271_INIT_H__
-#define __WL1271_INIT_H__
+#ifndef __INIT_H__
+#define __INIT_H__
 
-#include "wl1271.h"
+#include "wl12xx.h"
 
 int wl1271_hw_init_power_auth(struct wl1271 *wl);
-int wl1271_init_templates_config(struct wl1271 *wl);
+int wl1271_sta_init_templates_config(struct wl1271 *wl);
 int wl1271_init_phy_config(struct wl1271 *wl);
 int wl1271_init_pta(struct wl1271 *wl);
 int wl1271_init_energy_detection(struct wl1271 *wl);
+int wl1271_chip_specific_init(struct wl1271 *wl);
 int wl1271_hw_init(struct wl1271 *wl);
+int wl1271_init_ap_rates(struct wl1271 *wl);
+int wl1271_ap_init_templates(struct wl1271 *wl);
 
 #endif
diff --git a/drivers/net/wireless/wl12xx/wl1271_io.c b/drivers/net/wireless/wl12xx/io.c
index c8759acef131..da5c1ad942a4 100644
--- a/drivers/net/wireless/wl12xx/wl1271_io.c
+++ b/drivers/net/wireless/wl12xx/io.c
@@ -26,9 +26,10 @@
 #include <linux/crc7.h>
 #include <linux/spi/spi.h>
 
-#include "wl1271.h"
+#include "wl12xx.h"
 #include "wl12xx_80211.h"
-#include "wl1271_io.h"
+#include "io.h"
+#include "tx.h"
 
 #define OCP_CMD_LOOP  32
 
@@ -43,6 +44,16 @@
 #define OCP_STATUS_REQ_FAILED 0x20000
 #define OCP_STATUS_RESP_ERROR 0x30000
 
+bool wl1271_set_block_size(struct wl1271 *wl)
+{
+        if (wl->if_ops->set_block_size) {
+                wl->if_ops->set_block_size(wl, WL12XX_BUS_BLOCK_SIZE);
+                return true;
+        }
+
+        return false;
+}
+
 void wl1271_disable_interrupts(struct wl1271 *wl)
 {
         wl->if_ops->disable_irq(wl);
@@ -113,6 +124,7 @@ int wl1271_set_partition(struct wl1271 *wl,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(wl1271_set_partition);
 
 void wl1271_io_reset(struct wl1271 *wl)
 {
diff --git a/drivers/net/wireless/wl12xx/wl1271_io.h b/drivers/net/wireless/wl12xx/io.h
index bc806c74c63a..beed621a8ae0 100644
--- a/drivers/net/wireless/wl12xx/wl1271_io.h
+++ b/drivers/net/wireless/wl12xx/io.h
@@ -22,10 +22,10 @@
  *
  */
 
-#ifndef __WL1271_IO_H__
-#define __WL1271_IO_H__
+#ifndef __IO_H__
+#define __IO_H__
 
-#include "wl1271_reg.h"
+#include "reg.h"
 
 #define HW_ACCESS_MEMORY_MAX_RANGE      0x1FFC0
 
@@ -94,7 +94,7 @@ static inline int wl1271_translate_addr(struct wl1271 *wl, int addr)
          * translated region.
          *
          * The translated regions occur next to each other in physical device
-         * memory, so just add the sizes of the preceeding address regions to
+         * memory, so just add the sizes of the preceding address regions to
          * get the offset to the new region.
          *
          * Currently, only the two first regions are addressed, and the
@@ -144,10 +144,13 @@ static inline void wl1271_power_off(struct wl1271 *wl)
         clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
 }
 
-static inline void wl1271_power_on(struct wl1271 *wl)
+static inline int wl1271_power_on(struct wl1271 *wl)
 {
-        wl->if_ops->power(wl, true);
-        set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
+        int ret = wl->if_ops->power(wl, true);
+        if (ret == 0)
+                set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
+
+        return ret;
 }
 
 
@@ -165,5 +168,9 @@ void wl1271_unregister_hw(struct wl1271 *wl);
 int wl1271_init_ieee80211(struct wl1271 *wl);
 struct ieee80211_hw *wl1271_alloc_hw(void);
 int wl1271_free_hw(struct wl1271 *wl);
+irqreturn_t wl1271_irq(int irq, void *data);
+bool wl1271_set_block_size(struct wl1271 *wl);
+int wl1271_tx_dummy_packet(struct wl1271 *wl);
+void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters);
 
 #endif
diff --git a/drivers/net/wireless/wl12xx/main.c b/drivers/net/wireless/wl12xx/main.c
new file mode 100644
index 000000000000..e6497dc669df
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/main.c
@@ -0,0 +1,4095 @@
+/*
+ * This file is part of wl1271
+ *
+ * Copyright (C) 2008-2010 Nokia Corporation
+ *
+ * Contact: Luciano Coelho <luciano.coelho@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/firmware.h>
+#include <linux/delay.h>
+#include <linux/spi/spi.h>
+#include <linux/crc32.h>
+#include <linux/etherdevice.h>
+#include <linux/vmalloc.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/wl12xx.h>
+
+#include "wl12xx.h"
+#include "wl12xx_80211.h"
+#include "reg.h"
+#include "io.h"
+#include "event.h"
+#include "tx.h"
+#include "rx.h"
+#include "ps.h"
+#include "init.h"
+#include "debugfs.h"
+#include "cmd.h"
+#include "boot.h"
+#include "testmode.h"
+#include "scan.h"
+
+#define WL1271_BOOT_RETRIES 3
+
+static struct conf_drv_settings default_conf = {
+        .sg = {
+                .sta_params = {
+                        [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
+                        [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
+                        [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
+                        [CONF_SG_BT_LOAD_RATIO]                     = 200,
+                        [CONF_SG_AUTO_PS_MODE]                      = 1,
+                        [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
+                        [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
+                        [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
+                        [CONF_SG_BEACON_MISS_PERCENT]               = 60,
+                        [CONF_SG_RATE_ADAPT_THRESH]                 = 12,
+                        [CONF_SG_RATE_ADAPT_SNR]                    = 0,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
+                        /* Note: with UPSD, this should be 4 */
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
+                        /* Note: with UPDS, this should be 15 */
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
+                        /* Note: with UPDS, this should be 50 */
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
+                        /* Note: with UPDS, this should be 10 */
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
+                        [CONF_SG_RXT]                               = 1200,
+                        [CONF_SG_TXT]                               = 1000,
+                        [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
+                        [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
+                        [CONF_SG_UPSD_TIMEOUT]                      = 10,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
+                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
+                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
+                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
+                        [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
+                        [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
+                        [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
+                        [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
+                        [CONF_SG_HV3_MAX_SERVED]                    = 6,
+                        [CONF_SG_DHCP_TIME]                         = 5000,
+                        [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
+                },
+                .ap_params = {
+                        [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
+                        [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
+                        [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
+                        [CONF_SG_BT_LOAD_RATIO]                     = 50,
+                        [CONF_SG_AUTO_PS_MODE]                      = 1,
+                        [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
+                        [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
+                        [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
+                        [CONF_SG_BEACON_MISS_PERCENT]               = 60,
+                        [CONF_SG_RATE_ADAPT_THRESH]                 = 64,
+                        [CONF_SG_RATE_ADAPT_SNR]                    = 1,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 25,
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 25,
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 25,
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 25,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
+                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 25,
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
+                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 25,
+                        [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 25,
+                        [CONF_SG_RXT]                               = 1200,
+                        [CONF_SG_TXT]                               = 1000,
+                        [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
+                        [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
+                        [CONF_SG_UPSD_TIMEOUT]                      = 10,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
+                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
+                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
+                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
+                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
+                        [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
+                        [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
+                        [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
+                        [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
+                        [CONF_SG_HV3_MAX_SERVED]                    = 6,
+                        [CONF_SG_DHCP_TIME]                         = 5000,
+                        [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
+                        [CONF_SG_TEMP_PARAM_1]                      = 0,
+                        [CONF_SG_TEMP_PARAM_2]                      = 0,
+                        [CONF_SG_TEMP_PARAM_3]                      = 0,
+                        [CONF_SG_TEMP_PARAM_4]                      = 0,
+                        [CONF_SG_TEMP_PARAM_5]                      = 0,
+                        [CONF_SG_AP_BEACON_MISS_TX]                 = 3,
+                        [CONF_SG_RX_WINDOW_LENGTH]                  = 6,
+                        [CONF_SG_AP_CONNECTION_PROTECTION_TIME]     = 50,
+                        [CONF_SG_TEMP_PARAM_6]                      = 1,
+                },
+                .state = CONF_SG_PROTECTIVE,
+        },
+        .rx = {
+                .rx_msdu_life_time           = 512000,
+                .packet_detection_threshold  = 0,
+                .ps_poll_timeout             = 15,
+                .upsd_timeout                = 15,
+                .rts_threshold               = IEEE80211_MAX_RTS_THRESHOLD,
+                .rx_cca_threshold            = 0,
+                .irq_blk_threshold           = 0xFFFF,
+                .irq_pkt_threshold           = 0,
+                .irq_timeout                 = 600,
+                .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
+        },
+        .tx = {
+                .tx_energy_detection         = 0,
+                .sta_rc_conf                 = {
+                        .enabled_rates       = 0,
+                        .short_retry_limit   = 10,
+                        .long_retry_limit    = 10,
+                        .aflags              = 0,
+                },
+                .ac_conf_count               = 4,
+                .ac_conf                     = {
+                        [CONF_TX_AC_BE] = {
+                                .ac          = CONF_TX_AC_BE,
+                                .cw_min      = 15,
+                                .cw_max      = 63,
+                                .aifsn       = 3,
+                                .tx_op_limit = 0,
+                        },
+                        [CONF_TX_AC_BK] = {
+                                .ac          = CONF_TX_AC_BK,
+                                .cw_min      = 15,
+                                .cw_max      = 63,
+                                .aifsn       = 7,
+                                .tx_op_limit = 0,
+                        },
+                        [CONF_TX_AC_VI] = {
+                                .ac          = CONF_TX_AC_VI,
+                                .cw_min      = 15,
+                                .cw_max      = 63,
+                                .aifsn       = CONF_TX_AIFS_PIFS,
+                                .tx_op_limit = 3008,
+                        },
+                        [CONF_TX_AC_VO] = {
+                                .ac          = CONF_TX_AC_VO,
+                                .cw_min      = 15,
+                                .cw_max      = 63,
+                                .aifsn       = CONF_TX_AIFS_PIFS,
+                                .tx_op_limit = 1504,
+                        },
+                },
+                .ap_max_tx_retries = 100,
+                .tid_conf_count = 4,
+                .tid_conf = {
+                        [CONF_TX_AC_BE] = {
+                                .queue_id    = CONF_TX_AC_BE,
+                                .channel_type = CONF_CHANNEL_TYPE_EDCF,
+                                .tsid        = CONF_TX_AC_BE,
+                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
+                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
+                                .apsd_conf   = {0, 0},
+                        },
+                        [CONF_TX_AC_BK] = {
+                                .queue_id    = CONF_TX_AC_BK,
+                                .channel_type = CONF_CHANNEL_TYPE_EDCF,
+                                .tsid        = CONF_TX_AC_BK,
+                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
+                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
+                                .apsd_conf   = {0, 0},
+                        },
+                        [CONF_TX_AC_VI] = {
+                                .queue_id    = CONF_TX_AC_VI,
+                                .channel_type = CONF_CHANNEL_TYPE_EDCF,
+                                .tsid        = CONF_TX_AC_VI,
+                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
+                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
+                                .apsd_conf   = {0, 0},
+                        },
+                        [CONF_TX_AC_VO] = {
+                                .queue_id    = CONF_TX_AC_VO,
+                                .channel_type = CONF_CHANNEL_TYPE_EDCF,
+                                .tsid        = CONF_TX_AC_VO,
+                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
+                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
+                                .apsd_conf   = {0, 0},
+                        },
+                },
+                .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
+                .tx_compl_timeout            = 700,
+                .tx_compl_threshold          = 4,
+                .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
+                .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
+                .tmpl_short_retry_limit      = 10,
+                .tmpl_long_retry_limit       = 10,
+        },
+        .conn = {
+                .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
+                .listen_interval             = 1,
+                .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
+                .bcn_filt_ie_count           = 2,
+                .bcn_filt_ie = {
+                        [0] = {
+                                .ie          = WLAN_EID_CHANNEL_SWITCH,
+                                .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
+                        },
+                        [1] = {
+                                .ie          = WLAN_EID_HT_INFORMATION,
+                                .rule        = CONF_BCN_RULE_PASS_ON_CHANGE,
+                        },
+                },
+                .synch_fail_thold            = 10,
+                .bss_lose_timeout            = 100,
+                .beacon_rx_timeout           = 10000,
+                .broadcast_timeout           = 20000,
+                .rx_broadcast_in_ps          = 1,
+                .ps_poll_threshold           = 10,
+                .ps_poll_recovery_period     = 700,
+                .bet_enable                  = CONF_BET_MODE_ENABLE,
+                .bet_max_consecutive         = 50,
+                .psm_entry_retries           = 5,
+                .psm_exit_retries            = 16,
+                .psm_entry_nullfunc_retries  = 3,
+                .psm_entry_hangover_period   = 1,
+                .keep_alive_interval         = 55000,
+                .max_listen_interval         = 20,
+        },
+        .itrim = {
+                .enable = false,
+                .timeout = 50000,
+        },
+        .pm_config = {
+                .host_clk_settling_time = 5000,
+                .host_fast_wakeup_support = false
+        },
+        .roam_trigger = {
+                .trigger_pacing               = 1,
+                .avg_weight_rssi_beacon       = 20,
+                .avg_weight_rssi_data         = 10,
+                .avg_weight_snr_beacon        = 20,
+                .avg_weight_snr_data          = 10,
+        },
+        .scan = {
+                .min_dwell_time_active        = 7500,
+                .max_dwell_time_active        = 30000,
+                .min_dwell_time_passive       = 100000,
+                .max_dwell_time_passive       = 100000,
+                .num_probe_reqs               = 2,
+        },
+        .sched_scan = {
+                /* sched_scan requires dwell times in TU instead of TU/1000 */
+                .min_dwell_time_active = 8,
+                .max_dwell_time_active = 30,
+                .dwell_time_passive    = 100,
+                .dwell_time_dfs        = 150,
+                .num_probe_reqs        = 2,
+                .rssi_threshold        = -90,
+                .snr_threshold         = 0,
+        },
+        .rf = {
+                .tx_per_channel_power_compensation_2 = {
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                },
+                .tx_per_channel_power_compensation_5 = {
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                },
+        },
+        .ht = {
+                .tx_ba_win_size = 64,
+                .inactivity_timeout = 10000,
+        },
+        .mem_wl127x = {
+                .num_stations                 = 1,
+                .ssid_profiles                = 1,
+                .rx_block_num                 = 70,
+                .tx_min_block_num             = 40,
+                .dynamic_memory               = 1,
+                .min_req_tx_blocks            = 100,
+                .min_req_rx_blocks            = 22,
+                .tx_min                       = 27,
+        },
+        .mem_wl128x = {
+                .num_stations                 = 1,
+                .ssid_profiles                = 1,
+                .rx_block_num                 = 40,
+                .tx_min_block_num             = 40,
+                .dynamic_memory               = 1,
+                .min_req_tx_blocks            = 45,
+                .min_req_rx_blocks            = 22,
+                .tx_min                       = 27,
+        },
+        .fm_coex = {
+                .enable                       = true,
+                .swallow_period               = 5,
+                .n_divider_fref_set_1         = 0xff,       /* default */
+                .n_divider_fref_set_2         = 12,
+                .m_divider_fref_set_1         = 148,
+                .m_divider_fref_set_2         = 0xffff,     /* default */
+                .coex_pll_stabilization_time  = 0xffffffff, /* default */
+                .ldo_stabilization_time       = 0xffff,     /* default */
+                .fm_disturbed_band_margin     = 0xff,       /* default */
+                .swallow_clk_diff             = 0xff,       /* default */
+        },
+        .hci_io_ds = HCI_IO_DS_6MA,
+};
+
+static void __wl1271_op_remove_interface(struct wl1271 *wl,
+                                         bool reset_tx_queues);
+static void wl1271_free_ap_keys(struct wl1271 *wl);
+
+
+static void wl1271_device_release(struct device *dev)
+{
+
+}
+
+static struct platform_device wl1271_device = {
+        .name           = "wl1271",
+        .id             = -1,
+
+        /* device model insists to have a release function */
+        .dev            = {
+                .release = wl1271_device_release,
+        },
+};
+
+static DEFINE_MUTEX(wl_list_mutex);
+static LIST_HEAD(wl_list);
+
+static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
+                             void *arg)
+{
+        struct net_device *dev = arg;
+        struct wireless_dev *wdev;
+        struct wiphy *wiphy;
+        struct ieee80211_hw *hw;
+        struct wl1271 *wl;
+        struct wl1271 *wl_temp;
+        int ret = 0;
+
+        /* Check that this notification is for us. */
+        if (what != NETDEV_CHANGE)
+                return NOTIFY_DONE;
+
+        wdev = dev->ieee80211_ptr;
+        if (wdev == NULL)
+                return NOTIFY_DONE;
+
+        wiphy = wdev->wiphy;
+        if (wiphy == NULL)
+                return NOTIFY_DONE;
+
+        hw = wiphy_priv(wiphy);
+        if (hw == NULL)
+                return NOTIFY_DONE;
+
+        wl_temp = hw->priv;
+        mutex_lock(&wl_list_mutex);
+        list_for_each_entry(wl, &wl_list, list) {
+                if (wl == wl_temp)
+                        break;
+        }
+        mutex_unlock(&wl_list_mutex);
+        if (wl != wl_temp)
+                return NOTIFY_DONE;
+
+        mutex_lock(&wl->mutex);
+
+        if (wl->state == WL1271_STATE_OFF)
+                goto out;
+
+        if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        if ((dev->operstate == IF_OPER_UP) &&
+            !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
+                wl1271_cmd_set_sta_state(wl);
+                wl1271_info("Association completed.");
+        }
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return NOTIFY_OK;
+}
+
+static int wl1271_reg_notify(struct wiphy *wiphy,
+                             struct regulatory_request *request)
+{
+        struct ieee80211_supported_band *band;
+        struct ieee80211_channel *ch;
+        int i;
+
+        band = wiphy->bands[IEEE80211_BAND_5GHZ];
+        for (i = 0; i < band->n_channels; i++) {
+                ch = &band->channels[i];
+                if (ch->flags & IEEE80211_CHAN_DISABLED)
+                        continue;
+
+                if (ch->flags & IEEE80211_CHAN_RADAR)
+                        ch->flags |= IEEE80211_CHAN_NO_IBSS |
+                                     IEEE80211_CHAN_PASSIVE_SCAN;
+
+        }
+
+        return 0;
+}
+
+static void wl1271_conf_init(struct wl1271 *wl)
+{
+
+        /*
+         * This function applies the default configuration to the driver. This
+         * function is invoked upon driver load (spi probe.)
+         *
+         * The configuration is stored in a run-time structure in order to
+         * facilitate for run-time adjustment of any of the parameters. Making
+         * changes to the configuration structure will apply the new values on
+         * the next interface up (wl1271_op_start.)
+         */
+
+        /* apply driver default configuration */
+        memcpy(&wl->conf, &default_conf, sizeof(default_conf));
+}
+
+
+static int wl1271_plt_init(struct wl1271 *wl)
+{
+        struct conf_tx_ac_category *conf_ac;
+        struct conf_tx_tid *conf_tid;
+        int ret, i;
+
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                ret = wl128x_cmd_general_parms(wl);
+        else
+                ret = wl1271_cmd_general_parms(wl);
+        if (ret < 0)
+                return ret;
+
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                ret = wl128x_cmd_radio_parms(wl);
+        else
+                ret = wl1271_cmd_radio_parms(wl);
+        if (ret < 0)
+                return ret;
+
+        if (wl->chip.id != CHIP_ID_1283_PG20) {
+                ret = wl1271_cmd_ext_radio_parms(wl);
+                if (ret < 0)
+                        return ret;
+        }
+        if (ret < 0)
+                return ret;
+
+        /* Chip-specific initializations */
+        ret = wl1271_chip_specific_init(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_sta_init_templates_config(wl);
+        if (ret < 0)
+                return ret;
+
+        ret = wl1271_acx_init_mem_config(wl);
+        if (ret < 0)
+                return ret;
+
+        /* PHY layer config */
+        ret = wl1271_init_phy_config(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        ret = wl1271_acx_dco_itrim_params(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Initialize connection monitoring thresholds */
+        ret = wl1271_acx_conn_monit_params(wl, false);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Bluetooth WLAN coexistence */
+        ret = wl1271_init_pta(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* FM WLAN coexistence */
+        ret = wl1271_acx_fm_coex(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Energy detection */
+        ret = wl1271_init_energy_detection(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        ret = wl1271_acx_sta_mem_cfg(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Default fragmentation threshold */
+        ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Default TID/AC configuration */
+        BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
+        for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
+                conf_ac = &wl->conf.tx.ac_conf[i];
+                ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
+                                        conf_ac->cw_max, conf_ac->aifsn,
+                                        conf_ac->tx_op_limit);
+                if (ret < 0)
+                        goto out_free_memmap;
+
+                conf_tid = &wl->conf.tx.tid_conf[i];
+                ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
+                                         conf_tid->channel_type,
+                                         conf_tid->tsid,
+                                         conf_tid->ps_scheme,
+                                         conf_tid->ack_policy,
+                                         conf_tid->apsd_conf[0],
+                                         conf_tid->apsd_conf[1]);
+                if (ret < 0)
+                        goto out_free_memmap;
+        }
+
+        /* Enable data path */
+        ret = wl1271_cmd_data_path(wl, 1);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* Configure for CAM power saving (ie. always active) */
+        ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        /* configure PM */
+        ret = wl1271_acx_pm_config(wl);
+        if (ret < 0)
+                goto out_free_memmap;
+
+        return 0;
+
+ out_free_memmap:
+        kfree(wl->target_mem_map);
+        wl->target_mem_map = NULL;
+
+        return ret;
+}
+
+static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
+{
+        bool fw_ps;
+
+        /* only regulate station links */
+        if (hlid < WL1271_AP_STA_HLID_START)
+                return;
+
+        fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
+
+        /*
+         * Wake up from high level PS if the STA is asleep with too little
+         * blocks in FW or if the STA is awake.
+         */
+        if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
+                wl1271_ps_link_end(wl, hlid);
+
+        /* Start high-level PS if the STA is asleep with enough blocks in FW */
+        else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
+                wl1271_ps_link_start(wl, hlid, true);
+}
+
+static void wl1271_irq_update_links_status(struct wl1271 *wl,
+                                       struct wl1271_fw_ap_status *status)
+{
+        u32 cur_fw_ps_map;
+        u8 hlid;
+
+        cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
+        if (wl->ap_fw_ps_map != cur_fw_ps_map) {
+                wl1271_debug(DEBUG_PSM,
+                             "link ps prev 0x%x cur 0x%x changed 0x%x",
+                             wl->ap_fw_ps_map, cur_fw_ps_map,
+                             wl->ap_fw_ps_map ^ cur_fw_ps_map);
+
+                wl->ap_fw_ps_map = cur_fw_ps_map;
+        }
+
+        for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
+                u8 cnt = status->tx_lnk_free_blks[hlid] -
+                        wl->links[hlid].prev_freed_blks;
+
+                wl->links[hlid].prev_freed_blks =
+                        status->tx_lnk_free_blks[hlid];
+                wl->links[hlid].allocated_blks -= cnt;
+
+                wl1271_irq_ps_regulate_link(wl, hlid,
+                                            wl->links[hlid].allocated_blks);
+        }
+}
+
+static void wl1271_fw_status(struct wl1271 *wl,
+                             struct wl1271_fw_full_status *full_status)
+{
+        struct wl1271_fw_common_status *status = &full_status->common;
+        struct timespec ts;
+        u32 old_tx_blk_count = wl->tx_blocks_available;
+        u32 freed_blocks = 0;
+        int i;
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS) {
+                wl1271_raw_read(wl, FW_STATUS_ADDR, status,
+                                sizeof(struct wl1271_fw_ap_status), false);
+        } else {
+                wl1271_raw_read(wl, FW_STATUS_ADDR, status,
+                                sizeof(struct wl1271_fw_sta_status), false);
+        }
+
+        wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
+                     "drv_rx_counter = %d, tx_results_counter = %d)",
+                     status->intr,
+                     status->fw_rx_counter,
+                     status->drv_rx_counter,
+                     status->tx_results_counter);
+
+        /* update number of available TX blocks */
+        for (i = 0; i < NUM_TX_QUEUES; i++) {
+                freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
+                                wl->tx_blocks_freed[i];
+
+                wl->tx_blocks_freed[i] =
+                        le32_to_cpu(status->tx_released_blks[i]);
+        }
+
+        wl->tx_allocated_blocks -= freed_blocks;
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS) {
+                /* Update num of allocated TX blocks per link and ps status */
+                wl1271_irq_update_links_status(wl, &full_status->ap);
+                wl->tx_blocks_available += freed_blocks;
+        } else {
+                int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
+
+                /*
+                 * The FW might change the total number of TX memblocks before
+                 * we get a notification about blocks being released. Thus, the
+                 * available blocks calculation might yield a temporary result
+                 * which is lower than the actual available blocks. Keeping in
+                 * mind that only blocks that were allocated can be moved from
+                 * TX to RX, tx_blocks_available should never decrease here.
+                 */
+                wl->tx_blocks_available = max((int)wl->tx_blocks_available,
+                                              avail);
+        }
+
+        /* if more blocks are available now, tx work can be scheduled */
+        if (wl->tx_blocks_available > old_tx_blk_count)
+                clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
+
+        /* update the host-chipset time offset */
+        getnstimeofday(&ts);
+        wl->time_offset = (timespec_to_ns(&ts) >> 10) -
+                (s64)le32_to_cpu(status->fw_localtime);
+}
+
+static void wl1271_flush_deferred_work(struct wl1271 *wl)
+{
+        struct sk_buff *skb;
+
+        /* Pass all received frames to the network stack */
+        while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
+                ieee80211_rx_ni(wl->hw, skb);
+
+        /* Return sent skbs to the network stack */
+        while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
+                ieee80211_tx_status(wl->hw, skb);
+}
+
+static void wl1271_netstack_work(struct work_struct *work)
+{
+        struct wl1271 *wl =
+                container_of(work, struct wl1271, netstack_work);
+
+        do {
+                wl1271_flush_deferred_work(wl);
+        } while (skb_queue_len(&wl->deferred_rx_queue));
+}
+
+#define WL1271_IRQ_MAX_LOOPS 256
+
+irqreturn_t wl1271_irq(int irq, void *cookie)
+{
+        int ret;
+        u32 intr;
+        int loopcount = WL1271_IRQ_MAX_LOOPS;
+        struct wl1271 *wl = (struct wl1271 *)cookie;
+        bool done = false;
+        unsigned int defer_count;
+        unsigned long flags;
+
+        /* TX might be handled here, avoid redundant work */
+        set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
+        cancel_work_sync(&wl->tx_work);
+
+        /*
+         * In case edge triggered interrupt must be used, we cannot iterate
+         * more than once without introducing race conditions with the hardirq.
+         */
+        if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
+                loopcount = 1;
+
+        mutex_lock(&wl->mutex);
+
+        wl1271_debug(DEBUG_IRQ, "IRQ work");
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        while (!done && loopcount--) {
+                /*
+                 * In order to avoid a race with the hardirq, clear the flag
+                 * before acknowledging the chip. Since the mutex is held,
+                 * wl1271_ps_elp_wakeup cannot be called concurrently.
+                 */
+                clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
+                smp_mb__after_clear_bit();
+
+                wl1271_fw_status(wl, wl->fw_status);
+                intr = le32_to_cpu(wl->fw_status->common.intr);
+                intr &= WL1271_INTR_MASK;
+                if (!intr) {
+                        done = true;
+                        continue;
+                }
+
+                if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
+                        wl1271_error("watchdog interrupt received! "
+                                     "starting recovery.");
+                        ieee80211_queue_work(wl->hw, &wl->recovery_work);
+
+                        /* restarting the chip. ignore any other interrupt. */
+                        goto out;
+                }
+
+                if (likely(intr & WL1271_ACX_INTR_DATA)) {
+                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
+
+                        wl1271_rx(wl, &wl->fw_status->common);
+
+                        /* Check if any tx blocks were freed */
+                        spin_lock_irqsave(&wl->wl_lock, flags);
+                        if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
+                            wl->tx_queue_count) {
+                                spin_unlock_irqrestore(&wl->wl_lock, flags);
+                                /*
+                                 * In order to avoid starvation of the TX path,
+                                 * call the work function directly.
+                                 */
+                                wl1271_tx_work_locked(wl);
+                        } else {
+                                spin_unlock_irqrestore(&wl->wl_lock, flags);
+                        }
+
+                        /* check for tx results */
+                        if (wl->fw_status->common.tx_results_counter !=
+                            (wl->tx_results_count & 0xff))
+                                wl1271_tx_complete(wl);
+
+                        /* Make sure the deferred queues don't get too long */
+                        defer_count = skb_queue_len(&wl->deferred_tx_queue) +
+                                      skb_queue_len(&wl->deferred_rx_queue);
+                        if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
+                                wl1271_flush_deferred_work(wl);
+                }
+
+                if (intr & WL1271_ACX_INTR_EVENT_A) {
+                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
+                        wl1271_event_handle(wl, 0);
+                }
+
+                if (intr & WL1271_ACX_INTR_EVENT_B) {
+                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
+                        wl1271_event_handle(wl, 1);
+                }
+
+                if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
+                        wl1271_debug(DEBUG_IRQ,
+                                     "WL1271_ACX_INTR_INIT_COMPLETE");
+
+                if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
+                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
+        }
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        spin_lock_irqsave(&wl->wl_lock, flags);
+        /* In case TX was not handled here, queue TX work */
+        clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
+        if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
+            wl->tx_queue_count)
+                ieee80211_queue_work(wl->hw, &wl->tx_work);
+        spin_unlock_irqrestore(&wl->wl_lock, flags);
+
+        mutex_unlock(&wl->mutex);
+
+        return IRQ_HANDLED;
+}
+EXPORT_SYMBOL_GPL(wl1271_irq);
+
+static int wl1271_fetch_firmware(struct wl1271 *wl)
+{
+        const struct firmware *fw;
+        const char *fw_name;
+        int ret;
+
+        switch (wl->bss_type) {
+        case BSS_TYPE_AP_BSS:
+                if (wl->chip.id == CHIP_ID_1283_PG20)
+                        fw_name = WL128X_AP_FW_NAME;
+                else
+                        fw_name = WL127X_AP_FW_NAME;
+                break;
+        case BSS_TYPE_IBSS:
+        case BSS_TYPE_STA_BSS:
+                if (wl->chip.id == CHIP_ID_1283_PG20)
+                        fw_name = WL128X_FW_NAME;
+                else
+                        fw_name = WL1271_FW_NAME;
+                break;
+        default:
+                wl1271_error("no compatible firmware for bss_type %d",
+                             wl->bss_type);
+                return -EINVAL;
+        }
+
+        wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
+
+        ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
+
+        if (ret < 0) {
+                wl1271_error("could not get firmware: %d", ret);
+                return ret;
+        }
+
+        if (fw->size % 4) {
+                wl1271_error("firmware size is not multiple of 32 bits: %zu",
+                             fw->size);
+                ret = -EILSEQ;
+                goto out;
+        }
+
+        vfree(wl->fw);
+        wl->fw_len = fw->size;
+        wl->fw = vmalloc(wl->fw_len);
+
+        if (!wl->fw) {
+                wl1271_error("could not allocate memory for the firmware");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        memcpy(wl->fw, fw->data, wl->fw_len);
+        wl->fw_bss_type = wl->bss_type;
+        ret = 0;
+
+out:
+        release_firmware(fw);
+
+        return ret;
+}
+
+static int wl1271_fetch_nvs(struct wl1271 *wl)
+{
+        const struct firmware *fw;
+        int ret;
+
+        ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
+
+        if (ret < 0) {
+                wl1271_error("could not get nvs file: %d", ret);
+                return ret;
+        }
+
+        wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
+
+        if (!wl->nvs) {
+                wl1271_error("could not allocate memory for the nvs file");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        wl->nvs_len = fw->size;
+
+out:
+        release_firmware(fw);
+
+        return ret;
+}
+
+static void wl1271_recovery_work(struct work_struct *work)
+{
+        struct wl1271 *wl =
+                container_of(work, struct wl1271, recovery_work);
+
+        mutex_lock(&wl->mutex);
+
+        if (wl->state != WL1271_STATE_ON)
+                goto out;
+
+        wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
+                    wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
+
+        if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
+                ieee80211_connection_loss(wl->vif);
+
+        /* Prevent spurious TX during FW restart */
+        ieee80211_stop_queues(wl->hw);
+
+        if (wl->sched_scanning) {
+                ieee80211_sched_scan_stopped(wl->hw);
+                wl->sched_scanning = false;
+        }
+
+        /* reboot the chipset */
+        __wl1271_op_remove_interface(wl, false);
+        ieee80211_restart_hw(wl->hw);
+
+        /*
+         * Its safe to enable TX now - the queues are stopped after a request
+         * to restart the HW.
+         */
+        ieee80211_wake_queues(wl->hw);
+
+out:
+        mutex_unlock(&wl->mutex);
+}
+
+static void wl1271_fw_wakeup(struct wl1271 *wl)
+{
+        u32 elp_reg;
+
+        elp_reg = ELPCTRL_WAKE_UP;
+        wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
+}
+
+static int wl1271_setup(struct wl1271 *wl)
+{
+        wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
+        if (!wl->fw_status)
+                return -ENOMEM;
+
+        wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
+        if (!wl->tx_res_if) {
+                kfree(wl->fw_status);
+                return -ENOMEM;
+        }
+
+        return 0;
+}
+
+static int wl1271_chip_wakeup(struct wl1271 *wl)
+{
+        struct wl1271_partition_set partition;
+        int ret = 0;
+
+        msleep(WL1271_PRE_POWER_ON_SLEEP);
+        ret = wl1271_power_on(wl);
+        if (ret < 0)
+                goto out;
+        msleep(WL1271_POWER_ON_SLEEP);
+        wl1271_io_reset(wl);
+        wl1271_io_init(wl);
+
+        /* We don't need a real memory partition here, because we only want
+         * to use the registers at this point. */
+        memset(&partition, 0, sizeof(partition));
+        partition.reg.start = REGISTERS_BASE;
+        partition.reg.size = REGISTERS_DOWN_SIZE;
+        wl1271_set_partition(wl, &partition);
+
+        /* ELP module wake up */
+        wl1271_fw_wakeup(wl);
+
+        /* whal_FwCtrl_BootSm() */
+
+        /* 0. read chip id from CHIP_ID */
+        wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
+
+        /* 1. check if chip id is valid */
+
+        switch (wl->chip.id) {
+        case CHIP_ID_1271_PG10:
+                wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
+                               wl->chip.id);
+
+                ret = wl1271_setup(wl);
+                if (ret < 0)
+                        goto out;
+                break;
+        case CHIP_ID_1271_PG20:
+                wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
+                             wl->chip.id);
+
+                /* end-of-transaction flag should be set in wl127x AP mode */
+                if (wl->bss_type == BSS_TYPE_AP_BSS)
+                        wl->quirks |= WL12XX_QUIRK_END_OF_TRANSACTION;
+
+                ret = wl1271_setup(wl);
+                if (ret < 0)
+                        goto out;
+                break;
+        case CHIP_ID_1283_PG20:
+                wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
+                             wl->chip.id);
+
+                ret = wl1271_setup(wl);
+                if (ret < 0)
+                        goto out;
+                if (wl1271_set_block_size(wl))
+                        wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
+                break;
+        case CHIP_ID_1283_PG10:
+        default:
+                wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
+                ret = -ENODEV;
+                goto out;
+        }
+
+        /* Make sure the firmware type matches the BSS type */
+        if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
+                ret = wl1271_fetch_firmware(wl);
+                if (ret < 0)
+                        goto out;
+        }
+
+        /* No NVS from netlink, try to get it from the filesystem */
+        if (wl->nvs == NULL) {
+                ret = wl1271_fetch_nvs(wl);
+                if (ret < 0)
+                        goto out;
+        }
+
+out:
+        return ret;
+}
+
+static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
+{
+        unsigned int quirks = 0;
+        unsigned int *fw_ver = wl->chip.fw_ver;
+
+        /* Only for wl127x */
+        if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
+            /* Check STA version */
+            (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
+              (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
+             /* Check AP version */
+             ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
+              (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
+                quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
+
+        return quirks;
+}
+
+int wl1271_plt_start(struct wl1271 *wl)
+{
+        int retries = WL1271_BOOT_RETRIES;
+        int ret;
+
+        mutex_lock(&wl->mutex);
+
+        wl1271_notice("power up");
+
+        if (wl->state != WL1271_STATE_OFF) {
+                wl1271_error("cannot go into PLT state because not "
+                             "in off state: %d", wl->state);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        wl->bss_type = BSS_TYPE_STA_BSS;
+
+        while (retries) {
+                retries--;
+                ret = wl1271_chip_wakeup(wl);
+                if (ret < 0)
+                        goto power_off;
+
+                ret = wl1271_boot(wl);
+                if (ret < 0)
+                        goto power_off;
+
+                ret = wl1271_plt_init(wl);
+                if (ret < 0)
+                        goto irq_disable;
+
+                wl->state = WL1271_STATE_PLT;
+                wl1271_notice("firmware booted in PLT mode (%s)",
+                              wl->chip.fw_ver_str);
+
+                /* Check if any quirks are needed with older fw versions */
+                wl->quirks |= wl1271_get_fw_ver_quirks(wl);
+                goto out;
+
+irq_disable:
+                mutex_unlock(&wl->mutex);
+                /* Unlocking the mutex in the middle of handling is
+                   inherently unsafe. In this case we deem it safe to do,
+                   because we need to let any possibly pending IRQ out of
+                   the system (and while we are WL1271_STATE_OFF the IRQ
+                   work function will not do anything.) Also, any other
+                   possible concurrent operations will fail due to the
+                   current state, hence the wl1271 struct should be safe. */
+                wl1271_disable_interrupts(wl);
+                wl1271_flush_deferred_work(wl);
+                cancel_work_sync(&wl->netstack_work);
+                mutex_lock(&wl->mutex);
+power_off:
+                wl1271_power_off(wl);
+        }
+
+        wl1271_error("firmware boot in PLT mode failed despite %d retries",
+                     WL1271_BOOT_RETRIES);
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+static int __wl1271_plt_stop(struct wl1271 *wl)
+{
+        int ret = 0;
+
+        wl1271_notice("power down");
+
+        if (wl->state != WL1271_STATE_PLT) {
+                wl1271_error("cannot power down because not in PLT "
+                             "state: %d", wl->state);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        wl1271_power_off(wl);
+
+        wl->state = WL1271_STATE_OFF;
+        wl->rx_counter = 0;
+
+        mutex_unlock(&wl->mutex);
+        wl1271_disable_interrupts(wl);
+        wl1271_flush_deferred_work(wl);
+        cancel_work_sync(&wl->netstack_work);
+        cancel_work_sync(&wl->recovery_work);
+        mutex_lock(&wl->mutex);
+out:
+        return ret;
+}
+
+int wl1271_plt_stop(struct wl1271 *wl)
+{
+        int ret;
+
+        mutex_lock(&wl->mutex);
+        ret = __wl1271_plt_stop(wl);
+        mutex_unlock(&wl->mutex);
+        return ret;
+}
+
+static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
+{
+        struct wl1271 *wl = hw->priv;
+        unsigned long flags;
+        int q;
+        u8 hlid = 0;
+
+        q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS)
+                hlid = wl1271_tx_get_hlid(skb);
+
+        spin_lock_irqsave(&wl->wl_lock, flags);
+
+        wl->tx_queue_count++;
+
+        /*
+         * The workqueue is slow to process the tx_queue and we need stop
+         * the queue here, otherwise the queue will get too long.
+         */
+        if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
+                wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
+                ieee80211_stop_queues(wl->hw);
+                set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
+        }
+
+        /* queue the packet */
+        if (wl->bss_type == BSS_TYPE_AP_BSS) {
+                wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
+                skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
+        } else {
+                skb_queue_tail(&wl->tx_queue[q], skb);
+        }
+
+        /*
+         * The chip specific setup must run before the first TX packet -
+         * before that, the tx_work will not be initialized!
+         */
+
+        if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
+            !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
+                ieee80211_queue_work(wl->hw, &wl->tx_work);
+
+        spin_unlock_irqrestore(&wl->wl_lock, flags);
+}
+
+int wl1271_tx_dummy_packet(struct wl1271 *wl)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wl->wl_lock, flags);
+        set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
+        wl->tx_queue_count++;
+        spin_unlock_irqrestore(&wl->wl_lock, flags);
+
+        /* The FW is low on RX memory blocks, so send the dummy packet asap */
+        if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
+                wl1271_tx_work_locked(wl);
+
+        /*
+         * If the FW TX is busy, TX work will be scheduled by the threaded
+         * interrupt handler function
+         */
+        return 0;
+}
+
+/*
+ * The size of the dummy packet should be at least 1400 bytes. However, in
+ * order to minimize the number of bus transactions, aligning it to 512 bytes
+ * boundaries could be beneficial, performance wise
+ */
+#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
+
+static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
+{
+        struct sk_buff *skb;
+        struct ieee80211_hdr_3addr *hdr;
+        unsigned int dummy_packet_size;
+
+        dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
+                            sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
+
+        skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
+        if (!skb) {
+                wl1271_warning("Failed to allocate a dummy packet skb");
+                return NULL;
+        }
+
+        skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
+
+        hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
+        memset(hdr, 0, sizeof(*hdr));
+        hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
+                                         IEEE80211_STYPE_NULLFUNC |
+                                         IEEE80211_FCTL_TODS);
+
+        memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
+
+        /* Dummy packets require the TID to be management */
+        skb->priority = WL1271_TID_MGMT;
+
+        /* Initialize all fields that might be used */
+        skb_set_queue_mapping(skb, 0);
+        memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
+
+        return skb;
+}
+
+
+static struct notifier_block wl1271_dev_notifier = {
+        .notifier_call = wl1271_dev_notify,
+};
+
+#ifdef CONFIG_PM
+static int wl1271_configure_suspend(struct wl1271 *wl)
+{
+        int ret;
+
+        if (wl->bss_type != BSS_TYPE_STA_BSS)
+                return 0;
+
+        mutex_lock(&wl->mutex);
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out_unlock;
+
+        /* enter psm if needed*/
+        if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
+                DECLARE_COMPLETION_ONSTACK(compl);
+
+                wl->ps_compl = &compl;
+                ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
+                                   wl->basic_rate, true);
+                if (ret < 0)
+                        goto out_sleep;
+
+                /* we must unlock here so we will be able to get events */
+                wl1271_ps_elp_sleep(wl);
+                mutex_unlock(&wl->mutex);
+
+                ret = wait_for_completion_timeout(
+                        &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
+                if (ret <= 0) {
+                        wl1271_warning("couldn't enter ps mode!");
+                        ret = -EBUSY;
+                        goto out;
+                }
+
+                /* take mutex again, and wakeup */
+                mutex_lock(&wl->mutex);
+
+                ret = wl1271_ps_elp_wakeup(wl);
+                if (ret < 0)
+                        goto out_unlock;
+        }
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+out_unlock:
+        mutex_unlock(&wl->mutex);
+out:
+        return ret;
+
+}
+
+static void wl1271_configure_resume(struct wl1271 *wl)
+{
+        int ret;
+
+        if (wl->bss_type != BSS_TYPE_STA_BSS)
+                return;
+
+        mutex_lock(&wl->mutex);
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        /* exit psm if it wasn't configured */
+        if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
+                wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
+                                   wl->basic_rate, true);
+
+        wl1271_ps_elp_sleep(wl);
+out:
+        mutex_unlock(&wl->mutex);
+}
+
+static int wl1271_op_suspend(struct ieee80211_hw *hw,
+                            struct cfg80211_wowlan *wow)
+{
+        struct wl1271 *wl = hw->priv;
+        wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
+        wl->wow_enabled = !!wow;
+        if (wl->wow_enabled) {
+                int ret;
+                ret = wl1271_configure_suspend(wl);
+                if (ret < 0) {
+                        wl1271_warning("couldn't prepare device to suspend");
+                        return ret;
+                }
+                /* flush any remaining work */
+                wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
+                flush_delayed_work(&wl->scan_complete_work);
+
+                /*
+                 * disable and re-enable interrupts in order to flush
+                 * the threaded_irq
+                 */
+                wl1271_disable_interrupts(wl);
+
+                /*
+                 * set suspended flag to avoid triggering a new threaded_irq
+                 * work. no need for spinlock as interrupts are disabled.
+                 */
+                set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
+
+                wl1271_enable_interrupts(wl);
+                flush_work(&wl->tx_work);
+                flush_delayed_work(&wl->pspoll_work);
+                flush_delayed_work(&wl->elp_work);
+        }
+        return 0;
+}
+
+static int wl1271_op_resume(struct ieee80211_hw *hw)
+{
+        struct wl1271 *wl = hw->priv;
+        wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
+                     wl->wow_enabled);
+
+        /*
+         * re-enable irq_work enqueuing, and call irq_work directly if
+         * there is a pending work.
+         */
+        if (wl->wow_enabled) {
+                struct wl1271 *wl = hw->priv;
+                unsigned long flags;
+                bool run_irq_work = false;
+
+                spin_lock_irqsave(&wl->wl_lock, flags);
+                clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
+                if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
+                        run_irq_work = true;
+                spin_unlock_irqrestore(&wl->wl_lock, flags);
+
+                if (run_irq_work) {
+                        wl1271_debug(DEBUG_MAC80211,
+                                     "run postponed irq_work directly");
+                        wl1271_irq(0, wl);
+                        wl1271_enable_interrupts(wl);
+                }
+
+                wl1271_configure_resume(wl);
+        }
+
+        return 0;
+}
+#endif
+
+static int wl1271_op_start(struct ieee80211_hw *hw)
+{
+        wl1271_debug(DEBUG_MAC80211, "mac80211 start");
+
+        /*
+         * We have to delay the booting of the hardware because
+         * we need to know the local MAC address before downloading and
+         * initializing the firmware. The MAC address cannot be changed
+         * after boot, and without the proper MAC address, the firmware
+         * will not function properly.
+         *
+         * The MAC address is first known when the corresponding interface
+         * is added. That is where we will initialize the hardware.
+         *
+         * In addition, we currently have different firmwares for AP and managed
+         * operation. We will know which to boot according to interface type.
+         */
+
+        return 0;
+}
+
+static void wl1271_op_stop(struct ieee80211_hw *hw)
+{
+        wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
+}
+
+static int wl1271_op_add_interface(struct ieee80211_hw *hw,
+                                   struct ieee80211_vif *vif)
+{
+        struct wl1271 *wl = hw->priv;
+        struct wiphy *wiphy = hw->wiphy;
+        int retries = WL1271_BOOT_RETRIES;
+        int ret = 0;
+        bool booted = false;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
+                     vif->type, vif->addr);
+
+        mutex_lock(&wl->mutex);
+        if (wl->vif) {
+                wl1271_debug(DEBUG_MAC80211,
+                             "multiple vifs are not supported yet");
+                ret = -EBUSY;
+                goto out;
+        }
+
+        /*
+         * in some very corner case HW recovery scenarios its possible to
+         * get here before __wl1271_op_remove_interface is complete, so
+         * opt out if that is the case.
+         */
+        if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        switch (vif->type) {
+        case NL80211_IFTYPE_STATION:
+                wl->bss_type = BSS_TYPE_STA_BSS;
+                wl->set_bss_type = BSS_TYPE_STA_BSS;
+                break;
+        case NL80211_IFTYPE_ADHOC:
+                wl->bss_type = BSS_TYPE_IBSS;
+                wl->set_bss_type = BSS_TYPE_STA_BSS;
+                break;
+        case NL80211_IFTYPE_AP:
+                wl->bss_type = BSS_TYPE_AP_BSS;
+                break;
+        default:
+                ret = -EOPNOTSUPP;
+                goto out;
+        }
+
+        memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
+
+        if (wl->state != WL1271_STATE_OFF) {
+                wl1271_error("cannot start because not in off state: %d",
+                             wl->state);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        while (retries) {
+                retries--;
+                ret = wl1271_chip_wakeup(wl);
+                if (ret < 0)
+                        goto power_off;
+
+                ret = wl1271_boot(wl);
+                if (ret < 0)
+                        goto power_off;
+
+                ret = wl1271_hw_init(wl);
+                if (ret < 0)
+                        goto irq_disable;
+
+                booted = true;
+                break;
+
+irq_disable:
+                mutex_unlock(&wl->mutex);
+                /* Unlocking the mutex in the middle of handling is
+                   inherently unsafe. In this case we deem it safe to do,
+                   because we need to let any possibly pending IRQ out of
+                   the system (and while we are WL1271_STATE_OFF the IRQ
+                   work function will not do anything.) Also, any other
+                   possible concurrent operations will fail due to the
+                   current state, hence the wl1271 struct should be safe. */
+                wl1271_disable_interrupts(wl);
+                wl1271_flush_deferred_work(wl);
+                cancel_work_sync(&wl->netstack_work);
+                mutex_lock(&wl->mutex);
+power_off:
+                wl1271_power_off(wl);
+        }
+
+        if (!booted) {
+                wl1271_error("firmware boot failed despite %d retries",
+                             WL1271_BOOT_RETRIES);
+                goto out;
+        }
+
+        wl->vif = vif;
+        wl->state = WL1271_STATE_ON;
+        set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
+        wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
+
+        /* update hw/fw version info in wiphy struct */
+        wiphy->hw_version = wl->chip.id;
+        strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
+                sizeof(wiphy->fw_version));
+
+        /* Check if any quirks are needed with older fw versions */
+        wl->quirks |= wl1271_get_fw_ver_quirks(wl);
+
+        /*
+         * Now we know if 11a is supported (info from the NVS), so disable
+         * 11a channels if not supported
+         */
+        if (!wl->enable_11a)
+                wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
+
+        wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
+                     wl->enable_11a ? "" : "not ");
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        mutex_lock(&wl_list_mutex);
+        if (!ret)
+                list_add(&wl->list, &wl_list);
+        mutex_unlock(&wl_list_mutex);
+
+        return ret;
+}
+
+static void __wl1271_op_remove_interface(struct wl1271 *wl,
+                                         bool reset_tx_queues)
+{
+        int i;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
+
+        /* because of hardware recovery, we may get here twice */
+        if (wl->state != WL1271_STATE_ON)
+                return;
+
+        wl1271_info("down");
+
+        mutex_lock(&wl_list_mutex);
+        list_del(&wl->list);
+        mutex_unlock(&wl_list_mutex);
+
+        /* enable dyn ps just in case (if left on due to fw crash etc) */
+        if (wl->bss_type == BSS_TYPE_STA_BSS)
+                ieee80211_enable_dyn_ps(wl->vif);
+
+        if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
+                wl->scan.state = WL1271_SCAN_STATE_IDLE;
+                memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
+                wl->scan.req = NULL;
+                ieee80211_scan_completed(wl->hw, true);
+        }
+
+        /*
+         * this must be before the cancel_work calls below, so that the work
+         * functions don't perform further work.
+         */
+        wl->state = WL1271_STATE_OFF;
+
+        mutex_unlock(&wl->mutex);
+
+        wl1271_disable_interrupts(wl);
+        wl1271_flush_deferred_work(wl);
+        cancel_delayed_work_sync(&wl->scan_complete_work);
+        cancel_work_sync(&wl->netstack_work);
+        cancel_work_sync(&wl->tx_work);
+        cancel_delayed_work_sync(&wl->pspoll_work);
+        cancel_delayed_work_sync(&wl->elp_work);
+
+        mutex_lock(&wl->mutex);
+
+        /* let's notify MAC80211 about the remaining pending TX frames */
+        wl1271_tx_reset(wl, reset_tx_queues);
+        wl1271_power_off(wl);
+
+        memset(wl->bssid, 0, ETH_ALEN);
+        memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
+        wl->ssid_len = 0;
+        wl->bss_type = MAX_BSS_TYPE;
+        wl->set_bss_type = MAX_BSS_TYPE;
+        wl->band = IEEE80211_BAND_2GHZ;
+
+        wl->rx_counter = 0;
+        wl->psm_entry_retry = 0;
+        wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
+        wl->tx_blocks_available = 0;
+        wl->tx_allocated_blocks = 0;
+        wl->tx_results_count = 0;
+        wl->tx_packets_count = 0;
+        wl->tx_security_last_seq = 0;
+        wl->tx_security_seq = 0;
+        wl->time_offset = 0;
+        wl->session_counter = 0;
+        wl->rate_set = CONF_TX_RATE_MASK_BASIC;
+        wl->vif = NULL;
+        wl->filters = 0;
+        wl1271_free_ap_keys(wl);
+        memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
+        wl->ap_fw_ps_map = 0;
+        wl->ap_ps_map = 0;
+        wl->sched_scanning = false;
+
+        /*
+         * this is performed after the cancel_work calls and the associated
+         * mutex_lock, so that wl1271_op_add_interface does not accidentally
+         * get executed before all these vars have been reset.
+         */
+        wl->flags = 0;
+
+        for (i = 0; i < NUM_TX_QUEUES; i++)
+                wl->tx_blocks_freed[i] = 0;
+
+        wl1271_debugfs_reset(wl);
+
+        kfree(wl->fw_status);
+        wl->fw_status = NULL;
+        kfree(wl->tx_res_if);
+        wl->tx_res_if = NULL;
+        kfree(wl->target_mem_map);
+        wl->target_mem_map = NULL;
+}
+
+static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
+                                       struct ieee80211_vif *vif)
+{
+        struct wl1271 *wl = hw->priv;
+
+        mutex_lock(&wl->mutex);
+        /*
+         * wl->vif can be null here if someone shuts down the interface
+         * just when hardware recovery has been started.
+         */
+        if (wl->vif) {
+                WARN_ON(wl->vif != vif);
+                __wl1271_op_remove_interface(wl, true);
+        }
+
+        mutex_unlock(&wl->mutex);
+        cancel_work_sync(&wl->recovery_work);
+}
+
+void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
+{
+        wl1271_set_default_filters(wl);
+
+        /* combine requested filters with current filter config */
+        filters = wl->filters | filters;
+
+        wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
+
+        if (filters & FIF_PROMISC_IN_BSS) {
+                wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
+                wl->rx_config &= ~CFG_UNI_FILTER_EN;
+                wl->rx_config |= CFG_BSSID_FILTER_EN;
+        }
+        if (filters & FIF_BCN_PRBRESP_PROMISC) {
+                wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
+                wl->rx_config &= ~CFG_BSSID_FILTER_EN;
+                wl->rx_config &= ~CFG_SSID_FILTER_EN;
+        }
+        if (filters & FIF_OTHER_BSS) {
+                wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
+                wl->rx_config &= ~CFG_BSSID_FILTER_EN;
+        }
+        if (filters & FIF_CONTROL) {
+                wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
+                wl->rx_filter |= CFG_RX_CTL_EN;
+        }
+        if (filters & FIF_FCSFAIL) {
+                wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
+                wl->rx_filter |= CFG_RX_FCS_ERROR;
+        }
+}
+
+static int wl1271_dummy_join(struct wl1271 *wl)
+{
+        int ret = 0;
+        /* we need to use a dummy BSSID for now */
+        static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
+                                                  0xad, 0xbe, 0xef };
+
+        memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
+
+        /* pass through frames from all BSS */
+        wl1271_configure_filters(wl, FIF_OTHER_BSS);
+
+        ret = wl1271_cmd_join(wl, wl->set_bss_type);
+        if (ret < 0)
+                goto out;
+
+        set_bit(WL1271_FLAG_JOINED, &wl->flags);
+
+out:
+        return ret;
+}
+
+static int wl1271_join(struct wl1271 *wl, bool set_assoc)
+{
+        int ret;
+
+        /*
+         * One of the side effects of the JOIN command is that is clears
+         * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
+         * to a WPA/WPA2 access point will therefore kill the data-path.
+         * Currently the only valid scenario for JOIN during association
+         * is on roaming, in which case we will also be given new keys.
+         * Keep the below message for now, unless it starts bothering
+         * users who really like to roam a lot :)
+         */
+        if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
+                wl1271_info("JOIN while associated.");
+
+        if (set_assoc)
+                set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
+
+        ret = wl1271_cmd_join(wl, wl->set_bss_type);
+        if (ret < 0)
+                goto out;
+
+        set_bit(WL1271_FLAG_JOINED, &wl->flags);
+
+        if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
+                goto out;
+
+        /*
+         * The join command disable the keep-alive mode, shut down its process,
+         * and also clear the template config, so we need to reset it all after
+         * the join. The acx_aid starts the keep-alive process, and the order
+         * of the commands below is relevant.
+         */
+        ret = wl1271_acx_keep_alive_mode(wl, true);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_acx_aid(wl, wl->aid);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_cmd_build_klv_null_data(wl);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
+                                           ACX_KEEP_ALIVE_TPL_VALID);
+        if (ret < 0)
+                goto out;
+
+out:
+        return ret;
+}
+
+static int wl1271_unjoin(struct wl1271 *wl)
+{
+        int ret;
+
+        /* to stop listening to a channel, we disconnect */
+        ret = wl1271_cmd_disconnect(wl);
+        if (ret < 0)
+                goto out;
+
+        clear_bit(WL1271_FLAG_JOINED, &wl->flags);
+        memset(wl->bssid, 0, ETH_ALEN);
+
+        /* stop filtering packets based on bssid */
+        wl1271_configure_filters(wl, FIF_OTHER_BSS);
+
+out:
+        return ret;
+}
+
+static void wl1271_set_band_rate(struct wl1271 *wl)
+{
+        if (wl->band == IEEE80211_BAND_2GHZ)
+                wl->basic_rate_set = wl->conf.tx.basic_rate;
+        else
+                wl->basic_rate_set = wl->conf.tx.basic_rate_5;
+}
+
+static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
+{
+        int ret;
+
+        if (idle) {
+                if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
+                        ret = wl1271_unjoin(wl);
+                        if (ret < 0)
+                                goto out;
+                }
+                wl->rate_set = wl1271_tx_min_rate_get(wl);
+                ret = wl1271_acx_sta_rate_policies(wl);
+                if (ret < 0)
+                        goto out;
+                ret = wl1271_acx_keep_alive_config(
+                        wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
+                        ACX_KEEP_ALIVE_TPL_INVALID);
+                if (ret < 0)
+                        goto out;
+                set_bit(WL1271_FLAG_IDLE, &wl->flags);
+        } else {
+                /* increment the session counter */
+                wl->session_counter++;
+                if (wl->session_counter >= SESSION_COUNTER_MAX)
+                        wl->session_counter = 0;
+
+                /* The current firmware only supports sched_scan in idle */
+                if (wl->sched_scanning) {
+                        wl1271_scan_sched_scan_stop(wl);
+                        ieee80211_sched_scan_stopped(wl->hw);
+                }
+
+                ret = wl1271_dummy_join(wl);
+                if (ret < 0)
+                        goto out;
+                clear_bit(WL1271_FLAG_IDLE, &wl->flags);
+        }
+
+out:
+        return ret;
+}
+
+static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
+{
+        struct wl1271 *wl = hw->priv;
+        struct ieee80211_conf *conf = &hw->conf;
+        int channel, ret = 0;
+        bool is_ap;
+
+        channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
+                     " changed 0x%x",
+                     channel,
+                     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
+                     conf->power_level,
+                     conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
+                         changed);
+
+        /*
+         * mac80211 will go to idle nearly immediately after transmitting some
+         * frames, such as the deauth. To make sure those frames reach the air,
+         * wait here until the TX queue is fully flushed.
+         */
+        if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
+            (conf->flags & IEEE80211_CONF_IDLE))
+                wl1271_tx_flush(wl);
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF)) {
+                /* we support configuring the channel and band while off */
+                if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
+                        wl->band = conf->channel->band;
+                        wl->channel = channel;
+                }
+
+                goto out;
+        }
+
+        is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        /* if the channel changes while joined, join again */
+        if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
+            ((wl->band != conf->channel->band) ||
+             (wl->channel != channel))) {
+                wl->band = conf->channel->band;
+                wl->channel = channel;
+
+                if (!is_ap) {
+                        /*
+                         * FIXME: the mac80211 should really provide a fixed
+                         * rate to use here. for now, just use the smallest
+                         * possible rate for the band as a fixed rate for
+                         * association frames and other control messages.
+                         */
+                        if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
+                                wl1271_set_band_rate(wl);
+
+                        wl->basic_rate = wl1271_tx_min_rate_get(wl);
+                        ret = wl1271_acx_sta_rate_policies(wl);
+                        if (ret < 0)
+                                wl1271_warning("rate policy for channel "
+                                               "failed %d", ret);
+
+                        if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
+                                ret = wl1271_join(wl, false);
+                                if (ret < 0)
+                                        wl1271_warning("cmd join on channel "
+                                                       "failed %d", ret);
+                        }
+                }
+        }
+
+        if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
+                ret = wl1271_sta_handle_idle(wl,
+                                        conf->flags & IEEE80211_CONF_IDLE);
+                if (ret < 0)
+                        wl1271_warning("idle mode change failed %d", ret);
+        }
+
+        /*
+         * if mac80211 changes the PSM mode, make sure the mode is not
+         * incorrectly changed after the pspoll failure active window.
+         */
+        if (changed & IEEE80211_CONF_CHANGE_PS)
+                clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
+
+        if (conf->flags & IEEE80211_CONF_PS &&
+            !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
+                set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
+
+                /*
+                 * We enter PSM only if we're already associated.
+                 * If we're not, we'll enter it when joining an SSID,
+                 * through the bss_info_changed() hook.
+                 */
+                if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
+                        wl1271_debug(DEBUG_PSM, "psm enabled");
+                        ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
+                                                 wl->basic_rate, true);
+                }
+        } else if (!(conf->flags & IEEE80211_CONF_PS) &&
+                   test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
+                wl1271_debug(DEBUG_PSM, "psm disabled");
+
+                clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
+
+                if (test_bit(WL1271_FLAG_PSM, &wl->flags))
+                        ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
+                                                 wl->basic_rate, true);
+        }
+
+        if (conf->power_level != wl->power_level) {
+                ret = wl1271_acx_tx_power(wl, conf->power_level);
+                if (ret < 0)
+                        goto out_sleep;
+
+                wl->power_level = conf->power_level;
+        }
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+struct wl1271_filter_params {
+        bool enabled;
+        int mc_list_length;
+        u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
+};
+
+static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
+                                       struct netdev_hw_addr_list *mc_list)
+{
+        struct wl1271_filter_params *fp;
+        struct netdev_hw_addr *ha;
+        struct wl1271 *wl = hw->priv;
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                return 0;
+
+        fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
+        if (!fp) {
+                wl1271_error("Out of memory setting filters.");
+                return 0;
+        }
+
+        /* update multicast filtering parameters */
+        fp->mc_list_length = 0;
+        if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
+                fp->enabled = false;
+        } else {
+                fp->enabled = true;
+                netdev_hw_addr_list_for_each(ha, mc_list) {
+                        memcpy(fp->mc_list[fp->mc_list_length],
+                                        ha->addr, ETH_ALEN);
+                        fp->mc_list_length++;
+                }
+        }
+
+        return (u64)(unsigned long)fp;
+}
+
+#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
+                                  FIF_ALLMULTI | \
+                                  FIF_FCSFAIL | \
+                                  FIF_BCN_PRBRESP_PROMISC | \
+                                  FIF_CONTROL | \
+                                  FIF_OTHER_BSS)
+
+static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
+                                       unsigned int changed,
+                                       unsigned int *total, u64 multicast)
+{
+        struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
+        struct wl1271 *wl = hw->priv;
+        int ret;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
+                     " total %x", changed, *total);
+
+        mutex_lock(&wl->mutex);
+
+        *total &= WL1271_SUPPORTED_FILTERS;
+        changed &= WL1271_SUPPORTED_FILTERS;
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        if (wl->bss_type != BSS_TYPE_AP_BSS) {
+                if (*total & FIF_ALLMULTI)
+                        ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
+                else if (fp)
+                        ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
+                                                           fp->mc_list,
+                                                           fp->mc_list_length);
+                if (ret < 0)
+                        goto out_sleep;
+        }
+
+        /* determine, whether supported filter values have changed */
+        if (changed == 0)
+                goto out_sleep;
+
+        /* configure filters */
+        wl->filters = *total;
+        wl1271_configure_filters(wl, 0);
+
+        /* apply configured filters */
+        ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
+        if (ret < 0)
+                goto out_sleep;
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+        kfree(fp);
+}
+
+static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
+                        u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
+                        u16 tx_seq_16)
+{
+        struct wl1271_ap_key *ap_key;
+        int i;
+
+        wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
+
+        if (key_size > MAX_KEY_SIZE)
+                return -EINVAL;
+
+        /*
+         * Find next free entry in ap_keys. Also check we are not replacing
+         * an existing key.
+         */
+        for (i = 0; i < MAX_NUM_KEYS; i++) {
+                if (wl->recorded_ap_keys[i] == NULL)
+                        break;
+
+                if (wl->recorded_ap_keys[i]->id == id) {
+                        wl1271_warning("trying to record key replacement");
+                        return -EINVAL;
+                }
+        }
+
+        if (i == MAX_NUM_KEYS)
+                return -EBUSY;
+
+        ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
+        if (!ap_key)
+                return -ENOMEM;
+
+        ap_key->id = id;
+        ap_key->key_type = key_type;
+        ap_key->key_size = key_size;
+        memcpy(ap_key->key, key, key_size);
+        ap_key->hlid = hlid;
+        ap_key->tx_seq_32 = tx_seq_32;
+        ap_key->tx_seq_16 = tx_seq_16;
+
+        wl->recorded_ap_keys[i] = ap_key;
+        return 0;
+}
+
+static void wl1271_free_ap_keys(struct wl1271 *wl)
+{
+        int i;
+
+        for (i = 0; i < MAX_NUM_KEYS; i++) {
+                kfree(wl->recorded_ap_keys[i]);
+                wl->recorded_ap_keys[i] = NULL;
+        }
+}
+
+static int wl1271_ap_init_hwenc(struct wl1271 *wl)
+{
+        int i, ret = 0;
+        struct wl1271_ap_key *key;
+        bool wep_key_added = false;
+
+        for (i = 0; i < MAX_NUM_KEYS; i++) {
+                if (wl->recorded_ap_keys[i] == NULL)
+                        break;
+
+                key = wl->recorded_ap_keys[i];
+                ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
+                                            key->id, key->key_type,
+                                            key->key_size, key->key,
+                                            key->hlid, key->tx_seq_32,
+                                            key->tx_seq_16);
+                if (ret < 0)
+                        goto out;
+
+                if (key->key_type == KEY_WEP)
+                        wep_key_added = true;
+        }
+
+        if (wep_key_added) {
+                ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
+                if (ret < 0)
+                        goto out;
+        }
+
+out:
+        wl1271_free_ap_keys(wl);
+        return ret;
+}
+
+static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
+                       u8 key_size, const u8 *key, u32 tx_seq_32,
+                       u16 tx_seq_16, struct ieee80211_sta *sta)
+{
+        int ret;
+        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+
+        if (is_ap) {
+                struct wl1271_station *wl_sta;
+                u8 hlid;
+
+                if (sta) {
+                        wl_sta = (struct wl1271_station *)sta->drv_priv;
+                        hlid = wl_sta->hlid;
+                } else {
+                        hlid = WL1271_AP_BROADCAST_HLID;
+                }
+
+                if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
+                        /*
+                         * We do not support removing keys after AP shutdown.
+                         * Pretend we do to make mac80211 happy.
+                         */
+                        if (action != KEY_ADD_OR_REPLACE)
+                                return 0;
+
+                        ret = wl1271_record_ap_key(wl, id,
+                                             key_type, key_size,
+                                             key, hlid, tx_seq_32,
+                                             tx_seq_16);
+                } else {
+                        ret = wl1271_cmd_set_ap_key(wl, action,
+                                             id, key_type, key_size,
+                                             key, hlid, tx_seq_32,
+                                             tx_seq_16);
+                }
+
+                if (ret < 0)
+                        return ret;
+        } else {
+                const u8 *addr;
+                static const u8 bcast_addr[ETH_ALEN] = {
+                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+                };
+
+                addr = sta ? sta->addr : bcast_addr;
+
+                if (is_zero_ether_addr(addr)) {
+                        /* We dont support TX only encryption */
+                        return -EOPNOTSUPP;
+                }
+
+                /* The wl1271 does not allow to remove unicast keys - they
+                   will be cleared automatically on next CMD_JOIN. Ignore the
+                   request silently, as we dont want the mac80211 to emit
+                   an error message. */
+                if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
+                        return 0;
+
+                ret = wl1271_cmd_set_sta_key(wl, action,
+                                             id, key_type, key_size,
+                                             key, addr, tx_seq_32,
+                                             tx_seq_16);
+                if (ret < 0)
+                        return ret;
+
+                /* the default WEP key needs to be configured at least once */
+                if (key_type == KEY_WEP) {
+                        ret = wl1271_cmd_set_sta_default_wep_key(wl,
+                                                        wl->default_key);
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+
+        return 0;
+}
+
+static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
+                             struct ieee80211_vif *vif,
+                             struct ieee80211_sta *sta,
+                             struct ieee80211_key_conf *key_conf)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret;
+        u32 tx_seq_32 = 0;
+        u16 tx_seq_16 = 0;
+        u8 key_type;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
+
+        wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
+        wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
+                     key_conf->cipher, key_conf->keyidx,
+                     key_conf->keylen, key_conf->flags);
+        wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF)) {
+                ret = -EAGAIN;
+                goto out_unlock;
+        }
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out_unlock;
+
+        switch (key_conf->cipher) {
+        case WLAN_CIPHER_SUITE_WEP40:
+        case WLAN_CIPHER_SUITE_WEP104:
+                key_type = KEY_WEP;
+
+                key_conf->hw_key_idx = key_conf->keyidx;
+                break;
+        case WLAN_CIPHER_SUITE_TKIP:
+                key_type = KEY_TKIP;
+
+                key_conf->hw_key_idx = key_conf->keyidx;
+                tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
+                tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
+                break;
+        case WLAN_CIPHER_SUITE_CCMP:
+                key_type = KEY_AES;
+
+                key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
+                tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
+                tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
+                break;
+        case WL1271_CIPHER_SUITE_GEM:
+                key_type = KEY_GEM;
+                tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
+                tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
+                break;
+        default:
+                wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
+
+                ret = -EOPNOTSUPP;
+                goto out_sleep;
+        }
+
+        switch (cmd) {
+        case SET_KEY:
+                ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
+                                 key_conf->keyidx, key_type,
+                                 key_conf->keylen, key_conf->key,
+                                 tx_seq_32, tx_seq_16, sta);
+                if (ret < 0) {
+                        wl1271_error("Could not add or replace key");
+                        goto out_sleep;
+                }
+                break;
+
+        case DISABLE_KEY:
+                ret = wl1271_set_key(wl, KEY_REMOVE,
+                                     key_conf->keyidx, key_type,
+                                     key_conf->keylen, key_conf->key,
+                                     0, 0, sta);
+                if (ret < 0) {
+                        wl1271_error("Could not remove key");
+                        goto out_sleep;
+                }
+                break;
+
+        default:
+                wl1271_error("Unsupported key cmd 0x%x", cmd);
+                ret = -EOPNOTSUPP;
+                break;
+        }
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+
+out_unlock:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
+                             struct ieee80211_vif *vif,
+                             struct cfg80211_scan_request *req)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret;
+        u8 *ssid = NULL;
+        size_t len = 0;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
+
+        if (req->n_ssids) {
+                ssid = req->ssids[0].ssid;
+                len = req->ssids[0].ssid_len;
+        }
+
+        mutex_lock(&wl->mutex);
+
+        if (wl->state == WL1271_STATE_OFF) {
+                /*
+                 * We cannot return -EBUSY here because cfg80211 will expect
+                 * a call to ieee80211_scan_completed if we do - in this case
+                 * there won't be any call.
+                 */
+                ret = -EAGAIN;
+                goto out;
+        }
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_scan(hw->priv, ssid, len, req);
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
+                                      struct ieee80211_vif *vif,
+                                      struct cfg80211_sched_scan_request *req,
+                                      struct ieee80211_sched_scan_ies *ies)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret;
+
+        wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
+
+        mutex_lock(&wl->mutex);
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_scan_sched_scan_config(wl, req, ies);
+        if (ret < 0)
+                goto out_sleep;
+
+        ret = wl1271_scan_sched_scan_start(wl);
+        if (ret < 0)
+                goto out_sleep;
+
+        wl->sched_scanning = true;
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+out:
+        mutex_unlock(&wl->mutex);
+        return ret;
+}
+
+static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
+                                      struct ieee80211_vif *vif)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret;
+
+        wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
+
+        mutex_lock(&wl->mutex);
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        wl1271_scan_sched_scan_stop(wl);
+
+        wl1271_ps_elp_sleep(wl);
+out:
+        mutex_unlock(&wl->mutex);
+}
+
+static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret = 0;
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF)) {
+                ret = -EAGAIN;
+                goto out;
+        }
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_acx_frag_threshold(wl, value);
+        if (ret < 0)
+                wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret = 0;
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF)) {
+                ret = -EAGAIN;
+                goto out;
+        }
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_acx_rts_threshold(wl, value);
+        if (ret < 0)
+                wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
+                            int offset)
+{
+        u8 ssid_len;
+        const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
+                                         skb->len - offset);
+
+        if (!ptr) {
+                wl1271_error("No SSID in IEs!");
+                return -ENOENT;
+        }
+
+        ssid_len = ptr[1];
+        if (ssid_len > IEEE80211_MAX_SSID_LEN) {
+                wl1271_error("SSID is too long!");
+                return -EINVAL;
+        }
+
+        wl->ssid_len = ssid_len;
+        memcpy(wl->ssid, ptr+2, ssid_len);
+        return 0;
+}
+
+static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
+                                       struct ieee80211_bss_conf *bss_conf,
+                                       u32 changed)
+{
+        int ret = 0;
+
+        if (changed & BSS_CHANGED_ERP_SLOT) {
+                if (bss_conf->use_short_slot)
+                        ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
+                else
+                        ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
+                if (ret < 0) {
+                        wl1271_warning("Set slot time failed %d", ret);
+                        goto out;
+                }
+        }
+
+        if (changed & BSS_CHANGED_ERP_PREAMBLE) {
+                if (bss_conf->use_short_preamble)
+                        wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
+                else
+                        wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
+        }
+
+        if (changed & BSS_CHANGED_ERP_CTS_PROT) {
+                if (bss_conf->use_cts_prot)
+                        ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
+                else
+                        ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
+                if (ret < 0) {
+                        wl1271_warning("Set ctsprotect failed %d", ret);
+                        goto out;
+                }
+        }
+
+out:
+        return ret;
+}
+
+static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
+                                          struct ieee80211_vif *vif,
+                                          struct ieee80211_bss_conf *bss_conf,
+                                          u32 changed)
+{
+        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+        int ret = 0;
+
+        if ((changed & BSS_CHANGED_BEACON_INT)) {
+                wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
+                        bss_conf->beacon_int);
+
+                wl->beacon_int = bss_conf->beacon_int;
+        }
+
+        if ((changed & BSS_CHANGED_BEACON)) {
+                struct ieee80211_hdr *hdr;
+                int ieoffset = offsetof(struct ieee80211_mgmt,
+                                        u.beacon.variable);
+                struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
+                u16 tmpl_id;
+
+                if (!beacon)
+                        goto out;
+
+                wl1271_debug(DEBUG_MASTER, "beacon updated");
+
+                ret = wl1271_ssid_set(wl, beacon, ieoffset);
+                if (ret < 0) {
+                        dev_kfree_skb(beacon);
+                        goto out;
+                }
+                tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
+                                  CMD_TEMPL_BEACON;
+                ret = wl1271_cmd_template_set(wl, tmpl_id,
+                                              beacon->data,
+                                              beacon->len, 0,
+                                              wl1271_tx_min_rate_get(wl));
+                if (ret < 0) {
+                        dev_kfree_skb(beacon);
+                        goto out;
+                }
+
+                hdr = (struct ieee80211_hdr *) beacon->data;
+                hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
+                                                 IEEE80211_STYPE_PROBE_RESP);
+
+                tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
+                                  CMD_TEMPL_PROBE_RESPONSE;
+                ret = wl1271_cmd_template_set(wl,
+                                              tmpl_id,
+                                              beacon->data,
+                                              beacon->len, 0,
+                                              wl1271_tx_min_rate_get(wl));
+                dev_kfree_skb(beacon);
+                if (ret < 0)
+                        goto out;
+        }
+
+out:
+        return ret;
+}
+
+/* AP mode changes */
+static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
+                                       struct ieee80211_vif *vif,
+                                       struct ieee80211_bss_conf *bss_conf,
+                                       u32 changed)
+{
+        int ret = 0;
+
+        if ((changed & BSS_CHANGED_BASIC_RATES)) {
+                u32 rates = bss_conf->basic_rates;
+
+                wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
+                wl->basic_rate = wl1271_tx_min_rate_get(wl);
+
+                ret = wl1271_init_ap_rates(wl);
+                if (ret < 0) {
+                        wl1271_error("AP rate policy change failed %d", ret);
+                        goto out;
+                }
+
+                ret = wl1271_ap_init_templates(wl);
+                if (ret < 0)
+                        goto out;
+        }
+
+        ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
+        if (ret < 0)
+                goto out;
+
+        if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
+                if (bss_conf->enable_beacon) {
+                        if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
+                                ret = wl1271_cmd_start_bss(wl);
+                                if (ret < 0)
+                                        goto out;
+
+                                set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
+                                wl1271_debug(DEBUG_AP, "started AP");
+
+                                ret = wl1271_ap_init_hwenc(wl);
+                                if (ret < 0)
+                                        goto out;
+                        }
+                } else {
+                        if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
+                                ret = wl1271_cmd_stop_bss(wl);
+                                if (ret < 0)
+                                        goto out;
+
+                                clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
+                                wl1271_debug(DEBUG_AP, "stopped AP");
+                        }
+                }
+        }
+
+        if (changed & BSS_CHANGED_IBSS) {
+                wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
+                             bss_conf->ibss_joined);
+
+                if (bss_conf->ibss_joined) {
+                        u32 rates = bss_conf->basic_rates;
+                        wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
+                                                                         rates);
+                        wl->basic_rate = wl1271_tx_min_rate_get(wl);
+
+                        /* by default, use 11b rates */
+                        wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
+                        ret = wl1271_acx_sta_rate_policies(wl);
+                        if (ret < 0)
+                                goto out;
+                }
+        }
+
+        ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
+        if (ret < 0)
+                goto out;
+out:
+        return;
+}
+
+/* STA/IBSS mode changes */
+static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
+                                        struct ieee80211_vif *vif,
+                                        struct ieee80211_bss_conf *bss_conf,
+                                        u32 changed)
+{
+        bool do_join = false, set_assoc = false;
+        bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
+        u32 sta_rate_set = 0;
+        int ret;
+        struct ieee80211_sta *sta;
+        bool sta_exists = false;
+        struct ieee80211_sta_ht_cap sta_ht_cap;
+
+        if (is_ibss) {
+                ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
+                                                     changed);
+                if (ret < 0)
+                        goto out;
+        }
+
+        if ((changed & BSS_CHANGED_BEACON_INT)  && is_ibss)
+                do_join = true;
+
+        /* Need to update the SSID (for filtering etc) */
+        if ((changed & BSS_CHANGED_BEACON) && is_ibss)
+                do_join = true;
+
+        if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
+                wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
+                             bss_conf->enable_beacon ? "enabled" : "disabled");
+
+                if (bss_conf->enable_beacon)
+                        wl->set_bss_type = BSS_TYPE_IBSS;
+                else
+                        wl->set_bss_type = BSS_TYPE_STA_BSS;
+                do_join = true;
+        }
+
+        if ((changed & BSS_CHANGED_CQM)) {
+                bool enable = false;
+                if (bss_conf->cqm_rssi_thold)
+                        enable = true;
+                ret = wl1271_acx_rssi_snr_trigger(wl, enable,
+                                                  bss_conf->cqm_rssi_thold,
+                                                  bss_conf->cqm_rssi_hyst);
+                if (ret < 0)
+                        goto out;
+                wl->rssi_thold = bss_conf->cqm_rssi_thold;
+        }
+
+        if ((changed & BSS_CHANGED_BSSID) &&
+            /*
+             * Now we know the correct bssid, so we send a new join command
+             * and enable the BSSID filter
+             */
+            memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
+                memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
+
+                if (!is_zero_ether_addr(wl->bssid)) {
+                        ret = wl1271_cmd_build_null_data(wl);
+                        if (ret < 0)
+                                goto out;
+
+                        ret = wl1271_build_qos_null_data(wl);
+                        if (ret < 0)
+                                goto out;
+
+                        /* filter out all packets not from this BSSID */
+                        wl1271_configure_filters(wl, 0);
+
+                        /* Need to update the BSSID (for filtering etc) */
+                        do_join = true;
+                }
+        }
+
+        rcu_read_lock();
+        sta = ieee80211_find_sta(vif, bss_conf->bssid);
+        if (sta)  {
+                /* save the supp_rates of the ap */
+                sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
+                if (sta->ht_cap.ht_supported)
+                        sta_rate_set |=
+                            (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
+                sta_ht_cap = sta->ht_cap;
+                sta_exists = true;
+        }
+        rcu_read_unlock();
+
+        if (sta_exists) {
+                /* handle new association with HT and HT information change */
+                if ((changed & BSS_CHANGED_HT) &&
+                    (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
+                        ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
+                                                             true);
+                        if (ret < 0) {
+                                wl1271_warning("Set ht cap true failed %d",
+                                               ret);
+                                goto out;
+                        }
+                        ret = wl1271_acx_set_ht_information(wl,
+                                                bss_conf->ht_operation_mode);
+                        if (ret < 0) {
+                                wl1271_warning("Set ht information failed %d",
+                                               ret);
+                                goto out;
+                        }
+                }
+                /* handle new association without HT and disassociation */
+                else if (changed & BSS_CHANGED_ASSOC) {
+                        ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
+                                                             false);
+                        if (ret < 0) {
+                                wl1271_warning("Set ht cap false failed %d",
+                                               ret);
+                                goto out;
+                        }
+                }
+        }
+
+        if ((changed & BSS_CHANGED_ASSOC)) {
+                if (bss_conf->assoc) {
+                        u32 rates;
+                        int ieoffset;
+                        wl->aid = bss_conf->aid;
+                        set_assoc = true;
+
+                        wl->ps_poll_failures = 0;
+
+                        /*
+                         * use basic rates from AP, and determine lowest rate
+                         * to use with control frames.
+                         */
+                        rates = bss_conf->basic_rates;
+                        wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
+                                                                         rates);
+                        wl->basic_rate = wl1271_tx_min_rate_get(wl);
+                        if (sta_rate_set)
+                                wl->rate_set = wl1271_tx_enabled_rates_get(wl,
+                                                                sta_rate_set);
+                        ret = wl1271_acx_sta_rate_policies(wl);
+                        if (ret < 0)
+                                goto out;
+
+                        /*
+                         * with wl1271, we don't need to update the
+                         * beacon_int and dtim_period, because the firmware
+                         * updates it by itself when the first beacon is
+                         * received after a join.
+                         */
+                        ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
+                        if (ret < 0)
+                                goto out;
+
+                        /*
+                         * Get a template for hardware connection maintenance
+                         */
+                        dev_kfree_skb(wl->probereq);
+                        wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
+                        ieoffset = offsetof(struct ieee80211_mgmt,
+                                            u.probe_req.variable);
+                        wl1271_ssid_set(wl, wl->probereq, ieoffset);
+
+                        /* enable the connection monitoring feature */
+                        ret = wl1271_acx_conn_monit_params(wl, true);
+                        if (ret < 0)
+                                goto out;
+
+                        /* If we want to go in PSM but we're not there yet */
+                        if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
+                            !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
+                                enum wl1271_cmd_ps_mode mode;
+
+                                mode = STATION_POWER_SAVE_MODE;
+                                ret = wl1271_ps_set_mode(wl, mode,
+                                                         wl->basic_rate,
+                                                         true);
+                                if (ret < 0)
+                                        goto out;
+                        }
+                } else {
+                        /* use defaults when not associated */
+                        bool was_assoc =
+                            !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
+                                                 &wl->flags);
+                        clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
+                        wl->aid = 0;
+
+                        /* free probe-request template */
+                        dev_kfree_skb(wl->probereq);
+                        wl->probereq = NULL;
+
+                        /* re-enable dynamic ps - just in case */
+                        ieee80211_enable_dyn_ps(wl->vif);
+
+                        /* revert back to minimum rates for the current band */
+                        wl1271_set_band_rate(wl);
+                        wl->basic_rate = wl1271_tx_min_rate_get(wl);
+                        ret = wl1271_acx_sta_rate_policies(wl);
+                        if (ret < 0)
+                                goto out;
+
+                        /* disable connection monitor features */
+                        ret = wl1271_acx_conn_monit_params(wl, false);
+
+                        /* Disable the keep-alive feature */
+                        ret = wl1271_acx_keep_alive_mode(wl, false);
+                        if (ret < 0)
+                                goto out;
+
+                        /* restore the bssid filter and go to dummy bssid */
+                        if (was_assoc) {
+                                wl1271_unjoin(wl);
+                                wl1271_dummy_join(wl);
+                        }
+                }
+        }
+
+        ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
+        if (ret < 0)
+                goto out;
+
+        if (changed & BSS_CHANGED_ARP_FILTER) {
+                __be32 addr = bss_conf->arp_addr_list[0];
+                WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
+
+                if (bss_conf->arp_addr_cnt == 1 &&
+                    bss_conf->arp_filter_enabled) {
+                        /*
+                         * The template should have been configured only upon
+                         * association. however, it seems that the correct ip
+                         * isn't being set (when sending), so we have to
+                         * reconfigure the template upon every ip change.
+                         */
+                        ret = wl1271_cmd_build_arp_rsp(wl, addr);
+                        if (ret < 0) {
+                                wl1271_warning("build arp rsp failed: %d", ret);
+                                goto out;
+                        }
+
+                        ret = wl1271_acx_arp_ip_filter(wl,
+                                ACX_ARP_FILTER_ARP_FILTERING,
+                                addr);
+                } else
+                        ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
+
+                if (ret < 0)
+                        goto out;
+        }
+
+        if (do_join) {
+                ret = wl1271_join(wl, set_assoc);
+                if (ret < 0) {
+                        wl1271_warning("cmd join failed %d", ret);
+                        goto out;
+                }
+        }
+
+out:
+        return;
+}
+
+static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
+                                       struct ieee80211_vif *vif,
+                                       struct ieee80211_bss_conf *bss_conf,
+                                       u32 changed)
+{
+        struct wl1271 *wl = hw->priv;
+        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+        int ret;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
+                     (int)changed);
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        if (is_ap)
+                wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
+        else
+                wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+}
+
+static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
+                             const struct ieee80211_tx_queue_params *params)
+{
+        struct wl1271 *wl = hw->priv;
+        u8 ps_scheme;
+        int ret = 0;
+
+        mutex_lock(&wl->mutex);
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
+
+        if (params->uapsd)
+                ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
+        else
+                ps_scheme = CONF_PS_SCHEME_LEGACY;
+
+        if (wl->state == WL1271_STATE_OFF) {
+                /*
+                 * If the state is off, the parameters will be recorded and
+                 * configured on init. This happens in AP-mode.
+                 */
+                struct conf_tx_ac_category *conf_ac =
+                        &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
+                struct conf_tx_tid *conf_tid =
+                        &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
+
+                conf_ac->ac = wl1271_tx_get_queue(queue);
+                conf_ac->cw_min = (u8)params->cw_min;
+                conf_ac->cw_max = params->cw_max;
+                conf_ac->aifsn = params->aifs;
+                conf_ac->tx_op_limit = params->txop << 5;
+
+                conf_tid->queue_id = wl1271_tx_get_queue(queue);
+                conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
+                conf_tid->tsid = wl1271_tx_get_queue(queue);
+                conf_tid->ps_scheme = ps_scheme;
+                conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
+                conf_tid->apsd_conf[0] = 0;
+                conf_tid->apsd_conf[1] = 0;
+                goto out;
+        }
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        /*
+         * the txop is confed in units of 32us by the mac80211,
+         * we need us
+         */
+        ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
+                                params->cw_min, params->cw_max,
+                                params->aifs, params->txop << 5);
+        if (ret < 0)
+                goto out_sleep;
+
+        ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
+                                 CONF_CHANNEL_TYPE_EDCF,
+                                 wl1271_tx_get_queue(queue),
+                                 ps_scheme, CONF_ACK_POLICY_LEGACY,
+                                 0, 0);
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
+{
+
+        struct wl1271 *wl = hw->priv;
+        u64 mactime = ULLONG_MAX;
+        int ret;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_acx_tsf_info(wl, &mactime);
+        if (ret < 0)
+                goto out_sleep;
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+        return mactime;
+}
+
+static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
+                                struct survey_info *survey)
+{
+        struct wl1271 *wl = hw->priv;
+        struct ieee80211_conf *conf = &hw->conf;
+
+        if (idx != 0)
+                return -ENOENT;
+
+        survey->channel = conf->channel;
+        survey->filled = SURVEY_INFO_NOISE_DBM;
+        survey->noise = wl->noise;
+
+        return 0;
+}
+
+static int wl1271_allocate_sta(struct wl1271 *wl,
+                             struct ieee80211_sta *sta,
+                             u8 *hlid)
+{
+        struct wl1271_station *wl_sta;
+        int id;
+
+        id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
+        if (id >= AP_MAX_STATIONS) {
+                wl1271_warning("could not allocate HLID - too much stations");
+                return -EBUSY;
+        }
+
+        wl_sta = (struct wl1271_station *)sta->drv_priv;
+        __set_bit(id, wl->ap_hlid_map);
+        wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
+        *hlid = wl_sta->hlid;
+        memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
+        return 0;
+}
+
+static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
+{
+        int id = hlid - WL1271_AP_STA_HLID_START;
+
+        if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
+                return;
+
+        __clear_bit(id, wl->ap_hlid_map);
+        memset(wl->links[hlid].addr, 0, ETH_ALEN);
+        wl1271_tx_reset_link_queues(wl, hlid);
+        __clear_bit(hlid, &wl->ap_ps_map);
+        __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
+}
+
+static int wl1271_op_sta_add(struct ieee80211_hw *hw,
+                             struct ieee80211_vif *vif,
+                             struct ieee80211_sta *sta)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret = 0;
+        u8 hlid;
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        if (wl->bss_type != BSS_TYPE_AP_BSS)
+                goto out;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
+
+        ret = wl1271_allocate_sta(wl, sta, &hlid);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out_free_sta;
+
+        ret = wl1271_cmd_add_sta(wl, sta, hlid);
+        if (ret < 0)
+                goto out_sleep;
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+
+out_free_sta:
+        if (ret < 0)
+                wl1271_free_sta(wl, hlid);
+
+out:
+        mutex_unlock(&wl->mutex);
+        return ret;
+}
+
+static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
+                                struct ieee80211_vif *vif,
+                                struct ieee80211_sta *sta)
+{
+        struct wl1271 *wl = hw->priv;
+        struct wl1271_station *wl_sta;
+        int ret = 0, id;
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        if (wl->bss_type != BSS_TYPE_AP_BSS)
+                goto out;
+
+        wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
+
+        wl_sta = (struct wl1271_station *)sta->drv_priv;
+        id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
+        if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
+        if (ret < 0)
+                goto out_sleep;
+
+        wl1271_free_sta(wl, wl_sta->hlid);
+
+out_sleep:
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+        return ret;
+}
+
+static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
+                                  struct ieee80211_vif *vif,
+                                  enum ieee80211_ampdu_mlme_action action,
+                                  struct ieee80211_sta *sta, u16 tid, u16 *ssn,
+                                  u8 buf_size)
+{
+        struct wl1271 *wl = hw->priv;
+        int ret;
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF)) {
+                ret = -EAGAIN;
+                goto out;
+        }
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        switch (action) {
+        case IEEE80211_AMPDU_RX_START:
+                if (wl->ba_support) {
+                        ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
+                                                                 true);
+                        if (!ret)
+                                wl->ba_rx_bitmap |= BIT(tid);
+                } else {
+                        ret = -ENOTSUPP;
+                }
+                break;
+
+        case IEEE80211_AMPDU_RX_STOP:
+                ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
+                if (!ret)
+                        wl->ba_rx_bitmap &= ~BIT(tid);
+                break;
+
+        /*
+         * The BA initiator session management in FW independently.
+         * Falling break here on purpose for all TX APDU commands.
+         */
+        case IEEE80211_AMPDU_TX_START:
+        case IEEE80211_AMPDU_TX_STOP:
+        case IEEE80211_AMPDU_TX_OPERATIONAL:
+                ret = -EINVAL;
+                break;
+
+        default:
+                wl1271_error("Incorrect ampdu action id=%x\n", action);
+                ret = -EINVAL;
+        }
+
+        wl1271_ps_elp_sleep(wl);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
+{
+        struct wl1271 *wl = hw->priv;
+        bool ret = false;
+
+        mutex_lock(&wl->mutex);
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        /* packets are considered pending if in the TX queue or the FW */
+        ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);
+
+        /* the above is appropriate for STA mode for PS purposes */
+        WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
+
+out:
+        mutex_unlock(&wl->mutex);
+
+        return ret;
+}
+
+/* can't be const, mac80211 writes to this */
+static struct ieee80211_rate wl1271_rates[] = {
+        { .bitrate = 10,
+          .hw_value = CONF_HW_BIT_RATE_1MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
+        { .bitrate = 20,
+          .hw_value = CONF_HW_BIT_RATE_2MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
+          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
+        { .bitrate = 55,
+          .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
+          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
+        { .bitrate = 110,
+          .hw_value = CONF_HW_BIT_RATE_11MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
+          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
+        { .bitrate = 60,
+          .hw_value = CONF_HW_BIT_RATE_6MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
+        { .bitrate = 90,
+          .hw_value = CONF_HW_BIT_RATE_9MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
+        { .bitrate = 120,
+          .hw_value = CONF_HW_BIT_RATE_12MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
+        { .bitrate = 180,
+          .hw_value = CONF_HW_BIT_RATE_18MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
+        { .bitrate = 240,
+          .hw_value = CONF_HW_BIT_RATE_24MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
+        { .bitrate = 360,
+         .hw_value = CONF_HW_BIT_RATE_36MBPS,
+         .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
+        { .bitrate = 480,
+          .hw_value = CONF_HW_BIT_RATE_48MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
+        { .bitrate = 540,
+          .hw_value = CONF_HW_BIT_RATE_54MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
+};
+
+/* can't be const, mac80211 writes to this */
+static struct ieee80211_channel wl1271_channels[] = {
+        { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
+        { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
+        { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
+        { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
+        { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
+        { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
+        { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
+        { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
+        { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
+        { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
+        { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
+        { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
+        { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
+        { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
+};
+
+/* mapping to indexes for wl1271_rates */
+static const u8 wl1271_rate_to_idx_2ghz[] = {
+        /* MCS rates are used only with 11n */
+        7,                            /* CONF_HW_RXTX_RATE_MCS7 */
+        6,                            /* CONF_HW_RXTX_RATE_MCS6 */
+        5,                            /* CONF_HW_RXTX_RATE_MCS5 */
+        4,                            /* CONF_HW_RXTX_RATE_MCS4 */
+        3,                            /* CONF_HW_RXTX_RATE_MCS3 */
+        2,                            /* CONF_HW_RXTX_RATE_MCS2 */
+        1,                            /* CONF_HW_RXTX_RATE_MCS1 */
+        0,                            /* CONF_HW_RXTX_RATE_MCS0 */
+
+        11,                            /* CONF_HW_RXTX_RATE_54   */
+        10,                            /* CONF_HW_RXTX_RATE_48   */
+        9,                             /* CONF_HW_RXTX_RATE_36   */
+        8,                             /* CONF_HW_RXTX_RATE_24   */
+
+        /* TI-specific rate */
+        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
+
+        7,                             /* CONF_HW_RXTX_RATE_18   */
+        6,                             /* CONF_HW_RXTX_RATE_12   */
+        3,                             /* CONF_HW_RXTX_RATE_11   */
+        5,                             /* CONF_HW_RXTX_RATE_9    */
+        4,                             /* CONF_HW_RXTX_RATE_6    */
+        2,                             /* CONF_HW_RXTX_RATE_5_5  */
+        1,                             /* CONF_HW_RXTX_RATE_2    */
+        0                              /* CONF_HW_RXTX_RATE_1    */
+};
+
+/* 11n STA capabilities */
+#define HW_RX_HIGHEST_RATE      72
+
+#ifdef CONFIG_WL12XX_HT
+#define WL12XX_HT_CAP { \
+        .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
+               (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
+        .ht_supported = true, \
+        .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
+        .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
+        .mcs = { \
+                .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
+                .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
+                .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
+                }, \
+}
+#else
+#define WL12XX_HT_CAP { \
+        .ht_supported = false, \
+}
+#endif
+
+/* can't be const, mac80211 writes to this */
+static struct ieee80211_supported_band wl1271_band_2ghz = {
+        .channels = wl1271_channels,
+        .n_channels = ARRAY_SIZE(wl1271_channels),
+        .bitrates = wl1271_rates,
+        .n_bitrates = ARRAY_SIZE(wl1271_rates),
+        .ht_cap = WL12XX_HT_CAP,
+};
+
+/* 5 GHz data rates for WL1273 */
+static struct ieee80211_rate wl1271_rates_5ghz[] = {
+        { .bitrate = 60,
+          .hw_value = CONF_HW_BIT_RATE_6MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
+        { .bitrate = 90,
+          .hw_value = CONF_HW_BIT_RATE_9MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
+        { .bitrate = 120,
+          .hw_value = CONF_HW_BIT_RATE_12MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
+        { .bitrate = 180,
+          .hw_value = CONF_HW_BIT_RATE_18MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
+        { .bitrate = 240,
+          .hw_value = CONF_HW_BIT_RATE_24MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
+        { .bitrate = 360,
+         .hw_value = CONF_HW_BIT_RATE_36MBPS,
+         .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
+        { .bitrate = 480,
+          .hw_value = CONF_HW_BIT_RATE_48MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
+        { .bitrate = 540,
+          .hw_value = CONF_HW_BIT_RATE_54MBPS,
+          .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
+};
+
+/* 5 GHz band channels for WL1273 */
+static struct ieee80211_channel wl1271_channels_5ghz[] = {
+        { .hw_value = 7, .center_freq = 5035},
+        { .hw_value = 8, .center_freq = 5040},
+        { .hw_value = 9, .center_freq = 5045},
+        { .hw_value = 11, .center_freq = 5055},
+        { .hw_value = 12, .center_freq = 5060},
+        { .hw_value = 16, .center_freq = 5080},
+        { .hw_value = 34, .center_freq = 5170},
+        { .hw_value = 36, .center_freq = 5180},
+        { .hw_value = 38, .center_freq = 5190},
+        { .hw_value = 40, .center_freq = 5200},
+        { .hw_value = 42, .center_freq = 5210},
+        { .hw_value = 44, .center_freq = 5220},
+        { .hw_value = 46, .center_freq = 5230},
+        { .hw_value = 48, .center_freq = 5240},
+        { .hw_value = 52, .center_freq = 5260},
+        { .hw_value = 56, .center_freq = 5280},
+        { .hw_value = 60, .center_freq = 5300},
+        { .hw_value = 64, .center_freq = 5320},
+        { .hw_value = 100, .center_freq = 5500},
+        { .hw_value = 104, .center_freq = 5520},
+        { .hw_value = 108, .center_freq = 5540},
+        { .hw_value = 112, .center_freq = 5560},
+        { .hw_value = 116, .center_freq = 5580},
+        { .hw_value = 120, .center_freq = 5600},
+        { .hw_value = 124, .center_freq = 5620},
+        { .hw_value = 128, .center_freq = 5640},
+        { .hw_value = 132, .center_freq = 5660},
+        { .hw_value = 136, .center_freq = 5680},
+        { .hw_value = 140, .center_freq = 5700},
+        { .hw_value = 149, .center_freq = 5745},
+        { .hw_value = 153, .center_freq = 5765},
+        { .hw_value = 157, .center_freq = 5785},
+        { .hw_value = 161, .center_freq = 5805},
+        { .hw_value = 165, .center_freq = 5825},
+};
+
+/* mapping to indexes for wl1271_rates_5ghz */
+static const u8 wl1271_rate_to_idx_5ghz[] = {
+        /* MCS rates are used only with 11n */
+        7,                            /* CONF_HW_RXTX_RATE_MCS7 */
+        6,                            /* CONF_HW_RXTX_RATE_MCS6 */
+        5,                            /* CONF_HW_RXTX_RATE_MCS5 */
+        4,                            /* CONF_HW_RXTX_RATE_MCS4 */
+        3,                            /* CONF_HW_RXTX_RATE_MCS3 */
+        2,                            /* CONF_HW_RXTX_RATE_MCS2 */
+        1,                            /* CONF_HW_RXTX_RATE_MCS1 */
+        0,                            /* CONF_HW_RXTX_RATE_MCS0 */
+
+        7,                             /* CONF_HW_RXTX_RATE_54   */
+        6,                             /* CONF_HW_RXTX_RATE_48   */
+        5,                             /* CONF_HW_RXTX_RATE_36   */
+        4,                             /* CONF_HW_RXTX_RATE_24   */
+
+        /* TI-specific rate */
+        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
+
+        3,                             /* CONF_HW_RXTX_RATE_18   */
+        2,                             /* CONF_HW_RXTX_RATE_12   */
+        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
+        1,                             /* CONF_HW_RXTX_RATE_9    */
+        0,                             /* CONF_HW_RXTX_RATE_6    */
+        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
+        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
+        CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
+};
+
+static struct ieee80211_supported_band wl1271_band_5ghz = {
+        .channels = wl1271_channels_5ghz,
+        .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
+        .bitrates = wl1271_rates_5ghz,
+        .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
+        .ht_cap = WL12XX_HT_CAP,
+};
+
+static const u8 *wl1271_band_rate_to_idx[] = {
+        [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
+        [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
+};
+
+static const struct ieee80211_ops wl1271_ops = {
+        .start = wl1271_op_start,
+        .stop = wl1271_op_stop,
+        .add_interface = wl1271_op_add_interface,
+        .remove_interface = wl1271_op_remove_interface,
+#ifdef CONFIG_PM
+        .suspend = wl1271_op_suspend,
+        .resume = wl1271_op_resume,
+#endif
+        .config = wl1271_op_config,
+        .prepare_multicast = wl1271_op_prepare_multicast,
+        .configure_filter = wl1271_op_configure_filter,
+        .tx = wl1271_op_tx,
+        .set_key = wl1271_op_set_key,
+        .hw_scan = wl1271_op_hw_scan,
+        .sched_scan_start = wl1271_op_sched_scan_start,
+        .sched_scan_stop = wl1271_op_sched_scan_stop,
+        .bss_info_changed = wl1271_op_bss_info_changed,
+        .set_frag_threshold = wl1271_op_set_frag_threshold,
+        .set_rts_threshold = wl1271_op_set_rts_threshold,
+        .conf_tx = wl1271_op_conf_tx,
+        .get_tsf = wl1271_op_get_tsf,
+        .get_survey = wl1271_op_get_survey,
+        .sta_add = wl1271_op_sta_add,
+        .sta_remove = wl1271_op_sta_remove,
+        .ampdu_action = wl1271_op_ampdu_action,
+        .tx_frames_pending = wl1271_tx_frames_pending,
+        CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
+};
+
+
+u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
+{
+        u8 idx;
+
+        BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
+
+        if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
+                wl1271_error("Illegal RX rate from HW: %d", rate);
+                return 0;
+        }
+
+        idx = wl1271_band_rate_to_idx[band][rate];
+        if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
+                wl1271_error("Unsupported RX rate from HW: %d", rate);
+                return 0;
+        }
+
+        return idx;
+}
+
+static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
+                                               struct device_attribute *attr,
+                                               char *buf)
+{
+        struct wl1271 *wl = dev_get_drvdata(dev);
+        ssize_t len;
+
+        len = PAGE_SIZE;
+
+        mutex_lock(&wl->mutex);
+        len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
+                       wl->sg_enabled);
+        mutex_unlock(&wl->mutex);
+
+        return len;
+
+}
+
+static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        struct wl1271 *wl = dev_get_drvdata(dev);
+        unsigned long res;
+        int ret;
+
+        ret = kstrtoul(buf, 10, &res);
+        if (ret < 0) {
+                wl1271_warning("incorrect value written to bt_coex_mode");
+                return count;
+        }
+
+        mutex_lock(&wl->mutex);
+
+        res = !!res;
+
+        if (res == wl->sg_enabled)
+                goto out;
+
+        wl->sg_enabled = res;
+
+        if (wl->state == WL1271_STATE_OFF)
+                goto out;
+
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        wl1271_acx_sg_enable(wl, wl->sg_enabled);
+        wl1271_ps_elp_sleep(wl);
+
+ out:
+        mutex_unlock(&wl->mutex);
+        return count;
+}
+
+static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
+                   wl1271_sysfs_show_bt_coex_state,
+                   wl1271_sysfs_store_bt_coex_state);
+
+static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct wl1271 *wl = dev_get_drvdata(dev);
+        ssize_t len;
+
+        len = PAGE_SIZE;
+
+        mutex_lock(&wl->mutex);
+        if (wl->hw_pg_ver >= 0)
+                len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
+        else
+                len = snprintf(buf, len, "n/a\n");
+        mutex_unlock(&wl->mutex);
+
+        return len;
+}
+
+static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
+                   wl1271_sysfs_show_hw_pg_ver, NULL);
+
+int wl1271_register_hw(struct wl1271 *wl)
+{
+        int ret;
+
+        if (wl->mac80211_registered)
+                return 0;
+
+        ret = wl1271_fetch_nvs(wl);
+        if (ret == 0) {
+                /* NOTE: The wl->nvs->nvs element must be first, in
+                 * order to simplify the casting, we assume it is at
+                 * the beginning of the wl->nvs structure.
+                 */
+                u8 *nvs_ptr = (u8 *)wl->nvs;
+
+                wl->mac_addr[0] = nvs_ptr[11];
+                wl->mac_addr[1] = nvs_ptr[10];
+                wl->mac_addr[2] = nvs_ptr[6];
+                wl->mac_addr[3] = nvs_ptr[5];
+                wl->mac_addr[4] = nvs_ptr[4];
+                wl->mac_addr[5] = nvs_ptr[3];
+        }
+
+        SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
+
+        ret = ieee80211_register_hw(wl->hw);
+        if (ret < 0) {
+                wl1271_error("unable to register mac80211 hw: %d", ret);
+                return ret;
+        }
+
+        wl->mac80211_registered = true;
+
+        wl1271_debugfs_init(wl);
+
+        register_netdevice_notifier(&wl1271_dev_notifier);
+
+        wl1271_notice("loaded");
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(wl1271_register_hw);
+
+void wl1271_unregister_hw(struct wl1271 *wl)
+{
+        if (wl->state == WL1271_STATE_PLT)
+                __wl1271_plt_stop(wl);
+
+        unregister_netdevice_notifier(&wl1271_dev_notifier);
+        ieee80211_unregister_hw(wl->hw);
+        wl->mac80211_registered = false;
+
+}
+EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
+
+int wl1271_init_ieee80211(struct wl1271 *wl)
+{
+        static const u32 cipher_suites[] = {
+                WLAN_CIPHER_SUITE_WEP40,
+                WLAN_CIPHER_SUITE_WEP104,
+                WLAN_CIPHER_SUITE_TKIP,
+                WLAN_CIPHER_SUITE_CCMP,
+                WL1271_CIPHER_SUITE_GEM,
+        };
+
+        /* The tx descriptor buffer and the TKIP space. */
+        wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
+                sizeof(struct wl1271_tx_hw_descr);
+
+        /* unit us */
+        /* FIXME: find a proper value */
+        wl->hw->channel_change_time = 10000;
+        wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
+
+        wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
+                IEEE80211_HW_BEACON_FILTER |
+                IEEE80211_HW_SUPPORTS_PS |
+                IEEE80211_HW_SUPPORTS_UAPSD |
+                IEEE80211_HW_HAS_RATE_CONTROL |
+                IEEE80211_HW_CONNECTION_MONITOR |
+                IEEE80211_HW_SUPPORTS_CQM_RSSI |
+                IEEE80211_HW_REPORTS_TX_ACK_STATUS |
+                IEEE80211_HW_SPECTRUM_MGMT |
+                IEEE80211_HW_AP_LINK_PS;
+
+        wl->hw->wiphy->cipher_suites = cipher_suites;
+        wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
+
+        wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
+                BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
+        wl->hw->wiphy->max_scan_ssids = 1;
+        /*
+         * Maximum length of elements in scanning probe request templates
+         * should be the maximum length possible for a template, without
+         * the IEEE80211 header of the template
+         */
+        wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
+                        sizeof(struct ieee80211_header);
+
+        /* make sure all our channels fit in the scanned_ch bitmask */
+        BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
+                     ARRAY_SIZE(wl1271_channels_5ghz) >
+                     WL1271_MAX_CHANNELS);
+        /*
+         * We keep local copies of the band structs because we need to
+         * modify them on a per-device basis.
+         */
+        memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
+               sizeof(wl1271_band_2ghz));
+        memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
+               sizeof(wl1271_band_5ghz));
+
+        wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
+                &wl->bands[IEEE80211_BAND_2GHZ];
+        wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
+                &wl->bands[IEEE80211_BAND_5GHZ];
+
+        wl->hw->queues = 4;
+        wl->hw->max_rates = 1;
+
+        wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
+
+        SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
+
+        wl->hw->sta_data_size = sizeof(struct wl1271_station);
+
+        wl->hw->max_rx_aggregation_subframes = 8;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
+
+#define WL1271_DEFAULT_CHANNEL 0
+
+struct ieee80211_hw *wl1271_alloc_hw(void)
+{
+        struct ieee80211_hw *hw;
+        struct platform_device *plat_dev = NULL;
+        struct wl1271 *wl;
+        int i, j, ret;
+        unsigned int order;
+
+        hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
+        if (!hw) {
+                wl1271_error("could not alloc ieee80211_hw");
+                ret = -ENOMEM;
+                goto err_hw_alloc;
+        }
+
+        plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
+        if (!plat_dev) {
+                wl1271_error("could not allocate platform_device");
+                ret = -ENOMEM;
+                goto err_plat_alloc;
+        }
+
+        wl = hw->priv;
+        memset(wl, 0, sizeof(*wl));
+
+        INIT_LIST_HEAD(&wl->list);
+
+        wl->hw = hw;
+        wl->plat_dev = plat_dev;
+
+        for (i = 0; i < NUM_TX_QUEUES; i++)
+                skb_queue_head_init(&wl->tx_queue[i]);
+
+        for (i = 0; i < NUM_TX_QUEUES; i++)
+                for (j = 0; j < AP_MAX_LINKS; j++)
+                        skb_queue_head_init(&wl->links[j].tx_queue[i]);
+
+        skb_queue_head_init(&wl->deferred_rx_queue);
+        skb_queue_head_init(&wl->deferred_tx_queue);
+
+        INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
+        INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
+        INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
+        INIT_WORK(&wl->tx_work, wl1271_tx_work);
+        INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
+        INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
+        wl->channel = WL1271_DEFAULT_CHANNEL;
+        wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
+        wl->default_key = 0;
+        wl->rx_counter = 0;
+        wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
+        wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
+        wl->psm_entry_retry = 0;
+        wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
+        wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
+        wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
+        wl->rate_set = CONF_TX_RATE_MASK_BASIC;
+        wl->band = IEEE80211_BAND_2GHZ;
+        wl->vif = NULL;
+        wl->flags = 0;
+        wl->sg_enabled = true;
+        wl->hw_pg_ver = -1;
+        wl->bss_type = MAX_BSS_TYPE;
+        wl->set_bss_type = MAX_BSS_TYPE;
+        wl->fw_bss_type = MAX_BSS_TYPE;
+        wl->last_tx_hlid = 0;
+        wl->ap_ps_map = 0;
+        wl->ap_fw_ps_map = 0;
+        wl->quirks = 0;
+        wl->platform_quirks = 0;
+        wl->sched_scanning = false;
+
+        memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
+        for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
+                wl->tx_frames[i] = NULL;
+
+        spin_lock_init(&wl->wl_lock);
+
+        wl->state = WL1271_STATE_OFF;
+        mutex_init(&wl->mutex);
+
+        /* Apply default driver configuration. */
+        wl1271_conf_init(wl);
+
+        order = get_order(WL1271_AGGR_BUFFER_SIZE);
+        wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
+        if (!wl->aggr_buf) {
+                ret = -ENOMEM;
+                goto err_hw;
+        }
+
+        wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
+        if (!wl->dummy_packet) {
+                ret = -ENOMEM;
+                goto err_aggr;
+        }
+
+        /* Register platform device */
+        ret = platform_device_register(wl->plat_dev);
+        if (ret) {
+                wl1271_error("couldn't register platform device");
+                goto err_dummy_packet;
+        }
+        dev_set_drvdata(&wl->plat_dev->dev, wl);
+
+        /* Create sysfs file to control bt coex state */
+        ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
+        if (ret < 0) {
+                wl1271_error("failed to create sysfs file bt_coex_state");
+                goto err_platform;
+        }
+
+        /* Create sysfs file to get HW PG version */
+        ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
+        if (ret < 0) {
+                wl1271_error("failed to create sysfs file hw_pg_ver");
+                goto err_bt_coex_state;
+        }
+
+        return hw;
+
+err_bt_coex_state:
+        device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
+
+err_platform:
+        platform_device_unregister(wl->plat_dev);
+
+err_dummy_packet:
+        dev_kfree_skb(wl->dummy_packet);
+
+err_aggr:
+        free_pages((unsigned long)wl->aggr_buf, order);
+
+err_hw:
+        wl1271_debugfs_exit(wl);
+        kfree(plat_dev);
+
+err_plat_alloc:
+        ieee80211_free_hw(hw);
+
+err_hw_alloc:
+
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
+
+int wl1271_free_hw(struct wl1271 *wl)
+{
+        platform_device_unregister(wl->plat_dev);
+        dev_kfree_skb(wl->dummy_packet);
+        free_pages((unsigned long)wl->aggr_buf,
+                        get_order(WL1271_AGGR_BUFFER_SIZE));
+        kfree(wl->plat_dev);
+
+        wl1271_debugfs_exit(wl);
+
+        vfree(wl->fw);
+        wl->fw = NULL;
+        kfree(wl->nvs);
+        wl->nvs = NULL;
+
+        kfree(wl->fw_status);
+        kfree(wl->tx_res_if);
+
+        ieee80211_free_hw(wl->hw);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(wl1271_free_hw);
+
+u32 wl12xx_debug_level = DEBUG_NONE;
+EXPORT_SYMBOL_GPL(wl12xx_debug_level);
+module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
+MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
+MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
diff --git a/drivers/net/wireless/wl12xx/wl1271_ps.c b/drivers/net/wireless/wl12xx/ps.c
index a5e60e0403e5..b59b67711a17 100644
--- a/drivers/net/wireless/wl12xx/wl1271_ps.c
+++ b/drivers/net/wireless/wl12xx/ps.c
@@ -21,9 +21,10 @@
  *
  */
 
-#include "wl1271_reg.h"
-#include "wl1271_ps.h"
-#include "wl1271_io.h"
+#include "reg.h"
+#include "ps.h"
+#include "io.h"
+#include "tx.h"
 
 #define WL1271_WAKEUP_TIMEOUT 500
 
@@ -39,6 +40,13 @@ void wl1271_elp_work(struct work_struct *work)
 
         mutex_lock(&wl->mutex);
 
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                goto out;
+
+        /* our work might have been already cancelled */
+        if (unlikely(!test_bit(WL1271_FLAG_ELP_REQUESTED, &wl->flags)))
+                goto out;
+
         if (test_bit(WL1271_FLAG_IN_ELP, &wl->flags) ||
             (!test_bit(WL1271_FLAG_PSM, &wl->flags) &&
              !test_bit(WL1271_FLAG_IDLE, &wl->flags)))
@@ -57,15 +65,19 @@ out:
 /* Routines to toggle sleep mode while in ELP */
 void wl1271_ps_elp_sleep(struct wl1271 *wl)
 {
-        if (test_bit(WL1271_FLAG_PSM, &wl->flags) ||
-            test_bit(WL1271_FLAG_IDLE, &wl->flags)) {
-                cancel_delayed_work(&wl->elp_work);
-                ieee80211_queue_delayed_work(wl->hw, &wl->elp_work,
-                                        msecs_to_jiffies(ELP_ENTRY_DELAY));
-        }
+        /* we shouldn't get consecutive sleep requests */
+        if (WARN_ON(test_and_set_bit(WL1271_FLAG_ELP_REQUESTED, &wl->flags)))
+                return;
+
+        if (!test_bit(WL1271_FLAG_PSM, &wl->flags) &&
+            !test_bit(WL1271_FLAG_IDLE, &wl->flags))
+                return;
+
+        ieee80211_queue_delayed_work(wl->hw, &wl->elp_work,
+                                     msecs_to_jiffies(ELP_ENTRY_DELAY));
 }
 
-int wl1271_ps_elp_wakeup(struct wl1271 *wl, bool chip_awake)
+int wl1271_ps_elp_wakeup(struct wl1271 *wl)
 {
         DECLARE_COMPLETION_ONSTACK(compl);
         unsigned long flags;
@@ -73,6 +85,16 @@ int wl1271_ps_elp_wakeup(struct wl1271 *wl, bool chip_awake)
         u32 start_time = jiffies;
         bool pending = false;
 
+        /*
+         * we might try to wake up even if we didn't go to sleep
+         * before (e.g. on boot)
+         */
+        if (!test_and_clear_bit(WL1271_FLAG_ELP_REQUESTED, &wl->flags))
+                return 0;
+
+        /* don't cancel_sync as it might contend for a mutex and deadlock */
+        cancel_delayed_work(&wl->elp_work);
+
         if (!test_bit(WL1271_FLAG_IN_ELP, &wl->flags))
                 return 0;
 
@@ -83,7 +105,7 @@ int wl1271_ps_elp_wakeup(struct wl1271 *wl, bool chip_awake)
          * the completion variable in one entity.
          */
         spin_lock_irqsave(&wl->wl_lock, flags);
-        if (work_pending(&wl->irq_work) || chip_awake)
+        if (test_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags))
                 pending = true;
         else
                 wl->elp_compl = &compl;
@@ -96,6 +118,7 @@ int wl1271_ps_elp_wakeup(struct wl1271 *wl, bool chip_awake)
                         &compl, msecs_to_jiffies(WL1271_WAKEUP_TIMEOUT));
                 if (ret == 0) {
                         wl1271_error("ELP wakeup timeout!");
+                        ieee80211_queue_work(wl->hw, &wl->recovery_work);
                         ret = -ETIMEDOUT;
                         goto err;
                 } else if (ret < 0) {
@@ -121,7 +144,7 @@ out:
 }
 
 int wl1271_ps_set_mode(struct wl1271 *wl, enum wl1271_cmd_ps_mode mode,
-                       bool send)
+                       u32 rates, bool send)
 {
         int ret;
 
@@ -129,7 +152,13 @@ int wl1271_ps_set_mode(struct wl1271 *wl, enum wl1271_cmd_ps_mode mode,
         case STATION_POWER_SAVE_MODE:
                 wl1271_debug(DEBUG_PSM, "entering psm");
 
-                ret = wl1271_cmd_ps_mode(wl, STATION_POWER_SAVE_MODE, send);
+                ret = wl1271_acx_wake_up_conditions(wl);
+                if (ret < 0) {
+                        wl1271_error("couldn't set wake up conditions");
+                        return ret;
+                }
+
+                ret = wl1271_cmd_ps_mode(wl, STATION_POWER_SAVE_MODE);
                 if (ret < 0)
                         return ret;
 
@@ -138,9 +167,6 @@ int wl1271_ps_set_mode(struct wl1271 *wl, enum wl1271_cmd_ps_mode mode,
         case STATION_ACTIVE_MODE:
         default:
                 wl1271_debug(DEBUG_PSM, "leaving psm");
-                ret = wl1271_ps_elp_wakeup(wl, false);
-                if (ret < 0)
-                        return ret;
 
                 /* disable beacon early termination */
                 ret = wl1271_acx_bet_enable(wl, false);
@@ -152,7 +178,7 @@ int wl1271_ps_set_mode(struct wl1271 *wl, enum wl1271_cmd_ps_mode mode,
                 if (ret < 0)
                         return ret;
 
-                ret = wl1271_cmd_ps_mode(wl, STATION_ACTIVE_MODE, send);
+                ret = wl1271_cmd_ps_mode(wl, STATION_ACTIVE_MODE);
                 if (ret < 0)
                         return ret;
 
@@ -163,4 +189,81 @@ int wl1271_ps_set_mode(struct wl1271 *wl, enum wl1271_cmd_ps_mode mode,
         return ret;
 }
 
+static void wl1271_ps_filter_frames(struct wl1271 *wl, u8 hlid)
+{
+        int i, filtered = 0;
+        struct sk_buff *skb;
+        struct ieee80211_tx_info *info;
+        unsigned long flags;
+
+        /* filter all frames currently the low level queus for this hlid */
+        for (i = 0; i < NUM_TX_QUEUES; i++) {
+                while ((skb = skb_dequeue(&wl->links[hlid].tx_queue[i]))) {
+                        info = IEEE80211_SKB_CB(skb);
+                        info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
+                        info->status.rates[0].idx = -1;
+                        ieee80211_tx_status(wl->hw, skb);
+                        filtered++;
+                }
+        }
+
+        spin_lock_irqsave(&wl->wl_lock, flags);
+        wl->tx_queue_count -= filtered;
+        spin_unlock_irqrestore(&wl->wl_lock, flags);
+
+        wl1271_handle_tx_low_watermark(wl);
+}
+
+void wl1271_ps_link_start(struct wl1271 *wl, u8 hlid, bool clean_queues)
+{
+        struct ieee80211_sta *sta;
+
+        if (test_bit(hlid, &wl->ap_ps_map))
+                return;
+
+        wl1271_debug(DEBUG_PSM, "start mac80211 PSM on hlid %d blks %d "
+                     "clean_queues %d", hlid, wl->links[hlid].allocated_blks,
+                     clean_queues);
+
+        rcu_read_lock();
+        sta = ieee80211_find_sta(wl->vif, wl->links[hlid].addr);
+        if (!sta) {
+                wl1271_error("could not find sta %pM for starting ps",
+                             wl->links[hlid].addr);
+                rcu_read_unlock();
+                return;
+        }
+
+        ieee80211_sta_ps_transition_ni(sta, true);
+        rcu_read_unlock();
+
+        /* do we want to filter all frames from this link's queues? */
+        if (clean_queues)
+                wl1271_ps_filter_frames(wl, hlid);
 
+        __set_bit(hlid, &wl->ap_ps_map);
+}
+
+void wl1271_ps_link_end(struct wl1271 *wl, u8 hlid)
+{
+        struct ieee80211_sta *sta;
+
+        if (!test_bit(hlid, &wl->ap_ps_map))
+                return;
+
+        wl1271_debug(DEBUG_PSM, "end mac80211 PSM on hlid %d", hlid);
+
+        __clear_bit(hlid, &wl->ap_ps_map);
+
+        rcu_read_lock();
+        sta = ieee80211_find_sta(wl->vif, wl->links[hlid].addr);
+        if (!sta) {
+                wl1271_error("could not find sta %pM for ending ps",
+                             wl->links[hlid].addr);
+                goto end;
+        }
+
+        ieee80211_sta_ps_transition_ni(sta, false);
+end:
+        rcu_read_unlock();
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_ps.h b/drivers/net/wireless/wl12xx/ps.h
index 940276f517a4..25eb9bc9b628 100644
--- a/drivers/net/wireless/wl12xx/wl1271_ps.h
+++ b/drivers/net/wireless/wl12xx/ps.h
@@ -21,16 +21,20 @@
  *
  */
 
-#ifndef __WL1271_PS_H__
-#define __WL1271_PS_H__
+#ifndef __PS_H__
+#define __PS_H__
 
-#include "wl1271.h"
-#include "wl1271_acx.h"
+#include "wl12xx.h"
+#include "acx.h"
 
 int wl1271_ps_set_mode(struct wl1271 *wl, enum wl1271_cmd_ps_mode mode,
-                       bool send);
+                       u32 rates, bool send);
 void wl1271_ps_elp_sleep(struct wl1271 *wl);
-int wl1271_ps_elp_wakeup(struct wl1271 *wl, bool chip_awake);
+int wl1271_ps_elp_wakeup(struct wl1271 *wl);
 void wl1271_elp_work(struct work_struct *work);
+void wl1271_ps_link_start(struct wl1271 *wl, u8 hlid, bool clean_queues);
+void wl1271_ps_link_end(struct wl1271 *wl, u8 hlid);
+
+#define WL1271_PS_COMPLETE_TIMEOUT 500
 
 #endif /* __WL1271_PS_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1271_reg.h b/drivers/net/wireless/wl12xx/reg.h
index 990960771528..440a4ee9cb42 100644
--- a/drivers/net/wireless/wl12xx/wl1271_reg.h
+++ b/drivers/net/wireless/wl12xx/reg.h
@@ -207,6 +207,8 @@
 
 #define CHIP_ID_1271_PG10              (0x4030101)
 #define CHIP_ID_1271_PG20              (0x4030111)
+#define CHIP_ID_1283_PG10              (0x05030101)
+#define CHIP_ID_1283_PG20              (0x05030111)
 
 #define ENABLE                         (REGISTERS_BASE + 0x5450)
 
@@ -452,24 +454,11 @@
 #define HI_CFG_UART_TX_OUT_GPIO_14  0x00000200
 #define HI_CFG_UART_TX_OUT_GPIO_7   0x00000400
 
-/*
- * NOTE: USE_ACTIVE_HIGH compilation flag should be defined in makefile
- *       for platforms using active high interrupt level
- */
-#ifdef USE_ACTIVE_HIGH
 #define HI_CFG_DEF_VAL              \
         (HI_CFG_UART_ENABLE |        \
         HI_CFG_RST232_ENABLE |      \
         HI_CFG_CLOCK_REQ_SELECT |   \
         HI_CFG_HOST_INT_ENABLE)
-#else
-#define HI_CFG_DEF_VAL              \
-        (HI_CFG_UART_ENABLE |        \
-        HI_CFG_RST232_ENABLE |      \
-        HI_CFG_CLOCK_REQ_SELECT |   \
-        HI_CFG_HOST_INT_ENABLE)
-
-#endif
 
 #define REF_FREQ_19_2                       0
 #define REF_FREQ_26_0                       1
diff --git a/drivers/net/wireless/wl12xx/rx.c b/drivers/net/wireless/wl12xx/rx.c
new file mode 100644
index 000000000000..70091035e019
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/rx.c
@@ -0,0 +1,244 @@
+/*
+ * This file is part of wl1271
+ *
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * Contact: Luciano Coelho <luciano.coelho@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/gfp.h>
+
+#include "wl12xx.h"
+#include "acx.h"
+#include "reg.h"
+#include "rx.h"
+#include "io.h"
+
+static u8 wl1271_rx_get_mem_block(struct wl1271_fw_common_status *status,
+                                  u32 drv_rx_counter)
+{
+        return le32_to_cpu(status->rx_pkt_descs[drv_rx_counter]) &
+                RX_MEM_BLOCK_MASK;
+}
+
+static u32 wl1271_rx_get_buf_size(struct wl1271_fw_common_status *status,
+                                 u32 drv_rx_counter)
+{
+        return (le32_to_cpu(status->rx_pkt_descs[drv_rx_counter]) &
+                RX_BUF_SIZE_MASK) >> RX_BUF_SIZE_SHIFT_DIV;
+}
+
+static void wl1271_rx_status(struct wl1271 *wl,
+                             struct wl1271_rx_descriptor *desc,
+                             struct ieee80211_rx_status *status,
+                             u8 beacon)
+{
+        memset(status, 0, sizeof(struct ieee80211_rx_status));
+
+        if ((desc->flags & WL1271_RX_DESC_BAND_MASK) == WL1271_RX_DESC_BAND_BG)
+                status->band = IEEE80211_BAND_2GHZ;
+        else
+                status->band = IEEE80211_BAND_5GHZ;
+
+        status->rate_idx = wl1271_rate_to_idx(desc->rate, status->band);
+
+#ifdef CONFIG_WL12XX_HT
+        /* 11n support */
+        if (desc->rate <= CONF_HW_RXTX_RATE_MCS0)
+                status->flag |= RX_FLAG_HT;
+#endif
+
+        status->signal = desc->rssi;
+
+        /*
+         * FIXME: In wl1251, the SNR should be divided by two.  In wl1271 we
+         * need to divide by two for now, but TI has been discussing about
+         * changing it.  This needs to be rechecked.
+         */
+        wl->noise = desc->rssi - (desc->snr >> 1);
+
+        status->freq = ieee80211_channel_to_frequency(desc->channel,
+                                                      status->band);
+
+        if (desc->flags & WL1271_RX_DESC_ENCRYPT_MASK) {
+                u8 desc_err_code = desc->status & WL1271_RX_DESC_STATUS_MASK;
+
+                status->flag |= RX_FLAG_IV_STRIPPED | RX_FLAG_MMIC_STRIPPED |
+                                RX_FLAG_DECRYPTED;
+
+                if (unlikely(desc_err_code == WL1271_RX_DESC_MIC_FAIL)) {
+                        status->flag |= RX_FLAG_MMIC_ERROR;
+                        wl1271_warning("Michael MIC error");
+                }
+        }
+}
+
+static int wl1271_rx_handle_data(struct wl1271 *wl, u8 *data, u32 length)
+{
+        struct wl1271_rx_descriptor *desc;
+        struct sk_buff *skb;
+        struct ieee80211_hdr *hdr;
+        u8 *buf;
+        u8 beacon = 0;
+
+        /*
+         * In PLT mode we seem to get frames and mac80211 warns about them,
+         * workaround this by not retrieving them at all.
+         */
+        if (unlikely(wl->state == WL1271_STATE_PLT))
+                return -EINVAL;
+
+        /* the data read starts with the descriptor */
+        desc = (struct wl1271_rx_descriptor *) data;
+
+        switch (desc->status & WL1271_RX_DESC_STATUS_MASK) {
+        /* discard corrupted packets */
+        case WL1271_RX_DESC_DRIVER_RX_Q_FAIL:
+        case WL1271_RX_DESC_DECRYPT_FAIL:
+                wl1271_warning("corrupted packet in RX with status: 0x%x",
+                               desc->status & WL1271_RX_DESC_STATUS_MASK);
+                return -EINVAL;
+        case WL1271_RX_DESC_SUCCESS:
+        case WL1271_RX_DESC_MIC_FAIL:
+                break;
+        default:
+                wl1271_error("invalid RX descriptor status: 0x%x",
+                             desc->status & WL1271_RX_DESC_STATUS_MASK);
+                return -EINVAL;
+        }
+
+        skb = __dev_alloc_skb(length, GFP_KERNEL);
+        if (!skb) {
+                wl1271_error("Couldn't allocate RX frame");
+                return -ENOMEM;
+        }
+
+        buf = skb_put(skb, length);
+        memcpy(buf, data, length);
+
+        /* now we pull the descriptor out of the buffer */
+        skb_pull(skb, sizeof(*desc));
+
+        hdr = (struct ieee80211_hdr *)skb->data;
+        if (ieee80211_is_beacon(hdr->frame_control))
+                beacon = 1;
+
+        wl1271_rx_status(wl, desc, IEEE80211_SKB_RXCB(skb), beacon);
+
+        wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb,
+                     skb->len - desc->pad_len,
+                     beacon ? "beacon" : "");
+
+        skb_trim(skb, skb->len - desc->pad_len);
+
+        skb_queue_tail(&wl->deferred_rx_queue, skb);
+        ieee80211_queue_work(wl->hw, &wl->netstack_work);
+
+        return 0;
+}
+
+void wl1271_rx(struct wl1271 *wl, struct wl1271_fw_common_status *status)
+{
+        struct wl1271_acx_mem_map *wl_mem_map = wl->target_mem_map;
+        u32 buf_size;
+        u32 fw_rx_counter  = status->fw_rx_counter & NUM_RX_PKT_DESC_MOD_MASK;
+        u32 drv_rx_counter = wl->rx_counter & NUM_RX_PKT_DESC_MOD_MASK;
+        u32 rx_counter;
+        u32 mem_block;
+        u32 pkt_length;
+        u32 pkt_offset;
+
+        while (drv_rx_counter != fw_rx_counter) {
+                buf_size = 0;
+                rx_counter = drv_rx_counter;
+                while (rx_counter != fw_rx_counter) {
+                        pkt_length = wl1271_rx_get_buf_size(status, rx_counter);
+                        if (buf_size + pkt_length > WL1271_AGGR_BUFFER_SIZE)
+                                break;
+                        buf_size += pkt_length;
+                        rx_counter++;
+                        rx_counter &= NUM_RX_PKT_DESC_MOD_MASK;
+                }
+
+                if (buf_size == 0) {
+                        wl1271_warning("received empty data");
+                        break;
+                }
+
+                if (wl->chip.id != CHIP_ID_1283_PG20) {
+                        /*
+                         * Choose the block we want to read
+                         * For aggregated packets, only the first memory block
+                         * should be retrieved. The FW takes care of the rest.
+                         */
+                        mem_block = wl1271_rx_get_mem_block(status,
+                                                            drv_rx_counter);
+
+                        wl->rx_mem_pool_addr.addr = (mem_block << 8) +
+                           le32_to_cpu(wl_mem_map->packet_memory_pool_start);
+
+                        wl->rx_mem_pool_addr.addr_extra =
+                                wl->rx_mem_pool_addr.addr + 4;
+
+                        wl1271_write(wl, WL1271_SLV_REG_DATA,
+                                     &wl->rx_mem_pool_addr,
+                                     sizeof(wl->rx_mem_pool_addr), false);
+                }
+
+                /* Read all available packets at once */
+                wl1271_read(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
+                                buf_size, true);
+
+                /* Split data into separate packets */
+                pkt_offset = 0;
+                while (pkt_offset < buf_size) {
+                        pkt_length = wl1271_rx_get_buf_size(status,
+                                        drv_rx_counter);
+                        /*
+                         * the handle data call can only fail in memory-outage
+                         * conditions, in that case the received frame will just
+                         * be dropped.
+                         */
+                        wl1271_rx_handle_data(wl,
+                                              wl->aggr_buf + pkt_offset,
+                                              pkt_length);
+                        wl->rx_counter++;
+                        drv_rx_counter++;
+                        drv_rx_counter &= NUM_RX_PKT_DESC_MOD_MASK;
+                        pkt_offset += pkt_length;
+                }
+        }
+
+        /*
+         * Write the driver's packet counter to the FW. This is only required
+         * for older hardware revisions
+         */
+        if (wl->quirks & WL12XX_QUIRK_END_OF_TRANSACTION)
+                wl1271_write32(wl, RX_DRIVER_COUNTER_ADDRESS, wl->rx_counter);
+}
+
+void wl1271_set_default_filters(struct wl1271 *wl)
+{
+        if (wl->bss_type == BSS_TYPE_AP_BSS) {
+                wl->rx_config = WL1271_DEFAULT_AP_RX_CONFIG;
+                wl->rx_filter = WL1271_DEFAULT_AP_RX_FILTER;
+        } else {
+                wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
+                wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
+        }
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_rx.h b/drivers/net/wireless/wl12xx/rx.h
index 13a232333b13..75fabf836491 100644
--- a/drivers/net/wireless/wl12xx/wl1271_rx.h
+++ b/drivers/net/wireless/wl12xx/rx.h
@@ -22,18 +22,14 @@
  *
  */
 
-#ifndef __WL1271_RX_H__
-#define __WL1271_RX_H__
+#ifndef __RX_H__
+#define __RX_H__
 
 #include <linux/bitops.h>
 
 #define WL1271_RX_MAX_RSSI -30
 #define WL1271_RX_MIN_RSSI -95
 
-#define WL1271_RX_ALIGN_TO 4
-#define WL1271_RX_ALIGN(len) (((len) + WL1271_RX_ALIGN_TO - 1) & \
-                             ~(WL1271_RX_ALIGN_TO - 1))
-
 #define SHORT_PREAMBLE_BIT   BIT(0)
 #define OFDM_RATE_BIT        BIT(6)
 #define PBCC_RATE_BIT        BIT(7)
@@ -86,8 +82,9 @@
 /*
  * RX Descriptor status
  *
- * Bits 0-2 - status
- * Bits 3-7 - reserved
+ * Bits 0-2 - error code
+ * Bits 3-5 - process_id tag (AP mode FW)
+ * Bits 6-7 - reserved
  */
 #define WL1271_RX_DESC_STATUS_MASK      0x07
 
@@ -110,12 +107,16 @@ struct wl1271_rx_descriptor {
         u8  snr;
         __le32 timestamp;
         u8  packet_class;
-        u8  process_id;
+        union {
+                u8  process_id; /* STA FW */
+                u8  hlid; /* AP FW */
+        } __packed;
         u8  pad_len;
         u8  reserved;
 } __packed;
 
-void wl1271_rx(struct wl1271 *wl, struct wl1271_fw_status *status);
-u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate);
+void wl1271_rx(struct wl1271 *wl, struct wl1271_fw_common_status *status);
+u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band);
+void wl1271_set_default_filters(struct wl1271 *wl);
 
 #endif
diff --git a/drivers/net/wireless/wl12xx/scan.c b/drivers/net/wireless/wl12xx/scan.c
new file mode 100644
index 000000000000..56f76abc754d
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/scan.c
@@ -0,0 +1,582 @@
+/*
+ * This file is part of wl1271
+ *
+ * Copyright (C) 2009-2010 Nokia Corporation
+ *
+ * Contact: Luciano Coelho <luciano.coelho@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/ieee80211.h>
+
+#include "wl12xx.h"
+#include "cmd.h"
+#include "scan.h"
+#include "acx.h"
+#include "ps.h"
+
+void wl1271_scan_complete_work(struct work_struct *work)
+{
+        struct delayed_work *dwork;
+        struct wl1271 *wl;
+
+        dwork = container_of(work, struct delayed_work, work);
+        wl = container_of(dwork, struct wl1271, scan_complete_work);
+
+        wl1271_debug(DEBUG_SCAN, "Scanning complete");
+
+        mutex_lock(&wl->mutex);
+
+        if (wl->state == WL1271_STATE_OFF)
+                goto out;
+
+        if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
+                goto out;
+
+        wl->scan.state = WL1271_SCAN_STATE_IDLE;
+        memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
+        wl->scan.req = NULL;
+        ieee80211_scan_completed(wl->hw, false);
+
+        /* restore hardware connection monitoring template */
+        if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
+                if (wl1271_ps_elp_wakeup(wl) == 0) {
+                        wl1271_cmd_build_ap_probe_req(wl, wl->probereq);
+                        wl1271_ps_elp_sleep(wl);
+                }
+        }
+
+        if (wl->scan.failed) {
+                wl1271_info("Scan completed due to error.");
+                ieee80211_queue_work(wl->hw, &wl->recovery_work);
+        }
+
+out:
+        mutex_unlock(&wl->mutex);
+
+}
+
+
+static int wl1271_get_scan_channels(struct wl1271 *wl,
+                                    struct cfg80211_scan_request *req,
+                                    struct basic_scan_channel_params *channels,
+                                    enum ieee80211_band band, bool passive)
+{
+        struct conf_scan_settings *c = &wl->conf.scan;
+        int i, j;
+        u32 flags;
+
+        for (i = 0, j = 0;
+             i < req->n_channels && j < WL1271_SCAN_MAX_CHANNELS;
+             i++) {
+
+                flags = req->channels[i]->flags;
+
+                if (!test_bit(i, wl->scan.scanned_ch) &&
+                    !(flags & IEEE80211_CHAN_DISABLED) &&
+                    ((!!(flags & IEEE80211_CHAN_PASSIVE_SCAN)) == passive) &&
+                    (req->channels[i]->band == band)) {
+
+                        wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
+                                     req->channels[i]->band,
+                                     req->channels[i]->center_freq);
+                        wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
+                                     req->channels[i]->hw_value,
+                                     req->channels[i]->flags);
+                        wl1271_debug(DEBUG_SCAN,
+                                     "max_antenna_gain %d, max_power %d",
+                                     req->channels[i]->max_antenna_gain,
+                                     req->channels[i]->max_power);
+                        wl1271_debug(DEBUG_SCAN, "beacon_found %d",
+                                     req->channels[i]->beacon_found);
+
+                        if (!passive) {
+                                channels[j].min_duration =
+                                        cpu_to_le32(c->min_dwell_time_active);
+                                channels[j].max_duration =
+                                        cpu_to_le32(c->max_dwell_time_active);
+                        } else {
+                                channels[j].min_duration =
+                                        cpu_to_le32(c->min_dwell_time_passive);
+                                channels[j].max_duration =
+                                        cpu_to_le32(c->max_dwell_time_passive);
+                        }
+                        channels[j].early_termination = 0;
+                        channels[j].tx_power_att = req->channels[i]->max_power;
+                        channels[j].channel = req->channels[i]->hw_value;
+
+                        memset(&channels[j].bssid_lsb, 0xff, 4);
+                        memset(&channels[j].bssid_msb, 0xff, 2);
+
+                        /* Mark the channels we already used */
+                        set_bit(i, wl->scan.scanned_ch);
+
+                        j++;
+                }
+        }
+
+        return j;
+}
+
+#define WL1271_NOTHING_TO_SCAN 1
+
+static int wl1271_scan_send(struct wl1271 *wl, enum ieee80211_band band,
+                             bool passive, u32 basic_rate)
+{
+        struct wl1271_cmd_scan *cmd;
+        struct wl1271_cmd_trigger_scan_to *trigger;
+        int ret;
+        u16 scan_options = 0;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        trigger = kzalloc(sizeof(*trigger), GFP_KERNEL);
+        if (!cmd || !trigger) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* We always use high priority scans */
+        scan_options = WL1271_SCAN_OPT_PRIORITY_HIGH;
+
+        /* No SSIDs means that we have a forced passive scan */
+        if (passive || wl->scan.req->n_ssids == 0)
+                scan_options |= WL1271_SCAN_OPT_PASSIVE;
+
+        cmd->params.scan_options = cpu_to_le16(scan_options);
+
+        cmd->params.n_ch = wl1271_get_scan_channels(wl, wl->scan.req,
+                                                    cmd->channels,
+                                                    band, passive);
+        if (cmd->params.n_ch == 0) {
+                ret = WL1271_NOTHING_TO_SCAN;
+                goto out;
+        }
+
+        cmd->params.tx_rate = cpu_to_le32(basic_rate);
+        cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
+        cmd->params.rx_filter_options =
+                cpu_to_le32(CFG_RX_PRSP_EN | CFG_RX_MGMT_EN | CFG_RX_BCN_EN);
+
+        cmd->params.n_probe_reqs = wl->conf.scan.num_probe_reqs;
+        cmd->params.tx_rate = cpu_to_le32(basic_rate);
+        cmd->params.tid_trigger = 0;
+        cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG;
+
+        if (band == IEEE80211_BAND_2GHZ)
+                cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ;
+        else
+                cmd->params.band = WL1271_SCAN_BAND_5_GHZ;
+
+        if (wl->scan.ssid_len && wl->scan.ssid) {
+                cmd->params.ssid_len = wl->scan.ssid_len;
+                memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len);
+        }
+
+        ret = wl1271_cmd_build_probe_req(wl, wl->scan.ssid, wl->scan.ssid_len,
+                                         wl->scan.req->ie, wl->scan.req->ie_len,
+                                         band);
+        if (ret < 0) {
+                wl1271_error("PROBE request template failed");
+                goto out;
+        }
+
+        /* disable the timeout */
+        trigger->timeout = 0;
+        ret = wl1271_cmd_send(wl, CMD_TRIGGER_SCAN_TO, trigger,
+                              sizeof(*trigger), 0);
+        if (ret < 0) {
+                wl1271_error("trigger scan to failed for hw scan");
+                goto out;
+        }
+
+        wl1271_dump(DEBUG_SCAN, "SCAN: ", cmd, sizeof(*cmd));
+
+        ret = wl1271_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd), 0);
+        if (ret < 0) {
+                wl1271_error("SCAN failed");
+                goto out;
+        }
+
+out:
+        kfree(cmd);
+        kfree(trigger);
+        return ret;
+}
+
+void wl1271_scan_stm(struct wl1271 *wl)
+{
+        int ret = 0;
+
+        switch (wl->scan.state) {
+        case WL1271_SCAN_STATE_IDLE:
+                break;
+
+        case WL1271_SCAN_STATE_2GHZ_ACTIVE:
+                ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, false,
+                                       wl->conf.tx.basic_rate);
+                if (ret == WL1271_NOTHING_TO_SCAN) {
+                        wl->scan.state = WL1271_SCAN_STATE_2GHZ_PASSIVE;
+                        wl1271_scan_stm(wl);
+                }
+
+                break;
+
+        case WL1271_SCAN_STATE_2GHZ_PASSIVE:
+                ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, true,
+                                       wl->conf.tx.basic_rate);
+                if (ret == WL1271_NOTHING_TO_SCAN) {
+                        if (wl->enable_11a)
+                                wl->scan.state = WL1271_SCAN_STATE_5GHZ_ACTIVE;
+                        else
+                                wl->scan.state = WL1271_SCAN_STATE_DONE;
+                        wl1271_scan_stm(wl);
+                }
+
+                break;
+
+        case WL1271_SCAN_STATE_5GHZ_ACTIVE:
+                ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, false,
+                                       wl->conf.tx.basic_rate_5);
+                if (ret == WL1271_NOTHING_TO_SCAN) {
+                        wl->scan.state = WL1271_SCAN_STATE_5GHZ_PASSIVE;
+                        wl1271_scan_stm(wl);
+                }
+
+                break;
+
+        case WL1271_SCAN_STATE_5GHZ_PASSIVE:
+                ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, true,
+                                       wl->conf.tx.basic_rate_5);
+                if (ret == WL1271_NOTHING_TO_SCAN) {
+                        wl->scan.state = WL1271_SCAN_STATE_DONE;
+                        wl1271_scan_stm(wl);
+                }
+
+                break;
+
+        case WL1271_SCAN_STATE_DONE:
+                wl->scan.failed = false;
+                cancel_delayed_work(&wl->scan_complete_work);
+                ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
+                                             msecs_to_jiffies(0));
+                break;
+
+        default:
+                wl1271_error("invalid scan state");
+                break;
+        }
+
+        if (ret < 0) {
+                cancel_delayed_work(&wl->scan_complete_work);
+                ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
+                                             msecs_to_jiffies(0));
+        }
+}
+
+int wl1271_scan(struct wl1271 *wl, const u8 *ssid, size_t ssid_len,
+                struct cfg80211_scan_request *req)
+{
+        /*
+         * cfg80211 should guarantee that we don't get more channels
+         * than what we have registered.
+         */
+        BUG_ON(req->n_channels > WL1271_MAX_CHANNELS);
+
+        if (wl->scan.state != WL1271_SCAN_STATE_IDLE)
+                return -EBUSY;
+
+        wl->scan.state = WL1271_SCAN_STATE_2GHZ_ACTIVE;
+
+        if (ssid_len && ssid) {
+                wl->scan.ssid_len = ssid_len;
+                memcpy(wl->scan.ssid, ssid, ssid_len);
+        } else {
+                wl->scan.ssid_len = 0;
+        }
+
+        wl->scan.req = req;
+        memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
+
+        /* we assume failure so that timeout scenarios are handled correctly */
+        wl->scan.failed = true;
+        ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
+                                     msecs_to_jiffies(WL1271_SCAN_TIMEOUT));
+
+        wl1271_scan_stm(wl);
+
+        return 0;
+}
+
+static int
+wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
+                                    struct cfg80211_sched_scan_request *req,
+                                    struct conn_scan_ch_params *channels,
+                                    u32 band, bool radar, bool passive,
+                                    int start)
+{
+        struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
+        int i, j;
+        u32 flags;
+        bool force_passive = !req->n_ssids;
+
+        for (i = 0, j = start;
+             i < req->n_channels && j < MAX_CHANNELS_ALL_BANDS;
+             i++) {
+                flags = req->channels[i]->flags;
+
+                if (force_passive)
+                        flags |= IEEE80211_CHAN_PASSIVE_SCAN;
+
+                if ((req->channels[i]->band == band) &&
+                    !(flags & IEEE80211_CHAN_DISABLED) &&
+                    (!!(flags & IEEE80211_CHAN_RADAR) == radar) &&
+                    /* if radar is set, we ignore the passive flag */
+                    (radar ||
+                     !!(flags & IEEE80211_CHAN_PASSIVE_SCAN) == passive)) {
+                        wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
+                                     req->channels[i]->band,
+                                     req->channels[i]->center_freq);
+                        wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
+                                     req->channels[i]->hw_value,
+                                     req->channels[i]->flags);
+                        wl1271_debug(DEBUG_SCAN, "max_power %d",
+                                     req->channels[i]->max_power);
+
+                        if (flags & IEEE80211_CHAN_RADAR) {
+                                channels[j].flags |= SCAN_CHANNEL_FLAGS_DFS;
+                                channels[j].passive_duration =
+                                        cpu_to_le16(c->dwell_time_dfs);
+                        }
+                        else if (flags & IEEE80211_CHAN_PASSIVE_SCAN) {
+                                channels[j].passive_duration =
+                                        cpu_to_le16(c->dwell_time_passive);
+                        } else {
+                                channels[j].min_duration =
+                                        cpu_to_le16(c->min_dwell_time_active);
+                                channels[j].max_duration =
+                                        cpu_to_le16(c->max_dwell_time_active);
+                        }
+                        channels[j].tx_power_att = req->channels[i]->max_power;
+                        channels[j].channel = req->channels[i]->hw_value;
+
+                        j++;
+                }
+        }
+
+        return j - start;
+}
+
+static int
+wl1271_scan_sched_scan_channels(struct wl1271 *wl,
+                                struct cfg80211_sched_scan_request *req,
+                                struct wl1271_cmd_sched_scan_config *cfg)
+{
+        int idx = 0;
+
+        cfg->passive[0] =
+                wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
+                                                    IEEE80211_BAND_2GHZ,
+                                                    false, true, idx);
+        idx += cfg->passive[0];
+
+        cfg->active[0] =
+                wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
+                                                    IEEE80211_BAND_2GHZ,
+                                                    false, false, idx);
+        /*
+         * 5GHz channels always start at position 14, not immediately
+         * after the last 2.4GHz channel
+         */
+        idx = 14;
+
+        cfg->passive[1] =
+                wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
+                                                    IEEE80211_BAND_5GHZ,
+                                                    false, true, idx);
+        idx += cfg->passive[1];
+
+        cfg->dfs =
+                wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
+                                                    IEEE80211_BAND_5GHZ,
+                                                    true, true, idx);
+        idx += cfg->dfs;
+
+        cfg->active[1] =
+                wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
+                                                    IEEE80211_BAND_5GHZ,
+                                                    false, false, idx);
+        idx += cfg->active[1];
+
+        wl1271_debug(DEBUG_SCAN, "    2.4GHz: active %d passive %d",
+                     cfg->active[0], cfg->passive[0]);
+        wl1271_debug(DEBUG_SCAN, "    5GHz: active %d passive %d",
+                     cfg->active[1], cfg->passive[1]);
+        wl1271_debug(DEBUG_SCAN, "    DFS: %d", cfg->dfs);
+
+        return idx;
+}
+
+int wl1271_scan_sched_scan_config(struct wl1271 *wl,
+                                  struct cfg80211_sched_scan_request *req,
+                                  struct ieee80211_sched_scan_ies *ies)
+{
+        struct wl1271_cmd_sched_scan_config *cfg = NULL;
+        struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
+        int i, total_channels, ret;
+        bool force_passive = !req->n_ssids;
+
+        wl1271_debug(DEBUG_CMD, "cmd sched_scan scan config");
+
+        cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
+        if (!cfg)
+                return -ENOMEM;
+
+        cfg->rssi_threshold = c->rssi_threshold;
+        cfg->snr_threshold  = c->snr_threshold;
+        cfg->n_probe_reqs = c->num_probe_reqs;
+        /* cycles set to 0 it means infinite (until manually stopped) */
+        cfg->cycles = 0;
+        /* report APs when at least 1 is found */
+        cfg->report_after = 1;
+        /* don't stop scanning automatically when something is found */
+        cfg->terminate = 0;
+        cfg->tag = WL1271_SCAN_DEFAULT_TAG;
+        /* don't filter on BSS type */
+        cfg->bss_type = SCAN_BSS_TYPE_ANY;
+        /* currently NL80211 supports only a single interval */
+        for (i = 0; i < SCAN_MAX_CYCLE_INTERVALS; i++)
+                cfg->intervals[i] = cpu_to_le32(req->interval);
+
+        if (!force_passive && req->ssids[0].ssid_len && req->ssids[0].ssid) {
+                cfg->filter_type = SCAN_SSID_FILTER_SPECIFIC;
+                cfg->ssid_len = req->ssids[0].ssid_len;
+                memcpy(cfg->ssid, req->ssids[0].ssid,
+                       req->ssids[0].ssid_len);
+        } else {
+                cfg->filter_type = SCAN_SSID_FILTER_ANY;
+                cfg->ssid_len = 0;
+        }
+
+        total_channels = wl1271_scan_sched_scan_channels(wl, req, cfg);
+        if (total_channels == 0) {
+                wl1271_error("scan channel list is empty");
+                ret = -EINVAL;
+                goto out;
+        }
+
+        if (!force_passive && cfg->active[0]) {
+                ret = wl1271_cmd_build_probe_req(wl, req->ssids[0].ssid,
+                                                 req->ssids[0].ssid_len,
+                                                 ies->ie[IEEE80211_BAND_2GHZ],
+                                                 ies->len[IEEE80211_BAND_2GHZ],
+                                                 IEEE80211_BAND_2GHZ);
+                if (ret < 0) {
+                        wl1271_error("2.4GHz PROBE request template failed");
+                        goto out;
+                }
+        }
+
+        if (!force_passive && cfg->active[1]) {
+                ret = wl1271_cmd_build_probe_req(wl,  req->ssids[0].ssid,
+                                                 req->ssids[0].ssid_len,
+                                                 ies->ie[IEEE80211_BAND_5GHZ],
+                                                 ies->len[IEEE80211_BAND_5GHZ],
+                                                 IEEE80211_BAND_5GHZ);
+                if (ret < 0) {
+                        wl1271_error("5GHz PROBE request template failed");
+                        goto out;
+                }
+        }
+
+        wl1271_dump(DEBUG_SCAN, "SCAN_CFG: ", cfg, sizeof(*cfg));
+
+        ret = wl1271_cmd_send(wl, CMD_CONNECTION_SCAN_CFG, cfg,
+                              sizeof(*cfg), 0);
+        if (ret < 0) {
+                wl1271_error("SCAN configuration failed");
+                goto out;
+        }
+out:
+        kfree(cfg);
+        return ret;
+}
+
+int wl1271_scan_sched_scan_start(struct wl1271 *wl)
+{
+        struct wl1271_cmd_sched_scan_start *start;
+        int ret = 0;
+
+        wl1271_debug(DEBUG_CMD, "cmd periodic scan start");
+
+        if (wl->bss_type != BSS_TYPE_STA_BSS)
+                return -EOPNOTSUPP;
+
+        if (!test_bit(WL1271_FLAG_IDLE, &wl->flags))
+                return -EBUSY;
+
+        start = kzalloc(sizeof(*start), GFP_KERNEL);
+        if (!start)
+                return -ENOMEM;
+
+        start->tag = WL1271_SCAN_DEFAULT_TAG;
+
+        ret = wl1271_cmd_send(wl, CMD_START_PERIODIC_SCAN, start,
+                              sizeof(*start), 0);
+        if (ret < 0) {
+                wl1271_error("failed to send scan start command");
+                goto out_free;
+        }
+
+out_free:
+        kfree(start);
+        return ret;
+}
+
+void wl1271_scan_sched_scan_results(struct wl1271 *wl)
+{
+        wl1271_debug(DEBUG_SCAN, "got periodic scan results");
+
+        ieee80211_sched_scan_results(wl->hw);
+}
+
+void wl1271_scan_sched_scan_stop(struct wl1271 *wl)
+{
+        struct wl1271_cmd_sched_scan_stop *stop;
+        int ret = 0;
+
+        wl1271_debug(DEBUG_CMD, "cmd periodic scan stop");
+
+        /* FIXME: what to do if alloc'ing to stop fails? */
+        stop = kzalloc(sizeof(*stop), GFP_KERNEL);
+        if (!stop) {
+                wl1271_error("failed to alloc memory to send sched scan stop");
+                return;
+        }
+
+        stop->tag = WL1271_SCAN_DEFAULT_TAG;
+
+        ret = wl1271_cmd_send(wl, CMD_STOP_PERIODIC_SCAN, stop,
+                              sizeof(*stop), 0);
+        if (ret < 0) {
+                wl1271_error("failed to send sched scan stop command");
+                goto out_free;
+        }
+        wl->sched_scanning = false;
+
+out_free:
+        kfree(stop);
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_scan.h b/drivers/net/wireless/wl12xx/scan.h
index f1815700f5f9..a0b6c5d67b07 100644
--- a/drivers/net/wireless/wl12xx/wl1271_scan.h
+++ b/drivers/net/wireless/wl12xx/scan.h
@@ -21,10 +21,10 @@
  *
  */
 
-#ifndef __WL1271_SCAN_H__
-#define __WL1271_SCAN_H__
+#ifndef __SCAN_H__
+#define __SCAN_H__
 
-#include "wl1271.h"
+#include "wl12xx.h"
 
 int wl1271_scan(struct wl1271 *wl, const u8 *ssid, size_t ssid_len,
                 struct cfg80211_scan_request *req);
@@ -32,6 +32,13 @@ int wl1271_scan_build_probe_req(struct wl1271 *wl,
                                 const u8 *ssid, size_t ssid_len,
                                 const u8 *ie, size_t ie_len, u8 band);
 void wl1271_scan_stm(struct wl1271 *wl);
+void wl1271_scan_complete_work(struct work_struct *work);
+int wl1271_scan_sched_scan_config(struct wl1271 *wl,
+                                     struct cfg80211_sched_scan_request *req,
+                                     struct ieee80211_sched_scan_ies *ies);
+int wl1271_scan_sched_scan_start(struct wl1271 *wl);
+void wl1271_scan_sched_scan_stop(struct wl1271 *wl);
+void wl1271_scan_sched_scan_results(struct wl1271 *wl);
 
 #define WL1271_SCAN_MAX_CHANNELS       24
 #define WL1271_SCAN_DEFAULT_TAG        1
@@ -39,11 +46,10 @@ void wl1271_scan_stm(struct wl1271 *wl);
 #define WL1271_SCAN_OPT_ACTIVE         0
 #define WL1271_SCAN_OPT_PASSIVE        1
 #define WL1271_SCAN_OPT_PRIORITY_HIGH  4
-#define WL1271_SCAN_CHAN_MIN_DURATION  30000  /* TU */
-#define WL1271_SCAN_CHAN_MAX_DURATION  60000  /* TU */
 #define WL1271_SCAN_BAND_2_4_GHZ 0
 #define WL1271_SCAN_BAND_5_GHZ 1
-#define WL1271_SCAN_PROBE_REQS 3
+
+#define WL1271_SCAN_TIMEOUT    10000 /* msec */
 
 enum {
         WL1271_SCAN_STATE_IDLE,
@@ -106,4 +112,115 @@ struct wl1271_cmd_trigger_scan_to {
         __le32 timeout;
 } __packed;
 
+#define MAX_CHANNELS_ALL_BANDS 41
+#define SCAN_MAX_CYCLE_INTERVALS 16
+#define SCAN_MAX_BANDS 3
+
+enum {
+        SCAN_CHANNEL_TYPE_2GHZ_PASSIVE,
+        SCAN_CHANNEL_TYPE_2GHZ_ACTIVE,
+        SCAN_CHANNEL_TYPE_5GHZ_PASSIVE,
+        SCAN_CHANNEL_TYPE_5GHZ_ACTIVE,
+        SCAN_CHANNEL_TYPE_5GHZ_DFS,
+};
+
+enum {
+        SCAN_SSID_FILTER_ANY      = 0,
+        SCAN_SSID_FILTER_SPECIFIC = 1,
+        SCAN_SSID_FILTER_LIST     = 2,
+        SCAN_SSID_FILTER_DISABLED = 3
+};
+
+enum {
+        SCAN_BSS_TYPE_INDEPENDENT,
+        SCAN_BSS_TYPE_INFRASTRUCTURE,
+        SCAN_BSS_TYPE_ANY,
+};
+
+#define SCAN_CHANNEL_FLAGS_DFS          BIT(0)
+#define SCAN_CHANNEL_FLAGS_DFS_ENABLED  BIT(1)
+
+struct conn_scan_ch_params {
+        __le16 min_duration;
+        __le16 max_duration;
+        __le16 passive_duration;
+
+        u8  channel;
+        u8  tx_power_att;
+
+        /* bit 0: DFS channel; bit 1: DFS enabled */
+        u8  flags;
+
+        u8  padding[3];
+} __packed;
+
+struct wl1271_cmd_sched_scan_config {
+        struct wl1271_cmd_header header;
+
+        __le32 intervals[SCAN_MAX_CYCLE_INTERVALS];
+
+        s8 rssi_threshold; /* for filtering (in dBm) */
+        s8 snr_threshold;  /* for filtering (in dB) */
+
+        u8 cycles;       /* maximum number of scan cycles */
+        u8 report_after; /* report when this number of results are received */
+        u8 terminate;    /* stop scanning after reporting */
+
+        u8 tag;
+        u8 bss_type; /* for filtering */
+        u8 filter_type;
+
+        u8 ssid_len;     /* For SCAN_SSID_FILTER_SPECIFIC */
+        u8 ssid[IW_ESSID_MAX_SIZE];
+
+        u8 n_probe_reqs; /* Number of probes requests per channel */
+
+        u8 passive[SCAN_MAX_BANDS];
+        u8 active[SCAN_MAX_BANDS];
+
+        u8 dfs;
+
+        u8 padding[3];
+
+        struct conn_scan_ch_params channels[MAX_CHANNELS_ALL_BANDS];
+} __packed;
+
+
+#define SCHED_SCAN_MAX_SSIDS 8
+
+enum {
+        SCAN_SSID_TYPE_PUBLIC = 0,
+        SCAN_SSID_TYPE_HIDDEN = 1,
+};
+
+struct wl1271_ssid {
+        u8 type;
+        u8 len;
+        u8 ssid[IW_ESSID_MAX_SIZE];
+        /* u8 padding[2]; */
+} __packed;
+
+struct wl1271_cmd_sched_scan_ssid_list {
+        struct wl1271_cmd_header header;
+
+        u8 n_ssids;
+        struct wl1271_ssid ssids[SCHED_SCAN_MAX_SSIDS];
+        u8 padding[3];
+} __packed;
+
+struct wl1271_cmd_sched_scan_start {
+        struct wl1271_cmd_header header;
+
+        u8 tag;
+        u8 padding[3];
+} __packed;
+
+struct wl1271_cmd_sched_scan_stop {
+        struct wl1271_cmd_header header;
+
+        u8 tag;
+        u8 padding[3];
+} __packed;
+
+
 #endif /* __WL1271_SCAN_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1271_sdio.c b/drivers/net/wireless/wl12xx/sdio.c
index 7059b5cccf0f..536e5065454b 100644
--- a/drivers/net/wireless/wl12xx/wl1271_sdio.c
+++ b/drivers/net/wireless/wl12xx/sdio.c
@@ -28,14 +28,14 @@
 #include <linux/mmc/sdio_func.h>
 #include <linux/mmc/sdio_ids.h>
 #include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
 #include <linux/gpio.h>
+#include <linux/wl12xx.h>
+#include <linux/pm_runtime.h>
 
-#include "wl1271.h"
+#include "wl12xx.h"
 #include "wl12xx_80211.h"
-#include "wl1271_io.h"
-
-
-#define RX71_WL1271_IRQ_GPIO            42
+#include "io.h"
 
 #ifndef SDIO_VENDOR_ID_TI
 #define SDIO_VENDOR_ID_TI               0x0097
@@ -51,6 +51,13 @@ static const struct sdio_device_id wl1271_devices[] = {
 };
 MODULE_DEVICE_TABLE(sdio, wl1271_devices);
 
+static void wl1271_sdio_set_block_size(struct wl1271 *wl, unsigned int blksz)
+{
+        sdio_claim_host(wl->if_priv);
+        sdio_set_block_size(wl->if_priv, blksz);
+        sdio_release_host(wl->if_priv);
+}
+
 static inline struct sdio_func *wl_to_func(struct wl1271 *wl)
 {
         return wl->if_priv;
@@ -61,7 +68,7 @@ static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)
         return &(wl_to_func(wl)->dev);
 }
 
-static irqreturn_t wl1271_irq(int irq, void *cookie)
+static irqreturn_t wl1271_hardirq(int irq, void *cookie)
 {
         struct wl1271 *wl = cookie;
         unsigned long flags;
@@ -70,17 +77,24 @@ static irqreturn_t wl1271_irq(int irq, void *cookie)
 
         /* complete the ELP completion */
         spin_lock_irqsave(&wl->wl_lock, flags);
+        set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
         if (wl->elp_compl) {
                 complete(wl->elp_compl);
                 wl->elp_compl = NULL;
         }
 
-        if (!test_and_set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags))
-                ieee80211_queue_work(wl->hw, &wl->irq_work);
-        set_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
+        if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
+                /* don't enqueue a work right now. mark it as pending */
+                set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
+                wl1271_debug(DEBUG_IRQ, "should not enqueue work");
+                disable_irq_nosync(wl->irq);
+                pm_wakeup_event(wl1271_sdio_wl_to_dev(wl), 0);
+                spin_unlock_irqrestore(&wl->wl_lock, flags);
+                return IRQ_HANDLED;
+        }
         spin_unlock_irqrestore(&wl->wl_lock, flags);
 
-        return IRQ_HANDLED;
+        return IRQ_WAKE_THREAD;
 }
 
 static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)
@@ -124,7 +138,6 @@ static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,
 
         if (ret)
                 wl1271_error("sdio read failed (%d)", ret);
-
 }
 
 static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
@@ -147,26 +160,56 @@ static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
                 else
                         ret = sdio_memcpy_toio(func, addr, buf, len);
         }
+
         if (ret)
                 wl1271_error("sdio write failed (%d)", ret);
+}
+
+static int wl1271_sdio_power_on(struct wl1271 *wl)
+{
+        struct sdio_func *func = wl_to_func(wl);
+        int ret;
+
+        /* Make sure the card will not be powered off by runtime PM */
+        ret = pm_runtime_get_sync(&func->dev);
+        if (ret < 0)
+                goto out;
 
+        /* Runtime PM might be disabled, so power up the card manually */
+        ret = mmc_power_restore_host(func->card->host);
+        if (ret < 0)
+                goto out;
+
+        sdio_claim_host(func);
+        sdio_enable_func(func);
+
+out:
+        return ret;
 }
 
-static void wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
+static int wl1271_sdio_power_off(struct wl1271 *wl)
 {
         struct sdio_func *func = wl_to_func(wl);
+        int ret;
 
-        /* Let the SDIO stack handle wlan_enable control, so we
-         * keep host claimed while wlan is in use to keep wl1271
-         * alive.
-         */
-        if (enable) {
-                sdio_claim_host(func);
-                sdio_enable_func(func);
-        } else {
-                sdio_disable_func(func);
-                sdio_release_host(func);
-        }
+        sdio_disable_func(func);
+        sdio_release_host(func);
+
+        /* Runtime PM might be disabled, so power off the card manually */
+        ret = mmc_power_save_host(func->card->host);
+        if (ret < 0)
+                return ret;
+
+        /* Let runtime PM know the card is powered off */
+        return pm_runtime_put_sync(&func->dev);
+}
+
+static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
+{
+        if (enable)
+                return wl1271_sdio_power_on(wl);
+        else
+                return wl1271_sdio_power_off(wl);
 }
 
 static struct wl1271_if_operations sdio_ops = {
@@ -177,14 +220,18 @@ static struct wl1271_if_operations sdio_ops = {
         .power          = wl1271_sdio_set_power,
         .dev            = wl1271_sdio_wl_to_dev,
         .enable_irq     = wl1271_sdio_enable_interrupts,
-        .disable_irq    = wl1271_sdio_disable_interrupts
+        .disable_irq    = wl1271_sdio_disable_interrupts,
+        .set_block_size = wl1271_sdio_set_block_size,
 };
 
 static int __devinit wl1271_probe(struct sdio_func *func,
                                   const struct sdio_device_id *id)
 {
         struct ieee80211_hw *hw;
+        const struct wl12xx_platform_data *wlan_data;
         struct wl1271 *wl;
+        unsigned long irqflags;
+        mmc_pm_flag_t mmcflags;
         int ret;
 
         /* We are only able to handle the wlan function */
@@ -203,23 +250,46 @@ static int __devinit wl1271_probe(struct sdio_func *func,
         /* Grab access to FN0 for ELP reg. */
         func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
 
-        wl->irq = gpio_to_irq(RX71_WL1271_IRQ_GPIO);
-        if (wl->irq < 0) {
-                ret = wl->irq;
-                wl1271_error("could not get irq!");
+        /* Use block mode for transferring over one block size of data */
+        func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
+
+        wlan_data = wl12xx_get_platform_data();
+        if (IS_ERR(wlan_data)) {
+                ret = PTR_ERR(wlan_data);
+                wl1271_error("missing wlan platform data: %d", ret);
                 goto out_free;
         }
 
-        ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
+        wl->irq = wlan_data->irq;
+        wl->ref_clock = wlan_data->board_ref_clock;
+        wl->tcxo_clock = wlan_data->board_tcxo_clock;
+        wl->platform_quirks = wlan_data->platform_quirks;
+
+        if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
+                irqflags = IRQF_TRIGGER_RISING;
+        else
+                irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
+
+        ret = request_threaded_irq(wl->irq, wl1271_hardirq, wl1271_irq,
+                                   irqflags,
+                                   DRIVER_NAME, wl);
         if (ret < 0) {
                 wl1271_error("request_irq() failed: %d", ret);
                 goto out_free;
         }
 
-        set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
+        enable_irq_wake(wl->irq);
+        device_init_wakeup(wl1271_sdio_wl_to_dev(wl), 1);
 
         disable_irq(wl->irq);
 
+        /* if sdio can keep power while host is suspended, enable wow */
+        mmcflags = sdio_get_host_pm_caps(func);
+        wl1271_debug(DEBUG_SDIO, "sdio PM caps = 0x%x", mmcflags);
+
+        if (mmcflags & MMC_PM_KEEP_POWER)
+                hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;
+
         ret = wl1271_init_ieee80211(wl);
         if (ret)
                 goto out_irq;
@@ -230,6 +300,9 @@ static int __devinit wl1271_probe(struct sdio_func *func,
 
         sdio_set_drvdata(func, wl);
 
+        /* Tell PM core that we don't need the card to be powered now */
+        pm_runtime_put_noidle(&func->dev);
+
         wl1271_notice("initialized");
 
         return 0;
@@ -237,7 +310,6 @@ static int __devinit wl1271_probe(struct sdio_func *func,
  out_irq:
         free_irq(wl->irq, wl);
 
-
  out_free:
         wl1271_free_hw(wl);
 
@@ -248,17 +320,84 @@ static void __devexit wl1271_remove(struct sdio_func *func)
 {
         struct wl1271 *wl = sdio_get_drvdata(func);
 
-        free_irq(wl->irq, wl);
+        /* Undo decrement done above in wl1271_probe */
+        pm_runtime_get_noresume(&func->dev);
 
         wl1271_unregister_hw(wl);
+        device_init_wakeup(wl1271_sdio_wl_to_dev(wl), 0);
+        disable_irq_wake(wl->irq);
+        free_irq(wl->irq, wl);
         wl1271_free_hw(wl);
 }
 
+#ifdef CONFIG_PM
+static int wl1271_suspend(struct device *dev)
+{
+        /* Tell MMC/SDIO core it's OK to power down the card
+         * (if it isn't already), but not to remove it completely */
+        struct sdio_func *func = dev_to_sdio_func(dev);
+        struct wl1271 *wl = sdio_get_drvdata(func);
+        mmc_pm_flag_t sdio_flags;
+        int ret = 0;
+
+        wl1271_debug(DEBUG_MAC80211, "wl1271 suspend. wow_enabled: %d",
+                     wl->wow_enabled);
+
+        /* check whether sdio should keep power */
+        if (wl->wow_enabled) {
+                sdio_flags = sdio_get_host_pm_caps(func);
+
+                if (!(sdio_flags & MMC_PM_KEEP_POWER)) {
+                        wl1271_error("can't keep power while host "
+                                     "is suspended");
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                /* keep power while host suspended */
+                ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
+                if (ret) {
+                        wl1271_error("error while trying to keep power");
+                        goto out;
+                }
+
+                /* release host */
+                sdio_release_host(func);
+        }
+out:
+        return ret;
+}
+
+static int wl1271_resume(struct device *dev)
+{
+        struct sdio_func *func = dev_to_sdio_func(dev);
+        struct wl1271 *wl = sdio_get_drvdata(func);
+
+        wl1271_debug(DEBUG_MAC80211, "wl1271 resume");
+        if (wl->wow_enabled) {
+                /* claim back host */
+                sdio_claim_host(func);
+        }
+
+        return 0;
+}
+
+static const struct dev_pm_ops wl1271_sdio_pm_ops = {
+        .suspend        = wl1271_suspend,
+        .resume         = wl1271_resume,
+};
+#endif
+
 static struct sdio_driver wl1271_sdio_driver = {
         .name           = "wl1271_sdio",
         .id_table       = wl1271_devices,
         .probe          = wl1271_probe,
         .remove         = __devexit_p(wl1271_remove),
+#ifdef CONFIG_PM
+        .drv = {
+                .pm = &wl1271_sdio_pm_ops,
+        },
+#endif
 };
 
 static int __init wl1271_init(void)
@@ -286,6 +425,9 @@ module_init(wl1271_init);
 module_exit(wl1271_exit);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
+MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
 MODULE_FIRMWARE(WL1271_FW_NAME);
+MODULE_FIRMWARE(WL128X_FW_NAME);
+MODULE_FIRMWARE(WL127X_AP_FW_NAME);
+MODULE_FIRMWARE(WL128X_AP_FW_NAME);
diff --git a/drivers/net/wireless/wl12xx/sdio_test.c b/drivers/net/wireless/wl12xx/sdio_test.c
new file mode 100644
index 000000000000..f28915392877
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/sdio_test.c
@@ -0,0 +1,534 @@
+/*
+ * SDIO testing driver for wl12xx
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * Contact: Roger Quadros <roger.quadros@nokia.com>
+ *
+ * wl12xx read/write routines taken from the main module
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/crc7.h>
+#include <linux/vmalloc.h>
+#include <linux/mmc/sdio_func.h>
+#include <linux/mmc/sdio_ids.h>
+#include <linux/mmc/card.h>
+#include <linux/gpio.h>
+#include <linux/wl12xx.h>
+#include <linux/kthread.h>
+#include <linux/firmware.h>
+#include <linux/pm_runtime.h>
+
+#include "wl12xx.h"
+#include "io.h"
+#include "boot.h"
+
+#ifndef SDIO_VENDOR_ID_TI
+#define SDIO_VENDOR_ID_TI               0x0097
+#endif
+
+#ifndef SDIO_DEVICE_ID_TI_WL1271
+#define SDIO_DEVICE_ID_TI_WL1271        0x4076
+#endif
+
+static bool rx, tx;
+
+module_param(rx, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(rx, "Perform rx test. Default (0). "
+        "This test continuously reads data from the SDIO device.\n");
+
+module_param(tx, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(tx, "Perform tx test. Default (0). "
+        "This test continuously writes data to the SDIO device.\n");
+
+struct wl1271_test {
+        struct wl1271 wl;
+        struct task_struct *test_task;
+};
+
+static const struct sdio_device_id wl1271_devices[] = {
+        { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1271) },
+        {}
+};
+
+static inline struct sdio_func *wl_to_func(struct wl1271 *wl)
+{
+        return wl->if_priv;
+}
+
+static struct device *wl1271_sdio_wl_to_dev(struct wl1271 *wl)
+{
+        return &(wl_to_func(wl)->dev);
+}
+
+static void wl1271_sdio_raw_read(struct wl1271 *wl, int addr, void *buf,
+                size_t len, bool fixed)
+{
+        int ret = 0;
+        struct sdio_func *func = wl_to_func(wl);
+
+        if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
+                ((u8 *)buf)[0] = sdio_f0_readb(func, addr, &ret);
+                wl1271_debug(DEBUG_SDIO, "sdio read 52 addr 0x%x, byte 0x%02x",
+                                addr, ((u8 *)buf)[0]);
+        } else {
+                if (fixed)
+                        ret = sdio_readsb(func, buf, addr, len);
+                else
+                        ret = sdio_memcpy_fromio(func, buf, addr, len);
+
+                wl1271_debug(DEBUG_SDIO, "sdio read 53 addr 0x%x, %zu bytes",
+                                addr, len);
+                wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
+        }
+
+        if (ret)
+                wl1271_error("sdio read failed (%d)", ret);
+}
+
+static void wl1271_sdio_raw_write(struct wl1271 *wl, int addr, void *buf,
+                size_t len, bool fixed)
+{
+        int ret = 0;
+        struct sdio_func *func = wl_to_func(wl);
+
+        if (unlikely(addr == HW_ACCESS_ELP_CTRL_REG_ADDR)) {
+                sdio_f0_writeb(func, ((u8 *)buf)[0], addr, &ret);
+                wl1271_debug(DEBUG_SDIO, "sdio write 52 addr 0x%x, byte 0x%02x",
+                                addr, ((u8 *)buf)[0]);
+        } else {
+                wl1271_debug(DEBUG_SDIO, "sdio write 53 addr 0x%x, %zu bytes",
+                                addr, len);
+                wl1271_dump_ascii(DEBUG_SDIO, "data: ", buf, len);
+
+                if (fixed)
+                        ret = sdio_writesb(func, addr, buf, len);
+                else
+                        ret = sdio_memcpy_toio(func, addr, buf, len);
+        }
+        if (ret)
+                wl1271_error("sdio write failed (%d)", ret);
+
+}
+
+static int wl1271_sdio_set_power(struct wl1271 *wl, bool enable)
+{
+        struct sdio_func *func = wl_to_func(wl);
+        int ret;
+
+        /* Let the SDIO stack handle wlan_enable control, so we
+         * keep host claimed while wlan is in use to keep wl1271
+         * alive.
+         */
+        if (enable) {
+                /* Power up the card */
+                ret = pm_runtime_get_sync(&func->dev);
+                if (ret < 0)
+                        goto out;
+                sdio_claim_host(func);
+                sdio_enable_func(func);
+                sdio_release_host(func);
+        } else {
+                sdio_claim_host(func);
+                sdio_disable_func(func);
+                sdio_release_host(func);
+
+                /* Power down the card */
+                ret = pm_runtime_put_sync(&func->dev);
+        }
+
+out:
+        return ret;
+}
+
+static void wl1271_sdio_disable_interrupts(struct wl1271 *wl)
+{
+}
+
+static void wl1271_sdio_enable_interrupts(struct wl1271 *wl)
+{
+}
+
+
+static struct wl1271_if_operations sdio_ops = {
+        .read           = wl1271_sdio_raw_read,
+        .write          = wl1271_sdio_raw_write,
+        .power          = wl1271_sdio_set_power,
+        .dev            = wl1271_sdio_wl_to_dev,
+        .enable_irq     = wl1271_sdio_enable_interrupts,
+        .disable_irq    = wl1271_sdio_disable_interrupts,
+};
+
+static void wl1271_fw_wakeup(struct wl1271 *wl)
+{
+        u32 elp_reg;
+
+        elp_reg = ELPCTRL_WAKE_UP;
+        wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
+}
+
+static int wl1271_fetch_firmware(struct wl1271 *wl)
+{
+        const struct firmware *fw;
+        int ret;
+
+        if (wl->chip.id == CHIP_ID_1283_PG20)
+                ret = request_firmware(&fw, WL128X_FW_NAME,
+                                       wl1271_wl_to_dev(wl));
+        else
+                ret = request_firmware(&fw, WL1271_FW_NAME,
+                                       wl1271_wl_to_dev(wl));
+
+        if (ret < 0) {
+                wl1271_error("could not get firmware: %d", ret);
+                return ret;
+        }
+
+        if (fw->size % 4) {
+                wl1271_error("firmware size is not multiple of 32 bits: %zu",
+                                fw->size);
+                ret = -EILSEQ;
+                goto out;
+        }
+
+        wl->fw_len = fw->size;
+        wl->fw = vmalloc(wl->fw_len);
+
+        if (!wl->fw) {
+                wl1271_error("could not allocate memory for the firmware");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        memcpy(wl->fw, fw->data, wl->fw_len);
+
+        ret = 0;
+
+out:
+        release_firmware(fw);
+
+        return ret;
+}
+
+static int wl1271_fetch_nvs(struct wl1271 *wl)
+{
+        const struct firmware *fw;
+        int ret;
+
+        ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
+
+        if (ret < 0) {
+                wl1271_error("could not get nvs file: %d", ret);
+                return ret;
+        }
+
+        wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
+
+        if (!wl->nvs) {
+                wl1271_error("could not allocate memory for the nvs file");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        wl->nvs_len = fw->size;
+
+out:
+        release_firmware(fw);
+
+        return ret;
+}
+
+static int wl1271_chip_wakeup(struct wl1271 *wl)
+{
+        struct wl1271_partition_set partition;
+        int ret;
+
+        msleep(WL1271_PRE_POWER_ON_SLEEP);
+        ret = wl1271_power_on(wl);
+        if (ret)
+                return ret;
+
+        msleep(WL1271_POWER_ON_SLEEP);
+
+        /* We don't need a real memory partition here, because we only want
+         * to use the registers at this point. */
+        memset(&partition, 0, sizeof(partition));
+        partition.reg.start = REGISTERS_BASE;
+        partition.reg.size = REGISTERS_DOWN_SIZE;
+        wl1271_set_partition(wl, &partition);
+
+        /* ELP module wake up */
+        wl1271_fw_wakeup(wl);
+
+        /* whal_FwCtrl_BootSm() */
+
+        /* 0. read chip id from CHIP_ID */
+        wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
+
+        /* 1. check if chip id is valid */
+
+        switch (wl->chip.id) {
+        case CHIP_ID_1271_PG10:
+                wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
+                                wl->chip.id);
+                break;
+        case CHIP_ID_1271_PG20:
+                wl1271_notice("chip id 0x%x (1271 PG20)",
+                                wl->chip.id);
+                break;
+        case CHIP_ID_1283_PG20:
+                wl1271_notice("chip id 0x%x (1283 PG20)",
+                                wl->chip.id);
+                break;
+        case CHIP_ID_1283_PG10:
+        default:
+                wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
+                return -ENODEV;
+        }
+
+        return ret;
+}
+
+static struct wl1271_partition_set part_down = {
+        .mem = {
+                .start = 0x00000000,
+                .size  = 0x000177c0
+        },
+        .reg = {
+                .start = REGISTERS_BASE,
+                .size  = 0x00008800
+        },
+        .mem2 = {
+                .start = 0x00000000,
+                .size  = 0x00000000
+        },
+        .mem3 = {
+                .start = 0x00000000,
+                .size  = 0x00000000
+        },
+};
+
+static int tester(void *data)
+{
+        struct wl1271 *wl = data;
+        struct sdio_func *func = wl_to_func(wl);
+        struct device *pdev = &func->dev;
+        int ret = 0;
+        bool rx_started = 0;
+        bool tx_started = 0;
+        uint8_t *tx_buf, *rx_buf;
+        int test_size = PAGE_SIZE;
+        u32 addr = 0;
+        struct wl1271_partition_set partition;
+
+        /* We assume chip is powered up and firmware fetched */
+
+        memcpy(&partition, &part_down, sizeof(partition));
+        partition.mem.start = addr;
+        wl1271_set_partition(wl, &partition);
+
+        tx_buf = kmalloc(test_size, GFP_KERNEL);
+        rx_buf = kmalloc(test_size, GFP_KERNEL);
+        if (!tx_buf || !rx_buf) {
+                dev_err(pdev,
+                        "Could not allocate memory. Test will not run.\n");
+                ret = -ENOMEM;
+                goto free;
+        }
+
+        memset(tx_buf, 0x5a, test_size);
+
+        /* write something in data area so we can read it back */
+        wl1271_write(wl, addr, tx_buf, test_size, false);
+
+        while (!kthread_should_stop()) {
+                if (rx && !rx_started) {
+                        dev_info(pdev, "starting rx test\n");
+                        rx_started = 1;
+                } else if (!rx && rx_started) {
+                        dev_info(pdev, "stopping rx test\n");
+                        rx_started = 0;
+                }
+
+                if (tx && !tx_started) {
+                        dev_info(pdev, "starting tx test\n");
+                        tx_started = 1;
+                } else if (!tx && tx_started) {
+                        dev_info(pdev, "stopping tx test\n");
+                        tx_started = 0;
+                }
+
+                if (rx_started)
+                        wl1271_read(wl, addr, rx_buf, test_size, false);
+
+                if (tx_started)
+                        wl1271_write(wl, addr, tx_buf, test_size, false);
+
+                if (!rx_started && !tx_started)
+                        msleep(100);
+        }
+
+free:
+        kfree(tx_buf);
+        kfree(rx_buf);
+        return ret;
+}
+
+static int __devinit wl1271_probe(struct sdio_func *func,
+                const struct sdio_device_id *id)
+{
+        const struct wl12xx_platform_data *wlan_data;
+        struct wl1271 *wl;
+        struct wl1271_test *wl_test;
+        int ret = 0;
+
+        /* wl1271 has 2 sdio functions we handle just the wlan part */
+        if (func->num != 0x02)
+                return -ENODEV;
+
+        wl_test = kzalloc(sizeof(struct wl1271_test), GFP_KERNEL);
+        if (!wl_test) {
+                dev_err(&func->dev, "Could not allocate memory\n");
+                return -ENOMEM;
+        }
+
+        wl = &wl_test->wl;
+
+        wl->if_priv = func;
+        wl->if_ops = &sdio_ops;
+
+        /* Grab access to FN0 for ELP reg. */
+        func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
+
+        /* Use block mode for transferring over one block size of data */
+        func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
+
+        wlan_data = wl12xx_get_platform_data();
+        if (IS_ERR(wlan_data)) {
+                ret = PTR_ERR(wlan_data);
+                dev_err(&func->dev, "missing wlan platform data: %d\n", ret);
+                goto out_free;
+        }
+
+        wl->irq = wlan_data->irq;
+        wl->ref_clock = wlan_data->board_ref_clock;
+        wl->tcxo_clock = wlan_data->board_tcxo_clock;
+
+        sdio_set_drvdata(func, wl_test);
+
+
+        /* power up the device */
+        ret = wl1271_chip_wakeup(wl);
+        if (ret) {
+                dev_err(&func->dev, "could not wake up chip\n");
+                goto out_free;
+        }
+
+        if (wl->fw == NULL) {
+                ret = wl1271_fetch_firmware(wl);
+                if (ret < 0) {
+                        dev_err(&func->dev, "firmware fetch error\n");
+                        goto out_off;
+                }
+        }
+
+        /* fetch NVS */
+        if (wl->nvs == NULL) {
+                ret = wl1271_fetch_nvs(wl);
+                if (ret < 0) {
+                        dev_err(&func->dev, "NVS fetch error\n");
+                        goto out_off;
+                }
+        }
+
+        ret = wl1271_load_firmware(wl);
+        if (ret < 0) {
+                dev_err(&func->dev, "firmware load error: %d\n", ret);
+                goto out_free;
+        }
+
+        dev_info(&func->dev, "initialized\n");
+
+        /* I/O testing will be done in the tester thread */
+
+        wl_test->test_task = kthread_run(tester, wl, "sdio_tester");
+        if (IS_ERR(wl_test->test_task)) {
+                dev_err(&func->dev, "unable to create kernel thread\n");
+                ret = PTR_ERR(wl_test->test_task);
+                goto out_free;
+        }
+
+        return 0;
+
+out_off:
+        /* power off the chip */
+        wl1271_power_off(wl);
+
+out_free:
+        kfree(wl_test);
+        return ret;
+}
+
+static void __devexit wl1271_remove(struct sdio_func *func)
+{
+        struct wl1271_test *wl_test = sdio_get_drvdata(func);
+
+        /* stop the I/O test thread */
+        kthread_stop(wl_test->test_task);
+
+        /* power off the chip */
+        wl1271_power_off(&wl_test->wl);
+
+        vfree(wl_test->wl.fw);
+        wl_test->wl.fw = NULL;
+        kfree(wl_test->wl.nvs);
+        wl_test->wl.nvs = NULL;
+
+        kfree(wl_test);
+}
+
+static struct sdio_driver wl1271_sdio_driver = {
+        .name           = "wl12xx_sdio_test",
+        .id_table       = wl1271_devices,
+        .probe          = wl1271_probe,
+        .remove         = __devexit_p(wl1271_remove),
+};
+
+static int __init wl1271_init(void)
+{
+        int ret;
+
+        ret = sdio_register_driver(&wl1271_sdio_driver);
+        if (ret < 0)
+                pr_err("failed to register sdio driver: %d\n", ret);
+
+        return ret;
+}
+module_init(wl1271_init);
+
+static void __exit wl1271_exit(void)
+{
+        sdio_unregister_driver(&wl1271_sdio_driver);
+}
+module_exit(wl1271_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Roger Quadros <roger.quadros@nokia.com>");
+
diff --git a/drivers/net/wireless/wl12xx/wl1271_spi.c b/drivers/net/wireless/wl12xx/spi.c
index 4cb99c541e2a..51662bb68019 100644
--- a/drivers/net/wireless/wl12xx/wl1271_spi.c
+++ b/drivers/net/wireless/wl12xx/spi.c
@@ -25,14 +25,14 @@
 #include <linux/module.h>
 #include <linux/crc7.h>
 #include <linux/spi/spi.h>
-#include <linux/spi/wl12xx.h>
+#include <linux/wl12xx.h>
 #include <linux/slab.h>
 
-#include "wl1271.h"
+#include "wl12xx.h"
 #include "wl12xx_80211.h"
-#include "wl1271_io.h"
+#include "io.h"
 
-#include "wl1271_reg.h"
+#include "reg.h"
 
 #define WSPI_CMD_READ                 0x40000000
 #define WSPI_CMD_WRITE                0x00000000
@@ -63,6 +63,11 @@
                 ((WL1271_BUSY_WORD_LEN - 4) / sizeof(u32))
 #define HW_ACCESS_WSPI_INIT_CMD_MASK  0
 
+/* HW limitation: maximum possible chunk size is 4095 bytes */
+#define WSPI_MAX_CHUNK_SIZE    4092
+
+#define WSPI_MAX_NUM_OF_CHUNKS (WL1271_AGGR_BUFFER_SIZE / WSPI_MAX_CHUNK_SIZE)
+
 static inline struct spi_device *wl_to_spi(struct wl1271 *wl)
 {
         return wl->if_priv;
@@ -105,9 +110,9 @@ static void wl1271_spi_reset(struct wl1271 *wl)
         spi_message_add_tail(&t, &m);
 
         spi_sync(wl_to_spi(wl), &m);
-        kfree(cmd);
 
         wl1271_dump(DEBUG_SPI, "spi reset -> ", cmd, WSPI_INIT_CMD_LEN);
+        kfree(cmd);
 }
 
 static void wl1271_spi_init(struct wl1271 *wl)
@@ -202,120 +207,144 @@ static int wl1271_spi_read_busy(struct wl1271 *wl)
 static void wl1271_spi_raw_read(struct wl1271 *wl, int addr, void *buf,
                                 size_t len, bool fixed)
 {
-        struct spi_transfer t[3];
+        struct spi_transfer t[2];
         struct spi_message m;
         u32 *busy_buf;
         u32 *cmd;
+        u32 chunk_len;
 
-        cmd = &wl->buffer_cmd;
-        busy_buf = wl->buffer_busyword;
+        while (len > 0) {
+                chunk_len = min((size_t)WSPI_MAX_CHUNK_SIZE, len);
 
-        *cmd = 0;
-        *cmd |= WSPI_CMD_READ;
-        *cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
-        *cmd |= addr & WSPI_CMD_BYTE_ADDR;
+                cmd = &wl->buffer_cmd;
+                busy_buf = wl->buffer_busyword;
 
-        if (fixed)
-                *cmd |= WSPI_CMD_FIXED;
+                *cmd = 0;
+                *cmd |= WSPI_CMD_READ;
+                *cmd |= (chunk_len << WSPI_CMD_BYTE_LENGTH_OFFSET) &
+                        WSPI_CMD_BYTE_LENGTH;
+                *cmd |= addr & WSPI_CMD_BYTE_ADDR;
 
-        spi_message_init(&m);
-        memset(t, 0, sizeof(t));
+                if (fixed)
+                        *cmd |= WSPI_CMD_FIXED;
 
-        t[0].tx_buf = cmd;
-        t[0].len = 4;
-        t[0].cs_change = true;
-        spi_message_add_tail(&t[0], &m);
+                spi_message_init(&m);
+                memset(t, 0, sizeof(t));
 
-        /* Busy and non busy words read */
-        t[1].rx_buf = busy_buf;
-        t[1].len = WL1271_BUSY_WORD_LEN;
-        t[1].cs_change = true;
-        spi_message_add_tail(&t[1], &m);
+                t[0].tx_buf = cmd;
+                t[0].len = 4;
+                t[0].cs_change = true;
+                spi_message_add_tail(&t[0], &m);
 
-        spi_sync(wl_to_spi(wl), &m);
+                /* Busy and non busy words read */
+                t[1].rx_buf = busy_buf;
+                t[1].len = WL1271_BUSY_WORD_LEN;
+                t[1].cs_change = true;
+                spi_message_add_tail(&t[1], &m);
 
-        if (!(busy_buf[WL1271_BUSY_WORD_CNT - 1] & 0x1) &&
-            wl1271_spi_read_busy(wl)) {
-                memset(buf, 0, len);
-                return;
-        }
+                spi_sync(wl_to_spi(wl), &m);
 
-        spi_message_init(&m);
-        memset(t, 0, sizeof(t));
+                if (!(busy_buf[WL1271_BUSY_WORD_CNT - 1] & 0x1) &&
+                    wl1271_spi_read_busy(wl)) {
+                        memset(buf, 0, chunk_len);
+                        return;
+                }
+
+                spi_message_init(&m);
+                memset(t, 0, sizeof(t));
 
-        t[0].rx_buf = buf;
-        t[0].len = len;
-        t[0].cs_change = true;
-        spi_message_add_tail(&t[0], &m);
+                t[0].rx_buf = buf;
+                t[0].len = chunk_len;
+                t[0].cs_change = true;
+                spi_message_add_tail(&t[0], &m);
 
-        spi_sync(wl_to_spi(wl), &m);
+                spi_sync(wl_to_spi(wl), &m);
 
-        wl1271_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
-        wl1271_dump(DEBUG_SPI, "spi_read buf <- ", buf, len);
+                wl1271_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
+                wl1271_dump(DEBUG_SPI, "spi_read buf <- ", buf, chunk_len);
+
+                if (!fixed)
+                        addr += chunk_len;
+                buf += chunk_len;
+                len -= chunk_len;
+        }
 }
 
 static void wl1271_spi_raw_write(struct wl1271 *wl, int addr, void *buf,
                           size_t len, bool fixed)
 {
-        struct spi_transfer t[2];
+        struct spi_transfer t[2 * WSPI_MAX_NUM_OF_CHUNKS];
         struct spi_message m;
+        u32 commands[WSPI_MAX_NUM_OF_CHUNKS];
         u32 *cmd;
+        u32 chunk_len;
+        int i;
 
-        cmd = &wl->buffer_cmd;
-
-        *cmd = 0;
-        *cmd |= WSPI_CMD_WRITE;
-        *cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
-        *cmd |= addr & WSPI_CMD_BYTE_ADDR;
-
-        if (fixed)
-                *cmd |= WSPI_CMD_FIXED;
+        WARN_ON(len > WL1271_AGGR_BUFFER_SIZE);
 
         spi_message_init(&m);
         memset(t, 0, sizeof(t));
 
-        t[0].tx_buf = cmd;
-        t[0].len = sizeof(*cmd);
-        spi_message_add_tail(&t[0], &m);
+        cmd = &commands[0];
+        i = 0;
+        while (len > 0) {
+                chunk_len = min((size_t)WSPI_MAX_CHUNK_SIZE, len);
 
-        t[1].tx_buf = buf;
-        t[1].len = len;
-        spi_message_add_tail(&t[1], &m);
+                *cmd = 0;
+                *cmd |= WSPI_CMD_WRITE;
+                *cmd |= (chunk_len << WSPI_CMD_BYTE_LENGTH_OFFSET) &
+                        WSPI_CMD_BYTE_LENGTH;
+                *cmd |= addr & WSPI_CMD_BYTE_ADDR;
 
-        spi_sync(wl_to_spi(wl), &m);
+                if (fixed)
+                        *cmd |= WSPI_CMD_FIXED;
 
-        wl1271_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
-        wl1271_dump(DEBUG_SPI, "spi_write buf -> ", buf, len);
+                t[i].tx_buf = cmd;
+                t[i].len = sizeof(*cmd);
+                spi_message_add_tail(&t[i++], &m);
+
+                t[i].tx_buf = buf;
+                t[i].len = chunk_len;
+                spi_message_add_tail(&t[i++], &m);
+
+                wl1271_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
+                wl1271_dump(DEBUG_SPI, "spi_write buf -> ", buf, chunk_len);
+
+                if (!fixed)
+                        addr += chunk_len;
+                buf += chunk_len;
+                len -= chunk_len;
+                cmd++;
+        }
+
+        spi_sync(wl_to_spi(wl), &m);
 }
 
-static irqreturn_t wl1271_irq(int irq, void *cookie)
+static irqreturn_t wl1271_hardirq(int irq, void *cookie)
 {
-        struct wl1271 *wl;
+        struct wl1271 *wl = cookie;
         unsigned long flags;
 
         wl1271_debug(DEBUG_IRQ, "IRQ");
 
-        wl = cookie;
-
         /* complete the ELP completion */
         spin_lock_irqsave(&wl->wl_lock, flags);
+        set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
         if (wl->elp_compl) {
                 complete(wl->elp_compl);
                 wl->elp_compl = NULL;
         }
-
-        if (!test_and_set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags))
-                ieee80211_queue_work(wl->hw, &wl->irq_work);
-        set_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
         spin_unlock_irqrestore(&wl->wl_lock, flags);
 
-        return IRQ_HANDLED;
+        return IRQ_WAKE_THREAD;
 }
 
-static void wl1271_spi_set_power(struct wl1271 *wl, bool enable)
+static int wl1271_spi_set_power(struct wl1271 *wl, bool enable)
 {
         if (wl->set_power)
                 wl->set_power(enable);
+
+        return 0;
 }
 
 static struct wl1271_if_operations spi_ops = {
@@ -326,7 +355,8 @@ static struct wl1271_if_operations spi_ops = {
         .power          = wl1271_spi_set_power,
         .dev            = wl1271_spi_wl_to_dev,
         .enable_irq     = wl1271_spi_enable_interrupts,
-        .disable_irq    = wl1271_spi_disable_interrupts
+        .disable_irq    = wl1271_spi_disable_interrupts,
+        .set_block_size = NULL,
 };
 
 static int __devinit wl1271_probe(struct spi_device *spi)
@@ -334,6 +364,7 @@ static int __devinit wl1271_probe(struct spi_device *spi)
         struct wl12xx_platform_data *pdata;
         struct ieee80211_hw *hw;
         struct wl1271 *wl;
+        unsigned long irqflags;
         int ret;
 
         pdata = spi->dev.platform_data;
@@ -370,6 +401,15 @@ static int __devinit wl1271_probe(struct spi_device *spi)
                 goto out_free;
         }
 
+        wl->ref_clock = pdata->board_ref_clock;
+        wl->tcxo_clock = pdata->board_tcxo_clock;
+        wl->platform_quirks = pdata->platform_quirks;
+
+        if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
+                irqflags = IRQF_TRIGGER_RISING;
+        else
+                irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
+
         wl->irq = spi->irq;
         if (wl->irq < 0) {
                 wl1271_error("irq missing in platform data");
@@ -377,14 +417,14 @@ static int __devinit wl1271_probe(struct spi_device *spi)
                 goto out_free;
         }
 
-        ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
+        ret = request_threaded_irq(wl->irq, wl1271_hardirq, wl1271_irq,
+                                   irqflags,
+                                   DRIVER_NAME, wl);
         if (ret < 0) {
                 wl1271_error("request_irq() failed: %d", ret);
                 goto out_free;
         }
 
-        set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
-
         disable_irq(wl->irq);
 
         ret = wl1271_init_ieee80211(wl);
@@ -412,9 +452,8 @@ static int __devexit wl1271_remove(struct spi_device *spi)
 {
         struct wl1271 *wl = dev_get_drvdata(&spi->dev);
 
-        free_irq(wl->irq, wl);
-
         wl1271_unregister_hw(wl);
+        free_irq(wl->irq, wl);
         wl1271_free_hw(wl);
 
         return 0;
@@ -457,7 +496,10 @@ module_init(wl1271_init);
 module_exit(wl1271_exit);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
+MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
 MODULE_FIRMWARE(WL1271_FW_NAME);
+MODULE_FIRMWARE(WL128X_FW_NAME);
+MODULE_FIRMWARE(WL127X_AP_FW_NAME);
+MODULE_FIRMWARE(WL128X_AP_FW_NAME);
 MODULE_ALIAS("spi:wl1271");
diff --git a/drivers/net/wireless/wl12xx/wl1271_testmode.c b/drivers/net/wireless/wl12xx/testmode.c
index 6e0952f79e9a..da351d7cd1f2 100644
--- a/drivers/net/wireless/wl12xx/wl1271_testmode.c
+++ b/drivers/net/wireless/wl12xx/testmode.c
@@ -20,13 +20,14 @@
  * 02110-1301 USA
  *
  */
-#include "wl1271_testmode.h"
+#include "testmode.h"
 
 #include <linux/slab.h>
 #include <net/genetlink.h>
 
-#include "wl1271.h"
-#include "wl1271_acx.h"
+#include "wl12xx.h"
+#include "acx.h"
+#include "reg.h"
 
 #define WL1271_TM_MAX_DATA_LENGTH 1024
 
@@ -37,6 +38,7 @@ enum wl1271_tm_commands {
         WL1271_TM_CMD_CONFIGURE,
         WL1271_TM_CMD_NVS_PUSH,
         WL1271_TM_CMD_SET_PLT_MODE,
+        WL1271_TM_CMD_RECOVER,
 
         __WL1271_TM_CMD_AFTER_LAST
 };
@@ -199,24 +201,17 @@ static int wl1271_tm_cmd_nvs_push(struct wl1271 *wl, struct nlattr *tb[])
         buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
         len = nla_len(tb[WL1271_TM_ATTR_DATA]);
 
-        /*
-         * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz band
-         * configurations) can be removed when those NVS files stop floating
-         * around.
-         */
-        if (len != sizeof(struct wl1271_nvs_file) &&
-            (len != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
-             wl1271_11a_enabled())) {
-                wl1271_error("nvs size is not as expected: %zu != %zu",
-                             len, sizeof(struct wl1271_nvs_file));
-                return -EMSGSIZE;
-        }
-
         mutex_lock(&wl->mutex);
 
         kfree(wl->nvs);
 
-        wl->nvs = kzalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
+        if ((wl->chip.id == CHIP_ID_1283_PG20) &&
+            (len != sizeof(struct wl128x_nvs_file)))
+                return -EINVAL;
+        else if (len != sizeof(struct wl1271_nvs_file))
+                return -EINVAL;
+
+        wl->nvs = kzalloc(len, GFP_KERNEL);
         if (!wl->nvs) {
                 wl1271_error("could not allocate memory for the nvs file");
                 ret = -ENOMEM;
@@ -224,6 +219,7 @@ static int wl1271_tm_cmd_nvs_push(struct wl1271 *wl, struct nlattr *tb[])
         }
 
         memcpy(wl->nvs, buf, len);
+        wl->nvs_len = len;
 
         wl1271_debug(DEBUG_TESTMODE, "testmode pushed nvs");
 
@@ -260,6 +256,15 @@ static int wl1271_tm_cmd_set_plt_mode(struct wl1271 *wl, struct nlattr *tb[])
         return ret;
 }
 
+static int wl1271_tm_cmd_recover(struct wl1271 *wl, struct nlattr *tb[])
+{
+        wl1271_debug(DEBUG_TESTMODE, "testmode cmd recover");
+
+        ieee80211_queue_work(wl->hw, &wl->recovery_work);
+
+        return 0;
+}
+
 int wl1271_tm_cmd(struct ieee80211_hw *hw, void *data, int len)
 {
         struct wl1271 *wl = hw->priv;
@@ -284,6 +289,8 @@ int wl1271_tm_cmd(struct ieee80211_hw *hw, void *data, int len)
                 return wl1271_tm_cmd_nvs_push(wl, tb);
         case WL1271_TM_CMD_SET_PLT_MODE:
                 return wl1271_tm_cmd_set_plt_mode(wl, tb);
+        case WL1271_TM_CMD_RECOVER:
+                return wl1271_tm_cmd_recover(wl, tb);
         default:
                 return -EOPNOTSUPP;
         }
diff --git a/drivers/net/wireless/wl12xx/wl1271_testmode.h b/drivers/net/wireless/wl12xx/testmode.h
index c196d28f9d9d..8071654259ea 100644
--- a/drivers/net/wireless/wl12xx/wl1271_testmode.h
+++ b/drivers/net/wireless/wl12xx/testmode.h
@@ -21,8 +21,8 @@
  *
  */
 
-#ifndef __WL1271_TESTMODE_H__
-#define __WL1271_TESTMODE_H__
+#ifndef __TESTMODE_H__
+#define __TESTMODE_H__
 
 #include <net/mac80211.h>
 
diff --git a/drivers/net/wireless/wl12xx/tx.c b/drivers/net/wireless/wl12xx/tx.c
new file mode 100644
index 000000000000..ca3ab1c1acef
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/tx.c
@@ -0,0 +1,885 @@
+/*
+ * This file is part of wl1271
+ *
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * Contact: Luciano Coelho <luciano.coelho@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/etherdevice.h>
+
+#include "wl12xx.h"
+#include "io.h"
+#include "reg.h"
+#include "ps.h"
+#include "tx.h"
+
+static int wl1271_set_default_wep_key(struct wl1271 *wl, u8 id)
+{
+        int ret;
+        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+
+        if (is_ap)
+                ret = wl1271_cmd_set_ap_default_wep_key(wl, id);
+        else
+                ret = wl1271_cmd_set_sta_default_wep_key(wl, id);
+
+        if (ret < 0)
+                return ret;
+
+        wl1271_debug(DEBUG_CRYPT, "default wep key idx: %d", (int)id);
+        return 0;
+}
+
+static int wl1271_alloc_tx_id(struct wl1271 *wl, struct sk_buff *skb)
+{
+        int id;
+
+        id = find_first_zero_bit(wl->tx_frames_map, ACX_TX_DESCRIPTORS);
+        if (id >= ACX_TX_DESCRIPTORS)
+                return -EBUSY;
+
+        __set_bit(id, wl->tx_frames_map);
+        wl->tx_frames[id] = skb;
+        wl->tx_frames_cnt++;
+        return id;
+}
+
+static void wl1271_free_tx_id(struct wl1271 *wl, int id)
+{
+        if (__test_and_clear_bit(id, wl->tx_frames_map)) {
+                if (unlikely(wl->tx_frames_cnt == ACX_TX_DESCRIPTORS))
+                        clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
+
+                wl->tx_frames[id] = NULL;
+                wl->tx_frames_cnt--;
+        }
+}
+
+static int wl1271_tx_update_filters(struct wl1271 *wl,
+                                                 struct sk_buff *skb)
+{
+        struct ieee80211_hdr *hdr;
+
+        hdr = (struct ieee80211_hdr *)(skb->data +
+                                       sizeof(struct wl1271_tx_hw_descr));
+
+        /*
+         * stop bssid-based filtering before transmitting authentication
+         * requests. this way the hw will never drop authentication
+         * responses coming from BSSIDs it isn't familiar with (e.g. on
+         * roaming)
+         */
+        if (!ieee80211_is_auth(hdr->frame_control))
+                return 0;
+
+        wl1271_configure_filters(wl, FIF_OTHER_BSS);
+
+        return wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
+}
+
+static void wl1271_tx_ap_update_inconnection_sta(struct wl1271 *wl,
+                                                 struct sk_buff *skb)
+{
+        struct ieee80211_hdr *hdr;
+
+        /*
+         * add the station to the known list before transmitting the
+         * authentication response. this way it won't get de-authed by FW
+         * when transmitting too soon.
+         */
+        hdr = (struct ieee80211_hdr *)(skb->data +
+                                       sizeof(struct wl1271_tx_hw_descr));
+        if (ieee80211_is_auth(hdr->frame_control))
+                wl1271_acx_set_inconnection_sta(wl, hdr->addr1);
+}
+
+static void wl1271_tx_regulate_link(struct wl1271 *wl, u8 hlid)
+{
+        bool fw_ps;
+        u8 tx_blks;
+
+        /* only regulate station links */
+        if (hlid < WL1271_AP_STA_HLID_START)
+                return;
+
+        fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
+        tx_blks = wl->links[hlid].allocated_blks;
+
+        /*
+         * if in FW PS and there is enough data in FW we can put the link
+         * into high-level PS and clean out its TX queues.
+         */
+        if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
+                wl1271_ps_link_start(wl, hlid, true);
+}
+
+u8 wl1271_tx_get_hlid(struct sk_buff *skb)
+{
+        struct ieee80211_tx_info *control = IEEE80211_SKB_CB(skb);
+
+        if (control->control.sta) {
+                struct wl1271_station *wl_sta;
+
+                wl_sta = (struct wl1271_station *)
+                                control->control.sta->drv_priv;
+                return wl_sta->hlid;
+        } else {
+                struct ieee80211_hdr *hdr;
+
+                hdr = (struct ieee80211_hdr *)skb->data;
+                if (ieee80211_is_mgmt(hdr->frame_control))
+                        return WL1271_AP_GLOBAL_HLID;
+                else
+                        return WL1271_AP_BROADCAST_HLID;
+        }
+}
+
+static unsigned int wl12xx_calc_packet_alignment(struct wl1271 *wl,
+                                                unsigned int packet_length)
+{
+        if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT)
+                return ALIGN(packet_length, WL12XX_BUS_BLOCK_SIZE);
+        else
+                return ALIGN(packet_length, WL1271_TX_ALIGN_TO);
+}
+
+static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
+                                u32 buf_offset, u8 hlid)
+{
+        struct wl1271_tx_hw_descr *desc;
+        u32 total_len = skb->len + sizeof(struct wl1271_tx_hw_descr) + extra;
+        u32 len;
+        u32 total_blocks;
+        int id, ret = -EBUSY;
+        u32 spare_blocks;
+
+        if (unlikely(wl->quirks & WL12XX_QUIRK_USE_2_SPARE_BLOCKS))
+                spare_blocks = 2;
+        else
+                spare_blocks = 1;
+
+        if (buf_offset + total_len > WL1271_AGGR_BUFFER_SIZE)
+                return -EAGAIN;
+
+        /* allocate free identifier for the packet */
+        id = wl1271_alloc_tx_id(wl, skb);
+        if (id < 0)
+                return id;
+
+        /* approximate the number of blocks required for this packet
+           in the firmware */
+        len = wl12xx_calc_packet_alignment(wl, total_len);
+
+        total_blocks = (len + TX_HW_BLOCK_SIZE - 1) / TX_HW_BLOCK_SIZE +
+                spare_blocks;
+
+        if (total_blocks <= wl->tx_blocks_available) {
+                desc = (struct wl1271_tx_hw_descr *)skb_push(
+                        skb, total_len - skb->len);
+
+                /* HW descriptor fields change between wl127x and wl128x */
+                if (wl->chip.id == CHIP_ID_1283_PG20) {
+                        desc->wl128x_mem.total_mem_blocks = total_blocks;
+                } else {
+                        desc->wl127x_mem.extra_blocks = spare_blocks;
+                        desc->wl127x_mem.total_mem_blocks = total_blocks;
+                }
+
+                desc->id = id;
+
+                wl->tx_blocks_available -= total_blocks;
+                wl->tx_allocated_blocks += total_blocks;
+
+                if (wl->bss_type == BSS_TYPE_AP_BSS)
+                        wl->links[hlid].allocated_blks += total_blocks;
+
+                ret = 0;
+
+                wl1271_debug(DEBUG_TX,
+                             "tx_allocate: size: %d, blocks: %d, id: %d",
+                             total_len, total_blocks, id);
+        } else {
+                wl1271_free_tx_id(wl, id);
+        }
+
+        return ret;
+}
+
+static bool wl12xx_is_dummy_packet(struct wl1271 *wl, struct sk_buff *skb)
+{
+        return wl->dummy_packet == skb;
+}
+
+static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
+                              u32 extra, struct ieee80211_tx_info *control,
+                              u8 hlid)
+{
+        struct timespec ts;
+        struct wl1271_tx_hw_descr *desc;
+        int aligned_len, ac, rate_idx;
+        s64 hosttime;
+        u16 tx_attr;
+
+        desc = (struct wl1271_tx_hw_descr *) skb->data;
+
+        /* relocate space for security header */
+        if (extra) {
+                void *framestart = skb->data + sizeof(*desc);
+                u16 fc = *(u16 *)(framestart + extra);
+                int hdrlen = ieee80211_hdrlen(cpu_to_le16(fc));
+                memmove(framestart, framestart + extra, hdrlen);
+        }
+
+        /* configure packet life time */
+        getnstimeofday(&ts);
+        hosttime = (timespec_to_ns(&ts) >> 10);
+        desc->start_time = cpu_to_le32(hosttime - wl->time_offset);
+
+        if (wl->bss_type != BSS_TYPE_AP_BSS)
+                desc->life_time = cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU);
+        else
+                desc->life_time = cpu_to_le16(TX_HW_AP_MODE_PKT_LIFETIME_TU);
+
+        /* queue */
+        ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
+        desc->tid = skb->priority;
+
+        if (wl12xx_is_dummy_packet(wl, skb)) {
+                /*
+                 * FW expects the dummy packet to have an invalid session id -
+                 * any session id that is different than the one set in the join
+                 */
+                tx_attr = ((~wl->session_counter) <<
+                           TX_HW_ATTR_OFST_SESSION_COUNTER) &
+                           TX_HW_ATTR_SESSION_COUNTER;
+
+                tx_attr |= TX_HW_ATTR_TX_DUMMY_REQ;
+        } else {
+                /* configure the tx attributes */
+                tx_attr =
+                        wl->session_counter << TX_HW_ATTR_OFST_SESSION_COUNTER;
+        }
+
+        if (wl->bss_type != BSS_TYPE_AP_BSS) {
+                desc->aid = hlid;
+
+                /* if the packets are destined for AP (have a STA entry)
+                   send them with AP rate policies, otherwise use default
+                   basic rates */
+                if (control->control.sta)
+                        rate_idx = ACX_TX_AP_FULL_RATE;
+                else
+                        rate_idx = ACX_TX_BASIC_RATE;
+        } else {
+                desc->hlid = hlid;
+                switch (hlid) {
+                case WL1271_AP_GLOBAL_HLID:
+                        rate_idx = ACX_TX_AP_MODE_MGMT_RATE;
+                        break;
+                case WL1271_AP_BROADCAST_HLID:
+                        rate_idx = ACX_TX_AP_MODE_BCST_RATE;
+                        break;
+                default:
+                        rate_idx = ac;
+                        break;
+                }
+        }
+
+        tx_attr |= rate_idx << TX_HW_ATTR_OFST_RATE_POLICY;
+        desc->reserved = 0;
+
+        aligned_len = wl12xx_calc_packet_alignment(wl, skb->len);
+
+        if (wl->chip.id == CHIP_ID_1283_PG20) {
+                desc->wl128x_mem.extra_bytes = aligned_len - skb->len;
+                desc->length = cpu_to_le16(aligned_len >> 2);
+
+                wl1271_debug(DEBUG_TX, "tx_fill_hdr: hlid: %d "
+                             "tx_attr: 0x%x len: %d life: %d mem: %d",
+                             desc->hlid, tx_attr,
+                             le16_to_cpu(desc->length),
+                             le16_to_cpu(desc->life_time),
+                             desc->wl128x_mem.total_mem_blocks);
+        } else {
+                int pad;
+
+                /* Store the aligned length in terms of words */
+                desc->length = cpu_to_le16(aligned_len >> 2);
+
+                /* calculate number of padding bytes */
+                pad = aligned_len - skb->len;
+                tx_attr |= pad << TX_HW_ATTR_OFST_LAST_WORD_PAD;
+
+                wl1271_debug(DEBUG_TX, "tx_fill_hdr: pad: %d hlid: %d "
+                             "tx_attr: 0x%x len: %d life: %d mem: %d", pad,
+                             desc->hlid, tx_attr,
+                             le16_to_cpu(desc->length),
+                             le16_to_cpu(desc->life_time),
+                             desc->wl127x_mem.total_mem_blocks);
+        }
+
+        desc->tx_attr = cpu_to_le16(tx_attr);
+}
+
+/* caller must hold wl->mutex */
+static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct sk_buff *skb,
+                                                        u32 buf_offset)
+{
+        struct ieee80211_tx_info *info;
+        u32 extra = 0;
+        int ret = 0;
+        u32 total_len;
+        u8 hlid;
+
+        if (!skb)
+                return -EINVAL;
+
+        info = IEEE80211_SKB_CB(skb);
+
+        if (info->control.hw_key &&
+            info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP)
+                extra = WL1271_TKIP_IV_SPACE;
+
+        if (info->control.hw_key) {
+                bool is_wep;
+                u8 idx = info->control.hw_key->hw_key_idx;
+                u32 cipher = info->control.hw_key->cipher;
+
+                is_wep = (cipher == WLAN_CIPHER_SUITE_WEP40) ||
+                         (cipher == WLAN_CIPHER_SUITE_WEP104);
+
+                if (unlikely(is_wep && wl->default_key != idx)) {
+                        ret = wl1271_set_default_wep_key(wl, idx);
+                        if (ret < 0)
+                                return ret;
+                        wl->default_key = idx;
+                }
+        }
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS)
+                hlid = wl1271_tx_get_hlid(skb);
+        else
+                hlid = TX_HW_DEFAULT_AID;
+
+        ret = wl1271_tx_allocate(wl, skb, extra, buf_offset, hlid);
+        if (ret < 0)
+                return ret;
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS) {
+                wl1271_tx_ap_update_inconnection_sta(wl, skb);
+                wl1271_tx_regulate_link(wl, hlid);
+        } else {
+                wl1271_tx_update_filters(wl, skb);
+        }
+
+        wl1271_tx_fill_hdr(wl, skb, extra, info, hlid);
+
+        /*
+         * The length of each packet is stored in terms of
+         * words. Thus, we must pad the skb data to make sure its
+         * length is aligned.  The number of padding bytes is computed
+         * and set in wl1271_tx_fill_hdr.
+         * In special cases, we want to align to a specific block size
+         * (eg. for wl128x with SDIO we align to 256).
+         */
+        total_len = wl12xx_calc_packet_alignment(wl, skb->len);
+
+        memcpy(wl->aggr_buf + buf_offset, skb->data, skb->len);
+        memset(wl->aggr_buf + buf_offset + skb->len, 0, total_len - skb->len);
+
+        /* Revert side effects in the dummy packet skb, so it can be reused */
+        if (wl12xx_is_dummy_packet(wl, skb))
+                skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
+
+        return total_len;
+}
+
+u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set)
+{
+        struct ieee80211_supported_band *band;
+        u32 enabled_rates = 0;
+        int bit;
+
+        band = wl->hw->wiphy->bands[wl->band];
+        for (bit = 0; bit < band->n_bitrates; bit++) {
+                if (rate_set & 0x1)
+                        enabled_rates |= band->bitrates[bit].hw_value;
+                rate_set >>= 1;
+        }
+
+#ifdef CONFIG_WL12XX_HT
+        /* MCS rates indication are on bits 16 - 23 */
+        rate_set >>= HW_HT_RATES_OFFSET - band->n_bitrates;
+
+        for (bit = 0; bit < 8; bit++) {
+                if (rate_set & 0x1)
+                        enabled_rates |= (CONF_HW_BIT_RATE_MCS_0 << bit);
+                rate_set >>= 1;
+        }
+#endif
+
+        return enabled_rates;
+}
+
+void wl1271_handle_tx_low_watermark(struct wl1271 *wl)
+{
+        unsigned long flags;
+
+        if (test_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags) &&
+            wl->tx_queue_count <= WL1271_TX_QUEUE_LOW_WATERMARK) {
+                /* firmware buffer has space, restart queues */
+                spin_lock_irqsave(&wl->wl_lock, flags);
+                ieee80211_wake_queues(wl->hw);
+                clear_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
+                spin_unlock_irqrestore(&wl->wl_lock, flags);
+        }
+}
+
+static struct sk_buff *wl1271_sta_skb_dequeue(struct wl1271 *wl)
+{
+        struct sk_buff *skb = NULL;
+        unsigned long flags;
+
+        skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_VO]);
+        if (skb)
+                goto out;
+        skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_VI]);
+        if (skb)
+                goto out;
+        skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_BE]);
+        if (skb)
+                goto out;
+        skb = skb_dequeue(&wl->tx_queue[CONF_TX_AC_BK]);
+
+out:
+        if (skb) {
+                spin_lock_irqsave(&wl->wl_lock, flags);
+                wl->tx_queue_count--;
+                spin_unlock_irqrestore(&wl->wl_lock, flags);
+        }
+
+        return skb;
+}
+
+static struct sk_buff *wl1271_ap_skb_dequeue(struct wl1271 *wl)
+{
+        struct sk_buff *skb = NULL;
+        unsigned long flags;
+        int i, h, start_hlid;
+
+        /* start from the link after the last one */
+        start_hlid = (wl->last_tx_hlid + 1) % AP_MAX_LINKS;
+
+        /* dequeue according to AC, round robin on each link */
+        for (i = 0; i < AP_MAX_LINKS; i++) {
+                h = (start_hlid + i) % AP_MAX_LINKS;
+
+                skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_VO]);
+                if (skb)
+                        goto out;
+                skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_VI]);
+                if (skb)
+                        goto out;
+                skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_BE]);
+                if (skb)
+                        goto out;
+                skb = skb_dequeue(&wl->links[h].tx_queue[CONF_TX_AC_BK]);
+                if (skb)
+                        goto out;
+        }
+
+out:
+        if (skb) {
+                wl->last_tx_hlid = h;
+                spin_lock_irqsave(&wl->wl_lock, flags);
+                wl->tx_queue_count--;
+                spin_unlock_irqrestore(&wl->wl_lock, flags);
+        } else {
+                wl->last_tx_hlid = 0;
+        }
+
+        return skb;
+}
+
+static struct sk_buff *wl1271_skb_dequeue(struct wl1271 *wl)
+{
+        unsigned long flags;
+        struct sk_buff *skb = NULL;
+
+        if (wl->bss_type == BSS_TYPE_AP_BSS)
+                skb = wl1271_ap_skb_dequeue(wl);
+        else
+                skb = wl1271_sta_skb_dequeue(wl);
+
+        if (!skb &&
+            test_and_clear_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags)) {
+                skb = wl->dummy_packet;
+                spin_lock_irqsave(&wl->wl_lock, flags);
+                wl->tx_queue_count--;
+                spin_unlock_irqrestore(&wl->wl_lock, flags);
+        }
+
+        return skb;
+}
+
+static void wl1271_skb_queue_head(struct wl1271 *wl, struct sk_buff *skb)
+{
+        unsigned long flags;
+        int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
+
+        if (wl12xx_is_dummy_packet(wl, skb)) {
+                set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
+        } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
+                u8 hlid = wl1271_tx_get_hlid(skb);
+                skb_queue_head(&wl->links[hlid].tx_queue[q], skb);
+
+                /* make sure we dequeue the same packet next time */
+                wl->last_tx_hlid = (hlid + AP_MAX_LINKS - 1) % AP_MAX_LINKS;
+        } else {
+                skb_queue_head(&wl->tx_queue[q], skb);
+        }
+
+        spin_lock_irqsave(&wl->wl_lock, flags);
+        wl->tx_queue_count++;
+        spin_unlock_irqrestore(&wl->wl_lock, flags);
+}
+
+void wl1271_tx_work_locked(struct wl1271 *wl)
+{
+        struct sk_buff *skb;
+        u32 buf_offset = 0;
+        bool sent_packets = false;
+        int ret;
+
+        if (unlikely(wl->state == WL1271_STATE_OFF))
+                return;
+
+        while ((skb = wl1271_skb_dequeue(wl))) {
+                ret = wl1271_prepare_tx_frame(wl, skb, buf_offset);
+                if (ret == -EAGAIN) {
+                        /*
+                         * Aggregation buffer is full.
+                         * Flush buffer and try again.
+                         */
+                        wl1271_skb_queue_head(wl, skb);
+                        wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
+                                     buf_offset, true);
+                        sent_packets = true;
+                        buf_offset = 0;
+                        continue;
+                } else if (ret == -EBUSY) {
+                        /*
+                         * Firmware buffer is full.
+                         * Queue back last skb, and stop aggregating.
+                         */
+                        wl1271_skb_queue_head(wl, skb);
+                        /* No work left, avoid scheduling redundant tx work */
+                        set_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
+                        goto out_ack;
+                } else if (ret < 0) {
+                        dev_kfree_skb(skb);
+                        goto out_ack;
+                }
+                buf_offset += ret;
+                wl->tx_packets_count++;
+        }
+
+out_ack:
+        if (buf_offset) {
+                wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
+                                buf_offset, true);
+                sent_packets = true;
+        }
+        if (sent_packets) {
+                /*
+                 * Interrupt the firmware with the new packets. This is only
+                 * required for older hardware revisions
+                 */
+                if (wl->quirks & WL12XX_QUIRK_END_OF_TRANSACTION)
+                        wl1271_write32(wl, WL1271_HOST_WR_ACCESS,
+                                       wl->tx_packets_count);
+
+                wl1271_handle_tx_low_watermark(wl);
+        }
+}
+
+void wl1271_tx_work(struct work_struct *work)
+{
+        struct wl1271 *wl = container_of(work, struct wl1271, tx_work);
+        int ret;
+
+        mutex_lock(&wl->mutex);
+        ret = wl1271_ps_elp_wakeup(wl);
+        if (ret < 0)
+                goto out;
+
+        wl1271_tx_work_locked(wl);
+
+        wl1271_ps_elp_sleep(wl);
+out:
+        mutex_unlock(&wl->mutex);
+}
+
+static void wl1271_tx_complete_packet(struct wl1271 *wl,
+                                      struct wl1271_tx_hw_res_descr *result)
+{
+        struct ieee80211_tx_info *info;
+        struct sk_buff *skb;
+        int id = result->id;
+        int rate = -1;
+        u8 retries = 0;
+
+        /* check for id legality */
+        if (unlikely(id >= ACX_TX_DESCRIPTORS || wl->tx_frames[id] == NULL)) {
+                wl1271_warning("TX result illegal id: %d", id);
+                return;
+        }
+
+        skb = wl->tx_frames[id];
+        info = IEEE80211_SKB_CB(skb);
+
+        if (wl12xx_is_dummy_packet(wl, skb)) {
+                wl1271_free_tx_id(wl, id);
+                return;
+        }
+
+        /* update the TX status info */
+        if (result->status == TX_SUCCESS) {
+                if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
+                        info->flags |= IEEE80211_TX_STAT_ACK;
+                rate = wl1271_rate_to_idx(result->rate_class_index, wl->band);
+                retries = result->ack_failures;
+        } else if (result->status == TX_RETRY_EXCEEDED) {
+                wl->stats.excessive_retries++;
+                retries = result->ack_failures;
+        }
+
+        info->status.rates[0].idx = rate;
+        info->status.rates[0].count = retries;
+        info->status.rates[0].flags = 0;
+        info->status.ack_signal = -1;
+
+        wl->stats.retry_count += result->ack_failures;
+
+        /* update security sequence number */
+        wl->tx_security_seq += (result->lsb_security_sequence_number -
+                                wl->tx_security_last_seq);
+        wl->tx_security_last_seq = result->lsb_security_sequence_number;
+
+        /* remove private header from packet */
+        skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
+
+        /* remove TKIP header space if present */
+        if (info->control.hw_key &&
+            info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) {
+                int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
+                memmove(skb->data + WL1271_TKIP_IV_SPACE, skb->data, hdrlen);
+                skb_pull(skb, WL1271_TKIP_IV_SPACE);
+        }
+
+        wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
+                     " status 0x%x",
+                     result->id, skb, result->ack_failures,
+                     result->rate_class_index, result->status);
+
+        /* return the packet to the stack */
+        skb_queue_tail(&wl->deferred_tx_queue, skb);
+        ieee80211_queue_work(wl->hw, &wl->netstack_work);
+        wl1271_free_tx_id(wl, result->id);
+}
+
+/* Called upon reception of a TX complete interrupt */
+void wl1271_tx_complete(struct wl1271 *wl)
+{
+        struct wl1271_acx_mem_map *memmap =
+                (struct wl1271_acx_mem_map *)wl->target_mem_map;
+        u32 count, fw_counter;
+        u32 i;
+
+        /* read the tx results from the chipset */
+        wl1271_read(wl, le32_to_cpu(memmap->tx_result),
+                    wl->tx_res_if, sizeof(*wl->tx_res_if), false);
+        fw_counter = le32_to_cpu(wl->tx_res_if->tx_result_fw_counter);
+
+        /* write host counter to chipset (to ack) */
+        wl1271_write32(wl, le32_to_cpu(memmap->tx_result) +
+                       offsetof(struct wl1271_tx_hw_res_if,
+                                tx_result_host_counter), fw_counter);
+
+        count = fw_counter - wl->tx_results_count;
+        wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d", count);
+
+        /* verify that the result buffer is not getting overrun */
+        if (unlikely(count > TX_HW_RESULT_QUEUE_LEN))
+                wl1271_warning("TX result overflow from chipset: %d", count);
+
+        /* process the results */
+        for (i = 0; i < count; i++) {
+                struct wl1271_tx_hw_res_descr *result;
+                u8 offset = wl->tx_results_count & TX_HW_RESULT_QUEUE_LEN_MASK;
+
+                /* process the packet */
+                result =  &(wl->tx_res_if->tx_results_queue[offset]);
+                wl1271_tx_complete_packet(wl, result);
+
+                wl->tx_results_count++;
+        }
+}
+
+void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid)
+{
+        struct sk_buff *skb;
+        int i, total = 0;
+        unsigned long flags;
+        struct ieee80211_tx_info *info;
+
+        for (i = 0; i < NUM_TX_QUEUES; i++) {
+                while ((skb = skb_dequeue(&wl->links[hlid].tx_queue[i]))) {
+                        wl1271_debug(DEBUG_TX, "link freeing skb 0x%p", skb);
+                        info = IEEE80211_SKB_CB(skb);
+                        info->status.rates[0].idx = -1;
+                        info->status.rates[0].count = 0;
+                        ieee80211_tx_status(wl->hw, skb);
+                        total++;
+                }
+        }
+
+        spin_lock_irqsave(&wl->wl_lock, flags);
+        wl->tx_queue_count -= total;
+        spin_unlock_irqrestore(&wl->wl_lock, flags);
+
+        wl1271_handle_tx_low_watermark(wl);
+}
+
+/* caller must hold wl->mutex and TX must be stopped */
+void wl1271_tx_reset(struct wl1271 *wl, bool reset_tx_queues)
+{
+        int i;
+        struct sk_buff *skb;
+        struct ieee80211_tx_info *info;
+
+        /* TX failure */
+        if (wl->bss_type == BSS_TYPE_AP_BSS) {
+                for (i = 0; i < AP_MAX_LINKS; i++) {
+                        wl1271_tx_reset_link_queues(wl, i);
+                        wl->links[i].allocated_blks = 0;
+                        wl->links[i].prev_freed_blks = 0;
+                }
+
+                wl->last_tx_hlid = 0;
+        } else {
+                for (i = 0; i < NUM_TX_QUEUES; i++) {
+                        while ((skb = skb_dequeue(&wl->tx_queue[i]))) {
+                                wl1271_debug(DEBUG_TX, "freeing skb 0x%p",
+                                             skb);
+
+                                if (!wl12xx_is_dummy_packet(wl, skb)) {
+                                        info = IEEE80211_SKB_CB(skb);
+                                        info->status.rates[0].idx = -1;
+                                        info->status.rates[0].count = 0;
+                                        ieee80211_tx_status(wl->hw, skb);
+                                }
+                        }
+                }
+        }
+
+        wl->tx_queue_count = 0;
+
+        /*
+         * Make sure the driver is at a consistent state, in case this
+         * function is called from a context other than interface removal.
+         * This call will always wake the TX queues.
+         */
+        if (reset_tx_queues)
+                wl1271_handle_tx_low_watermark(wl);
+
+        for (i = 0; i < ACX_TX_DESCRIPTORS; i++) {
+                if (wl->tx_frames[i] == NULL)
+                        continue;
+
+                skb = wl->tx_frames[i];
+                wl1271_free_tx_id(wl, i);
+                wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb);
+
+                if (!wl12xx_is_dummy_packet(wl, skb)) {
+                        /*
+                         * Remove private headers before passing the skb to
+                         * mac80211
+                         */
+                        info = IEEE80211_SKB_CB(skb);
+                        skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
+                        if (info->control.hw_key &&
+                            info->control.hw_key->cipher ==
+                            WLAN_CIPHER_SUITE_TKIP) {
+                                int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
+                                memmove(skb->data + WL1271_TKIP_IV_SPACE,
+                                        skb->data, hdrlen);
+                                skb_pull(skb, WL1271_TKIP_IV_SPACE);
+                        }
+
+                        info->status.rates[0].idx = -1;
+                        info->status.rates[0].count = 0;
+
+                        ieee80211_tx_status(wl->hw, skb);
+                }
+        }
+}
+
+#define WL1271_TX_FLUSH_TIMEOUT 500000
+
+/* caller must *NOT* hold wl->mutex */
+void wl1271_tx_flush(struct wl1271 *wl)
+{
+        unsigned long timeout;
+        timeout = jiffies + usecs_to_jiffies(WL1271_TX_FLUSH_TIMEOUT);
+
+        while (!time_after(jiffies, timeout)) {
+                mutex_lock(&wl->mutex);
+                wl1271_debug(DEBUG_TX, "flushing tx buffer: %d %d",
+                             wl->tx_frames_cnt, wl->tx_queue_count);
+                if ((wl->tx_frames_cnt == 0) && (wl->tx_queue_count == 0)) {
+                        mutex_unlock(&wl->mutex);
+                        return;
+                }
+                mutex_unlock(&wl->mutex);
+                msleep(1);
+        }
+
+        wl1271_warning("Unable to flush all TX buffers, timed out.");
+}
+
+u32 wl1271_tx_min_rate_get(struct wl1271 *wl)
+{
+        int i;
+        u32 rate = 0;
+
+        if (!wl->basic_rate_set) {
+                WARN_ON(1);
+                wl->basic_rate_set = wl->conf.tx.basic_rate;
+        }
+
+        for (i = 0; !rate; i++) {
+                if ((wl->basic_rate_set >> i) & 0x1)
+                        rate = 1 << i;
+        }
+
+        return rate;
+}
diff --git a/drivers/net/wireless/wl12xx/wl1271_tx.h b/drivers/net/wireless/wl12xx/tx.h
index 48bf92621c03..832f9258d675 100644
--- a/drivers/net/wireless/wl12xx/wl1271_tx.h
+++ b/drivers/net/wireless/wl12xx/tx.h
@@ -22,13 +22,13 @@
  *
  */
 
-#ifndef __WL1271_TX_H__
-#define __WL1271_TX_H__
+#ifndef __TX_H__
+#define __TX_H__
 
-#define TX_HW_BLOCK_SPARE                2
 #define TX_HW_BLOCK_SIZE                 252
 
 #define TX_HW_MGMT_PKT_LIFETIME_TU       2000
+#define TX_HW_AP_MODE_PKT_LIFETIME_TU    8000
 /* The chipset reference driver states, that the "aid" value 1
  * is for infra-BSS, but is still always used */
 #define TX_HW_DEFAULT_AID                1
@@ -40,6 +40,7 @@
                                           BIT(8) | BIT(9))
 #define TX_HW_ATTR_LAST_WORD_PAD         (BIT(10) | BIT(11))
 #define TX_HW_ATTR_TX_CMPLT_REQ          BIT(12)
+#define TX_HW_ATTR_TX_DUMMY_REQ          BIT(13)
 
 #define TX_HW_ATTR_OFST_SAVE_RETRIES     0
 #define TX_HW_ATTR_OFST_HEADER_PAD       1
@@ -52,24 +53,62 @@
 #define TX_HW_RESULT_QUEUE_LEN_MASK      0xf
 
 #define WL1271_TX_ALIGN_TO 4
-#define WL1271_TX_ALIGN(len) (((len) + WL1271_TX_ALIGN_TO - 1) & \
-                             ~(WL1271_TX_ALIGN_TO - 1))
 #define WL1271_TKIP_IV_SPACE 4
 
+/* Used for management frames and dummy packets */
+#define WL1271_TID_MGMT 7
+
+struct wl127x_tx_mem {
+        /*
+         * Number of extra memory blocks to allocate for this packet
+         * in addition to the number of blocks derived from the packet
+         * length.
+         */
+        u8 extra_blocks;
+        /*
+         * Total number of memory blocks allocated by the host for
+         * this packet. Must be equal or greater than the actual
+         * blocks number allocated by HW.
+         */
+        u8 total_mem_blocks;
+} __packed;
+
+struct wl128x_tx_mem {
+        /*
+         * Total number of memory blocks allocated by the host for
+         * this packet.
+         */
+        u8 total_mem_blocks;
+        /*
+         * Number of extra bytes, at the end of the frame. the host
+         * uses this padding to complete each frame to integer number
+         * of SDIO blocks.
+         */
+        u8 extra_bytes;
+} __packed;
+
+/*
+ * On wl128x based devices, when TX packets are aggregated, each packet
+ * size must be aligned to the SDIO block size. The maximum block size
+ * is bounded by the type of the padded bytes field that is sent to the
+ * FW. Currently the type is u8, so the maximum block size is 256 bytes.
+ */
+#define WL12XX_BUS_BLOCK_SIZE min(512u, \
+            (1u << (8 * sizeof(((struct wl128x_tx_mem *) 0)->extra_bytes))))
+
 struct wl1271_tx_hw_descr {
         /* Length of packet in words, including descriptor+header+data */
         __le16 length;
-        /* Number of extra memory blocks to allocate for this packet in
-           addition to the number of blocks derived from the packet length */
-        u8 extra_mem_blocks;
-        /* Total number of memory blocks allocated by the host for this packet.
-           Must be equal or greater than the actual blocks number allocated by
-           HW!! */
-        u8 total_mem_blocks;
+        union {
+                struct wl127x_tx_mem wl127x_mem;
+                struct wl128x_tx_mem wl128x_mem;
+        } __packed;
         /* Device time (in us) when the packet arrived to the driver */
         __le32 start_time;
-        /* Max delay in TUs until transmission. The last device time the
-           packet can be transmitted is: startTime+(1024*LifeTime) */
+        /*
+         * Max delay in TUs until transmission. The last device time the
+         * packet can be transmitted is: start_time + (1024 * life_time)
+         */
         __le16 life_time;
         /* Bitwise fields - see TX_ATTR... definitions above. */
         __le16 tx_attr;
@@ -77,8 +116,12 @@ struct wl1271_tx_hw_descr {
         u8 id;
         /* The packet TID value (as User-Priority) */
         u8 tid;
-        /* Identifier of the remote STA in IBSS, 1 in infra-BSS */
-        u8 aid;
+        union {
+                /* STA - Identifier of the remote STA in IBSS, 1 in infra-BSS */
+                u8 aid;
+                /* AP - host link ID (HLID) */
+                u8 hlid;
+        } __packed;
         u8 reserved;
 } __packed;
 
@@ -139,28 +182,16 @@ static inline int wl1271_tx_get_queue(int queue)
         }
 }
 
-/* wl1271 tx descriptor needs the tid and we need to convert it from ac */
-static inline int wl1271_tx_ac_to_tid(int ac)
-{
-        switch (ac) {
-        case 0:
-                return 0;
-        case 1:
-                return 2;
-        case 2:
-                return 4;
-        case 3:
-                return 6;
-        default:
-                return 0;
-        }
-}
-
 void wl1271_tx_work(struct work_struct *work);
+void wl1271_tx_work_locked(struct wl1271 *wl);
 void wl1271_tx_complete(struct wl1271 *wl);
-void wl1271_tx_reset(struct wl1271 *wl);
+void wl1271_tx_reset(struct wl1271 *wl, bool reset_tx_queues);
 void wl1271_tx_flush(struct wl1271 *wl);
-u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate);
+u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band);
 u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set);
+u32 wl1271_tx_min_rate_get(struct wl1271 *wl);
+u8 wl1271_tx_get_hlid(struct sk_buff *skb);
+void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid);
+void wl1271_handle_tx_low_watermark(struct wl1271 *wl);
 
 #endif
diff --git a/drivers/net/wireless/wl12xx/wl1251.h b/drivers/net/wireless/wl12xx/wl1251.h
deleted file mode 100644
index 6b942a28e6a5..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251.h
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008-2009 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_H__
-#define __WL1251_H__
-
-#include <linux/mutex.h>
-#include <linux/list.h>
-#include <linux/bitops.h>
-#include <net/mac80211.h>
-
-#define DRIVER_NAME "wl1251"
-#define DRIVER_PREFIX DRIVER_NAME ": "
-
-enum {
-        DEBUG_NONE      = 0,
-        DEBUG_IRQ       = BIT(0),
-        DEBUG_SPI       = BIT(1),
-        DEBUG_BOOT      = BIT(2),
-        DEBUG_MAILBOX   = BIT(3),
-        DEBUG_NETLINK   = BIT(4),
-        DEBUG_EVENT     = BIT(5),
-        DEBUG_TX        = BIT(6),
-        DEBUG_RX        = BIT(7),
-        DEBUG_SCAN      = BIT(8),
-        DEBUG_CRYPT     = BIT(9),
-        DEBUG_PSM       = BIT(10),
-        DEBUG_MAC80211  = BIT(11),
-        DEBUG_CMD       = BIT(12),
-        DEBUG_ACX       = BIT(13),
-        DEBUG_ALL       = ~0,
-};
-
-#define DEBUG_LEVEL (DEBUG_NONE)
-
-#define DEBUG_DUMP_LIMIT 1024
-
-#define wl1251_error(fmt, arg...) \
-        printk(KERN_ERR DRIVER_PREFIX "ERROR " fmt "\n", ##arg)
-
-#define wl1251_warning(fmt, arg...) \
-        printk(KERN_WARNING DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
-
-#define wl1251_notice(fmt, arg...) \
-        printk(KERN_INFO DRIVER_PREFIX fmt "\n", ##arg)
-
-#define wl1251_info(fmt, arg...) \
-        printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg)
-
-#define wl1251_debug(level, fmt, arg...) \
-        do { \
-                if (level & DEBUG_LEVEL) \
-                        printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg); \
-        } while (0)
-
-#define wl1251_dump(level, prefix, buf, len)    \
-        do { \
-                if (level & DEBUG_LEVEL) \
-                        print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
-                                       DUMP_PREFIX_OFFSET, 16, 1,       \
-                                       buf,                             \
-                                       min_t(size_t, len, DEBUG_DUMP_LIMIT), \
-                                       0);                              \
-        } while (0)
-
-#define wl1251_dump_ascii(level, prefix, buf, len)      \
-        do { \
-                if (level & DEBUG_LEVEL) \
-                        print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
-                                       DUMP_PREFIX_OFFSET, 16, 1,       \
-                                       buf,                             \
-                                       min_t(size_t, len, DEBUG_DUMP_LIMIT), \
-                                       true);                           \
-        } while (0)
-
-#define WL1251_DEFAULT_RX_CONFIG (CFG_UNI_FILTER_EN |   \
-                                  CFG_BSSID_FILTER_EN)
-
-#define WL1251_DEFAULT_RX_FILTER (CFG_RX_PRSP_EN |  \
-                                  CFG_RX_MGMT_EN |  \
-                                  CFG_RX_DATA_EN |  \
-                                  CFG_RX_CTL_EN |   \
-                                  CFG_RX_BCN_EN |   \
-                                  CFG_RX_AUTH_EN |  \
-                                  CFG_RX_ASSOC_EN)
-
-#define WL1251_BUSY_WORD_LEN 8
-
-struct boot_attr {
-        u32 radio_type;
-        u8 mac_clock;
-        u8 arm_clock;
-        int firmware_debug;
-        u32 minor;
-        u32 major;
-        u32 bugfix;
-};
-
-enum wl1251_state {
-        WL1251_STATE_OFF,
-        WL1251_STATE_ON,
-        WL1251_STATE_PLT,
-};
-
-enum wl1251_partition_type {
-        PART_DOWN,
-        PART_WORK,
-        PART_DRPW,
-
-        PART_TABLE_LEN
-};
-
-struct wl1251_partition {
-        u32 size;
-        u32 start;
-};
-
-struct wl1251_partition_set {
-        struct wl1251_partition mem;
-        struct wl1251_partition reg;
-};
-
-struct wl1251;
-
-struct wl1251_stats {
-        struct acx_statistics *fw_stats;
-        unsigned long fw_stats_update;
-
-        unsigned int retry_count;
-        unsigned int excessive_retries;
-};
-
-struct wl1251_debugfs {
-        struct dentry *rootdir;
-        struct dentry *fw_statistics;
-
-        struct dentry *tx_internal_desc_overflow;
-
-        struct dentry *rx_out_of_mem;
-        struct dentry *rx_hdr_overflow;
-        struct dentry *rx_hw_stuck;
-        struct dentry *rx_dropped;
-        struct dentry *rx_fcs_err;
-        struct dentry *rx_xfr_hint_trig;
-        struct dentry *rx_path_reset;
-        struct dentry *rx_reset_counter;
-
-        struct dentry *dma_rx_requested;
-        struct dentry *dma_rx_errors;
-        struct dentry *dma_tx_requested;
-        struct dentry *dma_tx_errors;
-
-        struct dentry *isr_cmd_cmplt;
-        struct dentry *isr_fiqs;
-        struct dentry *isr_rx_headers;
-        struct dentry *isr_rx_mem_overflow;
-        struct dentry *isr_rx_rdys;
-        struct dentry *isr_irqs;
-        struct dentry *isr_tx_procs;
-        struct dentry *isr_decrypt_done;
-        struct dentry *isr_dma0_done;
-        struct dentry *isr_dma1_done;
-        struct dentry *isr_tx_exch_complete;
-        struct dentry *isr_commands;
-        struct dentry *isr_rx_procs;
-        struct dentry *isr_hw_pm_mode_changes;
-        struct dentry *isr_host_acknowledges;
-        struct dentry *isr_pci_pm;
-        struct dentry *isr_wakeups;
-        struct dentry *isr_low_rssi;
-
-        struct dentry *wep_addr_key_count;
-        struct dentry *wep_default_key_count;
-        /* skipping wep.reserved */
-        struct dentry *wep_key_not_found;
-        struct dentry *wep_decrypt_fail;
-        struct dentry *wep_packets;
-        struct dentry *wep_interrupt;
-
-        struct dentry *pwr_ps_enter;
-        struct dentry *pwr_elp_enter;
-        struct dentry *pwr_missing_bcns;
-        struct dentry *pwr_wake_on_host;
-        struct dentry *pwr_wake_on_timer_exp;
-        struct dentry *pwr_tx_with_ps;
-        struct dentry *pwr_tx_without_ps;
-        struct dentry *pwr_rcvd_beacons;
-        struct dentry *pwr_power_save_off;
-        struct dentry *pwr_enable_ps;
-        struct dentry *pwr_disable_ps;
-        struct dentry *pwr_fix_tsf_ps;
-        /* skipping cont_miss_bcns_spread for now */
-        struct dentry *pwr_rcvd_awake_beacons;
-
-        struct dentry *mic_rx_pkts;
-        struct dentry *mic_calc_failure;
-
-        struct dentry *aes_encrypt_fail;
-        struct dentry *aes_decrypt_fail;
-        struct dentry *aes_encrypt_packets;
-        struct dentry *aes_decrypt_packets;
-        struct dentry *aes_encrypt_interrupt;
-        struct dentry *aes_decrypt_interrupt;
-
-        struct dentry *event_heart_beat;
-        struct dentry *event_calibration;
-        struct dentry *event_rx_mismatch;
-        struct dentry *event_rx_mem_empty;
-        struct dentry *event_rx_pool;
-        struct dentry *event_oom_late;
-        struct dentry *event_phy_transmit_error;
-        struct dentry *event_tx_stuck;
-
-        struct dentry *ps_pspoll_timeouts;
-        struct dentry *ps_upsd_timeouts;
-        struct dentry *ps_upsd_max_sptime;
-        struct dentry *ps_upsd_max_apturn;
-        struct dentry *ps_pspoll_max_apturn;
-        struct dentry *ps_pspoll_utilization;
-        struct dentry *ps_upsd_utilization;
-
-        struct dentry *rxpipe_rx_prep_beacon_drop;
-        struct dentry *rxpipe_descr_host_int_trig_rx_data;
-        struct dentry *rxpipe_beacon_buffer_thres_host_int_trig_rx_data;
-        struct dentry *rxpipe_missed_beacon_host_int_trig_rx_data;
-        struct dentry *rxpipe_tx_xfr_host_int_trig_rx_data;
-
-        struct dentry *tx_queue_len;
-        struct dentry *tx_queue_status;
-
-        struct dentry *retry_count;
-        struct dentry *excessive_retries;
-};
-
-struct wl1251_if_operations {
-        void (*read)(struct wl1251 *wl, int addr, void *buf, size_t len);
-        void (*write)(struct wl1251 *wl, int addr, void *buf, size_t len);
-        void (*read_elp)(struct wl1251 *wl, int addr, u32 *val);
-        void (*write_elp)(struct wl1251 *wl, int addr, u32 val);
-        void (*reset)(struct wl1251 *wl);
-        void (*enable_irq)(struct wl1251 *wl);
-        void (*disable_irq)(struct wl1251 *wl);
-};
-
-struct wl1251 {
-        struct ieee80211_hw *hw;
-        bool mac80211_registered;
-
-        void *if_priv;
-        const struct wl1251_if_operations *if_ops;
-
-        void (*set_power)(bool enable);
-        int irq;
-        bool use_eeprom;
-
-        enum wl1251_state state;
-        struct mutex mutex;
-
-        int physical_mem_addr;
-        int physical_reg_addr;
-        int virtual_mem_addr;
-        int virtual_reg_addr;
-
-        int cmd_box_addr;
-        int event_box_addr;
-        struct boot_attr boot_attr;
-
-        u8 *fw;
-        size_t fw_len;
-        u8 *nvs;
-        size_t nvs_len;
-
-        u8 bssid[ETH_ALEN];
-        u8 mac_addr[ETH_ALEN];
-        u8 bss_type;
-        u8 listen_int;
-        int channel;
-
-        void *target_mem_map;
-        struct acx_data_path_params_resp *data_path;
-
-        /* Number of TX packets transferred to the FW, modulo 16 */
-        u32 data_in_count;
-
-        /* Frames scheduled for transmission, not handled yet */
-        struct sk_buff_head tx_queue;
-        bool tx_queue_stopped;
-
-        struct work_struct tx_work;
-        struct work_struct filter_work;
-
-        /* Pending TX frames */
-        struct sk_buff *tx_frames[16];
-
-        /*
-         * Index pointing to the next TX complete entry
-         * in the cyclic XT complete array we get from
-         * the FW.
-         */
-        u32 next_tx_complete;
-
-        /* FW Rx counter */
-        u32 rx_counter;
-
-        /* Rx frames handled */
-        u32 rx_handled;
-
-        /* Current double buffer */
-        u32 rx_current_buffer;
-        u32 rx_last_id;
-
-        /* The target interrupt mask */
-        u32 intr_mask;
-        struct work_struct irq_work;
-
-        /* The mbox event mask */
-        u32 event_mask;
-
-        /* Mailbox pointers */
-        u32 mbox_ptr[2];
-
-        /* Are we currently scanning */
-        bool scanning;
-
-        /* Default key (for WEP) */
-        u32 default_key;
-
-        unsigned int tx_mgmt_frm_rate;
-        unsigned int tx_mgmt_frm_mod;
-
-        unsigned int rx_config;
-        unsigned int rx_filter;
-
-        /* is firmware in elp mode */
-        bool elp;
-
-        struct delayed_work elp_work;
-
-        /* we can be in psm, but not in elp, we have to differentiate */
-        bool psm;
-
-        /* PSM mode requested */
-        bool psm_requested;
-
-        u16 beacon_int;
-        u8 dtim_period;
-
-        /* in dBm */
-        int power_level;
-
-        struct wl1251_stats stats;
-        struct wl1251_debugfs debugfs;
-
-        u32 buffer_32;
-        u32 buffer_cmd;
-        u8 buffer_busyword[WL1251_BUSY_WORD_LEN];
-        struct wl1251_rx_descriptor *rx_descriptor;
-
-        struct ieee80211_vif *vif;
-
-        u32 chip_id;
-        char fw_ver[21];
-
-        /* Most recently reported noise in dBm */
-        s8 noise;
-};
-
-int wl1251_plt_start(struct wl1251 *wl);
-int wl1251_plt_stop(struct wl1251 *wl);
-
-struct ieee80211_hw *wl1251_alloc_hw(void);
-int wl1251_free_hw(struct wl1251 *wl);
-int wl1251_init_ieee80211(struct wl1251 *wl);
-void wl1251_enable_interrupts(struct wl1251 *wl);
-void wl1251_disable_interrupts(struct wl1251 *wl);
-
-#define DEFAULT_HW_GEN_MODULATION_TYPE    CCK_LONG /* Long Preamble */
-#define DEFAULT_HW_GEN_TX_RATE          RATE_2MBPS
-#define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */
-
-#define WL1251_DEFAULT_POWER_LEVEL 20
-
-#define WL1251_TX_QUEUE_MAX_LENGTH 20
-
-#define WL1251_DEFAULT_BEACON_INT 100
-#define WL1251_DEFAULT_DTIM_PERIOD 1
-
-#define WL1251_DEFAULT_CHANNEL 0
-
-#define CHIP_ID_1251_PG10                  (0x7010101)
-#define CHIP_ID_1251_PG11                  (0x7020101)
-#define CHIP_ID_1251_PG12                  (0x7030101)
-#define CHIP_ID_1271_PG10                  (0x4030101)
-#define CHIP_ID_1271_PG20                  (0x4030111)
-
-#define WL1251_FW_NAME "wl1251-fw.bin"
-#define WL1251_NVS_NAME "wl1251-nvs.bin"
-
-#define WL1251_POWER_ON_SLEEP 10 /* in miliseconds */
-
-#define WL1251_PART_DOWN_MEM_START      0x0
-#define WL1251_PART_DOWN_MEM_SIZE       0x16800
-#define WL1251_PART_DOWN_REG_START      REGISTERS_BASE
-#define WL1251_PART_DOWN_REG_SIZE       REGISTERS_DOWN_SIZE
-
-#define WL1251_PART_WORK_MEM_START      0x28000
-#define WL1251_PART_WORK_MEM_SIZE       0x14000
-#define WL1251_PART_WORK_REG_START      REGISTERS_BASE
-#define WL1251_PART_WORK_REG_SIZE       REGISTERS_WORK_SIZE
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1251_acx.c b/drivers/net/wireless/wl12xx/wl1251_acx.c
deleted file mode 100644
index 91891f928070..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_acx.c
+++ /dev/null
@@ -1,1048 +0,0 @@
-#include "wl1251_acx.h"
-
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/crc7.h>
-
-#include "wl1251.h"
-#include "wl1251_reg.h"
-#include "wl1251_cmd.h"
-#include "wl1251_ps.h"
-
-int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
-                           u8 mgt_rate, u8 mgt_mod)
-{
-        struct acx_fw_gen_frame_rates *rates;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx frame rates");
-
-        rates = kzalloc(sizeof(*rates), GFP_KERNEL);
-        if (!rates) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        rates->tx_ctrl_frame_rate = ctrl_rate;
-        rates->tx_ctrl_frame_mod = ctrl_mod;
-        rates->tx_mgt_frame_rate = mgt_rate;
-        rates->tx_mgt_frame_mod = mgt_mod;
-
-        ret = wl1251_cmd_configure(wl, ACX_FW_GEN_FRAME_RATES,
-                                   rates, sizeof(*rates));
-        if (ret < 0) {
-                wl1251_error("Failed to set FW rates and modulation");
-                goto out;
-        }
-
-out:
-        kfree(rates);
-        return ret;
-}
-
-
-int wl1251_acx_station_id(struct wl1251 *wl)
-{
-        struct acx_dot11_station_id *mac;
-        int ret, i;
-
-        wl1251_debug(DEBUG_ACX, "acx dot11_station_id");
-
-        mac = kzalloc(sizeof(*mac), GFP_KERNEL);
-        if (!mac) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        for (i = 0; i < ETH_ALEN; i++)
-                mac->mac[i] = wl->mac_addr[ETH_ALEN - 1 - i];
-
-        ret = wl1251_cmd_configure(wl, DOT11_STATION_ID, mac, sizeof(*mac));
-        if (ret < 0)
-                goto out;
-
-out:
-        kfree(mac);
-        return ret;
-}
-
-int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id)
-{
-        struct acx_dot11_default_key *default_key;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx dot11_default_key (%d)", key_id);
-
-        default_key = kzalloc(sizeof(*default_key), GFP_KERNEL);
-        if (!default_key) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        default_key->id = key_id;
-
-        ret = wl1251_cmd_configure(wl, DOT11_DEFAULT_KEY,
-                                   default_key, sizeof(*default_key));
-        if (ret < 0) {
-                wl1251_error("Couldn't set default key");
-                goto out;
-        }
-
-        wl->default_key = key_id;
-
-out:
-        kfree(default_key);
-        return ret;
-}
-
-int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
-                                  u8 listen_interval)
-{
-        struct acx_wake_up_condition *wake_up;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx wake up conditions");
-
-        wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
-        if (!wake_up) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        wake_up->wake_up_event = wake_up_event;
-        wake_up->listen_interval = listen_interval;
-
-        ret = wl1251_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
-                                   wake_up, sizeof(*wake_up));
-        if (ret < 0) {
-                wl1251_warning("could not set wake up conditions: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(wake_up);
-        return ret;
-}
-
-int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth)
-{
-        struct acx_sleep_auth *auth;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx sleep auth");
-
-        auth = kzalloc(sizeof(*auth), GFP_KERNEL);
-        if (!auth) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        auth->sleep_auth = sleep_auth;
-
-        ret = wl1251_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
-        if (ret < 0)
-                return ret;
-
-out:
-        kfree(auth);
-        return ret;
-}
-
-int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len)
-{
-        struct acx_revision *rev;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx fw rev");
-
-        rev = kzalloc(sizeof(*rev), GFP_KERNEL);
-        if (!rev) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = wl1251_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
-        if (ret < 0) {
-                wl1251_warning("ACX_FW_REV interrogate failed");
-                goto out;
-        }
-
-        /* be careful with the buffer sizes */
-        strncpy(buf, rev->fw_version, min(len, sizeof(rev->fw_version)));
-
-        /*
-         * if the firmware version string is exactly
-         * sizeof(rev->fw_version) long or fw_len is less than
-         * sizeof(rev->fw_version) it won't be null terminated
-         */
-        buf[min(len, sizeof(rev->fw_version)) - 1] = '\0';
-
-out:
-        kfree(rev);
-        return ret;
-}
-
-int wl1251_acx_tx_power(struct wl1251 *wl, int power)
-{
-        struct acx_current_tx_power *acx;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
-
-        if (power < 0 || power > 25)
-                return -EINVAL;
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->current_tx_power = power * 10;
-
-        ret = wl1251_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("configure of tx power failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_feature_cfg(struct wl1251 *wl)
-{
-        struct acx_feature_config *feature;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx feature cfg");
-
-        feature = kzalloc(sizeof(*feature), GFP_KERNEL);
-        if (!feature) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* DF_ENCRYPTION_DISABLE and DF_SNIFF_MODE_ENABLE are disabled */
-        feature->data_flow_options = 0;
-        feature->options = 0;
-
-        ret = wl1251_cmd_configure(wl, ACX_FEATURE_CFG,
-                                   feature, sizeof(*feature));
-        if (ret < 0) {
-                wl1251_error("Couldn't set HW encryption");
-                goto out;
-        }
-
-out:
-        kfree(feature);
-        return ret;
-}
-
-int wl1251_acx_mem_map(struct wl1251 *wl, struct acx_header *mem_map,
-                       size_t len)
-{
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx mem map");
-
-        ret = wl1251_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_acx_data_path_params(struct wl1251 *wl,
-                                struct acx_data_path_params_resp *resp)
-{
-        struct acx_data_path_params *params;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx data path params");
-
-        params = kzalloc(sizeof(*params), GFP_KERNEL);
-        if (!params) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        params->rx_packet_ring_chunk_size = DP_RX_PACKET_RING_CHUNK_SIZE;
-        params->tx_packet_ring_chunk_size = DP_TX_PACKET_RING_CHUNK_SIZE;
-
-        params->rx_packet_ring_chunk_num = DP_RX_PACKET_RING_CHUNK_NUM;
-        params->tx_packet_ring_chunk_num = DP_TX_PACKET_RING_CHUNK_NUM;
-
-        params->tx_complete_threshold = 1;
-
-        params->tx_complete_ring_depth = FW_TX_CMPLT_BLOCK_SIZE;
-
-        params->tx_complete_timeout = DP_TX_COMPLETE_TIME_OUT;
-
-        ret = wl1251_cmd_configure(wl, ACX_DATA_PATH_PARAMS,
-                                   params, sizeof(*params));
-        if (ret < 0)
-                goto out;
-
-        /* FIXME: shouldn't this be ACX_DATA_PATH_RESP_PARAMS? */
-        ret = wl1251_cmd_interrogate(wl, ACX_DATA_PATH_PARAMS,
-                                     resp, sizeof(*resp));
-
-        if (ret < 0) {
-                wl1251_warning("failed to read data path parameters: %d", ret);
-                goto out;
-        } else if (resp->header.cmd.status != CMD_STATUS_SUCCESS) {
-                wl1251_warning("data path parameter acx status failed");
-                ret = -EIO;
-                goto out;
-        }
-
-out:
-        kfree(params);
-        return ret;
-}
-
-int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time)
-{
-        struct acx_rx_msdu_lifetime *acx;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx rx msdu life time");
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->lifetime = life_time;
-        ret = wl1251_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
-                                   acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("failed to set rx msdu life time: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter)
-{
-        struct acx_rx_config *rx_config;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx rx config");
-
-        rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
-        if (!rx_config) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        rx_config->config_options = config;
-        rx_config->filter_options = filter;
-
-        ret = wl1251_cmd_configure(wl, ACX_RX_CFG,
-                                   rx_config, sizeof(*rx_config));
-        if (ret < 0) {
-                wl1251_warning("failed to set rx config: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(rx_config);
-        return ret;
-}
-
-int wl1251_acx_pd_threshold(struct wl1251 *wl)
-{
-        struct acx_packet_detection *pd;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx data pd threshold");
-
-        pd = kzalloc(sizeof(*pd), GFP_KERNEL);
-        if (!pd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* FIXME: threshold value not set */
-
-        ret = wl1251_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
-        if (ret < 0) {
-                wl1251_warning("failed to set pd threshold: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(pd);
-        return 0;
-}
-
-int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time)
-{
-        struct acx_slot *slot;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx slot");
-
-        slot = kzalloc(sizeof(*slot), GFP_KERNEL);
-        if (!slot) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        slot->wone_index = STATION_WONE_INDEX;
-        slot->slot_time = slot_time;
-
-        ret = wl1251_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
-        if (ret < 0) {
-                wl1251_warning("failed to set slot time: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(slot);
-        return ret;
-}
-
-int wl1251_acx_group_address_tbl(struct wl1251 *wl)
-{
-        struct acx_dot11_grp_addr_tbl *acx;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx group address tbl");
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* MAC filtering */
-        acx->enabled = 0;
-        acx->num_groups = 0;
-        memset(acx->mac_table, 0, ADDRESS_GROUP_MAX_LEN);
-
-        ret = wl1251_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
-                                   acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("failed to set group addr table: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_service_period_timeout(struct wl1251 *wl)
-{
-        struct acx_rx_timeout *rx_timeout;
-        int ret;
-
-        rx_timeout = kzalloc(sizeof(*rx_timeout), GFP_KERNEL);
-        if (!rx_timeout) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        wl1251_debug(DEBUG_ACX, "acx service period timeout");
-
-        rx_timeout->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
-        rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_DEF;
-
-        ret = wl1251_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
-                                   rx_timeout, sizeof(*rx_timeout));
-        if (ret < 0) {
-                wl1251_warning("failed to set service period timeout: %d",
-                               ret);
-                goto out;
-        }
-
-out:
-        kfree(rx_timeout);
-        return ret;
-}
-
-int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold)
-{
-        struct acx_rts_threshold *rts;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx rts threshold");
-
-        rts = kzalloc(sizeof(*rts), GFP_KERNEL);
-        if (!rts) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        rts->threshold = rts_threshold;
-
-        ret = wl1251_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
-        if (ret < 0) {
-                wl1251_warning("failed to set rts threshold: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(rts);
-        return ret;
-}
-
-int wl1251_acx_beacon_filter_opt(struct wl1251 *wl, bool enable_filter)
-{
-        struct acx_beacon_filter_option *beacon_filter;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx beacon filter opt");
-
-        beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
-        if (!beacon_filter) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        beacon_filter->enable = enable_filter;
-        beacon_filter->max_num_beacons = 0;
-
-        ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
-                                   beacon_filter, sizeof(*beacon_filter));
-        if (ret < 0) {
-                wl1251_warning("failed to set beacon filter opt: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(beacon_filter);
-        return ret;
-}
-
-int wl1251_acx_beacon_filter_table(struct wl1251 *wl)
-{
-        struct acx_beacon_filter_ie_table *ie_table;
-        int idx = 0;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx beacon filter table");
-
-        ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
-        if (!ie_table) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* configure default beacon pass-through rules */
-        ie_table->num_ie = 1;
-        ie_table->table[idx++] = BEACON_FILTER_IE_ID_CHANNEL_SWITCH_ANN;
-        ie_table->table[idx++] = BEACON_RULE_PASS_ON_APPEARANCE;
-
-        ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
-                                   ie_table, sizeof(*ie_table));
-        if (ret < 0) {
-                wl1251_warning("failed to set beacon filter table: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(ie_table);
-        return ret;
-}
-
-int wl1251_acx_conn_monit_params(struct wl1251 *wl)
-{
-        struct acx_conn_monit_params *acx;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx connection monitor parameters");
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->synch_fail_thold = SYNCH_FAIL_DEFAULT_THRESHOLD;
-        acx->bss_lose_timeout = NO_BEACON_DEFAULT_TIMEOUT;
-
-        ret = wl1251_cmd_configure(wl, ACX_CONN_MONIT_PARAMS,
-                                   acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("failed to set connection monitor "
-                               "parameters: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_sg_enable(struct wl1251 *wl)
-{
-        struct acx_bt_wlan_coex *pta;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx sg enable");
-
-        pta = kzalloc(sizeof(*pta), GFP_KERNEL);
-        if (!pta) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        pta->enable = SG_ENABLE;
-
-        ret = wl1251_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
-        if (ret < 0) {
-                wl1251_warning("failed to set softgemini enable: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(pta);
-        return ret;
-}
-
-int wl1251_acx_sg_cfg(struct wl1251 *wl)
-{
-        struct acx_bt_wlan_coex_param *param;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx sg cfg");
-
-        param = kzalloc(sizeof(*param), GFP_KERNEL);
-        if (!param) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* BT-WLAN coext parameters */
-        param->min_rate = RATE_INDEX_24MBPS;
-        param->bt_hp_max_time = PTA_BT_HP_MAXTIME_DEF;
-        param->wlan_hp_max_time = PTA_WLAN_HP_MAX_TIME_DEF;
-        param->sense_disable_timer = PTA_SENSE_DISABLE_TIMER_DEF;
-        param->rx_time_bt_hp = PTA_PROTECTIVE_RX_TIME_DEF;
-        param->tx_time_bt_hp = PTA_PROTECTIVE_TX_TIME_DEF;
-        param->rx_time_bt_hp_fast = PTA_PROTECTIVE_RX_TIME_FAST_DEF;
-        param->tx_time_bt_hp_fast = PTA_PROTECTIVE_TX_TIME_FAST_DEF;
-        param->wlan_cycle_fast = PTA_CYCLE_TIME_FAST_DEF;
-        param->bt_anti_starvation_period = PTA_ANTI_STARVE_PERIOD_DEF;
-        param->next_bt_lp_packet = PTA_TIMEOUT_NEXT_BT_LP_PACKET_DEF;
-        param->wake_up_beacon = PTA_TIME_BEFORE_BEACON_DEF;
-        param->hp_dm_max_guard_time = PTA_HPDM_MAX_TIME_DEF;
-        param->next_wlan_packet = PTA_TIME_OUT_NEXT_WLAN_DEF;
-        param->antenna_type = PTA_ANTENNA_TYPE_DEF;
-        param->signal_type = PTA_SIGNALING_TYPE_DEF;
-        param->afh_leverage_on = PTA_AFH_LEVERAGE_ON_DEF;
-        param->quiet_cycle_num = PTA_NUMBER_QUIET_CYCLE_DEF;
-        param->max_cts = PTA_MAX_NUM_CTS_DEF;
-        param->wlan_packets_num = PTA_NUMBER_OF_WLAN_PACKETS_DEF;
-        param->bt_packets_num = PTA_NUMBER_OF_BT_PACKETS_DEF;
-        param->missed_rx_avalanche = PTA_RX_FOR_AVALANCHE_DEF;
-        param->wlan_elp_hp = PTA_ELP_HP_DEF;
-        param->bt_anti_starvation_cycles = PTA_ANTI_STARVE_NUM_CYCLE_DEF;
-        param->ack_mode_dual_ant = PTA_ACK_MODE_DEF;
-        param->pa_sd_enable = PTA_ALLOW_PA_SD_DEF;
-        param->pta_auto_mode_enable = PTA_AUTO_MODE_NO_CTS_DEF;
-        param->bt_hp_respected_num = PTA_BT_HP_RESPECTED_DEF;
-
-        ret = wl1251_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
-        if (ret < 0) {
-                wl1251_warning("failed to set sg config: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(param);
-        return ret;
-}
-
-int wl1251_acx_cca_threshold(struct wl1251 *wl)
-{
-        struct acx_energy_detection *detection;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx cca threshold");
-
-        detection = kzalloc(sizeof(*detection), GFP_KERNEL);
-        if (!detection) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D;
-        detection->tx_energy_detection = 0;
-
-        ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
-                                   detection, sizeof(*detection));
-        if (ret < 0) {
-                wl1251_warning("failed to set cca threshold: %d", ret);
-                return ret;
-        }
-
-out:
-        kfree(detection);
-        return ret;
-}
-
-int wl1251_acx_bcn_dtim_options(struct wl1251 *wl)
-{
-        struct acx_beacon_broadcast *bb;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx bcn dtim options");
-
-        bb = kzalloc(sizeof(*bb), GFP_KERNEL);
-        if (!bb) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        bb->beacon_rx_timeout = BCN_RX_TIMEOUT_DEF_VALUE;
-        bb->broadcast_timeout = BROADCAST_RX_TIMEOUT_DEF_VALUE;
-        bb->rx_broadcast_in_ps = RX_BROADCAST_IN_PS_DEF_VALUE;
-        bb->ps_poll_threshold = CONSECUTIVE_PS_POLL_FAILURE_DEF;
-
-        ret = wl1251_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
-        if (ret < 0) {
-                wl1251_warning("failed to set rx config: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(bb);
-        return ret;
-}
-
-int wl1251_acx_aid(struct wl1251 *wl, u16 aid)
-{
-        struct acx_aid *acx_aid;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx aid");
-
-        acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
-        if (!acx_aid) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx_aid->aid = aid;
-
-        ret = wl1251_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
-        if (ret < 0) {
-                wl1251_warning("failed to set aid: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx_aid);
-        return ret;
-}
-
-int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask)
-{
-        struct acx_event_mask *mask;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx event mbox mask");
-
-        mask = kzalloc(sizeof(*mask), GFP_KERNEL);
-        if (!mask) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* high event mask is unused */
-        mask->high_event_mask = 0xffffffff;
-
-        mask->event_mask = event_mask;
-
-        ret = wl1251_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
-                                   mask, sizeof(*mask));
-        if (ret < 0) {
-                wl1251_warning("failed to set acx_event_mbox_mask: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(mask);
-        return ret;
-}
-
-int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble)
-{
-        struct acx_preamble *acx;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx_set_preamble");
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->preamble = preamble;
-
-        ret = wl1251_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("Setting of preamble failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_cts_protect(struct wl1251 *wl,
-                           enum acx_ctsprotect_type ctsprotect)
-{
-        struct acx_ctsprotect *acx;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx_set_ctsprotect");
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->ctsprotect = ctsprotect;
-
-        ret = wl1251_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("Setting of ctsprotect failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_tsf_info(struct wl1251 *wl, u64 *mactime)
-{
-        struct acx_tsf_info *tsf_info;
-        int ret;
-
-        tsf_info = kzalloc(sizeof(*tsf_info), GFP_KERNEL);
-        if (!tsf_info) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = wl1251_cmd_interrogate(wl, ACX_TSF_INFO,
-                                     tsf_info, sizeof(*tsf_info));
-        if (ret < 0) {
-                wl1251_warning("ACX_FW_REV interrogate failed");
-                goto out;
-        }
-
-        *mactime = tsf_info->current_tsf_lsb |
-                (tsf_info->current_tsf_msb << 31);
-
-out:
-        kfree(tsf_info);
-        return ret;
-}
-
-int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats)
-{
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx statistics");
-
-        ret = wl1251_cmd_interrogate(wl, ACX_STATISTICS, stats,
-                                     sizeof(*stats));
-        if (ret < 0) {
-                wl1251_warning("acx statistics failed: %d", ret);
-                return -ENOMEM;
-        }
-
-        return 0;
-}
-
-int wl1251_acx_rate_policies(struct wl1251 *wl)
-{
-        struct acx_rate_policy *acx;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_ACX, "acx rate policies");
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* configure one default (one-size-fits-all) rate class */
-        acx->rate_class_cnt = 1;
-        acx->rate_class[0].enabled_rates = ACX_RATE_MASK_UNSPECIFIED;
-        acx->rate_class[0].short_retry_limit = ACX_RATE_RETRY_LIMIT;
-        acx->rate_class[0].long_retry_limit = ACX_RATE_RETRY_LIMIT;
-        acx->rate_class[0].aflags = 0;
-
-        ret = wl1251_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("Setting of rate policies failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_mem_cfg(struct wl1251 *wl)
-{
-        struct wl1251_acx_config_memory *mem_conf;
-        int ret, i;
-
-        wl1251_debug(DEBUG_ACX, "acx mem cfg");
-
-        mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
-        if (!mem_conf) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* memory config */
-        mem_conf->mem_config.num_stations = cpu_to_le16(DEFAULT_NUM_STATIONS);
-        mem_conf->mem_config.rx_mem_block_num = 35;
-        mem_conf->mem_config.tx_min_mem_block_num = 64;
-        mem_conf->mem_config.num_tx_queues = MAX_TX_QUEUES;
-        mem_conf->mem_config.host_if_options = HOSTIF_PKT_RING;
-        mem_conf->mem_config.num_ssid_profiles = 1;
-        mem_conf->mem_config.debug_buffer_size =
-                cpu_to_le16(TRACE_BUFFER_MAX_SIZE);
-
-        /* RX queue config */
-        mem_conf->rx_queue_config.dma_address = 0;
-        mem_conf->rx_queue_config.num_descs = ACX_RX_DESC_DEF;
-        mem_conf->rx_queue_config.priority = DEFAULT_RXQ_PRIORITY;
-        mem_conf->rx_queue_config.type = DEFAULT_RXQ_TYPE;
-
-        /* TX queue config */
-        for (i = 0; i < MAX_TX_QUEUES; i++) {
-                mem_conf->tx_queue_config[i].num_descs = ACX_TX_DESC_DEF;
-                mem_conf->tx_queue_config[i].attributes = i;
-        }
-
-        ret = wl1251_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
-                                   sizeof(*mem_conf));
-        if (ret < 0) {
-                wl1251_warning("wl1251 mem config failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(mem_conf);
-        return ret;
-}
-
-int wl1251_acx_wr_tbtt_and_dtim(struct wl1251 *wl, u16 tbtt, u8 dtim)
-{
-        struct wl1251_acx_wr_tbtt_and_dtim *acx;
-        int ret;
-
-        wl1251_debug(DEBUG_ACX, "acx tbtt and dtim");
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->tbtt = tbtt;
-        acx->dtim = dtim;
-
-        ret = wl1251_cmd_configure(wl, ACX_WR_TBTT_AND_DTIM,
-                                   acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("failed to set tbtt and dtim: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_ac_cfg(struct wl1251 *wl, u8 ac, u8 cw_min, u16 cw_max,
-                      u8 aifs, u16 txop)
-{
-        struct wl1251_acx_ac_cfg *acx;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d "
-                     "aifs %d txop %d", ac, cw_min, cw_max, aifs, txop);
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->ac = ac;
-        acx->cw_min = cw_min;
-        acx->cw_max = cw_max;
-        acx->aifsn = aifs;
-        acx->txop_limit = txop;
-
-        ret = wl1251_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("acx ac cfg failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
-
-int wl1251_acx_tid_cfg(struct wl1251 *wl, u8 queue,
-                       enum wl1251_acx_channel_type type,
-                       u8 tsid, enum wl1251_acx_ps_scheme ps_scheme,
-                       enum wl1251_acx_ack_policy ack_policy)
-{
-        struct wl1251_acx_tid_cfg *acx;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_ACX, "acx tid cfg %d type %d tsid %d "
-                     "ps_scheme %d ack_policy %d", queue, type, tsid,
-                     ps_scheme, ack_policy);
-
-        acx = kzalloc(sizeof(*acx), GFP_KERNEL);
-
-        if (!acx) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        acx->queue = queue;
-        acx->type = type;
-        acx->tsid = tsid;
-        acx->ps_scheme = ps_scheme;
-        acx->ack_policy = ack_policy;
-
-        ret = wl1251_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_warning("acx tid cfg failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(acx);
-        return ret;
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_acx.h b/drivers/net/wireless/wl12xx/wl1251_acx.h
deleted file mode 100644
index 842df310d92a..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_acx.h
+++ /dev/null
@@ -1,1413 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_ACX_H__
-#define __WL1251_ACX_H__
-
-#include "wl1251.h"
-#include "wl1251_cmd.h"
-
-/* Target's information element */
-struct acx_header {
-        struct wl1251_cmd_header cmd;
-
-        /* acx (or information element) header */
-        u16 id;
-
-        /* payload length (not including headers */
-        u16 len;
-};
-
-struct acx_error_counter {
-        struct acx_header header;
-
-        /* The number of PLCP errors since the last time this */
-        /* information element was interrogated. This field is */
-        /* automatically cleared when it is interrogated.*/
-        u32 PLCP_error;
-
-        /* The number of FCS errors since the last time this */
-        /* information element was interrogated. This field is */
-        /* automatically cleared when it is interrogated.*/
-        u32 FCS_error;
-
-        /* The number of MPDUs without PLCP header errors received*/
-        /* since the last time this information element was interrogated. */
-        /* This field is automatically cleared when it is interrogated.*/
-        u32 valid_frame;
-
-        /* the number of missed sequence numbers in the squentially */
-        /* values of frames seq numbers */
-        u32 seq_num_miss;
-} __packed;
-
-struct acx_revision {
-        struct acx_header header;
-
-        /*
-         * The WiLink firmware version, an ASCII string x.x.x.x,
-         * that uniquely identifies the current firmware.
-         * The left most digit is incremented each time a
-         * significant change is made to the firmware, such as
-         * code redesign or new platform support.
-         * The second digit is incremented when major enhancements
-         * are added or major fixes are made.
-         * The third digit is incremented for each GA release.
-         * The fourth digit is incremented for each build.
-         * The first two digits identify a firmware release version,
-         * in other words, a unique set of features.
-         * The first three digits identify a GA release.
-         */
-        char fw_version[20];
-
-        /*
-         * This 4 byte field specifies the WiLink hardware version.
-         * bits 0  - 15: Reserved.
-         * bits 16 - 23: Version ID - The WiLink version ID
-         *              (1 = first spin, 2 = second spin, and so on).
-         * bits 24 - 31: Chip ID - The WiLink chip ID.
-         */
-        u32 hw_version;
-} __packed;
-
-enum wl1251_psm_mode {
-        /* Active mode */
-        WL1251_PSM_CAM = 0,
-
-        /* Power save mode */
-        WL1251_PSM_PS = 1,
-
-        /* Extreme low power */
-        WL1251_PSM_ELP = 2,
-};
-
-struct acx_sleep_auth {
-        struct acx_header header;
-
-        /* The sleep level authorization of the device. */
-        /* 0 - Always active*/
-        /* 1 - Power down mode: light / fast sleep*/
-        /* 2 - ELP mode: Deep / Max sleep*/
-        u8  sleep_auth;
-        u8  padding[3];
-} __packed;
-
-enum {
-        HOSTIF_PCI_MASTER_HOST_INDIRECT,
-        HOSTIF_PCI_MASTER_HOST_DIRECT,
-        HOSTIF_SLAVE,
-        HOSTIF_PKT_RING,
-        HOSTIF_DONTCARE = 0xFF
-};
-
-#define DEFAULT_UCAST_PRIORITY          0
-#define DEFAULT_RX_Q_PRIORITY           0
-#define DEFAULT_NUM_STATIONS            1
-#define DEFAULT_RXQ_PRIORITY            0 /* low 0 .. 15 high  */
-#define DEFAULT_RXQ_TYPE                0x07    /* All frames, Data/Ctrl/Mgmt */
-#define TRACE_BUFFER_MAX_SIZE           256
-
-#define  DP_RX_PACKET_RING_CHUNK_SIZE 1600
-#define  DP_TX_PACKET_RING_CHUNK_SIZE 1600
-#define  DP_RX_PACKET_RING_CHUNK_NUM 2
-#define  DP_TX_PACKET_RING_CHUNK_NUM 2
-#define  DP_TX_COMPLETE_TIME_OUT 20
-#define  FW_TX_CMPLT_BLOCK_SIZE 16
-
-struct acx_data_path_params {
-        struct acx_header header;
-
-        u16 rx_packet_ring_chunk_size;
-        u16 tx_packet_ring_chunk_size;
-
-        u8 rx_packet_ring_chunk_num;
-        u8 tx_packet_ring_chunk_num;
-
-        /*
-         * Maximum number of packets that can be gathered
-         * in the TX complete ring before an interrupt
-         * is generated.
-         */
-        u8 tx_complete_threshold;
-
-        /* Number of pending TX complete entries in cyclic ring.*/
-        u8 tx_complete_ring_depth;
-
-        /*
-         * Max num microseconds since a packet enters the TX
-         * complete ring until an interrupt is generated.
-         */
-        u32 tx_complete_timeout;
-} __packed;
-
-
-struct acx_data_path_params_resp {
-        struct acx_header header;
-
-        u16 rx_packet_ring_chunk_size;
-        u16 tx_packet_ring_chunk_size;
-
-        u8 rx_packet_ring_chunk_num;
-        u8 tx_packet_ring_chunk_num;
-
-        u8 pad[2];
-
-        u32 rx_packet_ring_addr;
-        u32 tx_packet_ring_addr;
-
-        u32 rx_control_addr;
-        u32 tx_control_addr;
-
-        u32 tx_complete_addr;
-} __packed;
-
-#define TX_MSDU_LIFETIME_MIN       0
-#define TX_MSDU_LIFETIME_MAX       3000
-#define TX_MSDU_LIFETIME_DEF       512
-#define RX_MSDU_LIFETIME_MIN       0
-#define RX_MSDU_LIFETIME_MAX       0xFFFFFFFF
-#define RX_MSDU_LIFETIME_DEF       512000
-
-struct acx_rx_msdu_lifetime {
-        struct acx_header header;
-
-        /*
-         * The maximum amount of time, in TU, before the
-         * firmware discards the MSDU.
-         */
-        u32 lifetime;
-} __packed;
-
-/*
- * RX Config Options Table
- * Bit          Definition
- * ===          ==========
- * 31:14                Reserved
- * 13           Copy RX Status - when set, write three receive status words
- *              to top of rx'd MPDUs.
- *              When cleared, do not write three status words (added rev 1.5)
- * 12           Reserved
- * 11           RX Complete upon FCS error - when set, give rx complete
- *              interrupt for FCS errors, after the rx filtering, e.g. unicast
- *              frames not to us with FCS error will not generate an interrupt.
- * 10           SSID Filter Enable - When set, the WiLink discards all beacon,
- *              probe request, and probe response frames with an SSID that does
- *              not match the SSID specified by the host in the START/JOIN
- *              command.
- *              When clear, the WiLink receives frames with any SSID.
- * 9            Broadcast Filter Enable - When set, the WiLink discards all
- *              broadcast frames. When clear, the WiLink receives all received
- *              broadcast frames.
- * 8:6          Reserved
- * 5            BSSID Filter Enable - When set, the WiLink discards any frames
- *              with a BSSID that does not match the BSSID specified by the
- *              host.
- *              When clear, the WiLink receives frames from any BSSID.
- * 4            MAC Addr Filter - When set, the WiLink discards any frames
- *              with a destination address that does not match the MAC address
- *              of the adaptor.
- *              When clear, the WiLink receives frames destined to any MAC
- *              address.
- * 3            Promiscuous - When set, the WiLink receives all valid frames
- *              (i.e., all frames that pass the FCS check).
- *              When clear, only frames that pass the other filters specified
- *              are received.
- * 2            FCS - When set, the WiLink includes the FCS with the received
- *              frame.
- *              When cleared, the FCS is discarded.
- * 1            PLCP header - When set, write all data from baseband to frame
- *              buffer including PHY header.
- * 0            Reserved - Always equal to 0.
- *
- * RX Filter Options Table
- * Bit          Definition
- * ===          ==========
- * 31:12                Reserved - Always equal to 0.
- * 11           Association - When set, the WiLink receives all association
- *              related frames (association request/response, reassocation
- *              request/response, and disassociation). When clear, these frames
- *              are discarded.
- * 10           Auth/De auth - When set, the WiLink receives all authentication
- *              and de-authentication frames. When clear, these frames are
- *              discarded.
- * 9            Beacon - When set, the WiLink receives all beacon frames.
- *              When clear, these frames are discarded.
- * 8            Contention Free - When set, the WiLink receives all contention
- *              free frames.
- *              When clear, these frames are discarded.
- * 7            Control - When set, the WiLink receives all control frames.
- *              When clear, these frames are discarded.
- * 6            Data - When set, the WiLink receives all data frames.
- *              When clear, these frames are discarded.
- * 5            FCS Error - When set, the WiLink receives frames that have FCS
- *              errors.
- *              When clear, these frames are discarded.
- * 4            Management - When set, the WiLink receives all management
- *              frames.
- *              When clear, these frames are discarded.
- * 3            Probe Request - When set, the WiLink receives all probe request
- *              frames.
- *              When clear, these frames are discarded.
- * 2            Probe Response - When set, the WiLink receives all probe
- *              response frames.
- *              When clear, these frames are discarded.
- * 1            RTS/CTS/ACK - When set, the WiLink receives all RTS, CTS and ACK
- *              frames.
- *              When clear, these frames are discarded.
- * 0            Rsvd Type/Sub Type - When set, the WiLink receives all frames
- *              that have reserved frame types and sub types as defined by the
- *              802.11 specification.
- *              When clear, these frames are discarded.
- */
-struct acx_rx_config {
-        struct acx_header header;
-
-        u32 config_options;
-        u32 filter_options;
-} __packed;
-
-enum {
-        QOS_AC_BE = 0,
-        QOS_AC_BK,
-        QOS_AC_VI,
-        QOS_AC_VO,
-        QOS_HIGHEST_AC_INDEX = QOS_AC_VO,
-};
-
-#define MAX_NUM_OF_AC             (QOS_HIGHEST_AC_INDEX+1)
-#define FIRST_AC_INDEX            QOS_AC_BE
-#define MAX_NUM_OF_802_1d_TAGS    8
-#define AC_PARAMS_MAX_TSID        15
-#define MAX_APSD_CONF             0xffff
-
-#define  QOS_TX_HIGH_MIN      (0)
-#define  QOS_TX_HIGH_MAX      (100)
-
-#define  QOS_TX_HIGH_BK_DEF   (25)
-#define  QOS_TX_HIGH_BE_DEF   (35)
-#define  QOS_TX_HIGH_VI_DEF   (35)
-#define  QOS_TX_HIGH_VO_DEF   (35)
-
-#define  QOS_TX_LOW_BK_DEF    (15)
-#define  QOS_TX_LOW_BE_DEF    (25)
-#define  QOS_TX_LOW_VI_DEF    (25)
-#define  QOS_TX_LOW_VO_DEF    (25)
-
-struct acx_tx_queue_qos_config {
-        struct acx_header header;
-
-        u8 qid;
-        u8 pad[3];
-
-        /* Max number of blocks allowd in the queue */
-        u16 high_threshold;
-
-        /* Lowest memory blocks guaranteed for this queue */
-        u16 low_threshold;
-} __packed;
-
-struct acx_packet_detection {
-        struct acx_header header;
-
-        u32 threshold;
-} __packed;
-
-
-enum acx_slot_type {
-        SLOT_TIME_LONG = 0,
-        SLOT_TIME_SHORT = 1,
-        DEFAULT_SLOT_TIME = SLOT_TIME_SHORT,
-        MAX_SLOT_TIMES = 0xFF
-};
-
-#define STATION_WONE_INDEX 0
-
-struct acx_slot {
-        struct acx_header header;
-
-        u8 wone_index; /* Reserved */
-        u8 slot_time;
-        u8 reserved[6];
-} __packed;
-
-
-#define ADDRESS_GROUP_MAX       (8)
-#define ADDRESS_GROUP_MAX_LEN   (ETH_ALEN * ADDRESS_GROUP_MAX)
-
-struct acx_dot11_grp_addr_tbl {
-        struct acx_header header;
-
-        u8 enabled;
-        u8 num_groups;
-        u8 pad[2];
-        u8 mac_table[ADDRESS_GROUP_MAX_LEN];
-} __packed;
-
-
-#define  RX_TIMEOUT_PS_POLL_MIN    0
-#define  RX_TIMEOUT_PS_POLL_MAX    (200000)
-#define  RX_TIMEOUT_PS_POLL_DEF    (15)
-#define  RX_TIMEOUT_UPSD_MIN       0
-#define  RX_TIMEOUT_UPSD_MAX       (200000)
-#define  RX_TIMEOUT_UPSD_DEF       (15)
-
-struct acx_rx_timeout {
-        struct acx_header header;
-
-        /*
-         * The longest time the STA will wait to receive
-         * traffic from the AP after a PS-poll has been
-         * transmitted.
-         */
-        u16 ps_poll_timeout;
-
-        /*
-         * The longest time the STA will wait to receive
-         * traffic from the AP after a frame has been sent
-         * from an UPSD enabled queue.
-         */
-        u16 upsd_timeout;
-} __packed;
-
-#define RTS_THRESHOLD_MIN              0
-#define RTS_THRESHOLD_MAX              4096
-#define RTS_THRESHOLD_DEF              2347
-
-struct acx_rts_threshold {
-        struct acx_header header;
-
-        u16 threshold;
-        u8 pad[2];
-} __packed;
-
-struct acx_beacon_filter_option {
-        struct acx_header header;
-
-        u8 enable;
-
-        /*
-         * The number of beacons without the unicast TIM
-         * bit set that the firmware buffers before
-         * signaling the host about ready frames.
-         * When set to 0 and the filter is enabled, beacons
-         * without the unicast TIM bit set are dropped.
-         */
-        u8 max_num_beacons;
-        u8 pad[2];
-} __packed;
-
-/*
- * ACXBeaconFilterEntry (not 221)
- * Byte Offset     Size (Bytes)    Definition
- * ===========     ============    ==========
- * 0                            1               IE identifier
- * 1               1               Treatment bit mask
- *
- * ACXBeaconFilterEntry (221)
- * Byte Offset     Size (Bytes)    Definition
- * ===========     ============    ==========
- * 0               1               IE identifier
- * 1               1               Treatment bit mask
- * 2               3               OUI
- * 5               1               Type
- * 6               2               Version
- *
- *
- * Treatment bit mask - The information element handling:
- * bit 0 - The information element is compared and transferred
- * in case of change.
- * bit 1 - The information element is transferred to the host
- * with each appearance or disappearance.
- * Note that both bits can be set at the same time.
- */
-#define BEACON_FILTER_TABLE_MAX_IE_NUM                 (32)
-#define BEACON_FILTER_TABLE_MAX_VENDOR_SPECIFIC_IE_NUM (6)
-#define BEACON_FILTER_TABLE_IE_ENTRY_SIZE              (2)
-#define BEACON_FILTER_TABLE_EXTRA_VENDOR_SPECIFIC_IE_SIZE (6)
-#define BEACON_FILTER_TABLE_MAX_SIZE ((BEACON_FILTER_TABLE_MAX_IE_NUM * \
-                            BEACON_FILTER_TABLE_IE_ENTRY_SIZE) + \
-                           (BEACON_FILTER_TABLE_MAX_VENDOR_SPECIFIC_IE_NUM * \
-                            BEACON_FILTER_TABLE_EXTRA_VENDOR_SPECIFIC_IE_SIZE))
-
-#define BEACON_RULE_PASS_ON_CHANGE                     BIT(0)
-#define BEACON_RULE_PASS_ON_APPEARANCE                 BIT(1)
-
-#define BEACON_FILTER_IE_ID_CHANNEL_SWITCH_ANN         (37)
-
-struct acx_beacon_filter_ie_table {
-        struct acx_header header;
-
-        u8 num_ie;
-        u8 table[BEACON_FILTER_TABLE_MAX_SIZE];
-        u8 pad[3];
-} __packed;
-
-#define SYNCH_FAIL_DEFAULT_THRESHOLD    10     /* number of beacons */
-#define NO_BEACON_DEFAULT_TIMEOUT       (500) /* in microseconds */
-
-struct acx_conn_monit_params {
-        struct acx_header header;
-
-        u32 synch_fail_thold; /* number of beacons missed */
-        u32 bss_lose_timeout; /* number of TU's from synch fail */
-};
-
-enum {
-        SG_ENABLE = 0,
-        SG_DISABLE,
-        SG_SENSE_NO_ACTIVITY,
-        SG_SENSE_ACTIVE
-};
-
-struct acx_bt_wlan_coex {
-        struct acx_header header;
-
-        /*
-         * 0 -> PTA enabled
-         * 1 -> PTA disabled
-         * 2 -> sense no active mode, i.e.
-         *      an interrupt is sent upon
-         *      BT activity.
-         * 3 -> PTA is switched on in response
-         *      to the interrupt sending.
-         */
-        u8 enable;
-        u8 pad[3];
-} __packed;
-
-#define PTA_ANTENNA_TYPE_DEF              (0)
-#define PTA_BT_HP_MAXTIME_DEF             (2000)
-#define PTA_WLAN_HP_MAX_TIME_DEF          (5000)
-#define PTA_SENSE_DISABLE_TIMER_DEF       (1350)
-#define PTA_PROTECTIVE_RX_TIME_DEF        (1500)
-#define PTA_PROTECTIVE_TX_TIME_DEF        (1500)
-#define PTA_TIMEOUT_NEXT_BT_LP_PACKET_DEF (3000)
-#define PTA_SIGNALING_TYPE_DEF            (1)
-#define PTA_AFH_LEVERAGE_ON_DEF           (0)
-#define PTA_NUMBER_QUIET_CYCLE_DEF        (0)
-#define PTA_MAX_NUM_CTS_DEF               (3)
-#define PTA_NUMBER_OF_WLAN_PACKETS_DEF    (2)
-#define PTA_NUMBER_OF_BT_PACKETS_DEF      (2)
-#define PTA_PROTECTIVE_RX_TIME_FAST_DEF   (1500)
-#define PTA_PROTECTIVE_TX_TIME_FAST_DEF   (3000)
-#define PTA_CYCLE_TIME_FAST_DEF           (8700)
-#define PTA_RX_FOR_AVALANCHE_DEF          (5)
-#define PTA_ELP_HP_DEF                    (0)
-#define PTA_ANTI_STARVE_PERIOD_DEF        (500)
-#define PTA_ANTI_STARVE_NUM_CYCLE_DEF     (4)
-#define PTA_ALLOW_PA_SD_DEF               (1)
-#define PTA_TIME_BEFORE_BEACON_DEF        (6300)
-#define PTA_HPDM_MAX_TIME_DEF             (1600)
-#define PTA_TIME_OUT_NEXT_WLAN_DEF        (2550)
-#define PTA_AUTO_MODE_NO_CTS_DEF          (0)
-#define PTA_BT_HP_RESPECTED_DEF           (3)
-#define PTA_WLAN_RX_MIN_RATE_DEF          (24)
-#define PTA_ACK_MODE_DEF                  (1)
-
-struct acx_bt_wlan_coex_param {
-        struct acx_header header;
-
-        /*
-         * The minimum rate of a received WLAN packet in the STA,
-         * during protective mode, of which a new BT-HP request
-         * during this Rx will always be respected and gain the antenna.
-         */
-        u32 min_rate;
-
-        /* Max time the BT HP will be respected. */
-        u16 bt_hp_max_time;
-
-        /* Max time the WLAN HP will be respected. */
-        u16 wlan_hp_max_time;
-
-        /*
-         * The time between the last BT activity
-         * and the moment when the sense mode returns
-         * to SENSE_INACTIVE.
-         */
-        u16 sense_disable_timer;
-
-        /* Time before the next BT HP instance */
-        u16 rx_time_bt_hp;
-        u16 tx_time_bt_hp;
-
-        /* range: 10-20000    default: 1500 */
-        u16 rx_time_bt_hp_fast;
-        u16 tx_time_bt_hp_fast;
-
-        /* range: 2000-65535  default: 8700 */
-        u16 wlan_cycle_fast;
-
-        /* range: 0 - 15000 (Msec) default: 1000 */
-        u16 bt_anti_starvation_period;
-
-        /* range 400-10000(Usec) default: 3000 */
-        u16 next_bt_lp_packet;
-
-        /* Deafult: worst case for BT DH5 traffic */
-        u16 wake_up_beacon;
-
-        /* range: 0-50000(Usec) default: 1050 */
-        u16 hp_dm_max_guard_time;
-
-        /*
-         * This is to prevent both BT & WLAN antenna
-         * starvation.
-         * Range: 100-50000(Usec) default:2550
-         */
-        u16 next_wlan_packet;
-
-        /* 0 -> shared antenna */
-        u8 antenna_type;
-
-        /*
-         * 0 -> TI legacy
-         * 1 -> Palau
-         */
-        u8 signal_type;
-
-        /*
-         * BT AFH status
-         * 0 -> no AFH
-         * 1 -> from dedicated GPIO
-         * 2 -> AFH on (from host)
-         */
-        u8 afh_leverage_on;
-
-        /*
-         * The number of cycles during which no
-         * TX will be sent after 1 cycle of RX
-         * transaction in protective mode
-         */
-        u8 quiet_cycle_num;
-
-        /*
-         * The maximum number of CTSs that will
-         * be sent for receiving RX packet in
-         * protective mode
-         */
-        u8 max_cts;
-
-        /*
-         * The number of WLAN packets
-         * transferred in common mode before
-         * switching to BT.
-         */
-        u8 wlan_packets_num;
-
-        /*
-         * The number of BT packets
-         * transferred in common mode before
-         * switching to WLAN.
-         */
-        u8 bt_packets_num;
-
-        /* range: 1-255  default: 5 */
-        u8 missed_rx_avalanche;
-
-        /* range: 0-1    default: 1 */
-        u8 wlan_elp_hp;
-
-        /* range: 0 - 15  default: 4 */
-        u8 bt_anti_starvation_cycles;
-
-        u8 ack_mode_dual_ant;
-
-        /*
-         * Allow PA_SD assertion/de-assertion
-         * during enabled BT activity.
-         */
-        u8 pa_sd_enable;
-
-        /*
-         * Enable/Disable PTA in auto mode:
-         * Support Both Active & P.S modes
-         */
-        u8 pta_auto_mode_enable;
-
-        /* range: 0 - 20  default: 1 */
-        u8 bt_hp_respected_num;
-} __packed;
-
-#define CCA_THRSH_ENABLE_ENERGY_D       0x140A
-#define CCA_THRSH_DISABLE_ENERGY_D      0xFFEF
-
-struct acx_energy_detection {
-        struct acx_header header;
-
-        /* The RX Clear Channel Assessment threshold in the PHY */
-        u16 rx_cca_threshold;
-        u8 tx_energy_detection;
-        u8 pad;
-} __packed;
-
-#define BCN_RX_TIMEOUT_DEF_VALUE        10000
-#define BROADCAST_RX_TIMEOUT_DEF_VALUE  20000
-#define RX_BROADCAST_IN_PS_DEF_VALUE    1
-#define CONSECUTIVE_PS_POLL_FAILURE_DEF 4
-
-struct acx_beacon_broadcast {
-        struct acx_header header;
-
-        u16 beacon_rx_timeout;
-        u16 broadcast_timeout;
-
-        /* Enables receiving of broadcast packets in PS mode */
-        u8 rx_broadcast_in_ps;
-
-        /* Consecutive PS Poll failures before updating the host */
-        u8 ps_poll_threshold;
-        u8 pad[2];
-} __packed;
-
-struct acx_event_mask {
-        struct acx_header header;
-
-        u32 event_mask;
-        u32 high_event_mask; /* Unused */
-} __packed;
-
-#define CFG_RX_FCS              BIT(2)
-#define CFG_RX_ALL_GOOD         BIT(3)
-#define CFG_UNI_FILTER_EN       BIT(4)
-#define CFG_BSSID_FILTER_EN     BIT(5)
-#define CFG_MC_FILTER_EN        BIT(6)
-#define CFG_MC_ADDR0_EN         BIT(7)
-#define CFG_MC_ADDR1_EN         BIT(8)
-#define CFG_BC_REJECT_EN        BIT(9)
-#define CFG_SSID_FILTER_EN      BIT(10)
-#define CFG_RX_INT_FCS_ERROR    BIT(11)
-#define CFG_RX_INT_ENCRYPTED    BIT(12)
-#define CFG_RX_WR_RX_STATUS     BIT(13)
-#define CFG_RX_FILTER_NULTI     BIT(14)
-#define CFG_RX_RESERVE          BIT(15)
-#define CFG_RX_TIMESTAMP_TSF    BIT(16)
-
-#define CFG_RX_RSV_EN           BIT(0)
-#define CFG_RX_RCTS_ACK         BIT(1)
-#define CFG_RX_PRSP_EN          BIT(2)
-#define CFG_RX_PREQ_EN          BIT(3)
-#define CFG_RX_MGMT_EN          BIT(4)
-#define CFG_RX_FCS_ERROR        BIT(5)
-#define CFG_RX_DATA_EN          BIT(6)
-#define CFG_RX_CTL_EN           BIT(7)
-#define CFG_RX_CF_EN            BIT(8)
-#define CFG_RX_BCN_EN           BIT(9)
-#define CFG_RX_AUTH_EN          BIT(10)
-#define CFG_RX_ASSOC_EN         BIT(11)
-
-#define SCAN_PASSIVE            BIT(0)
-#define SCAN_5GHZ_BAND          BIT(1)
-#define SCAN_TRIGGERED          BIT(2)
-#define SCAN_PRIORITY_HIGH      BIT(3)
-
-struct acx_fw_gen_frame_rates {
-        struct acx_header header;
-
-        u8 tx_ctrl_frame_rate; /* RATE_* */
-        u8 tx_ctrl_frame_mod; /* CCK_* or PBCC_* */
-        u8 tx_mgt_frame_rate;
-        u8 tx_mgt_frame_mod;
-} __packed;
-
-/* STA MAC */
-struct acx_dot11_station_id {
-        struct acx_header header;
-
-        u8 mac[ETH_ALEN];
-        u8 pad[2];
-} __packed;
-
-struct acx_feature_config {
-        struct acx_header header;
-
-        u32 options;
-        u32 data_flow_options;
-} __packed;
-
-struct acx_current_tx_power {
-        struct acx_header header;
-
-        u8  current_tx_power;
-        u8  padding[3];
-} __packed;
-
-struct acx_dot11_default_key {
-        struct acx_header header;
-
-        u8 id;
-        u8 pad[3];
-} __packed;
-
-struct acx_tsf_info {
-        struct acx_header header;
-
-        u32 current_tsf_msb;
-        u32 current_tsf_lsb;
-        u32 last_TBTT_msb;
-        u32 last_TBTT_lsb;
-        u8 last_dtim_count;
-        u8 pad[3];
-} __packed;
-
-enum acx_wake_up_event {
-        WAKE_UP_EVENT_BEACON_BITMAP     = 0x01, /* Wake on every Beacon*/
-        WAKE_UP_EVENT_DTIM_BITMAP       = 0x02, /* Wake on every DTIM*/
-        WAKE_UP_EVENT_N_DTIM_BITMAP     = 0x04, /* Wake on every Nth DTIM */
-        WAKE_UP_EVENT_N_BEACONS_BITMAP  = 0x08, /* Wake on every Nth Beacon */
-        WAKE_UP_EVENT_BITS_MASK         = 0x0F
-};
-
-struct acx_wake_up_condition {
-        struct acx_header header;
-
-        u8 wake_up_event; /* Only one bit can be set */
-        u8 listen_interval;
-        u8 pad[2];
-} __packed;
-
-struct acx_aid {
-        struct acx_header header;
-
-        /*
-         * To be set when associated with an AP.
-         */
-        u16 aid;
-        u8 pad[2];
-} __packed;
-
-enum acx_preamble_type {
-        ACX_PREAMBLE_LONG = 0,
-        ACX_PREAMBLE_SHORT = 1
-};
-
-struct acx_preamble {
-        struct acx_header header;
-
-        /*
-         * When set, the WiLink transmits the frames with a short preamble and
-         * when cleared, the WiLink transmits the frames with a long preamble.
-         */
-        u8 preamble;
-        u8 padding[3];
-} __packed;
-
-enum acx_ctsprotect_type {
-        CTSPROTECT_DISABLE = 0,
-        CTSPROTECT_ENABLE = 1
-};
-
-struct acx_ctsprotect {
-        struct acx_header header;
-        u8 ctsprotect;
-        u8 padding[3];
-} __packed;
-
-struct acx_tx_statistics {
-        u32 internal_desc_overflow;
-}  __packed;
-
-struct acx_rx_statistics {
-        u32 out_of_mem;
-        u32 hdr_overflow;
-        u32 hw_stuck;
-        u32 dropped;
-        u32 fcs_err;
-        u32 xfr_hint_trig;
-        u32 path_reset;
-        u32 reset_counter;
-} __packed;
-
-struct acx_dma_statistics {
-        u32 rx_requested;
-        u32 rx_errors;
-        u32 tx_requested;
-        u32 tx_errors;
-}  __packed;
-
-struct acx_isr_statistics {
-        /* host command complete */
-        u32 cmd_cmplt;
-
-        /* fiqisr() */
-        u32 fiqs;
-
-        /* (INT_STS_ND & INT_TRIG_RX_HEADER) */
-        u32 rx_headers;
-
-        /* (INT_STS_ND & INT_TRIG_RX_CMPLT) */
-        u32 rx_completes;
-
-        /* (INT_STS_ND & INT_TRIG_NO_RX_BUF) */
-        u32 rx_mem_overflow;
-
-        /* (INT_STS_ND & INT_TRIG_S_RX_RDY) */
-        u32 rx_rdys;
-
-        /* irqisr() */
-        u32 irqs;
-
-        /* (INT_STS_ND & INT_TRIG_TX_PROC) */
-        u32 tx_procs;
-
-        /* (INT_STS_ND & INT_TRIG_DECRYPT_DONE) */
-        u32 decrypt_done;
-
-        /* (INT_STS_ND & INT_TRIG_DMA0) */
-        u32 dma0_done;
-
-        /* (INT_STS_ND & INT_TRIG_DMA1) */
-        u32 dma1_done;
-
-        /* (INT_STS_ND & INT_TRIG_TX_EXC_CMPLT) */
-        u32 tx_exch_complete;
-
-        /* (INT_STS_ND & INT_TRIG_COMMAND) */
-        u32 commands;
-
-        /* (INT_STS_ND & INT_TRIG_RX_PROC) */
-        u32 rx_procs;
-
-        /* (INT_STS_ND & INT_TRIG_PM_802) */
-        u32 hw_pm_mode_changes;
-
-        /* (INT_STS_ND & INT_TRIG_ACKNOWLEDGE) */
-        u32 host_acknowledges;
-
-        /* (INT_STS_ND & INT_TRIG_PM_PCI) */
-        u32 pci_pm;
-
-        /* (INT_STS_ND & INT_TRIG_ACM_WAKEUP) */
-        u32 wakeups;
-
-        /* (INT_STS_ND & INT_TRIG_LOW_RSSI) */
-        u32 low_rssi;
-} __packed;
-
-struct acx_wep_statistics {
-        /* WEP address keys configured */
-        u32 addr_key_count;
-
-        /* default keys configured */
-        u32 default_key_count;
-
-        u32 reserved;
-
-        /* number of times that WEP key not found on lookup */
-        u32 key_not_found;
-
-        /* number of times that WEP key decryption failed */
-        u32 decrypt_fail;
-
-        /* WEP packets decrypted */
-        u32 packets;
-
-        /* WEP decrypt interrupts */
-        u32 interrupt;
-} __packed;
-
-#define ACX_MISSED_BEACONS_SPREAD 10
-
-struct acx_pwr_statistics {
-        /* the amount of enters into power save mode (both PD & ELP) */
-        u32 ps_enter;
-
-        /* the amount of enters into ELP mode */
-        u32 elp_enter;
-
-        /* the amount of missing beacon interrupts to the host */
-        u32 missing_bcns;
-
-        /* the amount of wake on host-access times */
-        u32 wake_on_host;
-
-        /* the amount of wake on timer-expire */
-        u32 wake_on_timer_exp;
-
-        /* the number of packets that were transmitted with PS bit set */
-        u32 tx_with_ps;
-
-        /* the number of packets that were transmitted with PS bit clear */
-        u32 tx_without_ps;
-
-        /* the number of received beacons */
-        u32 rcvd_beacons;
-
-        /* the number of entering into PowerOn (power save off) */
-        u32 power_save_off;
-
-        /* the number of entries into power save mode */
-        u16 enable_ps;
-
-        /*
-         * the number of exits from power save, not including failed PS
-         * transitions
-         */
-        u16 disable_ps;
-
-        /*
-         * the number of times the TSF counter was adjusted because
-         * of drift
-         */
-        u32 fix_tsf_ps;
-
-        /* Gives statistics about the spread continuous missed beacons.
-         * The 16 LSB are dedicated for the PS mode.
-         * The 16 MSB are dedicated for the PS mode.
-         * cont_miss_bcns_spread[0] - single missed beacon.
-         * cont_miss_bcns_spread[1] - two continuous missed beacons.
-         * cont_miss_bcns_spread[2] - three continuous missed beacons.
-         * ...
-         * cont_miss_bcns_spread[9] - ten and more continuous missed beacons.
-        */
-        u32 cont_miss_bcns_spread[ACX_MISSED_BEACONS_SPREAD];
-
-        /* the number of beacons in awake mode */
-        u32 rcvd_awake_beacons;
-} __packed;
-
-struct acx_mic_statistics {
-        u32 rx_pkts;
-        u32 calc_failure;
-} __packed;
-
-struct acx_aes_statistics {
-        u32 encrypt_fail;
-        u32 decrypt_fail;
-        u32 encrypt_packets;
-        u32 decrypt_packets;
-        u32 encrypt_interrupt;
-        u32 decrypt_interrupt;
-} __packed;
-
-struct acx_event_statistics {
-        u32 heart_beat;
-        u32 calibration;
-        u32 rx_mismatch;
-        u32 rx_mem_empty;
-        u32 rx_pool;
-        u32 oom_late;
-        u32 phy_transmit_error;
-        u32 tx_stuck;
-} __packed;
-
-struct acx_ps_statistics {
-        u32 pspoll_timeouts;
-        u32 upsd_timeouts;
-        u32 upsd_max_sptime;
-        u32 upsd_max_apturn;
-        u32 pspoll_max_apturn;
-        u32 pspoll_utilization;
-        u32 upsd_utilization;
-} __packed;
-
-struct acx_rxpipe_statistics {
-        u32 rx_prep_beacon_drop;
-        u32 descr_host_int_trig_rx_data;
-        u32 beacon_buffer_thres_host_int_trig_rx_data;
-        u32 missed_beacon_host_int_trig_rx_data;
-        u32 tx_xfr_host_int_trig_rx_data;
-} __packed;
-
-struct acx_statistics {
-        struct acx_header header;
-
-        struct acx_tx_statistics tx;
-        struct acx_rx_statistics rx;
-        struct acx_dma_statistics dma;
-        struct acx_isr_statistics isr;
-        struct acx_wep_statistics wep;
-        struct acx_pwr_statistics pwr;
-        struct acx_aes_statistics aes;
-        struct acx_mic_statistics mic;
-        struct acx_event_statistics event;
-        struct acx_ps_statistics ps;
-        struct acx_rxpipe_statistics rxpipe;
-} __packed;
-
-#define ACX_MAX_RATE_CLASSES       8
-#define ACX_RATE_MASK_UNSPECIFIED  0
-#define ACX_RATE_RETRY_LIMIT      10
-
-struct acx_rate_class {
-        u32 enabled_rates;
-        u8 short_retry_limit;
-        u8 long_retry_limit;
-        u8 aflags;
-        u8 reserved;
-};
-
-struct acx_rate_policy {
-        struct acx_header header;
-
-        u32 rate_class_cnt;
-        struct acx_rate_class rate_class[ACX_MAX_RATE_CLASSES];
-} __packed;
-
-struct wl1251_acx_memory {
-        __le16 num_stations; /* number of STAs to be supported. */
-        u16 reserved_1;
-
-        /*
-         * Nmber of memory buffers for the RX mem pool.
-         * The actual number may be less if there are
-         * not enough blocks left for the minimum num
-         * of TX ones.
-         */
-        u8 rx_mem_block_num;
-        u8 reserved_2;
-        u8 num_tx_queues; /* From 1 to 16 */
-        u8 host_if_options; /* HOST_IF* */
-        u8 tx_min_mem_block_num;
-        u8 num_ssid_profiles;
-        __le16 debug_buffer_size;
-} __packed;
-
-
-#define ACX_RX_DESC_MIN                1
-#define ACX_RX_DESC_MAX                127
-#define ACX_RX_DESC_DEF                32
-struct wl1251_acx_rx_queue_config {
-        u8 num_descs;
-        u8 pad;
-        u8 type;
-        u8 priority;
-        __le32 dma_address;
-} __packed;
-
-#define ACX_TX_DESC_MIN                1
-#define ACX_TX_DESC_MAX                127
-#define ACX_TX_DESC_DEF                16
-struct wl1251_acx_tx_queue_config {
-    u8 num_descs;
-    u8 pad[2];
-    u8 attributes;
-} __packed;
-
-#define MAX_TX_QUEUE_CONFIGS 5
-#define MAX_TX_QUEUES 4
-struct wl1251_acx_config_memory {
-        struct acx_header header;
-
-        struct wl1251_acx_memory mem_config;
-        struct wl1251_acx_rx_queue_config rx_queue_config;
-        struct wl1251_acx_tx_queue_config tx_queue_config[MAX_TX_QUEUE_CONFIGS];
-} __packed;
-
-struct wl1251_acx_mem_map {
-        struct acx_header header;
-
-        void *code_start;
-        void *code_end;
-
-        void *wep_defkey_start;
-        void *wep_defkey_end;
-
-        void *sta_table_start;
-        void *sta_table_end;
-
-        void *packet_template_start;
-        void *packet_template_end;
-
-        void *queue_memory_start;
-        void *queue_memory_end;
-
-        void *packet_memory_pool_start;
-        void *packet_memory_pool_end;
-
-        void *debug_buffer1_start;
-        void *debug_buffer1_end;
-
-        void *debug_buffer2_start;
-        void *debug_buffer2_end;
-
-        /* Number of blocks FW allocated for TX packets */
-        u32 num_tx_mem_blocks;
-
-        /* Number of blocks FW allocated for RX packets */
-        u32 num_rx_mem_blocks;
-} __packed;
-
-
-struct wl1251_acx_wr_tbtt_and_dtim {
-
-        struct acx_header header;
-
-        /* Time in TUs between two consecutive beacons */
-        u16 tbtt;
-
-        /*
-         * DTIM period
-         * For BSS: Number of TBTTs in a DTIM period (range: 1-10)
-         * For IBSS: value shall be set to 1
-        */
-        u8  dtim;
-        u8  padding;
-} __packed;
-
-struct wl1251_acx_ac_cfg {
-        struct acx_header header;
-
-        /*
-         * Access Category - The TX queue's access category
-         * (refer to AccessCategory_enum)
-         */
-        u8 ac;
-
-        /*
-         * The contention window minimum size (in slots) for
-         * the access class.
-         */
-        u8 cw_min;
-
-        /*
-         * The contention window maximum size (in slots) for
-         * the access class.
-         */
-        u16 cw_max;
-
-        /* The AIF value (in slots) for the access class. */
-        u8 aifsn;
-
-        u8 reserved;
-
-        /* The TX Op Limit (in microseconds) for the access class. */
-        u16 txop_limit;
-} __packed;
-
-
-enum wl1251_acx_channel_type {
-        CHANNEL_TYPE_DCF        = 0,
-        CHANNEL_TYPE_EDCF       = 1,
-        CHANNEL_TYPE_HCCA       = 2,
-};
-
-enum wl1251_acx_ps_scheme {
-        /* regular ps: simple sending of packets */
-        WL1251_ACX_PS_SCHEME_LEGACY     = 0,
-
-        /* sending a packet triggers a unscheduled apsd downstream */
-        WL1251_ACX_PS_SCHEME_UPSD_TRIGGER       = 1,
-
-        /* a pspoll packet will be sent before every data packet */
-        WL1251_ACX_PS_SCHEME_LEGACY_PSPOLL      = 2,
-
-        /* scheduled apsd mode */
-        WL1251_ACX_PS_SCHEME_SAPSD              = 3,
-};
-
-enum wl1251_acx_ack_policy {
-        WL1251_ACX_ACK_POLICY_LEGACY    = 0,
-        WL1251_ACX_ACK_POLICY_NO_ACK    = 1,
-        WL1251_ACX_ACK_POLICY_BLOCK     = 2,
-};
-
-struct wl1251_acx_tid_cfg {
-        struct acx_header header;
-
-        /* tx queue id number (0-7) */
-        u8 queue;
-
-        /* channel access type for the queue, enum wl1251_acx_channel_type */
-        u8 type;
-
-        /* EDCA: ac index (0-3), HCCA: traffic stream id (8-15) */
-        u8 tsid;
-
-        /* ps scheme of the specified queue, enum wl1251_acx_ps_scheme */
-        u8 ps_scheme;
-
-        /* the tx queue ack policy, enum wl1251_acx_ack_policy */
-        u8 ack_policy;
-
-        u8 padding[3];
-
-        /* not supported */
-        u32 apsdconf[2];
-} __packed;
-
-/*************************************************************************
-
-    Host Interrupt Register (WiLink -> Host)
-
-**************************************************************************/
-
-/* RX packet is ready in Xfer buffer #0 */
-#define WL1251_ACX_INTR_RX0_DATA      BIT(0)
-
-/* TX result(s) are in the TX complete buffer */
-#define WL1251_ACX_INTR_TX_RESULT       BIT(1)
-
-/* OBSOLETE */
-#define WL1251_ACX_INTR_TX_XFR          BIT(2)
-
-/* RX packet is ready in Xfer buffer #1 */
-#define WL1251_ACX_INTR_RX1_DATA        BIT(3)
-
-/* Event was entered to Event MBOX #A */
-#define WL1251_ACX_INTR_EVENT_A         BIT(4)
-
-/* Event was entered to Event MBOX #B */
-#define WL1251_ACX_INTR_EVENT_B         BIT(5)
-
-/* OBSOLETE */
-#define WL1251_ACX_INTR_WAKE_ON_HOST    BIT(6)
-
-/* Trace meassge on MBOX #A */
-#define WL1251_ACX_INTR_TRACE_A         BIT(7)
-
-/* Trace meassge on MBOX #B */
-#define WL1251_ACX_INTR_TRACE_B         BIT(8)
-
-/* Command processing completion */
-#define WL1251_ACX_INTR_CMD_COMPLETE    BIT(9)
-
-/* Init sequence is done */
-#define WL1251_ACX_INTR_INIT_COMPLETE   BIT(14)
-
-#define WL1251_ACX_INTR_ALL           0xFFFFFFFF
-
-enum {
-        ACX_WAKE_UP_CONDITIONS      = 0x0002,
-        ACX_MEM_CFG                 = 0x0003,
-        ACX_SLOT                    = 0x0004,
-        ACX_QUEUE_HEAD              = 0x0005, /* for MASTER mode only */
-        ACX_AC_CFG                  = 0x0007,
-        ACX_MEM_MAP                 = 0x0008,
-        ACX_AID                     = 0x000A,
-        ACX_RADIO_PARAM             = 0x000B, /* Not used */
-        ACX_CFG                     = 0x000C, /* Not used */
-        ACX_FW_REV                  = 0x000D,
-        ACX_MEDIUM_USAGE            = 0x000F,
-        ACX_RX_CFG                  = 0x0010,
-        ACX_TX_QUEUE_CFG            = 0x0011, /* FIXME: only used by wl1251 */
-        ACX_BSS_IN_PS               = 0x0012, /* for AP only */
-        ACX_STATISTICS              = 0x0013, /* Debug API */
-        ACX_FEATURE_CFG             = 0x0015,
-        ACX_MISC_CFG                = 0x0017, /* Not used */
-        ACX_TID_CFG                 = 0x001A,
-        ACX_BEACON_FILTER_OPT       = 0x001F,
-        ACX_LOW_RSSI                = 0x0020,
-        ACX_NOISE_HIST              = 0x0021,
-        ACX_HDK_VERSION             = 0x0022, /* ??? */
-        ACX_PD_THRESHOLD            = 0x0023,
-        ACX_DATA_PATH_PARAMS        = 0x0024, /* WO */
-        ACX_DATA_PATH_RESP_PARAMS   = 0x0024, /* RO */
-        ACX_CCA_THRESHOLD           = 0x0025,
-        ACX_EVENT_MBOX_MASK         = 0x0026,
-#ifdef FW_RUNNING_AS_AP
-        ACX_DTIM_PERIOD             = 0x0027, /* for AP only */
-#else
-        ACX_WR_TBTT_AND_DTIM        = 0x0027, /* STA only */
-#endif
-        ACX_ACI_OPTION_CFG          = 0x0029, /* OBSOLETE (for 1251)*/
-        ACX_GPIO_CFG                = 0x002A, /* Not used */
-        ACX_GPIO_SET                = 0x002B, /* Not used */
-        ACX_PM_CFG                  = 0x002C, /* To Be Documented */
-        ACX_CONN_MONIT_PARAMS       = 0x002D,
-        ACX_AVERAGE_RSSI            = 0x002E, /* Not used */
-        ACX_CONS_TX_FAILURE         = 0x002F,
-        ACX_BCN_DTIM_OPTIONS        = 0x0031,
-        ACX_SG_ENABLE               = 0x0032,
-        ACX_SG_CFG                  = 0x0033,
-        ACX_ANTENNA_DIVERSITY_CFG   = 0x0035, /* To Be Documented */
-        ACX_LOW_SNR                 = 0x0037, /* To Be Documented */
-        ACX_BEACON_FILTER_TABLE     = 0x0038,
-        ACX_ARP_IP_FILTER           = 0x0039,
-        ACX_ROAMING_STATISTICS_TBL  = 0x003B,
-        ACX_RATE_POLICY             = 0x003D,
-        ACX_CTS_PROTECTION          = 0x003E,
-        ACX_SLEEP_AUTH              = 0x003F,
-        ACX_PREAMBLE_TYPE           = 0x0040,
-        ACX_ERROR_CNT               = 0x0041,
-        ACX_FW_GEN_FRAME_RATES      = 0x0042,
-        ACX_IBSS_FILTER             = 0x0044,
-        ACX_SERVICE_PERIOD_TIMEOUT  = 0x0045,
-        ACX_TSF_INFO                = 0x0046,
-        ACX_CONFIG_PS_WMM           = 0x0049,
-        ACX_ENABLE_RX_DATA_FILTER   = 0x004A,
-        ACX_SET_RX_DATA_FILTER      = 0x004B,
-        ACX_GET_DATA_FILTER_STATISTICS = 0x004C,
-        ACX_POWER_LEVEL_TABLE       = 0x004D,
-        ACX_BET_ENABLE              = 0x0050,
-        DOT11_STATION_ID            = 0x1001,
-        DOT11_RX_MSDU_LIFE_TIME     = 0x1004,
-        DOT11_CUR_TX_PWR            = 0x100D,
-        DOT11_DEFAULT_KEY           = 0x1010,
-        DOT11_RX_DOT11_MODE         = 0x1012,
-        DOT11_RTS_THRESHOLD         = 0x1013,
-        DOT11_GROUP_ADDRESS_TBL     = 0x1014,
-
-        MAX_DOT11_IE = DOT11_GROUP_ADDRESS_TBL,
-
-        MAX_IE = 0xFFFF
-};
-
-
-int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
-                           u8 mgt_rate, u8 mgt_mod);
-int wl1251_acx_station_id(struct wl1251 *wl);
-int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id);
-int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
-                                  u8 listen_interval);
-int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth);
-int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len);
-int wl1251_acx_tx_power(struct wl1251 *wl, int power);
-int wl1251_acx_feature_cfg(struct wl1251 *wl);
-int wl1251_acx_mem_map(struct wl1251 *wl,
-                       struct acx_header *mem_map, size_t len);
-int wl1251_acx_data_path_params(struct wl1251 *wl,
-                                struct acx_data_path_params_resp *data_path);
-int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time);
-int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter);
-int wl1251_acx_pd_threshold(struct wl1251 *wl);
-int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time);
-int wl1251_acx_group_address_tbl(struct wl1251 *wl);
-int wl1251_acx_service_period_timeout(struct wl1251 *wl);
-int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold);
-int wl1251_acx_beacon_filter_opt(struct wl1251 *wl, bool enable_filter);
-int wl1251_acx_beacon_filter_table(struct wl1251 *wl);
-int wl1251_acx_conn_monit_params(struct wl1251 *wl);
-int wl1251_acx_sg_enable(struct wl1251 *wl);
-int wl1251_acx_sg_cfg(struct wl1251 *wl);
-int wl1251_acx_cca_threshold(struct wl1251 *wl);
-int wl1251_acx_bcn_dtim_options(struct wl1251 *wl);
-int wl1251_acx_aid(struct wl1251 *wl, u16 aid);
-int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask);
-int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble);
-int wl1251_acx_cts_protect(struct wl1251 *wl,
-                            enum acx_ctsprotect_type ctsprotect);
-int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats);
-int wl1251_acx_tsf_info(struct wl1251 *wl, u64 *mactime);
-int wl1251_acx_rate_policies(struct wl1251 *wl);
-int wl1251_acx_mem_cfg(struct wl1251 *wl);
-int wl1251_acx_wr_tbtt_and_dtim(struct wl1251 *wl, u16 tbtt, u8 dtim);
-int wl1251_acx_ac_cfg(struct wl1251 *wl, u8 ac, u8 cw_min, u16 cw_max,
-                      u8 aifs, u16 txop);
-int wl1251_acx_tid_cfg(struct wl1251 *wl, u8 queue,
-                       enum wl1251_acx_channel_type type,
-                       u8 tsid, enum wl1251_acx_ps_scheme ps_scheme,
-                       enum wl1251_acx_ack_policy ack_policy);
-
-#endif /* __WL1251_ACX_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1251_boot.c b/drivers/net/wireless/wl12xx/wl1251_boot.c
deleted file mode 100644
index 65e0416be5b6..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_boot.c
+++ /dev/null
@@ -1,559 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/gpio.h>
-#include <linux/slab.h>
-
-#include "wl1251_reg.h"
-#include "wl1251_boot.h"
-#include "wl1251_io.h"
-#include "wl1251_spi.h"
-#include "wl1251_event.h"
-#include "wl1251_acx.h"
-
-void wl1251_boot_target_enable_interrupts(struct wl1251 *wl)
-{
-        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask));
-        wl1251_reg_write32(wl, HI_CFG, HI_CFG_DEF_VAL);
-}
-
-int wl1251_boot_soft_reset(struct wl1251 *wl)
-{
-        unsigned long timeout;
-        u32 boot_data;
-
-        /* perform soft reset */
-        wl1251_reg_write32(wl, ACX_REG_SLV_SOFT_RESET, ACX_SLV_SOFT_RESET_BIT);
-
-        /* SOFT_RESET is self clearing */
-        timeout = jiffies + usecs_to_jiffies(SOFT_RESET_MAX_TIME);
-        while (1) {
-                boot_data = wl1251_reg_read32(wl, ACX_REG_SLV_SOFT_RESET);
-                wl1251_debug(DEBUG_BOOT, "soft reset bootdata 0x%x", boot_data);
-                if ((boot_data & ACX_SLV_SOFT_RESET_BIT) == 0)
-                        break;
-
-                if (time_after(jiffies, timeout)) {
-                        /* 1.2 check pWhalBus->uSelfClearTime if the
-                         * timeout was reached */
-                        wl1251_error("soft reset timeout");
-                        return -1;
-                }
-
-                udelay(SOFT_RESET_STALL_TIME);
-        }
-
-        /* disable Rx/Tx */
-        wl1251_reg_write32(wl, ENABLE, 0x0);
-
-        /* disable auto calibration on start*/
-        wl1251_reg_write32(wl, SPARE_A2, 0xffff);
-
-        return 0;
-}
-
-int wl1251_boot_init_seq(struct wl1251 *wl)
-{
-        u32 scr_pad6, init_data, tmp, elp_cmd, ref_freq;
-
-        /*
-         * col #1: INTEGER_DIVIDER
-         * col #2: FRACTIONAL_DIVIDER
-         * col #3: ATTN_BB
-         * col #4: ALPHA_BB
-         * col #5: STOP_TIME_BB
-         * col #6: BB_PLL_LOOP_FILTER
-         */
-        static const u32 LUT[REF_FREQ_NUM][LUT_PARAM_NUM] = {
-
-                {   83, 87381,  0xB, 5, 0xF00,  3}, /* REF_FREQ_19_2*/
-                {   61, 141154, 0xB, 5, 0x1450, 2}, /* REF_FREQ_26_0*/
-                {   41, 174763, 0xC, 6, 0x2D00, 1}, /* REF_FREQ_38_4*/
-                {   40, 0,      0xC, 6, 0x2EE0, 1}, /* REF_FREQ_40_0*/
-                {   47, 162280, 0xC, 6, 0x2760, 1}  /* REF_FREQ_33_6        */
-        };
-
-        /* read NVS params */
-        scr_pad6 = wl1251_reg_read32(wl, SCR_PAD6);
-        wl1251_debug(DEBUG_BOOT, "scr_pad6 0x%x", scr_pad6);
-
-        /* read ELP_CMD */
-        elp_cmd = wl1251_reg_read32(wl, ELP_CMD);
-        wl1251_debug(DEBUG_BOOT, "elp_cmd 0x%x", elp_cmd);
-
-        /* set the BB calibration time to be 300 usec (PLL_CAL_TIME) */
-        ref_freq = scr_pad6 & 0x000000FF;
-        wl1251_debug(DEBUG_BOOT, "ref_freq 0x%x", ref_freq);
-
-        wl1251_reg_write32(wl, PLL_CAL_TIME, 0x9);
-
-        /*
-         * PG 1.2: set the clock buffer time to be 210 usec (CLK_BUF_TIME)
-         */
-        wl1251_reg_write32(wl, CLK_BUF_TIME, 0x6);
-
-        /*
-         * set the clock detect feature to work in the restart wu procedure
-         * (ELP_CFG_MODE[14]) and Select the clock source type
-         * (ELP_CFG_MODE[13:12])
-         */
-        tmp = ((scr_pad6 & 0x0000FF00) << 4) | 0x00004000;
-        wl1251_reg_write32(wl, ELP_CFG_MODE, tmp);
-
-        /* PG 1.2: enable the BB PLL fix. Enable the PLL_LIMP_CLK_EN_CMD */
-        elp_cmd |= 0x00000040;
-        wl1251_reg_write32(wl, ELP_CMD, elp_cmd);
-
-        /* PG 1.2: Set the BB PLL stable time to be 1000usec
-         * (PLL_STABLE_TIME) */
-        wl1251_reg_write32(wl, CFG_PLL_SYNC_CNT, 0x20);
-
-        /* PG 1.2: read clock request time */
-        init_data = wl1251_reg_read32(wl, CLK_REQ_TIME);
-
-        /*
-         * PG 1.2: set the clock request time to be ref_clk_settling_time -
-         * 1ms = 4ms
-         */
-        if (init_data > 0x21)
-                tmp = init_data - 0x21;
-        else
-                tmp = 0;
-        wl1251_reg_write32(wl, CLK_REQ_TIME, tmp);
-
-        /* set BB PLL configurations in RF AFE */
-        wl1251_reg_write32(wl, 0x003058cc, 0x4B5);
-
-        /* set RF_AFE_REG_5 */
-        wl1251_reg_write32(wl, 0x003058d4, 0x50);
-
-        /* set RF_AFE_CTRL_REG_2 */
-        wl1251_reg_write32(wl, 0x00305948, 0x11c001);
-
-        /*
-         * change RF PLL and BB PLL divider for VCO clock and adjust VCO
-         * bais current(RF_AFE_REG_13)
-         */
-        wl1251_reg_write32(wl, 0x003058f4, 0x1e);
-
-        /* set BB PLL configurations */
-        tmp = LUT[ref_freq][LUT_PARAM_INTEGER_DIVIDER] | 0x00017000;
-        wl1251_reg_write32(wl, 0x00305840, tmp);
-
-        /* set fractional divider according to Appendix C-BB PLL
-         * Calculations
-         */
-        tmp = LUT[ref_freq][LUT_PARAM_FRACTIONAL_DIVIDER];
-        wl1251_reg_write32(wl, 0x00305844, tmp);
-
-        /* set the initial data for the sigma delta */
-        wl1251_reg_write32(wl, 0x00305848, 0x3039);
-
-        /*
-         * set the accumulator attenuation value, calibration loop1
-         * (alpha), calibration loop2 (beta), calibration loop3 (gamma) and
-         * the VCO gain
-         */
-        tmp = (LUT[ref_freq][LUT_PARAM_ATTN_BB] << 16) |
-                (LUT[ref_freq][LUT_PARAM_ALPHA_BB] << 12) | 0x1;
-        wl1251_reg_write32(wl, 0x00305854, tmp);
-
-        /*
-         * set the calibration stop time after holdoff time expires and set
-         * settling time HOLD_OFF_TIME_BB
-         */
-        tmp = LUT[ref_freq][LUT_PARAM_STOP_TIME_BB] | 0x000A0000;
-        wl1251_reg_write32(wl, 0x00305858, tmp);
-
-        /*
-         * set BB PLL Loop filter capacitor3- BB_C3[2:0] and set BB PLL
-         * constant leakage current to linearize PFD to 0uA -
-         * BB_ILOOPF[7:3]
-         */
-        tmp = LUT[ref_freq][LUT_PARAM_BB_PLL_LOOP_FILTER] | 0x00000030;
-        wl1251_reg_write32(wl, 0x003058f8, tmp);
-
-        /*
-         * set regulator output voltage for n divider to
-         * 1.35-BB_REFDIV[1:0], set charge pump current- BB_CPGAIN[4:2],
-         * set BB PLL Loop filter capacitor2- BB_C2[7:5], set gain of BB
-         * PLL auto-call to normal mode- BB_CALGAIN_3DB[8]
-         */
-        wl1251_reg_write32(wl, 0x003058f0, 0x29);
-
-        /* enable restart wakeup sequence (ELP_CMD[0]) */
-        wl1251_reg_write32(wl, ELP_CMD, elp_cmd | 0x1);
-
-        /* restart sequence completed */
-        udelay(2000);
-
-        return 0;
-}
-
-static void wl1251_boot_set_ecpu_ctrl(struct wl1251 *wl, u32 flag)
-{
-        u32 cpu_ctrl;
-
-        /* 10.5.0 run the firmware (I) */
-        cpu_ctrl = wl1251_reg_read32(wl, ACX_REG_ECPU_CONTROL);
-
-        /* 10.5.1 run the firmware (II) */
-        cpu_ctrl &= ~flag;
-        wl1251_reg_write32(wl, ACX_REG_ECPU_CONTROL, cpu_ctrl);
-}
-
-int wl1251_boot_run_firmware(struct wl1251 *wl)
-{
-        int loop, ret;
-        u32 chip_id, acx_intr;
-
-        wl1251_boot_set_ecpu_ctrl(wl, ECPU_CONTROL_HALT);
-
-        chip_id = wl1251_reg_read32(wl, CHIP_ID_B);
-
-        wl1251_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x", chip_id);
-
-        if (chip_id != wl->chip_id) {
-                wl1251_error("chip id doesn't match after firmware boot");
-                return -EIO;
-        }
-
-        /* wait for init to complete */
-        loop = 0;
-        while (loop++ < INIT_LOOP) {
-                udelay(INIT_LOOP_DELAY);
-                acx_intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
-
-                if (acx_intr == 0xffffffff) {
-                        wl1251_error("error reading hardware complete "
-                                     "init indication");
-                        return -EIO;
-                }
-                /* check that ACX_INTR_INIT_COMPLETE is enabled */
-                else if (acx_intr & WL1251_ACX_INTR_INIT_COMPLETE) {
-                        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
-                                           WL1251_ACX_INTR_INIT_COMPLETE);
-                        break;
-                }
-        }
-
-        if (loop > INIT_LOOP) {
-                wl1251_error("timeout waiting for the hardware to "
-                             "complete initialization");
-                return -EIO;
-        }
-
-        /* get hardware config command mail box */
-        wl->cmd_box_addr = wl1251_reg_read32(wl, REG_COMMAND_MAILBOX_PTR);
-
-        /* get hardware config event mail box */
-        wl->event_box_addr = wl1251_reg_read32(wl, REG_EVENT_MAILBOX_PTR);
-
-        /* set the working partition to its "running" mode offset */
-        wl1251_set_partition(wl, WL1251_PART_WORK_MEM_START,
-                             WL1251_PART_WORK_MEM_SIZE,
-                             WL1251_PART_WORK_REG_START,
-                             WL1251_PART_WORK_REG_SIZE);
-
-        wl1251_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x event_box_addr 0x%x",
-                     wl->cmd_box_addr, wl->event_box_addr);
-
-        wl1251_acx_fw_version(wl, wl->fw_ver, sizeof(wl->fw_ver));
-
-        /*
-         * in case of full asynchronous mode the firmware event must be
-         * ready to receive event from the command mailbox
-         */
-
-        /* enable gpio interrupts */
-        wl1251_enable_interrupts(wl);
-
-        /* Enable target's interrupts */
-        wl->intr_mask = WL1251_ACX_INTR_RX0_DATA |
-                WL1251_ACX_INTR_RX1_DATA |
-                WL1251_ACX_INTR_TX_RESULT |
-                WL1251_ACX_INTR_EVENT_A |
-                WL1251_ACX_INTR_EVENT_B |
-                WL1251_ACX_INTR_INIT_COMPLETE;
-        wl1251_boot_target_enable_interrupts(wl);
-
-        wl->event_mask = SCAN_COMPLETE_EVENT_ID | BSS_LOSE_EVENT_ID |
-                SYNCHRONIZATION_TIMEOUT_EVENT_ID |
-                ROAMING_TRIGGER_LOW_RSSI_EVENT_ID |
-                ROAMING_TRIGGER_REGAINED_RSSI_EVENT_ID |
-                REGAINED_BSS_EVENT_ID | BT_PTA_SENSE_EVENT_ID |
-                BT_PTA_PREDICTION_EVENT_ID;
-
-        ret = wl1251_event_unmask(wl);
-        if (ret < 0) {
-                wl1251_error("EVENT mask setting failed");
-                return ret;
-        }
-
-        wl1251_event_mbox_config(wl);
-
-        /* firmware startup completed */
-        return 0;
-}
-
-static int wl1251_boot_upload_firmware(struct wl1251 *wl)
-{
-        int addr, chunk_num, partition_limit;
-        size_t fw_data_len, len;
-        u8 *p, *buf;
-
-        /* whal_FwCtrl_LoadFwImageSm() */
-
-        wl1251_debug(DEBUG_BOOT, "chip id before fw upload: 0x%x",
-                     wl1251_reg_read32(wl, CHIP_ID_B));
-
-        /* 10.0 check firmware length and set partition */
-        fw_data_len =  (wl->fw[4] << 24) | (wl->fw[5] << 16) |
-                (wl->fw[6] << 8) | (wl->fw[7]);
-
-        wl1251_debug(DEBUG_BOOT, "fw_data_len %zu chunk_size %d", fw_data_len,
-                CHUNK_SIZE);
-
-        if ((fw_data_len % 4) != 0) {
-                wl1251_error("firmware length not multiple of four");
-                return -EIO;
-        }
-
-        buf = kmalloc(CHUNK_SIZE, GFP_KERNEL);
-        if (!buf) {
-                wl1251_error("allocation for firmware upload chunk failed");
-                return -ENOMEM;
-        }
-
-        wl1251_set_partition(wl, WL1251_PART_DOWN_MEM_START,
-                             WL1251_PART_DOWN_MEM_SIZE,
-                             WL1251_PART_DOWN_REG_START,
-                             WL1251_PART_DOWN_REG_SIZE);
-
-        /* 10.1 set partition limit and chunk num */
-        chunk_num = 0;
-        partition_limit = WL1251_PART_DOWN_MEM_SIZE;
-
-        while (chunk_num < fw_data_len / CHUNK_SIZE) {
-                /* 10.2 update partition, if needed */
-                addr = WL1251_PART_DOWN_MEM_START +
-                        (chunk_num + 2) * CHUNK_SIZE;
-                if (addr > partition_limit) {
-                        addr = WL1251_PART_DOWN_MEM_START +
-                                chunk_num * CHUNK_SIZE;
-                        partition_limit = chunk_num * CHUNK_SIZE +
-                                WL1251_PART_DOWN_MEM_SIZE;
-                        wl1251_set_partition(wl,
-                                             addr,
-                                             WL1251_PART_DOWN_MEM_SIZE,
-                                             WL1251_PART_DOWN_REG_START,
-                                             WL1251_PART_DOWN_REG_SIZE);
-                }
-
-                /* 10.3 upload the chunk */
-                addr = WL1251_PART_DOWN_MEM_START + chunk_num * CHUNK_SIZE;
-                p = wl->fw + FW_HDR_SIZE + chunk_num * CHUNK_SIZE;
-                wl1251_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x",
-                             p, addr);
-
-                /* need to copy the chunk for dma */
-                len = CHUNK_SIZE;
-                memcpy(buf, p, len);
-                wl1251_mem_write(wl, addr, buf, len);
-
-                chunk_num++;
-        }
-
-        /* 10.4 upload the last chunk */
-        addr = WL1251_PART_DOWN_MEM_START + chunk_num * CHUNK_SIZE;
-        p = wl->fw + FW_HDR_SIZE + chunk_num * CHUNK_SIZE;
-
-        /* need to copy the chunk for dma */
-        len = fw_data_len % CHUNK_SIZE;
-        memcpy(buf, p, len);
-
-        wl1251_debug(DEBUG_BOOT, "uploading fw last chunk (%zu B) 0x%p to 0x%x",
-                     len, p, addr);
-        wl1251_mem_write(wl, addr, buf, len);
-
-        kfree(buf);
-
-        return 0;
-}
-
-static int wl1251_boot_upload_nvs(struct wl1251 *wl)
-{
-        size_t nvs_len, nvs_bytes_written, burst_len;
-        int nvs_start, i;
-        u32 dest_addr, val;
-        u8 *nvs_ptr, *nvs;
-
-        nvs = wl->nvs;
-        if (nvs == NULL)
-                return -ENODEV;
-
-        nvs_ptr = nvs;
-
-        nvs_len = wl->nvs_len;
-        nvs_start = wl->fw_len;
-
-        /*
-         * Layout before the actual NVS tables:
-         * 1 byte : burst length.
-         * 2 bytes: destination address.
-         * n bytes: data to burst copy.
-         *
-         * This is ended by a 0 length, then the NVS tables.
-         */
-
-        while (nvs_ptr[0]) {
-                burst_len = nvs_ptr[0];
-                dest_addr = (nvs_ptr[1] & 0xfe) | ((u32)(nvs_ptr[2] << 8));
-
-                /* We move our pointer to the data */
-                nvs_ptr += 3;
-
-                for (i = 0; i < burst_len; i++) {
-                        val = (nvs_ptr[0] | (nvs_ptr[1] << 8)
-                               | (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));
-
-                        wl1251_debug(DEBUG_BOOT,
-                                     "nvs burst write 0x%x: 0x%x",
-                                     dest_addr, val);
-                        wl1251_mem_write32(wl, dest_addr, val);
-
-                        nvs_ptr += 4;
-                        dest_addr += 4;
-                }
-        }
-
-        /*
-         * We've reached the first zero length, the first NVS table
-         * is 7 bytes further.
-         */
-        nvs_ptr += 7;
-        nvs_len -= nvs_ptr - nvs;
-        nvs_len = ALIGN(nvs_len, 4);
-
-        /* Now we must set the partition correctly */
-        wl1251_set_partition(wl, nvs_start,
-                             WL1251_PART_DOWN_MEM_SIZE,
-                             WL1251_PART_DOWN_REG_START,
-                             WL1251_PART_DOWN_REG_SIZE);
-
-        /* And finally we upload the NVS tables */
-        nvs_bytes_written = 0;
-        while (nvs_bytes_written < nvs_len) {
-                val = (nvs_ptr[0] | (nvs_ptr[1] << 8)
-                       | (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));
-
-                val = cpu_to_le32(val);
-
-                wl1251_debug(DEBUG_BOOT,
-                             "nvs write table 0x%x: 0x%x",
-                             nvs_start, val);
-                wl1251_mem_write32(wl, nvs_start, val);
-
-                nvs_ptr += 4;
-                nvs_bytes_written += 4;
-                nvs_start += 4;
-        }
-
-        return 0;
-}
-
-int wl1251_boot(struct wl1251 *wl)
-{
-        int ret = 0, minor_minor_e2_ver;
-        u32 tmp, boot_data;
-
-        /* halt embedded ARM CPU while loading firmware */
-        wl1251_reg_write32(wl, ACX_REG_ECPU_CONTROL, ECPU_CONTROL_HALT);
-
-        ret = wl1251_boot_soft_reset(wl);
-        if (ret < 0)
-                goto out;
-
-        /* 2. start processing NVS file */
-        if (wl->use_eeprom) {
-                wl1251_reg_write32(wl, ACX_REG_EE_START, START_EEPROM_MGR);
-                /* Wait for EEPROM NVS burst read to complete */
-                msleep(40);
-                wl1251_reg_write32(wl, ACX_EEPROMLESS_IND_REG, USE_EEPROM);
-        } else {
-                ret = wl1251_boot_upload_nvs(wl);
-                if (ret < 0)
-                        goto out;
-
-                /* write firmware's last address (ie. it's length) to
-                 * ACX_EEPROMLESS_IND_REG */
-                wl1251_reg_write32(wl, ACX_EEPROMLESS_IND_REG, wl->fw_len);
-        }
-
-        /* 6. read the EEPROM parameters */
-        tmp = wl1251_reg_read32(wl, SCR_PAD2);
-
-        /* 7. read bootdata */
-        wl->boot_attr.radio_type = (tmp & 0x0000FF00) >> 8;
-        wl->boot_attr.major = (tmp & 0x00FF0000) >> 16;
-        tmp = wl1251_reg_read32(wl, SCR_PAD3);
-
-        /* 8. check bootdata and call restart sequence */
-        wl->boot_attr.minor = (tmp & 0x00FF0000) >> 16;
-        minor_minor_e2_ver = (tmp & 0xFF000000) >> 24;
-
-        wl1251_debug(DEBUG_BOOT, "radioType 0x%x majorE2Ver 0x%x "
-                     "minorE2Ver 0x%x minor_minor_e2_ver 0x%x",
-                     wl->boot_attr.radio_type, wl->boot_attr.major,
-                     wl->boot_attr.minor, minor_minor_e2_ver);
-
-        ret = wl1251_boot_init_seq(wl);
-        if (ret < 0)
-                goto out;
-
-        /* 9. NVS processing done */
-        boot_data = wl1251_reg_read32(wl, ACX_REG_ECPU_CONTROL);
-
-        wl1251_debug(DEBUG_BOOT, "halt boot_data 0x%x", boot_data);
-
-        /* 10. check that ECPU_CONTROL_HALT bits are set in
-         * pWhalBus->uBootData and start uploading firmware
-         */
-        if ((boot_data & ECPU_CONTROL_HALT) == 0) {
-                wl1251_error("boot failed, ECPU_CONTROL_HALT not set");
-                ret = -EIO;
-                goto out;
-        }
-
-        ret = wl1251_boot_upload_firmware(wl);
-        if (ret < 0)
-                goto out;
-
-        /* 10.5 start firmware */
-        ret = wl1251_boot_run_firmware(wl);
-        if (ret < 0)
-                goto out;
-
-out:
-        return ret;
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_boot.h b/drivers/net/wireless/wl12xx/wl1251_boot.h
deleted file mode 100644
index 90063697e8f2..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_boot.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __BOOT_H__
-#define __BOOT_H__
-
-#include "wl1251.h"
-
-int wl1251_boot_soft_reset(struct wl1251 *wl);
-int wl1251_boot_init_seq(struct wl1251 *wl);
-int wl1251_boot_run_firmware(struct wl1251 *wl);
-void wl1251_boot_target_enable_interrupts(struct wl1251 *wl);
-int wl1251_boot(struct wl1251 *wl);
-
-/* number of times we try to read the INIT interrupt */
-#define INIT_LOOP 20000
-
-/* delay between retries */
-#define INIT_LOOP_DELAY 50
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1251_cmd.c b/drivers/net/wireless/wl12xx/wl1251_cmd.c
deleted file mode 100644
index ce3722f4c3e3..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_cmd.c
+++ /dev/null
@@ -1,496 +0,0 @@
-#include "wl1251_cmd.h"
-
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/crc7.h>
-
-#include "wl1251.h"
-#include "wl1251_reg.h"
-#include "wl1251_io.h"
-#include "wl1251_ps.h"
-#include "wl1251_acx.h"
-
-/**
- * send command to firmware
- *
- * @wl: wl struct
- * @id: command id
- * @buf: buffer containing the command, must work with dma
- * @len: length of the buffer
- */
-int wl1251_cmd_send(struct wl1251 *wl, u16 id, void *buf, size_t len)
-{
-        struct wl1251_cmd_header *cmd;
-        unsigned long timeout;
-        u32 intr;
-        int ret = 0;
-
-        cmd = buf;
-        cmd->id = id;
-        cmd->status = 0;
-
-        WARN_ON(len % 4 != 0);
-
-        wl1251_mem_write(wl, wl->cmd_box_addr, buf, len);
-
-        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD);
-
-        timeout = jiffies + msecs_to_jiffies(WL1251_COMMAND_TIMEOUT);
-
-        intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
-        while (!(intr & WL1251_ACX_INTR_CMD_COMPLETE)) {
-                if (time_after(jiffies, timeout)) {
-                        wl1251_error("command complete timeout");
-                        ret = -ETIMEDOUT;
-                        goto out;
-                }
-
-                msleep(1);
-
-                intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
-        }
-
-        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
-                           WL1251_ACX_INTR_CMD_COMPLETE);
-
-out:
-        return ret;
-}
-
-/**
- * send test command to firmware
- *
- * @wl: wl struct
- * @buf: buffer containing the command, with all headers, must work with dma
- * @len: length of the buffer
- * @answer: is answer needed
- */
-int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer)
-{
-        int ret;
-
-        wl1251_debug(DEBUG_CMD, "cmd test");
-
-        ret = wl1251_cmd_send(wl, CMD_TEST, buf, buf_len);
-
-        if (ret < 0) {
-                wl1251_warning("TEST command failed");
-                return ret;
-        }
-
-        if (answer) {
-                struct wl1251_command *cmd_answer;
-
-                /*
-                 * The test command got in, we can read the answer.
-                 * The answer would be a wl1251_command, where the
-                 * parameter array contains the actual answer.
-                 */
-                wl1251_mem_read(wl, wl->cmd_box_addr, buf, buf_len);
-
-                cmd_answer = buf;
-
-                if (cmd_answer->header.status != CMD_STATUS_SUCCESS)
-                        wl1251_error("TEST command answer error: %d",
-                                     cmd_answer->header.status);
-        }
-
-        return 0;
-}
-
-/**
- * read acx from firmware
- *
- * @wl: wl struct
- * @id: acx id
- * @buf: buffer for the response, including all headers, must work with dma
- * @len: lenght of buf
- */
-int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len)
-{
-        struct acx_header *acx = buf;
-        int ret;
-
-        wl1251_debug(DEBUG_CMD, "cmd interrogate");
-
-        acx->id = id;
-
-        /* payload length, does not include any headers */
-        acx->len = len - sizeof(*acx);
-
-        ret = wl1251_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx));
-        if (ret < 0) {
-                wl1251_error("INTERROGATE command failed");
-                goto out;
-        }
-
-        /* the interrogate command got in, we can read the answer */
-        wl1251_mem_read(wl, wl->cmd_box_addr, buf, len);
-
-        acx = buf;
-        if (acx->cmd.status != CMD_STATUS_SUCCESS)
-                wl1251_error("INTERROGATE command error: %d",
-                             acx->cmd.status);
-
-out:
-        return ret;
-}
-
-/**
- * write acx value to firmware
- *
- * @wl: wl struct
- * @id: acx id
- * @buf: buffer containing acx, including all headers, must work with dma
- * @len: length of buf
- */
-int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len)
-{
-        struct acx_header *acx = buf;
-        int ret;
-
-        wl1251_debug(DEBUG_CMD, "cmd configure");
-
-        acx->id = id;
-
-        /* payload length, does not include any headers */
-        acx->len = len - sizeof(*acx);
-
-        ret = wl1251_cmd_send(wl, CMD_CONFIGURE, acx, len);
-        if (ret < 0) {
-                wl1251_warning("CONFIGURE command NOK");
-                return ret;
-        }
-
-        return 0;
-}
-
-int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
-                   void *bitmap, u16 bitmap_len, u8 bitmap_control)
-{
-        struct wl1251_cmd_vbm_update *vbm;
-        int ret;
-
-        wl1251_debug(DEBUG_CMD, "cmd vbm");
-
-        vbm = kzalloc(sizeof(*vbm), GFP_KERNEL);
-        if (!vbm) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* Count and period will be filled by the target */
-        vbm->tim.bitmap_ctrl = bitmap_control;
-        if (bitmap_len > PARTIAL_VBM_MAX) {
-                wl1251_warning("cmd vbm len is %d B, truncating to %d",
-                               bitmap_len, PARTIAL_VBM_MAX);
-                bitmap_len = PARTIAL_VBM_MAX;
-        }
-        memcpy(vbm->tim.pvb_field, bitmap, bitmap_len);
-        vbm->tim.identity = identity;
-        vbm->tim.length = bitmap_len + 3;
-
-        vbm->len = cpu_to_le16(bitmap_len + 5);
-
-        ret = wl1251_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm));
-        if (ret < 0) {
-                wl1251_error("VBM command failed");
-                goto out;
-        }
-
-out:
-        kfree(vbm);
-        return 0;
-}
-
-int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)
-{
-        struct cmd_enabledisable_path *cmd;
-        int ret;
-        u16 cmd_rx, cmd_tx;
-
-        wl1251_debug(DEBUG_CMD, "cmd data path");
-
-        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
-        if (!cmd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        cmd->channel = channel;
-
-        if (enable) {
-                cmd_rx = CMD_ENABLE_RX;
-                cmd_tx = CMD_ENABLE_TX;
-        } else {
-                cmd_rx = CMD_DISABLE_RX;
-                cmd_tx = CMD_DISABLE_TX;
-        }
-
-        ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd));
-        if (ret < 0) {
-                wl1251_error("rx %s cmd for channel %d failed",
-                             enable ? "start" : "stop", channel);
-                goto out;
-        }
-
-        wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d",
-                     enable ? "start" : "stop", channel);
-
-        ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd));
-        if (ret < 0) {
-                wl1251_error("tx %s cmd for channel %d failed",
-                             enable ? "start" : "stop", channel);
-                return ret;
-        }
-
-        wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
-                     enable ? "start" : "stop", channel);
-
-out:
-        kfree(cmd);
-        return ret;
-}
-
-int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel,
-                    u16 beacon_interval, u8 dtim_interval)
-{
-        struct cmd_join *join;
-        int ret, i;
-        u8 *bssid;
-
-        join = kzalloc(sizeof(*join), GFP_KERNEL);
-        if (!join) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d",
-                     bss_type == BSS_TYPE_IBSS ? " ibss" : "",
-                     channel, beacon_interval, dtim_interval);
-
-        /* Reverse order BSSID */
-        bssid = (u8 *) &join->bssid_lsb;
-        for (i = 0; i < ETH_ALEN; i++)
-                bssid[i] = wl->bssid[ETH_ALEN - i - 1];
-
-        join->rx_config_options = wl->rx_config;
-        join->rx_filter_options = wl->rx_filter;
-
-        /*
-         * FIXME: disable temporarily all filters because after commit
-         * 9cef8737 "mac80211: fix managed mode BSSID handling" broke
-         * association. The filter logic needs to be implemented properly
-         * and once that is done, this hack can be removed.
-         */
-        join->rx_config_options = 0;
-        join->rx_filter_options = WL1251_DEFAULT_RX_FILTER;
-
-        join->basic_rate_set = RATE_MASK_1MBPS | RATE_MASK_2MBPS |
-                RATE_MASK_5_5MBPS | RATE_MASK_11MBPS;
-
-        join->beacon_interval = beacon_interval;
-        join->dtim_interval = dtim_interval;
-        join->bss_type = bss_type;
-        join->channel = channel;
-        join->ctrl = JOIN_CMD_CTRL_TX_FLUSH;
-
-        ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join));
-        if (ret < 0) {
-                wl1251_error("failed to initiate cmd join");
-                goto out;
-        }
-
-out:
-        kfree(join);
-        return ret;
-}
-
-int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode)
-{
-        struct wl1251_cmd_ps_params *ps_params = NULL;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_CMD, "cmd set ps mode");
-
-        ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
-        if (!ps_params) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ps_params->ps_mode = ps_mode;
-        ps_params->send_null_data = 1;
-        ps_params->retries = 5;
-        ps_params->hang_over_period = 128;
-        ps_params->null_data_rate = 1; /* 1 Mbps */
-
-        ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
-                              sizeof(*ps_params));
-        if (ret < 0) {
-                wl1251_error("cmd set_ps_mode failed");
-                goto out;
-        }
-
-out:
-        kfree(ps_params);
-        return ret;
-}
-
-int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
-                           size_t len)
-{
-        struct cmd_read_write_memory *cmd;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_CMD, "cmd read memory");
-
-        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
-        if (!cmd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        WARN_ON(len > MAX_READ_SIZE);
-        len = min_t(size_t, len, MAX_READ_SIZE);
-
-        cmd->addr = addr;
-        cmd->size = len;
-
-        ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd));
-        if (ret < 0) {
-                wl1251_error("read memory command failed: %d", ret);
-                goto out;
-        }
-
-        /* the read command got in, we can now read the answer */
-        wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
-
-        if (cmd->header.status != CMD_STATUS_SUCCESS)
-                wl1251_error("error in read command result: %d",
-                             cmd->header.status);
-
-        memcpy(answer, cmd->value, len);
-
-out:
-        kfree(cmd);
-        return ret;
-}
-
-int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
-                            void *buf, size_t buf_len)
-{
-        struct wl1251_cmd_packet_template *cmd;
-        size_t cmd_len;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id);
-
-        WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE);
-        buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE);
-        cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4);
-
-        cmd = kzalloc(cmd_len, GFP_KERNEL);
-        if (!cmd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        cmd->size = cpu_to_le16(buf_len);
-
-        if (buf)
-                memcpy(cmd->data, buf, buf_len);
-
-        ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len);
-        if (ret < 0) {
-                wl1251_warning("cmd set_template failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(cmd);
-        return ret;
-}
-
-int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len,
-                    struct ieee80211_channel *channels[],
-                    unsigned int n_channels, unsigned int n_probes)
-{
-        struct wl1251_cmd_scan *cmd;
-        int i, ret = 0;
-
-        wl1251_debug(DEBUG_CMD, "cmd scan");
-
-        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
-        if (!cmd)
-                return -ENOMEM;
-
-        cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
-        cmd->params.rx_filter_options = cpu_to_le32(CFG_RX_PRSP_EN |
-                                                    CFG_RX_MGMT_EN |
-                                                    CFG_RX_BCN_EN);
-        cmd->params.scan_options = 0;
-        cmd->params.num_channels = n_channels;
-        cmd->params.num_probe_requests = n_probes;
-        cmd->params.tx_rate = cpu_to_le16(1 << 1); /* 2 Mbps */
-        cmd->params.tid_trigger = 0;
-
-        for (i = 0; i < n_channels; i++) {
-                cmd->channels[i].min_duration =
-                        cpu_to_le32(WL1251_SCAN_MIN_DURATION);
-                cmd->channels[i].max_duration =
-                        cpu_to_le32(WL1251_SCAN_MAX_DURATION);
-                memset(&cmd->channels[i].bssid_lsb, 0xff, 4);
-                memset(&cmd->channels[i].bssid_msb, 0xff, 2);
-                cmd->channels[i].early_termination = 0;
-                cmd->channels[i].tx_power_att = 0;
-                cmd->channels[i].channel = channels[i]->hw_value;
-        }
-
-        cmd->params.ssid_len = ssid_len;
-        if (ssid)
-                memcpy(cmd->params.ssid, ssid, ssid_len);
-
-        ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd));
-        if (ret < 0) {
-                wl1251_error("cmd scan failed: %d", ret);
-                goto out;
-        }
-
-        wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
-
-        if (cmd->header.status != CMD_STATUS_SUCCESS) {
-                wl1251_error("cmd scan status wasn't success: %d",
-                             cmd->header.status);
-                ret = -EIO;
-                goto out;
-        }
-
-out:
-        kfree(cmd);
-        return ret;
-}
-
-int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout)
-{
-        struct wl1251_cmd_trigger_scan_to *cmd;
-        int ret;
-
-        wl1251_debug(DEBUG_CMD, "cmd trigger scan to");
-
-        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
-        if (!cmd)
-                return -ENOMEM;
-
-        cmd->timeout = timeout;
-
-        ret = wl1251_cmd_send(wl, CMD_TRIGGER_SCAN_TO, cmd, sizeof(*cmd));
-        if (ret < 0) {
-                wl1251_error("cmd trigger scan to failed: %d", ret);
-                goto out;
-        }
-
-out:
-        kfree(cmd);
-        return ret;
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_cmd.h b/drivers/net/wireless/wl12xx/wl1251_cmd.h
deleted file mode 100644
index a9e4991369be..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_cmd.h
+++ /dev/null
@@ -1,417 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_CMD_H__
-#define __WL1251_CMD_H__
-
-#include "wl1251.h"
-
-#include <net/cfg80211.h>
-
-struct acx_header;
-
-int wl1251_cmd_send(struct wl1251 *wl, u16 type, void *buf, size_t buf_len);
-int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer);
-int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len);
-int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len);
-int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
-                   void *bitmap, u16 bitmap_len, u8 bitmap_control);
-int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable);
-int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel,
-                    u16 beacon_interval, u8 dtim_interval);
-int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode);
-int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
-                           size_t len);
-int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
-                            void *buf, size_t buf_len);
-int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len,
-                    struct ieee80211_channel *channels[],
-                    unsigned int n_channels, unsigned int n_probes);
-int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout);
-
-/* unit ms */
-#define WL1251_COMMAND_TIMEOUT 2000
-
-enum wl1251_commands {
-        CMD_RESET           = 0,
-        CMD_INTERROGATE     = 1,    /*use this to read information elements*/
-        CMD_CONFIGURE       = 2,    /*use this to write information elements*/
-        CMD_ENABLE_RX       = 3,
-        CMD_ENABLE_TX       = 4,
-        CMD_DISABLE_RX      = 5,
-        CMD_DISABLE_TX      = 6,
-        CMD_SCAN            = 8,
-        CMD_STOP_SCAN       = 9,
-        CMD_VBM             = 10,
-        CMD_START_JOIN      = 11,
-        CMD_SET_KEYS        = 12,
-        CMD_READ_MEMORY     = 13,
-        CMD_WRITE_MEMORY    = 14,
-        CMD_BEACON          = 19,
-        CMD_PROBE_RESP      = 20,
-        CMD_NULL_DATA       = 21,
-        CMD_PROBE_REQ       = 22,
-        CMD_TEST            = 23,
-        CMD_RADIO_CALIBRATE     = 25,   /* OBSOLETE */
-        CMD_ENABLE_RX_PATH      = 27,   /* OBSOLETE */
-        CMD_NOISE_HIST      = 28,
-        CMD_RX_RESET        = 29,
-        CMD_PS_POLL         = 30,
-        CMD_QOS_NULL_DATA   = 31,
-        CMD_LNA_CONTROL     = 32,
-        CMD_SET_BCN_MODE    = 33,
-        CMD_MEASUREMENT      = 34,
-        CMD_STOP_MEASUREMENT = 35,
-        CMD_DISCONNECT       = 36,
-        CMD_SET_PS_MODE      = 37,
-        CMD_CHANNEL_SWITCH   = 38,
-        CMD_STOP_CHANNEL_SWICTH = 39,
-        CMD_AP_DISCOVERY     = 40,
-        CMD_STOP_AP_DISCOVERY = 41,
-        CMD_SPS_SCAN = 42,
-        CMD_STOP_SPS_SCAN = 43,
-        CMD_HEALTH_CHECK     = 45,
-        CMD_DEBUG            = 46,
-        CMD_TRIGGER_SCAN_TO  = 47,
-
-        NUM_COMMANDS,
-        MAX_COMMAND_ID = 0xFFFF,
-};
-
-#define MAX_CMD_PARAMS 572
-
-struct wl1251_cmd_header {
-        u16 id;
-        u16 status;
-        /* payload */
-        u8 data[0];
-} __packed;
-
-struct  wl1251_command {
-        struct wl1251_cmd_header header;
-        u8  parameters[MAX_CMD_PARAMS];
-};
-
-enum {
-        CMD_MAILBOX_IDLE                        =  0,
-        CMD_STATUS_SUCCESS                      =  1,
-        CMD_STATUS_UNKNOWN_CMD                  =  2,
-        CMD_STATUS_UNKNOWN_IE                   =  3,
-        CMD_STATUS_REJECT_MEAS_SG_ACTIVE        = 11,
-        CMD_STATUS_RX_BUSY                      = 13,
-        CMD_STATUS_INVALID_PARAM                = 14,
-        CMD_STATUS_TEMPLATE_TOO_LARGE           = 15,
-        CMD_STATUS_OUT_OF_MEMORY                = 16,
-        CMD_STATUS_STA_TABLE_FULL               = 17,
-        CMD_STATUS_RADIO_ERROR                  = 18,
-        CMD_STATUS_WRONG_NESTING                = 19,
-        CMD_STATUS_TIMEOUT                      = 21, /* Driver internal use.*/
-        CMD_STATUS_FW_RESET                     = 22, /* Driver internal use.*/
-        MAX_COMMAND_STATUS                      = 0xff
-};
-
-
-/*
- * CMD_READ_MEMORY
- *
- * The host issues this command to read the WiLink device memory/registers.
- *
- * Note: The Base Band address has special handling (16 bits registers and
- * addresses). For more information, see the hardware specification.
- */
-/*
- * CMD_WRITE_MEMORY
- *
- * The host issues this command to write the WiLink device memory/registers.
- *
- * The Base Band address has special handling (16 bits registers and
- * addresses). For more information, see the hardware specification.
- */
-#define MAX_READ_SIZE 256
-
-struct cmd_read_write_memory {
-        struct wl1251_cmd_header header;
-
-        /* The address of the memory to read from or write to.*/
-        u32 addr;
-
-        /* The amount of data in bytes to read from or write to the WiLink
-         * device.*/
-        u32 size;
-
-        /* The actual value read from or written to the Wilink. The source
-           of this field is the Host in WRITE command or the Wilink in READ
-           command. */
-        u8 value[MAX_READ_SIZE];
-};
-
-#define CMDMBOX_HEADER_LEN 4
-#define CMDMBOX_INFO_ELEM_HEADER_LEN 4
-
-#define WL1251_SCAN_MIN_DURATION 30000
-#define WL1251_SCAN_MAX_DURATION 60000
-
-#define WL1251_SCAN_NUM_PROBES 3
-
-struct wl1251_scan_parameters {
-        __le32 rx_config_options;
-        __le32 rx_filter_options;
-
-        /*
-         * Scan options:
-         * bit 0: When this bit is set, passive scan.
-         * bit 1: Band, when this bit is set we scan
-         * in the 5Ghz band.
-         * bit 2: voice mode, 0 for normal scan.
-         * bit 3: scan priority, 1 for high priority.
-         */
-        __le16 scan_options;
-
-        /* Number of channels to scan */
-        u8 num_channels;
-
-        /* Number opf probe requests to send, per channel */
-        u8 num_probe_requests;
-
-        /* Rate and modulation for probe requests */
-        __le16 tx_rate;
-
-        u8 tid_trigger;
-        u8 ssid_len;
-        u8 ssid[32];
-
-} __packed;
-
-struct wl1251_scan_ch_parameters {
-        __le32 min_duration; /* in TU */
-        __le32 max_duration; /* in TU */
-        u32 bssid_lsb;
-        u16 bssid_msb;
-
-        /*
-         * bits 0-3: Early termination count.
-         * bits 4-5: Early termination condition.
-         */
-        u8 early_termination;
-
-        u8 tx_power_att;
-        u8 channel;
-        u8 pad[3];
-} __packed;
-
-/* SCAN parameters */
-#define SCAN_MAX_NUM_OF_CHANNELS 16
-
-struct wl1251_cmd_scan {
-        struct wl1251_cmd_header header;
-
-        struct wl1251_scan_parameters params;
-        struct wl1251_scan_ch_parameters channels[SCAN_MAX_NUM_OF_CHANNELS];
-} __packed;
-
-enum {
-        BSS_TYPE_IBSS = 0,
-        BSS_TYPE_STA_BSS = 2,
-        BSS_TYPE_AP_BSS = 3,
-        MAX_BSS_TYPE = 0xFF
-};
-
-#define JOIN_CMD_CTRL_TX_FLUSH             0x80 /* Firmware flushes all Tx */
-#define JOIN_CMD_CTRL_EARLY_WAKEUP_ENABLE  0x01 /* Early wakeup time */
-
-
-struct cmd_join {
-        struct wl1251_cmd_header header;
-
-        u32 bssid_lsb;
-        u16 bssid_msb;
-        u16 beacon_interval; /* in TBTTs */
-        u32 rx_config_options;
-        u32 rx_filter_options;
-
-        /*
-         * The target uses this field to determine the rate at
-         * which to transmit control frame responses (such as
-         * ACK or CTS frames).
-         */
-        u16 basic_rate_set;
-        u8 dtim_interval;
-        u8 tx_ctrl_frame_rate; /* OBSOLETE */
-        u8 tx_ctrl_frame_mod;  /* OBSOLETE */
-        /*
-         * bits 0-2: This bitwise field specifies the type
-         * of BSS to start or join (BSS_TYPE_*).
-         * bit 4: Band - The radio band in which to join
-         * or start.
-         *  0 - 2.4GHz band
-         *  1 - 5GHz band
-         * bits 3, 5-7: Reserved
-         */
-        u8 bss_type;
-        u8 channel;
-        u8 ssid_len;
-        u8 ssid[IW_ESSID_MAX_SIZE];
-        u8 ctrl; /* JOIN_CMD_CTRL_* */
-        u8 tx_mgt_frame_rate; /* OBSOLETE */
-        u8 tx_mgt_frame_mod;  /* OBSOLETE */
-        u8 reserved;
-} __packed;
-
-struct cmd_enabledisable_path {
-        struct wl1251_cmd_header header;
-
-        u8 channel;
-        u8 padding[3];
-} __packed;
-
-#define WL1251_MAX_TEMPLATE_SIZE 300
-
-struct wl1251_cmd_packet_template {
-        struct wl1251_cmd_header header;
-
-        __le16 size;
-        u8 data[0];
-} __packed;
-
-#define TIM_ELE_ID    5
-#define PARTIAL_VBM_MAX    251
-
-struct wl1251_tim {
-        u8 identity;
-        u8 length;
-        u8 dtim_count;
-        u8 dtim_period;
-        u8 bitmap_ctrl;
-        u8 pvb_field[PARTIAL_VBM_MAX]; /* Partial Virtual Bitmap */
-} __packed;
-
-/* Virtual Bit Map update */
-struct wl1251_cmd_vbm_update {
-        struct wl1251_cmd_header header;
-        __le16 len;
-        u8  padding[2];
-        struct wl1251_tim tim;
-} __packed;
-
-enum wl1251_cmd_ps_mode {
-        STATION_ACTIVE_MODE,
-        STATION_POWER_SAVE_MODE
-};
-
-struct wl1251_cmd_ps_params {
-        struct wl1251_cmd_header header;
-
-        u8 ps_mode; /* STATION_* */
-        u8 send_null_data; /* Do we have to send NULL data packet ? */
-        u8 retries; /* Number of retires for the initial NULL data packet */
-
-         /*
-          * TUs during which the target stays awake after switching
-          * to power save mode.
-          */
-        u8 hang_over_period;
-        u16 null_data_rate;
-        u8 pad[2];
-} __packed;
-
-struct wl1251_cmd_trigger_scan_to {
-        struct wl1251_cmd_header header;
-
-        u32 timeout;
-};
-
-/* HW encryption keys */
-#define NUM_ACCESS_CATEGORIES_COPY 4
-#define MAX_KEY_SIZE 32
-
-/* When set, disable HW encryption */
-#define DF_ENCRYPTION_DISABLE      0x01
-/* When set, disable HW decryption */
-#define DF_SNIFF_MODE_ENABLE       0x80
-
-enum wl1251_cmd_key_action {
-        KEY_ADD_OR_REPLACE = 1,
-        KEY_REMOVE         = 2,
-        KEY_SET_ID         = 3,
-        MAX_KEY_ACTION     = 0xffff,
-};
-
-enum wl1251_cmd_key_type {
-        KEY_WEP_DEFAULT       = 0,
-        KEY_WEP_ADDR          = 1,
-        KEY_AES_GROUP         = 4,
-        KEY_AES_PAIRWISE      = 5,
-        KEY_WEP_GROUP         = 6,
-        KEY_TKIP_MIC_GROUP    = 10,
-        KEY_TKIP_MIC_PAIRWISE = 11,
-};
-
-/*
- *
- * key_type_e   key size    key format
- * ----------   ---------   ----------
- * 0x00         5, 13, 29   Key data
- * 0x01         5, 13, 29   Key data
- * 0x04         16          16 bytes of key data
- * 0x05         16          16 bytes of key data
- * 0x0a         32          16 bytes of TKIP key data
- *                          8 bytes of RX MIC key data
- *                          8 bytes of TX MIC key data
- * 0x0b         32          16 bytes of TKIP key data
- *                          8 bytes of RX MIC key data
- *                          8 bytes of TX MIC key data
- *
- */
-
-struct wl1251_cmd_set_keys {
-        struct wl1251_cmd_header header;
-
-        /* Ignored for default WEP key */
-        u8 addr[ETH_ALEN];
-
-        /* key_action_e */
-        u16 key_action;
-
-        u16 reserved_1;
-
-        /* key size in bytes */
-        u8 key_size;
-
-        /* key_type_e */
-        u8 key_type;
-        u8 ssid_profile;
-
-        /*
-         * TKIP, AES: frame's key id field.
-         * For WEP default key: key id;
-         */
-        u8 id;
-        u8 reserved_2[6];
-        u8 key[MAX_KEY_SIZE];
-        u16 ac_seq_num16[NUM_ACCESS_CATEGORIES_COPY];
-        u32 ac_seq_num32[NUM_ACCESS_CATEGORIES_COPY];
-} __packed;
-
-
-#endif /* __WL1251_CMD_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1251_debugfs.c b/drivers/net/wireless/wl12xx/wl1251_debugfs.c
deleted file mode 100644
index 5e4465ac08fa..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_debugfs.c
+++ /dev/null
@@ -1,543 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include "wl1251_debugfs.h"
-
-#include <linux/skbuff.h>
-#include <linux/slab.h>
-
-#include "wl1251.h"
-#include "wl1251_acx.h"
-#include "wl1251_ps.h"
-
-/* ms */
-#define WL1251_DEBUGFS_STATS_LIFETIME 1000
-
-/* debugfs macros idea from mac80211 */
-
-#define DEBUGFS_READONLY_FILE(name, buflen, fmt, value...)              \
-static ssize_t name## _read(struct file *file, char __user *userbuf,    \
-                            size_t count, loff_t *ppos)                 \
-{                                                                       \
-        struct wl1251 *wl = file->private_data;                         \
-        char buf[buflen];                                               \
-        int res;                                                        \
-                                                                        \
-        res = scnprintf(buf, buflen, fmt "\n", ##value);                \
-        return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
-}                                                                       \
-                                                                        \
-static const struct file_operations name## _ops = {                     \
-        .read = name## _read,                                           \
-        .open = wl1251_open_file_generic,                               \
-};
-
-#define DEBUGFS_ADD(name, parent)                                       \
-        wl->debugfs.name = debugfs_create_file(#name, 0400, parent,     \
-                                               wl, &name## _ops);       \
-        if (IS_ERR(wl->debugfs.name)) {                                 \
-                ret = PTR_ERR(wl->debugfs.name);                        \
-                wl->debugfs.name = NULL;                                \
-                goto out;                                               \
-        }
-
-#define DEBUGFS_DEL(name)                                               \
-        do {                                                            \
-                debugfs_remove(wl->debugfs.name);                       \
-                wl->debugfs.name = NULL;                                \
-        } while (0)
-
-#define DEBUGFS_FWSTATS_FILE(sub, name, buflen, fmt)                    \
-static ssize_t sub## _ ##name## _read(struct file *file,                \
-                                      char __user *userbuf,             \
-                                      size_t count, loff_t *ppos)       \
-{                                                                       \
-        struct wl1251 *wl = file->private_data;                         \
-        char buf[buflen];                                               \
-        int res;                                                        \
-                                                                        \
-        wl1251_debugfs_update_stats(wl);                                \
-                                                                        \
-        res = scnprintf(buf, buflen, fmt "\n",                          \
-                        wl->stats.fw_stats->sub.name);                  \
-        return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
-}                                                                       \
-                                                                        \
-static const struct file_operations sub## _ ##name## _ops = {           \
-        .read = sub## _ ##name## _read,                                 \
-        .open = wl1251_open_file_generic,                               \
-};
-
-#define DEBUGFS_FWSTATS_ADD(sub, name)                          \
-        DEBUGFS_ADD(sub## _ ##name, wl->debugfs.fw_statistics)
-
-#define DEBUGFS_FWSTATS_DEL(sub, name)                          \
-        DEBUGFS_DEL(sub## _ ##name)
-
-static void wl1251_debugfs_update_stats(struct wl1251 *wl)
-{
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        if (wl->state == WL1251_STATE_ON &&
-            time_after(jiffies, wl->stats.fw_stats_update +
-                       msecs_to_jiffies(WL1251_DEBUGFS_STATS_LIFETIME))) {
-                wl1251_acx_statistics(wl, wl->stats.fw_stats);
-                wl->stats.fw_stats_update = jiffies;
-        }
-
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1251_open_file_generic(struct inode *inode, struct file *file)
-{
-        file->private_data = inode->i_private;
-        return 0;
-}
-
-DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(rx, out_of_mem, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, hw_stuck, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, dropped, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, fcs_err, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, path_reset, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, reset_counter, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(dma, rx_requested, 20, "%u");
-DEBUGFS_FWSTATS_FILE(dma, rx_errors, 20, "%u");
-DEBUGFS_FWSTATS_FILE(dma, tx_requested, 20, "%u");
-DEBUGFS_FWSTATS_FILE(dma, tx_errors, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, fiqs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_headers, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_rdys, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, irqs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, tx_procs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, decrypt_done, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, dma0_done, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, dma1_done, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, commands, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_procs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, pci_pm, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, wakeups, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, low_rssi, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(wep, addr_key_count, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, default_key_count, 20, "%u");
-/* skipping wep.reserved */
-DEBUGFS_FWSTATS_FILE(wep, key_not_found, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, packets, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, interrupt, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(pwr, ps_enter, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, elp_enter, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, power_save_off, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, enable_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, disable_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, 20, "%u");
-/* skipping cont_miss_bcns_spread for now */
-DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(mic, rx_pkts, 20, "%u");
-DEBUGFS_FWSTATS_FILE(mic, calc_failure, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(event, heart_beat, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, calibration, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, rx_mismatch, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, rx_pool, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, oom_late, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, tx_stuck, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data,
-                     20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, 20, "%u");
-
-DEBUGFS_READONLY_FILE(retry_count, 20, "%u", wl->stats.retry_count);
-DEBUGFS_READONLY_FILE(excessive_retries, 20, "%u",
-                      wl->stats.excessive_retries);
-
-static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
-                                 size_t count, loff_t *ppos)
-{
-        struct wl1251 *wl = file->private_data;
-        u32 queue_len;
-        char buf[20];
-        int res;
-
-        queue_len = skb_queue_len(&wl->tx_queue);
-
-        res = scnprintf(buf, sizeof(buf), "%u\n", queue_len);
-        return simple_read_from_buffer(userbuf, count, ppos, buf, res);
-}
-
-static const struct file_operations tx_queue_len_ops = {
-        .read = tx_queue_len_read,
-        .open = wl1251_open_file_generic,
-};
-
-static ssize_t tx_queue_status_read(struct file *file, char __user *userbuf,
-                                    size_t count, loff_t *ppos)
-{
-        struct wl1251 *wl = file->private_data;
-        char buf[3], status;
-        int len;
-
-        if (wl->tx_queue_stopped)
-                status = 's';
-        else
-                status = 'r';
-
-        len = scnprintf(buf, sizeof(buf), "%c\n", status);
-        return simple_read_from_buffer(userbuf, count, ppos, buf, len);
-}
-
-static const struct file_operations tx_queue_status_ops = {
-        .read = tx_queue_status_read,
-        .open = wl1251_open_file_generic,
-};
-
-static void wl1251_debugfs_delete_files(struct wl1251 *wl)
-{
-        DEBUGFS_FWSTATS_DEL(tx, internal_desc_overflow);
-
-        DEBUGFS_FWSTATS_DEL(rx, out_of_mem);
-        DEBUGFS_FWSTATS_DEL(rx, hdr_overflow);
-        DEBUGFS_FWSTATS_DEL(rx, hw_stuck);
-        DEBUGFS_FWSTATS_DEL(rx, dropped);
-        DEBUGFS_FWSTATS_DEL(rx, fcs_err);
-        DEBUGFS_FWSTATS_DEL(rx, xfr_hint_trig);
-        DEBUGFS_FWSTATS_DEL(rx, path_reset);
-        DEBUGFS_FWSTATS_DEL(rx, reset_counter);
-
-        DEBUGFS_FWSTATS_DEL(dma, rx_requested);
-        DEBUGFS_FWSTATS_DEL(dma, rx_errors);
-        DEBUGFS_FWSTATS_DEL(dma, tx_requested);
-        DEBUGFS_FWSTATS_DEL(dma, tx_errors);
-
-        DEBUGFS_FWSTATS_DEL(isr, cmd_cmplt);
-        DEBUGFS_FWSTATS_DEL(isr, fiqs);
-        DEBUGFS_FWSTATS_DEL(isr, rx_headers);
-        DEBUGFS_FWSTATS_DEL(isr, rx_mem_overflow);
-        DEBUGFS_FWSTATS_DEL(isr, rx_rdys);
-        DEBUGFS_FWSTATS_DEL(isr, irqs);
-        DEBUGFS_FWSTATS_DEL(isr, tx_procs);
-        DEBUGFS_FWSTATS_DEL(isr, decrypt_done);
-        DEBUGFS_FWSTATS_DEL(isr, dma0_done);
-        DEBUGFS_FWSTATS_DEL(isr, dma1_done);
-        DEBUGFS_FWSTATS_DEL(isr, tx_exch_complete);
-        DEBUGFS_FWSTATS_DEL(isr, commands);
-        DEBUGFS_FWSTATS_DEL(isr, rx_procs);
-        DEBUGFS_FWSTATS_DEL(isr, hw_pm_mode_changes);
-        DEBUGFS_FWSTATS_DEL(isr, host_acknowledges);
-        DEBUGFS_FWSTATS_DEL(isr, pci_pm);
-        DEBUGFS_FWSTATS_DEL(isr, wakeups);
-        DEBUGFS_FWSTATS_DEL(isr, low_rssi);
-
-        DEBUGFS_FWSTATS_DEL(wep, addr_key_count);
-        DEBUGFS_FWSTATS_DEL(wep, default_key_count);
-        /* skipping wep.reserved */
-        DEBUGFS_FWSTATS_DEL(wep, key_not_found);
-        DEBUGFS_FWSTATS_DEL(wep, decrypt_fail);
-        DEBUGFS_FWSTATS_DEL(wep, packets);
-        DEBUGFS_FWSTATS_DEL(wep, interrupt);
-
-        DEBUGFS_FWSTATS_DEL(pwr, ps_enter);
-        DEBUGFS_FWSTATS_DEL(pwr, elp_enter);
-        DEBUGFS_FWSTATS_DEL(pwr, missing_bcns);
-        DEBUGFS_FWSTATS_DEL(pwr, wake_on_host);
-        DEBUGFS_FWSTATS_DEL(pwr, wake_on_timer_exp);
-        DEBUGFS_FWSTATS_DEL(pwr, tx_with_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, tx_without_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, rcvd_beacons);
-        DEBUGFS_FWSTATS_DEL(pwr, power_save_off);
-        DEBUGFS_FWSTATS_DEL(pwr, enable_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, disable_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, fix_tsf_ps);
-        /* skipping cont_miss_bcns_spread for now */
-        DEBUGFS_FWSTATS_DEL(pwr, rcvd_awake_beacons);
-
-        DEBUGFS_FWSTATS_DEL(mic, rx_pkts);
-        DEBUGFS_FWSTATS_DEL(mic, calc_failure);
-
-        DEBUGFS_FWSTATS_DEL(aes, encrypt_fail);
-        DEBUGFS_FWSTATS_DEL(aes, decrypt_fail);
-        DEBUGFS_FWSTATS_DEL(aes, encrypt_packets);
-        DEBUGFS_FWSTATS_DEL(aes, decrypt_packets);
-        DEBUGFS_FWSTATS_DEL(aes, encrypt_interrupt);
-        DEBUGFS_FWSTATS_DEL(aes, decrypt_interrupt);
-
-        DEBUGFS_FWSTATS_DEL(event, heart_beat);
-        DEBUGFS_FWSTATS_DEL(event, calibration);
-        DEBUGFS_FWSTATS_DEL(event, rx_mismatch);
-        DEBUGFS_FWSTATS_DEL(event, rx_mem_empty);
-        DEBUGFS_FWSTATS_DEL(event, rx_pool);
-        DEBUGFS_FWSTATS_DEL(event, oom_late);
-        DEBUGFS_FWSTATS_DEL(event, phy_transmit_error);
-        DEBUGFS_FWSTATS_DEL(event, tx_stuck);
-
-        DEBUGFS_FWSTATS_DEL(ps, pspoll_timeouts);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_timeouts);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_max_sptime);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_max_apturn);
-        DEBUGFS_FWSTATS_DEL(ps, pspoll_max_apturn);
-        DEBUGFS_FWSTATS_DEL(ps, pspoll_utilization);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_utilization);
-
-        DEBUGFS_FWSTATS_DEL(rxpipe, rx_prep_beacon_drop);
-        DEBUGFS_FWSTATS_DEL(rxpipe, descr_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_DEL(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_DEL(rxpipe, missed_beacon_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_DEL(rxpipe, tx_xfr_host_int_trig_rx_data);
-
-        DEBUGFS_DEL(tx_queue_len);
-        DEBUGFS_DEL(tx_queue_status);
-        DEBUGFS_DEL(retry_count);
-        DEBUGFS_DEL(excessive_retries);
-}
-
-static int wl1251_debugfs_add_files(struct wl1251 *wl)
-{
-        int ret = 0;
-
-        DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow);
-
-        DEBUGFS_FWSTATS_ADD(rx, out_of_mem);
-        DEBUGFS_FWSTATS_ADD(rx, hdr_overflow);
-        DEBUGFS_FWSTATS_ADD(rx, hw_stuck);
-        DEBUGFS_FWSTATS_ADD(rx, dropped);
-        DEBUGFS_FWSTATS_ADD(rx, fcs_err);
-        DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig);
-        DEBUGFS_FWSTATS_ADD(rx, path_reset);
-        DEBUGFS_FWSTATS_ADD(rx, reset_counter);
-
-        DEBUGFS_FWSTATS_ADD(dma, rx_requested);
-        DEBUGFS_FWSTATS_ADD(dma, rx_errors);
-        DEBUGFS_FWSTATS_ADD(dma, tx_requested);
-        DEBUGFS_FWSTATS_ADD(dma, tx_errors);
-
-        DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt);
-        DEBUGFS_FWSTATS_ADD(isr, fiqs);
-        DEBUGFS_FWSTATS_ADD(isr, rx_headers);
-        DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow);
-        DEBUGFS_FWSTATS_ADD(isr, rx_rdys);
-        DEBUGFS_FWSTATS_ADD(isr, irqs);
-        DEBUGFS_FWSTATS_ADD(isr, tx_procs);
-        DEBUGFS_FWSTATS_ADD(isr, decrypt_done);
-        DEBUGFS_FWSTATS_ADD(isr, dma0_done);
-        DEBUGFS_FWSTATS_ADD(isr, dma1_done);
-        DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete);
-        DEBUGFS_FWSTATS_ADD(isr, commands);
-        DEBUGFS_FWSTATS_ADD(isr, rx_procs);
-        DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes);
-        DEBUGFS_FWSTATS_ADD(isr, host_acknowledges);
-        DEBUGFS_FWSTATS_ADD(isr, pci_pm);
-        DEBUGFS_FWSTATS_ADD(isr, wakeups);
-        DEBUGFS_FWSTATS_ADD(isr, low_rssi);
-
-        DEBUGFS_FWSTATS_ADD(wep, addr_key_count);
-        DEBUGFS_FWSTATS_ADD(wep, default_key_count);
-        /* skipping wep.reserved */
-        DEBUGFS_FWSTATS_ADD(wep, key_not_found);
-        DEBUGFS_FWSTATS_ADD(wep, decrypt_fail);
-        DEBUGFS_FWSTATS_ADD(wep, packets);
-        DEBUGFS_FWSTATS_ADD(wep, interrupt);
-
-        DEBUGFS_FWSTATS_ADD(pwr, ps_enter);
-        DEBUGFS_FWSTATS_ADD(pwr, elp_enter);
-        DEBUGFS_FWSTATS_ADD(pwr, missing_bcns);
-        DEBUGFS_FWSTATS_ADD(pwr, wake_on_host);
-        DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp);
-        DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons);
-        DEBUGFS_FWSTATS_ADD(pwr, power_save_off);
-        DEBUGFS_FWSTATS_ADD(pwr, enable_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, disable_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps);
-        /* skipping cont_miss_bcns_spread for now */
-        DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons);
-
-        DEBUGFS_FWSTATS_ADD(mic, rx_pkts);
-        DEBUGFS_FWSTATS_ADD(mic, calc_failure);
-
-        DEBUGFS_FWSTATS_ADD(aes, encrypt_fail);
-        DEBUGFS_FWSTATS_ADD(aes, decrypt_fail);
-        DEBUGFS_FWSTATS_ADD(aes, encrypt_packets);
-        DEBUGFS_FWSTATS_ADD(aes, decrypt_packets);
-        DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt);
-        DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt);
-
-        DEBUGFS_FWSTATS_ADD(event, heart_beat);
-        DEBUGFS_FWSTATS_ADD(event, calibration);
-        DEBUGFS_FWSTATS_ADD(event, rx_mismatch);
-        DEBUGFS_FWSTATS_ADD(event, rx_mem_empty);
-        DEBUGFS_FWSTATS_ADD(event, rx_pool);
-        DEBUGFS_FWSTATS_ADD(event, oom_late);
-        DEBUGFS_FWSTATS_ADD(event, phy_transmit_error);
-        DEBUGFS_FWSTATS_ADD(event, tx_stuck);
-
-        DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn);
-        DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn);
-        DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_utilization);
-
-        DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop);
-        DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data);
-
-        DEBUGFS_ADD(tx_queue_len, wl->debugfs.rootdir);
-        DEBUGFS_ADD(tx_queue_status, wl->debugfs.rootdir);
-        DEBUGFS_ADD(retry_count, wl->debugfs.rootdir);
-        DEBUGFS_ADD(excessive_retries, wl->debugfs.rootdir);
-
-out:
-        if (ret < 0)
-                wl1251_debugfs_delete_files(wl);
-
-        return ret;
-}
-
-void wl1251_debugfs_reset(struct wl1251 *wl)
-{
-        if (wl->stats.fw_stats != NULL)
-                memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
-        wl->stats.retry_count = 0;
-        wl->stats.excessive_retries = 0;
-}
-
-int wl1251_debugfs_init(struct wl1251 *wl)
-{
-        int ret;
-
-        wl->debugfs.rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
-
-        if (IS_ERR(wl->debugfs.rootdir)) {
-                ret = PTR_ERR(wl->debugfs.rootdir);
-                wl->debugfs.rootdir = NULL;
-                goto err;
-        }
-
-        wl->debugfs.fw_statistics = debugfs_create_dir("fw-statistics",
-                                                       wl->debugfs.rootdir);
-
-        if (IS_ERR(wl->debugfs.fw_statistics)) {
-                ret = PTR_ERR(wl->debugfs.fw_statistics);
-                wl->debugfs.fw_statistics = NULL;
-                goto err_root;
-        }
-
-        wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats),
-                                      GFP_KERNEL);
-
-        if (!wl->stats.fw_stats) {
-                ret = -ENOMEM;
-                goto err_fw;
-        }
-
-        wl->stats.fw_stats_update = jiffies;
-
-        ret = wl1251_debugfs_add_files(wl);
-
-        if (ret < 0)
-                goto err_file;
-
-        return 0;
-
-err_file:
-        kfree(wl->stats.fw_stats);
-        wl->stats.fw_stats = NULL;
-
-err_fw:
-        debugfs_remove(wl->debugfs.fw_statistics);
-        wl->debugfs.fw_statistics = NULL;
-
-err_root:
-        debugfs_remove(wl->debugfs.rootdir);
-        wl->debugfs.rootdir = NULL;
-
-err:
-        return ret;
-}
-
-void wl1251_debugfs_exit(struct wl1251 *wl)
-{
-        wl1251_debugfs_delete_files(wl);
-
-        kfree(wl->stats.fw_stats);
-        wl->stats.fw_stats = NULL;
-
-        debugfs_remove(wl->debugfs.fw_statistics);
-        wl->debugfs.fw_statistics = NULL;
-
-        debugfs_remove(wl->debugfs.rootdir);
-        wl->debugfs.rootdir = NULL;
-
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_debugfs.h b/drivers/net/wireless/wl12xx/wl1251_debugfs.h
deleted file mode 100644
index 6dc3d080853c..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_debugfs.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef WL1251_DEBUGFS_H
-#define WL1251_DEBUGFS_H
-
-#include "wl1251.h"
-
-int wl1251_debugfs_init(struct wl1251 *wl);
-void wl1251_debugfs_exit(struct wl1251 *wl);
-void wl1251_debugfs_reset(struct wl1251 *wl);
-
-#endif /* WL1251_DEBUGFS_H */
diff --git a/drivers/net/wireless/wl12xx/wl1251_event.c b/drivers/net/wireless/wl12xx/wl1251_event.c
deleted file mode 100644
index 020d764f9c13..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_event.c
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include "wl1251.h"
-#include "wl1251_reg.h"
-#include "wl1251_io.h"
-#include "wl1251_event.h"
-#include "wl1251_ps.h"
-
-static int wl1251_event_scan_complete(struct wl1251 *wl,
-                                      struct event_mailbox *mbox)
-{
-        wl1251_debug(DEBUG_EVENT, "status: 0x%x, channels: %d",
-                     mbox->scheduled_scan_status,
-                     mbox->scheduled_scan_channels);
-
-        if (wl->scanning) {
-                mutex_unlock(&wl->mutex);
-                ieee80211_scan_completed(wl->hw, false);
-                mutex_lock(&wl->mutex);
-                wl1251_debug(DEBUG_MAC80211, "mac80211 hw scan completed");
-                wl->scanning = false;
-        }
-
-        return 0;
-}
-
-static void wl1251_event_mbox_dump(struct event_mailbox *mbox)
-{
-        wl1251_debug(DEBUG_EVENT, "MBOX DUMP:");
-        wl1251_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
-        wl1251_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
-}
-
-static int wl1251_event_process(struct wl1251 *wl, struct event_mailbox *mbox)
-{
-        int ret;
-        u32 vector;
-
-        wl1251_event_mbox_dump(mbox);
-
-        vector = mbox->events_vector & ~(mbox->events_mask);
-        wl1251_debug(DEBUG_EVENT, "vector: 0x%x", vector);
-
-        if (vector & SCAN_COMPLETE_EVENT_ID) {
-                ret = wl1251_event_scan_complete(wl, mbox);
-                if (ret < 0)
-                        return ret;
-        }
-
-        if (vector & BSS_LOSE_EVENT_ID) {
-                wl1251_debug(DEBUG_EVENT, "BSS_LOSE_EVENT");
-
-                if (wl->psm_requested && wl->psm) {
-                        ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE);
-                        if (ret < 0)
-                                return ret;
-                }
-        }
-
-        if (vector & SYNCHRONIZATION_TIMEOUT_EVENT_ID && wl->psm) {
-                wl1251_debug(DEBUG_EVENT, "SYNCHRONIZATION_TIMEOUT_EVENT");
-
-                /* indicate to the stack, that beacons have been lost */
-                ieee80211_beacon_loss(wl->vif);
-        }
-
-        if (vector & REGAINED_BSS_EVENT_ID) {
-                if (wl->psm_requested) {
-                        ret = wl1251_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
-                        if (ret < 0)
-                                return ret;
-                }
-        }
-
-        return 0;
-}
-
-int wl1251_event_unmask(struct wl1251 *wl)
-{
-        int ret;
-
-        ret = wl1251_acx_event_mbox_mask(wl, ~(wl->event_mask));
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-void wl1251_event_mbox_config(struct wl1251 *wl)
-{
-        wl->mbox_ptr[0] = wl1251_reg_read32(wl, REG_EVENT_MAILBOX_PTR);
-        wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox);
-
-        wl1251_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x",
-                     wl->mbox_ptr[0], wl->mbox_ptr[1]);
-}
-
-int wl1251_event_handle(struct wl1251 *wl, u8 mbox_num)
-{
-        struct event_mailbox mbox;
-        int ret;
-
-        wl1251_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num);
-
-        if (mbox_num > 1)
-                return -EINVAL;
-
-        /* first we read the mbox descriptor */
-        wl1251_mem_read(wl, wl->mbox_ptr[mbox_num], &mbox,
-                            sizeof(struct event_mailbox));
-
-        /* process the descriptor */
-        ret = wl1251_event_process(wl, &mbox);
-        if (ret < 0)
-                return ret;
-
-        /* then we let the firmware know it can go on...*/
-        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_EVENT_ACK);
-
-        return 0;
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_event.h b/drivers/net/wireless/wl12xx/wl1251_event.h
deleted file mode 100644
index f48a2b66bc5a..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_event.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_EVENT_H__
-#define __WL1251_EVENT_H__
-
-/*
- * Mbox events
- *
- * The event mechanism is based on a pair of event buffers (buffers A and
- * B) at fixed locations in the target's memory. The host processes one
- * buffer while the other buffer continues to collect events. If the host
- * is not processing events, an interrupt is issued to signal that a buffer
- * is ready. Once the host is done with processing events from one buffer,
- * it signals the target (with an ACK interrupt) that the event buffer is
- * free.
- */
-
-enum {
-        RESERVED1_EVENT_ID                       = BIT(0),
-        RESERVED2_EVENT_ID                       = BIT(1),
-        MEASUREMENT_START_EVENT_ID               = BIT(2),
-        SCAN_COMPLETE_EVENT_ID                   = BIT(3),
-        CALIBRATION_COMPLETE_EVENT_ID            = BIT(4),
-        ROAMING_TRIGGER_LOW_RSSI_EVENT_ID        = BIT(5),
-        PS_REPORT_EVENT_ID                       = BIT(6),
-        SYNCHRONIZATION_TIMEOUT_EVENT_ID         = BIT(7),
-        HEALTH_REPORT_EVENT_ID                   = BIT(8),
-        ACI_DETECTION_EVENT_ID                   = BIT(9),
-        DEBUG_REPORT_EVENT_ID                    = BIT(10),
-        MAC_STATUS_EVENT_ID                      = BIT(11),
-        DISCONNECT_EVENT_COMPLETE_ID             = BIT(12),
-        JOIN_EVENT_COMPLETE_ID                   = BIT(13),
-        CHANNEL_SWITCH_COMPLETE_EVENT_ID         = BIT(14),
-        BSS_LOSE_EVENT_ID                        = BIT(15),
-        ROAMING_TRIGGER_MAX_TX_RETRY_EVENT_ID    = BIT(16),
-        MEASUREMENT_COMPLETE_EVENT_ID            = BIT(17),
-        AP_DISCOVERY_COMPLETE_EVENT_ID           = BIT(18),
-        SCHEDULED_SCAN_COMPLETE_EVENT_ID         = BIT(19),
-        PSPOLL_DELIVERY_FAILURE_EVENT_ID         = BIT(20),
-        RESET_BSS_EVENT_ID                       = BIT(21),
-        REGAINED_BSS_EVENT_ID                    = BIT(22),
-        ROAMING_TRIGGER_REGAINED_RSSI_EVENT_ID   = BIT(23),
-        ROAMING_TRIGGER_LOW_SNR_EVENT_ID         = BIT(24),
-        ROAMING_TRIGGER_REGAINED_SNR_EVENT_ID    = BIT(25),
-
-        DBG_EVENT_ID                             = BIT(26),
-        BT_PTA_SENSE_EVENT_ID                    = BIT(27),
-        BT_PTA_PREDICTION_EVENT_ID               = BIT(28),
-        BT_PTA_AVALANCHE_EVENT_ID                = BIT(29),
-
-        PLT_RX_CALIBRATION_COMPLETE_EVENT_ID     = BIT(30),
-
-        EVENT_MBOX_ALL_EVENT_ID                  = 0x7fffffff,
-};
-
-struct event_debug_report {
-        u8 debug_event_id;
-        u8 num_params;
-        u16 pad;
-        u32 report_1;
-        u32 report_2;
-        u32 report_3;
-} __packed;
-
-struct event_mailbox {
-        u32 events_vector;
-        u32 events_mask;
-        u32 reserved_1;
-        u32 reserved_2;
-
-        char average_rssi_level;
-        u8 ps_status;
-        u8 channel_switch_status;
-        u8 scheduled_scan_status;
-
-        /* Channels scanned by the scheduled scan */
-        u16 scheduled_scan_channels;
-
-        /* If bit 0 is set -> target's fatal error */
-        u16 health_report;
-        u16 bad_fft_counter;
-        u8 bt_pta_sense_info;
-        u8 bt_pta_protective_info;
-        u32 reserved;
-        u32 debug_report[2];
-
-        /* Number of FCS errors since last event */
-        u32 fcs_err_counter;
-
-        struct event_debug_report report;
-        u8 average_snr_level;
-        u8 padding[19];
-} __packed;
-
-int wl1251_event_unmask(struct wl1251 *wl);
-void wl1251_event_mbox_config(struct wl1251 *wl);
-int wl1251_event_handle(struct wl1251 *wl, u8 mbox);
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1251_init.c b/drivers/net/wireless/wl12xx/wl1251_init.c
deleted file mode 100644
index b538bdd7b320..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_init.c
+++ /dev/null
@@ -1,425 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-
-#include "wl1251_init.h"
-#include "wl12xx_80211.h"
-#include "wl1251_acx.h"
-#include "wl1251_cmd.h"
-#include "wl1251_reg.h"
-
-int wl1251_hw_init_hwenc_config(struct wl1251 *wl)
-{
-        int ret;
-
-        ret = wl1251_acx_feature_cfg(wl);
-        if (ret < 0) {
-                wl1251_warning("couldn't set feature config");
-                return ret;
-        }
-
-        ret = wl1251_acx_default_key(wl, wl->default_key);
-        if (ret < 0) {
-                wl1251_warning("couldn't set default key");
-                return ret;
-        }
-
-        return 0;
-}
-
-int wl1251_hw_init_templates_config(struct wl1251 *wl)
-{
-        int ret;
-        u8 partial_vbm[PARTIAL_VBM_MAX];
-
-        /* send empty templates for fw memory reservation */
-        ret = wl1251_cmd_template_set(wl, CMD_PROBE_REQ, NULL,
-                                      sizeof(struct wl12xx_probe_req_template));
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_cmd_template_set(wl, CMD_NULL_DATA, NULL,
-                                      sizeof(struct wl12xx_null_data_template));
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_cmd_template_set(wl, CMD_PS_POLL, NULL,
-                                      sizeof(struct wl12xx_ps_poll_template));
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_cmd_template_set(wl, CMD_QOS_NULL_DATA, NULL,
-                                      sizeof
-                                      (struct wl12xx_qos_null_data_template));
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_cmd_template_set(wl, CMD_PROBE_RESP, NULL,
-                                      sizeof
-                                      (struct wl12xx_probe_resp_template));
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_cmd_template_set(wl, CMD_BEACON, NULL,
-                                      sizeof
-                                      (struct wl12xx_beacon_template));
-        if (ret < 0)
-                return ret;
-
-        /* tim templates, first reserve space then allocate an empty one */
-        memset(partial_vbm, 0, PARTIAL_VBM_MAX);
-        ret = wl1251_cmd_vbm(wl, TIM_ELE_ID, partial_vbm, PARTIAL_VBM_MAX, 0);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_cmd_vbm(wl, TIM_ELE_ID, partial_vbm, 1, 0);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_hw_init_rx_config(struct wl1251 *wl, u32 config, u32 filter)
-{
-        int ret;
-
-        ret = wl1251_acx_rx_msdu_life_time(wl, RX_MSDU_LIFETIME_DEF);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_acx_rx_config(wl, config, filter);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_hw_init_phy_config(struct wl1251 *wl)
-{
-        int ret;
-
-        ret = wl1251_acx_pd_threshold(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_acx_slot(wl, DEFAULT_SLOT_TIME);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_acx_group_address_tbl(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_acx_service_period_timeout(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_acx_rts_threshold(wl, RTS_THRESHOLD_DEF);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_hw_init_beacon_filter(struct wl1251 *wl)
-{
-        int ret;
-
-        /* disable beacon filtering at this stage */
-        ret = wl1251_acx_beacon_filter_opt(wl, false);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_acx_beacon_filter_table(wl);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_hw_init_pta(struct wl1251 *wl)
-{
-        int ret;
-
-        ret = wl1251_acx_sg_enable(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_acx_sg_cfg(wl);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_hw_init_energy_detection(struct wl1251 *wl)
-{
-        int ret;
-
-        ret = wl1251_acx_cca_threshold(wl);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_hw_init_beacon_broadcast(struct wl1251 *wl)
-{
-        int ret;
-
-        ret = wl1251_acx_bcn_dtim_options(wl);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1251_hw_init_power_auth(struct wl1251 *wl)
-{
-        return wl1251_acx_sleep_auth(wl, WL1251_PSM_CAM);
-}
-
-int wl1251_hw_init_mem_config(struct wl1251 *wl)
-{
-        int ret;
-
-        ret = wl1251_acx_mem_cfg(wl);
-        if (ret < 0)
-                return ret;
-
-        wl->target_mem_map = kzalloc(sizeof(struct wl1251_acx_mem_map),
-                                          GFP_KERNEL);
-        if (!wl->target_mem_map) {
-                wl1251_error("couldn't allocate target memory map");
-                return -ENOMEM;
-        }
-
-        /* we now ask for the firmware built memory map */
-        ret = wl1251_acx_mem_map(wl, wl->target_mem_map,
-                                 sizeof(struct wl1251_acx_mem_map));
-        if (ret < 0) {
-                wl1251_error("couldn't retrieve firmware memory map");
-                kfree(wl->target_mem_map);
-                wl->target_mem_map = NULL;
-                return ret;
-        }
-
-        return 0;
-}
-
-static int wl1251_hw_init_txq_fill(u8 qid,
-                                   struct acx_tx_queue_qos_config *config,
-                                   u32 num_blocks)
-{
-        config->qid = qid;
-
-        switch (qid) {
-        case QOS_AC_BE:
-                config->high_threshold =
-                        (QOS_TX_HIGH_BE_DEF * num_blocks) / 100;
-                config->low_threshold =
-                        (QOS_TX_LOW_BE_DEF * num_blocks) / 100;
-                break;
-        case QOS_AC_BK:
-                config->high_threshold =
-                        (QOS_TX_HIGH_BK_DEF * num_blocks) / 100;
-                config->low_threshold =
-                        (QOS_TX_LOW_BK_DEF * num_blocks) / 100;
-                break;
-        case QOS_AC_VI:
-                config->high_threshold =
-                        (QOS_TX_HIGH_VI_DEF * num_blocks) / 100;
-                config->low_threshold =
-                        (QOS_TX_LOW_VI_DEF * num_blocks) / 100;
-                break;
-        case QOS_AC_VO:
-                config->high_threshold =
-                        (QOS_TX_HIGH_VO_DEF * num_blocks) / 100;
-                config->low_threshold =
-                        (QOS_TX_LOW_VO_DEF * num_blocks) / 100;
-                break;
-        default:
-                wl1251_error("Invalid TX queue id: %d", qid);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-static int wl1251_hw_init_tx_queue_config(struct wl1251 *wl)
-{
-        struct acx_tx_queue_qos_config *config;
-        struct wl1251_acx_mem_map *wl_mem_map = wl->target_mem_map;
-        int ret, i;
-
-        wl1251_debug(DEBUG_ACX, "acx tx queue config");
-
-        config = kzalloc(sizeof(*config), GFP_KERNEL);
-        if (!config) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        for (i = 0; i < MAX_NUM_OF_AC; i++) {
-                ret = wl1251_hw_init_txq_fill(i, config,
-                                              wl_mem_map->num_tx_mem_blocks);
-                if (ret < 0)
-                        goto out;
-
-                ret = wl1251_cmd_configure(wl, ACX_TX_QUEUE_CFG,
-                                           config, sizeof(*config));
-                if (ret < 0)
-                        goto out;
-        }
-
-        wl1251_acx_ac_cfg(wl, AC_BE, CWMIN_BE, CWMAX_BE, AIFS_DIFS, TXOP_BE);
-        wl1251_acx_ac_cfg(wl, AC_BK, CWMIN_BK, CWMAX_BK, AIFS_DIFS, TXOP_BK);
-        wl1251_acx_ac_cfg(wl, AC_VI, CWMIN_VI, CWMAX_VI, AIFS_DIFS, TXOP_VI);
-        wl1251_acx_ac_cfg(wl, AC_VO, CWMIN_VO, CWMAX_VO, AIFS_DIFS, TXOP_VO);
-
-out:
-        kfree(config);
-        return ret;
-}
-
-static int wl1251_hw_init_data_path_config(struct wl1251 *wl)
-{
-        int ret;
-
-        /* asking for the data path parameters */
-        wl->data_path = kzalloc(sizeof(struct acx_data_path_params_resp),
-                                GFP_KERNEL);
-        if (!wl->data_path) {
-                wl1251_error("Couldnt allocate data path parameters");
-                return -ENOMEM;
-        }
-
-        ret = wl1251_acx_data_path_params(wl, wl->data_path);
-        if (ret < 0) {
-                kfree(wl->data_path);
-                wl->data_path = NULL;
-                return ret;
-        }
-
-        return 0;
-}
-
-
-int wl1251_hw_init(struct wl1251 *wl)
-{
-        struct wl1251_acx_mem_map *wl_mem_map;
-        int ret;
-
-        ret = wl1251_hw_init_hwenc_config(wl);
-        if (ret < 0)
-                return ret;
-
-        /* Template settings */
-        ret = wl1251_hw_init_templates_config(wl);
-        if (ret < 0)
-                return ret;
-
-        /* Default memory configuration */
-        ret = wl1251_hw_init_mem_config(wl);
-        if (ret < 0)
-                return ret;
-
-        /* Default data path configuration  */
-        ret = wl1251_hw_init_data_path_config(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* RX config */
-        ret = wl1251_hw_init_rx_config(wl,
-                                       RX_CFG_PROMISCUOUS | RX_CFG_TSF,
-                                       RX_FILTER_OPTION_DEF);
-        /* RX_CONFIG_OPTION_ANY_DST_ANY_BSS,
-           RX_FILTER_OPTION_FILTER_ALL); */
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* TX queues config */
-        ret = wl1251_hw_init_tx_queue_config(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* PHY layer config */
-        ret = wl1251_hw_init_phy_config(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* Initialize connection monitoring thresholds */
-        ret = wl1251_acx_conn_monit_params(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* Beacon filtering */
-        ret = wl1251_hw_init_beacon_filter(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* Bluetooth WLAN coexistence */
-        ret = wl1251_hw_init_pta(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* Energy detection */
-        ret = wl1251_hw_init_energy_detection(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* Beacons and boradcast settings */
-        ret = wl1251_hw_init_beacon_broadcast(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* Enable data path */
-        ret = wl1251_cmd_data_path(wl, wl->channel, 1);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        /* Default power state */
-        ret = wl1251_hw_init_power_auth(wl);
-        if (ret < 0)
-                goto out_free_data_path;
-
-        wl_mem_map = wl->target_mem_map;
-        wl1251_info("%d tx blocks at 0x%x, %d rx blocks at 0x%x",
-                    wl_mem_map->num_tx_mem_blocks,
-                    wl->data_path->tx_control_addr,
-                    wl_mem_map->num_rx_mem_blocks,
-                    wl->data_path->rx_control_addr);
-
-        return 0;
-
- out_free_data_path:
-        kfree(wl->data_path);
-
- out_free_memmap:
-        kfree(wl->target_mem_map);
-
-        return ret;
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_init.h b/drivers/net/wireless/wl12xx/wl1251_init.h
deleted file mode 100644
index 269cefb3e7d4..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_init.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_INIT_H__
-#define __WL1251_INIT_H__
-
-#include "wl1251.h"
-
-enum {
-        /* best effort/legacy */
-        AC_BE = 0,
-
-        /* background */
-        AC_BK = 1,
-
-        /* video */
-        AC_VI = 2,
-
-        /* voice */
-        AC_VO = 3,
-
-        /* broadcast dummy access category */
-        AC_BCAST = 4,
-
-        NUM_ACCESS_CATEGORIES = 4
-};
-
-/* following are defult values for the IE fields*/
-#define CWMIN_BK  15
-#define CWMIN_BE  15
-#define CWMIN_VI  7
-#define CWMIN_VO  3
-#define CWMAX_BK  1023
-#define CWMAX_BE  63
-#define CWMAX_VI  15
-#define CWMAX_VO  7
-
-/* slot number setting to start transmission at PIFS interval */
-#define AIFS_PIFS 1
-
-/*
- * slot number setting to start transmission at DIFS interval - normal DCF
- * access
- */
-#define AIFS_DIFS 2
-
-#define AIFSN_BK  7
-#define AIFSN_BE  3
-#define AIFSN_VI  AIFS_PIFS
-#define AIFSN_VO  AIFS_PIFS
-#define TXOP_BK   0
-#define TXOP_BE   0
-#define TXOP_VI   3008
-#define TXOP_VO   1504
-
-int wl1251_hw_init_hwenc_config(struct wl1251 *wl);
-int wl1251_hw_init_templates_config(struct wl1251 *wl);
-int wl1251_hw_init_rx_config(struct wl1251 *wl, u32 config, u32 filter);
-int wl1251_hw_init_phy_config(struct wl1251 *wl);
-int wl1251_hw_init_beacon_filter(struct wl1251 *wl);
-int wl1251_hw_init_pta(struct wl1251 *wl);
-int wl1251_hw_init_energy_detection(struct wl1251 *wl);
-int wl1251_hw_init_beacon_broadcast(struct wl1251 *wl);
-int wl1251_hw_init_power_auth(struct wl1251 *wl);
-int wl1251_hw_init_mem_config(struct wl1251 *wl);
-int wl1251_hw_init(struct wl1251 *wl);
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1251_io.c b/drivers/net/wireless/wl12xx/wl1251_io.c
deleted file mode 100644
index f1c232e0887f..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_io.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * This file is part of wl12xx
- *
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include "wl1251.h"
-#include "wl1251_reg.h"
-#include "wl1251_io.h"
-
-/* FIXME: this is static data nowadays and the table can be removed */
-static enum wl12xx_acx_int_reg wl1251_io_reg_table[ACX_REG_TABLE_LEN] = {
-        [ACX_REG_INTERRUPT_TRIG]     = (REGISTERS_BASE + 0x0474),
-        [ACX_REG_INTERRUPT_TRIG_H]   = (REGISTERS_BASE + 0x0478),
-        [ACX_REG_INTERRUPT_MASK]     = (REGISTERS_BASE + 0x0494),
-        [ACX_REG_HINT_MASK_SET]      = (REGISTERS_BASE + 0x0498),
-        [ACX_REG_HINT_MASK_CLR]      = (REGISTERS_BASE + 0x049C),
-        [ACX_REG_INTERRUPT_NO_CLEAR] = (REGISTERS_BASE + 0x04B0),
-        [ACX_REG_INTERRUPT_CLEAR]    = (REGISTERS_BASE + 0x04A4),
-        [ACX_REG_INTERRUPT_ACK]      = (REGISTERS_BASE + 0x04A8),
-        [ACX_REG_SLV_SOFT_RESET]     = (REGISTERS_BASE + 0x0000),
-        [ACX_REG_EE_START]           = (REGISTERS_BASE + 0x080C),
-        [ACX_REG_ECPU_CONTROL]       = (REGISTERS_BASE + 0x0804)
-};
-
-static int wl1251_translate_reg_addr(struct wl1251 *wl, int addr)
-{
-        /* If the address is lower than REGISTERS_BASE, it means that this is
-         * a chip-specific register address, so look it up in the registers
-         * table */
-        if (addr < REGISTERS_BASE) {
-                /* Make sure we don't go over the table */
-                if (addr >= ACX_REG_TABLE_LEN) {
-                        wl1251_error("address out of range (%d)", addr);
-                        return -EINVAL;
-                }
-                addr = wl1251_io_reg_table[addr];
-        }
-
-        return addr - wl->physical_reg_addr + wl->virtual_reg_addr;
-}
-
-static int wl1251_translate_mem_addr(struct wl1251 *wl, int addr)
-{
-        return addr - wl->physical_mem_addr + wl->virtual_mem_addr;
-}
-
-void wl1251_mem_read(struct wl1251 *wl, int addr, void *buf, size_t len)
-{
-        int physical;
-
-        physical = wl1251_translate_mem_addr(wl, addr);
-
-        wl->if_ops->read(wl, physical, buf, len);
-}
-
-void wl1251_mem_write(struct wl1251 *wl, int addr, void *buf, size_t len)
-{
-        int physical;
-
-        physical = wl1251_translate_mem_addr(wl, addr);
-
-        wl->if_ops->write(wl, physical, buf, len);
-}
-
-u32 wl1251_mem_read32(struct wl1251 *wl, int addr)
-{
-        return wl1251_read32(wl, wl1251_translate_mem_addr(wl, addr));
-}
-
-void wl1251_mem_write32(struct wl1251 *wl, int addr, u32 val)
-{
-        wl1251_write32(wl, wl1251_translate_mem_addr(wl, addr), val);
-}
-
-u32 wl1251_reg_read32(struct wl1251 *wl, int addr)
-{
-        return wl1251_read32(wl, wl1251_translate_reg_addr(wl, addr));
-}
-
-void wl1251_reg_write32(struct wl1251 *wl, int addr, u32 val)
-{
-        wl1251_write32(wl, wl1251_translate_reg_addr(wl, addr), val);
-}
-
-/* Set the partitions to access the chip addresses.
- *
- * There are two VIRTUAL partitions (the memory partition and the
- * registers partition), which are mapped to two different areas of the
- * PHYSICAL (hardware) memory.  This function also makes other checks to
- * ensure that the partitions are not overlapping.  In the diagram below, the
- * memory partition comes before the register partition, but the opposite is
- * also supported.
- *
- *                               PHYSICAL address
- *                                     space
- *
- *                                    |    |
- *                                 ...+----+--> mem_start
- *          VIRTUAL address     ...   |    |
- *               space       ...      |    | [PART_0]
- *                        ...         |    |
- * 0x00000000 <--+----+...         ...+----+--> mem_start + mem_size
- *               |    |         ...   |    |
- *               |MEM |      ...      |    |
- *               |    |   ...         |    |
- *  part_size <--+----+...            |    | {unused area)
- *               |    |   ...         |    |
- *               |REG |      ...      |    |
- *  part_size    |    |         ...   |    |
- *      +     <--+----+...         ...+----+--> reg_start
- *  reg_size              ...         |    |
- *                           ...      |    | [PART_1]
- *                              ...   |    |
- *                                 ...+----+--> reg_start + reg_size
- *                                    |    |
- *
- */
-void wl1251_set_partition(struct wl1251 *wl,
-                          u32 mem_start, u32 mem_size,
-                          u32 reg_start, u32 reg_size)
-{
-        struct wl1251_partition partition[2];
-
-        wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
-                     mem_start, mem_size);
-        wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
-                     reg_start, reg_size);
-
-        /* Make sure that the two partitions together don't exceed the
-         * address range */
-        if ((mem_size + reg_size) > HW_ACCESS_MEMORY_MAX_RANGE) {
-                wl1251_debug(DEBUG_SPI, "Total size exceeds maximum virtual"
-                             " address range.  Truncating partition[0].");
-                mem_size = HW_ACCESS_MEMORY_MAX_RANGE - reg_size;
-                wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
-                             mem_start, mem_size);
-                wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
-                             reg_start, reg_size);
-        }
-
-        if ((mem_start < reg_start) &&
-            ((mem_start + mem_size) > reg_start)) {
-                /* Guarantee that the memory partition doesn't overlap the
-                 * registers partition */
-                wl1251_debug(DEBUG_SPI, "End of partition[0] is "
-                             "overlapping partition[1].  Adjusted.");
-                mem_size = reg_start - mem_start;
-                wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
-                             mem_start, mem_size);
-                wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
-                             reg_start, reg_size);
-        } else if ((reg_start < mem_start) &&
-                   ((reg_start + reg_size) > mem_start)) {
-                /* Guarantee that the register partition doesn't overlap the
-                 * memory partition */
-                wl1251_debug(DEBUG_SPI, "End of partition[1] is"
-                             " overlapping partition[0].  Adjusted.");
-                reg_size = mem_start - reg_start;
-                wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
-                             mem_start, mem_size);
-                wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
-                             reg_start, reg_size);
-        }
-
-        partition[0].start = mem_start;
-        partition[0].size  = mem_size;
-        partition[1].start = reg_start;
-        partition[1].size  = reg_size;
-
-        wl->physical_mem_addr = mem_start;
-        wl->physical_reg_addr = reg_start;
-
-        wl->virtual_mem_addr = 0;
-        wl->virtual_reg_addr = mem_size;
-
-        wl->if_ops->write(wl, HW_ACCESS_PART0_SIZE_ADDR, partition,
-                sizeof(partition));
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_io.h b/drivers/net/wireless/wl12xx/wl1251_io.h
deleted file mode 100644
index c545e9d5f512..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_io.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * This file is part of wl12xx
- *
- * Copyright (C) 2008 Nokia Corporation
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-#ifndef __WL1251_IO_H__
-#define __WL1251_IO_H__
-
-#include "wl1251.h"
-
-#define HW_ACCESS_MEMORY_MAX_RANGE              0x1FFC0
-
-#define HW_ACCESS_PART0_SIZE_ADDR           0x1FFC0
-#define HW_ACCESS_PART0_START_ADDR          0x1FFC4
-#define HW_ACCESS_PART1_SIZE_ADDR           0x1FFC8
-#define HW_ACCESS_PART1_START_ADDR          0x1FFCC
-
-#define HW_ACCESS_REGISTER_SIZE             4
-
-#define HW_ACCESS_PRAM_MAX_RANGE                0x3c000
-
-static inline u32 wl1251_read32(struct wl1251 *wl, int addr)
-{
-        u32 response;
-
-        wl->if_ops->read(wl, addr, &response, sizeof(u32));
-
-        return response;
-}
-
-static inline void wl1251_write32(struct wl1251 *wl, int addr, u32 val)
-{
-        wl->if_ops->write(wl, addr, &val, sizeof(u32));
-}
-
-static inline u32 wl1251_read_elp(struct wl1251 *wl, int addr)
-{
-        u32 response;
-
-        if (wl->if_ops->read_elp)
-                wl->if_ops->read_elp(wl, addr, &response);
-        else
-                wl->if_ops->read(wl, addr, &response, sizeof(u32));
-
-        return response;
-}
-
-static inline void wl1251_write_elp(struct wl1251 *wl, int addr, u32 val)
-{
-        if (wl->if_ops->write_elp)
-                wl->if_ops->write_elp(wl, addr, val);
-        else
-                wl->if_ops->write(wl, addr, &val, sizeof(u32));
-}
-
-/* Memory target IO, address is translated to partition 0 */
-void wl1251_mem_read(struct wl1251 *wl, int addr, void *buf, size_t len);
-void wl1251_mem_write(struct wl1251 *wl, int addr, void *buf, size_t len);
-u32 wl1251_mem_read32(struct wl1251 *wl, int addr);
-void wl1251_mem_write32(struct wl1251 *wl, int addr, u32 val);
-/* Registers IO */
-u32 wl1251_reg_read32(struct wl1251 *wl, int addr);
-void wl1251_reg_write32(struct wl1251 *wl, int addr, u32 val);
-
-void wl1251_set_partition(struct wl1251 *wl,
-                          u32 part_start, u32 part_size,
-                          u32 reg_start,  u32 reg_size);
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1251_main.c b/drivers/net/wireless/wl12xx/wl1251_main.c
deleted file mode 100644
index 861a5f33761e..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_main.c
+++ /dev/null
@@ -1,1442 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2008-2009 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/firmware.h>
-#include <linux/delay.h>
-#include <linux/irq.h>
-#include <linux/crc32.h>
-#include <linux/etherdevice.h>
-#include <linux/vmalloc.h>
-#include <linux/slab.h>
-
-#include "wl1251.h"
-#include "wl12xx_80211.h"
-#include "wl1251_reg.h"
-#include "wl1251_io.h"
-#include "wl1251_cmd.h"
-#include "wl1251_event.h"
-#include "wl1251_tx.h"
-#include "wl1251_rx.h"
-#include "wl1251_ps.h"
-#include "wl1251_init.h"
-#include "wl1251_debugfs.h"
-#include "wl1251_boot.h"
-
-void wl1251_enable_interrupts(struct wl1251 *wl)
-{
-        wl->if_ops->enable_irq(wl);
-}
-
-void wl1251_disable_interrupts(struct wl1251 *wl)
-{
-        wl->if_ops->disable_irq(wl);
-}
-
-static void wl1251_power_off(struct wl1251 *wl)
-{
-        wl->set_power(false);
-}
-
-static void wl1251_power_on(struct wl1251 *wl)
-{
-        wl->set_power(true);
-}
-
-static int wl1251_fetch_firmware(struct wl1251 *wl)
-{
-        const struct firmware *fw;
-        struct device *dev = wiphy_dev(wl->hw->wiphy);
-        int ret;
-
-        ret = request_firmware(&fw, WL1251_FW_NAME, dev);
-
-        if (ret < 0) {
-                wl1251_error("could not get firmware: %d", ret);
-                return ret;
-        }
-
-        if (fw->size % 4) {
-                wl1251_error("firmware size is not multiple of 32 bits: %zu",
-                             fw->size);
-                ret = -EILSEQ;
-                goto out;
-        }
-
-        wl->fw_len = fw->size;
-        wl->fw = vmalloc(wl->fw_len);
-
-        if (!wl->fw) {
-                wl1251_error("could not allocate memory for the firmware");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        memcpy(wl->fw, fw->data, wl->fw_len);
-
-        ret = 0;
-
-out:
-        release_firmware(fw);
-
-        return ret;
-}
-
-static int wl1251_fetch_nvs(struct wl1251 *wl)
-{
-        const struct firmware *fw;
-        struct device *dev = wiphy_dev(wl->hw->wiphy);
-        int ret;
-
-        ret = request_firmware(&fw, WL1251_NVS_NAME, dev);
-
-        if (ret < 0) {
-                wl1251_error("could not get nvs file: %d", ret);
-                return ret;
-        }
-
-        if (fw->size % 4) {
-                wl1251_error("nvs size is not multiple of 32 bits: %zu",
-                             fw->size);
-                ret = -EILSEQ;
-                goto out;
-        }
-
-        wl->nvs_len = fw->size;
-        wl->nvs = kmemdup(fw->data, wl->nvs_len, GFP_KERNEL);
-
-        if (!wl->nvs) {
-                wl1251_error("could not allocate memory for the nvs file");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = 0;
-
-out:
-        release_firmware(fw);
-
-        return ret;
-}
-
-static void wl1251_fw_wakeup(struct wl1251 *wl)
-{
-        u32 elp_reg;
-
-        elp_reg = ELPCTRL_WAKE_UP;
-        wl1251_write_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
-        elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
-
-        if (!(elp_reg & ELPCTRL_WLAN_READY))
-                wl1251_warning("WLAN not ready");
-}
-
-static int wl1251_chip_wakeup(struct wl1251 *wl)
-{
-        int ret = 0;
-
-        wl1251_power_on(wl);
-        msleep(WL1251_POWER_ON_SLEEP);
-        wl->if_ops->reset(wl);
-
-        /* We don't need a real memory partition here, because we only want
-         * to use the registers at this point. */
-        wl1251_set_partition(wl,
-                             0x00000000,
-                             0x00000000,
-                             REGISTERS_BASE,
-                             REGISTERS_DOWN_SIZE);
-
-        /* ELP module wake up */
-        wl1251_fw_wakeup(wl);
-
-        /* whal_FwCtrl_BootSm() */
-
-        /* 0. read chip id from CHIP_ID */
-        wl->chip_id = wl1251_reg_read32(wl, CHIP_ID_B);
-
-        /* 1. check if chip id is valid */
-
-        switch (wl->chip_id) {
-        case CHIP_ID_1251_PG12:
-                wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG12)",
-                             wl->chip_id);
-                break;
-        case CHIP_ID_1251_PG11:
-                wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG11)",
-                             wl->chip_id);
-                break;
-        case CHIP_ID_1251_PG10:
-        default:
-                wl1251_error("unsupported chip id: 0x%x", wl->chip_id);
-                ret = -ENODEV;
-                goto out;
-        }
-
-        if (wl->fw == NULL) {
-                ret = wl1251_fetch_firmware(wl);
-                if (ret < 0)
-                        goto out;
-        }
-
-        if (wl->nvs == NULL && !wl->use_eeprom) {
-                /* No NVS from netlink, try to get it from the filesystem */
-                ret = wl1251_fetch_nvs(wl);
-                if (ret < 0)
-                        goto out;
-        }
-
-out:
-        return ret;
-}
-
-#define WL1251_IRQ_LOOP_COUNT 10
-static void wl1251_irq_work(struct work_struct *work)
-{
-        u32 intr, ctr = WL1251_IRQ_LOOP_COUNT;
-        struct wl1251 *wl =
-                container_of(work, struct wl1251, irq_work);
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        wl1251_debug(DEBUG_IRQ, "IRQ work");
-
-        if (wl->state == WL1251_STATE_OFF)
-                goto out;
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1251_ACX_INTR_ALL);
-
-        intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR);
-        wl1251_debug(DEBUG_IRQ, "intr: 0x%x", intr);
-
-        do {
-                if (wl->data_path) {
-                        wl->rx_counter = wl1251_mem_read32(
-                                wl, wl->data_path->rx_control_addr);
-
-                        /* We handle a frmware bug here */
-                        switch ((wl->rx_counter - wl->rx_handled) & 0xf) {
-                        case 0:
-                                wl1251_debug(DEBUG_IRQ,
-                                             "RX: FW and host in sync");
-                                intr &= ~WL1251_ACX_INTR_RX0_DATA;
-                                intr &= ~WL1251_ACX_INTR_RX1_DATA;
-                                break;
-                        case 1:
-                                wl1251_debug(DEBUG_IRQ, "RX: FW +1");
-                                intr |= WL1251_ACX_INTR_RX0_DATA;
-                                intr &= ~WL1251_ACX_INTR_RX1_DATA;
-                                break;
-                        case 2:
-                                wl1251_debug(DEBUG_IRQ, "RX: FW +2");
-                                intr |= WL1251_ACX_INTR_RX0_DATA;
-                                intr |= WL1251_ACX_INTR_RX1_DATA;
-                                break;
-                        default:
-                                wl1251_warning(
-                                        "RX: FW and host out of sync: %d",
-                                        wl->rx_counter - wl->rx_handled);
-                                break;
-                        }
-
-                        wl->rx_handled = wl->rx_counter;
-
-                        wl1251_debug(DEBUG_IRQ, "RX counter: %d",
-                                     wl->rx_counter);
-                }
-
-                intr &= wl->intr_mask;
-
-                if (intr == 0) {
-                        wl1251_debug(DEBUG_IRQ, "INTR is 0");
-                        goto out_sleep;
-                }
-
-                if (intr & WL1251_ACX_INTR_RX0_DATA) {
-                        wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA");
-                        wl1251_rx(wl);
-                }
-
-                if (intr & WL1251_ACX_INTR_RX1_DATA) {
-                        wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA");
-                        wl1251_rx(wl);
-                }
-
-                if (intr & WL1251_ACX_INTR_TX_RESULT) {
-                        wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT");
-                        wl1251_tx_complete(wl);
-                }
-
-                if (intr & (WL1251_ACX_INTR_EVENT_A |
-                            WL1251_ACX_INTR_EVENT_B)) {
-                        wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT (0x%x)",
-                                     intr);
-                        if (intr & WL1251_ACX_INTR_EVENT_A)
-                                wl1251_event_handle(wl, 0);
-                        else
-                                wl1251_event_handle(wl, 1);
-                }
-
-                if (intr & WL1251_ACX_INTR_INIT_COMPLETE)
-                        wl1251_debug(DEBUG_IRQ,
-                                     "WL1251_ACX_INTR_INIT_COMPLETE");
-
-                if (--ctr == 0)
-                        break;
-
-                intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR);
-        } while (intr);
-
-out_sleep:
-        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask));
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1251_join(struct wl1251 *wl, u8 bss_type, u8 channel,
-                       u16 beacon_interval, u8 dtim_period)
-{
-        int ret;
-
-        ret = wl1251_acx_frame_rates(wl, DEFAULT_HW_GEN_TX_RATE,
-                                     DEFAULT_HW_GEN_MODULATION_TYPE,
-                                     wl->tx_mgmt_frm_rate,
-                                     wl->tx_mgmt_frm_mod);
-        if (ret < 0)
-                goto out;
-
-
-        ret = wl1251_cmd_join(wl, bss_type, channel, beacon_interval,
-                              dtim_period);
-        if (ret < 0)
-                goto out;
-
-        /*
-         * FIXME: we should wait for JOIN_EVENT_COMPLETE_ID but to simplify
-         * locking we just sleep instead, for now
-         */
-        msleep(10);
-
-out:
-        return ret;
-}
-
-static void wl1251_filter_work(struct work_struct *work)
-{
-        struct wl1251 *wl =
-                container_of(work, struct wl1251, filter_work);
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        if (wl->state == WL1251_STATE_OFF)
-                goto out;
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1251_join(wl, wl->bss_type, wl->channel, wl->beacon_int,
-                          wl->dtim_period);
-        if (ret < 0)
-                goto out_sleep;
-
-out_sleep:
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1251_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
-{
-        struct wl1251 *wl = hw->priv;
-
-        skb_queue_tail(&wl->tx_queue, skb);
-
-        /*
-         * The chip specific setup must run before the first TX packet -
-         * before that, the tx_work will not be initialized!
-         */
-
-        ieee80211_queue_work(wl->hw, &wl->tx_work);
-
-        /*
-         * The workqueue is slow to process the tx_queue and we need stop
-         * the queue here, otherwise the queue will get too long.
-         */
-        if (skb_queue_len(&wl->tx_queue) >= WL1251_TX_QUEUE_MAX_LENGTH) {
-                wl1251_debug(DEBUG_TX, "op_tx: tx_queue full, stop queues");
-                ieee80211_stop_queues(wl->hw);
-
-                /*
-                 * FIXME: this is racy, the variable is not properly
-                 * protected. Maybe fix this by removing the stupid
-                 * variable altogether and checking the real queue state?
-                 */
-                wl->tx_queue_stopped = true;
-        }
-
-        return NETDEV_TX_OK;
-}
-
-static int wl1251_op_start(struct ieee80211_hw *hw)
-{
-        struct wl1251 *wl = hw->priv;
-        struct wiphy *wiphy = hw->wiphy;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 start");
-
-        mutex_lock(&wl->mutex);
-
-        if (wl->state != WL1251_STATE_OFF) {
-                wl1251_error("cannot start because not in off state: %d",
-                             wl->state);
-                ret = -EBUSY;
-                goto out;
-        }
-
-        ret = wl1251_chip_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1251_boot(wl);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1251_hw_init(wl);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1251_acx_station_id(wl);
-        if (ret < 0)
-                goto out;
-
-        wl->state = WL1251_STATE_ON;
-
-        wl1251_info("firmware booted (%s)", wl->fw_ver);
-
-        /* update hw/fw version info in wiphy struct */
-        wiphy->hw_version = wl->chip_id;
-        strncpy(wiphy->fw_version, wl->fw_ver, sizeof(wiphy->fw_version));
-
-out:
-        if (ret < 0)
-                wl1251_power_off(wl);
-
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-static void wl1251_op_stop(struct ieee80211_hw *hw)
-{
-        struct wl1251 *wl = hw->priv;
-
-        wl1251_info("down");
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 stop");
-
-        mutex_lock(&wl->mutex);
-
-        WARN_ON(wl->state != WL1251_STATE_ON);
-
-        if (wl->scanning) {
-                mutex_unlock(&wl->mutex);
-                ieee80211_scan_completed(wl->hw, true);
-                mutex_lock(&wl->mutex);
-                wl->scanning = false;
-        }
-
-        wl->state = WL1251_STATE_OFF;
-
-        wl1251_disable_interrupts(wl);
-
-        mutex_unlock(&wl->mutex);
-
-        cancel_work_sync(&wl->irq_work);
-        cancel_work_sync(&wl->tx_work);
-        cancel_work_sync(&wl->filter_work);
-
-        mutex_lock(&wl->mutex);
-
-        /* let's notify MAC80211 about the remaining pending TX frames */
-        wl1251_tx_flush(wl);
-        wl1251_power_off(wl);
-
-        memset(wl->bssid, 0, ETH_ALEN);
-        wl->listen_int = 1;
-        wl->bss_type = MAX_BSS_TYPE;
-
-        wl->data_in_count = 0;
-        wl->rx_counter = 0;
-        wl->rx_handled = 0;
-        wl->rx_current_buffer = 0;
-        wl->rx_last_id = 0;
-        wl->next_tx_complete = 0;
-        wl->elp = false;
-        wl->psm = 0;
-        wl->tx_queue_stopped = false;
-        wl->power_level = WL1251_DEFAULT_POWER_LEVEL;
-        wl->channel = WL1251_DEFAULT_CHANNEL;
-
-        wl1251_debugfs_reset(wl);
-
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1251_op_add_interface(struct ieee80211_hw *hw,
-                                   struct ieee80211_vif *vif)
-{
-        struct wl1251 *wl = hw->priv;
-        int ret = 0;
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
-                     vif->type, vif->addr);
-
-        mutex_lock(&wl->mutex);
-        if (wl->vif) {
-                ret = -EBUSY;
-                goto out;
-        }
-
-        wl->vif = vif;
-
-        switch (vif->type) {
-        case NL80211_IFTYPE_STATION:
-                wl->bss_type = BSS_TYPE_STA_BSS;
-                break;
-        case NL80211_IFTYPE_ADHOC:
-                wl->bss_type = BSS_TYPE_IBSS;
-                break;
-        default:
-                ret = -EOPNOTSUPP;
-                goto out;
-        }
-
-        if (memcmp(wl->mac_addr, vif->addr, ETH_ALEN)) {
-                memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
-                SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
-                ret = wl1251_acx_station_id(wl);
-                if (ret < 0)
-                        goto out;
-        }
-
-out:
-        mutex_unlock(&wl->mutex);
-        return ret;
-}
-
-static void wl1251_op_remove_interface(struct ieee80211_hw *hw,
-                                         struct ieee80211_vif *vif)
-{
-        struct wl1251 *wl = hw->priv;
-
-        mutex_lock(&wl->mutex);
-        wl1251_debug(DEBUG_MAC80211, "mac80211 remove interface");
-        wl->vif = NULL;
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1251_build_qos_null_data(struct wl1251 *wl)
-{
-        struct ieee80211_qos_hdr template;
-
-        memset(&template, 0, sizeof(template));
-
-        memcpy(template.addr1, wl->bssid, ETH_ALEN);
-        memcpy(template.addr2, wl->mac_addr, ETH_ALEN);
-        memcpy(template.addr3, wl->bssid, ETH_ALEN);
-
-        template.frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
-                                             IEEE80211_STYPE_QOS_NULLFUNC |
-                                             IEEE80211_FCTL_TODS);
-
-        /* FIXME: not sure what priority to use here */
-        template.qos_ctrl = cpu_to_le16(0);
-
-        return wl1251_cmd_template_set(wl, CMD_QOS_NULL_DATA, &template,
-                                       sizeof(template));
-}
-
-static int wl1251_op_config(struct ieee80211_hw *hw, u32 changed)
-{
-        struct wl1251 *wl = hw->priv;
-        struct ieee80211_conf *conf = &hw->conf;
-        int channel, ret = 0;
-
-        channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d",
-                     channel,
-                     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
-                     conf->power_level);
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        if (channel != wl->channel) {
-                wl->channel = channel;
-
-                ret = wl1251_join(wl, wl->bss_type, wl->channel,
-                                  wl->beacon_int, wl->dtim_period);
-                if (ret < 0)
-                        goto out_sleep;
-        }
-
-        if (conf->flags & IEEE80211_CONF_PS && !wl->psm_requested) {
-                wl1251_debug(DEBUG_PSM, "psm enabled");
-
-                wl->psm_requested = true;
-
-                wl->dtim_period = conf->ps_dtim_period;
-
-                ret = wl1251_acx_wr_tbtt_and_dtim(wl, wl->beacon_int,
-                                                  wl->dtim_period);
-
-                /*
-                 * mac80211 enables PSM only if we're already associated.
-                 */
-                ret = wl1251_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
-                if (ret < 0)
-                        goto out_sleep;
-        } else if (!(conf->flags & IEEE80211_CONF_PS) &&
-                   wl->psm_requested) {
-                wl1251_debug(DEBUG_PSM, "psm disabled");
-
-                wl->psm_requested = false;
-
-                if (wl->psm) {
-                        ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE);
-                        if (ret < 0)
-                                goto out_sleep;
-                }
-        }
-
-        if (conf->power_level != wl->power_level) {
-                ret = wl1251_acx_tx_power(wl, conf->power_level);
-                if (ret < 0)
-                        goto out_sleep;
-
-                wl->power_level = conf->power_level;
-        }
-
-out_sleep:
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-#define WL1251_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
-                                  FIF_ALLMULTI | \
-                                  FIF_FCSFAIL | \
-                                  FIF_BCN_PRBRESP_PROMISC | \
-                                  FIF_CONTROL | \
-                                  FIF_OTHER_BSS)
-
-static void wl1251_op_configure_filter(struct ieee80211_hw *hw,
-                                       unsigned int changed,
-                                       unsigned int *total,u64 multicast)
-{
-        struct wl1251 *wl = hw->priv;
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 configure filter");
-
-        *total &= WL1251_SUPPORTED_FILTERS;
-        changed &= WL1251_SUPPORTED_FILTERS;
-
-        if (changed == 0)
-                /* no filters which we support changed */
-                return;
-
-        /* FIXME: wl->rx_config and wl->rx_filter are not protected */
-
-        wl->rx_config = WL1251_DEFAULT_RX_CONFIG;
-        wl->rx_filter = WL1251_DEFAULT_RX_FILTER;
-
-        if (*total & FIF_PROMISC_IN_BSS) {
-                wl->rx_config |= CFG_BSSID_FILTER_EN;
-                wl->rx_config |= CFG_RX_ALL_GOOD;
-        }
-        if (*total & FIF_ALLMULTI)
-                /*
-                 * CFG_MC_FILTER_EN in rx_config needs to be 0 to receive
-                 * all multicast frames
-                 */
-                wl->rx_config &= ~CFG_MC_FILTER_EN;
-        if (*total & FIF_FCSFAIL)
-                wl->rx_filter |= CFG_RX_FCS_ERROR;
-        if (*total & FIF_BCN_PRBRESP_PROMISC) {
-                wl->rx_config &= ~CFG_BSSID_FILTER_EN;
-                wl->rx_config &= ~CFG_SSID_FILTER_EN;
-        }
-        if (*total & FIF_CONTROL)
-                wl->rx_filter |= CFG_RX_CTL_EN;
-        if (*total & FIF_OTHER_BSS)
-                wl->rx_filter &= ~CFG_BSSID_FILTER_EN;
-
-        /*
-         * FIXME: workqueues need to be properly cancelled on stop(), for
-         * now let's just disable changing the filter settings. They will
-         * be updated any on config().
-         */
-        /* schedule_work(&wl->filter_work); */
-}
-
-/* HW encryption */
-static int wl1251_set_key_type(struct wl1251 *wl,
-                               struct wl1251_cmd_set_keys *key,
-                               enum set_key_cmd cmd,
-                               struct ieee80211_key_conf *mac80211_key,
-                               const u8 *addr)
-{
-        switch (mac80211_key->alg) {
-        case ALG_WEP:
-                if (is_broadcast_ether_addr(addr))
-                        key->key_type = KEY_WEP_DEFAULT;
-                else
-                        key->key_type = KEY_WEP_ADDR;
-
-                mac80211_key->hw_key_idx = mac80211_key->keyidx;
-                break;
-        case ALG_TKIP:
-                if (is_broadcast_ether_addr(addr))
-                        key->key_type = KEY_TKIP_MIC_GROUP;
-                else
-                        key->key_type = KEY_TKIP_MIC_PAIRWISE;
-
-                mac80211_key->hw_key_idx = mac80211_key->keyidx;
-                break;
-        case ALG_CCMP:
-                if (is_broadcast_ether_addr(addr))
-                        key->key_type = KEY_AES_GROUP;
-                else
-                        key->key_type = KEY_AES_PAIRWISE;
-                mac80211_key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
-                break;
-        default:
-                wl1251_error("Unknown key algo 0x%x", mac80211_key->alg);
-                return -EOPNOTSUPP;
-        }
-
-        return 0;
-}
-
-static int wl1251_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
-                             struct ieee80211_vif *vif,
-                             struct ieee80211_sta *sta,
-                             struct ieee80211_key_conf *key)
-{
-        struct wl1251 *wl = hw->priv;
-        struct wl1251_cmd_set_keys *wl_cmd;
-        const u8 *addr;
-        int ret;
-
-        static const u8 bcast_addr[ETH_ALEN] =
-                { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 set key");
-
-        wl_cmd = kzalloc(sizeof(*wl_cmd), GFP_KERNEL);
-        if (!wl_cmd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        addr = sta ? sta->addr : bcast_addr;
-
-        wl1251_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
-        wl1251_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
-        wl1251_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
-                     key->alg, key->keyidx, key->keylen, key->flags);
-        wl1251_dump(DEBUG_CRYPT, "KEY: ", key->key, key->keylen);
-
-        if (is_zero_ether_addr(addr)) {
-                /* We dont support TX only encryption */
-                ret = -EOPNOTSUPP;
-                goto out;
-        }
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out_unlock;
-
-        switch (cmd) {
-        case SET_KEY:
-                wl_cmd->key_action = KEY_ADD_OR_REPLACE;
-                break;
-        case DISABLE_KEY:
-                wl_cmd->key_action = KEY_REMOVE;
-                break;
-        default:
-                wl1251_error("Unsupported key cmd 0x%x", cmd);
-                break;
-        }
-
-        ret = wl1251_set_key_type(wl, wl_cmd, cmd, key, addr);
-        if (ret < 0) {
-                wl1251_error("Set KEY type failed");
-                goto out_sleep;
-        }
-
-        if (wl_cmd->key_type != KEY_WEP_DEFAULT)
-                memcpy(wl_cmd->addr, addr, ETH_ALEN);
-
-        if ((wl_cmd->key_type == KEY_TKIP_MIC_GROUP) ||
-            (wl_cmd->key_type == KEY_TKIP_MIC_PAIRWISE)) {
-                /*
-                 * We get the key in the following form:
-                 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
-                 * but the target is expecting:
-                 * TKIP - RX MIC - TX MIC
-                 */
-                memcpy(wl_cmd->key, key->key, 16);
-                memcpy(wl_cmd->key + 16, key->key + 24, 8);
-                memcpy(wl_cmd->key + 24, key->key + 16, 8);
-
-        } else {
-                memcpy(wl_cmd->key, key->key, key->keylen);
-        }
-        wl_cmd->key_size = key->keylen;
-
-        wl_cmd->id = key->keyidx;
-        wl_cmd->ssid_profile = 0;
-
-        wl1251_dump(DEBUG_CRYPT, "TARGET KEY: ", wl_cmd, sizeof(*wl_cmd));
-
-        ret = wl1251_cmd_send(wl, CMD_SET_KEYS, wl_cmd, sizeof(*wl_cmd));
-        if (ret < 0) {
-                wl1251_warning("could not set keys");
-                goto out_sleep;
-        }
-
-out_sleep:
-        wl1251_ps_elp_sleep(wl);
-
-out_unlock:
-        mutex_unlock(&wl->mutex);
-
-out:
-        kfree(wl_cmd);
-
-        return ret;
-}
-
-static int wl1251_op_hw_scan(struct ieee80211_hw *hw,
-                             struct ieee80211_vif *vif,
-                             struct cfg80211_scan_request *req)
-{
-        struct wl1251 *wl = hw->priv;
-        struct sk_buff *skb;
-        size_t ssid_len = 0;
-        u8 *ssid = NULL;
-        int ret;
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 hw scan");
-
-        if (req->n_ssids) {
-                ssid = req->ssids[0].ssid;
-                ssid_len = req->ssids[0].ssid_len;
-        }
-
-        mutex_lock(&wl->mutex);
-
-        if (wl->scanning) {
-                wl1251_debug(DEBUG_SCAN, "scan already in progress");
-                ret = -EINVAL;
-                goto out;
-        }
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        skb = ieee80211_probereq_get(wl->hw, wl->vif, ssid, ssid_len,
-                                     req->ie, req->ie_len);
-        if (!skb) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = wl1251_cmd_template_set(wl, CMD_PROBE_REQ, skb->data,
-                                      skb->len);
-        dev_kfree_skb(skb);
-        if (ret < 0)
-                goto out_sleep;
-
-        ret = wl1251_cmd_trigger_scan_to(wl, 0);
-        if (ret < 0)
-                goto out_sleep;
-
-        wl->scanning = true;
-
-        ret = wl1251_cmd_scan(wl, ssid, ssid_len, req->channels,
-                              req->n_channels, WL1251_SCAN_NUM_PROBES);
-        if (ret < 0) {
-                wl->scanning = false;
-                goto out_sleep;
-        }
-
-out_sleep:
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-static int wl1251_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
-{
-        struct wl1251 *wl = hw->priv;
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1251_acx_rts_threshold(wl, (u16) value);
-        if (ret < 0)
-                wl1251_warning("wl1251_op_set_rts_threshold failed: %d", ret);
-
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw,
-                                       struct ieee80211_vif *vif,
-                                       struct ieee80211_bss_conf *bss_conf,
-                                       u32 changed)
-{
-        struct wl1251 *wl = hw->priv;
-        struct sk_buff *beacon, *skb;
-        int ret;
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 bss info changed");
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        if (changed & BSS_CHANGED_BSSID) {
-                memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
-
-                skb = ieee80211_nullfunc_get(wl->hw, wl->vif);
-                if (!skb)
-                        goto out_sleep;
-
-                ret = wl1251_cmd_template_set(wl, CMD_NULL_DATA,
-                                              skb->data, skb->len);
-                dev_kfree_skb(skb);
-                if (ret < 0)
-                        goto out_sleep;
-
-                ret = wl1251_build_qos_null_data(wl);
-                if (ret < 0)
-                        goto out;
-
-                if (wl->bss_type != BSS_TYPE_IBSS) {
-                        ret = wl1251_join(wl, wl->bss_type, wl->channel,
-                                          wl->beacon_int, wl->dtim_period);
-                        if (ret < 0)
-                                goto out_sleep;
-                }
-        }
-
-        if (changed & BSS_CHANGED_ASSOC) {
-                if (bss_conf->assoc) {
-                        wl->beacon_int = bss_conf->beacon_int;
-
-                        skb = ieee80211_pspoll_get(wl->hw, wl->vif);
-                        if (!skb)
-                                goto out_sleep;
-
-                        ret = wl1251_cmd_template_set(wl, CMD_PS_POLL,
-                                                      skb->data,
-                                                      skb->len);
-                        dev_kfree_skb(skb);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        ret = wl1251_acx_aid(wl, bss_conf->aid);
-                        if (ret < 0)
-                                goto out_sleep;
-                } else {
-                        /* use defaults when not associated */
-                        wl->beacon_int = WL1251_DEFAULT_BEACON_INT;
-                        wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD;
-                }
-        }
-        if (changed & BSS_CHANGED_ERP_SLOT) {
-                if (bss_conf->use_short_slot)
-                        ret = wl1251_acx_slot(wl, SLOT_TIME_SHORT);
-                else
-                        ret = wl1251_acx_slot(wl, SLOT_TIME_LONG);
-                if (ret < 0) {
-                        wl1251_warning("Set slot time failed %d", ret);
-                        goto out_sleep;
-                }
-        }
-
-        if (changed & BSS_CHANGED_ERP_PREAMBLE) {
-                if (bss_conf->use_short_preamble)
-                        wl1251_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
-                else
-                        wl1251_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
-        }
-
-        if (changed & BSS_CHANGED_ERP_CTS_PROT) {
-                if (bss_conf->use_cts_prot)
-                        ret = wl1251_acx_cts_protect(wl, CTSPROTECT_ENABLE);
-                else
-                        ret = wl1251_acx_cts_protect(wl, CTSPROTECT_DISABLE);
-                if (ret < 0) {
-                        wl1251_warning("Set ctsprotect failed %d", ret);
-                        goto out_sleep;
-                }
-        }
-
-        if (changed & BSS_CHANGED_BEACON) {
-                beacon = ieee80211_beacon_get(hw, vif);
-                ret = wl1251_cmd_template_set(wl, CMD_BEACON, beacon->data,
-                                              beacon->len);
-
-                if (ret < 0) {
-                        dev_kfree_skb(beacon);
-                        goto out_sleep;
-                }
-
-                ret = wl1251_cmd_template_set(wl, CMD_PROBE_RESP, beacon->data,
-                                              beacon->len);
-
-                dev_kfree_skb(beacon);
-
-                if (ret < 0)
-                        goto out_sleep;
-
-                ret = wl1251_join(wl, wl->bss_type, wl->beacon_int,
-                                  wl->channel, wl->dtim_period);
-
-                if (ret < 0)
-                        goto out_sleep;
-        }
-
-out_sleep:
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-
-/* can't be const, mac80211 writes to this */
-static struct ieee80211_rate wl1251_rates[] = {
-        { .bitrate = 10,
-          .hw_value = 0x1,
-          .hw_value_short = 0x1, },
-        { .bitrate = 20,
-          .hw_value = 0x2,
-          .hw_value_short = 0x2,
-          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
-        { .bitrate = 55,
-          .hw_value = 0x4,
-          .hw_value_short = 0x4,
-          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
-        { .bitrate = 110,
-          .hw_value = 0x20,
-          .hw_value_short = 0x20,
-          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
-        { .bitrate = 60,
-          .hw_value = 0x8,
-          .hw_value_short = 0x8, },
-        { .bitrate = 90,
-          .hw_value = 0x10,
-          .hw_value_short = 0x10, },
-        { .bitrate = 120,
-          .hw_value = 0x40,
-          .hw_value_short = 0x40, },
-        { .bitrate = 180,
-          .hw_value = 0x80,
-          .hw_value_short = 0x80, },
-        { .bitrate = 240,
-          .hw_value = 0x200,
-          .hw_value_short = 0x200, },
-        { .bitrate = 360,
-         .hw_value = 0x400,
-         .hw_value_short = 0x400, },
-        { .bitrate = 480,
-          .hw_value = 0x800,
-          .hw_value_short = 0x800, },
-        { .bitrate = 540,
-          .hw_value = 0x1000,
-          .hw_value_short = 0x1000, },
-};
-
-/* can't be const, mac80211 writes to this */
-static struct ieee80211_channel wl1251_channels[] = {
-        { .hw_value = 1, .center_freq = 2412},
-        { .hw_value = 2, .center_freq = 2417},
-        { .hw_value = 3, .center_freq = 2422},
-        { .hw_value = 4, .center_freq = 2427},
-        { .hw_value = 5, .center_freq = 2432},
-        { .hw_value = 6, .center_freq = 2437},
-        { .hw_value = 7, .center_freq = 2442},
-        { .hw_value = 8, .center_freq = 2447},
-        { .hw_value = 9, .center_freq = 2452},
-        { .hw_value = 10, .center_freq = 2457},
-        { .hw_value = 11, .center_freq = 2462},
-        { .hw_value = 12, .center_freq = 2467},
-        { .hw_value = 13, .center_freq = 2472},
-};
-
-static int wl1251_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
-                             const struct ieee80211_tx_queue_params *params)
-{
-        enum wl1251_acx_ps_scheme ps_scheme;
-        struct wl1251 *wl = hw->priv;
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        wl1251_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
-
-        ret = wl1251_ps_elp_wakeup(wl);
-        if (ret < 0)
-                goto out;
-
-        /* mac80211 uses units of 32 usec */
-        ret = wl1251_acx_ac_cfg(wl, wl1251_tx_get_queue(queue),
-                                params->cw_min, params->cw_max,
-                                params->aifs, params->txop * 32);
-        if (ret < 0)
-                goto out_sleep;
-
-        if (params->uapsd)
-                ps_scheme = WL1251_ACX_PS_SCHEME_UPSD_TRIGGER;
-        else
-                ps_scheme = WL1251_ACX_PS_SCHEME_LEGACY;
-
-        ret = wl1251_acx_tid_cfg(wl, wl1251_tx_get_queue(queue),
-                                 CHANNEL_TYPE_EDCF,
-                                 wl1251_tx_get_queue(queue), ps_scheme,
-                                 WL1251_ACX_ACK_POLICY_LEGACY);
-        if (ret < 0)
-                goto out_sleep;
-
-out_sleep:
-        wl1251_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-static int wl1251_op_get_survey(struct ieee80211_hw *hw, int idx,
-                                struct survey_info *survey)
-{
-        struct wl1251 *wl = hw->priv;
-        struct ieee80211_conf *conf = &hw->conf;
- 
-        if (idx != 0)
-                return -ENOENT;
- 
-        survey->channel = conf->channel;
-        survey->filled = SURVEY_INFO_NOISE_DBM;
-        survey->noise = wl->noise;
- 
-        return 0;
-}
-
-/* can't be const, mac80211 writes to this */
-static struct ieee80211_supported_band wl1251_band_2ghz = {
-        .channels = wl1251_channels,
-        .n_channels = ARRAY_SIZE(wl1251_channels),
-        .bitrates = wl1251_rates,
-        .n_bitrates = ARRAY_SIZE(wl1251_rates),
-};
-
-static const struct ieee80211_ops wl1251_ops = {
-        .start = wl1251_op_start,
-        .stop = wl1251_op_stop,
-        .add_interface = wl1251_op_add_interface,
-        .remove_interface = wl1251_op_remove_interface,
-        .config = wl1251_op_config,
-        .configure_filter = wl1251_op_configure_filter,
-        .tx = wl1251_op_tx,
-        .set_key = wl1251_op_set_key,
-        .hw_scan = wl1251_op_hw_scan,
-        .bss_info_changed = wl1251_op_bss_info_changed,
-        .set_rts_threshold = wl1251_op_set_rts_threshold,
-        .conf_tx = wl1251_op_conf_tx,
-        .get_survey = wl1251_op_get_survey,
-};
-
-static int wl1251_read_eeprom_byte(struct wl1251 *wl, off_t offset, u8 *data)
-{
-        unsigned long timeout;
-
-        wl1251_reg_write32(wl, EE_ADDR, offset);
-        wl1251_reg_write32(wl, EE_CTL, EE_CTL_READ);
-
-        /* EE_CTL_READ clears when data is ready */
-        timeout = jiffies + msecs_to_jiffies(100);
-        while (1) {
-                if (!(wl1251_reg_read32(wl, EE_CTL) & EE_CTL_READ))
-                        break;
-
-                if (time_after(jiffies, timeout))
-                        return -ETIMEDOUT;
-
-                msleep(1);
-        }
-
-        *data = wl1251_reg_read32(wl, EE_DATA);
-        return 0;
-}
-
-static int wl1251_read_eeprom(struct wl1251 *wl, off_t offset,
-                              u8 *data, size_t len)
-{
-        size_t i;
-        int ret;
-
-        wl1251_reg_write32(wl, EE_START, 0);
-
-        for (i = 0; i < len; i++) {
-                ret = wl1251_read_eeprom_byte(wl, offset + i, &data[i]);
-                if (ret < 0)
-                        return ret;
-        }
-
-        return 0;
-}
-
-static int wl1251_read_eeprom_mac(struct wl1251 *wl)
-{
-        u8 mac[ETH_ALEN];
-        int i, ret;
-
-        wl1251_set_partition(wl, 0, 0, REGISTERS_BASE, REGISTERS_DOWN_SIZE);
-
-        ret = wl1251_read_eeprom(wl, 0x1c, mac, sizeof(mac));
-        if (ret < 0) {
-                wl1251_warning("failed to read MAC address from EEPROM");
-                return ret;
-        }
-
-        /* MAC is stored in reverse order */
-        for (i = 0; i < ETH_ALEN; i++)
-                wl->mac_addr[i] = mac[ETH_ALEN - i - 1];
-
-        return 0;
-}
-
-static int wl1251_register_hw(struct wl1251 *wl)
-{
-        int ret;
-
-        if (wl->mac80211_registered)
-                return 0;
-
-        SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
-
-        ret = ieee80211_register_hw(wl->hw);
-        if (ret < 0) {
-                wl1251_error("unable to register mac80211 hw: %d", ret);
-                return ret;
-        }
-
-        wl->mac80211_registered = true;
-
-        wl1251_notice("loaded");
-
-        return 0;
-}
-
-int wl1251_init_ieee80211(struct wl1251 *wl)
-{
-        int ret;
-
-        /* The tx descriptor buffer and the TKIP space */
-        wl->hw->extra_tx_headroom = sizeof(struct tx_double_buffer_desc)
-                + WL1251_TKIP_IV_SPACE;
-
-        /* unit us */
-        /* FIXME: find a proper value */
-        wl->hw->channel_change_time = 10000;
-
-        wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
-                IEEE80211_HW_SUPPORTS_PS |
-                IEEE80211_HW_BEACON_FILTER |
-                IEEE80211_HW_SUPPORTS_UAPSD;
-
-        wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
-        wl->hw->wiphy->max_scan_ssids = 1;
-        wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1251_band_2ghz;
-
-        wl->hw->queues = 4;
-
-        if (wl->use_eeprom)
-                wl1251_read_eeprom_mac(wl);
-
-        ret = wl1251_register_hw(wl);
-        if (ret)
-                goto out;
-
-        wl1251_debugfs_init(wl);
-        wl1251_notice("initialized");
-
-        ret = 0;
-
-out:
-        return ret;
-}
-EXPORT_SYMBOL_GPL(wl1251_init_ieee80211);
-
-struct ieee80211_hw *wl1251_alloc_hw(void)
-{
-        struct ieee80211_hw *hw;
-        struct wl1251 *wl;
-        int i;
-        static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
-
-        hw = ieee80211_alloc_hw(sizeof(*wl), &wl1251_ops);
-        if (!hw) {
-                wl1251_error("could not alloc ieee80211_hw");
-                return ERR_PTR(-ENOMEM);
-        }
-
-        wl = hw->priv;
-        memset(wl, 0, sizeof(*wl));
-
-        wl->hw = hw;
-
-        wl->data_in_count = 0;
-
-        skb_queue_head_init(&wl->tx_queue);
-
-        INIT_WORK(&wl->filter_work, wl1251_filter_work);
-        INIT_DELAYED_WORK(&wl->elp_work, wl1251_elp_work);
-        wl->channel = WL1251_DEFAULT_CHANNEL;
-        wl->scanning = false;
-        wl->default_key = 0;
-        wl->listen_int = 1;
-        wl->rx_counter = 0;
-        wl->rx_handled = 0;
-        wl->rx_current_buffer = 0;
-        wl->rx_last_id = 0;
-        wl->rx_config = WL1251_DEFAULT_RX_CONFIG;
-        wl->rx_filter = WL1251_DEFAULT_RX_FILTER;
-        wl->elp = false;
-        wl->psm = 0;
-        wl->psm_requested = false;
-        wl->tx_queue_stopped = false;
-        wl->power_level = WL1251_DEFAULT_POWER_LEVEL;
-        wl->beacon_int = WL1251_DEFAULT_BEACON_INT;
-        wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD;
-        wl->vif = NULL;
-
-        for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++)
-                wl->tx_frames[i] = NULL;
-
-        wl->next_tx_complete = 0;
-
-        INIT_WORK(&wl->irq_work, wl1251_irq_work);
-        INIT_WORK(&wl->tx_work, wl1251_tx_work);
-
-        /*
-         * In case our MAC address is not correctly set,
-         * we use a random but Nokia MAC.
-         */
-        memcpy(wl->mac_addr, nokia_oui, 3);
-        get_random_bytes(wl->mac_addr + 3, 3);
-
-        wl->state = WL1251_STATE_OFF;
-        mutex_init(&wl->mutex);
-
-        wl->tx_mgmt_frm_rate = DEFAULT_HW_GEN_TX_RATE;
-        wl->tx_mgmt_frm_mod = DEFAULT_HW_GEN_MODULATION_TYPE;
-
-        wl->rx_descriptor = kmalloc(sizeof(*wl->rx_descriptor), GFP_KERNEL);
-        if (!wl->rx_descriptor) {
-                wl1251_error("could not allocate memory for rx descriptor");
-                ieee80211_free_hw(hw);
-                return ERR_PTR(-ENOMEM);
-        }
-
-        return hw;
-}
-EXPORT_SYMBOL_GPL(wl1251_alloc_hw);
-
-int wl1251_free_hw(struct wl1251 *wl)
-{
-        ieee80211_unregister_hw(wl->hw);
-
-        wl1251_debugfs_exit(wl);
-
-        kfree(wl->target_mem_map);
-        kfree(wl->data_path);
-        vfree(wl->fw);
-        wl->fw = NULL;
-        kfree(wl->nvs);
-        wl->nvs = NULL;
-
-        kfree(wl->rx_descriptor);
-        wl->rx_descriptor = NULL;
-
-        ieee80211_free_hw(wl->hw);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(wl1251_free_hw);
-
-MODULE_DESCRIPTION("TI wl1251 Wireles LAN Driver Core");
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");
-MODULE_FIRMWARE(WL1251_FW_NAME);
diff --git a/drivers/net/wireless/wl12xx/wl1251_ps.c b/drivers/net/wireless/wl12xx/wl1251_ps.c
deleted file mode 100644
index b55cb2bd459a..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_ps.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include "wl1251_reg.h"
-#include "wl1251_ps.h"
-#include "wl1251_cmd.h"
-#include "wl1251_io.h"
-
-/* in ms */
-#define WL1251_WAKEUP_TIMEOUT 100
-
-void wl1251_elp_work(struct work_struct *work)
-{
-        struct delayed_work *dwork;
-        struct wl1251 *wl;
-
-        dwork = container_of(work, struct delayed_work, work);
-        wl = container_of(dwork, struct wl1251, elp_work);
-
-        wl1251_debug(DEBUG_PSM, "elp work");
-
-        mutex_lock(&wl->mutex);
-
-        if (wl->elp || !wl->psm)
-                goto out;
-
-        wl1251_debug(DEBUG_PSM, "chip to elp");
-        wl1251_write_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, ELPCTRL_SLEEP);
-        wl->elp = true;
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-#define ELP_ENTRY_DELAY  5
-
-/* Routines to toggle sleep mode while in ELP */
-void wl1251_ps_elp_sleep(struct wl1251 *wl)
-{
-        unsigned long delay;
-
-        if (wl->psm) {
-                cancel_delayed_work(&wl->elp_work);
-                delay = msecs_to_jiffies(ELP_ENTRY_DELAY);
-                ieee80211_queue_delayed_work(wl->hw, &wl->elp_work, delay);
-        }
-}
-
-int wl1251_ps_elp_wakeup(struct wl1251 *wl)
-{
-        unsigned long timeout, start;
-        u32 elp_reg;
-
-        if (!wl->elp)
-                return 0;
-
-        wl1251_debug(DEBUG_PSM, "waking up chip from elp");
-
-        start = jiffies;
-        timeout = jiffies + msecs_to_jiffies(WL1251_WAKEUP_TIMEOUT);
-
-        wl1251_write_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, ELPCTRL_WAKE_UP);
-
-        elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
-
-        /*
-         * FIXME: we should wait for irq from chip but, as a temporary
-         * solution to simplify locking, let's poll instead
-         */
-        while (!(elp_reg & ELPCTRL_WLAN_READY)) {
-                if (time_after(jiffies, timeout)) {
-                        wl1251_error("elp wakeup timeout");
-                        return -ETIMEDOUT;
-                }
-                msleep(1);
-                elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
-        }
-
-        wl1251_debug(DEBUG_PSM, "wakeup time: %u ms",
-                     jiffies_to_msecs(jiffies - start));
-
-        wl->elp = false;
-
-        return 0;
-}
-
-static int wl1251_ps_set_elp(struct wl1251 *wl, bool enable)
-{
-        int ret;
-
-        if (enable) {
-                wl1251_debug(DEBUG_PSM, "sleep auth psm/elp");
-
-                ret = wl1251_acx_sleep_auth(wl, WL1251_PSM_ELP);
-                if (ret < 0)
-                        return ret;
-
-                wl1251_ps_elp_sleep(wl);
-        } else {
-                wl1251_debug(DEBUG_PSM, "sleep auth cam");
-
-                /*
-                 * When the target is in ELP, we can only
-                 * access the ELP control register. Thus,
-                 * we have to wake the target up before
-                 * changing the power authorization.
-                 */
-
-                wl1251_ps_elp_wakeup(wl);
-
-                ret = wl1251_acx_sleep_auth(wl, WL1251_PSM_CAM);
-                if (ret < 0)
-                        return ret;
-        }
-
-        return 0;
-}
-
-int wl1251_ps_set_mode(struct wl1251 *wl, enum wl1251_cmd_ps_mode mode)
-{
-        int ret;
-
-        switch (mode) {
-        case STATION_POWER_SAVE_MODE:
-                wl1251_debug(DEBUG_PSM, "entering psm");
-
-                /* enable beacon filtering */
-                ret = wl1251_acx_beacon_filter_opt(wl, true);
-                if (ret < 0)
-                        return ret;
-
-                ret = wl1251_acx_wake_up_conditions(wl,
-                                                    WAKE_UP_EVENT_DTIM_BITMAP,
-                                                    wl->listen_int);
-                if (ret < 0)
-                        return ret;
-
-                ret = wl1251_cmd_ps_mode(wl, STATION_POWER_SAVE_MODE);
-                if (ret < 0)
-                        return ret;
-
-                ret = wl1251_ps_set_elp(wl, true);
-                if (ret < 0)
-                        return ret;
-
-                wl->psm = 1;
-                break;
-        case STATION_ACTIVE_MODE:
-        default:
-                wl1251_debug(DEBUG_PSM, "leaving psm");
-                ret = wl1251_ps_set_elp(wl, false);
-                if (ret < 0)
-                        return ret;
-
-                /* disable beacon filtering */
-                ret = wl1251_acx_beacon_filter_opt(wl, false);
-                if (ret < 0)
-                        return ret;
-
-                ret = wl1251_acx_wake_up_conditions(wl,
-                                                    WAKE_UP_EVENT_DTIM_BITMAP,
-                                                    wl->listen_int);
-                if (ret < 0)
-                        return ret;
-
-                ret = wl1251_cmd_ps_mode(wl, STATION_ACTIVE_MODE);
-                if (ret < 0)
-                        return ret;
-
-                wl->psm = 0;
-                break;
-        }
-
-        return ret;
-}
-
diff --git a/drivers/net/wireless/wl12xx/wl1251_ps.h b/drivers/net/wireless/wl12xx/wl1251_ps.h
deleted file mode 100644
index c688ac57aee4..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_ps.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef __WL1251_PS_H__
-#define __WL1251_PS_H__
-
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include "wl1251.h"
-#include "wl1251_acx.h"
-
-int wl1251_ps_set_mode(struct wl1251 *wl, enum wl1251_cmd_ps_mode mode);
-void wl1251_ps_elp_sleep(struct wl1251 *wl);
-int wl1251_ps_elp_wakeup(struct wl1251 *wl);
-void wl1251_elp_work(struct work_struct *work);
-
-
-#endif /* __WL1251_PS_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1251_reg.h b/drivers/net/wireless/wl12xx/wl1251_reg.h
deleted file mode 100644
index d16edd9bf06c..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_reg.h
+++ /dev/null
@@ -1,657 +0,0 @@
-/*
- * This file is part of wl12xx
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __REG_H__
-#define __REG_H__
-
-#include <linux/bitops.h>
-
-#define REGISTERS_BASE 0x00300000
-#define DRPW_BASE      0x00310000
-
-#define REGISTERS_DOWN_SIZE 0x00008800
-#define REGISTERS_WORK_SIZE 0x0000b000
-
-#define HW_ACCESS_ELP_CTRL_REG_ADDR         0x1FFFC
-
-/* ELP register commands */
-#define ELPCTRL_WAKE_UP             0x1
-#define ELPCTRL_WAKE_UP_WLAN_READY  0x5
-#define ELPCTRL_SLEEP               0x0
-/* ELP WLAN_READY bit */
-#define ELPCTRL_WLAN_READY          0x2
-
-/* Device Configuration registers*/
-#define SOR_CFG                        (REGISTERS_BASE + 0x0800)
-#define ECPU_CTRL                      (REGISTERS_BASE + 0x0804)
-#define HI_CFG                         (REGISTERS_BASE + 0x0808)
-
-/* EEPROM registers */
-#define EE_START                       (REGISTERS_BASE + 0x080C)
-#define EE_CTL                         (REGISTERS_BASE + 0x2000)
-#define EE_DATA                        (REGISTERS_BASE + 0x2004)
-#define EE_ADDR                        (REGISTERS_BASE + 0x2008)
-
-#define EE_CTL_READ                   2
-
-#define CHIP_ID_B                      (REGISTERS_BASE + 0x5674)
-
-#define CHIP_ID_1251_PG10                  (0x7010101)
-#define CHIP_ID_1251_PG11                  (0x7020101)
-#define CHIP_ID_1251_PG12                  (0x7030101)
-
-#define ENABLE                         (REGISTERS_BASE + 0x5450)
-
-/* Power Management registers */
-#define ELP_CFG_MODE                   (REGISTERS_BASE + 0x5804)
-#define ELP_CMD                        (REGISTERS_BASE + 0x5808)
-#define PLL_CAL_TIME                   (REGISTERS_BASE + 0x5810)
-#define CLK_REQ_TIME                   (REGISTERS_BASE + 0x5814)
-#define CLK_BUF_TIME                   (REGISTERS_BASE + 0x5818)
-
-#define CFG_PLL_SYNC_CNT               (REGISTERS_BASE + 0x5820)
-
-/* Scratch Pad registers*/
-#define SCR_PAD0                       (REGISTERS_BASE + 0x5608)
-#define SCR_PAD1                       (REGISTERS_BASE + 0x560C)
-#define SCR_PAD2                       (REGISTERS_BASE + 0x5610)
-#define SCR_PAD3                       (REGISTERS_BASE + 0x5614)
-#define SCR_PAD4                       (REGISTERS_BASE + 0x5618)
-#define SCR_PAD4_SET                   (REGISTERS_BASE + 0x561C)
-#define SCR_PAD4_CLR                   (REGISTERS_BASE + 0x5620)
-#define SCR_PAD5                       (REGISTERS_BASE + 0x5624)
-#define SCR_PAD5_SET                   (REGISTERS_BASE + 0x5628)
-#define SCR_PAD5_CLR                   (REGISTERS_BASE + 0x562C)
-#define SCR_PAD6                       (REGISTERS_BASE + 0x5630)
-#define SCR_PAD7                       (REGISTERS_BASE + 0x5634)
-#define SCR_PAD8                       (REGISTERS_BASE + 0x5638)
-#define SCR_PAD9                       (REGISTERS_BASE + 0x563C)
-
-/* Spare registers*/
-#define SPARE_A1                       (REGISTERS_BASE + 0x0994)
-#define SPARE_A2                       (REGISTERS_BASE + 0x0998)
-#define SPARE_A3                       (REGISTERS_BASE + 0x099C)
-#define SPARE_A4                       (REGISTERS_BASE + 0x09A0)
-#define SPARE_A5                       (REGISTERS_BASE + 0x09A4)
-#define SPARE_A6                       (REGISTERS_BASE + 0x09A8)
-#define SPARE_A7                       (REGISTERS_BASE + 0x09AC)
-#define SPARE_A8                       (REGISTERS_BASE + 0x09B0)
-#define SPARE_B1                       (REGISTERS_BASE + 0x5420)
-#define SPARE_B2                       (REGISTERS_BASE + 0x5424)
-#define SPARE_B3                       (REGISTERS_BASE + 0x5428)
-#define SPARE_B4                       (REGISTERS_BASE + 0x542C)
-#define SPARE_B5                       (REGISTERS_BASE + 0x5430)
-#define SPARE_B6                       (REGISTERS_BASE + 0x5434)
-#define SPARE_B7                       (REGISTERS_BASE + 0x5438)
-#define SPARE_B8                       (REGISTERS_BASE + 0x543C)
-
-enum wl12xx_acx_int_reg {
-        ACX_REG_INTERRUPT_TRIG,
-        ACX_REG_INTERRUPT_TRIG_H,
-
-/*=============================================
-  Host Interrupt Mask Register - 32bit (RW)
-  ------------------------------------------
-  Setting a bit in this register masks the
-  corresponding interrupt to the host.
-  0 - RX0               - Rx first dubble buffer Data Interrupt
-  1 - TXD               - Tx Data Interrupt
-  2 - TXXFR             - Tx Transfer Interrupt
-  3 - RX1               - Rx second dubble buffer Data Interrupt
-  4 - RXXFR             - Rx Transfer Interrupt
-  5 - EVENT_A   - Event Mailbox interrupt
-  6 - EVENT_B   - Event Mailbox interrupt
-  7 - WNONHST   - Wake On Host Interrupt
-  8 - TRACE_A   - Debug Trace interrupt
-  9 - TRACE_B   - Debug Trace interrupt
- 10 - CDCMP             - Command Complete Interrupt
- 11 -
- 12 -
- 13 -
- 14 - ICOMP             - Initialization Complete Interrupt
- 16 - SG SE             - Soft Gemini - Sense enable interrupt
- 17 - SG SD             - Soft Gemini - Sense disable interrupt
- 18 -                   -
- 19 -                   -
- 20 -                   -
- 21-                    -
- Default: 0x0001
-*==============================================*/
-        ACX_REG_INTERRUPT_MASK,
-
-/*=============================================
-  Host Interrupt Mask Set 16bit, (Write only)
-  ------------------------------------------
- Setting a bit in this register sets
- the corresponding bin in ACX_HINT_MASK register
- without effecting the mask
- state of other bits (0 = no effect).
-==============================================*/
-        ACX_REG_HINT_MASK_SET,
-
-/*=============================================
-  Host Interrupt Mask Clear 16bit,(Write only)
-  ------------------------------------------
- Setting a bit in this register clears
- the corresponding bin in ACX_HINT_MASK register
- without effecting the mask
- state of other bits (0 = no effect).
-=============================================*/
-        ACX_REG_HINT_MASK_CLR,
-
-/*=============================================
-  Host Interrupt Status Nondestructive Read
-  16bit,(Read only)
-  ------------------------------------------
- The host can read this register to determine
- which interrupts are active.
- Reading this register doesn't
- effect its content.
-=============================================*/
-        ACX_REG_INTERRUPT_NO_CLEAR,
-
-/*=============================================
-  Host Interrupt Status Clear on Read  Register
-  16bit,(Read only)
-  ------------------------------------------
- The host can read this register to determine
- which interrupts are active.
- Reading this register clears it,
- thus making all interrupts inactive.
-==============================================*/
-        ACX_REG_INTERRUPT_CLEAR,
-
-/*=============================================
-  Host Interrupt Acknowledge Register
-  16bit,(Write only)
-  ------------------------------------------
- The host can set individual bits in this
- register to clear (acknowledge) the corresp.
- interrupt status bits in the HINT_STS_CLR and
- HINT_STS_ND registers, thus making the
- assotiated interrupt inactive. (0-no effect)
-==============================================*/
-        ACX_REG_INTERRUPT_ACK,
-
-/*===============================================
-   Host Software Reset - 32bit RW
- ------------------------------------------
-    [31:1] Reserved
-    0  SOFT_RESET Soft Reset  - When this bit is set,
-    it holds the Wlan hardware in a soft reset state.
-    This reset disables all MAC and baseband processor
-    clocks except the CardBus/PCI interface clock.
-    It also initializes all MAC state machines except
-    the host interface. It does not reload the
-    contents of the EEPROM. When this bit is cleared
-    (not self-clearing), the Wlan hardware
-    exits the software reset state.
-===============================================*/
-        ACX_REG_SLV_SOFT_RESET,
-
-/*===============================================
- EEPROM Burst Read Start  - 32bit RW
- ------------------------------------------
- [31:1] Reserved
- 0  ACX_EE_START -  EEPROM Burst Read Start 0
- Setting this bit starts a burst read from
- the external EEPROM.
- If this bit is set (after reset) before an EEPROM read/write,
- the burst read starts at EEPROM address 0.
- Otherwise, it starts at the address
- following the address of the previous access.
- TheWlan hardware hardware clears this bit automatically.
-
- Default: 0x00000000
-*================================================*/
-        ACX_REG_EE_START,
-
-/* Embedded ARM CPU Control */
-
-/*===============================================
- Halt eCPU   - 32bit RW
- ------------------------------------------
- 0 HALT_ECPU Halt Embedded CPU - This bit is the
- compliment of bit 1 (MDATA2) in the SOR_CFG register.
- During a hardware reset, this bit holds
- the inverse of MDATA2.
- When downloading firmware from the host,
- set this bit (pull down MDATA2).
- The host clears this bit after downloading the firmware into
- zero-wait-state SSRAM.
- When loading firmware from Flash, clear this bit (pull up MDATA2)
- so that the eCPU can run the bootloader code in Flash
- HALT_ECPU eCPU State
- --------------------
- 1 halt eCPU
- 0 enable eCPU
- ===============================================*/
-        ACX_REG_ECPU_CONTROL,
-
-        ACX_REG_TABLE_LEN
-};
-
-#define ACX_SLV_SOFT_RESET_BIT   BIT(0)
-#define ACX_REG_EEPROM_START_BIT BIT(0)
-
-/* Command/Information Mailbox Pointers */
-
-/*===============================================
-  Command Mailbox Pointer - 32bit RW
- ------------------------------------------
- This register holds the start address of
- the command mailbox located in the Wlan hardware memory.
- The host must read this pointer after a reset to
- find the location of the command mailbox.
- The Wlan hardware initializes the command mailbox
- pointer with the default address of the command mailbox.
- The command mailbox pointer is not valid until after
- the host receives the Init Complete interrupt from
- the Wlan hardware.
- ===============================================*/
-#define REG_COMMAND_MAILBOX_PTR                         (SCR_PAD0)
-
-/*===============================================
-  Information Mailbox Pointer - 32bit RW
- ------------------------------------------
- This register holds the start address of
- the information mailbox located in the Wlan hardware memory.
- The host must read this pointer after a reset to find
- the location of the information mailbox.
- The Wlan hardware initializes the information mailbox pointer
- with the default address of the information mailbox.
- The information mailbox pointer is not valid
- until after the host receives the Init Complete interrupt from
- the Wlan hardware.
- ===============================================*/
-#define REG_EVENT_MAILBOX_PTR                           (SCR_PAD1)
-
-
-/* Misc */
-
-#define REG_ENABLE_TX_RX                                (ENABLE)
-/*
- * Rx configuration (filter) information element
- * ---------------------------------------------
- */
-#define REG_RX_CONFIG                           (RX_CFG)
-#define REG_RX_FILTER                           (RX_FILTER_CFG)
-
-
-#define RX_CFG_ENABLE_PHY_HEADER_PLCP    0x0002
-
-/* promiscuous - receives all valid frames */
-#define RX_CFG_PROMISCUOUS               0x0008
-
-/* receives frames from any BSSID */
-#define RX_CFG_BSSID                     0x0020
-
-/* receives frames destined to any MAC address */
-#define RX_CFG_MAC                       0x0010
-
-#define RX_CFG_ENABLE_ONLY_MY_DEST_MAC   0x0010
-#define RX_CFG_ENABLE_ANY_DEST_MAC       0x0000
-#define RX_CFG_ENABLE_ONLY_MY_BSSID      0x0020
-#define RX_CFG_ENABLE_ANY_BSSID          0x0000
-
-/* discards all broadcast frames */
-#define RX_CFG_DISABLE_BCAST             0x0200
-
-#define RX_CFG_ENABLE_ONLY_MY_SSID       0x0400
-#define RX_CFG_ENABLE_RX_CMPLT_FCS_ERROR 0x0800
-#define RX_CFG_COPY_RX_STATUS            0x2000
-#define RX_CFG_TSF                       0x10000
-
-#define RX_CONFIG_OPTION_ANY_DST_MY_BSS  (RX_CFG_ENABLE_ANY_DEST_MAC | \
-                                          RX_CFG_ENABLE_ONLY_MY_BSSID)
-
-#define RX_CONFIG_OPTION_MY_DST_ANY_BSS  (RX_CFG_ENABLE_ONLY_MY_DEST_MAC\
-                                          | RX_CFG_ENABLE_ANY_BSSID)
-
-#define RX_CONFIG_OPTION_ANY_DST_ANY_BSS (RX_CFG_ENABLE_ANY_DEST_MAC | \
-                                          RX_CFG_ENABLE_ANY_BSSID)
-
-#define RX_CONFIG_OPTION_MY_DST_MY_BSS   (RX_CFG_ENABLE_ONLY_MY_DEST_MAC\
-                                          | RX_CFG_ENABLE_ONLY_MY_BSSID)
-
-#define RX_CONFIG_OPTION_FOR_SCAN  (RX_CFG_ENABLE_PHY_HEADER_PLCP \
-                                    | RX_CFG_ENABLE_RX_CMPLT_FCS_ERROR \
-                                    | RX_CFG_COPY_RX_STATUS | RX_CFG_TSF)
-
-#define RX_CONFIG_OPTION_FOR_MEASUREMENT (RX_CFG_ENABLE_ANY_DEST_MAC)
-
-#define RX_CONFIG_OPTION_FOR_JOIN        (RX_CFG_ENABLE_ONLY_MY_BSSID | \
-                                          RX_CFG_ENABLE_ONLY_MY_DEST_MAC)
-
-#define RX_CONFIG_OPTION_FOR_IBSS_JOIN   (RX_CFG_ENABLE_ONLY_MY_SSID | \
-                                          RX_CFG_ENABLE_ONLY_MY_DEST_MAC)
-
-#define RX_FILTER_OPTION_DEF          (CFG_RX_MGMT_EN | CFG_RX_DATA_EN\
-                                       | CFG_RX_CTL_EN | CFG_RX_BCN_EN\
-                                       | CFG_RX_AUTH_EN | CFG_RX_ASSOC_EN)
-
-#define RX_FILTER_OPTION_FILTER_ALL      0
-
-#define RX_FILTER_OPTION_DEF_PRSP_BCN  (CFG_RX_PRSP_EN | CFG_RX_MGMT_EN\
-                                        | CFG_RX_RCTS_ACK | CFG_RX_BCN_EN)
-
-#define RX_FILTER_OPTION_JOIN        (CFG_RX_MGMT_EN | CFG_RX_DATA_EN\
-                                      | CFG_RX_BCN_EN | CFG_RX_AUTH_EN\
-                                      | CFG_RX_ASSOC_EN | CFG_RX_RCTS_ACK\
-                                      | CFG_RX_PRSP_EN)
-
-
-/*===============================================
- EEPROM Read/Write Request 32bit RW
- ------------------------------------------
- 1 EE_READ - EEPROM Read Request 1 - Setting this bit
- loads a single byte of data into the EE_DATA
- register from the EEPROM location specified in
- the EE_ADDR register.
- The Wlan hardware hardware clears this bit automatically.
- EE_DATA is valid when this bit is cleared.
-
- 0 EE_WRITE  - EEPROM Write Request  - Setting this bit
- writes a single byte of data from the EE_DATA register into the
- EEPROM location specified in the EE_ADDR register.
- The Wlan hardware hardware clears this bit automatically.
-*===============================================*/
-#define EE_CTL                              (REGISTERS_BASE + 0x2000)
-#define ACX_EE_CTL_REG                      EE_CTL
-#define EE_WRITE                            0x00000001ul
-#define EE_READ                             0x00000002ul
-
-/*===============================================
-  EEPROM Address  - 32bit RW
-  ------------------------------------------
-  This register specifies the address
-  within the EEPROM from/to which to read/write data.
-  ===============================================*/
-#define EE_ADDR                             (REGISTERS_BASE + 0x2008)
-#define ACX_EE_ADDR_REG                     EE_ADDR
-
-/*===============================================
-  EEPROM Data  - 32bit RW
-  ------------------------------------------
-  This register either holds the read 8 bits of
-  data from the EEPROM or the write data
-  to be written to the EEPROM.
-  ===============================================*/
-#define EE_DATA                             (REGISTERS_BASE + 0x2004)
-#define ACX_EE_DATA_REG                     EE_DATA
-
-#define EEPROM_ACCESS_TO                    10000   /* timeout counter */
-#define START_EEPROM_MGR                    0x00000001
-
-/*===============================================
-  EEPROM Base Address  - 32bit RW
-  ------------------------------------------
-  This register holds the upper nine bits
-  [23:15] of the 24-bit Wlan hardware memory
-  address for burst reads from EEPROM accesses.
-  The EEPROM provides the lower 15 bits of this address.
-  The MSB of the address from the EEPROM is ignored.
-  ===============================================*/
-#define ACX_EE_CFG                          EE_CFG
-
-/*===============================================
-  GPIO Output Values  -32bit, RW
-  ------------------------------------------
-  [31:16]  Reserved
-  [15: 0]  Specify the output values (at the output driver inputs) for
-  GPIO[15:0], respectively.
-  ===============================================*/
-#define ACX_GPIO_OUT_REG            GPIO_OUT
-#define ACX_MAX_GPIO_LINES          15
-
-/*===============================================
-  Contention window  -32bit, RW
-  ------------------------------------------
-  [31:26]  Reserved
-  [25:16]  Max (0x3ff)
-  [15:07]  Reserved
-  [06:00]  Current contention window value - default is 0x1F
-  ===============================================*/
-#define ACX_CONT_WIND_CFG_REG    CONT_WIND_CFG
-#define ACX_CONT_WIND_MIN_MASK   0x0000007f
-#define ACX_CONT_WIND_MAX        0x03ff0000
-
-/*===============================================
-  HI_CFG Interface Configuration Register Values
-  ------------------------------------------
-  ===============================================*/
-#define HI_CFG_UART_ENABLE          0x00000004
-#define HI_CFG_RST232_ENABLE        0x00000008
-#define HI_CFG_CLOCK_REQ_SELECT     0x00000010
-#define HI_CFG_HOST_INT_ENABLE      0x00000020
-#define HI_CFG_VLYNQ_OUTPUT_ENABLE  0x00000040
-#define HI_CFG_HOST_INT_ACTIVE_LOW  0x00000080
-#define HI_CFG_UART_TX_OUT_GPIO_15  0x00000100
-#define HI_CFG_UART_TX_OUT_GPIO_14  0x00000200
-#define HI_CFG_UART_TX_OUT_GPIO_7   0x00000400
-
-/*
- * NOTE: USE_ACTIVE_HIGH compilation flag should be defined in makefile
- *       for platforms using active high interrupt level
- */
-#ifdef USE_ACTIVE_HIGH
-#define HI_CFG_DEF_VAL              \
-        (HI_CFG_UART_ENABLE |        \
-        HI_CFG_RST232_ENABLE |      \
-        HI_CFG_CLOCK_REQ_SELECT |   \
-        HI_CFG_HOST_INT_ENABLE)
-#else
-#define HI_CFG_DEF_VAL              \
-        (HI_CFG_UART_ENABLE |        \
-        HI_CFG_RST232_ENABLE |      \
-        HI_CFG_CLOCK_REQ_SELECT |   \
-        HI_CFG_HOST_INT_ENABLE)
-
-#endif
-
-#define REF_FREQ_19_2                       0
-#define REF_FREQ_26_0                       1
-#define REF_FREQ_38_4                       2
-#define REF_FREQ_40_0                       3
-#define REF_FREQ_33_6                       4
-#define REF_FREQ_NUM                        5
-
-#define LUT_PARAM_INTEGER_DIVIDER           0
-#define LUT_PARAM_FRACTIONAL_DIVIDER        1
-#define LUT_PARAM_ATTN_BB                   2
-#define LUT_PARAM_ALPHA_BB                  3
-#define LUT_PARAM_STOP_TIME_BB              4
-#define LUT_PARAM_BB_PLL_LOOP_FILTER        5
-#define LUT_PARAM_NUM                       6
-
-#define ACX_EEPROMLESS_IND_REG              (SCR_PAD4)
-#define USE_EEPROM                          0
-#define SOFT_RESET_MAX_TIME                 1000000
-#define SOFT_RESET_STALL_TIME               1000
-#define NVS_DATA_BUNDARY_ALIGNMENT          4
-
-
-/* Firmware image load chunk size */
-#define CHUNK_SIZE          512
-
-/* Firmware image header size */
-#define FW_HDR_SIZE 8
-
-#define ECPU_CONTROL_HALT                                       0x00000101
-
-
-/******************************************************************************
-
-    CHANNELS, BAND & REG DOMAINS definitions
-
-******************************************************************************/
-
-
-enum {
-        RADIO_BAND_2_4GHZ = 0,  /* 2.4 Ghz band */
-        RADIO_BAND_5GHZ = 1,    /* 5 Ghz band */
-        RADIO_BAND_JAPAN_4_9_GHZ = 2,
-        DEFAULT_BAND = RADIO_BAND_2_4GHZ,
-        INVALID_BAND = 0xFE,
-        MAX_RADIO_BANDS = 0xFF
-};
-
-enum {
-        NO_RATE      = 0,
-        RATE_1MBPS   = 0x0A,
-        RATE_2MBPS   = 0x14,
-        RATE_5_5MBPS = 0x37,
-        RATE_6MBPS   = 0x0B,
-        RATE_9MBPS   = 0x0F,
-        RATE_11MBPS  = 0x6E,
-        RATE_12MBPS  = 0x0A,
-        RATE_18MBPS  = 0x0E,
-        RATE_22MBPS  = 0xDC,
-        RATE_24MBPS  = 0x09,
-        RATE_36MBPS  = 0x0D,
-        RATE_48MBPS  = 0x08,
-        RATE_54MBPS  = 0x0C
-};
-
-enum {
-        RATE_INDEX_1MBPS   =  0,
-        RATE_INDEX_2MBPS   =  1,
-        RATE_INDEX_5_5MBPS =  2,
-        RATE_INDEX_6MBPS   =  3,
-        RATE_INDEX_9MBPS   =  4,
-        RATE_INDEX_11MBPS  =  5,
-        RATE_INDEX_12MBPS  =  6,
-        RATE_INDEX_18MBPS  =  7,
-        RATE_INDEX_22MBPS  =  8,
-        RATE_INDEX_24MBPS  =  9,
-        RATE_INDEX_36MBPS  =  10,
-        RATE_INDEX_48MBPS  =  11,
-        RATE_INDEX_54MBPS  =  12,
-        RATE_INDEX_MAX     =  RATE_INDEX_54MBPS,
-        MAX_RATE_INDEX,
-        INVALID_RATE_INDEX = MAX_RATE_INDEX,
-        RATE_INDEX_ENUM_MAX_SIZE = 0x7FFFFFFF
-};
-
-enum {
-        RATE_MASK_1MBPS = 0x1,
-        RATE_MASK_2MBPS = 0x2,
-        RATE_MASK_5_5MBPS = 0x4,
-        RATE_MASK_11MBPS = 0x20,
-};
-
-#define SHORT_PREAMBLE_BIT   BIT(0) /* CCK or Barker depending on the rate */
-#define OFDM_RATE_BIT        BIT(6)
-#define PBCC_RATE_BIT        BIT(7)
-
-enum {
-        CCK_LONG = 0,
-        CCK_SHORT = SHORT_PREAMBLE_BIT,
-        PBCC_LONG = PBCC_RATE_BIT,
-        PBCC_SHORT = PBCC_RATE_BIT | SHORT_PREAMBLE_BIT,
-        OFDM = OFDM_RATE_BIT
-};
-
-/******************************************************************************
-
-Transmit-Descriptor RATE-SET field definitions...
-
-Define a new "Rate-Set" for TX path that incorporates the
-Rate & Modulation info into a single 16-bit field.
-
-TxdRateSet_t:
-b15   - Indicates Preamble type (1=SHORT, 0=LONG).
-        Notes:
-        Must be LONG (0) for 1Mbps rate.
-        Does not apply (set to 0) for RevG-OFDM rates.
-b14   - Indicates PBCC encoding (1=PBCC, 0=not).
-        Notes:
-        Does not apply (set to 0) for rates 1 and 2 Mbps.
-        Does not apply (set to 0) for RevG-OFDM rates.
-b13    - Unused (set to 0).
-b12-b0 - Supported Rate indicator bits as defined below.
-
-******************************************************************************/
-
-
-/*************************************************************************
-
-    Interrupt Trigger Register (Host -> WiLink)
-
-**************************************************************************/
-
-/* Hardware to Embedded CPU Interrupts - first 32-bit register set */
-
-/*
- * Host Command Interrupt. Setting this bit masks
- * the interrupt that the host issues to inform
- * the FW that it has sent a command
- * to the Wlan hardware Command Mailbox.
- */
-#define INTR_TRIG_CMD       BIT(0)
-
-/*
- * Host Event Acknowlegde Interrupt. The host
- * sets this bit to acknowledge that it received
- * the unsolicited information from the event
- * mailbox.
- */
-#define INTR_TRIG_EVENT_ACK BIT(1)
-
-/*
- * The host sets this bit to inform the Wlan
- * FW that a TX packet is in the XFER
- * Buffer #0.
- */
-#define INTR_TRIG_TX_PROC0 BIT(2)
-
-/*
- * The host sets this bit to inform the FW
- * that it read a packet from RX XFER
- * Buffer #0.
- */
-#define INTR_TRIG_RX_PROC0 BIT(3)
-
-#define INTR_TRIG_DEBUG_ACK BIT(4)
-
-#define INTR_TRIG_STATE_CHANGED BIT(5)
-
-
-/* Hardware to Embedded CPU Interrupts - second 32-bit register set */
-
-/*
- * The host sets this bit to inform the FW
- * that it read a packet from RX XFER
- * Buffer #1.
- */
-#define INTR_TRIG_RX_PROC1 BIT(17)
-
-/*
- * The host sets this bit to inform the Wlan
- * hardware that a TX packet is in the XFER
- * Buffer #1.
- */
-#define INTR_TRIG_TX_PROC1 BIT(18)
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1251_rx.c b/drivers/net/wireless/wl12xx/wl1251_rx.c
deleted file mode 100644
index 1b6294b3b996..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_rx.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/skbuff.h>
-#include <linux/gfp.h>
-#include <net/mac80211.h>
-
-#include "wl1251.h"
-#include "wl1251_reg.h"
-#include "wl1251_io.h"
-#include "wl1251_rx.h"
-#include "wl1251_cmd.h"
-#include "wl1251_acx.h"
-
-static void wl1251_rx_header(struct wl1251 *wl,
-                             struct wl1251_rx_descriptor *desc)
-{
-        u32 rx_packet_ring_addr;
-
-        rx_packet_ring_addr = wl->data_path->rx_packet_ring_addr;
-        if (wl->rx_current_buffer)
-                rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size;
-
-        wl1251_mem_read(wl, rx_packet_ring_addr, desc, sizeof(*desc));
-}
-
-static void wl1251_rx_status(struct wl1251 *wl,
-                             struct wl1251_rx_descriptor *desc,
-                             struct ieee80211_rx_status *status,
-                             u8 beacon)
-{
-        u64 mactime;
-        int ret;
-
-        memset(status, 0, sizeof(struct ieee80211_rx_status));
-
-        status->band = IEEE80211_BAND_2GHZ;
-        status->mactime = desc->timestamp;
-
-        /*
-         * The rx status timestamp is a 32 bits value while the TSF is a
-         * 64 bits one.
-         * For IBSS merging, TSF is mandatory, so we have to get it
-         * somehow, so we ask for ACX_TSF_INFO.
-         * That could be moved to the get_tsf() hook, but unfortunately,
-         * this one must be atomic, while our SPI routines can sleep.
-         */
-        if ((wl->bss_type == BSS_TYPE_IBSS) && beacon) {
-                ret = wl1251_acx_tsf_info(wl, &mactime);
-                if (ret == 0)
-                        status->mactime = mactime;
-        }
-
-        status->signal = desc->rssi;
-
-        /*
-         * FIXME: guessing that snr needs to be divided by two, otherwise
-         * the values don't make any sense
-         */
-        wl->noise = desc->rssi - desc->snr / 2;
-
-        status->freq = ieee80211_channel_to_frequency(desc->channel);
-
-        status->flag |= RX_FLAG_TSFT;
-
-        if (desc->flags & RX_DESC_ENCRYPTION_MASK) {
-                status->flag |= RX_FLAG_IV_STRIPPED | RX_FLAG_MMIC_STRIPPED;
-
-                if (likely(!(desc->flags & RX_DESC_DECRYPT_FAIL)))
-                        status->flag |= RX_FLAG_DECRYPTED;
-
-                if (unlikely(desc->flags & RX_DESC_MIC_FAIL))
-                        status->flag |= RX_FLAG_MMIC_ERROR;
-        }
-
-        if (unlikely(!(desc->flags & RX_DESC_VALID_FCS)))
-                status->flag |= RX_FLAG_FAILED_FCS_CRC;
-
-
-        /* FIXME: set status->rate_idx */
-}
-
-static void wl1251_rx_body(struct wl1251 *wl,
-                           struct wl1251_rx_descriptor *desc)
-{
-        struct sk_buff *skb;
-        struct ieee80211_rx_status status;
-        u8 *rx_buffer, beacon = 0;
-        u16 length, *fc;
-        u32 curr_id, last_id_inc, rx_packet_ring_addr;
-
-        length = WL1251_RX_ALIGN(desc->length  - PLCP_HEADER_LENGTH);
-        curr_id = (desc->flags & RX_DESC_SEQNUM_MASK) >> RX_DESC_PACKETID_SHIFT;
-        last_id_inc = (wl->rx_last_id + 1) % (RX_MAX_PACKET_ID + 1);
-
-        if (last_id_inc != curr_id) {
-                wl1251_warning("curr ID:%d, last ID inc:%d",
-                               curr_id, last_id_inc);
-                wl->rx_last_id = curr_id;
-        } else {
-                wl->rx_last_id = last_id_inc;
-        }
-
-        rx_packet_ring_addr = wl->data_path->rx_packet_ring_addr +
-                sizeof(struct wl1251_rx_descriptor) + 20;
-        if (wl->rx_current_buffer)
-                rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size;
-
-        skb = __dev_alloc_skb(length, GFP_KERNEL);
-        if (!skb) {
-                wl1251_error("Couldn't allocate RX frame");
-                return;
-        }
-
-        rx_buffer = skb_put(skb, length);
-        wl1251_mem_read(wl, rx_packet_ring_addr, rx_buffer, length);
-
-        /* The actual lenght doesn't include the target's alignment */
-        skb->len = desc->length  - PLCP_HEADER_LENGTH;
-
-        fc = (u16 *)skb->data;
-
-        if ((*fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_BEACON)
-                beacon = 1;
-
-        wl1251_rx_status(wl, desc, &status, beacon);
-
-        wl1251_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
-                     beacon ? "beacon" : "");
-
-        memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
-        ieee80211_rx_ni(wl->hw, skb);
-}
-
-static void wl1251_rx_ack(struct wl1251 *wl)
-{
-        u32 data, addr;
-
-        if (wl->rx_current_buffer) {
-                addr = ACX_REG_INTERRUPT_TRIG_H;
-                data = INTR_TRIG_RX_PROC1;
-        } else {
-                addr = ACX_REG_INTERRUPT_TRIG;
-                data = INTR_TRIG_RX_PROC0;
-        }
-
-        wl1251_reg_write32(wl, addr, data);
-
-        /* Toggle buffer ring */
-        wl->rx_current_buffer = !wl->rx_current_buffer;
-}
-
-
-void wl1251_rx(struct wl1251 *wl)
-{
-        struct wl1251_rx_descriptor *rx_desc;
-
-        if (wl->state != WL1251_STATE_ON)
-                return;
-
-        rx_desc = wl->rx_descriptor;
-
-        /* We first read the frame's header */
-        wl1251_rx_header(wl, rx_desc);
-
-        /* Now we can read the body */
-        wl1251_rx_body(wl, rx_desc);
-
-        /* Finally, we need to ACK the RX */
-        wl1251_rx_ack(wl);
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_rx.h b/drivers/net/wireless/wl12xx/wl1251_rx.h
deleted file mode 100644
index da4e53406a0e..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_rx.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_RX_H__
-#define __WL1251_RX_H__
-
-#include <linux/bitops.h>
-
-#include "wl1251.h"
-
-/*
- * RX PATH
- *
- * The Rx path uses a double buffer and an rx_contro structure, each located
- * at a fixed address in the device memory. The host keeps track of which
- * buffer is available and alternates between them on a per packet basis.
- * The size of each of the two buffers is large enough to hold the longest
- * 802.3 packet.
- * The RX path goes like that:
- * 1) The target generates an interrupt each time a new packet is received.
- *   There are 2 RX interrupts, one for each buffer.
- * 2) The host reads the received packet from one of the double buffers.
- * 3) The host triggers a target interrupt.
- * 4) The target prepares the next RX packet.
- */
-
-#define WL1251_RX_MAX_RSSI -30
-#define WL1251_RX_MIN_RSSI -95
-
-#define WL1251_RX_ALIGN_TO 4
-#define WL1251_RX_ALIGN(len) (((len) + WL1251_RX_ALIGN_TO - 1) & \
-                             ~(WL1251_RX_ALIGN_TO - 1))
-
-#define SHORT_PREAMBLE_BIT   BIT(0)
-#define OFDM_RATE_BIT        BIT(6)
-#define PBCC_RATE_BIT        BIT(7)
-
-#define PLCP_HEADER_LENGTH 8
-#define RX_DESC_PACKETID_SHIFT 11
-#define RX_MAX_PACKET_ID 3
-
-#define RX_DESC_VALID_FCS         0x0001
-#define RX_DESC_MATCH_RXADDR1     0x0002
-#define RX_DESC_MCAST             0x0004
-#define RX_DESC_STAINTIM          0x0008
-#define RX_DESC_VIRTUAL_BM        0x0010
-#define RX_DESC_BCAST             0x0020
-#define RX_DESC_MATCH_SSID        0x0040
-#define RX_DESC_MATCH_BSSID       0x0080
-#define RX_DESC_ENCRYPTION_MASK   0x0300
-#define RX_DESC_MEASURMENT        0x0400
-#define RX_DESC_SEQNUM_MASK       0x1800
-#define RX_DESC_MIC_FAIL          0x2000
-#define RX_DESC_DECRYPT_FAIL      0x4000
-
-struct wl1251_rx_descriptor {
-        u32 timestamp; /* In microseconds */
-        u16 length; /* Paylod length, including headers */
-        u16 flags;
-
-        /*
-         * 0 - 802.11
-         * 1 - 802.3
-         * 2 - IP
-         * 3 - Raw Codec
-         */
-        u8 type;
-
-        /*
-         * Received Rate:
-         * 0x0A - 1MBPS
-         * 0x14 - 2MBPS
-         * 0x37 - 5_5MBPS
-         * 0x0B - 6MBPS
-         * 0x0F - 9MBPS
-         * 0x6E - 11MBPS
-         * 0x0A - 12MBPS
-         * 0x0E - 18MBPS
-         * 0xDC - 22MBPS
-         * 0x09 - 24MBPS
-         * 0x0D - 36MBPS
-         * 0x08 - 48MBPS
-         * 0x0C - 54MBPS
-         */
-        u8 rate;
-
-        u8 mod_pre; /* Modulation and preamble */
-        u8 channel;
-
-        /*
-         * 0 - 2.4 Ghz
-         * 1 - 5 Ghz
-         */
-        u8 band;
-
-        s8 rssi; /* in dB */
-        u8 rcpi; /* in dB */
-        u8 snr; /* in dB */
-} __packed;
-
-void wl1251_rx(struct wl1251 *wl);
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1251_sdio.c b/drivers/net/wireless/wl12xx/wl1251_sdio.c
deleted file mode 100644
index b901b6135654..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_sdio.c
+++ /dev/null
@@ -1,342 +0,0 @@
-/*
- * wl12xx SDIO routines
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- * Copyright (C) 2005 Texas Instruments Incorporated
- * Copyright (C) 2008 Google Inc
- * Copyright (C) 2009 Bob Copeland (me@bobcopeland.com)
- */
-#include <linux/module.h>
-#include <linux/mod_devicetable.h>
-#include <linux/mmc/sdio_func.h>
-#include <linux/mmc/sdio_ids.h>
-#include <linux/platform_device.h>
-#include <linux/spi/wl12xx.h>
-#include <linux/irq.h>
-
-#include "wl1251.h"
-
-#ifndef SDIO_VENDOR_ID_TI
-#define SDIO_VENDOR_ID_TI               0x104c
-#endif
-
-#ifndef SDIO_DEVICE_ID_TI_WL1251
-#define SDIO_DEVICE_ID_TI_WL1251        0x9066
-#endif
-
-struct wl1251_sdio {
-        struct sdio_func *func;
-        u32 elp_val;
-};
-
-static struct wl12xx_platform_data *wl12xx_board_data;
-
-static struct sdio_func *wl_to_func(struct wl1251 *wl)
-{
-        struct wl1251_sdio *wl_sdio = wl->if_priv;
-        return wl_sdio->func;
-}
-
-static void wl1251_sdio_interrupt(struct sdio_func *func)
-{
-        struct wl1251 *wl = sdio_get_drvdata(func);
-
-        wl1251_debug(DEBUG_IRQ, "IRQ");
-
-        /* FIXME should be synchronous for sdio */
-        ieee80211_queue_work(wl->hw, &wl->irq_work);
-}
-
-static const struct sdio_device_id wl1251_devices[] = {
-        { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) },
-        {}
-};
-MODULE_DEVICE_TABLE(sdio, wl1251_devices);
-
-
-static void wl1251_sdio_read(struct wl1251 *wl, int addr,
-                             void *buf, size_t len)
-{
-        int ret;
-        struct sdio_func *func = wl_to_func(wl);
-
-        sdio_claim_host(func);
-        ret = sdio_memcpy_fromio(func, buf, addr, len);
-        if (ret)
-                wl1251_error("sdio read failed (%d)", ret);
-        sdio_release_host(func);
-}
-
-static void wl1251_sdio_write(struct wl1251 *wl, int addr,
-                              void *buf, size_t len)
-{
-        int ret;
-        struct sdio_func *func = wl_to_func(wl);
-
-        sdio_claim_host(func);
-        ret = sdio_memcpy_toio(func, addr, buf, len);
-        if (ret)
-                wl1251_error("sdio write failed (%d)", ret);
-        sdio_release_host(func);
-}
-
-static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
-{
-        int ret = 0;
-        struct wl1251_sdio *wl_sdio = wl->if_priv;
-        struct sdio_func *func = wl_sdio->func;
-
-        /*
-         * The hardware only supports RAW (read after write) access for
-         * reading, regular sdio_readb won't work here (it interprets
-         * the unused bits of CMD52 as write data even if we send read
-         * request).
-         */
-        sdio_claim_host(func);
-        *val = sdio_writeb_readb(func, wl_sdio->elp_val, addr, &ret);
-        sdio_release_host(func);
-
-        if (ret)
-                wl1251_error("sdio_readb failed (%d)", ret);
-}
-
-static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
-{
-        int ret = 0;
-        struct wl1251_sdio *wl_sdio = wl->if_priv;
-        struct sdio_func *func = wl_sdio->func;
-
-        sdio_claim_host(func);
-        sdio_writeb(func, val, addr, &ret);
-        sdio_release_host(func);
-
-        if (ret)
-                wl1251_error("sdio_writeb failed (%d)", ret);
-        else
-                wl_sdio->elp_val = val;
-}
-
-static void wl1251_sdio_reset(struct wl1251 *wl)
-{
-}
-
-static void wl1251_sdio_enable_irq(struct wl1251 *wl)
-{
-        struct sdio_func *func = wl_to_func(wl);
-
-        sdio_claim_host(func);
-        sdio_claim_irq(func, wl1251_sdio_interrupt);
-        sdio_release_host(func);
-}
-
-static void wl1251_sdio_disable_irq(struct wl1251 *wl)
-{
-        struct sdio_func *func = wl_to_func(wl);
-
-        sdio_claim_host(func);
-        sdio_release_irq(func);
-        sdio_release_host(func);
-}
-
-/* Interrupts when using dedicated WLAN_IRQ pin */
-static irqreturn_t wl1251_line_irq(int irq, void *cookie)
-{
-        struct wl1251 *wl = cookie;
-
-        ieee80211_queue_work(wl->hw, &wl->irq_work);
-
-        return IRQ_HANDLED;
-}
-
-static void wl1251_enable_line_irq(struct wl1251 *wl)
-{
-        return enable_irq(wl->irq);
-}
-
-static void wl1251_disable_line_irq(struct wl1251 *wl)
-{
-        return disable_irq(wl->irq);
-}
-
-static void wl1251_sdio_set_power(bool enable)
-{
-}
-
-static struct wl1251_if_operations wl1251_sdio_ops = {
-        .read = wl1251_sdio_read,
-        .write = wl1251_sdio_write,
-        .write_elp = wl1251_sdio_write_elp,
-        .read_elp = wl1251_sdio_read_elp,
-        .reset = wl1251_sdio_reset,
-};
-
-static int wl1251_platform_probe(struct platform_device *pdev)
-{
-        if (pdev->id != -1) {
-                wl1251_error("can only handle single device");
-                return -ENODEV;
-        }
-
-        wl12xx_board_data = pdev->dev.platform_data;
-        return 0;
-}
-
-/*
- * Dummy platform_driver for passing platform_data to this driver,
- * until we have a way to pass this through SDIO subsystem or
- * some other way.
- */
-static struct platform_driver wl1251_platform_driver = {
-        .driver = {
-                .name   = "wl1251_data",
-                .owner  = THIS_MODULE,
-        },
-        .probe  = wl1251_platform_probe,
-};
-
-static int wl1251_sdio_probe(struct sdio_func *func,
-                             const struct sdio_device_id *id)
-{
-        int ret;
-        struct wl1251 *wl;
-        struct ieee80211_hw *hw;
-        struct wl1251_sdio *wl_sdio;
-
-        hw = wl1251_alloc_hw();
-        if (IS_ERR(hw))
-                return PTR_ERR(hw);
-
-        wl = hw->priv;
-
-        wl_sdio = kzalloc(sizeof(*wl_sdio), GFP_KERNEL);
-        if (wl_sdio == NULL) {
-                ret = -ENOMEM;
-                goto out_free_hw;
-        }
-
-        sdio_claim_host(func);
-        ret = sdio_enable_func(func);
-        if (ret)
-                goto release;
-
-        sdio_set_block_size(func, 512);
-        sdio_release_host(func);
-
-        SET_IEEE80211_DEV(hw, &func->dev);
-        wl_sdio->func = func;
-        wl->if_priv = wl_sdio;
-        wl->if_ops = &wl1251_sdio_ops;
-        wl->set_power = wl1251_sdio_set_power;
-
-        if (wl12xx_board_data != NULL) {
-                wl->set_power = wl12xx_board_data->set_power;
-                wl->irq = wl12xx_board_data->irq;
-                wl->use_eeprom = wl12xx_board_data->use_eeprom;
-        }
-
-        if (wl->irq) {
-                ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl);
-                if (ret < 0) {
-                        wl1251_error("request_irq() failed: %d", ret);
-                        goto disable;
-                }
-
-                set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
-                disable_irq(wl->irq);
-
-                wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq;
-                wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq;
-
-                wl1251_info("using dedicated interrupt line");
-        } else {
-                wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq;
-                wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq;
-
-                wl1251_info("using SDIO interrupt");
-        }
-
-        ret = wl1251_init_ieee80211(wl);
-        if (ret)
-                goto out_free_irq;
-
-        sdio_set_drvdata(func, wl);
-        return ret;
-
-out_free_irq:
-        if (wl->irq)
-                free_irq(wl->irq, wl);
-disable:
-        sdio_claim_host(func);
-        sdio_disable_func(func);
-release:
-        sdio_release_host(func);
-        kfree(wl_sdio);
-out_free_hw:
-        wl1251_free_hw(wl);
-        return ret;
-}
-
-static void __devexit wl1251_sdio_remove(struct sdio_func *func)
-{
-        struct wl1251 *wl = sdio_get_drvdata(func);
-        struct wl1251_sdio *wl_sdio = wl->if_priv;
-
-        if (wl->irq)
-                free_irq(wl->irq, wl);
-        kfree(wl_sdio);
-        wl1251_free_hw(wl);
-
-        sdio_claim_host(func);
-        sdio_release_irq(func);
-        sdio_disable_func(func);
-        sdio_release_host(func);
-}
-
-static struct sdio_driver wl1251_sdio_driver = {
-        .name           = "wl1251_sdio",
-        .id_table       = wl1251_devices,
-        .probe          = wl1251_sdio_probe,
-        .remove         = __devexit_p(wl1251_sdio_remove),
-};
-
-static int __init wl1251_sdio_init(void)
-{
-        int err;
-
-        err = platform_driver_register(&wl1251_platform_driver);
-        if (err) {
-                wl1251_error("failed to register platform driver: %d", err);
-                return err;
-        }
-
-        err = sdio_register_driver(&wl1251_sdio_driver);
-        if (err)
-                wl1251_error("failed to register sdio driver: %d", err);
-        return err;
-}
-
-static void __exit wl1251_sdio_exit(void)
-{
-        sdio_unregister_driver(&wl1251_sdio_driver);
-        platform_driver_unregister(&wl1251_platform_driver);
-        wl1251_notice("unloaded");
-}
-
-module_init(wl1251_sdio_init);
-module_exit(wl1251_sdio_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");
diff --git a/drivers/net/wireless/wl12xx/wl1251_spi.c b/drivers/net/wireless/wl12xx/wl1251_spi.c
deleted file mode 100644
index 27fdfaaeb074..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_spi.c
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/irq.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/crc7.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/wl12xx.h>
-
-#include "wl1251.h"
-#include "wl1251_reg.h"
-#include "wl1251_spi.h"
-
-static irqreturn_t wl1251_irq(int irq, void *cookie)
-{
-        struct wl1251 *wl;
-
-        wl1251_debug(DEBUG_IRQ, "IRQ");
-
-        wl = cookie;
-
-        ieee80211_queue_work(wl->hw, &wl->irq_work);
-
-        return IRQ_HANDLED;
-}
-
-static struct spi_device *wl_to_spi(struct wl1251 *wl)
-{
-        return wl->if_priv;
-}
-
-static void wl1251_spi_reset(struct wl1251 *wl)
-{
-        u8 *cmd;
-        struct spi_transfer t;
-        struct spi_message m;
-
-        cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
-        if (!cmd) {
-                wl1251_error("could not allocate cmd for spi reset");
-                return;
-        }
-
-        memset(&t, 0, sizeof(t));
-        spi_message_init(&m);
-
-        memset(cmd, 0xff, WSPI_INIT_CMD_LEN);
-
-        t.tx_buf = cmd;
-        t.len = WSPI_INIT_CMD_LEN;
-        spi_message_add_tail(&t, &m);
-
-        spi_sync(wl_to_spi(wl), &m);
-
-        wl1251_dump(DEBUG_SPI, "spi reset -> ", cmd, WSPI_INIT_CMD_LEN);
-}
-
-static void wl1251_spi_wake(struct wl1251 *wl)
-{
-        u8 crc[WSPI_INIT_CMD_CRC_LEN], *cmd;
-        struct spi_transfer t;
-        struct spi_message m;
-
-        cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
-        if (!cmd) {
-                wl1251_error("could not allocate cmd for spi init");
-                return;
-        }
-
-        memset(crc, 0, sizeof(crc));
-        memset(&t, 0, sizeof(t));
-        spi_message_init(&m);
-
-        /*
-         * Set WSPI_INIT_COMMAND
-         * the data is being send from the MSB to LSB
-         */
-        cmd[2] = 0xff;
-        cmd[3] = 0xff;
-        cmd[1] = WSPI_INIT_CMD_START | WSPI_INIT_CMD_TX;
-        cmd[0] = 0;
-        cmd[7] = 0;
-        cmd[6] |= HW_ACCESS_WSPI_INIT_CMD_MASK << 3;
-        cmd[6] |= HW_ACCESS_WSPI_FIXED_BUSY_LEN & WSPI_INIT_CMD_FIXEDBUSY_LEN;
-
-        if (HW_ACCESS_WSPI_FIXED_BUSY_LEN == 0)
-                cmd[5] |=  WSPI_INIT_CMD_DIS_FIXEDBUSY;
-        else
-                cmd[5] |= WSPI_INIT_CMD_EN_FIXEDBUSY;
-
-        cmd[5] |= WSPI_INIT_CMD_IOD | WSPI_INIT_CMD_IP | WSPI_INIT_CMD_CS
-                | WSPI_INIT_CMD_WSPI | WSPI_INIT_CMD_WS;
-
-        crc[0] = cmd[1];
-        crc[1] = cmd[0];
-        crc[2] = cmd[7];
-        crc[3] = cmd[6];
-        crc[4] = cmd[5];
-
-        cmd[4] |= crc7(0, crc, WSPI_INIT_CMD_CRC_LEN) << 1;
-        cmd[4] |= WSPI_INIT_CMD_END;
-
-        t.tx_buf = cmd;
-        t.len = WSPI_INIT_CMD_LEN;
-        spi_message_add_tail(&t, &m);
-
-        spi_sync(wl_to_spi(wl), &m);
-
-        wl1251_dump(DEBUG_SPI, "spi init -> ", cmd, WSPI_INIT_CMD_LEN);
-}
-
-static void wl1251_spi_reset_wake(struct wl1251 *wl)
-{
-        wl1251_spi_reset(wl);
-        wl1251_spi_wake(wl);
-}
-
-static void wl1251_spi_read(struct wl1251 *wl, int addr, void *buf,
-                            size_t len)
-{
-        struct spi_transfer t[3];
-        struct spi_message m;
-        u8 *busy_buf;
-        u32 *cmd;
-
-        cmd = &wl->buffer_cmd;
-        busy_buf = wl->buffer_busyword;
-
-        *cmd = 0;
-        *cmd |= WSPI_CMD_READ;
-        *cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
-        *cmd |= addr & WSPI_CMD_BYTE_ADDR;
-
-        spi_message_init(&m);
-        memset(t, 0, sizeof(t));
-
-        t[0].tx_buf = cmd;
-        t[0].len = 4;
-        spi_message_add_tail(&t[0], &m);
-
-        /* Busy and non busy words read */
-        t[1].rx_buf = busy_buf;
-        t[1].len = WL1251_BUSY_WORD_LEN;
-        spi_message_add_tail(&t[1], &m);
-
-        t[2].rx_buf = buf;
-        t[2].len = len;
-        spi_message_add_tail(&t[2], &m);
-
-        spi_sync(wl_to_spi(wl), &m);
-
-        /* FIXME: check busy words */
-
-        wl1251_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
-        wl1251_dump(DEBUG_SPI, "spi_read buf <- ", buf, len);
-}
-
-static void wl1251_spi_write(struct wl1251 *wl, int addr, void *buf,
-                             size_t len)
-{
-        struct spi_transfer t[2];
-        struct spi_message m;
-        u32 *cmd;
-
-        cmd = &wl->buffer_cmd;
-
-        *cmd = 0;
-        *cmd |= WSPI_CMD_WRITE;
-        *cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
-        *cmd |= addr & WSPI_CMD_BYTE_ADDR;
-
-        spi_message_init(&m);
-        memset(t, 0, sizeof(t));
-
-        t[0].tx_buf = cmd;
-        t[0].len = sizeof(*cmd);
-        spi_message_add_tail(&t[0], &m);
-
-        t[1].tx_buf = buf;
-        t[1].len = len;
-        spi_message_add_tail(&t[1], &m);
-
-        spi_sync(wl_to_spi(wl), &m);
-
-        wl1251_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
-        wl1251_dump(DEBUG_SPI, "spi_write buf -> ", buf, len);
-}
-
-static void wl1251_spi_enable_irq(struct wl1251 *wl)
-{
-        return enable_irq(wl->irq);
-}
-
-static void wl1251_spi_disable_irq(struct wl1251 *wl)
-{
-        return disable_irq(wl->irq);
-}
-
-static const struct wl1251_if_operations wl1251_spi_ops = {
-        .read = wl1251_spi_read,
-        .write = wl1251_spi_write,
-        .reset = wl1251_spi_reset_wake,
-        .enable_irq = wl1251_spi_enable_irq,
-        .disable_irq = wl1251_spi_disable_irq,
-};
-
-static int __devinit wl1251_spi_probe(struct spi_device *spi)
-{
-        struct wl12xx_platform_data *pdata;
-        struct ieee80211_hw *hw;
-        struct wl1251 *wl;
-        int ret;
-
-        pdata = spi->dev.platform_data;
-        if (!pdata) {
-                wl1251_error("no platform data");
-                return -ENODEV;
-        }
-
-        hw = wl1251_alloc_hw();
-        if (IS_ERR(hw))
-                return PTR_ERR(hw);
-
-        wl = hw->priv;
-
-        SET_IEEE80211_DEV(hw, &spi->dev);
-        dev_set_drvdata(&spi->dev, wl);
-        wl->if_priv = spi;
-        wl->if_ops = &wl1251_spi_ops;
-
-        /* This is the only SPI value that we need to set here, the rest
-         * comes from the board-peripherals file */
-        spi->bits_per_word = 32;
-
-        ret = spi_setup(spi);
-        if (ret < 0) {
-                wl1251_error("spi_setup failed");
-                goto out_free;
-        }
-
-        wl->set_power = pdata->set_power;
-        if (!wl->set_power) {
-                wl1251_error("set power function missing in platform data");
-                return -ENODEV;
-        }
-
-        wl->irq = spi->irq;
-        if (wl->irq < 0) {
-                wl1251_error("irq missing in platform data");
-                return -ENODEV;
-        }
-
-        wl->use_eeprom = pdata->use_eeprom;
-
-        ret = request_irq(wl->irq, wl1251_irq, 0, DRIVER_NAME, wl);
-        if (ret < 0) {
-                wl1251_error("request_irq() failed: %d", ret);
-                goto out_free;
-        }
-
-        set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
-
-        disable_irq(wl->irq);
-
-        ret = wl1251_init_ieee80211(wl);
-        if (ret)
-                goto out_irq;
-
-        return 0;
-
- out_irq:
-        free_irq(wl->irq, wl);
-
- out_free:
-        ieee80211_free_hw(hw);
-
-        return ret;
-}
-
-static int __devexit wl1251_spi_remove(struct spi_device *spi)
-{
-        struct wl1251 *wl = dev_get_drvdata(&spi->dev);
-
-        free_irq(wl->irq, wl);
-        wl1251_free_hw(wl);
-
-        return 0;
-}
-
-static struct spi_driver wl1251_spi_driver = {
-        .driver = {
-                .name           = DRIVER_NAME,
-                .bus            = &spi_bus_type,
-                .owner          = THIS_MODULE,
-        },
-
-        .probe          = wl1251_spi_probe,
-        .remove         = __devexit_p(wl1251_spi_remove),
-};
-
-static int __init wl1251_spi_init(void)
-{
-        int ret;
-
-        ret = spi_register_driver(&wl1251_spi_driver);
-        if (ret < 0) {
-                wl1251_error("failed to register spi driver: %d", ret);
-                goto out;
-        }
-
-out:
-        return ret;
-}
-
-static void __exit wl1251_spi_exit(void)
-{
-        spi_unregister_driver(&wl1251_spi_driver);
-
-        wl1251_notice("unloaded");
-}
-
-module_init(wl1251_spi_init);
-module_exit(wl1251_spi_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");
-MODULE_ALIAS("spi:wl1251");
diff --git a/drivers/net/wireless/wl12xx/wl1251_spi.h b/drivers/net/wireless/wl12xx/wl1251_spi.h
deleted file mode 100644
index 2e273a97e7f3..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_spi.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_SPI_H__
-#define __WL1251_SPI_H__
-
-#include "wl1251_cmd.h"
-#include "wl1251_acx.h"
-#include "wl1251_reg.h"
-
-#define WSPI_CMD_READ                 0x40000000
-#define WSPI_CMD_WRITE                0x00000000
-#define WSPI_CMD_FIXED                0x20000000
-#define WSPI_CMD_BYTE_LENGTH          0x1FFE0000
-#define WSPI_CMD_BYTE_LENGTH_OFFSET   17
-#define WSPI_CMD_BYTE_ADDR            0x0001FFFF
-
-#define WSPI_INIT_CMD_CRC_LEN       5
-
-#define WSPI_INIT_CMD_START         0x00
-#define WSPI_INIT_CMD_TX            0x40
-/* the extra bypass bit is sampled by the TNET as '1' */
-#define WSPI_INIT_CMD_BYPASS_BIT    0x80
-#define WSPI_INIT_CMD_FIXEDBUSY_LEN 0x07
-#define WSPI_INIT_CMD_EN_FIXEDBUSY  0x80
-#define WSPI_INIT_CMD_DIS_FIXEDBUSY 0x00
-#define WSPI_INIT_CMD_IOD           0x40
-#define WSPI_INIT_CMD_IP            0x20
-#define WSPI_INIT_CMD_CS            0x10
-#define WSPI_INIT_CMD_WS            0x08
-#define WSPI_INIT_CMD_WSPI          0x01
-#define WSPI_INIT_CMD_END           0x01
-
-#define WSPI_INIT_CMD_LEN           8
-
-#define HW_ACCESS_WSPI_FIXED_BUSY_LEN \
-                ((WL1251_BUSY_WORD_LEN - 4) / sizeof(u32))
-#define HW_ACCESS_WSPI_INIT_CMD_MASK  0
-
-#endif /* __WL1251_SPI_H__ */
diff --git a/drivers/net/wireless/wl12xx/wl1251_tx.c b/drivers/net/wireless/wl12xx/wl1251_tx.c
deleted file mode 100644
index a38ec199187a..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_tx.c
+++ /dev/null
@@ -1,562 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-
-#include "wl1251.h"
-#include "wl1251_reg.h"
-#include "wl1251_tx.h"
-#include "wl1251_ps.h"
-#include "wl1251_io.h"
-
-static bool wl1251_tx_double_buffer_busy(struct wl1251 *wl, u32 data_out_count)
-{
-        int used, data_in_count;
-
-        data_in_count = wl->data_in_count;
-
-        if (data_in_count < data_out_count)
-                /* data_in_count has wrapped */
-                data_in_count += TX_STATUS_DATA_OUT_COUNT_MASK + 1;
-
-        used = data_in_count - data_out_count;
-
-        WARN_ON(used < 0);
-        WARN_ON(used > DP_TX_PACKET_RING_CHUNK_NUM);
-
-        if (used >= DP_TX_PACKET_RING_CHUNK_NUM)
-                return true;
-        else
-                return false;
-}
-
-static int wl1251_tx_path_status(struct wl1251 *wl)
-{
-        u32 status, addr, data_out_count;
-        bool busy;
-
-        addr = wl->data_path->tx_control_addr;
-        status = wl1251_mem_read32(wl, addr);
-        data_out_count = status & TX_STATUS_DATA_OUT_COUNT_MASK;
-        busy = wl1251_tx_double_buffer_busy(wl, data_out_count);
-
-        if (busy)
-                return -EBUSY;
-
-        return 0;
-}
-
-static int wl1251_tx_id(struct wl1251 *wl, struct sk_buff *skb)
-{
-        int i;
-
-        for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++)
-                if (wl->tx_frames[i] == NULL) {
-                        wl->tx_frames[i] = skb;
-                        return i;
-                }
-
-        return -EBUSY;
-}
-
-static void wl1251_tx_control(struct tx_double_buffer_desc *tx_hdr,
-                              struct ieee80211_tx_info *control, u16 fc)
-{
-        *(u16 *)&tx_hdr->control = 0;
-
-        tx_hdr->control.rate_policy = 0;
-
-        /* 802.11 packets */
-        tx_hdr->control.packet_type = 0;
-
-        if (control->flags & IEEE80211_TX_CTL_NO_ACK)
-                tx_hdr->control.ack_policy = 1;
-
-        tx_hdr->control.tx_complete = 1;
-
-        if ((fc & IEEE80211_FTYPE_DATA) &&
-            ((fc & IEEE80211_STYPE_QOS_DATA) ||
-             (fc & IEEE80211_STYPE_QOS_NULLFUNC)))
-                tx_hdr->control.qos = 1;
-}
-
-/* RSN + MIC = 8 + 8 = 16 bytes (worst case - AES). */
-#define MAX_MSDU_SECURITY_LENGTH      16
-#define MAX_MPDU_SECURITY_LENGTH      16
-#define WLAN_QOS_HDR_LEN              26
-#define MAX_MPDU_HEADER_AND_SECURITY  (MAX_MPDU_SECURITY_LENGTH + \
-                                       WLAN_QOS_HDR_LEN)
-#define HW_BLOCK_SIZE                 252
-static void wl1251_tx_frag_block_num(struct tx_double_buffer_desc *tx_hdr)
-{
-        u16 payload_len, frag_threshold, mem_blocks;
-        u16 num_mpdus, mem_blocks_per_frag;
-
-        frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
-        tx_hdr->frag_threshold = cpu_to_le16(frag_threshold);
-
-        payload_len = le16_to_cpu(tx_hdr->length) + MAX_MSDU_SECURITY_LENGTH;
-
-        if (payload_len > frag_threshold) {
-                mem_blocks_per_frag =
-                        ((frag_threshold + MAX_MPDU_HEADER_AND_SECURITY) /
-                         HW_BLOCK_SIZE) + 1;
-                num_mpdus = payload_len / frag_threshold;
-                mem_blocks = num_mpdus * mem_blocks_per_frag;
-                payload_len -= num_mpdus * frag_threshold;
-                num_mpdus++;
-
-        } else {
-                mem_blocks_per_frag = 0;
-                mem_blocks = 0;
-                num_mpdus = 1;
-        }
-
-        mem_blocks += (payload_len / HW_BLOCK_SIZE) + 1;
-
-        if (num_mpdus > 1)
-                mem_blocks += min(num_mpdus, mem_blocks_per_frag);
-
-        tx_hdr->num_mem_blocks = mem_blocks;
-}
-
-static int wl1251_tx_fill_hdr(struct wl1251 *wl, struct sk_buff *skb,
-                              struct ieee80211_tx_info *control)
-{
-        struct tx_double_buffer_desc *tx_hdr;
-        struct ieee80211_rate *rate;
-        int id;
-        u16 fc;
-
-        if (!skb)
-                return -EINVAL;
-
-        id = wl1251_tx_id(wl, skb);
-        if (id < 0)
-                return id;
-
-        fc = *(u16 *)skb->data;
-        tx_hdr = (struct tx_double_buffer_desc *) skb_push(skb,
-                                                           sizeof(*tx_hdr));
-
-        tx_hdr->length = cpu_to_le16(skb->len - sizeof(*tx_hdr));
-        rate = ieee80211_get_tx_rate(wl->hw, control);
-        tx_hdr->rate = cpu_to_le16(rate->hw_value);
-        tx_hdr->expiry_time = cpu_to_le32(1 << 16);
-        tx_hdr->id = id;
-
-        tx_hdr->xmit_queue = wl1251_tx_get_queue(skb_get_queue_mapping(skb));
-
-        wl1251_tx_control(tx_hdr, control, fc);
-        wl1251_tx_frag_block_num(tx_hdr);
-
-        return 0;
-}
-
-/* We copy the packet to the target */
-static int wl1251_tx_send_packet(struct wl1251 *wl, struct sk_buff *skb,
-                                 struct ieee80211_tx_info *control)
-{
-        struct tx_double_buffer_desc *tx_hdr;
-        int len;
-        u32 addr;
-
-        if (!skb)
-                return -EINVAL;
-
-        tx_hdr = (struct tx_double_buffer_desc *) skb->data;
-
-        if (control->control.hw_key &&
-            control->control.hw_key->alg == ALG_TKIP) {
-                int hdrlen;
-                __le16 fc;
-                u16 length;
-                u8 *pos;
-
-                fc = *(__le16 *)(skb->data + sizeof(*tx_hdr));
-                length = le16_to_cpu(tx_hdr->length) + WL1251_TKIP_IV_SPACE;
-                tx_hdr->length = cpu_to_le16(length);
-
-                hdrlen = ieee80211_hdrlen(fc);
-
-                pos = skb_push(skb, WL1251_TKIP_IV_SPACE);
-                memmove(pos, pos + WL1251_TKIP_IV_SPACE,
-                        sizeof(*tx_hdr) + hdrlen);
-        }
-
-        /* Revisit. This is a workaround for getting non-aligned packets.
-           This happens at least with EAPOL packets from the user space.
-           Our DMA requires packets to be aligned on a 4-byte boundary.
-        */
-        if (unlikely((long)skb->data & 0x03)) {
-                int offset = (4 - (long)skb->data) & 0x03;
-                wl1251_debug(DEBUG_TX, "skb offset %d", offset);
-
-                /* check whether the current skb can be used */
-                if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) {
-                        unsigned char *src = skb->data;
-
-                        /* align the buffer on a 4-byte boundary */
-                        skb_reserve(skb, offset);
-                        memmove(skb->data, src, skb->len);
-                        tx_hdr = (struct tx_double_buffer_desc *) skb->data;
-                } else {
-                        wl1251_info("No handler, fixme!");
-                        return -EINVAL;
-                }
-        }
-
-        /* Our skb->data at this point includes the HW header */
-        len = WL1251_TX_ALIGN(skb->len);
-
-        if (wl->data_in_count & 0x1)
-                addr = wl->data_path->tx_packet_ring_addr +
-                        wl->data_path->tx_packet_ring_chunk_size;
-        else
-                addr = wl->data_path->tx_packet_ring_addr;
-
-        wl1251_mem_write(wl, addr, skb->data, len);
-
-        wl1251_debug(DEBUG_TX, "tx id %u skb 0x%p payload %u rate 0x%x "
-                     "queue %d", tx_hdr->id, skb, tx_hdr->length,
-                     tx_hdr->rate, tx_hdr->xmit_queue);
-
-        return 0;
-}
-
-static void wl1251_tx_trigger(struct wl1251 *wl)
-{
-        u32 data, addr;
-
-        if (wl->data_in_count & 0x1) {
-                addr = ACX_REG_INTERRUPT_TRIG_H;
-                data = INTR_TRIG_TX_PROC1;
-        } else {
-                addr = ACX_REG_INTERRUPT_TRIG;
-                data = INTR_TRIG_TX_PROC0;
-        }
-
-        wl1251_reg_write32(wl, addr, data);
-
-        /* Bumping data in */
-        wl->data_in_count = (wl->data_in_count + 1) &
-                TX_STATUS_DATA_OUT_COUNT_MASK;
-}
-
-/* caller must hold wl->mutex */
-static int wl1251_tx_frame(struct wl1251 *wl, struct sk_buff *skb)
-{
-        struct ieee80211_tx_info *info;
-        int ret = 0;
-        u8 idx;
-
-        info = IEEE80211_SKB_CB(skb);
-
-        if (info->control.hw_key) {
-                idx = info->control.hw_key->hw_key_idx;
-                if (unlikely(wl->default_key != idx)) {
-                        ret = wl1251_acx_default_key(wl, idx);
-                        if (ret < 0)
-                                return ret;
-                }
-        }
-
-        ret = wl1251_tx_path_status(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_tx_fill_hdr(wl, skb, info);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1251_tx_send_packet(wl, skb, info);
-        if (ret < 0)
-                return ret;
-
-        wl1251_tx_trigger(wl);
-
-        return ret;
-}
-
-void wl1251_tx_work(struct work_struct *work)
-{
-        struct wl1251 *wl = container_of(work, struct wl1251, tx_work);
-        struct sk_buff *skb;
-        bool woken_up = false;
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        if (unlikely(wl->state == WL1251_STATE_OFF))
-                goto out;
-
-        while ((skb = skb_dequeue(&wl->tx_queue))) {
-                if (!woken_up) {
-                        ret = wl1251_ps_elp_wakeup(wl);
-                        if (ret < 0)
-                                goto out;
-                        woken_up = true;
-                }
-
-                ret = wl1251_tx_frame(wl, skb);
-                if (ret == -EBUSY) {
-                        /* firmware buffer is full, stop queues */
-                        wl1251_debug(DEBUG_TX, "tx_work: fw buffer full, "
-                                     "stop queues");
-                        ieee80211_stop_queues(wl->hw);
-                        wl->tx_queue_stopped = true;
-                        skb_queue_head(&wl->tx_queue, skb);
-                        goto out;
-                } else if (ret < 0) {
-                        dev_kfree_skb(skb);
-                        goto out;
-                }
-        }
-
-out:
-        if (woken_up)
-                wl1251_ps_elp_sleep(wl);
-
-        mutex_unlock(&wl->mutex);
-}
-
-static const char *wl1251_tx_parse_status(u8 status)
-{
-        /* 8 bit status field, one character per bit plus null */
-        static char buf[9];
-        int i = 0;
-
-        memset(buf, 0, sizeof(buf));
-
-        if (status & TX_DMA_ERROR)
-                buf[i++] = 'm';
-        if (status & TX_DISABLED)
-                buf[i++] = 'd';
-        if (status & TX_RETRY_EXCEEDED)
-                buf[i++] = 'r';
-        if (status & TX_TIMEOUT)
-                buf[i++] = 't';
-        if (status & TX_KEY_NOT_FOUND)
-                buf[i++] = 'k';
-        if (status & TX_ENCRYPT_FAIL)
-                buf[i++] = 'e';
-        if (status & TX_UNAVAILABLE_PRIORITY)
-                buf[i++] = 'p';
-
-        /* bit 0 is unused apparently */
-
-        return buf;
-}
-
-static void wl1251_tx_packet_cb(struct wl1251 *wl,
-                                struct tx_result *result)
-{
-        struct ieee80211_tx_info *info;
-        struct sk_buff *skb;
-        int hdrlen, ret;
-        u8 *frame;
-
-        skb = wl->tx_frames[result->id];
-        if (skb == NULL) {
-                wl1251_error("SKB for packet %d is NULL", result->id);
-                return;
-        }
-
-        info = IEEE80211_SKB_CB(skb);
-
-        if (!(info->flags & IEEE80211_TX_CTL_NO_ACK) &&
-            (result->status == TX_SUCCESS))
-                info->flags |= IEEE80211_TX_STAT_ACK;
-
-        info->status.rates[0].count = result->ack_failures + 1;
-        wl->stats.retry_count += result->ack_failures;
-
-        /*
-         * We have to remove our private TX header before pushing
-         * the skb back to mac80211.
-         */
-        frame = skb_pull(skb, sizeof(struct tx_double_buffer_desc));
-        if (info->control.hw_key &&
-            info->control.hw_key->alg == ALG_TKIP) {
-                hdrlen = ieee80211_get_hdrlen_from_skb(skb);
-                memmove(frame + WL1251_TKIP_IV_SPACE, frame, hdrlen);
-                skb_pull(skb, WL1251_TKIP_IV_SPACE);
-        }
-
-        wl1251_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
-                     " status 0x%x (%s)",
-                     result->id, skb, result->ack_failures, result->rate,
-                     result->status, wl1251_tx_parse_status(result->status));
-
-
-        ieee80211_tx_status(wl->hw, skb);
-
-        wl->tx_frames[result->id] = NULL;
-
-        if (wl->tx_queue_stopped) {
-                wl1251_debug(DEBUG_TX, "cb: queue was stopped");
-
-                skb = skb_dequeue(&wl->tx_queue);
-
-                /* The skb can be NULL because tx_work might have been
-                   scheduled before the queue was stopped making the
-                   queue empty */
-
-                if (skb) {
-                        ret = wl1251_tx_frame(wl, skb);
-                        if (ret == -EBUSY) {
-                                /* firmware buffer is still full */
-                                wl1251_debug(DEBUG_TX, "cb: fw buffer "
-                                             "still full");
-                                skb_queue_head(&wl->tx_queue, skb);
-                                return;
-                        } else if (ret < 0) {
-                                dev_kfree_skb(skb);
-                                return;
-                        }
-                }
-
-                wl1251_debug(DEBUG_TX, "cb: waking queues");
-                ieee80211_wake_queues(wl->hw);
-                wl->tx_queue_stopped = false;
-        }
-}
-
-/* Called upon reception of a TX complete interrupt */
-void wl1251_tx_complete(struct wl1251 *wl)
-{
-        int i, result_index, num_complete = 0;
-        struct tx_result result[FW_TX_CMPLT_BLOCK_SIZE], *result_ptr;
-
-        if (unlikely(wl->state != WL1251_STATE_ON))
-                return;
-
-        /* First we read the result */
-        wl1251_mem_read(wl, wl->data_path->tx_complete_addr,
-                            result, sizeof(result));
-
-        result_index = wl->next_tx_complete;
-
-        for (i = 0; i < ARRAY_SIZE(result); i++) {
-                result_ptr = &result[result_index];
-
-                if (result_ptr->done_1 == 1 &&
-                    result_ptr->done_2 == 1) {
-                        wl1251_tx_packet_cb(wl, result_ptr);
-
-                        result_ptr->done_1 = 0;
-                        result_ptr->done_2 = 0;
-
-                        result_index = (result_index + 1) &
-                                (FW_TX_CMPLT_BLOCK_SIZE - 1);
-                        num_complete++;
-                } else {
-                        break;
-                }
-        }
-
-        /* Every completed frame needs to be acknowledged */
-        if (num_complete) {
-                /*
-                 * If we've wrapped, we have to clear
-                 * the results in 2 steps.
-                 */
-                if (result_index > wl->next_tx_complete) {
-                        /* Only 1 write is needed */
-                        wl1251_mem_write(wl,
-                                         wl->data_path->tx_complete_addr +
-                                         (wl->next_tx_complete *
-                                          sizeof(struct tx_result)),
-                                         &result[wl->next_tx_complete],
-                                         num_complete *
-                                         sizeof(struct tx_result));
-
-
-                } else if (result_index < wl->next_tx_complete) {
-                        /* 2 writes are needed */
-                        wl1251_mem_write(wl,
-                                         wl->data_path->tx_complete_addr +
-                                         (wl->next_tx_complete *
-                                          sizeof(struct tx_result)),
-                                         &result[wl->next_tx_complete],
-                                         (FW_TX_CMPLT_BLOCK_SIZE -
-                                          wl->next_tx_complete) *
-                                         sizeof(struct tx_result));
-
-                        wl1251_mem_write(wl,
-                                         wl->data_path->tx_complete_addr,
-                                         result,
-                                         (num_complete -
-                                          FW_TX_CMPLT_BLOCK_SIZE +
-                                          wl->next_tx_complete) *
-                                         sizeof(struct tx_result));
-
-                } else {
-                        /* We have to write the whole array */
-                        wl1251_mem_write(wl,
-                                         wl->data_path->tx_complete_addr,
-                                         result,
-                                         FW_TX_CMPLT_BLOCK_SIZE *
-                                         sizeof(struct tx_result));
-                }
-
-        }
-
-        wl->next_tx_complete = result_index;
-}
-
-/* caller must hold wl->mutex */
-void wl1251_tx_flush(struct wl1251 *wl)
-{
-        int i;
-        struct sk_buff *skb;
-        struct ieee80211_tx_info *info;
-
-        /* TX failure */
-/*      control->flags = 0; FIXME */
-
-        while ((skb = skb_dequeue(&wl->tx_queue))) {
-                info = IEEE80211_SKB_CB(skb);
-
-                wl1251_debug(DEBUG_TX, "flushing skb 0x%p", skb);
-
-                if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS))
-                                continue;
-
-                ieee80211_tx_status(wl->hw, skb);
-        }
-
-        for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++)
-                if (wl->tx_frames[i] != NULL) {
-                        skb = wl->tx_frames[i];
-                        info = IEEE80211_SKB_CB(skb);
-
-                        if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS))
-                                continue;
-
-                        ieee80211_tx_status(wl->hw, skb);
-                        wl->tx_frames[i] = NULL;
-                }
-}
diff --git a/drivers/net/wireless/wl12xx/wl1251_tx.h b/drivers/net/wireless/wl12xx/wl1251_tx.h
deleted file mode 100644
index f40eeb37f5aa..000000000000
--- a/drivers/net/wireless/wl12xx/wl1251_tx.h
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * This file is part of wl1251
- *
- * Copyright (c) 1998-2007 Texas Instruments Incorporated
- * Copyright (C) 2008 Nokia Corporation
- *
- * Contact: Kalle Valo <kalle.valo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1251_TX_H__
-#define __WL1251_TX_H__
-
-#include <linux/bitops.h>
-#include "wl1251_acx.h"
-
-/*
- *
- * TX PATH
- *
- * The Tx path uses a double buffer and a tx_control structure, each located
- * at a fixed address in the device's memory. On startup, the host retrieves
- * the pointers to these addresses. A double buffer allows for continuous data
- * flow towards the device. The host keeps track of which buffer is available
- * and alternates between these two buffers on a per packet basis.
- *
- * The size of each of the two buffers is large enough to hold the longest
- * 802.3 packet - maximum size Ethernet packet + header + descriptor.
- * TX complete indication will be received a-synchronously in a TX done cyclic
- * buffer which is composed of 16 tx_result descriptors structures and is used
- * in a cyclic manner.
- *
- * The TX (HOST) procedure is as follows:
- * 1. Read the Tx path status, that will give the data_out_count.
- * 2. goto 1, if not possible.
- *    i.e. if data_in_count - data_out_count >= HwBuffer size (2 for double
- *    buffer).
- * 3. Copy the packet (preceded by double_buffer_desc), if possible.
- *    i.e. if data_in_count - data_out_count < HwBuffer size (2 for double
- *    buffer).
- * 4. increment data_in_count.
- * 5. Inform the firmware by generating a firmware internal interrupt.
- * 6. FW will increment data_out_count after it reads the buffer.
- *
- * The TX Complete procedure:
- * 1. To get a TX complete indication the host enables the tx_complete flag in
- *    the TX descriptor Structure.
- * 2. For each packet with a Tx Complete field set, the firmware adds the
- *    transmit results to the cyclic buffer (txDoneRing) and sets both done_1
- *    and done_2 to 1 to indicate driver ownership.
- * 3. The firmware sends a Tx Complete interrupt to the host to trigger the
- *    host to process the new data. Note: interrupt will be send per packet if
- *    TX complete indication was requested in tx_control or per crossing
- *    aggregation threshold.
- * 4. After receiving the Tx Complete interrupt, the host reads the
- *    TxDescriptorDone information in a cyclic manner and clears both done_1
- *    and done_2 fields.
- *
- */
-
-#define TX_COMPLETE_REQUIRED_BIT        0x80
-#define TX_STATUS_DATA_OUT_COUNT_MASK   0xf
-
-#define WL1251_TX_ALIGN_TO 4
-#define WL1251_TX_ALIGN(len) (((len) + WL1251_TX_ALIGN_TO - 1) & \
-                             ~(WL1251_TX_ALIGN_TO - 1))
-#define WL1251_TKIP_IV_SPACE 4
-
-struct tx_control {
-        /* Rate Policy (class) index */
-        unsigned rate_policy:3;
-
-        /* When set, no ack policy is expected */
-        unsigned ack_policy:1;
-
-        /*
-         * Packet type:
-         * 0 -> 802.11
-         * 1 -> 802.3
-         * 2 -> IP
-         * 3 -> raw codec
-         */
-        unsigned packet_type:2;
-
-        /* If set, this is a QoS-Null or QoS-Data frame */
-        unsigned qos:1;
-
-        /*
-         * If set, the target triggers the tx complete INT
-         * upon frame sending completion.
-         */
-        unsigned tx_complete:1;
-
-        /* 2 bytes padding before packet header */
-        unsigned xfer_pad:1;
-
-        unsigned reserved:7;
-} __packed;
-
-
-struct tx_double_buffer_desc {
-        /* Length of payload, including headers. */
-        __le16 length;
-
-        /*
-         * A bit mask that specifies the initial rate to be used
-         * Possible values are:
-         * 0x0001 - 1Mbits
-         * 0x0002 - 2Mbits
-         * 0x0004 - 5.5Mbits
-         * 0x0008 - 6Mbits
-         * 0x0010 - 9Mbits
-         * 0x0020 - 11Mbits
-         * 0x0040 - 12Mbits
-         * 0x0080 - 18Mbits
-         * 0x0100 - 22Mbits
-         * 0x0200 - 24Mbits
-         * 0x0400 - 36Mbits
-         * 0x0800 - 48Mbits
-         * 0x1000 - 54Mbits
-         */
-        __le16 rate;
-
-        /* Time in us that a packet can spend in the target */
-        __le32 expiry_time;
-
-        /* index of the TX queue used for this packet */
-        u8 xmit_queue;
-
-        /* Used to identify a packet */
-        u8 id;
-
-        struct tx_control control;
-
-        /*
-         * The FW should cut the packet into fragments
-         * of this size.
-         */
-        __le16 frag_threshold;
-
-        /* Numbers of HW queue blocks to be allocated */
-        u8 num_mem_blocks;
-
-        u8 reserved;
-} __packed;
-
-enum {
-        TX_SUCCESS              = 0,
-        TX_DMA_ERROR            = BIT(7),
-        TX_DISABLED             = BIT(6),
-        TX_RETRY_EXCEEDED       = BIT(5),
-        TX_TIMEOUT              = BIT(4),
-        TX_KEY_NOT_FOUND        = BIT(3),
-        TX_ENCRYPT_FAIL         = BIT(2),
-        TX_UNAVAILABLE_PRIORITY = BIT(1),
-};
-
-struct tx_result {
-        /*
-         * Ownership synchronization between the host and
-         * the firmware. If done_1 and done_2 are cleared,
-         * owned by the FW (no info ready).
-         */
-        u8 done_1;
-
-        /* same as double_buffer_desc->id */
-        u8 id;
-
-        /*
-         * Total air access duration consumed by this
-         * packet, including all retries and overheads.
-         */
-        u16 medium_usage;
-
-        /* Total media delay (from 1st EDCA AIFS counter until TX Complete). */
-        u32 medium_delay;
-
-        /* Time between host xfer and tx complete */
-        u32 fw_hnadling_time;
-
-        /* The LS-byte of the last TKIP sequence number. */
-        u8 lsb_seq_num;
-
-        /* Retry count */
-        u8 ack_failures;
-
-        /* At which rate we got a ACK */
-        u16 rate;
-
-        u16 reserved;
-
-        /* TX_* */
-        u8 status;
-
-        /* See done_1 */
-        u8 done_2;
-} __packed;
-
-static inline int wl1251_tx_get_queue(int queue)
-{
-        switch (queue) {
-        case 0:
-                return QOS_AC_VO;
-        case 1:
-                return QOS_AC_VI;
-        case 2:
-                return QOS_AC_BE;
-        case 3:
-                return QOS_AC_BK;
-        default:
-                return QOS_AC_BE;
-        }
-}
-
-void wl1251_tx_work(struct work_struct *work);
-void wl1251_tx_complete(struct wl1251 *wl);
-void wl1251_tx_flush(struct wl1251 *wl);
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1271.h b/drivers/net/wireless/wl12xx/wl1271.h
deleted file mode 100644
index dd3cee6ea5bb..000000000000
--- a/drivers/net/wireless/wl12xx/wl1271.h
+++ /dev/null
@@ -1,510 +0,0 @@
-/*
- * This file is part of wl1271
- *
- * Copyright (C) 1998-2009 Texas Instruments. All rights reserved.
- * Copyright (C) 2008-2009 Nokia Corporation
- *
- * Contact: Luciano Coelho <luciano.coelho@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#ifndef __WL1271_H__
-#define __WL1271_H__
-
-#include <linux/mutex.h>
-#include <linux/completion.h>
-#include <linux/spinlock.h>
-#include <linux/list.h>
-#include <linux/bitops.h>
-#include <net/mac80211.h>
-
-#include "wl1271_conf.h"
-#include "wl1271_ini.h"
-
-#define DRIVER_NAME "wl1271"
-#define DRIVER_PREFIX DRIVER_NAME ": "
-
-enum {
-        DEBUG_NONE      = 0,
-        DEBUG_IRQ       = BIT(0),
-        DEBUG_SPI       = BIT(1),
-        DEBUG_BOOT      = BIT(2),
-        DEBUG_MAILBOX   = BIT(3),
-        DEBUG_TESTMODE  = BIT(4),
-        DEBUG_EVENT     = BIT(5),
-        DEBUG_TX        = BIT(6),
-        DEBUG_RX        = BIT(7),
-        DEBUG_SCAN      = BIT(8),
-        DEBUG_CRYPT     = BIT(9),
-        DEBUG_PSM       = BIT(10),
-        DEBUG_MAC80211  = BIT(11),
-        DEBUG_CMD       = BIT(12),
-        DEBUG_ACX       = BIT(13),
-        DEBUG_SDIO      = BIT(14),
-        DEBUG_FILTERS   = BIT(15),
-        DEBUG_ADHOC     = BIT(16),
-        DEBUG_ALL       = ~0,
-};
-
-#define DEBUG_LEVEL (DEBUG_NONE)
-
-#define DEBUG_DUMP_LIMIT 1024
-
-#define wl1271_error(fmt, arg...) \
-        printk(KERN_ERR DRIVER_PREFIX "ERROR " fmt "\n", ##arg)
-
-#define wl1271_warning(fmt, arg...) \
-        printk(KERN_WARNING DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
-
-#define wl1271_notice(fmt, arg...) \
-        printk(KERN_INFO DRIVER_PREFIX fmt "\n", ##arg)
-
-#define wl1271_info(fmt, arg...) \
-        printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg)
-
-#define wl1271_debug(level, fmt, arg...) \
-        do { \
-                if (level & DEBUG_LEVEL) \
-                        printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg); \
-        } while (0)
-
-#define wl1271_dump(level, prefix, buf, len)    \
-        do { \
-                if (level & DEBUG_LEVEL) \
-                        print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
-                                       DUMP_PREFIX_OFFSET, 16, 1,       \
-                                       buf,                             \
-                                       min_t(size_t, len, DEBUG_DUMP_LIMIT), \
-                                       0);                              \
-        } while (0)
-
-#define wl1271_dump_ascii(level, prefix, buf, len)      \
-        do { \
-                if (level & DEBUG_LEVEL) \
-                        print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
-                                       DUMP_PREFIX_OFFSET, 16, 1,       \
-                                       buf,                             \
-                                       min_t(size_t, len, DEBUG_DUMP_LIMIT), \
-                                       true);                           \
-        } while (0)
-
-#define WL1271_DEFAULT_RX_CONFIG (CFG_UNI_FILTER_EN |   \
-                                  CFG_BSSID_FILTER_EN | \
-                                  CFG_MC_FILTER_EN)
-
-#define WL1271_DEFAULT_RX_FILTER (CFG_RX_RCTS_ACK | CFG_RX_PRSP_EN |  \
-                                  CFG_RX_MGMT_EN | CFG_RX_DATA_EN |   \
-                                  CFG_RX_CTL_EN | CFG_RX_BCN_EN |     \
-                                  CFG_RX_AUTH_EN | CFG_RX_ASSOC_EN)
-
-#define WL1271_FW_NAME "wl1271-fw.bin"
-#define WL1271_NVS_NAME "wl1271-nvs.bin"
-
-#define WL1271_TX_SECURITY_LO16(s) ((u16)((s) & 0xffff))
-#define WL1271_TX_SECURITY_HI32(s) ((u32)(((s) >> 16) & 0xffffffff))
-
-/*
- * Enable/disable 802.11a support for WL1273
- */
-#undef WL1271_80211A_ENABLED
-
-#define WL1271_BUSY_WORD_CNT 1
-#define WL1271_BUSY_WORD_LEN (WL1271_BUSY_WORD_CNT * sizeof(u32))
-
-#define WL1271_ELP_HW_STATE_ASLEEP 0
-#define WL1271_ELP_HW_STATE_IRQ    1
-
-#define WL1271_DEFAULT_BEACON_INT  100
-#define WL1271_DEFAULT_DTIM_PERIOD 1
-
-#define ACX_TX_DESCRIPTORS         32
-
-enum wl1271_state {
-        WL1271_STATE_OFF,
-        WL1271_STATE_ON,
-        WL1271_STATE_PLT,
-};
-
-enum wl1271_partition_type {
-        PART_DOWN,
-        PART_WORK,
-        PART_DRPW,
-
-        PART_TABLE_LEN
-};
-
-struct wl1271_partition {
-        u32 size;
-        u32 start;
-};
-
-struct wl1271_partition_set {
-        struct wl1271_partition mem;
-        struct wl1271_partition reg;
-        struct wl1271_partition mem2;
-        struct wl1271_partition mem3;
-};
-
-struct wl1271;
-
-/* FIXME: I'm not sure about this structure name */
-struct wl1271_chip {
-        u32 id;
-        char fw_ver[21];
-};
-
-struct wl1271_stats {
-        struct acx_statistics *fw_stats;
-        unsigned long fw_stats_update;
-
-        unsigned int retry_count;
-        unsigned int excessive_retries;
-};
-
-struct wl1271_debugfs {
-        struct dentry *rootdir;
-        struct dentry *fw_statistics;
-
-        struct dentry *tx_internal_desc_overflow;
-
-        struct dentry *rx_out_of_mem;
-        struct dentry *rx_hdr_overflow;
-        struct dentry *rx_hw_stuck;
-        struct dentry *rx_dropped;
-        struct dentry *rx_fcs_err;
-        struct dentry *rx_xfr_hint_trig;
-        struct dentry *rx_path_reset;
-        struct dentry *rx_reset_counter;
-
-        struct dentry *dma_rx_requested;
-        struct dentry *dma_rx_errors;
-        struct dentry *dma_tx_requested;
-        struct dentry *dma_tx_errors;
-
-        struct dentry *isr_cmd_cmplt;
-        struct dentry *isr_fiqs;
-        struct dentry *isr_rx_headers;
-        struct dentry *isr_rx_mem_overflow;
-        struct dentry *isr_rx_rdys;
-        struct dentry *isr_irqs;
-        struct dentry *isr_tx_procs;
-        struct dentry *isr_decrypt_done;
-        struct dentry *isr_dma0_done;
-        struct dentry *isr_dma1_done;
-        struct dentry *isr_tx_exch_complete;
-        struct dentry *isr_commands;
-        struct dentry *isr_rx_procs;
-        struct dentry *isr_hw_pm_mode_changes;
-        struct dentry *isr_host_acknowledges;
-        struct dentry *isr_pci_pm;
-        struct dentry *isr_wakeups;
-        struct dentry *isr_low_rssi;
-
-        struct dentry *wep_addr_key_count;
-        struct dentry *wep_default_key_count;
-        /* skipping wep.reserved */
-        struct dentry *wep_key_not_found;
-        struct dentry *wep_decrypt_fail;
-        struct dentry *wep_packets;
-        struct dentry *wep_interrupt;
-
-        struct dentry *pwr_ps_enter;
-        struct dentry *pwr_elp_enter;
-        struct dentry *pwr_missing_bcns;
-        struct dentry *pwr_wake_on_host;
-        struct dentry *pwr_wake_on_timer_exp;
-        struct dentry *pwr_tx_with_ps;
-        struct dentry *pwr_tx_without_ps;
-        struct dentry *pwr_rcvd_beacons;
-        struct dentry *pwr_power_save_off;
-        struct dentry *pwr_enable_ps;
-        struct dentry *pwr_disable_ps;
-        struct dentry *pwr_fix_tsf_ps;
-        /* skipping cont_miss_bcns_spread for now */
-        struct dentry *pwr_rcvd_awake_beacons;
-
-        struct dentry *mic_rx_pkts;
-        struct dentry *mic_calc_failure;
-
-        struct dentry *aes_encrypt_fail;
-        struct dentry *aes_decrypt_fail;
-        struct dentry *aes_encrypt_packets;
-        struct dentry *aes_decrypt_packets;
-        struct dentry *aes_encrypt_interrupt;
-        struct dentry *aes_decrypt_interrupt;
-
-        struct dentry *event_heart_beat;
-        struct dentry *event_calibration;
-        struct dentry *event_rx_mismatch;
-        struct dentry *event_rx_mem_empty;
-        struct dentry *event_rx_pool;
-        struct dentry *event_oom_late;
-        struct dentry *event_phy_transmit_error;
-        struct dentry *event_tx_stuck;
-
-        struct dentry *ps_pspoll_timeouts;
-        struct dentry *ps_upsd_timeouts;
-        struct dentry *ps_upsd_max_sptime;
-        struct dentry *ps_upsd_max_apturn;
-        struct dentry *ps_pspoll_max_apturn;
-        struct dentry *ps_pspoll_utilization;
-        struct dentry *ps_upsd_utilization;
-
-        struct dentry *rxpipe_rx_prep_beacon_drop;
-        struct dentry *rxpipe_descr_host_int_trig_rx_data;
-        struct dentry *rxpipe_beacon_buffer_thres_host_int_trig_rx_data;
-        struct dentry *rxpipe_missed_beacon_host_int_trig_rx_data;
-        struct dentry *rxpipe_tx_xfr_host_int_trig_rx_data;
-
-        struct dentry *tx_queue_len;
-
-        struct dentry *retry_count;
-        struct dentry *excessive_retries;
-        struct dentry *gpio_power;
-};
-
-#define NUM_TX_QUEUES              4
-#define NUM_RX_PKT_DESC            8
-
-/* FW status registers */
-struct wl1271_fw_status {
-        __le32 intr;
-        u8  fw_rx_counter;
-        u8  drv_rx_counter;
-        u8  reserved;
-        u8  tx_results_counter;
-        __le32 rx_pkt_descs[NUM_RX_PKT_DESC];
-        __le32 tx_released_blks[NUM_TX_QUEUES];
-        __le32 fw_localtime;
-        __le32 padding[2];
-} __packed;
-
-struct wl1271_rx_mem_pool_addr {
-        u32 addr;
-        u32 addr_extra;
-};
-
-struct wl1271_scan {
-        struct cfg80211_scan_request *req;
-        bool *scanned_ch;
-        u8 state;
-        u8 ssid[IW_ESSID_MAX_SIZE+1];
-        size_t ssid_len;
-};
-
-struct wl1271_if_operations {
-        void (*read)(struct wl1271 *wl, int addr, void *buf, size_t len,
-                     bool fixed);
-        void (*write)(struct wl1271 *wl, int addr, void *buf, size_t len,
-                     bool fixed);
-        void (*reset)(struct wl1271 *wl);
-        void (*init)(struct wl1271 *wl);
-        void (*power)(struct wl1271 *wl, bool enable);
-        struct device* (*dev)(struct wl1271 *wl);
-        void (*enable_irq)(struct wl1271 *wl);
-        void (*disable_irq)(struct wl1271 *wl);
-};
-
-struct wl1271 {
-        struct platform_device *plat_dev;
-        struct ieee80211_hw *hw;
-        bool mac80211_registered;
-
-        void *if_priv;
-
-        struct wl1271_if_operations *if_ops;
-
-        void (*set_power)(bool enable);
-        int irq;
-
-        spinlock_t wl_lock;
-
-        enum wl1271_state state;
-        struct mutex mutex;
-
-#define WL1271_FLAG_STA_RATES_CHANGED  (0)
-#define WL1271_FLAG_STA_ASSOCIATED     (1)
-#define WL1271_FLAG_JOINED             (2)
-#define WL1271_FLAG_GPIO_POWER         (3)
-#define WL1271_FLAG_TX_QUEUE_STOPPED   (4)
-#define WL1271_FLAG_IN_ELP             (5)
-#define WL1271_FLAG_PSM                (6)
-#define WL1271_FLAG_PSM_REQUESTED      (7)
-#define WL1271_FLAG_IRQ_PENDING        (8)
-#define WL1271_FLAG_IRQ_RUNNING        (9)
-#define WL1271_FLAG_IDLE              (10)
-#define WL1271_FLAG_IDLE_REQUESTED    (11)
-#define WL1271_FLAG_PSPOLL_FAILURE    (12)
-        unsigned long flags;
-
-        struct wl1271_partition_set part;
-
-        struct wl1271_chip chip;
-
-        int cmd_box_addr;
-        int event_box_addr;
-
-        u8 *fw;
-        size_t fw_len;
-        struct wl1271_nvs_file *nvs;
-
-        s8 hw_pg_ver;
-
-        u8 bssid[ETH_ALEN];
-        u8 mac_addr[ETH_ALEN];
-        u8 bss_type;
-        u8 set_bss_type;
-        u8 ssid[IW_ESSID_MAX_SIZE + 1];
-        u8 ssid_len;
-        int channel;
-
-        struct wl1271_acx_mem_map *target_mem_map;
-
-        /* Accounting for allocated / available TX blocks on HW */
-        u32 tx_blocks_freed[NUM_TX_QUEUES];
-        u32 tx_blocks_available;
-        u32 tx_results_count;
-
-        /* Transmitted TX packets counter for chipset interface */
-        u32 tx_packets_count;
-
-        /* Time-offset between host and chipset clocks */
-        s64 time_offset;
-
-        /* Session counter for the chipset */
-        int session_counter;
-
-        /* Frames scheduled for transmission, not handled yet */
-        struct sk_buff_head tx_queue;
-
-        struct work_struct tx_work;
-
-        /* Pending TX frames */
-        struct sk_buff *tx_frames[ACX_TX_DESCRIPTORS];
-        int tx_frames_cnt;
-
-        /* Security sequence number counters */
-        u8 tx_security_last_seq;
-        s64 tx_security_seq;
-
-        /* FW Rx counter */
-        u32 rx_counter;
-
-        /* Rx memory pool address */
-        struct wl1271_rx_mem_pool_addr rx_mem_pool_addr;
-
-        /* The target interrupt mask */
-        struct work_struct irq_work;
-
-        /* The mbox event mask */
-        u32 event_mask;
-
-        /* Mailbox pointers */
-        u32 mbox_ptr[2];
-
-        /* Are we currently scanning */
-        struct wl1271_scan scan;
-
-        /* Our association ID */
-        u16 aid;
-
-        /* currently configured rate set */
-        u32 sta_rate_set;
-        u32 basic_rate_set;
-        u32 basic_rate;
-        u32 rate_set;
-
-        /* The current band */
-        enum ieee80211_band band;
-
-        /* Beaconing interval (needed for ad-hoc) */
-        u32 beacon_int;
-
-        /* Default key (for WEP) */
-        u32 default_key;
-
-        unsigned int filters;
-        unsigned int rx_config;
-        unsigned int rx_filter;
-
-        struct completion *elp_compl;
-        struct delayed_work elp_work;
-        struct delayed_work pspoll_work;
-
-        /* counter for ps-poll delivery failures */
-        int ps_poll_failures;
-
-        /* retry counter for PSM entries */
-        u8 psm_entry_retry;
-
-        /* in dBm */
-        int power_level;
-
-        int rssi_thold;
-        int last_rssi_event;
-
-        struct wl1271_stats stats;
-        struct wl1271_debugfs debugfs;
-
-        __le32 buffer_32;
-        u32 buffer_cmd;
-        u32 buffer_busyword[WL1271_BUSY_WORD_CNT];
-
-        struct wl1271_fw_status *fw_status;
-        struct wl1271_tx_hw_res_if *tx_res_if;
-
-        struct ieee80211_vif *vif;
-
-        /* Current chipset configuration */
-        struct conf_drv_settings conf;
-
-        bool sg_enabled;
-
-        struct list_head list;
-
-        /* Most recently reported noise in dBm */
-        s8 noise;
-};
-
-int wl1271_plt_start(struct wl1271 *wl);
-int wl1271_plt_stop(struct wl1271 *wl);
-
-#define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */
-
-#define SESSION_COUNTER_MAX 7 /* maximum value for the session counter */
-
-#define WL1271_DEFAULT_POWER_LEVEL 0
-
-#define WL1271_TX_QUEUE_LOW_WATERMARK  10
-#define WL1271_TX_QUEUE_HIGH_WATERMARK 25
-
-/* WL1271 needs a 200ms sleep after power on, and a 20ms sleep before power
-   on in case is has been shut down shortly before */
-#define WL1271_PRE_POWER_ON_SLEEP 20 /* in miliseconds */
-#define WL1271_POWER_ON_SLEEP 200 /* in miliseconds */
-
-static inline bool wl1271_11a_enabled(void)
-{
-        /* FIXME: this could be determined based on the NVS-INI file */
-#ifdef WL1271_80211A_ENABLED
-        return true;
-#else
-        return false;
-#endif
-}
-
-#endif
diff --git a/drivers/net/wireless/wl12xx/wl1271_debugfs.c b/drivers/net/wireless/wl12xx/wl1271_debugfs.c
deleted file mode 100644
index c239ef4d0b8d..000000000000
--- a/drivers/net/wireless/wl12xx/wl1271_debugfs.c
+++ /dev/null
@@ -1,579 +0,0 @@
-/*
- * This file is part of wl1271
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Luciano Coelho <luciano.coelho@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include "wl1271_debugfs.h"
-
-#include <linux/skbuff.h>
-#include <linux/slab.h>
-
-#include "wl1271.h"
-#include "wl1271_acx.h"
-#include "wl1271_ps.h"
-#include "wl1271_io.h"
-
-/* ms */
-#define WL1271_DEBUGFS_STATS_LIFETIME 1000
-
-/* debugfs macros idea from mac80211 */
-
-#define DEBUGFS_READONLY_FILE(name, buflen, fmt, value...)              \
-static ssize_t name## _read(struct file *file, char __user *userbuf,    \
-                            size_t count, loff_t *ppos)                 \
-{                                                                       \
-        struct wl1271 *wl = file->private_data;                         \
-        char buf[buflen];                                               \
-        int res;                                                        \
-                                                                        \
-        res = scnprintf(buf, buflen, fmt "\n", ##value);                \
-        return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
-}                                                                       \
-                                                                        \
-static const struct file_operations name## _ops = {                     \
-        .read = name## _read,                                           \
-        .open = wl1271_open_file_generic,                               \
-};
-
-#define DEBUGFS_ADD(name, parent)                                       \
-        wl->debugfs.name = debugfs_create_file(#name, 0400, parent,     \
-                                               wl, &name## _ops);       \
-        if (IS_ERR(wl->debugfs.name)) {                                 \
-                ret = PTR_ERR(wl->debugfs.name);                        \
-                wl->debugfs.name = NULL;                                \
-                goto out;                                               \
-        }
-
-#define DEBUGFS_DEL(name)                                               \
-        do {                                                            \
-                debugfs_remove(wl->debugfs.name);                       \
-                wl->debugfs.name = NULL;                                \
-        } while (0)
-
-#define DEBUGFS_FWSTATS_FILE(sub, name, buflen, fmt)                    \
-static ssize_t sub## _ ##name## _read(struct file *file,                \
-                                      char __user *userbuf,             \
-                                      size_t count, loff_t *ppos)       \
-{                                                                       \
-        struct wl1271 *wl = file->private_data;                         \
-        char buf[buflen];                                               \
-        int res;                                                        \
-                                                                        \
-        wl1271_debugfs_update_stats(wl);                                \
-                                                                        \
-        res = scnprintf(buf, buflen, fmt "\n",                          \
-                        wl->stats.fw_stats->sub.name);                  \
-        return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
-}                                                                       \
-                                                                        \
-static const struct file_operations sub## _ ##name## _ops = {           \
-        .read = sub## _ ##name## _read,                                 \
-        .open = wl1271_open_file_generic,                               \
-};
-
-#define DEBUGFS_FWSTATS_ADD(sub, name)                          \
-        DEBUGFS_ADD(sub## _ ##name, wl->debugfs.fw_statistics)
-
-#define DEBUGFS_FWSTATS_DEL(sub, name)                          \
-        DEBUGFS_DEL(sub## _ ##name)
-
-static void wl1271_debugfs_update_stats(struct wl1271 *wl)
-{
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        if (wl->state == WL1271_STATE_ON &&
-            time_after(jiffies, wl->stats.fw_stats_update +
-                       msecs_to_jiffies(WL1271_DEBUGFS_STATS_LIFETIME))) {
-                wl1271_acx_statistics(wl, wl->stats.fw_stats);
-                wl->stats.fw_stats_update = jiffies;
-        }
-
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1271_open_file_generic(struct inode *inode, struct file *file)
-{
-        file->private_data = inode->i_private;
-        return 0;
-}
-
-DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(rx, out_of_mem, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, hw_stuck, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, dropped, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, fcs_err, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, path_reset, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rx, reset_counter, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(dma, rx_requested, 20, "%u");
-DEBUGFS_FWSTATS_FILE(dma, rx_errors, 20, "%u");
-DEBUGFS_FWSTATS_FILE(dma, tx_requested, 20, "%u");
-DEBUGFS_FWSTATS_FILE(dma, tx_errors, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, fiqs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_headers, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_rdys, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, irqs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, tx_procs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, decrypt_done, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, dma0_done, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, dma1_done, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, commands, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, rx_procs, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, pci_pm, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, wakeups, 20, "%u");
-DEBUGFS_FWSTATS_FILE(isr, low_rssi, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(wep, addr_key_count, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, default_key_count, 20, "%u");
-/* skipping wep.reserved */
-DEBUGFS_FWSTATS_FILE(wep, key_not_found, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, packets, 20, "%u");
-DEBUGFS_FWSTATS_FILE(wep, interrupt, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(pwr, ps_enter, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, elp_enter, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, power_save_off, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, enable_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, disable_ps, 20, "%u");
-DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, 20, "%u");
-/* skipping cont_miss_bcns_spread for now */
-DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(mic, rx_pkts, 20, "%u");
-DEBUGFS_FWSTATS_FILE(mic, calc_failure, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, 20, "%u");
-DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(event, heart_beat, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, calibration, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, rx_mismatch, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, rx_pool, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, oom_late, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, 20, "%u");
-DEBUGFS_FWSTATS_FILE(event, tx_stuck, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, 20, "%u");
-DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, 20, "%u");
-
-DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data,
-                     20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, 20, "%u");
-DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, 20, "%u");
-
-DEBUGFS_READONLY_FILE(retry_count, 20, "%u", wl->stats.retry_count);
-DEBUGFS_READONLY_FILE(excessive_retries, 20, "%u",
-                      wl->stats.excessive_retries);
-
-static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
-                                 size_t count, loff_t *ppos)
-{
-        struct wl1271 *wl = file->private_data;
-        u32 queue_len;
-        char buf[20];
-        int res;
-
-        queue_len = skb_queue_len(&wl->tx_queue);
-
-        res = scnprintf(buf, sizeof(buf), "%u\n", queue_len);
-        return simple_read_from_buffer(userbuf, count, ppos, buf, res);
-}
-
-static const struct file_operations tx_queue_len_ops = {
-        .read = tx_queue_len_read,
-        .open = wl1271_open_file_generic,
-};
-
-static ssize_t gpio_power_read(struct file *file, char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-        struct wl1271 *wl = file->private_data;
-        bool state = test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
-
-        int res;
-        char buf[10];
-
-        res = scnprintf(buf, sizeof(buf), "%d\n", state);
-
-        return simple_read_from_buffer(user_buf, count, ppos, buf, res);
-}
-
-static ssize_t gpio_power_write(struct file *file,
-                           const char __user *user_buf,
-                           size_t count, loff_t *ppos)
-{
-        struct wl1271 *wl = file->private_data;
-        char buf[10];
-        size_t len;
-        unsigned long value;
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        len = min(count, sizeof(buf) - 1);
-        if (copy_from_user(buf, user_buf, len)) {
-                ret = -EFAULT;
-                goto out;
-        }
-        buf[len] = '\0';
-
-        ret = strict_strtoul(buf, 0, &value);
-        if (ret < 0) {
-                wl1271_warning("illegal value in gpio_power");
-                goto out;
-        }
-
-        if (value)
-                wl1271_power_on(wl);
-        else
-                wl1271_power_off(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-        return count;
-}
-
-static const struct file_operations gpio_power_ops = {
-        .read = gpio_power_read,
-        .write = gpio_power_write,
-        .open = wl1271_open_file_generic
-};
-
-static void wl1271_debugfs_delete_files(struct wl1271 *wl)
-{
-        DEBUGFS_FWSTATS_DEL(tx, internal_desc_overflow);
-
-        DEBUGFS_FWSTATS_DEL(rx, out_of_mem);
-        DEBUGFS_FWSTATS_DEL(rx, hdr_overflow);
-        DEBUGFS_FWSTATS_DEL(rx, hw_stuck);
-        DEBUGFS_FWSTATS_DEL(rx, dropped);
-        DEBUGFS_FWSTATS_DEL(rx, fcs_err);
-        DEBUGFS_FWSTATS_DEL(rx, xfr_hint_trig);
-        DEBUGFS_FWSTATS_DEL(rx, path_reset);
-        DEBUGFS_FWSTATS_DEL(rx, reset_counter);
-
-        DEBUGFS_FWSTATS_DEL(dma, rx_requested);
-        DEBUGFS_FWSTATS_DEL(dma, rx_errors);
-        DEBUGFS_FWSTATS_DEL(dma, tx_requested);
-        DEBUGFS_FWSTATS_DEL(dma, tx_errors);
-
-        DEBUGFS_FWSTATS_DEL(isr, cmd_cmplt);
-        DEBUGFS_FWSTATS_DEL(isr, fiqs);
-        DEBUGFS_FWSTATS_DEL(isr, rx_headers);
-        DEBUGFS_FWSTATS_DEL(isr, rx_mem_overflow);
-        DEBUGFS_FWSTATS_DEL(isr, rx_rdys);
-        DEBUGFS_FWSTATS_DEL(isr, irqs);
-        DEBUGFS_FWSTATS_DEL(isr, tx_procs);
-        DEBUGFS_FWSTATS_DEL(isr, decrypt_done);
-        DEBUGFS_FWSTATS_DEL(isr, dma0_done);
-        DEBUGFS_FWSTATS_DEL(isr, dma1_done);
-        DEBUGFS_FWSTATS_DEL(isr, tx_exch_complete);
-        DEBUGFS_FWSTATS_DEL(isr, commands);
-        DEBUGFS_FWSTATS_DEL(isr, rx_procs);
-        DEBUGFS_FWSTATS_DEL(isr, hw_pm_mode_changes);
-        DEBUGFS_FWSTATS_DEL(isr, host_acknowledges);
-        DEBUGFS_FWSTATS_DEL(isr, pci_pm);
-        DEBUGFS_FWSTATS_DEL(isr, wakeups);
-        DEBUGFS_FWSTATS_DEL(isr, low_rssi);
-
-        DEBUGFS_FWSTATS_DEL(wep, addr_key_count);
-        DEBUGFS_FWSTATS_DEL(wep, default_key_count);
-        /* skipping wep.reserved */
-        DEBUGFS_FWSTATS_DEL(wep, key_not_found);
-        DEBUGFS_FWSTATS_DEL(wep, decrypt_fail);
-        DEBUGFS_FWSTATS_DEL(wep, packets);
-        DEBUGFS_FWSTATS_DEL(wep, interrupt);
-
-        DEBUGFS_FWSTATS_DEL(pwr, ps_enter);
-        DEBUGFS_FWSTATS_DEL(pwr, elp_enter);
-        DEBUGFS_FWSTATS_DEL(pwr, missing_bcns);
-        DEBUGFS_FWSTATS_DEL(pwr, wake_on_host);
-        DEBUGFS_FWSTATS_DEL(pwr, wake_on_timer_exp);
-        DEBUGFS_FWSTATS_DEL(pwr, tx_with_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, tx_without_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, rcvd_beacons);
-        DEBUGFS_FWSTATS_DEL(pwr, power_save_off);
-        DEBUGFS_FWSTATS_DEL(pwr, enable_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, disable_ps);
-        DEBUGFS_FWSTATS_DEL(pwr, fix_tsf_ps);
-        /* skipping cont_miss_bcns_spread for now */
-        DEBUGFS_FWSTATS_DEL(pwr, rcvd_awake_beacons);
-
-        DEBUGFS_FWSTATS_DEL(mic, rx_pkts);
-        DEBUGFS_FWSTATS_DEL(mic, calc_failure);
-
-        DEBUGFS_FWSTATS_DEL(aes, encrypt_fail);
-        DEBUGFS_FWSTATS_DEL(aes, decrypt_fail);
-        DEBUGFS_FWSTATS_DEL(aes, encrypt_packets);
-        DEBUGFS_FWSTATS_DEL(aes, decrypt_packets);
-        DEBUGFS_FWSTATS_DEL(aes, encrypt_interrupt);
-        DEBUGFS_FWSTATS_DEL(aes, decrypt_interrupt);
-
-        DEBUGFS_FWSTATS_DEL(event, heart_beat);
-        DEBUGFS_FWSTATS_DEL(event, calibration);
-        DEBUGFS_FWSTATS_DEL(event, rx_mismatch);
-        DEBUGFS_FWSTATS_DEL(event, rx_mem_empty);
-        DEBUGFS_FWSTATS_DEL(event, rx_pool);
-        DEBUGFS_FWSTATS_DEL(event, oom_late);
-        DEBUGFS_FWSTATS_DEL(event, phy_transmit_error);
-        DEBUGFS_FWSTATS_DEL(event, tx_stuck);
-
-        DEBUGFS_FWSTATS_DEL(ps, pspoll_timeouts);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_timeouts);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_max_sptime);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_max_apturn);
-        DEBUGFS_FWSTATS_DEL(ps, pspoll_max_apturn);
-        DEBUGFS_FWSTATS_DEL(ps, pspoll_utilization);
-        DEBUGFS_FWSTATS_DEL(ps, upsd_utilization);
-
-        DEBUGFS_FWSTATS_DEL(rxpipe, rx_prep_beacon_drop);
-        DEBUGFS_FWSTATS_DEL(rxpipe, descr_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_DEL(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_DEL(rxpipe, missed_beacon_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_DEL(rxpipe, tx_xfr_host_int_trig_rx_data);
-
-        DEBUGFS_DEL(tx_queue_len);
-        DEBUGFS_DEL(retry_count);
-        DEBUGFS_DEL(excessive_retries);
-
-        DEBUGFS_DEL(gpio_power);
-}
-
-static int wl1271_debugfs_add_files(struct wl1271 *wl)
-{
-        int ret = 0;
-
-        DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow);
-
-        DEBUGFS_FWSTATS_ADD(rx, out_of_mem);
-        DEBUGFS_FWSTATS_ADD(rx, hdr_overflow);
-        DEBUGFS_FWSTATS_ADD(rx, hw_stuck);
-        DEBUGFS_FWSTATS_ADD(rx, dropped);
-        DEBUGFS_FWSTATS_ADD(rx, fcs_err);
-        DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig);
-        DEBUGFS_FWSTATS_ADD(rx, path_reset);
-        DEBUGFS_FWSTATS_ADD(rx, reset_counter);
-
-        DEBUGFS_FWSTATS_ADD(dma, rx_requested);
-        DEBUGFS_FWSTATS_ADD(dma, rx_errors);
-        DEBUGFS_FWSTATS_ADD(dma, tx_requested);
-        DEBUGFS_FWSTATS_ADD(dma, tx_errors);
-
-        DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt);
-        DEBUGFS_FWSTATS_ADD(isr, fiqs);
-        DEBUGFS_FWSTATS_ADD(isr, rx_headers);
-        DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow);
-        DEBUGFS_FWSTATS_ADD(isr, rx_rdys);
-        DEBUGFS_FWSTATS_ADD(isr, irqs);
-        DEBUGFS_FWSTATS_ADD(isr, tx_procs);
-        DEBUGFS_FWSTATS_ADD(isr, decrypt_done);
-        DEBUGFS_FWSTATS_ADD(isr, dma0_done);
-        DEBUGFS_FWSTATS_ADD(isr, dma1_done);
-        DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete);
-        DEBUGFS_FWSTATS_ADD(isr, commands);
-        DEBUGFS_FWSTATS_ADD(isr, rx_procs);
-        DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes);
-        DEBUGFS_FWSTATS_ADD(isr, host_acknowledges);
-        DEBUGFS_FWSTATS_ADD(isr, pci_pm);
-        DEBUGFS_FWSTATS_ADD(isr, wakeups);
-        DEBUGFS_FWSTATS_ADD(isr, low_rssi);
-
-        DEBUGFS_FWSTATS_ADD(wep, addr_key_count);
-        DEBUGFS_FWSTATS_ADD(wep, default_key_count);
-        /* skipping wep.reserved */
-        DEBUGFS_FWSTATS_ADD(wep, key_not_found);
-        DEBUGFS_FWSTATS_ADD(wep, decrypt_fail);
-        DEBUGFS_FWSTATS_ADD(wep, packets);
-        DEBUGFS_FWSTATS_ADD(wep, interrupt);
-
-        DEBUGFS_FWSTATS_ADD(pwr, ps_enter);
-        DEBUGFS_FWSTATS_ADD(pwr, elp_enter);
-        DEBUGFS_FWSTATS_ADD(pwr, missing_bcns);
-        DEBUGFS_FWSTATS_ADD(pwr, wake_on_host);
-        DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp);
-        DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons);
-        DEBUGFS_FWSTATS_ADD(pwr, power_save_off);
-        DEBUGFS_FWSTATS_ADD(pwr, enable_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, disable_ps);
-        DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps);
-        /* skipping cont_miss_bcns_spread for now */
-        DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons);
-
-        DEBUGFS_FWSTATS_ADD(mic, rx_pkts);
-        DEBUGFS_FWSTATS_ADD(mic, calc_failure);
-
-        DEBUGFS_FWSTATS_ADD(aes, encrypt_fail);
-        DEBUGFS_FWSTATS_ADD(aes, decrypt_fail);
-        DEBUGFS_FWSTATS_ADD(aes, encrypt_packets);
-        DEBUGFS_FWSTATS_ADD(aes, decrypt_packets);
-        DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt);
-        DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt);
-
-        DEBUGFS_FWSTATS_ADD(event, heart_beat);
-        DEBUGFS_FWSTATS_ADD(event, calibration);
-        DEBUGFS_FWSTATS_ADD(event, rx_mismatch);
-        DEBUGFS_FWSTATS_ADD(event, rx_mem_empty);
-        DEBUGFS_FWSTATS_ADD(event, rx_pool);
-        DEBUGFS_FWSTATS_ADD(event, oom_late);
-        DEBUGFS_FWSTATS_ADD(event, phy_transmit_error);
-        DEBUGFS_FWSTATS_ADD(event, tx_stuck);
-
-        DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn);
-        DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn);
-        DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization);
-        DEBUGFS_FWSTATS_ADD(ps, upsd_utilization);
-
-        DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop);
-        DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data);
-        DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data);
-
-        DEBUGFS_ADD(tx_queue_len, wl->debugfs.rootdir);
-        DEBUGFS_ADD(retry_count, wl->debugfs.rootdir);
-        DEBUGFS_ADD(excessive_retries, wl->debugfs.rootdir);
-
-        DEBUGFS_ADD(gpio_power, wl->debugfs.rootdir);
-
-out:
-        if (ret < 0)
-                wl1271_debugfs_delete_files(wl);
-
-        return ret;
-}
-
-void wl1271_debugfs_reset(struct wl1271 *wl)
-{
-        memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
-        wl->stats.retry_count = 0;
-        wl->stats.excessive_retries = 0;
-}
-
-int wl1271_debugfs_init(struct wl1271 *wl)
-{
-        int ret;
-
-        wl->debugfs.rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
-
-        if (IS_ERR(wl->debugfs.rootdir)) {
-                ret = PTR_ERR(wl->debugfs.rootdir);
-                wl->debugfs.rootdir = NULL;
-                goto err;
-        }
-
-        wl->debugfs.fw_statistics = debugfs_create_dir("fw-statistics",
-                                                       wl->debugfs.rootdir);
-
-        if (IS_ERR(wl->debugfs.fw_statistics)) {
-                ret = PTR_ERR(wl->debugfs.fw_statistics);
-                wl->debugfs.fw_statistics = NULL;
-                goto err_root;
-        }
-
-        wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats),
-                                      GFP_KERNEL);
-
-        if (!wl->stats.fw_stats) {
-                ret = -ENOMEM;
-                goto err_fw;
-        }
-
-        wl->stats.fw_stats_update = jiffies;
-
-        ret = wl1271_debugfs_add_files(wl);
-
-        if (ret < 0)
-                goto err_file;
-
-        return 0;
-
-err_file:
-        kfree(wl->stats.fw_stats);
-        wl->stats.fw_stats = NULL;
-
-err_fw:
-        debugfs_remove(wl->debugfs.fw_statistics);
-        wl->debugfs.fw_statistics = NULL;
-
-err_root:
-        debugfs_remove(wl->debugfs.rootdir);
-        wl->debugfs.rootdir = NULL;
-
-err:
-        return ret;
-}
-
-void wl1271_debugfs_exit(struct wl1271 *wl)
-{
-        wl1271_debugfs_delete_files(wl);
-
-        kfree(wl->stats.fw_stats);
-        wl->stats.fw_stats = NULL;
-
-        debugfs_remove(wl->debugfs.fw_statistics);
-        wl->debugfs.fw_statistics = NULL;
-
-        debugfs_remove(wl->debugfs.rootdir);
-        wl->debugfs.rootdir = NULL;
-
-}
diff --git a/drivers/net/wireless/wl12xx/wl1271_init.c b/drivers/net/wireless/wl12xx/wl1271_init.c
deleted file mode 100644
index 4447af1557f5..000000000000
--- a/drivers/net/wireless/wl12xx/wl1271_init.c
+++ /dev/null
@@ -1,368 +0,0 @@
-/*
- * This file is part of wl1271
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Luciano Coelho <luciano.coelho@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-
-#include "wl1271_init.h"
-#include "wl12xx_80211.h"
-#include "wl1271_acx.h"
-#include "wl1271_cmd.h"
-#include "wl1271_reg.h"
-
-static int wl1271_init_hwenc_config(struct wl1271 *wl)
-{
-        int ret;
-
-        ret = wl1271_acx_feature_cfg(wl);
-        if (ret < 0) {
-                wl1271_warning("couldn't set feature config");
-                return ret;
-        }
-
-        ret = wl1271_cmd_set_default_wep_key(wl, wl->default_key);
-        if (ret < 0) {
-                wl1271_warning("couldn't set default key");
-                return ret;
-        }
-
-        return 0;
-}
-
-int wl1271_init_templates_config(struct wl1271 *wl)
-{
-        int ret, i;
-
-        /* send empty templates for fw memory reservation */
-        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4, NULL,
-                                      sizeof(struct wl12xx_probe_req_template),
-                                      0, WL1271_RATE_AUTOMATIC);
-        if (ret < 0)
-                return ret;
-
-        if (wl1271_11a_enabled()) {
-                size_t size = sizeof(struct wl12xx_probe_req_template);
-                ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_5,
-                                              NULL, size, 0,
-                                              WL1271_RATE_AUTOMATIC);
-                if (ret < 0)
-                        return ret;
-        }
-
-        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, NULL,
-                                      sizeof(struct wl12xx_null_data_template),
-                                      0, WL1271_RATE_AUTOMATIC);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PS_POLL, NULL,
-                                      sizeof(struct wl12xx_ps_poll_template),
-                                      0, WL1271_RATE_AUTOMATIC);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, NULL,
-                                      sizeof
-                                      (struct wl12xx_qos_null_data_template),
-                                      0, WL1271_RATE_AUTOMATIC);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE, NULL,
-                                      sizeof
-                                      (struct wl12xx_probe_resp_template),
-                                      0, WL1271_RATE_AUTOMATIC);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON, NULL,
-                                      sizeof
-                                      (struct wl12xx_beacon_template),
-                                      0, WL1271_RATE_AUTOMATIC);
-        if (ret < 0)
-                return ret;
-
-        for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) {
-                ret = wl1271_cmd_template_set(wl, CMD_TEMPL_KLV, NULL,
-                                              WL1271_CMD_TEMPL_MAX_SIZE, i,
-                                              WL1271_RATE_AUTOMATIC);
-                if (ret < 0)
-                        return ret;
-        }
-
-        return 0;
-}
-
-static int wl1271_init_rx_config(struct wl1271 *wl, u32 config, u32 filter)
-{
-        int ret;
-
-        ret = wl1271_acx_rx_msdu_life_time(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_rx_config(wl, config, filter);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1271_init_phy_config(struct wl1271 *wl)
-{
-        int ret;
-
-        ret = wl1271_acx_pd_threshold(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_slot(wl, DEFAULT_SLOT_TIME);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_group_address_tbl(wl, true, NULL, 0);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_service_period_timeout(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_rts_threshold(wl, wl->conf.rx.rts_threshold);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static int wl1271_init_beacon_filter(struct wl1271 *wl)
-{
-        int ret;
-
-        /* disable beacon filtering at this stage */
-        ret = wl1271_acx_beacon_filter_opt(wl, false);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_beacon_filter_table(wl);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1271_init_pta(struct wl1271 *wl)
-{
-        int ret;
-
-        ret = wl1271_acx_sg_cfg(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_sg_enable(wl, wl->sg_enabled);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1271_init_energy_detection(struct wl1271 *wl)
-{
-        int ret;
-
-        ret = wl1271_acx_cca_threshold(wl);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static int wl1271_init_beacon_broadcast(struct wl1271 *wl)
-{
-        int ret;
-
-        ret = wl1271_acx_bcn_dtim_options(wl);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-int wl1271_hw_init(struct wl1271 *wl)
-{
-        struct conf_tx_ac_category *conf_ac;
-        struct conf_tx_tid *conf_tid;
-        int ret, i;
-
-        ret = wl1271_cmd_general_parms(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_cmd_radio_parms(wl);
-        if (ret < 0)
-                return ret;
-
-        /* Template settings */
-        ret = wl1271_init_templates_config(wl);
-        if (ret < 0)
-                return ret;
-
-        /* Default memory configuration */
-        ret = wl1271_acx_init_mem_config(wl);
-        if (ret < 0)
-                return ret;
-
-        /* RX config */
-        ret = wl1271_init_rx_config(wl,
-                                    RX_CFG_PROMISCUOUS | RX_CFG_TSF,
-                                    RX_FILTER_OPTION_DEF);
-        /* RX_CONFIG_OPTION_ANY_DST_ANY_BSS,
-           RX_FILTER_OPTION_FILTER_ALL); */
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* PHY layer config */
-        ret = wl1271_init_phy_config(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        ret = wl1271_acx_dco_itrim_params(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Initialize connection monitoring thresholds */
-        ret = wl1271_acx_conn_monit_params(wl, false);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Beacon filtering */
-        ret = wl1271_init_beacon_filter(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Configure TX patch complete interrupt behavior */
-        ret = wl1271_acx_tx_config_options(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* RX complete interrupt pacing */
-        ret = wl1271_acx_init_rx_interrupt(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Bluetooth WLAN coexistence */
-        ret = wl1271_init_pta(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Energy detection */
-        ret = wl1271_init_energy_detection(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Beacons and boradcast settings */
-        ret = wl1271_init_beacon_broadcast(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Default fragmentation threshold */
-        ret = wl1271_acx_frag_threshold(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Default TID configuration */
-        for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
-                conf_tid = &wl->conf.tx.tid_conf[i];
-                ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
-                                         conf_tid->channel_type,
-                                         conf_tid->tsid,
-                                         conf_tid->ps_scheme,
-                                         conf_tid->ack_policy,
-                                         conf_tid->apsd_conf[0],
-                                         conf_tid->apsd_conf[1]);
-                if (ret < 0)
-                        goto out_free_memmap;
-        }
-
-        /* Default AC configuration */
-        for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
-                conf_ac = &wl->conf.tx.ac_conf[i];
-                ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
-                                        conf_ac->cw_max, conf_ac->aifsn,
-                                        conf_ac->tx_op_limit);
-                if (ret < 0)
-                        goto out_free_memmap;
-        }
-
-        /* Configure TX rate classes */
-        ret = wl1271_acx_rate_policies(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Enable data path */
-        ret = wl1271_cmd_data_path(wl, 1);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Configure for ELP power saving */
-        ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Configure HW encryption */
-        ret = wl1271_init_hwenc_config(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* configure PM */
-        ret = wl1271_acx_pm_config(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* disable all keep-alive templates */
-        for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) {
-                ret = wl1271_acx_keep_alive_config(wl, i,
-                                                   ACX_KEEP_ALIVE_TPL_INVALID);
-                if (ret < 0)
-                        goto out_free_memmap;
-        }
-
-        /* disable the keep-alive feature */
-        ret = wl1271_acx_keep_alive_mode(wl, false);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Configure rssi/snr averaging weights */
-        ret = wl1271_acx_rssi_snr_avg_weights(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        return 0;
-
- out_free_memmap:
-        kfree(wl->target_mem_map);
-        wl->target_mem_map = NULL;
-
-        return ret;
-}
diff --git a/drivers/net/wireless/wl12xx/wl1271_main.c b/drivers/net/wireless/wl12xx/wl1271_main.c
deleted file mode 100644
index 9d68f0012f05..000000000000
--- a/drivers/net/wireless/wl12xx/wl1271_main.c
+++ /dev/null
@@ -1,2491 +0,0 @@
-/*
- * This file is part of wl1271
- *
- * Copyright (C) 2008-2010 Nokia Corporation
- *
- * Contact: Luciano Coelho <luciano.coelho@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/module.h>
-#include <linux/firmware.h>
-#include <linux/delay.h>
-#include <linux/spi/spi.h>
-#include <linux/crc32.h>
-#include <linux/etherdevice.h>
-#include <linux/vmalloc.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-
-#include "wl1271.h"
-#include "wl12xx_80211.h"
-#include "wl1271_reg.h"
-#include "wl1271_io.h"
-#include "wl1271_event.h"
-#include "wl1271_tx.h"
-#include "wl1271_rx.h"
-#include "wl1271_ps.h"
-#include "wl1271_init.h"
-#include "wl1271_debugfs.h"
-#include "wl1271_cmd.h"
-#include "wl1271_boot.h"
-#include "wl1271_testmode.h"
-#include "wl1271_scan.h"
-
-#define WL1271_BOOT_RETRIES 3
-
-static struct conf_drv_settings default_conf = {
-        .sg = {
-                .params = {
-                        [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
-                        [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
-                        [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
-                        [CONF_SG_BT_LOAD_RATIO]                     = 50,
-                        [CONF_SG_AUTO_PS_MODE]                      = 1,
-                        [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
-                        [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
-                        [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
-                        [CONF_SG_BEACON_MISS_PERCENT]               = 60,
-                        [CONF_SG_RATE_ADAPT_THRESH]                 = 12,
-                        [CONF_SG_RATE_ADAPT_SNR]                    = 0,
-                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
-                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
-                        [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
-                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
-                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
-                        /* Note: with UPSD, this should be 4 */
-                        [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
-                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
-                        [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
-                        [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
-                        /* Note: with UPDS, this should be 15 */
-                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
-                        /* Note: with UPDS, this should be 50 */
-                        [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
-                        /* Note: with UPDS, this should be 10 */
-                        [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
-                        [CONF_SG_RXT]                               = 1200,
-                        [CONF_SG_TXT]                               = 1000,
-                        [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
-                        [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
-                        [CONF_SG_UPSD_TIMEOUT]                      = 10,
-                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
-                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
-                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
-                        [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
-                        [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
-                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
-                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
-                        [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
-                        [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
-                        [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
-                        [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
-                        [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
-                        [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
-                        [CONF_SG_HV3_MAX_SERVED]                    = 6,
-                        [CONF_SG_DHCP_TIME]                         = 5000,
-                        [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
-                },
-                .state = CONF_SG_PROTECTIVE,
-        },
-        .rx = {
-                .rx_msdu_life_time           = 512000,
-                .packet_detection_threshold  = 0,
-                .ps_poll_timeout             = 15,
-                .upsd_timeout                = 15,
-                .rts_threshold               = 2347,
-                .rx_cca_threshold            = 0,
-                .irq_blk_threshold           = 0xFFFF,
-                .irq_pkt_threshold           = 0,
-                .irq_timeout                 = 600,
-                .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
-        },
-        .tx = {
-                .tx_energy_detection         = 0,
-                .rc_conf                     = {
-                        .enabled_rates       = 0,
-                        .short_retry_limit   = 10,
-                        .long_retry_limit    = 10,
-                        .aflags              = 0
-                },
-                .ac_conf_count               = 4,
-                .ac_conf                     = {
-                        [0] = {
-                                .ac          = CONF_TX_AC_BE,
-                                .cw_min      = 15,
-                                .cw_max      = 63,
-                                .aifsn       = 3,
-                                .tx_op_limit = 0,
-                        },
-                        [1] = {
-                                .ac          = CONF_TX_AC_BK,
-                                .cw_min      = 15,
-                                .cw_max      = 63,
-                                .aifsn       = 7,
-                                .tx_op_limit = 0,
-                        },
-                        [2] = {
-                                .ac          = CONF_TX_AC_VI,
-                                .cw_min      = 15,
-                                .cw_max      = 63,
-                                .aifsn       = CONF_TX_AIFS_PIFS,
-                                .tx_op_limit = 3008,
-                        },
-                        [3] = {
-                                .ac          = CONF_TX_AC_VO,
-                                .cw_min      = 15,
-                                .cw_max      = 63,
-                                .aifsn       = CONF_TX_AIFS_PIFS,
-                                .tx_op_limit = 1504,
-                        },
-                },
-                .tid_conf_count = 7,
-                .tid_conf = {
-                        [0] = {
-                                .queue_id    = 0,
-                                .channel_type = CONF_CHANNEL_TYPE_DCF,
-                                .tsid        = CONF_TX_AC_BE,
-                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
-                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
-                                .apsd_conf   = {0, 0},
-                        },
-                        [1] = {
-                                .queue_id    = 1,
-                                .channel_type = CONF_CHANNEL_TYPE_DCF,
-                                .tsid        = CONF_TX_AC_BE,
-                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
-                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
-                                .apsd_conf   = {0, 0},
-                        },
-                        [2] = {
-                                .queue_id    = 2,
-                                .channel_type = CONF_CHANNEL_TYPE_DCF,
-                                .tsid        = CONF_TX_AC_BE,
-                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
-                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
-                                .apsd_conf   = {0, 0},
-                        },
-                        [3] = {
-                                .queue_id    = 3,
-                                .channel_type = CONF_CHANNEL_TYPE_DCF,
-                                .tsid        = CONF_TX_AC_BE,
-                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
-                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
-                                .apsd_conf   = {0, 0},
-                        },
-                        [4] = {
-                                .queue_id    = 4,
-                                .channel_type = CONF_CHANNEL_TYPE_DCF,
-                                .tsid        = CONF_TX_AC_BE,
-                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
-                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
-                                .apsd_conf   = {0, 0},
-                        },
-                        [5] = {
-                                .queue_id    = 5,
-                                .channel_type = CONF_CHANNEL_TYPE_DCF,
-                                .tsid        = CONF_TX_AC_BE,
-                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
-                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
-                                .apsd_conf   = {0, 0},
-                        },
-                        [6] = {
-                                .queue_id    = 6,
-                                .channel_type = CONF_CHANNEL_TYPE_DCF,
-                                .tsid        = CONF_TX_AC_BE,
-                                .ps_scheme   = CONF_PS_SCHEME_LEGACY,
-                                .ack_policy  = CONF_ACK_POLICY_LEGACY,
-                                .apsd_conf   = {0, 0},
-                        }
-                },
-                .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
-                .tx_compl_timeout            = 700,
-                .tx_compl_threshold          = 4,
-                .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
-                .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
-        },
-        .conn = {
-                .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
-                .listen_interval             = 1,
-                .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
-                .bcn_filt_ie_count           = 1,
-                .bcn_filt_ie = {
-                        [0] = {
-                                .ie          = WLAN_EID_CHANNEL_SWITCH,
-                                .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
-                        }
-                },
-                .synch_fail_thold            = 10,
-                .bss_lose_timeout            = 100,
-                .beacon_rx_timeout           = 10000,
-                .broadcast_timeout           = 20000,
-                .rx_broadcast_in_ps          = 1,
-                .ps_poll_threshold           = 10,
-                .ps_poll_recovery_period     = 700,
-                .bet_enable                  = CONF_BET_MODE_ENABLE,
-                .bet_max_consecutive         = 10,
-                .psm_entry_retries           = 3,
-                .keep_alive_interval         = 55000,
-                .max_listen_interval         = 20,
-        },
-        .itrim = {
-                .enable = false,
-                .timeout = 50000,
-        },
-        .pm_config = {
-                .host_clk_settling_time = 5000,
-                .host_fast_wakeup_support = false
-        },
-        .roam_trigger = {
-                /* FIXME: due to firmware bug, must use value 1 for now */
-                .trigger_pacing               = 1,
-                .avg_weight_rssi_beacon       = 20,
-                .avg_weight_rssi_data         = 10,
-                .avg_weight_snr_beacon        = 20,
-                .avg_weight_snr_data          = 10
-        }
-};
-
-static void wl1271_device_release(struct device *dev)
-{
-
-}
-
-static struct platform_device wl1271_device = {
-        .name           = "wl1271",
-        .id             = -1,
-
-        /* device model insists to have a release function */
-        .dev            = {
-                .release = wl1271_device_release,
-        },
-};
-
-static LIST_HEAD(wl_list);
-
-static void wl1271_conf_init(struct wl1271 *wl)
-{
-
-        /*
-         * This function applies the default configuration to the driver. This
-         * function is invoked upon driver load (spi probe.)
-         *
-         * The configuration is stored in a run-time structure in order to
-         * facilitate for run-time adjustment of any of the parameters. Making
-         * changes to the configuration structure will apply the new values on
-         * the next interface up (wl1271_op_start.)
-         */
-
-        /* apply driver default configuration */
-        memcpy(&wl->conf, &default_conf, sizeof(default_conf));
-}
-
-
-static int wl1271_plt_init(struct wl1271 *wl)
-{
-        struct conf_tx_ac_category *conf_ac;
-        struct conf_tx_tid *conf_tid;
-        int ret, i;
-
-        ret = wl1271_cmd_general_parms(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_cmd_radio_parms(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_init_templates_config(wl);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_acx_init_mem_config(wl);
-        if (ret < 0)
-                return ret;
-
-        /* PHY layer config */
-        ret = wl1271_init_phy_config(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        ret = wl1271_acx_dco_itrim_params(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Initialize connection monitoring thresholds */
-        ret = wl1271_acx_conn_monit_params(wl, false);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Bluetooth WLAN coexistence */
-        ret = wl1271_init_pta(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Energy detection */
-        ret = wl1271_init_energy_detection(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Default fragmentation threshold */
-        ret = wl1271_acx_frag_threshold(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Default TID configuration */
-        for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
-                conf_tid = &wl->conf.tx.tid_conf[i];
-                ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
-                                         conf_tid->channel_type,
-                                         conf_tid->tsid,
-                                         conf_tid->ps_scheme,
-                                         conf_tid->ack_policy,
-                                         conf_tid->apsd_conf[0],
-                                         conf_tid->apsd_conf[1]);
-                if (ret < 0)
-                        goto out_free_memmap;
-        }
-
-        /* Default AC configuration */
-        for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
-                conf_ac = &wl->conf.tx.ac_conf[i];
-                ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
-                                        conf_ac->cw_max, conf_ac->aifsn,
-                                        conf_ac->tx_op_limit);
-                if (ret < 0)
-                        goto out_free_memmap;
-        }
-
-        /* Enable data path */
-        ret = wl1271_cmd_data_path(wl, 1);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* Configure for CAM power saving (ie. always active) */
-        ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        /* configure PM */
-        ret = wl1271_acx_pm_config(wl);
-        if (ret < 0)
-                goto out_free_memmap;
-
-        return 0;
-
- out_free_memmap:
-        kfree(wl->target_mem_map);
-        wl->target_mem_map = NULL;
-
-        return ret;
-}
-
-static void wl1271_fw_status(struct wl1271 *wl,
-                             struct wl1271_fw_status *status)
-{
-        struct timespec ts;
-        u32 total = 0;
-        int i;
-
-        wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
-
-        wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
-                     "drv_rx_counter = %d, tx_results_counter = %d)",
-                     status->intr,
-                     status->fw_rx_counter,
-                     status->drv_rx_counter,
-                     status->tx_results_counter);
-
-        /* update number of available TX blocks */
-        for (i = 0; i < NUM_TX_QUEUES; i++) {
-                u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
-                        wl->tx_blocks_freed[i];
-
-                wl->tx_blocks_freed[i] =
-                        le32_to_cpu(status->tx_released_blks[i]);
-                wl->tx_blocks_available += cnt;
-                total += cnt;
-        }
-
-        /* if more blocks are available now, schedule some tx work */
-        if (total && !skb_queue_empty(&wl->tx_queue))
-                ieee80211_queue_work(wl->hw, &wl->tx_work);
-
-        /* update the host-chipset time offset */
-        getnstimeofday(&ts);
-        wl->time_offset = (timespec_to_ns(&ts) >> 10) -
-                (s64)le32_to_cpu(status->fw_localtime);
-}
-
-#define WL1271_IRQ_MAX_LOOPS 10
-
-static void wl1271_irq_work(struct work_struct *work)
-{
-        int ret;
-        u32 intr;
-        int loopcount = WL1271_IRQ_MAX_LOOPS;
-        unsigned long flags;
-        struct wl1271 *wl =
-                container_of(work, struct wl1271, irq_work);
-
-        mutex_lock(&wl->mutex);
-
-        wl1271_debug(DEBUG_IRQ, "IRQ work");
-
-        if (unlikely(wl->state == WL1271_STATE_OFF))
-                goto out;
-
-        ret = wl1271_ps_elp_wakeup(wl, true);
-        if (ret < 0)
-                goto out;
-
-        spin_lock_irqsave(&wl->wl_lock, flags);
-        while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
-                clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
-                spin_unlock_irqrestore(&wl->wl_lock, flags);
-                loopcount--;
-
-                wl1271_fw_status(wl, wl->fw_status);
-                intr = le32_to_cpu(wl->fw_status->intr);
-                if (!intr) {
-                        wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
-                        spin_lock_irqsave(&wl->wl_lock, flags);
-                        continue;
-                }
-
-                intr &= WL1271_INTR_MASK;
-
-                if (intr & WL1271_ACX_INTR_DATA) {
-                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
-
-                        /* check for tx results */
-                        if (wl->fw_status->tx_results_counter !=
-                            (wl->tx_results_count & 0xff))
-                                wl1271_tx_complete(wl);
-
-                        wl1271_rx(wl, wl->fw_status);
-                }
-
-                if (intr & WL1271_ACX_INTR_EVENT_A) {
-                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
-                        wl1271_event_handle(wl, 0);
-                }
-
-                if (intr & WL1271_ACX_INTR_EVENT_B) {
-                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
-                        wl1271_event_handle(wl, 1);
-                }
-
-                if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
-                        wl1271_debug(DEBUG_IRQ,
-                                     "WL1271_ACX_INTR_INIT_COMPLETE");
-
-                if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
-                        wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
-
-                spin_lock_irqsave(&wl->wl_lock, flags);
-        }
-
-        if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
-                ieee80211_queue_work(wl->hw, &wl->irq_work);
-        else
-                clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
-        spin_unlock_irqrestore(&wl->wl_lock, flags);
-
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1271_fetch_firmware(struct wl1271 *wl)
-{
-        const struct firmware *fw;
-        int ret;
-
-        ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
-
-        if (ret < 0) {
-                wl1271_error("could not get firmware: %d", ret);
-                return ret;
-        }
-
-        if (fw->size % 4) {
-                wl1271_error("firmware size is not multiple of 32 bits: %zu",
-                             fw->size);
-                ret = -EILSEQ;
-                goto out;
-        }
-
-        wl->fw_len = fw->size;
-        wl->fw = vmalloc(wl->fw_len);
-
-        if (!wl->fw) {
-                wl1271_error("could not allocate memory for the firmware");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        memcpy(wl->fw, fw->data, wl->fw_len);
-
-        ret = 0;
-
-out:
-        release_firmware(fw);
-
-        return ret;
-}
-
-static int wl1271_fetch_nvs(struct wl1271 *wl)
-{
-        const struct firmware *fw;
-        int ret;
-
-        ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
-
-        if (ret < 0) {
-                wl1271_error("could not get nvs file: %d", ret);
-                return ret;
-        }
-
-        /*
-         * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz band
-         * configurations) can be removed when those NVS files stop floating
-         * around.
-         */
-        if (fw->size != sizeof(struct wl1271_nvs_file) &&
-            (fw->size != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
-             wl1271_11a_enabled())) {
-                wl1271_error("nvs size is not as expected: %zu != %zu",
-                             fw->size, sizeof(struct wl1271_nvs_file));
-                ret = -EILSEQ;
-                goto out;
-        }
-
-        wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
-
-        if (!wl->nvs) {
-                wl1271_error("could not allocate memory for the nvs file");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-out:
-        release_firmware(fw);
-
-        return ret;
-}
-
-static void wl1271_fw_wakeup(struct wl1271 *wl)
-{
-        u32 elp_reg;
-
-        elp_reg = ELPCTRL_WAKE_UP;
-        wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
-}
-
-static int wl1271_setup(struct wl1271 *wl)
-{
-        wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
-        if (!wl->fw_status)
-                return -ENOMEM;
-
-        wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
-        if (!wl->tx_res_if) {
-                kfree(wl->fw_status);
-                return -ENOMEM;
-        }
-
-        INIT_WORK(&wl->irq_work, wl1271_irq_work);
-        INIT_WORK(&wl->tx_work, wl1271_tx_work);
-        return 0;
-}
-
-static int wl1271_chip_wakeup(struct wl1271 *wl)
-{
-        struct wl1271_partition_set partition;
-        int ret = 0;
-
-        msleep(WL1271_PRE_POWER_ON_SLEEP);
-        wl1271_power_on(wl);
-        msleep(WL1271_POWER_ON_SLEEP);
-        wl1271_io_reset(wl);
-        wl1271_io_init(wl);
-
-        /* We don't need a real memory partition here, because we only want
-         * to use the registers at this point. */
-        memset(&partition, 0, sizeof(partition));
-        partition.reg.start = REGISTERS_BASE;
-        partition.reg.size = REGISTERS_DOWN_SIZE;
-        wl1271_set_partition(wl, &partition);
-
-        /* ELP module wake up */
-        wl1271_fw_wakeup(wl);
-
-        /* whal_FwCtrl_BootSm() */
-
-        /* 0. read chip id from CHIP_ID */
-        wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
-
-        /* 1. check if chip id is valid */
-
-        switch (wl->chip.id) {
-        case CHIP_ID_1271_PG10:
-                wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
-                               wl->chip.id);
-
-                ret = wl1271_setup(wl);
-                if (ret < 0)
-                        goto out;
-                break;
-        case CHIP_ID_1271_PG20:
-                wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
-                             wl->chip.id);
-
-                ret = wl1271_setup(wl);
-                if (ret < 0)
-                        goto out;
-                break;
-        default:
-                wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
-                ret = -ENODEV;
-                goto out;
-        }
-
-        if (wl->fw == NULL) {
-                ret = wl1271_fetch_firmware(wl);
-                if (ret < 0)
-                        goto out;
-        }
-
-        /* No NVS from netlink, try to get it from the filesystem */
-        if (wl->nvs == NULL) {
-                ret = wl1271_fetch_nvs(wl);
-                if (ret < 0)
-                        goto out;
-        }
-
-out:
-        return ret;
-}
-
-int wl1271_plt_start(struct wl1271 *wl)
-{
-        int retries = WL1271_BOOT_RETRIES;
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        wl1271_notice("power up");
-
-        if (wl->state != WL1271_STATE_OFF) {
-                wl1271_error("cannot go into PLT state because not "
-                             "in off state: %d", wl->state);
-                ret = -EBUSY;
-                goto out;
-        }
-
-        while (retries) {
-                retries--;
-                ret = wl1271_chip_wakeup(wl);
-                if (ret < 0)
-                        goto power_off;
-
-                ret = wl1271_boot(wl);
-                if (ret < 0)
-                        goto power_off;
-
-                ret = wl1271_plt_init(wl);
-                if (ret < 0)
-                        goto irq_disable;
-
-                wl->state = WL1271_STATE_PLT;
-                wl1271_notice("firmware booted in PLT mode (%s)",
-                              wl->chip.fw_ver);
-                goto out;
-
-irq_disable:
-                wl1271_disable_interrupts(wl);
-                mutex_unlock(&wl->mutex);
-                /* Unlocking the mutex in the middle of handling is
-                   inherently unsafe. In this case we deem it safe to do,
-                   because we need to let any possibly pending IRQ out of
-                   the system (and while we are WL1271_STATE_OFF the IRQ
-                   work function will not do anything.) Also, any other
-                   possible concurrent operations will fail due to the
-                   current state, hence the wl1271 struct should be safe. */
-                cancel_work_sync(&wl->irq_work);
-                mutex_lock(&wl->mutex);
-power_off:
-                wl1271_power_off(wl);
-        }
-
-        wl1271_error("firmware boot in PLT mode failed despite %d retries",
-                     WL1271_BOOT_RETRIES);
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-int wl1271_plt_stop(struct wl1271 *wl)
-{
-        int ret = 0;
-
-        mutex_lock(&wl->mutex);
-
-        wl1271_notice("power down");
-
-        if (wl->state != WL1271_STATE_PLT) {
-                wl1271_error("cannot power down because not in PLT "
-                             "state: %d", wl->state);
-                ret = -EBUSY;
-                goto out;
-        }
-
-        wl1271_disable_interrupts(wl);
-        wl1271_power_off(wl);
-
-        wl->state = WL1271_STATE_OFF;
-        wl->rx_counter = 0;
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-
-static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
-{
-        struct wl1271 *wl = hw->priv;
-        struct ieee80211_conf *conf = &hw->conf;
-        struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
-        struct ieee80211_sta *sta = txinfo->control.sta;
-        unsigned long flags;
-
-        /* peek into the rates configured in the STA entry */
-        spin_lock_irqsave(&wl->wl_lock, flags);
-        if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
-                wl->sta_rate_set = sta->supp_rates[conf->channel->band];
-                set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
-        }
-        spin_unlock_irqrestore(&wl->wl_lock, flags);
-
-        /* queue the packet */
-        skb_queue_tail(&wl->tx_queue, skb);
-
-        /*
-         * The chip specific setup must run before the first TX packet -
-         * before that, the tx_work will not be initialized!
-         */
-
-        ieee80211_queue_work(wl->hw, &wl->tx_work);
-
-        /*
-         * The workqueue is slow to process the tx_queue and we need stop
-         * the queue here, otherwise the queue will get too long.
-         */
-        if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
-                wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
-
-                spin_lock_irqsave(&wl->wl_lock, flags);
-                ieee80211_stop_queues(wl->hw);
-                set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
-                spin_unlock_irqrestore(&wl->wl_lock, flags);
-        }
-
-        return NETDEV_TX_OK;
-}
-
-static int wl1271_op_start(struct ieee80211_hw *hw)
-{
-        wl1271_debug(DEBUG_MAC80211, "mac80211 start");
-
-        /*
-         * We have to delay the booting of the hardware because
-         * we need to know the local MAC address before downloading and
-         * initializing the firmware. The MAC address cannot be changed
-         * after boot, and without the proper MAC address, the firmware
-         * will not function properly.
-         *
-         * The MAC address is first known when the corresponding interface
-         * is added. That is where we will initialize the hardware.
-         */
-
-        return 0;
-}
-
-static void wl1271_op_stop(struct ieee80211_hw *hw)
-{
-        wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
-}
-
-static int wl1271_op_add_interface(struct ieee80211_hw *hw,
-                                   struct ieee80211_vif *vif)
-{
-        struct wl1271 *wl = hw->priv;
-        struct wiphy *wiphy = hw->wiphy;
-        int retries = WL1271_BOOT_RETRIES;
-        int ret = 0;
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
-                     vif->type, vif->addr);
-
-        mutex_lock(&wl->mutex);
-        if (wl->vif) {
-                ret = -EBUSY;
-                goto out;
-        }
-
-        wl->vif = vif;
-
-        switch (vif->type) {
-        case NL80211_IFTYPE_STATION:
-                wl->bss_type = BSS_TYPE_STA_BSS;
-                wl->set_bss_type = BSS_TYPE_STA_BSS;
-                break;
-        case NL80211_IFTYPE_ADHOC:
-                wl->bss_type = BSS_TYPE_IBSS;
-                wl->set_bss_type = BSS_TYPE_STA_BSS;
-                break;
-        default:
-                ret = -EOPNOTSUPP;
-                goto out;
-        }
-
-        memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
-
-        if (wl->state != WL1271_STATE_OFF) {
-                wl1271_error("cannot start because not in off state: %d",
-                             wl->state);
-                ret = -EBUSY;
-                goto out;
-        }
-
-        while (retries) {
-                retries--;
-                ret = wl1271_chip_wakeup(wl);
-                if (ret < 0)
-                        goto power_off;
-
-                ret = wl1271_boot(wl);
-                if (ret < 0)
-                        goto power_off;
-
-                ret = wl1271_hw_init(wl);
-                if (ret < 0)
-                        goto irq_disable;
-
-                wl->state = WL1271_STATE_ON;
-                wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
-
-                /* update hw/fw version info in wiphy struct */
-                wiphy->hw_version = wl->chip.id;
-                strncpy(wiphy->fw_version, wl->chip.fw_ver,
-                        sizeof(wiphy->fw_version));
-
-                goto out;
-
-irq_disable:
-                wl1271_disable_interrupts(wl);
-                mutex_unlock(&wl->mutex);
-                /* Unlocking the mutex in the middle of handling is
-                   inherently unsafe. In this case we deem it safe to do,
-                   because we need to let any possibly pending IRQ out of
-                   the system (and while we are WL1271_STATE_OFF the IRQ
-                   work function will not do anything.) Also, any other
-                   possible concurrent operations will fail due to the
-                   current state, hence the wl1271 struct should be safe. */
-                cancel_work_sync(&wl->irq_work);
-                mutex_lock(&wl->mutex);
-power_off:
-                wl1271_power_off(wl);
-        }
-
-        wl1271_error("firmware boot failed despite %d retries",
-                     WL1271_BOOT_RETRIES);
-out:
-        mutex_unlock(&wl->mutex);
-
-        if (!ret)
-                list_add(&wl->list, &wl_list);
-
-        return ret;
-}
-
-static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
-                                       struct ieee80211_vif *vif)
-{
-        struct wl1271 *wl = hw->priv;
-        int i;
-
-        mutex_lock(&wl->mutex);
-        wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
-
-        wl1271_info("down");
-
-        list_del(&wl->list);
-
-        WARN_ON(wl->state != WL1271_STATE_ON);
-
-        /* enable dyn ps just in case (if left on due to fw crash etc) */
-        if (wl->bss_type == BSS_TYPE_STA_BSS)
-                ieee80211_enable_dyn_ps(wl->vif);
-
-        if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
-                mutex_unlock(&wl->mutex);
-                ieee80211_scan_completed(wl->hw, true);
-                mutex_lock(&wl->mutex);
-                wl->scan.state = WL1271_SCAN_STATE_IDLE;
-                kfree(wl->scan.scanned_ch);
-                wl->scan.scanned_ch = NULL;
-        }
-
-        wl->state = WL1271_STATE_OFF;
-
-        wl1271_disable_interrupts(wl);
-
-        mutex_unlock(&wl->mutex);
-
-        cancel_work_sync(&wl->irq_work);
-        cancel_work_sync(&wl->tx_work);
-        cancel_delayed_work_sync(&wl->pspoll_work);
-
-        mutex_lock(&wl->mutex);
-
-        /* let's notify MAC80211 about the remaining pending TX frames */
-        wl1271_tx_reset(wl);
-        wl1271_power_off(wl);
-
-        memset(wl->bssid, 0, ETH_ALEN);
-        memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
-        wl->ssid_len = 0;
-        wl->bss_type = MAX_BSS_TYPE;
-        wl->set_bss_type = MAX_BSS_TYPE;
-        wl->band = IEEE80211_BAND_2GHZ;
-
-        wl->rx_counter = 0;
-        wl->psm_entry_retry = 0;
-        wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
-        wl->tx_blocks_available = 0;
-        wl->tx_results_count = 0;
-        wl->tx_packets_count = 0;
-        wl->tx_security_last_seq = 0;
-        wl->tx_security_seq = 0;
-        wl->time_offset = 0;
-        wl->session_counter = 0;
-        wl->rate_set = CONF_TX_RATE_MASK_BASIC;
-        wl->sta_rate_set = 0;
-        wl->flags = 0;
-        wl->vif = NULL;
-        wl->filters = 0;
-
-        for (i = 0; i < NUM_TX_QUEUES; i++)
-                wl->tx_blocks_freed[i] = 0;
-
-        wl1271_debugfs_reset(wl);
-
-        kfree(wl->fw_status);
-        wl->fw_status = NULL;
-        kfree(wl->tx_res_if);
-        wl->tx_res_if = NULL;
-        kfree(wl->target_mem_map);
-        wl->target_mem_map = NULL;
-
-        mutex_unlock(&wl->mutex);
-}
-
-static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
-{
-        wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
-        wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
-
-        /* combine requested filters with current filter config */
-        filters = wl->filters | filters;
-
-        wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
-
-        if (filters & FIF_PROMISC_IN_BSS) {
-                wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
-                wl->rx_config &= ~CFG_UNI_FILTER_EN;
-                wl->rx_config |= CFG_BSSID_FILTER_EN;
-        }
-        if (filters & FIF_BCN_PRBRESP_PROMISC) {
-                wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
-                wl->rx_config &= ~CFG_BSSID_FILTER_EN;
-                wl->rx_config &= ~CFG_SSID_FILTER_EN;
-        }
-        if (filters & FIF_OTHER_BSS) {
-                wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
-                wl->rx_config &= ~CFG_BSSID_FILTER_EN;
-        }
-        if (filters & FIF_CONTROL) {
-                wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
-                wl->rx_filter |= CFG_RX_CTL_EN;
-        }
-        if (filters & FIF_FCSFAIL) {
-                wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
-                wl->rx_filter |= CFG_RX_FCS_ERROR;
-        }
-}
-
-static int wl1271_dummy_join(struct wl1271 *wl)
-{
-        int ret = 0;
-        /* we need to use a dummy BSSID for now */
-        static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
-                                                  0xad, 0xbe, 0xef };
-
-        memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
-
-        /* pass through frames from all BSS */
-        wl1271_configure_filters(wl, FIF_OTHER_BSS);
-
-        ret = wl1271_cmd_join(wl, wl->set_bss_type);
-        if (ret < 0)
-                goto out;
-
-        set_bit(WL1271_FLAG_JOINED, &wl->flags);
-
-out:
-        return ret;
-}
-
-static int wl1271_join(struct wl1271 *wl, bool set_assoc)
-{
-        int ret;
-
-        /*
-         * One of the side effects of the JOIN command is that is clears
-         * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
-         * to a WPA/WPA2 access point will therefore kill the data-path.
-         * Currently there is no supported scenario for JOIN during
-         * association - if it becomes a supported scenario, the WPA/WPA2 keys
-         * must be handled somehow.
-         *
-         */
-        if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
-                wl1271_info("JOIN while associated.");
-
-        if (set_assoc)
-                set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
-
-        ret = wl1271_cmd_join(wl, wl->set_bss_type);
-        if (ret < 0)
-                goto out;
-
-        set_bit(WL1271_FLAG_JOINED, &wl->flags);
-
-        if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
-                goto out;
-
-        /*
-         * The join command disable the keep-alive mode, shut down its process,
-         * and also clear the template config, so we need to reset it all after
-         * the join. The acx_aid starts the keep-alive process, and the order
-         * of the commands below is relevant.
-         */
-        ret = wl1271_acx_keep_alive_mode(wl, true);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1271_acx_aid(wl, wl->aid);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1271_cmd_build_klv_null_data(wl);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
-                                           ACX_KEEP_ALIVE_TPL_VALID);
-        if (ret < 0)
-                goto out;
-
-out:
-        return ret;
-}
-
-static int wl1271_unjoin(struct wl1271 *wl)
-{
-        int ret;
-
-        /* to stop listening to a channel, we disconnect */
-        ret = wl1271_cmd_disconnect(wl);
-        if (ret < 0)
-                goto out;
-
-        clear_bit(WL1271_FLAG_JOINED, &wl->flags);
-        memset(wl->bssid, 0, ETH_ALEN);
-
-        /* stop filterting packets based on bssid */
-        wl1271_configure_filters(wl, FIF_OTHER_BSS);
-
-out:
-        return ret;
-}
-
-static void wl1271_set_band_rate(struct wl1271 *wl)
-{
-        if (wl->band == IEEE80211_BAND_2GHZ)
-                wl->basic_rate_set = wl->conf.tx.basic_rate;
-        else
-                wl->basic_rate_set = wl->conf.tx.basic_rate_5;
-}
-
-static u32 wl1271_min_rate_get(struct wl1271 *wl)
-{
-        int i;
-        u32 rate = 0;
-
-        if (!wl->basic_rate_set) {
-                WARN_ON(1);
-                wl->basic_rate_set = wl->conf.tx.basic_rate;
-        }
-
-        for (i = 0; !rate; i++) {
-                if ((wl->basic_rate_set >> i) & 0x1)
-                        rate = 1 << i;
-        }
-
-        return rate;
-}
-
-static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
-{
-        int ret;
-
-        if (idle) {
-                if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
-                        ret = wl1271_unjoin(wl);
-                        if (ret < 0)
-                                goto out;
-                }
-                wl->rate_set = wl1271_min_rate_get(wl);
-                wl->sta_rate_set = 0;
-                ret = wl1271_acx_rate_policies(wl);
-                if (ret < 0)
-                        goto out;
-                ret = wl1271_acx_keep_alive_config(
-                        wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
-                        ACX_KEEP_ALIVE_TPL_INVALID);
-                if (ret < 0)
-                        goto out;
-                set_bit(WL1271_FLAG_IDLE, &wl->flags);
-        } else {
-                /* increment the session counter */
-                wl->session_counter++;
-                if (wl->session_counter >= SESSION_COUNTER_MAX)
-                        wl->session_counter = 0;
-                ret = wl1271_dummy_join(wl);
-                if (ret < 0)
-                        goto out;
-                clear_bit(WL1271_FLAG_IDLE, &wl->flags);
-        }
-
-out:
-        return ret;
-}
-
-static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
-{
-        struct wl1271 *wl = hw->priv;
-        struct ieee80211_conf *conf = &hw->conf;
-        int channel, ret = 0;
-
-        channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
-                     channel,
-                     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
-                     conf->power_level,
-                     conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
-
-        /*
-         * mac80211 will go to idle nearly immediately after transmitting some
-         * frames, such as the deauth. To make sure those frames reach the air,
-         * wait here until the TX queue is fully flushed.
-         */
-        if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
-            (conf->flags & IEEE80211_CONF_IDLE))
-                wl1271_tx_flush(wl);
-
-        mutex_lock(&wl->mutex);
-
-        if (unlikely(wl->state == WL1271_STATE_OFF))
-                goto out;
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        /* if the channel changes while joined, join again */
-        if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
-            ((wl->band != conf->channel->band) ||
-             (wl->channel != channel))) {
-                wl->band = conf->channel->band;
-                wl->channel = channel;
-
-                /*
-                 * FIXME: the mac80211 should really provide a fixed rate
-                 * to use here. for now, just use the smallest possible rate
-                 * for the band as a fixed rate for association frames and
-                 * other control messages.
-                 */
-                if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
-                        wl1271_set_band_rate(wl);
-
-                wl->basic_rate = wl1271_min_rate_get(wl);
-                ret = wl1271_acx_rate_policies(wl);
-                if (ret < 0)
-                        wl1271_warning("rate policy for update channel "
-                                       "failed %d", ret);
-
-                if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
-                        ret = wl1271_join(wl, false);
-                        if (ret < 0)
-                                wl1271_warning("cmd join to update channel "
-                                               "failed %d", ret);
-                }
-        }
-
-        if (changed & IEEE80211_CONF_CHANGE_IDLE) {
-                ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
-                if (ret < 0)
-                        wl1271_warning("idle mode change failed %d", ret);
-        }
-
-        /*
-         * if mac80211 changes the PSM mode, make sure the mode is not
-         * incorrectly changed after the pspoll failure active window.
-         */
-        if (changed & IEEE80211_CONF_CHANGE_PS)
-                clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
-
-        if (conf->flags & IEEE80211_CONF_PS &&
-            !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
-                set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
-
-                /*
-                 * We enter PSM only if we're already associated.
-                 * If we're not, we'll enter it when joining an SSID,
-                 * through the bss_info_changed() hook.
-                 */
-                if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
-                        wl1271_debug(DEBUG_PSM, "psm enabled");
-                        ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
-                                                 true);
-                }
-        } else if (!(conf->flags & IEEE80211_CONF_PS) &&
-                   test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
-                wl1271_debug(DEBUG_PSM, "psm disabled");
-
-                clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
-
-                if (test_bit(WL1271_FLAG_PSM, &wl->flags))
-                        ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
-                                                 true);
-        }
-
-        if (conf->power_level != wl->power_level) {
-                ret = wl1271_acx_tx_power(wl, conf->power_level);
-                if (ret < 0)
-                        goto out_sleep;
-
-                wl->power_level = conf->power_level;
-        }
-
-out_sleep:
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-struct wl1271_filter_params {
-        bool enabled;
-        int mc_list_length;
-        u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
-};
-
-static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
-                                       struct netdev_hw_addr_list *mc_list)
-{
-        struct wl1271_filter_params *fp;
-        struct netdev_hw_addr *ha;
-        struct wl1271 *wl = hw->priv;
-
-        if (unlikely(wl->state == WL1271_STATE_OFF))
-                return 0;
-
-        fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
-        if (!fp) {
-                wl1271_error("Out of memory setting filters.");
-                return 0;
-        }
-
-        /* update multicast filtering parameters */
-        fp->mc_list_length = 0;
-        if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
-                fp->enabled = false;
-        } else {
-                fp->enabled = true;
-                netdev_hw_addr_list_for_each(ha, mc_list) {
-                        memcpy(fp->mc_list[fp->mc_list_length],
-                                        ha->addr, ETH_ALEN);
-                        fp->mc_list_length++;
-                }
-        }
-
-        return (u64)(unsigned long)fp;
-}
-
-#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
-                                  FIF_ALLMULTI | \
-                                  FIF_FCSFAIL | \
-                                  FIF_BCN_PRBRESP_PROMISC | \
-                                  FIF_CONTROL | \
-                                  FIF_OTHER_BSS)
-
-static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
-                                       unsigned int changed,
-                                       unsigned int *total, u64 multicast)
-{
-        struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
-        struct wl1271 *wl = hw->priv;
-        int ret;
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
-
-        mutex_lock(&wl->mutex);
-
-        *total &= WL1271_SUPPORTED_FILTERS;
-        changed &= WL1271_SUPPORTED_FILTERS;
-
-        if (unlikely(wl->state == WL1271_STATE_OFF))
-                goto out;
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-
-        if (*total & FIF_ALLMULTI)
-                ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
-        else if (fp)
-                ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
-                                                   fp->mc_list,
-                                                   fp->mc_list_length);
-        if (ret < 0)
-                goto out_sleep;
-
-        /* determine, whether supported filter values have changed */
-        if (changed == 0)
-                goto out_sleep;
-
-        /* configure filters */
-        wl->filters = *total;
-        wl1271_configure_filters(wl, 0);
-
-        /* apply configured filters */
-        ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
-        if (ret < 0)
-                goto out_sleep;
-
-out_sleep:
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-        kfree(fp);
-}
-
-static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
-                             struct ieee80211_vif *vif,
-                             struct ieee80211_sta *sta,
-                             struct ieee80211_key_conf *key_conf)
-{
-        struct wl1271 *wl = hw->priv;
-        const u8 *addr;
-        int ret;
-        u32 tx_seq_32 = 0;
-        u16 tx_seq_16 = 0;
-        u8 key_type;
-
-        static const u8 bcast_addr[ETH_ALEN] =
-                { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
-
-        addr = sta ? sta->addr : bcast_addr;
-
-        wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
-        wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
-        wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
-                     key_conf->alg, key_conf->keyidx,
-                     key_conf->keylen, key_conf->flags);
-        wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
-
-        if (is_zero_ether_addr(addr)) {
-                /* We dont support TX only encryption */
-                ret = -EOPNOTSUPP;
-                goto out;
-        }
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out_unlock;
-
-        switch (key_conf->alg) {
-        case ALG_WEP:
-                key_type = KEY_WEP;
-
-                key_conf->hw_key_idx = key_conf->keyidx;
-                break;
-        case ALG_TKIP:
-                key_type = KEY_TKIP;
-
-                key_conf->hw_key_idx = key_conf->keyidx;
-                tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
-                tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
-                break;
-        case ALG_CCMP:
-                key_type = KEY_AES;
-
-                key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
-                tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
-                tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
-                break;
-        default:
-                wl1271_error("Unknown key algo 0x%x", key_conf->alg);
-
-                ret = -EOPNOTSUPP;
-                goto out_sleep;
-        }
-
-        switch (cmd) {
-        case SET_KEY:
-                ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
-                                         key_conf->keyidx, key_type,
-                                         key_conf->keylen, key_conf->key,
-                                         addr, tx_seq_32, tx_seq_16);
-                if (ret < 0) {
-                        wl1271_error("Could not add or replace key");
-                        goto out_sleep;
-                }
-
-                /* the default WEP key needs to be configured at least once */
-                if (key_type == KEY_WEP) {
-                        ret = wl1271_cmd_set_default_wep_key(wl,
-                                                             wl->default_key);
-                        if (ret < 0)
-                                goto out_sleep;
-                }
-                break;
-
-        case DISABLE_KEY:
-                /* The wl1271 does not allow to remove unicast keys - they
-                   will be cleared automatically on next CMD_JOIN. Ignore the
-                   request silently, as we dont want the mac80211 to emit
-                   an error message. */
-                if (!is_broadcast_ether_addr(addr))
-                        break;
-
-                ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
-                                         key_conf->keyidx, key_type,
-                                         key_conf->keylen, key_conf->key,
-                                         addr, 0, 0);
-                if (ret < 0) {
-                        wl1271_error("Could not remove key");
-                        goto out_sleep;
-                }
-                break;
-
-        default:
-                wl1271_error("Unsupported key cmd 0x%x", cmd);
-                ret = -EOPNOTSUPP;
-                break;
-        }
-
-out_sleep:
-        wl1271_ps_elp_sleep(wl);
-
-out_unlock:
-        mutex_unlock(&wl->mutex);
-
-out:
-        return ret;
-}
-
-static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
-                             struct ieee80211_vif *vif,
-                             struct cfg80211_scan_request *req)
-{
-        struct wl1271 *wl = hw->priv;
-        int ret;
-        u8 *ssid = NULL;
-        size_t len = 0;
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
-
-        if (req->n_ssids) {
-                ssid = req->ssids[0].ssid;
-                len = req->ssids[0].ssid_len;
-        }
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        if (wl1271_11a_enabled())
-                ret = wl1271_scan(hw->priv, ssid, len, req);
-        else
-                ret = wl1271_scan(hw->priv, ssid, len, req);
-
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
-{
-        struct wl1271 *wl = hw->priv;
-        int ret = 0;
-
-        mutex_lock(&wl->mutex);
-
-        if (unlikely(wl->state == WL1271_STATE_OFF))
-                goto out;
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1271_acx_rts_threshold(wl, (u16) value);
-        if (ret < 0)
-                wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
-
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
-{
-        u8 *ptr = beacon->data +
-                offsetof(struct ieee80211_mgmt, u.beacon.variable);
-
-        /* find the location of the ssid in the beacon */
-        while (ptr < beacon->data + beacon->len) {
-                if (ptr[0] == WLAN_EID_SSID) {
-                        wl->ssid_len = ptr[1];
-                        memcpy(wl->ssid, ptr+2, wl->ssid_len);
-                        return;
-                }
-                ptr += ptr[1];
-        }
-        wl1271_error("ad-hoc beacon template has no SSID!\n");
-}
-
-static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
-                                       struct ieee80211_vif *vif,
-                                       struct ieee80211_bss_conf *bss_conf,
-                                       u32 changed)
-{
-        enum wl1271_cmd_ps_mode mode;
-        struct wl1271 *wl = hw->priv;
-        bool do_join = false;
-        bool set_assoc = false;
-        int ret;
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        if ((changed && BSS_CHANGED_BEACON_INT) &&
-            (wl->bss_type == BSS_TYPE_IBSS)) {
-                wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
-                        bss_conf->beacon_int);
-
-                wl->beacon_int = bss_conf->beacon_int;
-                do_join = true;
-        }
-
-        if ((changed && BSS_CHANGED_BEACON) &&
-            (wl->bss_type == BSS_TYPE_IBSS)) {
-                struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
-
-                wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
-
-                if (beacon) {
-                        struct ieee80211_hdr *hdr;
-
-                        wl1271_ssid_set(wl, beacon);
-                        ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
-                                                      beacon->data,
-                                                      beacon->len, 0,
-                                                      wl1271_min_rate_get(wl));
-
-                        if (ret < 0) {
-                                dev_kfree_skb(beacon);
-                                goto out_sleep;
-                        }
-
-                        hdr = (struct ieee80211_hdr *) beacon->data;
-                        hdr->frame_control = cpu_to_le16(
-                                IEEE80211_FTYPE_MGMT |
-                                IEEE80211_STYPE_PROBE_RESP);
-
-                        ret = wl1271_cmd_template_set(wl,
-                                                      CMD_TEMPL_PROBE_RESPONSE,
-                                                      beacon->data,
-                                                      beacon->len, 0,
-                                                      wl1271_min_rate_get(wl));
-                        dev_kfree_skb(beacon);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        /* Need to update the SSID (for filtering etc) */
-                        do_join = true;
-                }
-        }
-
-        if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
-            (wl->bss_type == BSS_TYPE_IBSS)) {
-                wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
-                             bss_conf->enable_beacon ? "enabled" : "disabled");
-
-                if (bss_conf->enable_beacon)
-                        wl->set_bss_type = BSS_TYPE_IBSS;
-                else
-                        wl->set_bss_type = BSS_TYPE_STA_BSS;
-                do_join = true;
-        }
-
-        if (changed & BSS_CHANGED_CQM) {
-                bool enable = false;
-                if (bss_conf->cqm_rssi_thold)
-                        enable = true;
-                ret = wl1271_acx_rssi_snr_trigger(wl, enable,
-                                                  bss_conf->cqm_rssi_thold,
-                                                  bss_conf->cqm_rssi_hyst);
-                if (ret < 0)
-                        goto out;
-                wl->rssi_thold = bss_conf->cqm_rssi_thold;
-        }
-
-        if ((changed & BSS_CHANGED_BSSID) &&
-            /*
-             * Now we know the correct bssid, so we send a new join command
-             * and enable the BSSID filter
-             */
-            memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
-                        memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
-
-                        ret = wl1271_cmd_build_null_data(wl);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        ret = wl1271_build_qos_null_data(wl);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        /* filter out all packets not from this BSSID */
-                        wl1271_configure_filters(wl, 0);
-
-                        /* Need to update the BSSID (for filtering etc) */
-                        do_join = true;
-        }
-
-        if (changed & BSS_CHANGED_ASSOC) {
-                if (bss_conf->assoc) {
-                        u32 rates;
-                        wl->aid = bss_conf->aid;
-                        set_assoc = true;
-
-                        wl->ps_poll_failures = 0;
-
-                        /*
-                         * use basic rates from AP, and determine lowest rate
-                         * to use with control frames.
-                         */
-                        rates = bss_conf->basic_rates;
-                        wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
-                                                                         rates);
-                        wl->basic_rate = wl1271_min_rate_get(wl);
-                        ret = wl1271_acx_rate_policies(wl);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        /*
-                         * with wl1271, we don't need to update the
-                         * beacon_int and dtim_period, because the firmware
-                         * updates it by itself when the first beacon is
-                         * received after a join.
-                         */
-                        ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        /*
-                         * The SSID is intentionally set to NULL here - the
-                         * firmware will set the probe request with a
-                         * broadcast SSID regardless of what we set in the
-                         * template.
-                         */
-                        ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
-                                                         NULL, 0, wl->band);
-
-                        /* enable the connection monitoring feature */
-                        ret = wl1271_acx_conn_monit_params(wl, true);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        /* If we want to go in PSM but we're not there yet */
-                        if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
-                            !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
-                                mode = STATION_POWER_SAVE_MODE;
-                                ret = wl1271_ps_set_mode(wl, mode, true);
-                                if (ret < 0)
-                                        goto out_sleep;
-                        }
-                } else {
-                        /* use defaults when not associated */
-                        clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
-                        wl->aid = 0;
-
-                        /* re-enable dynamic ps - just in case */
-                        ieee80211_enable_dyn_ps(wl->vif);
-
-                        /* revert back to minimum rates for the current band */
-                        wl1271_set_band_rate(wl);
-                        wl->basic_rate = wl1271_min_rate_get(wl);
-                        ret = wl1271_acx_rate_policies(wl);
-                        if (ret < 0)
-                                goto out_sleep;
-
-                        /* disable connection monitor features */
-                        ret = wl1271_acx_conn_monit_params(wl, false);
-
-                        /* Disable the keep-alive feature */
-                        ret = wl1271_acx_keep_alive_mode(wl, false);
-
-                        if (ret < 0)
-                                goto out_sleep;
-                }
-
-        }
-
-        if (changed & BSS_CHANGED_ERP_SLOT) {
-                if (bss_conf->use_short_slot)
-                        ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
-                else
-                        ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
-                if (ret < 0) {
-                        wl1271_warning("Set slot time failed %d", ret);
-                        goto out_sleep;
-                }
-        }
-
-        if (changed & BSS_CHANGED_ERP_PREAMBLE) {
-                if (bss_conf->use_short_preamble)
-                        wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
-                else
-                        wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
-        }
-
-        if (changed & BSS_CHANGED_ERP_CTS_PROT) {
-                if (bss_conf->use_cts_prot)
-                        ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
-                else
-                        ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
-                if (ret < 0) {
-                        wl1271_warning("Set ctsprotect failed %d", ret);
-                        goto out_sleep;
-                }
-        }
-
-        if (changed & BSS_CHANGED_ARP_FILTER) {
-                __be32 addr = bss_conf->arp_addr_list[0];
-                WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
-
-                if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
-                        ret = wl1271_acx_arp_ip_filter(wl, true, addr);
-                else
-                        ret = wl1271_acx_arp_ip_filter(wl, false, addr);
-
-                if (ret < 0)
-                        goto out_sleep;
-        }
-
-        if (do_join) {
-                ret = wl1271_join(wl, set_assoc);
-                if (ret < 0) {
-                        wl1271_warning("cmd join failed %d", ret);
-                        goto out_sleep;
-                }
-        }
-
-out_sleep:
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-}
-
-static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
-                             const struct ieee80211_tx_queue_params *params)
-{
-        struct wl1271 *wl = hw->priv;
-        u8 ps_scheme;
-        int ret;
-
-        mutex_lock(&wl->mutex);
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        /* the txop is confed in units of 32us by the mac80211, we need us */
-        ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
-                                params->cw_min, params->cw_max,
-                                params->aifs, params->txop << 5);
-        if (ret < 0)
-                goto out_sleep;
-
-        if (params->uapsd)
-                ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
-        else
-                ps_scheme = CONF_PS_SCHEME_LEGACY;
-
-        ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
-                                 CONF_CHANNEL_TYPE_EDCF,
-                                 wl1271_tx_get_queue(queue),
-                                 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
-        if (ret < 0)
-                goto out_sleep;
-
-out_sleep:
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
-static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
-{
-
-        struct wl1271 *wl = hw->priv;
-        u64 mactime = ULLONG_MAX;
-        int ret;
-
-        wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
-
-        mutex_lock(&wl->mutex);
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        ret = wl1271_acx_tsf_info(wl, &mactime);
-        if (ret < 0)
-                goto out_sleep;
-
-out_sleep:
-        wl1271_ps_elp_sleep(wl);
-
-out:
-        mutex_unlock(&wl->mutex);
-        return mactime;
-}
-
-static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
-                                struct survey_info *survey)
-{
-        struct wl1271 *wl = hw->priv;
-        struct ieee80211_conf *conf = &hw->conf;
- 
-        if (idx != 0)
-                return -ENOENT;
- 
-        survey->channel = conf->channel;
-        survey->filled = SURVEY_INFO_NOISE_DBM;
-        survey->noise = wl->noise;
- 
-        return 0;
-}
-
-/* can't be const, mac80211 writes to this */
-static struct ieee80211_rate wl1271_rates[] = {
-        { .bitrate = 10,
-          .hw_value = CONF_HW_BIT_RATE_1MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
-        { .bitrate = 20,
-          .hw_value = CONF_HW_BIT_RATE_2MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
-          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
-        { .bitrate = 55,
-          .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
-          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
-        { .bitrate = 110,
-          .hw_value = CONF_HW_BIT_RATE_11MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
-          .flags = IEEE80211_RATE_SHORT_PREAMBLE },
-        { .bitrate = 60,
-          .hw_value = CONF_HW_BIT_RATE_6MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
-        { .bitrate = 90,
-          .hw_value = CONF_HW_BIT_RATE_9MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
-        { .bitrate = 120,
-          .hw_value = CONF_HW_BIT_RATE_12MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
-        { .bitrate = 180,
-          .hw_value = CONF_HW_BIT_RATE_18MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
-        { .bitrate = 240,
-          .hw_value = CONF_HW_BIT_RATE_24MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
-        { .bitrate = 360,
-         .hw_value = CONF_HW_BIT_RATE_36MBPS,
-         .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
-        { .bitrate = 480,
-          .hw_value = CONF_HW_BIT_RATE_48MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
-        { .bitrate = 540,
-          .hw_value = CONF_HW_BIT_RATE_54MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
-};
-
-/* can't be const, mac80211 writes to this */
-static struct ieee80211_channel wl1271_channels[] = {
-        { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
-        { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
-        { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
-        { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
-        { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
-        { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
-        { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
-        { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
-        { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
-        { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
-        { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
-        { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
-        { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
-};
-
-/* mapping to indexes for wl1271_rates */
-static const u8 wl1271_rate_to_idx_2ghz[] = {
-        /* MCS rates are used only with 11n */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
-
-        11,                            /* CONF_HW_RXTX_RATE_54   */
-        10,                            /* CONF_HW_RXTX_RATE_48   */
-        9,                             /* CONF_HW_RXTX_RATE_36   */
-        8,                             /* CONF_HW_RXTX_RATE_24   */
-
-        /* TI-specific rate */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
-
-        7,                             /* CONF_HW_RXTX_RATE_18   */
-        6,                             /* CONF_HW_RXTX_RATE_12   */
-        3,                             /* CONF_HW_RXTX_RATE_11   */
-        5,                             /* CONF_HW_RXTX_RATE_9    */
-        4,                             /* CONF_HW_RXTX_RATE_6    */
-        2,                             /* CONF_HW_RXTX_RATE_5_5  */
-        1,                             /* CONF_HW_RXTX_RATE_2    */
-        0                              /* CONF_HW_RXTX_RATE_1    */
-};
-
-/* can't be const, mac80211 writes to this */
-static struct ieee80211_supported_band wl1271_band_2ghz = {
-        .channels = wl1271_channels,
-        .n_channels = ARRAY_SIZE(wl1271_channels),
-        .bitrates = wl1271_rates,
-        .n_bitrates = ARRAY_SIZE(wl1271_rates),
-};
-
-/* 5 GHz data rates for WL1273 */
-static struct ieee80211_rate wl1271_rates_5ghz[] = {
-        { .bitrate = 60,
-          .hw_value = CONF_HW_BIT_RATE_6MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
-        { .bitrate = 90,
-          .hw_value = CONF_HW_BIT_RATE_9MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
-        { .bitrate = 120,
-          .hw_value = CONF_HW_BIT_RATE_12MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
-        { .bitrate = 180,
-          .hw_value = CONF_HW_BIT_RATE_18MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
-        { .bitrate = 240,
-          .hw_value = CONF_HW_BIT_RATE_24MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
-        { .bitrate = 360,
-         .hw_value = CONF_HW_BIT_RATE_36MBPS,
-         .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
-        { .bitrate = 480,
-          .hw_value = CONF_HW_BIT_RATE_48MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
-        { .bitrate = 540,
-          .hw_value = CONF_HW_BIT_RATE_54MBPS,
-          .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
-};
-
-/* 5 GHz band channels for WL1273 */
-static struct ieee80211_channel wl1271_channels_5ghz[] = {
-        { .hw_value = 183, .center_freq = 4915},
-        { .hw_value = 184, .center_freq = 4920},
-        { .hw_value = 185, .center_freq = 4925},
-        { .hw_value = 187, .center_freq = 4935},
-        { .hw_value = 188, .center_freq = 4940},
-        { .hw_value = 189, .center_freq = 4945},
-        { .hw_value = 192, .center_freq = 4960},
-        { .hw_value = 196, .center_freq = 4980},
-        { .hw_value = 7, .center_freq = 5035},
-        { .hw_value = 8, .center_freq = 5040},
-        { .hw_value = 9, .center_freq = 5045},
-        { .hw_value = 11, .center_freq = 5055},
-        { .hw_value = 12, .center_freq = 5060},
-        { .hw_value = 16, .center_freq = 5080},
-        { .hw_value = 34, .center_freq = 5170},
-        { .hw_value = 36, .center_freq = 5180},
-        { .hw_value = 38, .center_freq = 5190},
-        { .hw_value = 40, .center_freq = 5200},
-        { .hw_value = 42, .center_freq = 5210},
-        { .hw_value = 44, .center_freq = 5220},
-        { .hw_value = 46, .center_freq = 5230},
-        { .hw_value = 48, .center_freq = 5240},
-        { .hw_value = 52, .center_freq = 5260},
-        { .hw_value = 56, .center_freq = 5280},
-        { .hw_value = 60, .center_freq = 5300},
-        { .hw_value = 64, .center_freq = 5320},
-        { .hw_value = 100, .center_freq = 5500},
-        { .hw_value = 104, .center_freq = 5520},
-        { .hw_value = 108, .center_freq = 5540},
-        { .hw_value = 112, .center_freq = 5560},
-        { .hw_value = 116, .center_freq = 5580},
-        { .hw_value = 120, .center_freq = 5600},
-        { .hw_value = 124, .center_freq = 5620},
-        { .hw_value = 128, .center_freq = 5640},
-        { .hw_value = 132, .center_freq = 5660},
-        { .hw_value = 136, .center_freq = 5680},
-        { .hw_value = 140, .center_freq = 5700},
-        { .hw_value = 149, .center_freq = 5745},
-        { .hw_value = 153, .center_freq = 5765},
-        { .hw_value = 157, .center_freq = 5785},
-        { .hw_value = 161, .center_freq = 5805},
-        { .hw_value = 165, .center_freq = 5825},
-};
-
-/* mapping to indexes for wl1271_rates_5ghz */
-static const u8 wl1271_rate_to_idx_5ghz[] = {
-        /* MCS rates are used only with 11n */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
-
-        7,                             /* CONF_HW_RXTX_RATE_54   */
-        6,                             /* CONF_HW_RXTX_RATE_48   */
-        5,                             /* CONF_HW_RXTX_RATE_36   */
-        4,                             /* CONF_HW_RXTX_RATE_24   */
-
-        /* TI-specific rate */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
-
-        3,                             /* CONF_HW_RXTX_RATE_18   */
-        2,                             /* CONF_HW_RXTX_RATE_12   */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
-        1,                             /* CONF_HW_RXTX_RATE_9    */
-        0,                             /* CONF_HW_RXTX_RATE_6    */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
-        CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
-        CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
-};
-
-static struct ieee80211_supported_band wl1271_band_5ghz = {
-        .channels = wl1271_channels_5ghz,
-        .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
-        .bitrates = wl1271_rates_5ghz,
-        .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
-};
-
-static const u8 *wl1271_band_rate_to_idx[] = {
-        [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
-        [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
-};
-
-static const struct ieee80211_ops wl1271_ops = {
-        .start = wl1271_op_start,
-        .stop = wl1271_op_stop,
-        .add_interface = wl1271_op_add_interface,
-        .remove_interface = wl1271_op_remove_interface,
-        .config = wl1271_op_config,
-        .prepare_multicast = wl1271_op_prepare_multicast,
-        .configure_filter = wl1271_op_configure_filter,
-        .tx = wl1271_op_tx,
-        .set_key = wl1271_op_set_key,
-        .hw_scan = wl1271_op_hw_scan,
-        .bss_info_changed = wl1271_op_bss_info_changed,
-        .set_rts_threshold = wl1271_op_set_rts_threshold,
-        .conf_tx = wl1271_op_conf_tx,
-        .get_tsf = wl1271_op_get_tsf,
-        .get_survey = wl1271_op_get_survey,
-        CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
-};
-
-
-u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
-{
-        u8 idx;
-
-        BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
-
-        if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
-                wl1271_error("Illegal RX rate from HW: %d", rate);
-                return 0;
-        }
-
-        idx = wl1271_band_rate_to_idx[wl->band][rate];
-        if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
-                wl1271_error("Unsupported RX rate from HW: %d", rate);
-                return 0;
-        }
-
-        return idx;
-}
-
-static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
-                                               struct device_attribute *attr,
-                                               char *buf)
-{
-        struct wl1271 *wl = dev_get_drvdata(dev);
-        ssize_t len;
-
-        /* FIXME: what's the maximum length of buf? page size?*/
-        len = 500;
-
-        mutex_lock(&wl->mutex);
-        len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
-                       wl->sg_enabled);
-        mutex_unlock(&wl->mutex);
-
-        return len;
-
-}
-
-static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
-                                                struct device_attribute *attr,
-                                                const char *buf, size_t count)
-{
-        struct wl1271 *wl = dev_get_drvdata(dev);
-        unsigned long res;
-        int ret;
-
-        ret = strict_strtoul(buf, 10, &res);
-
-        if (ret < 0) {
-                wl1271_warning("incorrect value written to bt_coex_mode");
-                return count;
-        }
-
-        mutex_lock(&wl->mutex);
-
-        res = !!res;
-
-        if (res == wl->sg_enabled)
-                goto out;
-
-        wl->sg_enabled = res;
-
-        if (wl->state == WL1271_STATE_OFF)
-                goto out;
-
-        ret = wl1271_ps_elp_wakeup(wl, false);
-        if (ret < 0)
-                goto out;
-
-        wl1271_acx_sg_enable(wl, wl->sg_enabled);
-        wl1271_ps_elp_sleep(wl);
-
- out:
-        mutex_unlock(&wl->mutex);
-        return count;
-}
-
-static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
-                   wl1271_sysfs_show_bt_coex_state,
-                   wl1271_sysfs_store_bt_coex_state);
-
-static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
-                                           struct device_attribute *attr,
-                                           char *buf)
-{
-        struct wl1271 *wl = dev_get_drvdata(dev);
-        ssize_t len;
-
-        /* FIXME: what's the maximum length of buf? page size?*/
-        len = 500;
-
-        mutex_lock(&wl->mutex);
-        if (wl->hw_pg_ver >= 0)
-                len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
-        else
-                len = snprintf(buf, len, "n/a\n");
-        mutex_unlock(&wl->mutex);
-
-        return len;
-}
-
-static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
-                   wl1271_sysfs_show_hw_pg_ver, NULL);
-
-int wl1271_register_hw(struct wl1271 *wl)
-{
-        int ret;
-
-        if (wl->mac80211_registered)
-                return 0;
-
-        SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
-
-        ret = ieee80211_register_hw(wl->hw);
-        if (ret < 0) {
-                wl1271_error("unable to register mac80211 hw: %d", ret);
-                return ret;
-        }
-
-        wl->mac80211_registered = true;
-
-        wl1271_notice("loaded");
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(wl1271_register_hw);
-
-void wl1271_unregister_hw(struct wl1271 *wl)
-{
-        ieee80211_unregister_hw(wl->hw);
-        wl->mac80211_registered = false;
-
-}
-EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
-
-int wl1271_init_ieee80211(struct wl1271 *wl)
-{
-        /* The tx descriptor buffer and the TKIP space. */
-        wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
-                sizeof(struct wl1271_tx_hw_descr);
-
-        /* unit us */
-        /* FIXME: find a proper value */
-        wl->hw->channel_change_time = 10000;
-        wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
-
-        wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
-                IEEE80211_HW_BEACON_FILTER |
-                IEEE80211_HW_SUPPORTS_PS |
-                IEEE80211_HW_SUPPORTS_UAPSD |
-                IEEE80211_HW_HAS_RATE_CONTROL |
-                IEEE80211_HW_CONNECTION_MONITOR |
-                IEEE80211_HW_SUPPORTS_CQM_RSSI;
-
-        wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
-                BIT(NL80211_IFTYPE_ADHOC);
-        wl->hw->wiphy->max_scan_ssids = 1;
-        wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
-
-        if (wl1271_11a_enabled())
-                wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
-
-        wl->hw->queues = 4;
-        wl->hw->max_rates = 1;
-
-        SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
-
-#define WL1271_DEFAULT_CHANNEL 0
-
-struct ieee80211_hw *wl1271_alloc_hw(void)
-{
-        struct ieee80211_hw *hw;
-        struct platform_device *plat_dev = NULL;
-        struct wl1271 *wl;
-        int i, ret;
-
-        hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
-        if (!hw) {
-                wl1271_error("could not alloc ieee80211_hw");
-                ret = -ENOMEM;
-                goto err_hw_alloc;
-        }
-
-        plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
-        if (!plat_dev) {
-                wl1271_error("could not allocate platform_device");
-                ret = -ENOMEM;
-                goto err_plat_alloc;
-        }
-
-        wl = hw->priv;
-        memset(wl, 0, sizeof(*wl));
-
-        INIT_LIST_HEAD(&wl->list);
-
-        wl->hw = hw;
-        wl->plat_dev = plat_dev;
-
-        skb_queue_head_init(&wl->tx_queue);
-
-        INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
-        INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
-        wl->channel = WL1271_DEFAULT_CHANNEL;
-        wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
-        wl->default_key = 0;
-        wl->rx_counter = 0;
-        wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
-        wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
-        wl->psm_entry_retry = 0;
-        wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
-        wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
-        wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
-        wl->rate_set = CONF_TX_RATE_MASK_BASIC;
-        wl->sta_rate_set = 0;
-        wl->band = IEEE80211_BAND_2GHZ;
-        wl->vif = NULL;
-        wl->flags = 0;
-        wl->sg_enabled = true;
-        wl->hw_pg_ver = -1;
-
-        for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
-                wl->tx_frames[i] = NULL;
-
-        spin_lock_init(&wl->wl_lock);
-
-        wl->state = WL1271_STATE_OFF;
-        mutex_init(&wl->mutex);
-
-        /* Apply default driver configuration. */
-        wl1271_conf_init(wl);
-
-        wl1271_debugfs_init(wl);
-
-        /* Register platform device */
-        ret = platform_device_register(wl->plat_dev);
-        if (ret) {
-                wl1271_error("couldn't register platform device");
-                goto err_hw;
-        }
-        dev_set_drvdata(&wl->plat_dev->dev, wl);
-
-        /* Create sysfs file to control bt coex state */
-        ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
-        if (ret < 0) {
-                wl1271_error("failed to create sysfs file bt_coex_state");
-                goto err_platform;
-        }
-
-        /* Create sysfs file to get HW PG version */
-        ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
-        if (ret < 0) {
-                wl1271_error("failed to create sysfs file hw_pg_ver");
-                goto err_bt_coex_state;
-        }
-
-        return hw;
-
-err_bt_coex_state:
-        device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
-
-err_platform:
-        platform_device_unregister(wl->plat_dev);
-
-err_hw:
-        wl1271_debugfs_exit(wl);
-        kfree(plat_dev);
-
-err_plat_alloc:
-        ieee80211_free_hw(hw);
-
-err_hw_alloc:
-
-        return ERR_PTR(ret);
-}
-EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
-
-int wl1271_free_hw(struct wl1271 *wl)
-{
-        platform_device_unregister(wl->plat_dev);
-        kfree(wl->plat_dev);
-
-        wl1271_debugfs_exit(wl);
-
-        vfree(wl->fw);
-        wl->fw = NULL;
-        kfree(wl->nvs);
-        wl->nvs = NULL;
-
-        kfree(wl->fw_status);
-        kfree(wl->tx_res_if);
-
-        ieee80211_free_hw(wl->hw);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(wl1271_free_hw);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
-MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
diff --git a/drivers/net/wireless/wl12xx/wl1271_rx.c b/drivers/net/wireless/wl12xx/wl1271_rx.c
deleted file mode 100644
index 019aa79cd9df..000000000000
--- a/drivers/net/wireless/wl12xx/wl1271_rx.c
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * This file is part of wl1271
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Luciano Coelho <luciano.coelho@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/gfp.h>
-
-#include "wl1271.h"
-#include "wl1271_acx.h"
-#include "wl1271_reg.h"
-#include "wl1271_rx.h"
-#include "wl1271_io.h"
-
-static u8 wl1271_rx_get_mem_block(struct wl1271_fw_status *status,
-                                  u32 drv_rx_counter)
-{
-        return le32_to_cpu(status->rx_pkt_descs[drv_rx_counter]) &
-                RX_MEM_BLOCK_MASK;
-}
-
-static u32 wl1271_rx_get_buf_size(struct wl1271_fw_status *status,
-                                 u32 drv_rx_counter)
-{
-        return (le32_to_cpu(status->rx_pkt_descs[drv_rx_counter]) &
-                RX_BUF_SIZE_MASK) >> RX_BUF_SIZE_SHIFT_DIV;
-}
-
-static void wl1271_rx_status(struct wl1271 *wl,
-                             struct wl1271_rx_descriptor *desc,
-                             struct ieee80211_rx_status *status,
-                             u8 beacon)
-{
-        memset(status, 0, sizeof(struct ieee80211_rx_status));
-
-        status->band = wl->band;
-        status->rate_idx = wl1271_rate_to_idx(wl, desc->rate);
-
-        status->signal = desc->rssi;
-
-        /*
-         * FIXME: In wl1251, the SNR should be divided by two.  In wl1271 we
-         * need to divide by two for now, but TI has been discussing about
-         * changing it.  This needs to be rechecked.
-         */
-        wl->noise = desc->rssi - (desc->snr >> 1);
-
-        status->freq = ieee80211_channel_to_frequency(desc->channel);
-
-        if (desc->flags & WL1271_RX_DESC_ENCRYPT_MASK) {
-                status->flag |= RX_FLAG_IV_STRIPPED | RX_FLAG_MMIC_STRIPPED;
-
-                if (likely(!(desc->status & WL1271_RX_DESC_DECRYPT_FAIL)))
-                        status->flag |= RX_FLAG_DECRYPTED;
-                if (unlikely(desc->status & WL1271_RX_DESC_MIC_FAIL))
-                        status->flag |= RX_FLAG_MMIC_ERROR;
-        }
-}
-
-static void wl1271_rx_handle_data(struct wl1271 *wl, u32 length)
-{
-        struct ieee80211_rx_status rx_status;
-        struct wl1271_rx_descriptor *desc;
-        struct sk_buff *skb;
-        u16 *fc;
-        u8 *buf;
-        u8 beacon = 0;
-
-        /*
-         * In PLT mode we seem to get frames and mac80211 warns about them,
-         * workaround this by not retrieving them at all.
-         */
-        if (unlikely(wl->state == WL1271_STATE_PLT))
-                return;
-
-        skb = __dev_alloc_skb(length, GFP_KERNEL);
-        if (!skb) {
-                wl1271_error("Couldn't allocate RX frame");
-                return;
-        }
-
-        buf = skb_put(skb, length);
-        wl1271_read(wl, WL1271_SLV_MEM_DATA, buf, length, true);
-
-        /* the data read starts with the descriptor */
-        desc = (struct wl1271_rx_descriptor *) buf;
-
-        /* now we pull the descriptor out of the buffer */
-        skb_pull(skb, sizeof(*desc));
-
-        fc = (u16 *)skb->data;
-        if ((*fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_BEACON)
-                beacon = 1;
-
-        wl1271_rx_status(wl, desc, &rx_status, beacon);
-
-        wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
-                     beacon ? "beacon" : "");
-
-        skb_trim(skb, skb->len - desc->pad_len);
-
-        memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
-        ieee80211_rx_ni(wl->hw, skb);
-}
-
-void wl1271_rx(struct wl1271 *wl, struct wl1271_fw_status *status)
-{
-        struct wl1271_acx_mem_map *wl_mem_map = wl->target_mem_map;
-        u32 buf_size;
-        u32 fw_rx_counter  = status->fw_rx_counter & NUM_RX_PKT_DESC_MOD_MASK;
-        u32 drv_rx_counter = wl->rx_counter & NUM_RX_PKT_DESC_MOD_MASK;
-        u32 mem_block;
-
-        while (drv_rx_counter != fw_rx_counter) {
-                mem_block = wl1271_rx_get_mem_block(status, drv_rx_counter);
-                buf_size = wl1271_rx_get_buf_size(status, drv_rx_counter);
-
-                if (buf_size == 0) {
-                        wl1271_warning("received empty data");
-                        break;
-                }
-
-                wl->rx_mem_pool_addr.addr = (mem_block << 8) +
-                        le32_to_cpu(wl_mem_map->packet_memory_pool_start);
-                wl->rx_mem_pool_addr.addr_extra =
-                        wl->rx_mem_pool_addr.addr + 4;
-
-                /* Choose the block we want to read */
-                wl1271_write(wl, WL1271_SLV_REG_DATA, &wl->rx_mem_pool_addr,
-                             sizeof(wl->rx_mem_pool_addr), false);
-
-                wl1271_rx_handle_data(wl, buf_size);
-
-                wl->rx_counter++;
-                drv_rx_counter = wl->rx_counter & NUM_RX_PKT_DESC_MOD_MASK;
-        }
-
-        wl1271_write32(wl, RX_DRIVER_COUNTER_ADDRESS, wl->rx_counter);
-}
diff --git a/drivers/net/wireless/wl12xx/wl1271_scan.c b/drivers/net/wireless/wl12xx/wl1271_scan.c
deleted file mode 100644
index fec43eed8c55..000000000000
--- a/drivers/net/wireless/wl12xx/wl1271_scan.c
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * This file is part of wl1271
- *
- * Copyright (C) 2009-2010 Nokia Corporation
- *
- * Contact: Luciano Coelho <luciano.coelho@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/ieee80211.h>
-
-#include "wl1271.h"
-#include "wl1271_cmd.h"
-#include "wl1271_scan.h"
-#include "wl1271_acx.h"
-
-static int wl1271_get_scan_channels(struct wl1271 *wl,
-                                    struct cfg80211_scan_request *req,
-                                    struct basic_scan_channel_params *channels,
-                                    enum ieee80211_band band, bool passive)
-{
-        int i, j;
-        u32 flags;
-
-        for (i = 0, j = 0;
-             i < req->n_channels && j < WL1271_SCAN_MAX_CHANNELS;
-             i++) {
-
-                flags = req->channels[i]->flags;
-
-                if (!wl->scan.scanned_ch[i] &&
-                    !(flags & IEEE80211_CHAN_DISABLED) &&
-                    ((!!(flags & IEEE80211_CHAN_PASSIVE_SCAN)) == passive) &&
-                    (req->channels[i]->band == band)) {
-
-                        wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
-                                     req->channels[i]->band,
-                                     req->channels[i]->center_freq);
-                        wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
-                                     req->channels[i]->hw_value,
-                                     req->channels[i]->flags);
-                        wl1271_debug(DEBUG_SCAN,
-                                     "max_antenna_gain %d, max_power %d",
-                                     req->channels[i]->max_antenna_gain,
-                                     req->channels[i]->max_power);
-                        wl1271_debug(DEBUG_SCAN, "beacon_found %d",
-                                     req->channels[i]->beacon_found);
-
-                        channels[j].min_duration =
-                                cpu_to_le32(WL1271_SCAN_CHAN_MIN_DURATION);
-                        channels[j].max_duration =
-                                cpu_to_le32(WL1271_SCAN_CHAN_MAX_DURATION);
-                        channels[j].early_termination = 0;
-                        channels[j].tx_power_att = req->channels[i]->max_power;
-                        channels[j].channel = req->channels[i]->hw_value;
-
-                        memset(&channels[j].bssid_lsb, 0xff, 4);
-                        memset(&channels[j].bssid_msb, 0xff, 2);
-
-                        /* Mark the channels we already used */
-                        wl->scan.scanned_ch[i] = true;
-
-                        j++;
-                }
-        }
-
-        return j;
-}
-
-#define WL1271_NOTHING_TO_SCAN 1
-
-static int wl1271_scan_send(struct wl1271 *wl, enum ieee80211_band band,
-                             bool passive, u32 basic_rate)
-{
-        struct wl1271_cmd_scan *cmd;
-        struct wl1271_cmd_trigger_scan_to *trigger;
-        int ret;
-        u16 scan_options = 0;
-
-        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
-        trigger = kzalloc(sizeof(*trigger), GFP_KERNEL);
-        if (!cmd || !trigger) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* We always use high priority scans */
-        scan_options = WL1271_SCAN_OPT_PRIORITY_HIGH;
-        if(passive)
-                scan_options |= WL1271_SCAN_OPT_PASSIVE;
-        cmd->params.scan_options = cpu_to_le16(scan_options);
-
-        cmd->params.n_ch = wl1271_get_scan_channels(wl, wl->scan.req,
-                                                    cmd->channels,
-                                                    band, passive);
-        if (cmd->params.n_ch == 0) {
-                ret = WL1271_NOTHING_TO_SCAN;
-                goto out;
-        }
-
-        cmd->params.tx_rate = cpu_to_le32(basic_rate);
-        cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
-        cmd->params.rx_filter_options =
-                cpu_to_le32(CFG_RX_PRSP_EN | CFG_RX_MGMT_EN | CFG_RX_BCN_EN);
-
-        cmd->params.n_probe_reqs = WL1271_SCAN_PROBE_REQS;
-        cmd->params.tx_rate = cpu_to_le32(basic_rate);
-        cmd->params.tid_trigger = 0;
-        cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG;
-
-        if (band == IEEE80211_BAND_2GHZ)
-                cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ;
-        else
-                cmd->params.band = WL1271_SCAN_BAND_5_GHZ;
-
-        if (wl->scan.ssid_len && wl->scan.ssid) {
-                cmd->params.ssid_len = wl->scan.ssid_len;
-                memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len);
-        }
-
-        ret = wl1271_cmd_build_probe_req(wl, wl->scan.ssid, wl->scan.ssid_len,
-                                         wl->scan.req->ie, wl->scan.req->ie_len,
-                                         band);
-        if (ret < 0) {
-                wl1271_error("PROBE request template failed");
-                goto out;
-        }
-
-        /* disable the timeout */
-        trigger->timeout = 0;
-        ret = wl1271_cmd_send(wl, CMD_TRIGGER_SCAN_TO, trigger,
-                              sizeof(*trigger), 0);
-        if (ret < 0) {
-                wl1271_error("trigger scan to failed for hw scan");
-                goto out;
-        }
-
-        wl1271_dump(DEBUG_SCAN, "SCAN: ", cmd, sizeof(*cmd));
-
-        ret = wl1271_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd), 0);
-        if (ret < 0) {
-                wl1271_error("SCAN failed");
-                goto out;
-        }
-
-out:
-        kfree(cmd);
-        kfree(trigger);
-        return ret;
-}
-
-void wl1271_scan_stm(struct wl1271 *wl)
-{
-        int ret;
-
-        switch (wl->scan.state) {
-        case WL1271_SCAN_STATE_IDLE:
-                break;
-
-        case WL1271_SCAN_STATE_2GHZ_ACTIVE:
-                ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, false,
-                                       wl->conf.tx.basic_rate);
-                if (ret == WL1271_NOTHING_TO_SCAN) {
-                        wl->scan.state = WL1271_SCAN_STATE_2GHZ_PASSIVE;
-                        wl1271_scan_stm(wl);
-                }
-
-                break;
-
-        case WL1271_SCAN_STATE_2GHZ_PASSIVE:
-                ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, true,
-                                       wl->conf.tx.basic_rate);
-                if (ret == WL1271_NOTHING_TO_SCAN) {
-                        if (wl1271_11a_enabled())
-                                wl->scan.state = WL1271_SCAN_STATE_5GHZ_ACTIVE;
-                        else
-                                wl->scan.state = WL1271_SCAN_STATE_DONE;
-                        wl1271_scan_stm(wl);
-                }
-
-                break;
-
-        case WL1271_SCAN_STATE_5GHZ_ACTIVE:
-                ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, false,
-                                       wl->conf.tx.basic_rate_5);
-                if (ret == WL1271_NOTHING_TO_SCAN) {
-                        wl->scan.state = WL1271_SCAN_STATE_5GHZ_PASSIVE;
-                        wl1271_scan_stm(wl);
-                }
-
-                break;
-
-        case WL1271_SCAN_STATE_5GHZ_PASSIVE:
-                ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, true,
-                                       wl->conf.tx.basic_rate_5);
-                if (ret == WL1271_NOTHING_TO_SCAN) {
-                        wl->scan.state = WL1271_SCAN_STATE_DONE;
-                        wl1271_scan_stm(wl);
-                }
-
-                break;
-
-        case WL1271_SCAN_STATE_DONE:
-                mutex_unlock(&wl->mutex);
-                ieee80211_scan_completed(wl->hw, false);
-                mutex_lock(&wl->mutex);
-
-                kfree(wl->scan.scanned_ch);
-                wl->scan.scanned_ch = NULL;
-
-                wl->scan.state = WL1271_SCAN_STATE_IDLE;
-                break;
-
-        default:
-                wl1271_error("invalid scan state");
-                break;
-        }
-}
-
-int wl1271_scan(struct wl1271 *wl, const u8 *ssid, size_t ssid_len,
-                struct cfg80211_scan_request *req)
-{
-        if (wl->scan.state != WL1271_SCAN_STATE_IDLE)
-                return -EBUSY;
-
-        wl->scan.state = WL1271_SCAN_STATE_2GHZ_ACTIVE;
-
-        if (ssid_len && ssid) {
-                wl->scan.ssid_len = ssid_len;
-                memcpy(wl->scan.ssid, ssid, ssid_len);
-        } else {
-                wl->scan.ssid_len = 0;
-        }
-
-        wl->scan.req = req;
-
-        wl->scan.scanned_ch = kzalloc(req->n_channels *
-                                      sizeof(*wl->scan.scanned_ch),
-                                      GFP_KERNEL);
-        wl1271_scan_stm(wl);
-
-        return 0;
-}
diff --git a/drivers/net/wireless/wl12xx/wl1271_tx.c b/drivers/net/wireless/wl12xx/wl1271_tx.c
deleted file mode 100644
index c592cc2e9fe8..000000000000
--- a/drivers/net/wireless/wl12xx/wl1271_tx.c
+++ /dev/null
@@ -1,464 +0,0 @@
-/*
- * This file is part of wl1271
- *
- * Copyright (C) 2009 Nokia Corporation
- *
- * Contact: Luciano Coelho <luciano.coelho@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-
-#include "wl1271.h"
-#include "wl1271_io.h"
-#include "wl1271_reg.h"
-#include "wl1271_ps.h"
-#include "wl1271_tx.h"
-
-static int wl1271_tx_id(struct wl1271 *wl, struct sk_buff *skb)
-{
-        int i;
-        for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
-                if (wl->tx_frames[i] == NULL) {
-                        wl->tx_frames[i] = skb;
-                        wl->tx_frames_cnt++;
-                        return i;
-                }
-
-        return -EBUSY;
-}
-
-static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra)
-{
-        struct wl1271_tx_hw_descr *desc;
-        u32 total_len = skb->len + sizeof(struct wl1271_tx_hw_descr) + extra;
-        u32 total_blocks;
-        int id, ret = -EBUSY;
-
-        /* allocate free identifier for the packet */
-        id = wl1271_tx_id(wl, skb);
-        if (id < 0)
-                return id;
-
-        /* approximate the number of blocks required for this packet
-           in the firmware */
-        total_blocks = total_len + TX_HW_BLOCK_SIZE - 1;
-        total_blocks = total_blocks / TX_HW_BLOCK_SIZE + TX_HW_BLOCK_SPARE;
-        if (total_blocks <= wl->tx_blocks_available) {
-                desc = (struct wl1271_tx_hw_descr *)skb_push(
-                        skb, total_len - skb->len);
-
-                desc->extra_mem_blocks = TX_HW_BLOCK_SPARE;
-                desc->total_mem_blocks = total_blocks;
-                desc->id = id;
-
-                wl->tx_blocks_available -= total_blocks;
-
-                ret = 0;
-
-                wl1271_debug(DEBUG_TX,
-                             "tx_allocate: size: %d, blocks: %d, id: %d",
-                             total_len, total_blocks, id);
-        } else {
-                wl->tx_frames[id] = NULL;
-                wl->tx_frames_cnt--;
-        }
-
-        return ret;
-}
-
-static int wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
-                              u32 extra, struct ieee80211_tx_info *control)
-{
-        struct timespec ts;
-        struct wl1271_tx_hw_descr *desc;
-        int pad, ac;
-        s64 hosttime;
-        u16 tx_attr;
-
-        desc = (struct wl1271_tx_hw_descr *) skb->data;
-
-        /* relocate space for security header */
-        if (extra) {
-                void *framestart = skb->data + sizeof(*desc);
-                u16 fc = *(u16 *)(framestart + extra);
-                int hdrlen = ieee80211_hdrlen(cpu_to_le16(fc));
-                memmove(framestart, framestart + extra, hdrlen);
-        }
-
-        /* configure packet life time */
-        getnstimeofday(&ts);
-        hosttime = (timespec_to_ns(&ts) >> 10);
-        desc->start_time = cpu_to_le32(hosttime - wl->time_offset);
-        desc->life_time = cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU);
-
-        /* configure the tx attributes */
-        tx_attr = wl->session_counter << TX_HW_ATTR_OFST_SESSION_COUNTER;
-
-        /* queue */
-        ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
-        desc->tid = wl1271_tx_ac_to_tid(ac);
-
-        desc->aid = TX_HW_DEFAULT_AID;
-        desc->reserved = 0;
-
-        /* align the length (and store in terms of words) */
-        pad = WL1271_TX_ALIGN(skb->len);
-        desc->length = cpu_to_le16(pad >> 2);
-
-        /* calculate number of padding bytes */
-        pad = pad - skb->len;
-        tx_attr |= pad << TX_HW_ATTR_OFST_LAST_WORD_PAD;
-
-        /* if the packets are destined for AP (have a STA entry) send them
-           with AP rate policies, otherwise use default basic rates */
-        if (control->control.sta)
-                tx_attr |= ACX_TX_AP_FULL_RATE << TX_HW_ATTR_OFST_RATE_POLICY;
-
-        desc->tx_attr = cpu_to_le16(tx_attr);
-
-        wl1271_debug(DEBUG_TX, "tx_fill_hdr: pad: %d", pad);
-        return 0;
-}
-
-static int wl1271_tx_send_packet(struct wl1271 *wl, struct sk_buff *skb,
-                                 struct ieee80211_tx_info *control)
-{
-
-        struct wl1271_tx_hw_descr *desc;
-        int len;
-
-        /* FIXME: This is a workaround for getting non-aligned packets.
-           This happens at least with EAPOL packets from the user space.
-           Our DMA requires packets to be aligned on a 4-byte boundary.
-        */
-        if (unlikely((long)skb->data & 0x03)) {
-                int offset = (4 - (long)skb->data) & 0x03;
-                wl1271_debug(DEBUG_TX, "skb offset %d", offset);
-
-                /* check whether the current skb can be used */
-                if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) {
-                        unsigned char *src = skb->data;
-
-                        /* align the buffer on a 4-byte boundary */
-                        skb_reserve(skb, offset);
-                        memmove(skb->data, src, skb->len);
-                } else {
-                        wl1271_info("No handler, fixme!");
-                        return -EINVAL;
-                }
-        }
-
-        len = WL1271_TX_ALIGN(skb->len);
-
-        /* perform a fixed address block write with the packet */
-        wl1271_write(wl, WL1271_SLV_MEM_DATA, skb->data, len, true);
-
-        /* write packet new counter into the write access register */
-        wl->tx_packets_count++;
-
-        desc = (struct wl1271_tx_hw_descr *) skb->data;
-        wl1271_debug(DEBUG_TX, "tx id %u skb 0x%p payload %u (%u words)",
-                     desc->id, skb, len, desc->length);
-
-        return 0;
-}
-
-/* caller must hold wl->mutex */
-static int wl1271_tx_frame(struct wl1271 *wl, struct sk_buff *skb)
-{
-        struct ieee80211_tx_info *info;
-        u32 extra = 0;
-        int ret = 0;
-        u8 idx;
-
-        if (!skb)
-                return -EINVAL;
-
-        info = IEEE80211_SKB_CB(skb);
-
-        if (info->control.hw_key &&
-            info->control.hw_key->alg == ALG_TKIP)
-                extra = WL1271_TKIP_IV_SPACE;
-
-        if (info->control.hw_key) {
-                idx = info->control.hw_key->hw_key_idx;
-
-                /* FIXME: do we have to do this if we're not using WEP? */
-                if (unlikely(wl->default_key != idx)) {
-                        ret = wl1271_cmd_set_default_wep_key(wl, idx);
-                        if (ret < 0)
-                                return ret;
-                        wl->default_key = idx;
-                }
-        }
-
-        ret = wl1271_tx_allocate(wl, skb, extra);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_tx_fill_hdr(wl, skb, extra, info);
-        if (ret < 0)
-                return ret;
-
-        ret = wl1271_tx_send_packet(wl, skb, info);
-        if (ret < 0)
-                return ret;
-
-        return ret;
-}
-
-u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set)
-{
-        struct ieee80211_supported_band *band;
-        u32 enabled_rates = 0;
-        int bit;
-
-        band = wl->hw->wiphy->bands[wl->band];
-        for (bit = 0; bit < band->n_bitrates; bit++) {
-                if (rate_set & 0x1)
-                        enabled_rates |= band->bitrates[bit].hw_value;
-                rate_set >>= 1;
-        }
-
-        return enabled_rates;
-}
-
-void wl1271_tx_work(struct work_struct *work)
-{
-        struct wl1271 *wl = container_of(work, struct wl1271, tx_work);
-        struct sk_buff *skb;
-        bool woken_up = false;
-        u32 sta_rates = 0;
-        u32 prev_tx_packets_count;
-        int ret;
-
-        /* check if the rates supported by the AP have changed */
-        if (unlikely(test_and_clear_bit(WL1271_FLAG_STA_RATES_CHANGED,
-                                        &wl->flags))) {
-                unsigned long flags;
-                spin_lock_irqsave(&wl->wl_lock, flags);
-                sta_rates = wl->sta_rate_set;
-                spin_unlock_irqrestore(&wl->wl_lock, flags);
-        }
-
-        mutex_lock(&wl->mutex);
-
-        if (unlikely(wl->state == WL1271_STATE_OFF))
-                goto out;
-
-        prev_tx_packets_count = wl->tx_packets_count;
-
-        /* if rates have changed, re-configure the rate policy */
-        if (unlikely(sta_rates)) {
-                wl->rate_set = wl1271_tx_enabled_rates_get(wl, sta_rates);
-                wl1271_acx_rate_policies(wl);
-        }
-
-        while ((skb = skb_dequeue(&wl->tx_queue))) {
-                if (!woken_up) {
-                        ret = wl1271_ps_elp_wakeup(wl, false);
-                        if (ret < 0)
-                                goto out_ack;
-                        woken_up = true;
-                }
-
-                ret = wl1271_tx_frame(wl, skb);
-                if (ret == -EBUSY) {
-                        /* firmware buffer is full, lets stop transmitting. */
-                        skb_queue_head(&wl->tx_queue, skb);
-                        goto out_ack;
-                } else if (ret < 0) {
-                        dev_kfree_skb(skb);
-                        goto out_ack;
-                }
-        }
-
-out_ack:
-        /* interrupt the firmware with the new packets */
-        if (prev_tx_packets_count != wl->tx_packets_count)
-                wl1271_write32(wl, WL1271_HOST_WR_ACCESS, wl->tx_packets_count);
-
-out:
-        if (woken_up)
-                wl1271_ps_elp_sleep(wl);
-
-        mutex_unlock(&wl->mutex);
-}
-
-static void wl1271_tx_complete_packet(struct wl1271 *wl,
-                                      struct wl1271_tx_hw_res_descr *result)
-{
-        struct ieee80211_tx_info *info;
-        struct sk_buff *skb;
-        int id = result->id;
-        int rate = -1;
-        u8 retries = 0;
-
-        /* check for id legality */
-        if (unlikely(id >= ACX_TX_DESCRIPTORS || wl->tx_frames[id] == NULL)) {
-                wl1271_warning("TX result illegal id: %d", id);
-                return;
-        }
-
-        skb = wl->tx_frames[id];
-        info = IEEE80211_SKB_CB(skb);
-
-        /* update the TX status info */
-        if (result->status == TX_SUCCESS) {
-                if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
-                        info->flags |= IEEE80211_TX_STAT_ACK;
-                rate = wl1271_rate_to_idx(wl, result->rate_class_index);
-                retries = result->ack_failures;
-        } else if (result->status == TX_RETRY_EXCEEDED) {
-                wl->stats.excessive_retries++;
-                retries = result->ack_failures;
-        }
-
-        info->status.rates[0].idx = rate;
-        info->status.rates[0].count = retries;
-        info->status.rates[0].flags = 0;
-        info->status.ack_signal = -1;
-
-        wl->stats.retry_count += result->ack_failures;
-
-        /* update security sequence number */
-        wl->tx_security_seq += (result->lsb_security_sequence_number -
-                                wl->tx_security_last_seq);
-        wl->tx_security_last_seq = result->lsb_security_sequence_number;
-
-        /* remove private header from packet */
-        skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
-
-        /* remove TKIP header space if present */
-        if (info->control.hw_key &&
-            info->control.hw_key->alg == ALG_TKIP) {
-                int hdrlen = ieee80211_get_hdrlen_from_skb(skb);
-                memmove(skb->data + WL1271_TKIP_IV_SPACE, skb->data, hdrlen);
-                skb_pull(skb, WL1271_TKIP_IV_SPACE);
-        }
-
-        wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
-                     " status 0x%x",
-                     result->id, skb, result->ack_failures,
-                     result->rate_class_index, result->status);
-
-        /* return the packet to the stack */
-        ieee80211_tx_status(wl->hw, skb);
-        wl->tx_frames[result->id] = NULL;
-        wl->tx_frames_cnt--;
-}
-
-/* Called upon reception of a TX complete interrupt */
-void wl1271_tx_complete(struct wl1271 *wl)
-{
-        struct wl1271_acx_mem_map *memmap =
-                (struct wl1271_acx_mem_map *)wl->target_mem_map;
-        u32 count, fw_counter;
-        u32 i;
-
-        /* read the tx results from the chipset */
-        wl1271_read(wl, le32_to_cpu(memmap->tx_result),
-                    wl->tx_res_if, sizeof(*wl->tx_res_if), false);
-        fw_counter = le32_to_cpu(wl->tx_res_if->tx_result_fw_counter);
-
-        /* write host counter to chipset (to ack) */
-        wl1271_write32(wl, le32_to_cpu(memmap->tx_result) +
-                       offsetof(struct wl1271_tx_hw_res_if,
-                                tx_result_host_counter), fw_counter);
-
-        count = fw_counter - wl->tx_results_count;
-        wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d", count);
-
-        /* verify that the result buffer is not getting overrun */
-        if (unlikely(count > TX_HW_RESULT_QUEUE_LEN))
-                wl1271_warning("TX result overflow from chipset: %d", count);
-
-        /* process the results */
-        for (i = 0; i < count; i++) {
-                struct wl1271_tx_hw_res_descr *result;
-                u8 offset = wl->tx_results_count & TX_HW_RESULT_QUEUE_LEN_MASK;
-
-                /* process the packet */
-                result =  &(wl->tx_res_if->tx_results_queue[offset]);
-                wl1271_tx_complete_packet(wl, result);
-
-                wl->tx_results_count++;
-        }
-
-        if (test_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags) &&
-            skb_queue_len(&wl->tx_queue) <= WL1271_TX_QUEUE_LOW_WATERMARK) {
-                unsigned long flags;
-
-                /* firmware buffer has space, restart queues */
-                wl1271_debug(DEBUG_TX, "tx_complete: waking queues");
-                spin_lock_irqsave(&wl->wl_lock, flags);
-                ieee80211_wake_queues(wl->hw);
-                clear_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
-                spin_unlock_irqrestore(&wl->wl_lock, flags);
-                ieee80211_queue_work(wl->hw, &wl->tx_work);
-        }
-}
-
-/* caller must hold wl->mutex */
-void wl1271_tx_reset(struct wl1271 *wl)
-{
-        int i;
-        struct sk_buff *skb;
-
-        /* TX failure */
-/*      control->flags = 0; FIXME */
-
-        while ((skb = skb_dequeue(&wl->tx_queue))) {
-                wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb);
-                ieee80211_tx_status(wl->hw, skb);
-        }
-
-        for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
-                if (wl->tx_frames[i] != NULL) {
-                        skb = wl->tx_frames[i];
-                        wl->tx_frames[i] = NULL;
-                        wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb);
-                        ieee80211_tx_status(wl->hw, skb);
-                }
-        wl->tx_frames_cnt = 0;
-}
-
-#define WL1271_TX_FLUSH_TIMEOUT 500000
-
-/* caller must *NOT* hold wl->mutex */
-void wl1271_tx_flush(struct wl1271 *wl)
-{
-        unsigned long timeout;
-        timeout = jiffies + usecs_to_jiffies(WL1271_TX_FLUSH_TIMEOUT);
-
-        while (!time_after(jiffies, timeout)) {
-                mutex_lock(&wl->mutex);
-                wl1271_debug(DEBUG_TX, "flushing tx buffer: %d",
-                             wl->tx_frames_cnt);
-                if ((wl->tx_frames_cnt == 0) &&
-                    skb_queue_empty(&wl->tx_queue)) {
-                        mutex_unlock(&wl->mutex);
-                        return;
-                }
-                mutex_unlock(&wl->mutex);
-                msleep(1);
-        }
-
-        wl1271_warning("Unable to flush all TX buffers, timed out.");
-}
diff --git a/drivers/net/wireless/wl12xx/wl12xx.h b/drivers/net/wireless/wl12xx/wl12xx.h
new file mode 100644
index 000000000000..fbe8f46d1232
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/wl12xx.h
@@ -0,0 +1,639 @@
+/*
+ * This file is part of wl1271
+ *
+ * Copyright (C) 1998-2009 Texas Instruments. All rights reserved.
+ * Copyright (C) 2008-2009 Nokia Corporation
+ *
+ * Contact: Luciano Coelho <luciano.coelho@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef __WL12XX_H__
+#define __WL12XX_H__
+
+#include <linux/mutex.h>
+#include <linux/completion.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/bitops.h>
+#include <net/mac80211.h>
+
+#include "conf.h"
+#include "ini.h"
+
+#define DRIVER_NAME "wl1271"
+#define DRIVER_PREFIX DRIVER_NAME ": "
+
+/*
+ * FW versions support BA 11n
+ * versions marks x.x.x.50-60.x
+ */
+#define WL12XX_BA_SUPPORT_FW_COST_VER2_START    50
+#define WL12XX_BA_SUPPORT_FW_COST_VER2_END      60
+
+enum {
+        DEBUG_NONE      = 0,
+        DEBUG_IRQ       = BIT(0),
+        DEBUG_SPI       = BIT(1),
+        DEBUG_BOOT      = BIT(2),
+        DEBUG_MAILBOX   = BIT(3),
+        DEBUG_TESTMODE  = BIT(4),
+        DEBUG_EVENT     = BIT(5),
+        DEBUG_TX        = BIT(6),
+        DEBUG_RX        = BIT(7),
+        DEBUG_SCAN      = BIT(8),
+        DEBUG_CRYPT     = BIT(9),
+        DEBUG_PSM       = BIT(10),
+        DEBUG_MAC80211  = BIT(11),
+        DEBUG_CMD       = BIT(12),
+        DEBUG_ACX       = BIT(13),
+        DEBUG_SDIO      = BIT(14),
+        DEBUG_FILTERS   = BIT(15),
+        DEBUG_ADHOC     = BIT(16),
+        DEBUG_AP        = BIT(17),
+        DEBUG_MASTER    = (DEBUG_ADHOC | DEBUG_AP),
+        DEBUG_ALL       = ~0,
+};
+
+extern u32 wl12xx_debug_level;
+
+#define DEBUG_DUMP_LIMIT 1024
+
+#define wl1271_error(fmt, arg...) \
+        pr_err(DRIVER_PREFIX "ERROR " fmt "\n", ##arg)
+
+#define wl1271_warning(fmt, arg...) \
+        pr_warning(DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
+
+#define wl1271_notice(fmt, arg...) \
+        pr_info(DRIVER_PREFIX fmt "\n", ##arg)
+
+#define wl1271_info(fmt, arg...) \
+        pr_info(DRIVER_PREFIX fmt "\n", ##arg)
+
+#define wl1271_debug(level, fmt, arg...) \
+        do { \
+                if (level & wl12xx_debug_level) \
+                        pr_debug(DRIVER_PREFIX fmt "\n", ##arg); \
+        } while (0)
+
+/* TODO: use pr_debug_hex_dump when it will be available */
+#define wl1271_dump(level, prefix, buf, len)    \
+        do { \
+                if (level & wl12xx_debug_level) \
+                        print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
+                                       DUMP_PREFIX_OFFSET, 16, 1,       \
+                                       buf,                             \
+                                       min_t(size_t, len, DEBUG_DUMP_LIMIT), \
+                                       0);                              \
+        } while (0)
+
+#define wl1271_dump_ascii(level, prefix, buf, len)      \
+        do { \
+                if (level & wl12xx_debug_level) \
+                        print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
+                                       DUMP_PREFIX_OFFSET, 16, 1,       \
+                                       buf,                             \
+                                       min_t(size_t, len, DEBUG_DUMP_LIMIT), \
+                                       true);                           \
+        } while (0)
+
+#define WL1271_DEFAULT_STA_RX_CONFIG (CFG_UNI_FILTER_EN |       \
+                                  CFG_BSSID_FILTER_EN | \
+                                  CFG_MC_FILTER_EN)
+
+#define WL1271_DEFAULT_STA_RX_FILTER (CFG_RX_RCTS_ACK | CFG_RX_PRSP_EN |  \
+                                  CFG_RX_MGMT_EN | CFG_RX_DATA_EN |   \
+                                  CFG_RX_CTL_EN | CFG_RX_BCN_EN |     \
+                                  CFG_RX_AUTH_EN | CFG_RX_ASSOC_EN)
+
+#define WL1271_DEFAULT_AP_RX_CONFIG  0
+
+#define WL1271_DEFAULT_AP_RX_FILTER  (CFG_RX_RCTS_ACK | CFG_RX_PREQ_EN | \
+                                  CFG_RX_MGMT_EN | CFG_RX_DATA_EN | \
+                                  CFG_RX_CTL_EN | CFG_RX_AUTH_EN | \
+                                  CFG_RX_ASSOC_EN)
+
+
+
+#define WL1271_FW_NAME "ti-connectivity/wl1271-fw-2.bin"
+#define WL128X_FW_NAME "ti-connectivity/wl128x-fw.bin"
+#define WL127X_AP_FW_NAME "ti-connectivity/wl1271-fw-ap.bin"
+#define WL128X_AP_FW_NAME "ti-connectivity/wl128x-fw-ap.bin"
+
+/*
+ * wl127x and wl128x are using the same NVS file name. However, the
+ * ini parameters between them are different.  The driver validates
+ * the correct NVS size in wl1271_boot_upload_nvs().
+ */
+#define WL12XX_NVS_NAME "ti-connectivity/wl1271-nvs.bin"
+
+#define WL1271_TX_SECURITY_LO16(s) ((u16)((s) & 0xffff))
+#define WL1271_TX_SECURITY_HI32(s) ((u32)(((s) >> 16) & 0xffffffff))
+
+#define WL1271_CIPHER_SUITE_GEM 0x00147201
+
+#define WL1271_BUSY_WORD_CNT 1
+#define WL1271_BUSY_WORD_LEN (WL1271_BUSY_WORD_CNT * sizeof(u32))
+
+#define WL1271_ELP_HW_STATE_ASLEEP 0
+#define WL1271_ELP_HW_STATE_IRQ    1
+
+#define WL1271_DEFAULT_BEACON_INT  100
+#define WL1271_DEFAULT_DTIM_PERIOD 1
+
+#define WL1271_AP_GLOBAL_HLID      0
+#define WL1271_AP_BROADCAST_HLID   1
+#define WL1271_AP_STA_HLID_START   2
+
+/*
+ * When in AP-mode, we allow (at least) this number of mem-blocks
+ * to be transmitted to FW for a STA in PS-mode. Only when packets are
+ * present in the FW buffers it will wake the sleeping STA. We want to put
+ * enough packets for the driver to transmit all of its buffered data before
+ * the STA goes to sleep again. But we don't want to take too much mem-blocks
+ * as it might hurt the throughput of active STAs.
+ * The number of blocks (18) is enough for 2 large packets.
+ */
+#define WL1271_PS_STA_MAX_BLOCKS  (2 * 9)
+
+#define WL1271_AP_BSS_INDEX        0
+#define WL1271_AP_DEF_INACTIV_SEC  300
+#define WL1271_AP_DEF_BEACON_EXP   20
+
+#define ACX_TX_DESCRIPTORS         32
+
+#define WL1271_AGGR_BUFFER_SIZE (4 * PAGE_SIZE)
+
+enum wl1271_state {
+        WL1271_STATE_OFF,
+        WL1271_STATE_ON,
+        WL1271_STATE_PLT,
+};
+
+enum wl1271_partition_type {
+        PART_DOWN,
+        PART_WORK,
+        PART_DRPW,
+
+        PART_TABLE_LEN
+};
+
+struct wl1271_partition {
+        u32 size;
+        u32 start;
+};
+
+struct wl1271_partition_set {
+        struct wl1271_partition mem;
+        struct wl1271_partition reg;
+        struct wl1271_partition mem2;
+        struct wl1271_partition mem3;
+};
+
+struct wl1271;
+
+enum {
+        FW_VER_CHIP,
+        FW_VER_IF_TYPE,
+        FW_VER_MAJOR,
+        FW_VER_SUBTYPE,
+        FW_VER_MINOR,
+
+        NUM_FW_VER
+};
+
+#define FW_VER_CHIP_WL127X 6
+#define FW_VER_CHIP_WL128X 7
+
+#define FW_VER_IF_TYPE_STA 1
+#define FW_VER_IF_TYPE_AP  2
+
+#define FW_VER_MINOR_1_SPARE_STA_MIN 58
+#define FW_VER_MINOR_1_SPARE_AP_MIN  47
+
+struct wl1271_chip {
+        u32 id;
+        char fw_ver_str[ETHTOOL_BUSINFO_LEN];
+        unsigned int fw_ver[NUM_FW_VER];
+};
+
+struct wl1271_stats {
+        struct acx_statistics *fw_stats;
+        unsigned long fw_stats_update;
+
+        unsigned int retry_count;
+        unsigned int excessive_retries;
+};
+
+#define NUM_TX_QUEUES              4
+#define NUM_RX_PKT_DESC            8
+
+#define AP_MAX_STATIONS            5
+
+/* Broadcast and Global links + links to stations */
+#define AP_MAX_LINKS               (AP_MAX_STATIONS + 2)
+
+/* FW status registers common for AP/STA */
+struct wl1271_fw_common_status {
+        __le32 intr;
+        u8  fw_rx_counter;
+        u8  drv_rx_counter;
+        u8  reserved;
+        u8  tx_results_counter;
+        __le32 rx_pkt_descs[NUM_RX_PKT_DESC];
+        __le32 tx_released_blks[NUM_TX_QUEUES];
+        __le32 fw_localtime;
+} __packed;
+
+/* FW status registers for AP */
+struct wl1271_fw_ap_status {
+        struct wl1271_fw_common_status common;
+
+        /* Next fields valid only in AP FW */
+
+        /*
+         * A bitmap (where each bit represents a single HLID)
+         * to indicate if the station is in PS mode.
+         */
+        __le32 link_ps_bitmap;
+
+        /* Number of freed MBs per HLID */
+        u8 tx_lnk_free_blks[AP_MAX_LINKS];
+        u8 padding_1[1];
+} __packed;
+
+/* FW status registers for STA */
+struct wl1271_fw_sta_status {
+        struct wl1271_fw_common_status common;
+
+        u8  tx_total;
+        u8  reserved1;
+        __le16 reserved2;
+        /* Total structure size is 68 bytes */
+        u32 padding;
+} __packed;
+
+struct wl1271_fw_full_status {
+        union {
+                struct wl1271_fw_common_status common;
+                struct wl1271_fw_sta_status sta;
+                struct wl1271_fw_ap_status ap;
+        };
+} __packed;
+
+
+struct wl1271_rx_mem_pool_addr {
+        u32 addr;
+        u32 addr_extra;
+};
+
+#define WL1271_MAX_CHANNELS 64
+struct wl1271_scan {
+        struct cfg80211_scan_request *req;
+        unsigned long scanned_ch[BITS_TO_LONGS(WL1271_MAX_CHANNELS)];
+        bool failed;
+        u8 state;
+        u8 ssid[IW_ESSID_MAX_SIZE+1];
+        size_t ssid_len;
+};
+
+struct wl1271_if_operations {
+        void (*read)(struct wl1271 *wl, int addr, void *buf, size_t len,
+                     bool fixed);
+        void (*write)(struct wl1271 *wl, int addr, void *buf, size_t len,
+                     bool fixed);
+        void (*reset)(struct wl1271 *wl);
+        void (*init)(struct wl1271 *wl);
+        int (*power)(struct wl1271 *wl, bool enable);
+        struct device* (*dev)(struct wl1271 *wl);
+        void (*enable_irq)(struct wl1271 *wl);
+        void (*disable_irq)(struct wl1271 *wl);
+        void (*set_block_size) (struct wl1271 *wl, unsigned int blksz);
+};
+
+#define MAX_NUM_KEYS 14
+#define MAX_KEY_SIZE 32
+
+struct wl1271_ap_key {
+        u8 id;
+        u8 key_type;
+        u8 key_size;
+        u8 key[MAX_KEY_SIZE];
+        u8 hlid;
+        u32 tx_seq_32;
+        u16 tx_seq_16;
+};
+
+enum wl12xx_flags {
+        WL1271_FLAG_STA_ASSOCIATED,
+        WL1271_FLAG_JOINED,
+        WL1271_FLAG_GPIO_POWER,
+        WL1271_FLAG_TX_QUEUE_STOPPED,
+        WL1271_FLAG_TX_PENDING,
+        WL1271_FLAG_IN_ELP,
+        WL1271_FLAG_ELP_REQUESTED,
+        WL1271_FLAG_PSM,
+        WL1271_FLAG_PSM_REQUESTED,
+        WL1271_FLAG_IRQ_RUNNING,
+        WL1271_FLAG_IDLE,
+        WL1271_FLAG_PSPOLL_FAILURE,
+        WL1271_FLAG_STA_STATE_SENT,
+        WL1271_FLAG_FW_TX_BUSY,
+        WL1271_FLAG_AP_STARTED,
+        WL1271_FLAG_IF_INITIALIZED,
+        WL1271_FLAG_DUMMY_PACKET_PENDING,
+        WL1271_FLAG_SUSPENDED,
+        WL1271_FLAG_PENDING_WORK,
+};
+
+struct wl1271_link {
+        /* AP-mode - TX queue per AC in link */
+        struct sk_buff_head tx_queue[NUM_TX_QUEUES];
+
+        /* accounting for allocated / available TX blocks in FW */
+        u8 allocated_blks;
+        u8 prev_freed_blks;
+
+        u8 addr[ETH_ALEN];
+};
+
+struct wl1271 {
+        struct platform_device *plat_dev;
+        struct ieee80211_hw *hw;
+        bool mac80211_registered;
+
+        void *if_priv;
+
+        struct wl1271_if_operations *if_ops;
+
+        void (*set_power)(bool enable);
+        int irq;
+        int ref_clock;
+
+        spinlock_t wl_lock;
+
+        enum wl1271_state state;
+        struct mutex mutex;
+
+        unsigned long flags;
+
+        struct wl1271_partition_set part;
+
+        struct wl1271_chip chip;
+
+        int cmd_box_addr;
+        int event_box_addr;
+
+        u8 *fw;
+        size_t fw_len;
+        u8 fw_bss_type;
+        void *nvs;
+        size_t nvs_len;
+
+        s8 hw_pg_ver;
+
+        u8 bssid[ETH_ALEN];
+        u8 mac_addr[ETH_ALEN];
+        u8 bss_type;
+        u8 set_bss_type;
+        u8 ssid[IW_ESSID_MAX_SIZE + 1];
+        u8 ssid_len;
+        int channel;
+
+        struct wl1271_acx_mem_map *target_mem_map;
+
+        /* Accounting for allocated / available TX blocks on HW */
+        u32 tx_blocks_freed[NUM_TX_QUEUES];
+        u32 tx_blocks_available;
+        u32 tx_allocated_blocks;
+        u32 tx_results_count;
+
+        /* Transmitted TX packets counter for chipset interface */
+        u32 tx_packets_count;
+
+        /* Time-offset between host and chipset clocks */
+        s64 time_offset;
+
+        /* Session counter for the chipset */
+        int session_counter;
+
+        /* Frames scheduled for transmission, not handled yet */
+        struct sk_buff_head tx_queue[NUM_TX_QUEUES];
+        int tx_queue_count;
+
+        /* Frames received, not handled yet by mac80211 */
+        struct sk_buff_head deferred_rx_queue;
+
+        /* Frames sent, not returned yet to mac80211 */
+        struct sk_buff_head deferred_tx_queue;
+
+        struct work_struct tx_work;
+
+        /* Pending TX frames */
+        unsigned long tx_frames_map[BITS_TO_LONGS(ACX_TX_DESCRIPTORS)];
+        struct sk_buff *tx_frames[ACX_TX_DESCRIPTORS];
+        int tx_frames_cnt;
+
+        /* Security sequence number counters */
+        u8 tx_security_last_seq;
+        s64 tx_security_seq;
+
+        /* FW Rx counter */
+        u32 rx_counter;
+
+        /* Rx memory pool address */
+        struct wl1271_rx_mem_pool_addr rx_mem_pool_addr;
+
+        /* Intermediate buffer, used for packet aggregation */
+        u8 *aggr_buf;
+
+        /* Reusable dummy packet template */
+        struct sk_buff *dummy_packet;
+
+        /* Network stack work  */
+        struct work_struct netstack_work;
+
+        /* Hardware recovery work */
+        struct work_struct recovery_work;
+
+        /* The mbox event mask */
+        u32 event_mask;
+
+        /* Mailbox pointers */
+        u32 mbox_ptr[2];
+
+        /* Are we currently scanning */
+        struct wl1271_scan scan;
+        struct delayed_work scan_complete_work;
+
+        bool sched_scanning;
+
+        /* probe-req template for the current AP */
+        struct sk_buff *probereq;
+
+        /* Our association ID */
+        u16 aid;
+
+        /*
+         * currently configured rate set:
+         *      bits  0-15 - 802.11abg rates
+         *      bits 16-23 - 802.11n   MCS index mask
+         * support only 1 stream, thus only 8 bits for the MCS rates (0-7).
+         */
+        u32 basic_rate_set;
+        u32 basic_rate;
+        u32 rate_set;
+
+        /* The current band */
+        enum ieee80211_band band;
+
+        /* Beaconing interval (needed for ad-hoc) */
+        u32 beacon_int;
+
+        /* Default key (for WEP) */
+        u32 default_key;
+
+        unsigned int filters;
+        unsigned int rx_config;
+        unsigned int rx_filter;
+
+        struct completion *elp_compl;
+        struct completion *ps_compl;
+        struct delayed_work elp_work;
+        struct delayed_work pspoll_work;
+
+        /* counter for ps-poll delivery failures */
+        int ps_poll_failures;
+
+        /* retry counter for PSM entries */
+        u8 psm_entry_retry;
+
+        /* in dBm */
+        int power_level;
+
+        int rssi_thold;
+        int last_rssi_event;
+
+        struct wl1271_stats stats;
+
+        __le32 buffer_32;
+        u32 buffer_cmd;
+        u32 buffer_busyword[WL1271_BUSY_WORD_CNT];
+
+        struct wl1271_fw_full_status *fw_status;
+        struct wl1271_tx_hw_res_if *tx_res_if;
+
+        struct ieee80211_vif *vif;
+
+        /* Current chipset configuration */
+        struct conf_drv_settings conf;
+
+        bool sg_enabled;
+
+        bool enable_11a;
+
+        struct list_head list;
+
+        /* Most recently reported noise in dBm */
+        s8 noise;
+
+        /* map for HLIDs of associated stations - when operating in AP mode */
+        unsigned long ap_hlid_map[BITS_TO_LONGS(AP_MAX_STATIONS)];
+
+        /* recoreded keys for AP-mode - set here before AP startup */
+        struct wl1271_ap_key *recorded_ap_keys[MAX_NUM_KEYS];
+
+        /* bands supported by this instance of wl12xx */
+        struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+
+        /* RX BA constraint value */
+        bool ba_support;
+        u8 ba_rx_bitmap;
+
+        int tcxo_clock;
+
+        /*
+         * wowlan trigger was configured during suspend.
+         * (currently, only "ANY" trigger is supported)
+         */
+        bool wow_enabled;
+
+        /*
+         * AP-mode - links indexed by HLID. The global and broadcast links
+         * are always active.
+         */
+        struct wl1271_link links[AP_MAX_LINKS];
+
+        /* the hlid of the link where the last transmitted skb came from */
+        int last_tx_hlid;
+
+        /* AP-mode - a bitmap of links currently in PS mode according to FW */
+        u32 ap_fw_ps_map;
+
+        /* AP-mode - a bitmap of links currently in PS mode in mac80211 */
+        unsigned long ap_ps_map;
+
+        /* Quirks of specific hardware revisions */
+        unsigned int quirks;
+
+        /* Platform limitations */
+        unsigned int platform_quirks;
+};
+
+struct wl1271_station {
+        u8 hlid;
+};
+
+int wl1271_plt_start(struct wl1271 *wl);
+int wl1271_plt_stop(struct wl1271 *wl);
+
+#define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */
+
+#define SESSION_COUNTER_MAX 7 /* maximum value for the session counter */
+
+#define WL1271_DEFAULT_POWER_LEVEL 0
+
+#define WL1271_TX_QUEUE_LOW_WATERMARK  10
+#define WL1271_TX_QUEUE_HIGH_WATERMARK 25
+
+#define WL1271_DEFERRED_QUEUE_LIMIT    64
+
+/* WL1271 needs a 200ms sleep after power on, and a 20ms sleep before power
+   on in case is has been shut down shortly before */
+#define WL1271_PRE_POWER_ON_SLEEP 20 /* in milliseconds */
+#define WL1271_POWER_ON_SLEEP 200 /* in milliseconds */
+
+/* Macros to handle wl1271.sta_rate_set */
+#define HW_BG_RATES_MASK        0xffff
+#define HW_HT_RATES_OFFSET      16
+
+/* Quirks */
+
+/* Each RX/TX transaction requires an end-of-transaction transfer */
+#define WL12XX_QUIRK_END_OF_TRANSACTION         BIT(0)
+
+/*
+ * Older firmwares use 2 spare TX blocks
+ * (for STA < 6.1.3.50.58 or for AP < 6.2.0.0.47)
+ */
+#define WL12XX_QUIRK_USE_2_SPARE_BLOCKS         BIT(1)
+
+/* WL128X requires aggregated packets to be aligned to the SDIO block size */
+#define WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT        BIT(2)
+
+#endif
diff --git a/drivers/net/wireless/wl12xx/wl12xx_80211.h b/drivers/net/wireless/wl12xx/wl12xx_80211.h
index 184628027213..18fe542360f2 100644
--- a/drivers/net/wireless/wl12xx/wl12xx_80211.h
+++ b/drivers/net/wireless/wl12xx/wl12xx_80211.h
@@ -2,6 +2,7 @@
 #define __WL12XX_80211_H__
 
 #include <linux/if_ether.h>     /* ETH_ALEN */
+#include <linux/if_arp.h>
 
 /* RATES */
 #define IEEE80211_CCK_RATE_1MB                  0x02
@@ -54,7 +55,6 @@
 
 /* This really should be 8, but not for our firmware */
 #define MAX_SUPPORTED_RATES 32
-#define COUNTRY_STRING_LEN 3
 #define MAX_COUNTRY_TRIPLETS 32
 
 /* Headers */
@@ -98,7 +98,7 @@ struct country_triplet {
 
 struct wl12xx_ie_country {
         struct wl12xx_ie_header header;
-        u8 country_string[COUNTRY_STRING_LEN];
+        u8 country_string[IEEE80211_COUNTRY_STRING_LEN];
         struct country_triplet triplets[MAX_COUNTRY_TRIPLETS];
 } __packed;
 
@@ -133,11 +133,17 @@ struct wl12xx_qos_null_data_template {
         __le16 qos_ctl;
 } __packed;
 
-struct wl12xx_probe_req_template {
-        struct ieee80211_header header;
-        struct wl12xx_ie_ssid ssid;
-        struct wl12xx_ie_rates rates;
-        struct wl12xx_ie_rates ext_rates;
+struct wl12xx_arp_rsp_template {
+        struct ieee80211_hdr_3addr hdr;
+
+        u8 llc_hdr[sizeof(rfc1042_header)];
+        __be16 llc_type;
+
+        struct arphdr arp_hdr;
+        u8 sender_hw[ETH_ALEN];
+        __be32 sender_ip;
+        u8 target_hw[ETH_ALEN];
+        __be32 target_ip;
 } __packed;
 
 
@@ -153,4 +159,9 @@ struct wl12xx_probe_resp_template {
         struct wl12xx_ie_country country;
 } __packed;
 
+struct wl12xx_disconn_template {
+        struct ieee80211_header header;
+        __le16 disconn_reason;
+} __packed;
+
 #endif
diff --git a/drivers/net/wireless/wl12xx/wl12xx_platform_data.c b/drivers/net/wireless/wl12xx/wl12xx_platform_data.c
new file mode 100644
index 000000000000..973b11060a8f
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/wl12xx_platform_data.c
@@ -0,0 +1,28 @@
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/wl12xx.h>
+
+static const struct wl12xx_platform_data *platform_data;
+
+int __init wl12xx_set_platform_data(const struct wl12xx_platform_data *data)
+{
+        if (platform_data)
+                return -EBUSY;
+        if (!data)
+                return -EINVAL;
+
+        platform_data = kmemdup(data, sizeof(*data), GFP_KERNEL);
+        if (!platform_data)
+                return -ENOMEM;
+
+        return 0;
+}
+
+const struct wl12xx_platform_data *wl12xx_get_platform_data(void)
+{
+        if (!platform_data)
+                return ERR_PTR(-ENODEV);
+
+        return platform_data;
+}
+EXPORT_SYMBOL(wl12xx_get_platform_data);