72 files changed, 7713 insertions, 3048 deletions

diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig
index 1294175cab20..612fffe100a6 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -473,6 +473,15 @@ config MAC80211_HWSIM
           To compile this driver as a module, choose M here: the module will be
           called mac80211_hwsim.  If unsure, say N.
 
+config MWL8K
+        tristate "Marvell 88W8xxx PCI/PCIe Wireless support"
+        depends on MAC80211 && PCI && WLAN_80211 && EXPERIMENTAL
+        ---help---
+          This driver supports Marvell TOPDOG 802.11 wireless cards.
+
+          To compile this driver as a module, choose M here: the module
+          will be called mwl8k.  If unsure, say N.
+
 source "drivers/net/wireless/p54/Kconfig"
 source "drivers/net/wireless/ath5k/Kconfig"
 source "drivers/net/wireless/ath9k/Kconfig"
diff --git a/drivers/net/wireless/Makefile b/drivers/net/wireless/Makefile
index e2574cafe051..d780487c420f 100644
--- a/drivers/net/wireless/Makefile
+++ b/drivers/net/wireless/Makefile
@@ -48,6 +48,8 @@ obj-$(CONFIG_LIBERTAS_THINFIRM)	+= libertas_tf/
 
 obj-$(CONFIG_ADM8211)   += adm8211.o
 
+obj-$(CONFIG_MWL8K)     += mwl8k.o
+
 obj-$(CONFIG_IWLWIFI)   += iwlwifi/
 obj-$(CONFIG_RT2X00)    += rt2x00/
 
diff --git a/drivers/net/wireless/airo_cs.c b/drivers/net/wireless/airo_cs.c
index 27696c20f4c2..d0593ed9170e 100644
--- a/drivers/net/wireless/airo_cs.c
+++ b/drivers/net/wireless/airo_cs.c
@@ -16,8 +16,8 @@
     In addition this module was derived from dummy_cs.
     The initial developer of dummy_cs is David A. Hinds
     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
-    are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.    
-    
+    are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
+
 ======================================================================*/
 
 #ifdef __IN_PCMCIA_PACKAGE__
@@ -38,7 +38,7 @@
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/system.h>
 
 #include "airo.h"
@@ -54,7 +54,7 @@
 static int pc_debug = PCMCIA_DEBUG;
 module_param(pc_debug, int, 0);
 static char *version = "$Revision: 1.2 $";
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
+#define DEBUG(n, args...) if (pc_debug > (n)) printk(KERN_DEBUG args);
 #else
 #define DEBUG(n, args...)
 #endif
@@ -62,9 +62,9 @@ static char *version = "$Revision: 1.2 $";
 /*====================================================================*/
 
 MODULE_AUTHOR("Benjamin Reed");
-MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
-                   cards.  This is the module that links the PCMCIA card \
-                   with the airo module.");
+MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet "
+                   "cards.  This is the module that links the PCMCIA card "
+                   "with the airo module.");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
 
@@ -76,7 +76,7 @@ MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
    event is received.  The config() and release() entry points are
    used to configure or release a socket, in response to card
    insertion and ejection events.  They are invoked from the airo_cs
-   event handler. 
+   event handler.
 */
 
 static int airo_config(struct pcmcia_device *link);
@@ -103,8 +103,9 @@ static void airo_detach(struct pcmcia_device *p_dev);
    by one struct pcmcia_device structure (defined in ds.h).
 
    You may not want to use a linked list for this -- for example, the
-   memory card driver uses an array of struct pcmcia_device pointers, where minor
-   device numbers are used to derive the corresponding array index.
+   memory card driver uses an array of struct pcmcia_device pointers,
+   where minor device numbers are used to derive the corresponding
+   array index.
 */
 
 /*
@@ -122,22 +123,22 @@ static void airo_detach(struct pcmcia_device *p_dev);
    device IO routines can use a flag like this to throttle IO to a
    card that is not ready to accept it.
 */
-   
+
 typedef struct local_info_t {
         dev_node_t      node;
         struct net_device *eth_dev;
 } local_info_t;
 
 /*======================================================================
-  
+
   airo_attach() creates an "instance" of the driver, allocating
   local data structures for one device.  The device is registered
   with Card Services.
-  
+
   The dev_link structure is initialized, but we don't actually
   configure the card at this point -- we wait until we receive a
   card insertion event.
-  
+
   ======================================================================*/
 
 static int airo_probe(struct pcmcia_device *p_dev)
@@ -150,7 +151,7 @@ static int airo_probe(struct pcmcia_device *p_dev)
         p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
         p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
         p_dev->irq.Handler = NULL;
-        
+
         /*
           General socket configuration defaults can go here.  In this
           client, we assume very little, and rely on the CIS for almost
@@ -160,7 +161,7 @@ static int airo_probe(struct pcmcia_device *p_dev)
         */
         p_dev->conf.Attributes = 0;
         p_dev->conf.IntType = INT_MEMORY_AND_IO;
-        
+
         /* Allocate space for private device-specific data */
         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
         if (!local) {
@@ -173,12 +174,12 @@ static int airo_probe(struct pcmcia_device *p_dev)
 } /* airo_attach */
 
 /*======================================================================
-  
+
   This deletes a driver "instance".  The device is de-registered
   with Card Services.  If it has been released, all local data
   structures are freed.  Otherwise, the structures will be freed
   when the device is released.
-  
+
   ======================================================================*/
 
 static void airo_detach(struct pcmcia_device *link)
@@ -187,20 +188,20 @@ static void airo_detach(struct pcmcia_device *link)
 
         airo_release(link);
 
-        if ( ((local_info_t*)link->priv)->eth_dev ) {
-                stop_airo_card( ((local_info_t*)link->priv)->eth_dev, 0 );
+        if (((local_info_t *)link->priv)->eth_dev) {
+                stop_airo_card(((local_info_t *)link->priv)->eth_dev, 0);
         }
-        ((local_info_t*)link->priv)->eth_dev = NULL;
+        ((local_info_t *)link->priv)->eth_dev = NULL;
 
         kfree(link->priv);
 } /* airo_detach */
 
 /*======================================================================
-  
+
   airo_config() is scheduled to run after a CARD_INSERTION event
   is received, to configure the PCMCIA socket, and to make the
   device available to the system.
-  
+
   ======================================================================*/
 
 #define CS_CHECK(fn, ret) \
@@ -325,26 +326,28 @@ static int airo_config(struct pcmcia_device *link)
         */
         if (link->conf.Attributes & CONF_ENABLE_IRQ)
                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
-        
+
         /*
           This actually configures the PCMCIA socket -- setting up
           the I/O windows and the interrupt mapping, and putting the
           card and host interface into "Memory and IO" mode.
         */
-        CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
-        ((local_info_t*)link->priv)->eth_dev = 
-                init_airo_card( link->irq.AssignedIRQ,
-                                link->io.BasePort1, 1, &handle_to_dev(link) );
-        if (!((local_info_t*)link->priv)->eth_dev) goto cs_failed;
-        
+        CS_CHECK(RequestConfiguration,
+                 pcmcia_request_configuration(link, &link->conf));
+        ((local_info_t *)link->priv)->eth_dev =
+                init_airo_card(link->irq.AssignedIRQ,
+                               link->io.BasePort1, 1, &handle_to_dev(link));
+        if (!((local_info_t *)link->priv)->eth_dev)
+                goto cs_failed;
+
         /*
           At this point, the dev_node_t structure(s) need to be
           initialized and arranged in a linked list at link->dev_node.
         */
-        strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
+        strcpy(dev->node.dev_name, ((local_info_t *)link->priv)->eth_dev->name);
         dev->node.major = dev->node.minor = 0;
         link->dev_node = &dev->node;
-        
+
         /* Finally, report what we've done */
         printk(KERN_INFO "%s: index 0x%02x: ",
                dev->node.dev_name, link->conf.ConfigIndex);
@@ -374,11 +377,11 @@ static int airo_config(struct pcmcia_device *link)
 } /* airo_config */
 
 /*======================================================================
-  
+
   After a card is removed, airo_release() will unregister the
   device, and release the PCMCIA configuration.  If the device is
   still open, this will be postponed until it is closed.
-  
+
   ======================================================================*/
 
 static void airo_release(struct pcmcia_device *link)
@@ -475,7 +478,7 @@ static void airo_cs_cleanup(void)
     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-    POSSIBILITY OF SUCH DAMAGE.    
+    POSSIBILITY OF SUCH DAMAGE.
 */
 
 module_init(airo_cs_init);
diff --git a/drivers/net/wireless/ath5k/Makefile b/drivers/net/wireless/ath5k/Makefile
index 719cfaef7085..84a74c5248e5 100644
--- a/drivers/net/wireless/ath5k/Makefile
+++ b/drivers/net/wireless/ath5k/Makefile
@@ -10,5 +10,6 @@ ath5k-y				+= phy.o
 ath5k-y                         += reset.o
 ath5k-y                         += attach.o
 ath5k-y                         += base.o
+ath5k-y                         += led.o
 ath5k-$(CONFIG_ATH5K_DEBUG)     += debug.o
 obj-$(CONFIG_ATH5K)             += ath5k.o
diff --git a/drivers/net/wireless/ath5k/ath5k.h b/drivers/net/wireless/ath5k/ath5k.h
index b9af2b84c05f..0dc2c7321c8b 100644
--- a/drivers/net/wireless/ath5k/ath5k.h
+++ b/drivers/net/wireless/ath5k/ath5k.h
@@ -1129,6 +1129,12 @@ struct ath5k_hw {
 extern struct ath5k_hw *ath5k_hw_attach(struct ath5k_softc *sc, u8 mac_version);
 extern void ath5k_hw_detach(struct ath5k_hw *ah);
 
+/* LED functions */
+extern int ath5k_init_leds(struct ath5k_softc *sc);
+extern void ath5k_led_enable(struct ath5k_softc *sc);
+extern void ath5k_led_off(struct ath5k_softc *sc);
+extern void ath5k_unregister_leds(struct ath5k_softc *sc);
+
 /* Reset Functions */
 extern int ath5k_hw_nic_wakeup(struct ath5k_hw *ah, int flags, bool initial);
 extern int ath5k_hw_reset(struct ath5k_hw *ah, enum nl80211_iftype op_mode, struct ieee80211_channel *channel, bool change_channel);
diff --git a/drivers/net/wireless/ath5k/attach.c b/drivers/net/wireless/ath5k/attach.c
index 05bc5cb44e88..656cb9dc833b 100644
--- a/drivers/net/wireless/ath5k/attach.c
+++ b/drivers/net/wireless/ath5k/attach.c
@@ -34,14 +34,14 @@
 static int ath5k_hw_post(struct ath5k_hw *ah)
 {
 
-        int i, c;
-        u16 cur_reg;
-        u16 regs[2] = {AR5K_STA_ID0, AR5K_PHY(8)};
-        u32 var_pattern;
-        u32 static_pattern[4] = {
+        static const u32 static_pattern[4] = {
                 0x55555555,     0xaaaaaaaa,
                 0x66666666,     0x99999999
         };
+        static const u16 regs[2] = { AR5K_STA_ID0, AR5K_PHY(8) };
+        int i, c;
+        u16 cur_reg;
+        u32 var_pattern;
         u32 init_val;
         u32 cur_val;
 
@@ -106,7 +106,6 @@ struct ath5k_hw *ath5k_hw_attach(struct ath5k_softc *sc, u8 mac_version)
 {
         struct ath5k_hw *ah;
         struct pci_dev *pdev = sc->pdev;
-        u8 mac[ETH_ALEN] = {};
         int ret;
         u32 srev;
 
@@ -312,7 +311,7 @@ struct ath5k_hw *ath5k_hw_attach(struct ath5k_softc *sc, u8 mac_version)
         }
 
         /* MAC address is cleared until add_interface */
-        ath5k_hw_set_lladdr(ah, mac);
+        ath5k_hw_set_lladdr(ah, (u8[ETH_ALEN]){});
 
         /* Set BSSID to bcast address: ff:ff:ff:ff:ff:ff for now */
         memset(ah->ah_bssid, 0xff, ETH_ALEN);
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index f7c424dcac66..cad3ccf61b00 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -79,7 +79,7 @@ MODULE_VERSION("0.6.0 (EXPERIMENTAL)");
 
 
 /* Known PCI ids */
-static struct pci_device_id ath5k_pci_id_table[] __devinitdata = {
+static const struct pci_device_id ath5k_pci_id_table[] = {
         { PCI_VDEVICE(ATHEROS, 0x0207), .driver_data = AR5K_AR5210 }, /* 5210 early */
         { PCI_VDEVICE(ATHEROS, 0x0007), .driver_data = AR5K_AR5210 }, /* 5210 */
         { PCI_VDEVICE(ATHEROS, 0x0011), .driver_data = AR5K_AR5211 }, /* 5311 - this is on AHB bus !*/
@@ -103,7 +103,7 @@ static struct pci_device_id ath5k_pci_id_table[] __devinitdata = {
 MODULE_DEVICE_TABLE(pci, ath5k_pci_id_table);
 
 /* Known SREVs */
-static struct ath5k_srev_name srev_names[] = {
+static const struct ath5k_srev_name srev_names[] = {
         { "5210",       AR5K_VERSION_MAC,       AR5K_SREV_AR5210 },
         { "5311",       AR5K_VERSION_MAC,       AR5K_SREV_AR5311 },
         { "5311A",      AR5K_VERSION_MAC,       AR5K_SREV_AR5311A },
@@ -142,7 +142,7 @@ static struct ath5k_srev_name srev_names[] = {
         { "xxxxx",      AR5K_VERSION_RAD,       AR5K_SREV_UNKNOWN },
 };
 
-static struct ieee80211_rate ath5k_rates[] = {
+static const struct ieee80211_rate ath5k_rates[] = {
         { .bitrate = 10,
           .hw_value = ATH5K_RATE_CODE_1M, },
         { .bitrate = 20,
@@ -248,7 +248,7 @@ static void ath5k_bss_info_changed(struct ieee80211_hw *hw,
                 struct ieee80211_bss_conf *bss_conf,
                 u32 changes);
 
-static struct ieee80211_ops ath5k_hw_ops = {
+static const struct ieee80211_ops ath5k_hw_ops = {
         .tx             = ath5k_tx,
         .start          = ath5k_start,
         .stop           = ath5k_stop,
@@ -370,11 +370,6 @@ static irqreturn_t ath5k_intr(int irq, void *dev_id);
 static void     ath5k_tasklet_reset(unsigned long data);
 
 static void     ath5k_calibrate(unsigned long data);
-/* LED functions */
-static int      ath5k_init_leds(struct ath5k_softc *sc);
-static void     ath5k_led_enable(struct ath5k_softc *sc);
-static void     ath5k_led_off(struct ath5k_softc *sc);
-static void     ath5k_unregister_leds(struct ath5k_softc *sc);
 
 /*
  * Module init/exit functions
@@ -2530,141 +2525,6 @@ ath5k_calibrate(unsigned long data)
 }
 
 
-
-/***************\
-* LED functions *
-\***************/
-
-static void
-ath5k_led_enable(struct ath5k_softc *sc)
-{
-        if (test_bit(ATH_STAT_LEDSOFT, sc->status)) {
-                ath5k_hw_set_gpio_output(sc->ah, sc->led_pin);
-                ath5k_led_off(sc);
-        }
-}
-
-static void
-ath5k_led_on(struct ath5k_softc *sc)
-{
-        if (!test_bit(ATH_STAT_LEDSOFT, sc->status))
-                return;
-        ath5k_hw_set_gpio(sc->ah, sc->led_pin, sc->led_on);
-}
-
-static void
-ath5k_led_off(struct ath5k_softc *sc)
-{
-        if (!test_bit(ATH_STAT_LEDSOFT, sc->status))
-                return;
-        ath5k_hw_set_gpio(sc->ah, sc->led_pin, !sc->led_on);
-}
-
-static void
-ath5k_led_brightness_set(struct led_classdev *led_dev,
-        enum led_brightness brightness)
-{
-        struct ath5k_led *led = container_of(led_dev, struct ath5k_led,
-                led_dev);
-
-        if (brightness == LED_OFF)
-                ath5k_led_off(led->sc);
-        else
-                ath5k_led_on(led->sc);
-}
-
-static int
-ath5k_register_led(struct ath5k_softc *sc, struct ath5k_led *led,
-                   const char *name, char *trigger)
-{
-        int err;
-
-        led->sc = sc;
-        strncpy(led->name, name, sizeof(led->name));
-        led->led_dev.name = led->name;
-        led->led_dev.default_trigger = trigger;
-        led->led_dev.brightness_set = ath5k_led_brightness_set;
-
-        err = led_classdev_register(&sc->pdev->dev, &led->led_dev);
-        if (err) {
-                ATH5K_WARN(sc, "could not register LED %s\n", name);
-                led->sc = NULL;
-        }
-        return err;
-}
-
-static void
-ath5k_unregister_led(struct ath5k_led *led)
-{
-        if (!led->sc)
-                return;
-        led_classdev_unregister(&led->led_dev);
-        ath5k_led_off(led->sc);
-        led->sc = NULL;
-}
-
-static void
-ath5k_unregister_leds(struct ath5k_softc *sc)
-{
-        ath5k_unregister_led(&sc->rx_led);
-        ath5k_unregister_led(&sc->tx_led);
-}
-
-
-static int
-ath5k_init_leds(struct ath5k_softc *sc)
-{
-        int ret = 0;
-        struct ieee80211_hw *hw = sc->hw;
-        struct pci_dev *pdev = sc->pdev;
-        char name[ATH5K_LED_MAX_NAME_LEN + 1];
-
-        /*
-         * Auto-enable soft led processing for IBM cards and for
-         * 5211 minipci cards.
-         */
-        if (pdev->device == PCI_DEVICE_ID_ATHEROS_AR5212_IBM ||
-            pdev->device == PCI_DEVICE_ID_ATHEROS_AR5211) {
-                __set_bit(ATH_STAT_LEDSOFT, sc->status);
-                sc->led_pin = 0;
-                sc->led_on = 0;  /* active low */
-        }
-        /* Enable softled on PIN1 on HP Compaq nc6xx, nc4000 & nx5000 laptops */
-        if (pdev->subsystem_vendor == PCI_VENDOR_ID_COMPAQ) {
-                __set_bit(ATH_STAT_LEDSOFT, sc->status);
-                sc->led_pin = 1;
-                sc->led_on = 1;  /* active high */
-        }
-        /*
-         * Pin 3 on Foxconn chips used in Acer Aspire One (0x105b:e008) and
-         * in emachines notebooks with AMBIT subsystem.
-         */
-        if (pdev->subsystem_vendor == PCI_VENDOR_ID_FOXCONN ||
-            pdev->subsystem_vendor == PCI_VENDOR_ID_AMBIT) {
-                __set_bit(ATH_STAT_LEDSOFT, sc->status);
-                sc->led_pin = 3;
-                sc->led_on = 0;  /* active low */
-        }
-
-        if (!test_bit(ATH_STAT_LEDSOFT, sc->status))
-                goto out;
-
-        ath5k_led_enable(sc);
-
-        snprintf(name, sizeof(name), "ath5k-%s::rx", wiphy_name(hw->wiphy));
-        ret = ath5k_register_led(sc, &sc->rx_led, name,
-                ieee80211_get_rx_led_name(hw));
-        if (ret)
-                goto out;
-
-        snprintf(name, sizeof(name), "ath5k-%s::tx", wiphy_name(hw->wiphy));
-        ret = ath5k_register_led(sc, &sc->tx_led, name,
-                ieee80211_get_tx_led_name(hw));
-out:
-        return ret;
-}
-
-
 /********************\
 * Mac80211 functions *
 \********************/
diff --git a/drivers/net/wireless/ath5k/debug.c b/drivers/net/wireless/ath5k/debug.c
index 413ed689cd5f..9770bb3d40f9 100644
--- a/drivers/net/wireless/ath5k/debug.c
+++ b/drivers/net/wireless/ath5k/debug.c
@@ -82,14 +82,14 @@ static int ath5k_debugfs_open(struct inode *inode, struct file *file)
 /* debugfs: registers */
 
 struct reg {
-        char *name;
+        const char *name;
         int addr;
 };
 
 #define REG_STRUCT_INIT(r) { #r, r }
 
 /* just a few random registers, might want to add more */
-static struct reg regs[] = {
+static const struct reg regs[] = {
         REG_STRUCT_INIT(AR5K_CR),
         REG_STRUCT_INIT(AR5K_RXDP),
         REG_STRUCT_INIT(AR5K_CFG),
@@ -142,7 +142,7 @@ static struct reg regs[] = {
 
 static void *reg_start(struct seq_file *seq, loff_t *pos)
 {
-        return *pos < ARRAY_SIZE(regs) ? &regs[*pos] : NULL;
+        return *pos < ARRAY_SIZE(regs) ? (void *)&regs[*pos] : NULL;
 }
 
 static void reg_stop(struct seq_file *seq, void *p)
@@ -153,7 +153,7 @@ static void reg_stop(struct seq_file *seq, void *p)
 static void *reg_next(struct seq_file *seq, void *p, loff_t *pos)
 {
         ++*pos;
-        return *pos < ARRAY_SIZE(regs) ? &regs[*pos] : NULL;
+        return *pos < ARRAY_SIZE(regs) ? (void *)&regs[*pos] : NULL;
 }
 
 static int reg_show(struct seq_file *seq, void *p)
@@ -290,7 +290,7 @@ static const struct file_operations fops_reset = {
 
 /* debugfs: debug level */
 
-static struct {
+static const struct {
         enum ath5k_debug_level level;
         const char *name;
         const char *desc;
diff --git a/drivers/net/wireless/ath5k/eeprom.c b/drivers/net/wireless/ath5k/eeprom.c
index a54ee7e4967b..ac45ca47ca87 100644
--- a/drivers/net/wireless/ath5k/eeprom.c
+++ b/drivers/net/wireless/ath5k/eeprom.c
@@ -1418,14 +1418,11 @@ ath5k_eeprom_init(struct ath5k_hw *ah)
  */
 int ath5k_eeprom_read_mac(struct ath5k_hw *ah, u8 *mac)
 {
-        u8 mac_d[ETH_ALEN];
+        u8 mac_d[ETH_ALEN] = {};
         u32 total, offset;
         u16 data;
         int octet, ret;
 
-        memset(mac, 0, ETH_ALEN);
-        memset(mac_d, 0, ETH_ALEN);
-
         ret = ath5k_hw_eeprom_read(ah, 0x20, &data);
         if (ret)
                 return ret;
@@ -1441,11 +1438,11 @@ int ath5k_eeprom_read_mac(struct ath5k_hw *ah, u8 *mac)
                 octet += 2;
         }
 
-        memcpy(mac, mac_d, ETH_ALEN);
-
         if (!total || total == 3 * 0xffff)
                 return -EINVAL;
 
+        memcpy(mac, mac_d, ETH_ALEN);
+
         return 0;
 }
 
diff --git a/drivers/net/wireless/ath5k/led.c b/drivers/net/wireless/ath5k/led.c
new file mode 100644
index 000000000000..0686e12738b3
--- /dev/null
+++ b/drivers/net/wireless/ath5k/led.c
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting
+ * Copyright (c) 2004-2005 Atheros Communications, Inc.
+ * Copyright (c) 2007 Jiri Slaby <jirislaby@gmail.com>
+ * Copyright (c) 2009 Bob Copeland <me@bobcopeland.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
+ *    redistribution must be conditioned upon including a substantially
+ *    similar Disclaimer requirement for further binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+#include <linux/pci.h>
+#include "ath5k.h"
+#include "base.h"
+
+#define ATH_SDEVICE(subv,subd) \
+        .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
+        .subvendor = (subv), .subdevice = (subd)
+
+#define ATH_LED(pin,polarity) .driver_data = (((pin) << 8) | (polarity))
+#define ATH_PIN(data) ((data) >> 8)
+#define ATH_POLARITY(data) ((data) & 0xff)
+
+/* Devices we match on for LED config info (typically laptops) */
+static const struct pci_device_id ath5k_led_devices[] = {
+        /* IBM-specific AR5212 */
+        { PCI_VDEVICE(ATHEROS, PCI_DEVICE_ID_ATHEROS_AR5212_IBM), ATH_LED(0, 0) },
+        /* AR5211 */
+        { PCI_VDEVICE(ATHEROS, PCI_DEVICE_ID_ATHEROS_AR5211), ATH_LED(0, 0) },
+        /* HP Compaq nc6xx, nc4000, nx6000 */
+        { ATH_SDEVICE(PCI_VENDOR_ID_COMPAQ, PCI_ANY_ID), ATH_LED(1, 1) },
+        /* Acer Aspire One A150 (maximlevitsky@gmail.com) */
+        { ATH_SDEVICE(PCI_VENDOR_ID_FOXCONN, 0xe008), ATH_LED(3, 0) },
+        /* Acer Ferrari 5000 (russ.dill@gmail.com) */
+        { ATH_SDEVICE(PCI_VENDOR_ID_AMBIT, 0x0422), ATH_LED(1, 1) },
+        /* E-machines E510 (tuliom@gmail.com) */
+        { ATH_SDEVICE(PCI_VENDOR_ID_AMBIT, 0x0428), ATH_LED(3, 0) },
+        { }
+};
+
+void ath5k_led_enable(struct ath5k_softc *sc)
+{
+        if (test_bit(ATH_STAT_LEDSOFT, sc->status)) {
+                ath5k_hw_set_gpio_output(sc->ah, sc->led_pin);
+                ath5k_led_off(sc);
+        }
+}
+
+void ath5k_led_on(struct ath5k_softc *sc)
+{
+        if (!test_bit(ATH_STAT_LEDSOFT, sc->status))
+                return;
+        ath5k_hw_set_gpio(sc->ah, sc->led_pin, sc->led_on);
+}
+
+void ath5k_led_off(struct ath5k_softc *sc)
+{
+        if (!test_bit(ATH_STAT_LEDSOFT, sc->status))
+                return;
+        ath5k_hw_set_gpio(sc->ah, sc->led_pin, !sc->led_on);
+}
+
+static void
+ath5k_led_brightness_set(struct led_classdev *led_dev,
+        enum led_brightness brightness)
+{
+        struct ath5k_led *led = container_of(led_dev, struct ath5k_led,
+                led_dev);
+
+        if (brightness == LED_OFF)
+                ath5k_led_off(led->sc);
+        else
+                ath5k_led_on(led->sc);
+}
+
+static int
+ath5k_register_led(struct ath5k_softc *sc, struct ath5k_led *led,
+                   const char *name, char *trigger)
+{
+        int err;
+
+        led->sc = sc;
+        strncpy(led->name, name, sizeof(led->name));
+        led->led_dev.name = led->name;
+        led->led_dev.default_trigger = trigger;
+        led->led_dev.brightness_set = ath5k_led_brightness_set;
+
+        err = led_classdev_register(&sc->pdev->dev, &led->led_dev);
+        if (err) {
+                ATH5K_WARN(sc, "could not register LED %s\n", name);
+                led->sc = NULL;
+        }
+        return err;
+}
+
+static void
+ath5k_unregister_led(struct ath5k_led *led)
+{
+        if (!led->sc)
+                return;
+        led_classdev_unregister(&led->led_dev);
+        ath5k_led_off(led->sc);
+        led->sc = NULL;
+}
+
+void ath5k_unregister_leds(struct ath5k_softc *sc)
+{
+        ath5k_unregister_led(&sc->rx_led);
+        ath5k_unregister_led(&sc->tx_led);
+}
+
+int ath5k_init_leds(struct ath5k_softc *sc)
+{
+        int ret = 0;
+        struct ieee80211_hw *hw = sc->hw;
+        struct pci_dev *pdev = sc->pdev;
+        char name[ATH5K_LED_MAX_NAME_LEN + 1];
+        const struct pci_device_id *match;
+
+        match = pci_match_id(&ath5k_led_devices[0], pdev);
+        if (match) {
+                __set_bit(ATH_STAT_LEDSOFT, sc->status);
+                sc->led_pin = ATH_PIN(match->driver_data);
+                sc->led_on = ATH_POLARITY(match->driver_data);
+        }
+
+        if (!test_bit(ATH_STAT_LEDSOFT, sc->status))
+                goto out;
+
+        ath5k_led_enable(sc);
+
+        snprintf(name, sizeof(name), "ath5k-%s::rx", wiphy_name(hw->wiphy));
+        ret = ath5k_register_led(sc, &sc->rx_led, name,
+                ieee80211_get_rx_led_name(hw));
+        if (ret)
+                goto out;
+
+        snprintf(name, sizeof(name), "ath5k-%s::tx", wiphy_name(hw->wiphy));
+        ret = ath5k_register_led(sc, &sc->tx_led, name,
+                ieee80211_get_tx_led_name(hw));
+out:
+        return ret;
+}
+
diff --git a/drivers/net/wireless/ath5k/reset.c b/drivers/net/wireless/ath5k/reset.c
index 1531ccd35066..685dc213edae 100644
--- a/drivers/net/wireless/ath5k/reset.c
+++ b/drivers/net/wireless/ath5k/reset.c
@@ -102,7 +102,7 @@ static inline int ath5k_hw_write_ofdm_timings(struct ath5k_hw *ah,
  * index into rates for control rates, we can set it up like this because
  * this is only used for AR5212 and we know it supports G mode
  */
-static int control_rates[] =
+static const unsigned int control_rates[] =
         { 0, 1, 1, 1, 4, 4, 6, 6, 8, 8, 8, 8 };
 
 /**
diff --git a/drivers/net/wireless/ath9k/ahb.c b/drivers/net/wireless/ath9k/ahb.c
index bc562bd88890..00cc7bb01f2e 100644
--- a/drivers/net/wireless/ath9k/ahb.c
+++ b/drivers/net/wireless/ath9k/ahb.c
@@ -60,6 +60,7 @@ static struct ath_bus_ops ath_ahb_bus_ops  = {
 static int ath_ahb_probe(struct platform_device *pdev)
 {
         void __iomem *mem;
+        struct ath_wiphy *aphy;
         struct ath_softc *sc;
         struct ieee80211_hw *hw;
         struct resource *res;
diff --git a/drivers/net/wireless/ath9k/calib.c b/drivers/net/wireless/ath9k/calib.c
index 1c074c059b5c..c9446fb6b153 100644
--- a/drivers/net/wireless/ath9k/calib.c
+++ b/drivers/net/wireless/ath9k/calib.c
@@ -745,43 +745,6 @@ static void ath9k_olc_temp_compensation(struct ath_hw *ah)
         }
 }
 
-bool ath9k_hw_calibrate(struct ath_hw *ah, struct ath9k_channel *chan,
-                        u8 rxchainmask, bool longcal,
-                        bool *isCalDone)
-{
-        struct hal_cal_list *currCal = ah->cal_list_curr;
-
-        *isCalDone = true;
-
-        if (currCal &&
-            (currCal->calState == CAL_RUNNING ||
-             currCal->calState == CAL_WAITING)) {
-                ath9k_hw_per_calibration(ah, chan, rxchainmask, currCal,
-                                         isCalDone);
-                if (*isCalDone) {
-                        ah->cal_list_curr = currCal = currCal->calNext;
-
-                        if (currCal->calState == CAL_WAITING) {
-                                *isCalDone = false;
-                                ath9k_hw_reset_calibration(ah, currCal);
-                        }
-                }
-        }
-
-        if (longcal) {
-                if (OLC_FOR_AR9280_20_LATER)
-                        ath9k_olc_temp_compensation(ah);
-                ath9k_hw_getnf(ah, chan);
-                ath9k_hw_loadnf(ah, ah->curchan);
-                ath9k_hw_start_nfcal(ah);
-
-                if (chan->channelFlags & CHANNEL_CW_INT)
-                        chan->channelFlags &= ~CHANNEL_CW_INT;
-        }
-
-        return true;
-}
-
 static inline void ath9k_hw_9285_pa_cal(struct ath_hw *ah)
 {
 
@@ -877,22 +840,104 @@ static inline void ath9k_hw_9285_pa_cal(struct ath_hw *ah)
 
 }
 
+bool ath9k_hw_calibrate(struct ath_hw *ah, struct ath9k_channel *chan,
+                        u8 rxchainmask, bool longcal,
+                        bool *isCalDone)
+{
+        struct hal_cal_list *currCal = ah->cal_list_curr;
+
+        *isCalDone = true;
+
+        if (currCal &&
+            (currCal->calState == CAL_RUNNING ||
+             currCal->calState == CAL_WAITING)) {
+                ath9k_hw_per_calibration(ah, chan, rxchainmask, currCal,
+                                         isCalDone);
+                if (*isCalDone) {
+                        ah->cal_list_curr = currCal = currCal->calNext;
+
+                        if (currCal->calState == CAL_WAITING) {
+                                *isCalDone = false;
+                                ath9k_hw_reset_calibration(ah, currCal);
+                        }
+                }
+        }
+
+        if (longcal) {
+                if (AR_SREV_9285(ah) && AR_SREV_9285_11_OR_LATER(ah))
+                        ath9k_hw_9285_pa_cal(ah);
+
+                if (OLC_FOR_AR9280_20_LATER)
+                        ath9k_olc_temp_compensation(ah);
+                ath9k_hw_getnf(ah, chan);
+                ath9k_hw_loadnf(ah, ah->curchan);
+                ath9k_hw_start_nfcal(ah);
+
+                if (chan->channelFlags & CHANNEL_CW_INT)
+                        chan->channelFlags &= ~CHANNEL_CW_INT;
+        }
+
+        return true;
+}
+
+static bool ar9285_clc(struct ath_hw *ah, struct ath9k_channel *chan)
+{
+        REG_SET_BIT(ah, AR_PHY_CL_CAL_CTL, AR_PHY_CL_CAL_ENABLE);
+        if (chan->channelFlags & CHANNEL_HT20) {
+                REG_SET_BIT(ah, AR_PHY_CL_CAL_CTL, AR_PHY_PARALLEL_CAL_ENABLE);
+                REG_SET_BIT(ah, AR_PHY_TURBO, AR_PHY_FC_DYN2040_EN);
+                REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL,
+                            AR_PHY_AGC_CONTROL_FLTR_CAL);
+                REG_CLR_BIT(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_CAL_ENABLE);
+                REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL);
+                if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL,
+                                  AR_PHY_AGC_CONTROL_CAL, 0, AH_WAIT_TIMEOUT)) {
+                        DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE, "offset "
+                                "calibration failed to complete in "
+                                "1ms; noisy ??\n");
+                        return false;
+                }
+                REG_CLR_BIT(ah, AR_PHY_TURBO, AR_PHY_FC_DYN2040_EN);
+                REG_CLR_BIT(ah, AR_PHY_CL_CAL_CTL, AR_PHY_PARALLEL_CAL_ENABLE);
+                REG_CLR_BIT(ah, AR_PHY_CL_CAL_CTL, AR_PHY_CL_CAL_ENABLE);
+        }
+        REG_CLR_BIT(ah, AR_PHY_ADC_CTL, AR_PHY_ADC_CTL_OFF_PWDADC);
+        REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_FLTR_CAL);
+        REG_SET_BIT(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_CAL_ENABLE);
+        REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL);
+        if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL,
+                          0, AH_WAIT_TIMEOUT)) {
+                DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE, "offset calibration "
+                                "failed to complete in 1ms; noisy ??\n");
+                return false;
+        }
+
+        REG_SET_BIT(ah, AR_PHY_ADC_CTL, AR_PHY_ADC_CTL_OFF_PWDADC);
+        REG_CLR_BIT(ah, AR_PHY_CL_CAL_CTL, AR_PHY_CL_CAL_ENABLE);
+        REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_FLTR_CAL);
+
+        return true;
+}
+
 bool ath9k_hw_init_cal(struct ath_hw *ah,
                        struct ath9k_channel *chan)
 {
-        if (AR_SREV_9280_10_OR_LATER(ah)) {
+        if (AR_SREV_9285(ah) && AR_SREV_9285_12_OR_LATER(ah)) {
+                if (!ar9285_clc(ah, chan))
+                        return false;
+        } else if (AR_SREV_9280_10_OR_LATER(ah)) {
                 REG_CLR_BIT(ah, AR_PHY_ADC_CTL, AR_PHY_ADC_CTL_OFF_PWDADC);
                 REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_FLTR_CAL);
                 REG_CLR_BIT(ah, AR_PHY_CL_CAL_CTL, AR_PHY_CL_CAL_ENABLE);
 
                 /* Kick off the cal */
                 REG_WRITE(ah, AR_PHY_AGC_CONTROL,
-                          REG_READ(ah, AR_PHY_AGC_CONTROL) |
-                          AR_PHY_AGC_CONTROL_CAL);
+                                REG_READ(ah, AR_PHY_AGC_CONTROL) |
+                                AR_PHY_AGC_CONTROL_CAL);
 
                 if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL,
-                                   AR_PHY_AGC_CONTROL_CAL, 0,
-                                   AH_WAIT_TIMEOUT)) {
+                                        AR_PHY_AGC_CONTROL_CAL, 0,
+                                        AH_WAIT_TIMEOUT)) {
                         DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE,
                                 "offset calibration failed to complete in 1ms; "
                                 "noisy environment?\n");
@@ -906,11 +951,11 @@ bool ath9k_hw_init_cal(struct ath_hw *ah,
 
         /* Calibrate the AGC */
         REG_WRITE(ah, AR_PHY_AGC_CONTROL,
-                  REG_READ(ah, AR_PHY_AGC_CONTROL) |
-                  AR_PHY_AGC_CONTROL_CAL);
+                        REG_READ(ah, AR_PHY_AGC_CONTROL) |
+                        AR_PHY_AGC_CONTROL_CAL);
 
         if (!ath9k_hw_wait(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_CAL,
-                           0, AH_WAIT_TIMEOUT)) {
+                                0, AH_WAIT_TIMEOUT)) {
                 DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE,
                         "offset calibration failed to complete in 1ms; "
                         "noisy environment?\n");
@@ -928,8 +973,8 @@ bool ath9k_hw_init_cal(struct ath_hw *ah,
 
         /* Do NF Calibration */
         REG_WRITE(ah, AR_PHY_AGC_CONTROL,
-                  REG_READ(ah, AR_PHY_AGC_CONTROL) |
-                  AR_PHY_AGC_CONTROL_NF);
+                        REG_READ(ah, AR_PHY_AGC_CONTROL) |
+                        AR_PHY_AGC_CONTROL_NF);
 
         ah->cal_list = ah->cal_list_last = ah->cal_list_curr = NULL;
 
@@ -938,19 +983,19 @@ bool ath9k_hw_init_cal(struct ath_hw *ah,
                         INIT_CAL(&ah->adcgain_caldata);
                         INSERT_CAL(ah, &ah->adcgain_caldata);
                         DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE,
-                                "enabling ADC Gain Calibration.\n");
+                                        "enabling ADC Gain Calibration.\n");
                 }
                 if (ath9k_hw_iscal_supported(ah, ADC_DC_CAL)) {
                         INIT_CAL(&ah->adcdc_caldata);
                         INSERT_CAL(ah, &ah->adcdc_caldata);
                         DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE,
-                                "enabling ADC DC Calibration.\n");
+                                        "enabling ADC DC Calibration.\n");
                 }
                 if (ath9k_hw_iscal_supported(ah, IQ_MISMATCH_CAL)) {
                         INIT_CAL(&ah->iq_caldata);
                         INSERT_CAL(ah, &ah->iq_caldata);
                         DPRINTF(ah->ah_sc, ATH_DBG_CALIBRATE,
-                                "enabling IQ Calibration.\n");
+                                        "enabling IQ Calibration.\n");
                 }
 
                 ah->cal_list_curr = ah->cal_list;
diff --git a/drivers/net/wireless/ath9k/debug.c b/drivers/net/wireless/ath9k/debug.c
index 8d91422106d9..82573cadb1ab 100644
--- a/drivers/net/wireless/ath9k/debug.c
+++ b/drivers/net/wireless/ath9k/debug.c
@@ -14,11 +14,15 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include <asm/unaligned.h>
+
 #include "ath9k.h"
 
 static unsigned int ath9k_debug = DBG_DEFAULT;
 module_param_named(debug, ath9k_debug, uint, 0);
 
+static struct dentry *ath9k_debugfs_root;
+
 void DPRINTF(struct ath_softc *sc, int dbg_mask, const char *fmt, ...)
 {
         if (!sc)
@@ -318,6 +322,9 @@ static ssize_t read_file_rcstat(struct file *file, char __user *user_buf,
 {
         struct ath_softc *sc = file->private_data;
 
+        if (sc->cur_rate_table == NULL)
+                return 0;
+
         if (conf_is_ht(&sc->hw->conf))
                 return ath_read_file_stat_11n_rc(file, user_buf, count, ppos);
         else
@@ -491,12 +498,8 @@ int ath9k_init_debug(struct ath_softc *sc)
 {
         sc->debug.debug_mask = ath9k_debug;
 
-        sc->debug.debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
-        if (!sc->debug.debugfs_root)
-                goto err;
-
         sc->debug.debugfs_phy = debugfs_create_dir(wiphy_name(sc->hw->wiphy),
-                                                      sc->debug.debugfs_root);
+                                                      ath9k_debugfs_root);
         if (!sc->debug.debugfs_phy)
                 goto err;
 
@@ -538,5 +541,19 @@ void ath9k_exit_debug(struct ath_softc *sc)
         debugfs_remove(sc->debug.debugfs_interrupt);
         debugfs_remove(sc->debug.debugfs_dma);
         debugfs_remove(sc->debug.debugfs_phy);
-        debugfs_remove(sc->debug.debugfs_root);
+}
+
+int ath9k_debug_create_root(void)
+{
+        ath9k_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
+        if (!ath9k_debugfs_root)
+                return -ENOENT;
+
+        return 0;
+}
+
+void ath9k_debug_remove_root(void)
+{
+        debugfs_remove(ath9k_debugfs_root);
+        ath9k_debugfs_root = NULL;
 }
diff --git a/drivers/net/wireless/ath9k/debug.h b/drivers/net/wireless/ath9k/debug.h
index 2a33d74fdbee..065268b8568f 100644
--- a/drivers/net/wireless/ath9k/debug.h
+++ b/drivers/net/wireless/ath9k/debug.h
@@ -102,7 +102,6 @@ struct ath_stats {
 
 struct ath9k_debug {
         int debug_mask;
-        struct dentry *debugfs_root;
         struct dentry *debugfs_phy;
         struct dentry *debugfs_dma;
         struct dentry *debugfs_interrupt;
@@ -114,6 +113,8 @@ struct ath9k_debug {
 void DPRINTF(struct ath_softc *sc, int dbg_mask, const char *fmt, ...);
 int ath9k_init_debug(struct ath_softc *sc);
 void ath9k_exit_debug(struct ath_softc *sc);
+int ath9k_debug_create_root(void);
+void ath9k_debug_remove_root(void);
 void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status);
 void ath_debug_stat_rc(struct ath_softc *sc, struct sk_buff *skb);
 void ath_debug_stat_retries(struct ath_softc *sc, int rix,
@@ -135,6 +136,15 @@ static inline void ath9k_exit_debug(struct ath_softc *sc)
 {
 }
 
+static inline int ath9k_debug_create_root(void)
+{
+        return 0;
+}
+
+static inline void ath9k_debug_remove_root(void)
+{
+}
+
 static inline void ath_debug_stat_interrupt(struct ath_softc *sc,
                                             enum ath9k_int status)
 {
diff --git a/drivers/net/wireless/ath9k/eeprom.c b/drivers/net/wireless/ath9k/eeprom.c
index f935341bc5c4..183c949bcca1 100644
--- a/drivers/net/wireless/ath9k/eeprom.c
+++ b/drivers/net/wireless/ath9k/eeprom.c
@@ -640,7 +640,7 @@ static void ath9k_hw_get_4k_gain_boundaries_pdadcs(struct ath_hw *ah,
                 pPdGainBoundaries[i] =
                         min((u16)AR5416_MAX_RATE_POWER, pPdGainBoundaries[i]);
 
-                if ((i == 0) && !AR_SREV_5416_V20_OR_LATER(ah)) {
+                if ((i == 0) && !AR_SREV_5416_20_OR_LATER(ah)) {
                         minDelta = pPdGainBoundaries[0] - 23;
                         pPdGainBoundaries[0] = 23;
                 } else {
@@ -679,7 +679,7 @@ static void ath9k_hw_get_4k_gain_boundaries_pdadcs(struct ath_hw *ah,
                                     vpdTableI[i][sizeCurrVpdTable - 2]);
                 vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep);
 
-                if (tgtIndex > maxIndex) {
+                if (tgtIndex >= maxIndex) {
                         while ((ss <= tgtIndex) &&
                                (k < (AR5416_NUM_PDADC_VALUES - 1))) {
                                 tmpVal = (int16_t) TMP_VAL_VPD_TABLE;
@@ -713,11 +713,11 @@ static bool ath9k_hw_set_4k_power_cal_table(struct ath_hw *ah,
         u8 *pCalBChans = NULL;
         u16 pdGainOverlap_t2;
         static u8 pdadcValues[AR5416_NUM_PDADC_VALUES];
-        u16 gainBoundaries[AR5416_PD_GAINS_IN_MASK];
+        u16 gainBoundaries[AR5416_EEP4K_PD_GAINS_IN_MASK];
         u16 numPiers, i, j;
         int16_t tMinCalPower;
         u16 numXpdGain, xpdMask;
-        u16 xpdGainValues[AR5416_NUM_PD_GAINS] = { 0, 0, 0, 0 };
+        u16 xpdGainValues[AR5416_EEP4K_NUM_PD_GAINS] = { 0, 0 };
         u32 reg32, regOffset, regChainOffset;
 
         xpdMask = pEepData->modalHeader.xpdGain;
@@ -732,16 +732,16 @@ static bool ath9k_hw_set_4k_power_cal_table(struct ath_hw *ah,
         }
 
         pCalBChans = pEepData->calFreqPier2G;
-        numPiers = AR5416_NUM_2G_CAL_PIERS;
+        numPiers = AR5416_EEP4K_NUM_2G_CAL_PIERS;
 
         numXpdGain = 0;
 
-        for (i = 1; i <= AR5416_PD_GAINS_IN_MASK; i++) {
-                if ((xpdMask >> (AR5416_PD_GAINS_IN_MASK - i)) & 1) {
-                        if (numXpdGain >= AR5416_NUM_PD_GAINS)
+        for (i = 1; i <= AR5416_EEP4K_PD_GAINS_IN_MASK; i++) {
+                if ((xpdMask >> (AR5416_EEP4K_PD_GAINS_IN_MASK - i)) & 1) {
+                        if (numXpdGain >= AR5416_EEP4K_NUM_PD_GAINS)
                                 break;
                         xpdGainValues[numXpdGain] =
-                                (u16)(AR5416_PD_GAINS_IN_MASK - i);
+                                (u16)(AR5416_EEP4K_PD_GAINS_IN_MASK - i);
                         numXpdGain++;
                 }
         }
@@ -754,8 +754,8 @@ static bool ath9k_hw_set_4k_power_cal_table(struct ath_hw *ah,
                       xpdGainValues[1]);
         REG_RMW_FIELD(ah, AR_PHY_TPCRG1, AR_PHY_TPCRG1_PD_GAIN_3, 0);
 
-        for (i = 0; i < AR5416_MAX_CHAINS; i++) {
-                if (AR_SREV_5416_V20_OR_LATER(ah) &&
+        for (i = 0; i < AR5416_EEP4K_MAX_CHAINS; i++) {
+                if (AR_SREV_5416_20_OR_LATER(ah) &&
                     (ah->rxchainmask == 5 || ah->txchainmask == 5) &&
                     (i != 0)) {
                         regChainOffset = (i == 1) ? 0x2000 : 0x1000;
@@ -771,7 +771,7 @@ static bool ath9k_hw_set_4k_power_cal_table(struct ath_hw *ah,
                                             &tMinCalPower, gainBoundaries,
                                             pdadcValues, numXpdGain);
 
-                        if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
+                        if ((i == 0) || AR_SREV_5416_20_OR_LATER(ah)) {
                                 REG_WRITE(ah, AR_PHY_TPCRG5 + regChainOffset,
                                           SM(pdGainOverlap_t2,
                                              AR_PHY_TPCRG5_PD_GAIN_OVERLAP)
@@ -1707,7 +1707,7 @@ static bool ath9k_hw_def_set_board_values(struct ath_hw *ah,
                                 break;
                 }
 
-                if (AR_SREV_5416_V20_OR_LATER(ah) &&
+                if (AR_SREV_5416_20_OR_LATER(ah) &&
                     (ah->rxchainmask == 5 || ah->txchainmask == 5)
                     && (i != 0))
                         regChainOffset = (i == 1) ? 0x2000 : 0x1000;
@@ -1728,7 +1728,7 @@ static bool ath9k_hw_def_set_board_values(struct ath_hw *ah,
                           SM(pModal->iqCalQCh[i],
                              AR_PHY_TIMING_CTRL4_IQCORR_Q_Q_COFF));
 
-                if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
+                if ((i == 0) || AR_SREV_5416_20_OR_LATER(ah)) {
                         if (AR5416_VER_MASK >= AR5416_EEP_MINOR_VER_3) {
                                 txRxAttenLocal = pModal->txRxAttenCh[i];
                                 if (AR_SREV_9280_10_OR_LATER(ah)) {
@@ -2094,7 +2094,7 @@ static void ath9k_hw_get_def_gain_boundaries_pdadcs(struct ath_hw *ah,
                 pPdGainBoundaries[i] =
                         min((u16)AR5416_MAX_RATE_POWER, pPdGainBoundaries[i]);
 
-                if ((i == 0) && !AR_SREV_5416_V20_OR_LATER(ah)) {
+                if ((i == 0) && !AR_SREV_5416_20_OR_LATER(ah)) {
                         minDelta = pPdGainBoundaries[0] - 23;
                         pPdGainBoundaries[0] = 23;
                 } else {
@@ -2228,7 +2228,7 @@ static bool ath9k_hw_set_def_power_cal_table(struct ath_hw *ah,
                       xpdGainValues[2]);
 
         for (i = 0; i < AR5416_MAX_CHAINS; i++) {
-                if (AR_SREV_5416_V20_OR_LATER(ah) &&
+                if (AR_SREV_5416_20_OR_LATER(ah) &&
                     (ah->rxchainmask == 5 || ah->txchainmask == 5) &&
                     (i != 0)) {
                         regChainOffset = (i == 1) ? 0x2000 : 0x1000;
@@ -2262,7 +2262,7 @@ static bool ath9k_hw_set_def_power_cal_table(struct ath_hw *ah,
                                                         numXpdGain);
                         }
 
-                        if ((i == 0) || AR_SREV_5416_V20_OR_LATER(ah)) {
+                        if ((i == 0) || AR_SREV_5416_20_OR_LATER(ah)) {
                                 if (OLC_FOR_AR9280_20_LATER) {
                                         REG_WRITE(ah,
                                                 AR_PHY_TPCRG5 + regChainOffset,
diff --git a/drivers/net/wireless/ath9k/eeprom.h b/drivers/net/wireless/ath9k/eeprom.h
index 6296e3eff10b..d6f6108f63c7 100644
--- a/drivers/net/wireless/ath9k/eeprom.h
+++ b/drivers/net/wireless/ath9k/eeprom.h
@@ -261,7 +261,7 @@ struct base_eep_header_4k {
         u16 deviceCap;
         u32 binBuildNumber;
         u8 deviceType;
-        u8 futureBase[1];
+        u8 txGainType;
 } __packed;
 
 
diff --git a/drivers/net/wireless/ath9k/hw.c b/drivers/net/wireless/ath9k/hw.c
index 60e55d8c510b..d494e98ba971 100644
--- a/drivers/net/wireless/ath9k/hw.c
+++ b/drivers/net/wireless/ath9k/hw.c
@@ -682,22 +682,16 @@ static struct ath_hw *ath9k_hw_do_attach(u16 devid, struct ath_softc *sc,
                 ah->supp_cals = ADC_GAIN_CAL | ADC_DC_CAL | IQ_MISMATCH_CAL;
         }
 
-        if (AR_SREV_9160(ah)) {
-                ah->config.enable_ani = 1;
-                ah->ani_function = (ATH9K_ANI_SPUR_IMMUNITY_LEVEL |
-                                        ATH9K_ANI_FIRSTEP_LEVEL);
-        } else {
-                ah->ani_function = ATH9K_ANI_ALL;
-                if (AR_SREV_9280_10_OR_LATER(ah)) {
-                        ah->ani_function &=     ~ATH9K_ANI_NOISE_IMMUNITY_LEVEL;
-                }
-        }
+        ah->ani_function = ATH9K_ANI_ALL;
+        if (AR_SREV_9280_10_OR_LATER(ah))
+                ah->ani_function &= ~ATH9K_ANI_NOISE_IMMUNITY_LEVEL;
 
         DPRINTF(sc, ATH_DBG_RESET,
                 "This Mac Chip Rev 0x%02x.%x is \n",
                 ah->hw_version.macVersion, ah->hw_version.macRev);
 
         if (AR_SREV_9285_12_OR_LATER(ah)) {
+
                 INIT_INI_ARRAY(&ah->iniModes, ar9285Modes_9285_1_2,
                                ARRAY_SIZE(ar9285Modes_9285_1_2), 6);
                 INIT_INI_ARRAY(&ah->iniCommon, ar9285Common_9285_1_2,
@@ -837,6 +831,22 @@ static struct ath_hw *ath9k_hw_do_attach(u16 devid, struct ath_softc *sc,
         if (ecode != 0)
                 goto bad;
 
+        if (AR_SREV_9285_12_OR_LATER(ah)) {
+                u32 txgain_type = ah->eep_ops->get_eeprom(ah, EEP_TXGAIN_TYPE);
+
+                /* txgain table */
+                if (txgain_type == AR5416_EEP_TXGAIN_HIGH_POWER) {
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                        ar9285Modes_high_power_tx_gain_9285_1_2,
+                        ARRAY_SIZE(ar9285Modes_high_power_tx_gain_9285_1_2), 6);
+                } else {
+                        INIT_INI_ARRAY(&ah->iniModesTxGain,
+                        ar9285Modes_original_tx_gain_9285_1_2,
+                        ARRAY_SIZE(ar9285Modes_original_tx_gain_9285_1_2), 6);
+                }
+
+        }
+
         /* rxgain table */
         if (AR_SREV_9280_20(ah))
                 ath9k_hw_init_rxgain_ini(ah);
@@ -1173,7 +1183,7 @@ static void ath9k_hw_override_ini(struct ath_hw *ah,
         REG_SET_BIT(ah, AR_DIAG_SW, (AR_DIAG_RX_DIS | AR_DIAG_RX_ABORT));
 
 
-        if (!AR_SREV_5416_V20_OR_LATER(ah) ||
+        if (!AR_SREV_5416_20_OR_LATER(ah) ||
             AR_SREV_9280_10_OR_LATER(ah))
                 return;
 
@@ -1275,7 +1285,7 @@ static int ath9k_hw_process_ini(struct ath_hw *ah,
         REG_WRITE(ah, AR_PHY_ADC_SERIAL_CTL, AR_PHY_SEL_EXTERNAL_RADIO);
         ah->eep_ops->set_addac(ah, chan);
 
-        if (AR_SREV_5416_V22_OR_LATER(ah)) {
+        if (AR_SREV_5416_22_OR_LATER(ah)) {
                 REG_WRITE_ARRAY(&ah->iniAddac, 1, regWrites);
         } else {
                 struct ar5416IniArray temp;
@@ -1313,7 +1323,8 @@ static int ath9k_hw_process_ini(struct ath_hw *ah,
         if (AR_SREV_9280(ah))
                 REG_WRITE_ARRAY(&ah->iniModesRxGain, modesIndex, regWrites);
 
-        if (AR_SREV_9280(ah))
+        if (AR_SREV_9280(ah) || (AR_SREV_9285(ah) &&
+            AR_SREV_9285_12_OR_LATER(ah)))
                 REG_WRITE_ARRAY(&ah->iniModesTxGain, modesIndex, regWrites);
 
         for (i = 0; i < ah->iniCommon.ia_rows; i++) {
diff --git a/drivers/net/wireless/ath9k/initvals.h b/drivers/net/wireless/ath9k/initvals.h
index d49236368a1c..1d60c3706f1c 100644
--- a/drivers/net/wireless/ath9k/initvals.h
+++ b/drivers/net/wireless/ath9k/initvals.h
@@ -14,7 +14,7 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-static const u32 ar5416Modes_9100[][6] = {
+static const u32 ar5416Modes[][6] = {
     { 0x00001030, 0x00000230, 0x00000460, 0x000002c0, 0x00000160, 0x000001e0 },
     { 0x00001070, 0x00000168, 0x000002d0, 0x00000318, 0x0000018c, 0x000001e0 },
     { 0x000010b0, 0x00000e60, 0x00001cc0, 0x00007c70, 0x00003e38, 0x00001180 },
@@ -78,7 +78,7 @@ static const u32 ar5416Modes_9100[][6] = {
     { 0x0000a334, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 };
 
-static const u32 ar5416Common_9100[][2] = {
+static const u32 ar5416Common[][2] = {
     { 0x0000000c, 0x00000000 },
     { 0x00000030, 0x00020015 },
     { 0x00000034, 0x00000005 },
@@ -456,12 +456,12 @@ static const u32 ar5416Common_9100[][2] = {
     { 0x0000a3e0, 0x000001ce },
 };
 
-static const u32 ar5416Bank0_9100[][2] = {
+static const u32 ar5416Bank0[][2] = {
     { 0x000098b0, 0x1e5795e5 },
     { 0x000098e0, 0x02008020 },
 };
 
-static const u32 ar5416BB_RfGain_9100[][3] = {
+static const u32 ar5416BB_RfGain[][3] = {
     { 0x00009a00, 0x00000000, 0x00000000 },
     { 0x00009a04, 0x00000040, 0x00000040 },
     { 0x00009a08, 0x00000080, 0x00000080 },
@@ -528,21 +528,21 @@ static const u32 ar5416BB_RfGain_9100[][3] = {
     { 0x00009afc, 0x000000f9, 0x000000f9 },
 };
 
-static const u32 ar5416Bank1_9100[][2] = {
+static const u32 ar5416Bank1[][2] = {
     { 0x000098b0, 0x02108421 },
     { 0x000098ec, 0x00000008 },
 };
 
-static const u32 ar5416Bank2_9100[][2] = {
+static const u32 ar5416Bank2[][2] = {
     { 0x000098b0, 0x0e73ff17 },
     { 0x000098e0, 0x00000420 },
 };
 
-static const u32 ar5416Bank3_9100[][3] = {
+static const u32 ar5416Bank3[][3] = {
     { 0x000098f0, 0x01400018, 0x01c00018 },
 };
 
-static const u32 ar5416Bank6_9100[][3] = {
+static const u32 ar5416Bank6[][3] = {
 
     { 0x0000989c, 0x00000000, 0x00000000 },
     { 0x0000989c, 0x00000000, 0x00000000 },
@@ -579,7 +579,7 @@ static const u32 ar5416Bank6_9100[][3] = {
     { 0x000098d0, 0x0000000f, 0x0010000f },
 };
 
-static const u32 ar5416Bank6TPC_9100[][3] = {
+static const u32 ar5416Bank6TPC[][3] = {
     { 0x0000989c, 0x00000000, 0x00000000 },
     { 0x0000989c, 0x00000000, 0x00000000 },
     { 0x0000989c, 0x00000000, 0x00000000 },
@@ -615,13 +615,13 @@ static const u32 ar5416Bank6TPC_9100[][3] = {
     { 0x000098d0, 0x0000000f, 0x0010000f },
 };
 
-static const u32 ar5416Bank7_9100[][2] = {
+static const u32 ar5416Bank7[][2] = {
     { 0x0000989c, 0x00000500 },
     { 0x0000989c, 0x00000800 },
     { 0x000098cc, 0x0000000e },
 };
 
-static const u32 ar5416Addac_9100[][2] = {
+static const u32 ar5416Addac[][2] = {
     {0x0000989c,  0x00000000 },
     {0x0000989c,  0x00000003 },
     {0x0000989c,  0x00000000 },
@@ -661,7 +661,7 @@ static const u32 ar5416Addac_9100[][2] = {
     {0x000098cc,  0x00000000 },
 };
 
-static const u32 ar5416Modes[][6] = {
+static const u32 ar5416Modes_9100[][6] = {
     { 0x00001030, 0x00000230, 0x00000460, 0x000002c0, 0x00000160, 0x000001e0 },
     { 0x00001070, 0x00000168, 0x000002d0, 0x00000318, 0x0000018c, 0x000001e0 },
     { 0x000010b0, 0x00000e60, 0x00001cc0, 0x00007c70, 0x00003e38, 0x00001180 },
@@ -735,7 +735,7 @@ static const u32 ar5416Modes[][6] = {
     { 0x0000a334, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 };
 
-static const u32 ar5416Common[][2] = {
+static const u32 ar5416Common_9100[][2] = {
     { 0x0000000c, 0x00000000 },
     { 0x00000030, 0x00020015 },
     { 0x00000034, 0x00000005 },
@@ -1109,12 +1109,12 @@ static const u32 ar5416Common[][2] = {
     { 0x0000a3e0, 0x000001ce },
 };
 
-static const u32 ar5416Bank0[][2] = {
+static const u32 ar5416Bank0_9100[][2] = {
     { 0x000098b0, 0x1e5795e5 },
     { 0x000098e0, 0x02008020 },
 };
 
-static const u32 ar5416BB_RfGain[][3] = {
+static const u32 ar5416BB_RfGain_9100[][3] = {
     { 0x00009a00, 0x00000000, 0x00000000 },
     { 0x00009a04, 0x00000040, 0x00000040 },
     { 0x00009a08, 0x00000080, 0x00000080 },
@@ -1181,21 +1181,21 @@ static const u32 ar5416BB_RfGain[][3] = {
     { 0x00009afc, 0x000000f9, 0x000000f9 },
 };
 
-static const u32 ar5416Bank1[][2] = {
+static const u32 ar5416Bank1_9100[][2] = {
     { 0x000098b0, 0x02108421},
     { 0x000098ec, 0x00000008},
 };
 
-static const u32 ar5416Bank2[][2] = {
+static const u32 ar5416Bank2_9100[][2] = {
     { 0x000098b0, 0x0e73ff17},
     { 0x000098e0, 0x00000420},
 };
 
-static const u32 ar5416Bank3[][3] = {
+static const u32 ar5416Bank3_9100[][3] = {
     { 0x000098f0, 0x01400018, 0x01c00018 },
 };
 
-static const u32 ar5416Bank6[][3] = {
+static const u32 ar5416Bank6_9100[][3] = {
 
     { 0x0000989c, 0x00000000, 0x00000000 },
     { 0x0000989c, 0x00000000, 0x00000000 },
@@ -1233,7 +1233,7 @@ static const u32 ar5416Bank6[][3] = {
 };
 
 
-static const u32 ar5416Bank6TPC[][3] = {
+static const u32 ar5416Bank6TPC_9100[][3] = {
 
     { 0x0000989c, 0x00000000, 0x00000000 },
     { 0x0000989c, 0x00000000, 0x00000000 },
@@ -1270,13 +1270,13 @@ static const u32 ar5416Bank6TPC[][3] = {
     { 0x000098d0, 0x0000000f, 0x0010000f },
 };
 
-static const u32 ar5416Bank7[][2] = {
+static const u32 ar5416Bank7_9100[][2] = {
     { 0x0000989c, 0x00000500 },
     { 0x0000989c, 0x00000800 },
     { 0x000098cc, 0x0000000e },
 };
 
-static const u32 ar5416Addac[][2] = {
+static const u32 ar5416Addac_9100[][2] = {
     {0x0000989c, 0x00000000 },
     {0x0000989c, 0x00000000 },
     {0x0000989c, 0x00000000 },
@@ -4121,6 +4121,7 @@ static const u_int32_t ar9285PciePhy_clkreq_off_L1_9285[][2] = {
     {0x00004044,  0x00000000 },
 };
 
+/* AR9285 v1_2 PCI Register Writes.  Created: 03/04/09 */
 static const u_int32_t ar9285Modes_9285_1_2[][6] = {
     { 0x00001030, 0x00000230, 0x00000460, 0x000002c0, 0x00000160, 0x000001e0 },
     { 0x00001070, 0x00000168, 0x000002d0, 0x00000318, 0x0000018c, 0x000001e0 },
@@ -4155,7 +4156,7 @@ static const u_int32_t ar9285Modes_9285_1_2[][6] = {
     { 0x000099bc, 0x00000600, 0x00000600, 0x00000c00, 0x00000c00, 0x00000c00 },
     { 0x000099c0, 0x05eea6d4, 0x05eea6d4, 0x05eea6d4, 0x05eea6d4, 0x05eea6d4 },
     { 0x000099c4, 0x06336f77, 0x06336f77, 0x06336f77, 0x06336f77, 0x06336f77 },
-    { 0x000099c8, 0x60f65329, 0x60f65329, 0x60f65329, 0x60f65329, 0x60f65329 },
+    { 0x000099c8, 0x6af65329, 0x6af65329, 0x6af65329, 0x6af65329, 0x6af65329 },
     { 0x000099cc, 0x08f186c8, 0x08f186c8, 0x08f186c8, 0x08f186c8, 0x08f186c8 },
     { 0x000099d0, 0x00046384, 0x00046384, 0x00046384, 0x00046384, 0x00046384 },
     { 0x000099d4, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
@@ -4421,25 +4422,6 @@ static const u_int32_t ar9285Modes_9285_1_2[][6] = {
     { 0x0000a21c, 0x1883800a, 0x1883800a, 0x1883800a, 0x1883800a, 0x1883800a },
     { 0x0000a230, 0x00000000, 0x00000000, 0x00000210, 0x00000108, 0x00000000 },
     { 0x0000a250, 0x0004f000, 0x0004f000, 0x0004a000, 0x0004a000, 0x0004a000 },
-    { 0x0000a274, 0x0a81c652, 0x0a81c652, 0x0a820652, 0x0a820652, 0x0a82a652 },
-    { 0x0000a300, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
-    { 0x0000a304, 0x00000000, 0x00000000, 0x00007201, 0x00007201, 0x00000000 },
-    { 0x0000a308, 0x00000000, 0x00000000, 0x00010408, 0x00010408, 0x00000000 },
-    { 0x0000a30c, 0x00000000, 0x00000000, 0x0001860a, 0x0001860a, 0x00000000 },
-    { 0x0000a310, 0x00000000, 0x00000000, 0x00020818, 0x00020818, 0x00000000 },
-    { 0x0000a314, 0x00000000, 0x00000000, 0x00024858, 0x00024858, 0x00000000 },
-    { 0x0000a318, 0x00000000, 0x00000000, 0x00026859, 0x00026859, 0x00000000 },
-    { 0x0000a31c, 0x00000000, 0x00000000, 0x0002985b, 0x0002985b, 0x00000000 },
-    { 0x0000a320, 0x00000000, 0x00000000, 0x0002b89a, 0x0002b89a, 0x00000000 },
-    { 0x0000a324, 0x00000000, 0x00000000, 0x0002d89b, 0x0002d89b, 0x00000000 },
-    { 0x0000a328, 0x00000000, 0x00000000, 0x0002f89c, 0x0002f89c, 0x00000000 },
-    { 0x0000a32c, 0x00000000, 0x00000000, 0x0003189d, 0x0003189d, 0x00000000 },
-    { 0x0000a330, 0x00000000, 0x00000000, 0x0003389e, 0x0003389e, 0x00000000 },
-    { 0x0000a334, 0x00000000, 0x00000000, 0x000368de, 0x000368de, 0x00000000 },
-    { 0x0000a338, 0x00000000, 0x00000000, 0x0003891e, 0x0003891e, 0x00000000 },
-    { 0x0000a33c, 0x00000000, 0x00000000, 0x0003a95e, 0x0003a95e, 0x00000000 },
-    { 0x0000a340, 0x00000000, 0x00000000, 0x0003e9df, 0x0003e9df, 0x00000000 },
-    { 0x0000a344, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
     { 0x0000a358, 0x7999aa02, 0x7999aa02, 0x7999aa0e, 0x7999aa0e, 0x7999aa0e },
 };
 
@@ -4569,7 +4551,7 @@ static const u_int32_t ar9285Common_9285_1_2[][2] = {
     { 0x00008110, 0x00000168 },
     { 0x00008118, 0x000100aa },
     { 0x0000811c, 0x00003210 },
-    { 0x00008120, 0x08f04800 },
+    { 0x00008120, 0x08f04810 },
     { 0x00008124, 0x00000000 },
     { 0x00008128, 0x00000000 },
     { 0x0000812c, 0x00000000 },
@@ -4585,7 +4567,7 @@ static const u_int32_t ar9285Common_9285_1_2[][2] = {
     { 0x00008178, 0x00000100 },
     { 0x0000817c, 0x00000000 },
     { 0x000081c0, 0x00000000 },
-    { 0x000081d0, 0x00003210 },
+    { 0x000081d0, 0x0000320a },
     { 0x000081ec, 0x00000000 },
     { 0x000081f0, 0x00000000 },
     { 0x000081f4, 0x00000000 },
@@ -4709,8 +4691,6 @@ static const u_int32_t ar9285Common_9285_1_2[][2] = {
     { 0x0000a268, 0x00000000 },
     { 0x0000a26c, 0x0ebae9e6 },
     { 0x0000d270, 0x0d820820 },
-    { 0x0000a278, 0x318c6318 },
-    { 0x0000a27c, 0x050c0318 },
     { 0x0000d35c, 0x07ffffef },
     { 0x0000d360, 0x0fffffe7 },
     { 0x0000d364, 0x17ffffe5 },
@@ -4725,8 +4705,6 @@ static const u_int32_t ar9285Common_9285_1_2[][2] = {
     { 0x0000a388, 0x0c000000 },
     { 0x0000a38c, 0x20202020 },
     { 0x0000a390, 0x20202020 },
-    { 0x0000a394, 0x318c6318 },
-    { 0x0000a398, 0x00000318 },
     { 0x0000a39c, 0x00000001 },
     { 0x0000a3a0, 0x00000000 },
     { 0x0000a3a4, 0x00000000 },
@@ -4741,8 +4719,6 @@ static const u_int32_t ar9285Common_9285_1_2[][2] = {
     { 0x0000a3cc, 0x20202020 },
     { 0x0000a3d0, 0x20202020 },
     { 0x0000a3d4, 0x20202020 },
-    { 0x0000a3dc, 0x318c6318 },
-    { 0x0000a3e0, 0x00000318 },
     { 0x0000a3e4, 0x00000000 },
     { 0x0000a3e8, 0x18c43433 },
     { 0x0000a3ec, 0x00f70081 },
@@ -4753,13 +4729,11 @@ static const u_int32_t ar9285Common_9285_1_2[][2] = {
     { 0x00007810, 0x71c0d388 },
     { 0x00007814, 0x924934a8 },
     { 0x0000781c, 0x00000000 },
-    { 0x00007820, 0x00000c04 },
     { 0x00007824, 0x00d86fff },
     { 0x00007828, 0x26d2491b },
     { 0x0000782c, 0x6e36d97b },
     { 0x00007830, 0xedb6d96e },
     { 0x00007834, 0x71400087 },
-    { 0x00007838, 0xfac68801 },
     { 0x0000783c, 0x0001fffe },
     { 0x00007840, 0xffeb1a20 },
     { 0x00007844, 0x000c0db6 },
@@ -4772,10 +4746,81 @@ static const u_int32_t ar9285Common_9285_1_2[][2] = {
     { 0x00007860, 0x21084210 },
     { 0x00007864, 0xf7d7ffde },
     { 0x00007868, 0xc2034080 },
-    { 0x0000786c, 0x48609eb4 },
     { 0x00007870, 0x10142c00 },
 };
 
+static const u_int32_t ar9285Modes_high_power_tx_gain_9285_1_2[][6] = {
+    /* Address      5G-HT20     5G-HT40     2G-HT40     2G-HT20     Turbo   */
+    { 0x0000a300, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
+    { 0x0000a304, 0x00000000, 0x00000000, 0x00005200, 0x00005200, 0x00000000 },
+    { 0x0000a308, 0x00000000, 0x00000000, 0x00007201, 0x00007201, 0x00000000 },
+    { 0x0000a30c, 0x00000000, 0x00000000, 0x0000b240, 0x0000b240, 0x00000000 },
+    { 0x0000a310, 0x00000000, 0x00000000, 0x0000d241, 0x0000d241, 0x00000000 },
+    { 0x0000a314, 0x00000000, 0x00000000, 0x0000f440, 0x0000f440, 0x00000000 },
+    { 0x0000a318, 0x00000000, 0x00000000, 0x00014640, 0x00014640, 0x00000000 },
+    { 0x0000a31c, 0x00000000, 0x00000000, 0x00018680, 0x00018680, 0x00000000 },
+    { 0x0000a320, 0x00000000, 0x00000000, 0x00019841, 0x00019841, 0x00000000 },
+    { 0x0000a324, 0x00000000, 0x00000000, 0x0001ca40, 0x0001ca40, 0x00000000 },
+    { 0x0000a328, 0x00000000, 0x00000000, 0x0001fa80, 0x0001fa80, 0x00000000 },
+    { 0x0000a32c, 0x00000000, 0x00000000, 0x00023ac0, 0x00023ac0, 0x00000000 },
+    { 0x0000a330, 0x00000000, 0x00000000, 0x0002ab40, 0x0002ab40, 0x00000000 },
+    { 0x0000a334, 0x00000000, 0x00000000, 0x00033d82, 0x00033d82, 0x00000000 },
+    { 0x0000a338, 0x0003891e, 0x0003891e, 0x0003891e, 0x0003891e, 0x00000000 },
+    { 0x0000a33c, 0x0003a95e, 0x0003a95e, 0x0003a95e, 0x0003a95e, 0x00000000 },
+    { 0x0000a340, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a344, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a348, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a34c, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a350, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a354, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x00007838, 0xfac68803, 0xfac68803, 0xfac68803, 0xfac68803, 0xfac68803 },
+    { 0x0000786c, 0x08609ebe, 0x08609ebe, 0x08609ebe, 0x08609ebe, 0x08609ebe },
+    { 0x00007820, 0x00000c00, 0x00000c00, 0x00000c00, 0x00000c00, 0x00000c00 },
+    { 0x0000a274, 0x0a22a652, 0x0a22a652, 0x0a21a652, 0x0a21a652, 0x0a22a652 },
+    { 0x0000a278, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce },
+    { 0x0000a27c, 0x050701ce, 0x050701ce, 0x050701ce, 0x050701ce, 0x050701ce },
+    { 0x0000a394, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce },
+    { 0x0000a398, 0x000001ce, 0x000001ce, 0x000001ce, 0x000001ce, 0x000001ce },
+    { 0x0000a3dc, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce, 0x1ce739ce },
+    { 0x0000a3e0, 0x000001ce, 0x000001ce, 0x000001ce, 0x000001ce, 0x000001ce },
+};
+
+static const u_int32_t ar9285Modes_original_tx_gain_9285_1_2[][6] = {
+    /* Address      5G-HT20     5G-HT40     2G-HT40     2G-HT20     Turbo   */
+    { 0x0000a300, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
+    { 0x0000a304, 0x00000000, 0x00000000, 0x00009200, 0x00009200, 0x00000000 },
+    { 0x0000a308, 0x00000000, 0x00000000, 0x00010208, 0x00010208, 0x00000000 },
+    { 0x0000a30c, 0x00000000, 0x00000000, 0x00019608, 0x00019608, 0x00000000 },
+    { 0x0000a310, 0x00000000, 0x00000000, 0x00022618, 0x00022618, 0x00000000 },
+    { 0x0000a314, 0x00000000, 0x00000000, 0x0002a6c9, 0x0002a6c9, 0x00000000 },
+    { 0x0000a318, 0x00000000, 0x00000000, 0x00031710, 0x00031710, 0x00000000 },
+    { 0x0000a31c, 0x00000000, 0x00000000, 0x00035718, 0x00035718, 0x00000000 },
+    { 0x0000a320, 0x00000000, 0x00000000, 0x00038758, 0x00038758, 0x00000000 },
+    { 0x0000a324, 0x00000000, 0x00000000, 0x0003c75a, 0x0003c75a, 0x00000000 },
+    { 0x0000a328, 0x00000000, 0x00000000, 0x0004075c, 0x0004075c, 0x00000000 },
+    { 0x0000a32c, 0x00000000, 0x00000000, 0x0004475e, 0x0004475e, 0x00000000 },
+    { 0x0000a330, 0x00000000, 0x00000000, 0x0004679f, 0x0004679f, 0x00000000 },
+    { 0x0000a334, 0x00000000, 0x00000000, 0x000487df, 0x000487df, 0x00000000 },
+    { 0x0000a338, 0x0003891e, 0x0003891e, 0x0003891e, 0x0003891e, 0x00000000 },
+    { 0x0000a33c, 0x0003a95e, 0x0003a95e, 0x0003a95e, 0x0003a95e, 0x00000000 },
+    { 0x0000a340, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a344, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a348, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a34c, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a350, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x0000a354, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x0003e9df, 0x00000000 },
+    { 0x00007838, 0xfac68801, 0xfac68801, 0xfac68801, 0xfac68801, 0xfac68801 },
+    { 0x0000786c, 0x48609eb4, 0x48609eb4, 0x48609eb4, 0x48609eb4, 0x48609eb4 },
+    { 0x00007820, 0x00000c04, 0x00000c04, 0x00000c04, 0x00000c04, 0x00000c04 },
+    { 0x0000a274, 0x0a21c652, 0x0a21c652, 0x0a21a652, 0x0a21a652, 0x0a22a652 },
+    { 0x0000a278, 0x39ce739c, 0x39ce739c, 0x39ce739c, 0x39ce739c, 0x39ce739c },
+    { 0x0000a27c, 0x050e039c, 0x050e039c, 0x050e039c, 0x050e039c, 0x050e039c },
+    { 0x0000a394, 0x39ce739c, 0x39ce739c, 0x39ce739c, 0x39ce739c, 0x39ce739c },
+    { 0x0000a398, 0x0000039c, 0x0000039c, 0x0000039c, 0x0000039c, 0x0000039c },
+    { 0x0000a3dc, 0x39ce739c, 0x39ce739c, 0x39ce739c, 0x39ce739c, 0x39ce739c },
+    { 0x0000a3e0, 0x0000039c, 0x0000039c, 0x0000039c, 0x0000039c, 0x0000039c },
+};
+
 static const u_int32_t ar9285PciePhy_clkreq_always_on_L1_9285_1_2[][2] = {
     {0x00004040,  0x9248fd00 },
     {0x00004040,  0x24924924 },
diff --git a/drivers/net/wireless/ath9k/mac.h b/drivers/net/wireless/ath9k/mac.h
index 37e3948ddc25..a75f65dae1d7 100644
--- a/drivers/net/wireless/ath9k/mac.h
+++ b/drivers/net/wireless/ath9k/mac.h
@@ -17,7 +17,7 @@
 #ifndef MAC_H
 #define MAC_H
 
-#define RXSTATUS_RATE(ah, ads) (AR_SREV_5416_V20_OR_LATER(ah) ?         \
+#define RXSTATUS_RATE(ah, ads) (AR_SREV_5416_20_OR_LATER(ah) ?          \
                                 MS(ads->ds_rxstatus0, AR_RxRate) :      \
                                 (ads->ds_rxstatus3 >> 2) & 0xFF)
 
diff --git a/drivers/net/wireless/ath9k/main.c b/drivers/net/wireless/ath9k/main.c
index a9715f5b0af6..8db75f6de53e 100644
--- a/drivers/net/wireless/ath9k/main.c
+++ b/drivers/net/wireless/ath9k/main.c
@@ -1084,12 +1084,6 @@ fail:
         ath_deinit_leds(sc);
 }
 
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
-
-/*******************/
-/*      Rfkill     */
-/*******************/
-
 void ath_radio_enable(struct ath_softc *sc)
 {
         struct ath_hw *ah = sc->sc_ah;
@@ -1166,6 +1160,12 @@ void ath_radio_disable(struct ath_softc *sc)
         ath9k_ps_restore(sc);
 }
 
+#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
+
+/*******************/
+/*      Rfkill     */
+/*******************/
+
 static bool ath_is_rfkill_set(struct ath_softc *sc)
 {
         struct ath_hw *ah = sc->sc_ah;
@@ -1583,7 +1583,8 @@ void ath_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
                 IEEE80211_HW_SIGNAL_DBM |
                 IEEE80211_HW_AMPDU_AGGREGATION |
                 IEEE80211_HW_SUPPORTS_PS |
-                IEEE80211_HW_PS_NULLFUNC_STACK;
+                IEEE80211_HW_PS_NULLFUNC_STACK |
+                IEEE80211_HW_SPECTRUM_MGMT;
 
         if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || modparam_nohwcrypt)
                 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
@@ -1671,7 +1672,7 @@ int ath_attach(u16 devid, struct ath_softc *sc)
         }
         wiphy_apply_custom_regulatory(hw->wiphy, regd);
         ath9k_reg_apply_radar_flags(hw->wiphy);
-        ath9k_reg_apply_world_flags(hw->wiphy, REGDOM_SET_BY_INIT);
+        ath9k_reg_apply_world_flags(hw->wiphy, NL80211_REGDOM_SET_BY_DRIVER);
 
         INIT_WORK(&sc->chan_work, ath9k_wiphy_chan_work);
         INIT_DELAYED_WORK(&sc->wiphy_work, ath9k_wiphy_work);
@@ -1774,6 +1775,7 @@ int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
         DPRINTF(sc, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
                 name, nbuf, ndesc);
 
+        INIT_LIST_HEAD(head);
         /* ath_desc must be a multiple of DWORDs */
         if ((sizeof(struct ath_desc) % 4) != 0) {
                 DPRINTF(sc, ATH_DBG_FATAL, "ath_desc not DWORD aligned\n");
@@ -1805,7 +1807,7 @@ int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
 
         /* allocate descriptors */
         dd->dd_desc = dma_alloc_coherent(sc->dev, dd->dd_desc_len,
-                                         &dd->dd_desc_paddr, GFP_ATOMIC);
+                                         &dd->dd_desc_paddr, GFP_KERNEL);
         if (dd->dd_desc == NULL) {
                 error = -ENOMEM;
                 goto fail;
@@ -1817,15 +1819,13 @@ int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
 
         /* allocate buffers */
         bsize = sizeof(struct ath_buf) * nbuf;
-        bf = kmalloc(bsize, GFP_KERNEL);
+        bf = kzalloc(bsize, GFP_KERNEL);
         if (bf == NULL) {
                 error = -ENOMEM;
                 goto fail2;
         }
-        memset(bf, 0, bsize);
         dd->dd_bufptr = bf;
 
-        INIT_LIST_HEAD(head);
         for (i = 0; i < nbuf; i++, bf++, ds += ndesc) {
                 bf->bf_desc = ds;
                 bf->bf_daddr = DS2PHYS(dd, ds);
@@ -2859,12 +2859,20 @@ static int __init ath9k_init(void)
                 goto err_out;
         }
 
+        error = ath9k_debug_create_root();
+        if (error) {
+                printk(KERN_ERR
+                        "ath9k: Unable to create debugfs root: %d\n",
+                        error);
+                goto err_rate_unregister;
+        }
+
         error = ath_pci_init();
         if (error < 0) {
                 printk(KERN_ERR
                         "ath9k: No PCI devices found, driver not installed.\n");
                 error = -ENODEV;
-                goto err_rate_unregister;
+                goto err_remove_root;
         }
 
         error = ath_ahb_init();
@@ -2878,6 +2886,8 @@ static int __init ath9k_init(void)
  err_pci_exit:
         ath_pci_exit();
 
+ err_remove_root:
+        ath9k_debug_remove_root();
  err_rate_unregister:
         ath_rate_control_unregister();
  err_out:
@@ -2889,6 +2899,7 @@ static void __exit ath9k_exit(void)
 {
         ath_ahb_exit();
         ath_pci_exit();
+        ath9k_debug_remove_root();
         ath_rate_control_unregister();
         printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
 }
diff --git a/drivers/net/wireless/ath9k/phy.h b/drivers/net/wireless/ath9k/phy.h
index 6222e32c7748..1eac8c707342 100644
--- a/drivers/net/wireless/ath9k/phy.h
+++ b/drivers/net/wireless/ath9k/phy.h
@@ -446,6 +446,9 @@ bool ath9k_hw_init_rf(struct ath_hw *ah,
 #define AR_PHY_TPCRG1_PD_GAIN_3    0x00300000
 #define AR_PHY_TPCRG1_PD_GAIN_3_S  20
 
+#define AR_PHY_TPCRG1_PD_CAL_ENABLE   0x00400000
+#define AR_PHY_TPCRG1_PD_CAL_ENABLE_S 22
+
 #define AR_PHY_TX_PWRCTRL4       0xa264
 #define AR_PHY_TX_PWRCTRL_PD_AVG_VALID     0x00000001
 #define AR_PHY_TX_PWRCTRL_PD_AVG_VALID_S   0
@@ -513,6 +516,7 @@ bool ath9k_hw_init_rf(struct ath_hw *ah,
 /* Carrier leak calibration control, do it after AGC calibration */
 #define AR_PHY_CL_CAL_CTL       0xA358
 #define AR_PHY_CL_CAL_ENABLE    0x00000002
+#define AR_PHY_PARALLEL_CAL_ENABLE    0x00000001
 
 #define AR_PHY_POWER_TX_RATE5   0xA38C
 #define AR_PHY_POWER_TX_RATE6   0xA390
diff --git a/drivers/net/wireless/ath9k/recv.c b/drivers/net/wireless/ath9k/recv.c
index 3df5c7824360..0bba17662a1f 100644
--- a/drivers/net/wireless/ath9k/recv.c
+++ b/drivers/net/wireless/ath9k/recv.c
@@ -100,7 +100,7 @@ static u64 ath_extend_tsf(struct ath_softc *sc, u32 rstamp)
         return (tsf & ~0x7fff) | rstamp;
 }
 
-static struct sk_buff *ath_rxbuf_alloc(struct ath_softc *sc, u32 len)
+static struct sk_buff *ath_rxbuf_alloc(struct ath_softc *sc, u32 len, gfp_t gfp_mask)
 {
         struct sk_buff *skb;
         u32 off;
@@ -118,7 +118,7 @@ static struct sk_buff *ath_rxbuf_alloc(struct ath_softc *sc, u32 len)
          * Unfortunately this means we may get 8 KB here from the
          * kernel... and that is actually what is observed on some
          * systems :( */
-        skb = dev_alloc_skb(len + sc->cachelsz - 1);
+        skb = __dev_alloc_skb(len + sc->cachelsz - 1, gfp_mask);
         if (skb != NULL) {
                 off = ((unsigned long) skb->data) % sc->cachelsz;
                 if (off != 0)
@@ -306,7 +306,7 @@ int ath_rx_init(struct ath_softc *sc, int nbufs)
                 }
 
                 list_for_each_entry(bf, &sc->rx.rxbuf, list) {
-                        skb = ath_rxbuf_alloc(sc, sc->rx.bufsize);
+                        skb = ath_rxbuf_alloc(sc, sc->rx.bufsize, GFP_KERNEL);
                         if (skb == NULL) {
                                 error = -ENOMEM;
                                 break;
@@ -385,14 +385,15 @@ u32 ath_calcrxfilter(struct ath_softc *sc)
         if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
                 rfilt |= ATH9K_RX_FILTER_PROBEREQ;
 
-        /* Can't set HOSTAP into promiscous mode */
+        /*
+         * Set promiscuous mode when FIF_PROMISC_IN_BSS is enabled for station
+         * mode interface or when in monitor mode. AP mode does not need this
+         * since it receives all in-BSS frames anyway.
+         */
         if (((sc->sc_ah->opmode != NL80211_IFTYPE_AP) &&
              (sc->rx.rxfilter & FIF_PROMISC_IN_BSS)) ||
-            (sc->sc_ah->opmode == NL80211_IFTYPE_MONITOR)) {
+            (sc->sc_ah->opmode == NL80211_IFTYPE_MONITOR))
                 rfilt |= ATH9K_RX_FILTER_PROM;
-                /* ??? To prevent from sending ACK */
-                rfilt &= ~ATH9K_RX_FILTER_UCAST;
-        }
 
         if (sc->rx.rxfilter & FIF_CONTROL)
                 rfilt |= ATH9K_RX_FILTER_CONTROL;
@@ -580,7 +581,7 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush)
 
                 /* Ensure we always have an skb to requeue once we are done
                  * processing the current buffer's skb */
-                requeue_skb = ath_rxbuf_alloc(sc, sc->rx.bufsize);
+                requeue_skb = ath_rxbuf_alloc(sc, sc->rx.bufsize, GFP_ATOMIC);
 
                 /* If there is no memory we ignore the current RX'd frame,
                  * tell hardware it can give us a new frame using the old
diff --git a/drivers/net/wireless/ath9k/reg.h b/drivers/net/wireless/ath9k/reg.h
index 91442da18183..d86e90e38173 100644
--- a/drivers/net/wireless/ath9k/reg.h
+++ b/drivers/net/wireless/ath9k/reg.h
@@ -158,14 +158,6 @@
 #define AR_CST_TIMEOUT_LIMIT      0xFFFF0000
 #define AR_CST_TIMEOUT_LIMIT_S    16
 
-#define AR_SREV_VERSION_9100                  0x014
-
-#define AR_SREV_9100(ah) ((ah->hw_version.macVersion) == AR_SREV_VERSION_9100)
-#define AR_SREV_5416_V20_OR_LATER(_ah) \
-        (AR_SREV_9100((_ah)) || AR_SREV_5416_20_OR_LATER(_ah))
-#define AR_SREV_5416_V22_OR_LATER(_ah) \
-        (AR_SREV_9100((_ah)) || AR_SREV_5416_22_OR_LATER(_ah))
-
 #define AR_ISR               0x0080
 #define AR_ISR_RXOK          0x00000001
 #define AR_ISR_RXDESC        0x00000002
@@ -734,6 +726,7 @@
 #define AR_SREV_REVISION_5416_10               0
 #define AR_SREV_REVISION_5416_20               1
 #define AR_SREV_REVISION_5416_22               2
+#define AR_SREV_VERSION_9100                  0x14
 #define AR_SREV_VERSION_9160                  0x40
 #define AR_SREV_REVISION_9160_10              0
 #define AR_SREV_REVISION_9160_11              1
@@ -746,14 +739,23 @@
 #define AR_SREV_REVISION_9285_11              1
 #define AR_SREV_REVISION_9285_12              2
 
-#define AR_SREV_9100_OR_LATER(_ah) \
-        (((_ah)->hw_version.macVersion >= AR_SREV_VERSION_5416_PCIE))
+#define AR_SREV_5416(_ah) \
+        (((_ah)->hw_version.macVersion == AR_SREV_VERSION_5416_PCI) || \
+         ((_ah)->hw_version.macVersion == AR_SREV_VERSION_5416_PCIE))
 #define AR_SREV_5416_20_OR_LATER(_ah) \
-        (((_ah)->hw_version.macVersion >= AR_SREV_VERSION_9160) || \
-                ((_ah)->hw_version.macRev >= AR_SREV_REVISION_5416_20))
+        (((AR_SREV_5416(_ah)) && \
+         ((_ah)->hw_version.macRev >= AR_SREV_REVISION_5416_20)) || \
+         ((_ah)->hw_version.macVersion >= AR_SREV_VERSION_9100))
 #define AR_SREV_5416_22_OR_LATER(_ah) \
-        (((_ah)->hw_version.macVersion >= AR_SREV_VERSION_9160) || \
-                ((_ah)->hw_version.macRev >= AR_SREV_REVISION_5416_22))
+        (((AR_SREV_5416(_ah)) && \
+         ((_ah)->hw_version.macRev >= AR_SREV_REVISION_5416_22)) || \
+         ((_ah)->hw_version.macVersion >= AR_SREV_VERSION_9100))
+
+#define AR_SREV_9100(ah) \
+        ((ah->hw_version.macVersion) == AR_SREV_VERSION_9100)
+#define AR_SREV_9100_OR_LATER(_ah) \
+        (((_ah)->hw_version.macVersion >= AR_SREV_VERSION_9100))
+
 #define AR_SREV_9160(_ah) \
         (((_ah)->hw_version.macVersion == AR_SREV_VERSION_9160))
 #define AR_SREV_9160_10_OR_LATER(_ah) \
@@ -778,14 +780,14 @@
 #define AR_SREV_9285_10_OR_LATER(_ah) \
         (((_ah)->hw_version.macVersion >= AR_SREV_VERSION_9285))
 #define AR_SREV_9285_11(_ah) \
-        (AR_SREV_9280(ah) && \
+        (AR_SREV_9285(ah) && \
          ((_ah)->hw_version.macRev == AR_SREV_REVISION_9285_11))
 #define AR_SREV_9285_11_OR_LATER(_ah) \
         (((_ah)->hw_version.macVersion > AR_SREV_VERSION_9285) || \
          (AR_SREV_9285(ah) && ((_ah)->hw_version.macRev >= \
                                AR_SREV_REVISION_9285_11)))
 #define AR_SREV_9285_12(_ah) \
-        (AR_SREV_9280(ah) && \
+        (AR_SREV_9285(ah) && \
          ((_ah)->hw_version.macRev == AR_SREV_REVISION_9285_12))
 #define AR_SREV_9285_12_OR_LATER(_ah) \
         (((_ah)->hw_version.macVersion > AR_SREV_VERSION_9285) || \
diff --git a/drivers/net/wireless/ath9k/regd.c b/drivers/net/wireless/ath9k/regd.c
index 639da975bf54..b8f9b6d6bec4 100644
--- a/drivers/net/wireless/ath9k/regd.c
+++ b/drivers/net/wireless/ath9k/regd.c
@@ -168,8 +168,9 @@ static bool ath9k_is_radar_freq(u16 center_freq)
  *   received a beacon on a channel we can enable active scan and
  *   adhoc (or beaconing).
  */
-static void ath9k_reg_apply_beaconing_flags(struct wiphy *wiphy,
-                                             enum reg_set_by setby)
+static void ath9k_reg_apply_beaconing_flags(
+        struct wiphy *wiphy,
+        enum nl80211_reg_initiator initiator)
 {
         enum ieee80211_band band;
         struct ieee80211_supported_band *sband;
@@ -194,7 +195,7 @@ static void ath9k_reg_apply_beaconing_flags(struct wiphy *wiphy,
                             (ch->flags & IEEE80211_CHAN_RADAR))
                                 continue;
 
-                        if (setby == REGDOM_SET_BY_COUNTRY_IE) {
+                        if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
                                 r = freq_reg_info(wiphy, ch->center_freq,
                                         &bandwidth, &reg_rule);
                                 if (r)
@@ -226,8 +227,9 @@ static void ath9k_reg_apply_beaconing_flags(struct wiphy *wiphy,
 }
 
 /* Allows active scan scan on Ch 12 and 13 */
-static void ath9k_reg_apply_active_scan_flags(struct wiphy *wiphy,
-                                              enum reg_set_by setby)
+static void ath9k_reg_apply_active_scan_flags(
+        struct wiphy *wiphy,
+        enum nl80211_reg_initiator initiator)
 {
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *ch;
@@ -241,7 +243,7 @@ static void ath9k_reg_apply_active_scan_flags(struct wiphy *wiphy,
          * If no country IE has been received always enable active scan
          * on these channels. This is only done for specific regulatory SKUs
          */
-        if (setby != REGDOM_SET_BY_COUNTRY_IE) {
+        if (initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
                 ch = &sband->channels[11]; /* CH 12 */
                 if (ch->flags & IEEE80211_CHAN_PASSIVE_SCAN)
                         ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
@@ -308,7 +310,8 @@ void ath9k_reg_apply_radar_flags(struct wiphy *wiphy)
         }
 }
 
-void ath9k_reg_apply_world_flags(struct wiphy *wiphy, enum reg_set_by setby)
+void ath9k_reg_apply_world_flags(struct wiphy *wiphy,
+                                 enum nl80211_reg_initiator initiator)
 {
         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
         struct ath_wiphy *aphy = hw->priv;
@@ -320,11 +323,11 @@ void ath9k_reg_apply_world_flags(struct wiphy *wiphy, enum reg_set_by setby)
         case 0x63:
         case 0x66:
         case 0x67:
-                ath9k_reg_apply_beaconing_flags(wiphy, setby);
+                ath9k_reg_apply_beaconing_flags(wiphy, initiator);
                 break;
         case 0x68:
-                ath9k_reg_apply_beaconing_flags(wiphy, setby);
-                ath9k_reg_apply_active_scan_flags(wiphy, setby);
+                ath9k_reg_apply_beaconing_flags(wiphy, initiator);
+                ath9k_reg_apply_active_scan_flags(wiphy, initiator);
                 break;
         }
         return;
@@ -340,12 +343,11 @@ int ath9k_reg_notifier(struct wiphy *wiphy, struct regulatory_request *request)
         ath9k_reg_apply_radar_flags(wiphy);
 
         switch (request->initiator) {
-        case REGDOM_SET_BY_DRIVER:
-        case REGDOM_SET_BY_INIT:
-        case REGDOM_SET_BY_CORE:
-        case REGDOM_SET_BY_USER:
+        case NL80211_REGDOM_SET_BY_DRIVER:
+        case NL80211_REGDOM_SET_BY_CORE:
+        case NL80211_REGDOM_SET_BY_USER:
                 break;
-        case REGDOM_SET_BY_COUNTRY_IE:
+        case NL80211_REGDOM_SET_BY_COUNTRY_IE:
                 if (ath9k_is_world_regd(sc->sc_ah))
                         ath9k_reg_apply_world_flags(wiphy, request->initiator);
                 break;
diff --git a/drivers/net/wireless/ath9k/regd.h b/drivers/net/wireless/ath9k/regd.h
index d48160d0c0e9..8f885f3bc8df 100644
--- a/drivers/net/wireless/ath9k/regd.h
+++ b/drivers/net/wireless/ath9k/regd.h
@@ -236,7 +236,8 @@ enum CountryCode {
 bool ath9k_is_world_regd(struct ath_hw *ah);
 const struct ieee80211_regdomain *ath9k_world_regdomain(struct ath_hw *ah);
 const struct ieee80211_regdomain *ath9k_default_world_regdomain(void);
-void ath9k_reg_apply_world_flags(struct wiphy *wiphy, enum reg_set_by setby);
+void ath9k_reg_apply_world_flags(struct wiphy *wiphy,
+                                 enum nl80211_reg_initiator initiator);
 void ath9k_reg_apply_radar_flags(struct wiphy *wiphy);
 int ath9k_regd_init(struct ath_hw *ah);
 bool ath9k_regd_is_eeprom_valid(struct ath_hw *ah);
diff --git a/drivers/net/wireless/ath9k/xmit.c b/drivers/net/wireless/ath9k/xmit.c
index a82d2ab7c3a0..e3f376611f85 100644
--- a/drivers/net/wireless/ath9k/xmit.c
+++ b/drivers/net/wireless/ath9k/xmit.c
@@ -55,9 +55,9 @@ static u32 bits_per_symbol[][2] = {
 
 #define IS_HT_RATE(_rate)     ((_rate) & 0x80)
 
-static void ath_tx_send_normal(struct ath_softc *sc, struct ath_txq *txq,
-                               struct ath_atx_tid *tid,
-                               struct list_head *bf_head);
+static void ath_tx_send_ht_normal(struct ath_softc *sc, struct ath_txq *txq,
+                                  struct ath_atx_tid *tid,
+                                  struct list_head *bf_head);
 static void ath_tx_complete_buf(struct ath_softc *sc, struct ath_buf *bf,
                                 struct list_head *bf_q,
                                 int txok, int sendbar);
@@ -152,7 +152,7 @@ static void ath_tx_flush_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
                 ASSERT(!bf_isretried(bf));
                 list_move_tail(&bf->list, &bf_head);
-                ath_tx_send_normal(sc, txq, tid, &bf_head);
+                ath_tx_send_ht_normal(sc, txq, tid, &bf_head);
         }
 
         spin_unlock_bh(&txq->axq_lock);
@@ -891,7 +891,7 @@ struct ath_txq *ath_test_get_txq(struct ath_softc *sc, struct sk_buff *skb)
         spin_lock_bh(&txq->axq_lock);
 
         if (txq->axq_depth >= (ATH_TXBUF - 20)) {
-                DPRINTF(sc, ATH_DBG_FATAL,
+                DPRINTF(sc, ATH_DBG_XMIT,
                         "TX queue: %d is full, depth: %d\n",
                         qnum, txq->axq_depth);
                 ieee80211_stop_queue(sc->hw, skb_get_queue_mapping(skb));
@@ -1238,9 +1238,9 @@ static void ath_tx_send_ampdu(struct ath_softc *sc, struct ath_atx_tid *tid,
         ath_tx_txqaddbuf(sc, txctl->txq, bf_head);
 }
 
-static void ath_tx_send_normal(struct ath_softc *sc, struct ath_txq *txq,
-                               struct ath_atx_tid *tid,
-                               struct list_head *bf_head)
+static void ath_tx_send_ht_normal(struct ath_softc *sc, struct ath_txq *txq,
+                                  struct ath_atx_tid *tid,
+                                  struct list_head *bf_head)
 {
         struct ath_buf *bf;
 
@@ -1256,6 +1256,19 @@ static void ath_tx_send_normal(struct ath_softc *sc, struct ath_txq *txq,
         ath_tx_txqaddbuf(sc, txq, bf_head);
 }
 
+static void ath_tx_send_normal(struct ath_softc *sc, struct ath_txq *txq,
+                               struct list_head *bf_head)
+{
+        struct ath_buf *bf;
+
+        bf = list_first_entry(bf_head, struct ath_buf, list);
+
+        bf->bf_lastbf = bf;
+        bf->bf_nframes = 1;
+        ath_buf_set_rate(sc, bf);
+        ath_tx_txqaddbuf(sc, txq, bf_head);
+}
+
 static enum ath9k_pkt_type get_hw_packet_type(struct sk_buff *skb)
 {
         struct ieee80211_hdr *hdr;
@@ -1522,8 +1535,7 @@ static int ath_tx_setup_buffer(struct ieee80211_hw *hw, struct ath_buf *bf,
 
         bf->bf_frmlen = skb->len + FCS_LEN - (hdrlen & 3);
 
-        if ((conf_is_ht(&sc->hw->conf) && !is_pae(skb) &&
-             (tx_info->flags & IEEE80211_TX_CTL_AMPDU)))
+        if (conf_is_ht(&sc->hw->conf) && !is_pae(skb))
                 bf->bf_state.bf_type |= BUF_HT;
 
         bf->bf_flags = setup_tx_flags(sc, skb, txctl->txq);
@@ -1560,14 +1572,17 @@ static void ath_tx_start_dma(struct ath_softc *sc, struct ath_buf *bf,
 {
         struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu;
         struct ieee80211_tx_info *tx_info =  IEEE80211_SKB_CB(skb);
+        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
         struct ath_node *an = NULL;
         struct list_head bf_head;
         struct ath_desc *ds;
         struct ath_atx_tid *tid;
         struct ath_hw *ah = sc->sc_ah;
         int frm_type;
+        __le16 fc;
 
         frm_type = get_hw_packet_type(skb);
+        fc = hdr->frame_control;
 
         INIT_LIST_HEAD(&bf_head);
         list_add_tail(&bf->list, &bf_head);
@@ -1592,6 +1607,11 @@ static void ath_tx_start_dma(struct ath_softc *sc, struct ath_buf *bf,
                 an = (struct ath_node *)tx_info->control.sta->drv_priv;
                 tid = ATH_AN_2_TID(an, bf->bf_tidno);
 
+                if (!ieee80211_is_data_qos(fc)) {
+                        ath_tx_send_normal(sc, txctl->txq, &bf_head);
+                        goto tx_done;
+                }
+
                 if (ath_aggr_query(sc, an, bf->bf_tidno)) {
                         /*
                          * Try aggregation if it's a unicast data frame
@@ -1603,17 +1623,14 @@ static void ath_tx_start_dma(struct ath_softc *sc, struct ath_buf *bf,
                          * Send this frame as regular when ADDBA
                          * exchange is neither complete nor pending.
                          */
-                        ath_tx_send_normal(sc, txctl->txq,
-                                           tid, &bf_head);
+                        ath_tx_send_ht_normal(sc, txctl->txq,
+                                              tid, &bf_head);
                 }
         } else {
-                bf->bf_lastbf = bf;
-                bf->bf_nframes = 1;
-
-                ath_buf_set_rate(sc, bf);
-                ath_tx_txqaddbuf(sc, txctl->txq, &bf_head);
+                ath_tx_send_normal(sc, txctl->txq, &bf_head);
         }
 
+tx_done:
         spin_unlock_bh(&txctl->txq->axq_lock);
 }
 
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index 91930a2c3c6b..b06835a621a3 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -2,8 +2,8 @@
 
      Driver for Atmel at76c502 at76c504 and at76c506 wireless cards.
 
-        Copyright 2000-2001 ATMEL Corporation.
-        Copyright 2003-2004 Simon Kelley.
+        Copyright 2000-2001 ATMEL Corporation.
+        Copyright 2003-2004 Simon Kelley.
 
     This code was developed from version 2.1.1 of the Atmel drivers,
     released by Atmel corp. under the GPL in December 2002. It also
@@ -89,15 +89,15 @@ static struct {
         const char *fw_file;
         const char *fw_file_ext;
 } fw_table[] = {
-        { ATMEL_FW_TYPE_502,      "atmel_at76c502",      "bin" },
-        { ATMEL_FW_TYPE_502D,     "atmel_at76c502d",     "bin" },
-        { ATMEL_FW_TYPE_502E,     "atmel_at76c502e",     "bin" },
-        { ATMEL_FW_TYPE_502_3COM, "atmel_at76c502_3com", "bin" },
-        { ATMEL_FW_TYPE_504,      "atmel_at76c504",      "bin" },
-        { ATMEL_FW_TYPE_504_2958, "atmel_at76c504_2958", "bin" },
-        { ATMEL_FW_TYPE_504A_2958,"atmel_at76c504a_2958","bin" },
-        { ATMEL_FW_TYPE_506,      "atmel_at76c506",      "bin" },
-        { ATMEL_FW_TYPE_NONE,      NULL,                  NULL }
+        { ATMEL_FW_TYPE_502,            "atmel_at76c502",       "bin" },
+        { ATMEL_FW_TYPE_502D,           "atmel_at76c502d",      "bin" },
+        { ATMEL_FW_TYPE_502E,           "atmel_at76c502e",      "bin" },
+        { ATMEL_FW_TYPE_502_3COM,       "atmel_at76c502_3com",  "bin" },
+        { ATMEL_FW_TYPE_504,            "atmel_at76c504",       "bin" },
+        { ATMEL_FW_TYPE_504_2958,       "atmel_at76c504_2958",  "bin" },
+        { ATMEL_FW_TYPE_504A_2958,      "atmel_at76c504a_2958", "bin" },
+        { ATMEL_FW_TYPE_506,            "atmel_at76c506",       "bin" },
+        { ATMEL_FW_TYPE_NONE,           NULL,                   NULL }
 };
 
 #define MAX_SSID_LENGTH 32
@@ -106,60 +106,60 @@ static struct {
 #define MAX_BSS_ENTRIES 64
 
 /* registers */
-#define GCR  0x00    //      (SIR0)  General Configuration Register
-#define BSR  0x02    //      (SIR1)  Bank Switching Select Register
+#define GCR  0x00    /* (SIR0)  General Configuration Register */
+#define BSR  0x02    /* (SIR1)  Bank Switching Select Register */
 #define AR   0x04
 #define DR   0x08
-#define MR1  0x12    //      Mirror Register 1
-#define MR2  0x14    //      Mirror Register 2
-#define MR3  0x16    //      Mirror Register 3
-#define MR4  0x18    //      Mirror Register 4
+#define MR1  0x12    /* Mirror Register 1 */
+#define MR2  0x14    /* Mirror Register 2 */
+#define MR3  0x16    /* Mirror Register 3 */
+#define MR4  0x18    /* Mirror Register 4 */
 
 #define GPR1                            0x0c
 #define GPR2                            0x0e
 #define GPR3                            0x10
-//
-// Constants for the GCR register.
-//
-#define GCR_REMAP     0x0400          // Remap internal SRAM to 0
-#define GCR_SWRES     0x0080          // BIU reset (ARM and PAI are NOT reset)
-#define GCR_CORES     0x0060          // Core Reset (ARM and PAI are reset)
-#define GCR_ENINT     0x0002          // Enable Interrupts
-#define GCR_ACKINT    0x0008          // Acknowledge Interrupts
-
-#define BSS_SRAM      0x0200          // AMBA module selection --> SRAM
-#define BSS_IRAM      0x0100          // AMBA module selection --> IRAM
-//
-// Constants for the MR registers.
-//
-#define MAC_INIT_COMPLETE       0x0001        // MAC init has been completed
-#define MAC_BOOT_COMPLETE       0x0010        // MAC boot has been completed
-#define MAC_INIT_OK             0x0002        // MAC boot has been completed
+/*
+ * Constants for the GCR register.
+ */
+#define GCR_REMAP     0x0400          /* Remap internal SRAM to 0 */
+#define GCR_SWRES     0x0080          /* BIU reset (ARM and PAI are NOT reset) */
+#define GCR_CORES     0x0060          /* Core Reset (ARM and PAI are reset) */
+#define GCR_ENINT     0x0002          /* Enable Interrupts */
+#define GCR_ACKINT    0x0008          /* Acknowledge Interrupts */
+
+#define BSS_SRAM      0x0200          /* AMBA module selection --> SRAM */
+#define BSS_IRAM      0x0100          /* AMBA module selection --> IRAM */
+/*
+ *Constants for the MR registers.
+ */
+#define MAC_INIT_COMPLETE       0x0001        /* MAC init has been completed */
+#define MAC_BOOT_COMPLETE       0x0010        /* MAC boot has been completed */
+#define MAC_INIT_OK             0x0002        /* MAC boot has been completed */
 
 #define MIB_MAX_DATA_BYTES    212
 #define MIB_HEADER_SIZE       4    /* first four fields */
 
 struct get_set_mib {
-        u8 type;
-        u8 size;
-        u8 index;
-        u8 reserved;
-        u8 data[MIB_MAX_DATA_BYTES];
+        u8 type;
+        u8 size;
+        u8 index;
+        u8 reserved;
+        u8 data[MIB_MAX_DATA_BYTES];
 };
 
 struct rx_desc {
-        u32          Next;
-        u16          MsduPos;
-        u16          MsduSize;
-
-        u8           State;
-        u8           Status;
-        u8           Rate;
-        u8           Rssi;
-        u8           LinkQuality;
-        u8           PreambleType;
-        u16          Duration;
-        u32          RxTime;
+        u32          Next;
+        u16          MsduPos;
+        u16          MsduSize;
+
+        u8           State;
+        u8           Status;
+        u8           Rate;
+        u8           Rssi;
+        u8           LinkQuality;
+        u8           PreambleType;
+        u16          Duration;
+        u32          RxTime;
 };
 
 #define RX_DESC_FLAG_VALID       0x80
@@ -192,7 +192,7 @@ struct tx_desc {
         u8        KeyIndex;
         u8        ChiperType;
         u8        ChipreLength;
-        u8        Reserved1;
+        u8        Reserved1;
 
         u8        Reserved;
         u8        PacketType;
@@ -212,9 +212,9 @@ struct tx_desc {
 #define TX_DESC_PACKET_TYPE_OFFSET   17
 #define TX_DESC_HOST_LENGTH_OFFSET   18
 
-///////////////////////////////////////////////////////
-// Host-MAC interface
-///////////////////////////////////////////////////////
+/*
+ * Host-MAC interface
+ */
 
 #define TX_STATUS_SUCCESS       0x00
 
@@ -226,14 +226,14 @@ struct tx_desc {
 #define TX_PACKET_TYPE_DATA     0x01
 #define TX_PACKET_TYPE_MGMT     0x02
 
-#define ISR_EMPTY               0x00        // no bits set in ISR
-#define ISR_TxCOMPLETE          0x01        // packet transmitted
-#define ISR_RxCOMPLETE          0x02        // packet received
-#define ISR_RxFRAMELOST         0x04        // Rx Frame lost
-#define ISR_FATAL_ERROR         0x08        // Fatal error
-#define ISR_COMMAND_COMPLETE    0x10        // command completed
-#define ISR_OUT_OF_RANGE        0x20        // command completed
-#define ISR_IBSS_MERGE          0x40        // (4.1.2.30): IBSS merge
+#define ISR_EMPTY               0x00        /* no bits set in ISR */
+#define ISR_TxCOMPLETE          0x01        /* packet transmitted */
+#define ISR_RxCOMPLETE          0x02        /* packet received */
+#define ISR_RxFRAMELOST         0x04        /* Rx Frame lost */
+#define ISR_FATAL_ERROR         0x08        /* Fatal error */
+#define ISR_COMMAND_COMPLETE    0x10        /* command completed */
+#define ISR_OUT_OF_RANGE        0x20        /* command completed */
+#define ISR_IBSS_MERGE          0x40        /* (4.1.2.30): IBSS merge */
 #define ISR_GENERIC_IRQ         0x80
 
 #define Local_Mib_Type          0x01
@@ -311,22 +311,22 @@ struct tx_desc {
 #define MAX_ENCRYPTION_KEYS 4
 #define MAX_ENCRYPTION_KEY_SIZE 40
 
-///////////////////////////////////////////////////////////////////////////
-// 802.11 related definitions
-///////////////////////////////////////////////////////////////////////////
+/*
+ * 802.11 related definitions
+ */
 
-//
-// Regulatory Domains
-//
+/*
+ * Regulatory Domains
+ */
 
-#define REG_DOMAIN_FCC          0x10    //Channels      1-11    USA
-#define REG_DOMAIN_DOC          0x20    //Channel       1-11    Canada
-#define REG_DOMAIN_ETSI         0x30    //Channel       1-13    Europe (ex Spain/France)
-#define REG_DOMAIN_SPAIN        0x31    //Channel       10-11   Spain
-#define REG_DOMAIN_FRANCE       0x32    //Channel       10-13   France
-#define REG_DOMAIN_MKK          0x40    //Channel       14      Japan
-#define REG_DOMAIN_MKK1         0x41    //Channel       1-14    Japan(MKK1)
-#define REG_DOMAIN_ISRAEL       0x50    //Channel       3-9     ISRAEL
+#define REG_DOMAIN_FCC          0x10    /* Channels     1-11    USA                             */
+#define REG_DOMAIN_DOC          0x20    /* Channel      1-11    Canada                          */
+#define REG_DOMAIN_ETSI         0x30    /* Channel      1-13    Europe (ex Spain/France)        */
+#define REG_DOMAIN_SPAIN        0x31    /* Channel      10-11   Spain                           */
+#define REG_DOMAIN_FRANCE       0x32    /* Channel      10-13   France                          */
+#define REG_DOMAIN_MKK          0x40    /* Channel      14      Japan                           */
+#define REG_DOMAIN_MKK1         0x41    /* Channel      1-14    Japan(MKK1)                     */
+#define REG_DOMAIN_ISRAEL       0x50    /* Channel      3-9     ISRAEL                          */
 
 #define BSS_TYPE_AD_HOC         1
 #define BSS_TYPE_INFRASTRUCTURE 2
@@ -364,13 +364,13 @@ struct tx_desc {
 #define CIPHER_SUITE_CCX      4
 #define CIPHER_SUITE_WEP_128  5
 
-//
-// IFACE MACROS & definitions
-//
-//
+/*
+ * IFACE MACROS & definitions
+ */
 
-// FuncCtrl field:
-//
+/*
+ * FuncCtrl field:
+ */
 #define FUNC_CTRL_TxENABLE              0x10
 #define FUNC_CTRL_RxENABLE              0x20
 #define FUNC_CTRL_INIT_COMPLETE         0x01
@@ -378,48 +378,48 @@ struct tx_desc {
 /* A stub firmware image which reads the MAC address from NVRAM on the card.
    For copyright information and source see the end of this file. */
 static u8 mac_reader[] = {
-        0x06,0x00,0x00,0xea,0x04,0x00,0x00,0xea,0x03,0x00,0x00,0xea,0x02,0x00,0x00,0xea,
-        0x01,0x00,0x00,0xea,0x00,0x00,0x00,0xea,0xff,0xff,0xff,0xea,0xfe,0xff,0xff,0xea,
-        0xd3,0x00,0xa0,0xe3,0x00,0xf0,0x21,0xe1,0x0e,0x04,0xa0,0xe3,0x00,0x10,0xa0,0xe3,
-        0x81,0x11,0xa0,0xe1,0x00,0x10,0x81,0xe3,0x00,0x10,0x80,0xe5,0x1c,0x10,0x90,0xe5,
-        0x10,0x10,0xc1,0xe3,0x1c,0x10,0x80,0xe5,0x01,0x10,0xa0,0xe3,0x08,0x10,0x80,0xe5,
-        0x02,0x03,0xa0,0xe3,0x00,0x10,0xa0,0xe3,0xb0,0x10,0xc0,0xe1,0xb4,0x10,0xc0,0xe1,
-        0xb8,0x10,0xc0,0xe1,0xbc,0x10,0xc0,0xe1,0x56,0xdc,0xa0,0xe3,0x21,0x00,0x00,0xeb,
-        0x0a,0x00,0xa0,0xe3,0x1a,0x00,0x00,0xeb,0x10,0x00,0x00,0xeb,0x07,0x00,0x00,0xeb,
-        0x02,0x03,0xa0,0xe3,0x02,0x14,0xa0,0xe3,0xb4,0x10,0xc0,0xe1,0x4c,0x10,0x9f,0xe5,
-        0xbc,0x10,0xc0,0xe1,0x10,0x10,0xa0,0xe3,0xb8,0x10,0xc0,0xe1,0xfe,0xff,0xff,0xea,
-        0x00,0x40,0x2d,0xe9,0x00,0x20,0xa0,0xe3,0x02,0x3c,0xa0,0xe3,0x00,0x10,0xa0,0xe3,
-        0x28,0x00,0x9f,0xe5,0x37,0x00,0x00,0xeb,0x00,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,
-        0x00,0x40,0x2d,0xe9,0x12,0x2e,0xa0,0xe3,0x06,0x30,0xa0,0xe3,0x00,0x10,0xa0,0xe3,
-        0x02,0x04,0xa0,0xe3,0x2f,0x00,0x00,0xeb,0x00,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,
-        0x00,0x02,0x00,0x02,0x80,0x01,0x90,0xe0,0x01,0x00,0x00,0x0a,0x01,0x00,0x50,0xe2,
-        0xfc,0xff,0xff,0xea,0x1e,0xff,0x2f,0xe1,0x80,0x10,0xa0,0xe3,0xf3,0x06,0xa0,0xe3,
-        0x00,0x10,0x80,0xe5,0x00,0x10,0xa0,0xe3,0x00,0x10,0x80,0xe5,0x01,0x10,0xa0,0xe3,
-        0x04,0x10,0x80,0xe5,0x00,0x10,0x80,0xe5,0x0e,0x34,0xa0,0xe3,0x1c,0x10,0x93,0xe5,
-        0x02,0x1a,0x81,0xe3,0x1c,0x10,0x83,0xe5,0x58,0x11,0x9f,0xe5,0x30,0x10,0x80,0xe5,
-        0x54,0x11,0x9f,0xe5,0x34,0x10,0x80,0xe5,0x38,0x10,0x80,0xe5,0x3c,0x10,0x80,0xe5,
-        0x10,0x10,0x90,0xe5,0x08,0x00,0x90,0xe5,0x1e,0xff,0x2f,0xe1,0xf3,0x16,0xa0,0xe3,
-        0x08,0x00,0x91,0xe5,0x05,0x00,0xa0,0xe3,0x0c,0x00,0x81,0xe5,0x10,0x00,0x91,0xe5,
-        0x02,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0xff,0x00,0xa0,0xe3,0x0c,0x00,0x81,0xe5,
-        0x10,0x00,0x91,0xe5,0x02,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0x08,0x00,0x91,0xe5,
-        0x10,0x00,0x91,0xe5,0x01,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0x08,0x00,0x91,0xe5,
-        0xff,0x00,0x00,0xe2,0x1e,0xff,0x2f,0xe1,0x30,0x40,0x2d,0xe9,0x00,0x50,0xa0,0xe1,
-        0x03,0x40,0xa0,0xe1,0xa2,0x02,0xa0,0xe1,0x08,0x00,0x00,0xe2,0x03,0x00,0x80,0xe2,
-        0xd8,0x10,0x9f,0xe5,0x00,0x00,0xc1,0xe5,0x01,0x20,0xc1,0xe5,0xe2,0xff,0xff,0xeb,
-        0x01,0x00,0x10,0xe3,0xfc,0xff,0xff,0x1a,0x14,0x00,0xa0,0xe3,0xc4,0xff,0xff,0xeb,
-        0x04,0x20,0xa0,0xe1,0x05,0x10,0xa0,0xe1,0x02,0x00,0xa0,0xe3,0x01,0x00,0x00,0xeb,
-        0x30,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,0x70,0x40,0x2d,0xe9,0xf3,0x46,0xa0,0xe3,
-        0x00,0x30,0xa0,0xe3,0x00,0x00,0x50,0xe3,0x08,0x00,0x00,0x9a,0x8c,0x50,0x9f,0xe5,
-        0x03,0x60,0xd5,0xe7,0x0c,0x60,0x84,0xe5,0x10,0x60,0x94,0xe5,0x02,0x00,0x16,0xe3,
-        0xfc,0xff,0xff,0x0a,0x01,0x30,0x83,0xe2,0x00,0x00,0x53,0xe1,0xf7,0xff,0xff,0x3a,
-        0xff,0x30,0xa0,0xe3,0x0c,0x30,0x84,0xe5,0x08,0x00,0x94,0xe5,0x10,0x00,0x94,0xe5,
-        0x01,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0x08,0x00,0x94,0xe5,0x00,0x00,0xa0,0xe3,
-        0x00,0x00,0x52,0xe3,0x0b,0x00,0x00,0x9a,0x10,0x50,0x94,0xe5,0x02,0x00,0x15,0xe3,
-        0xfc,0xff,0xff,0x0a,0x0c,0x30,0x84,0xe5,0x10,0x50,0x94,0xe5,0x01,0x00,0x15,0xe3,
-        0xfc,0xff,0xff,0x0a,0x08,0x50,0x94,0xe5,0x01,0x50,0xc1,0xe4,0x01,0x00,0x80,0xe2,
-        0x02,0x00,0x50,0xe1,0xf3,0xff,0xff,0x3a,0xc8,0x00,0xa0,0xe3,0x98,0xff,0xff,0xeb,
-        0x70,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,0x01,0x0c,0x00,0x02,0x01,0x02,0x00,0x02,
-        0x00,0x01,0x00,0x02
+        0x06, 0x00, 0x00, 0xea, 0x04, 0x00, 0x00, 0xea, 0x03, 0x00, 0x00, 0xea, 0x02, 0x00, 0x00, 0xea,
+        0x01, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0xea, 0xff, 0xff, 0xff, 0xea, 0xfe, 0xff, 0xff, 0xea,
+        0xd3, 0x00, 0xa0, 0xe3, 0x00, 0xf0, 0x21, 0xe1, 0x0e, 0x04, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
+        0x81, 0x11, 0xa0, 0xe1, 0x00, 0x10, 0x81, 0xe3, 0x00, 0x10, 0x80, 0xe5, 0x1c, 0x10, 0x90, 0xe5,
+        0x10, 0x10, 0xc1, 0xe3, 0x1c, 0x10, 0x80, 0xe5, 0x01, 0x10, 0xa0, 0xe3, 0x08, 0x10, 0x80, 0xe5,
+        0x02, 0x03, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3, 0xb0, 0x10, 0xc0, 0xe1, 0xb4, 0x10, 0xc0, 0xe1,
+        0xb8, 0x10, 0xc0, 0xe1, 0xbc, 0x10, 0xc0, 0xe1, 0x56, 0xdc, 0xa0, 0xe3, 0x21, 0x00, 0x00, 0xeb,
+        0x0a, 0x00, 0xa0, 0xe3, 0x1a, 0x00, 0x00, 0xeb, 0x10, 0x00, 0x00, 0xeb, 0x07, 0x00, 0x00, 0xeb,
+        0x02, 0x03, 0xa0, 0xe3, 0x02, 0x14, 0xa0, 0xe3, 0xb4, 0x10, 0xc0, 0xe1, 0x4c, 0x10, 0x9f, 0xe5,
+        0xbc, 0x10, 0xc0, 0xe1, 0x10, 0x10, 0xa0, 0xe3, 0xb8, 0x10, 0xc0, 0xe1, 0xfe, 0xff, 0xff, 0xea,
+        0x00, 0x40, 0x2d, 0xe9, 0x00, 0x20, 0xa0, 0xe3, 0x02, 0x3c, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
+        0x28, 0x00, 0x9f, 0xe5, 0x37, 0x00, 0x00, 0xeb, 0x00, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1,
+        0x00, 0x40, 0x2d, 0xe9, 0x12, 0x2e, 0xa0, 0xe3, 0x06, 0x30, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
+        0x02, 0x04, 0xa0, 0xe3, 0x2f, 0x00, 0x00, 0xeb, 0x00, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1,
+        0x00, 0x02, 0x00, 0x02, 0x80, 0x01, 0x90, 0xe0, 0x01, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x50, 0xe2,
+        0xfc, 0xff, 0xff, 0xea, 0x1e, 0xff, 0x2f, 0xe1, 0x80, 0x10, 0xa0, 0xe3, 0xf3, 0x06, 0xa0, 0xe3,
+        0x00, 0x10, 0x80, 0xe5, 0x00, 0x10, 0xa0, 0xe3, 0x00, 0x10, 0x80, 0xe5, 0x01, 0x10, 0xa0, 0xe3,
+        0x04, 0x10, 0x80, 0xe5, 0x00, 0x10, 0x80, 0xe5, 0x0e, 0x34, 0xa0, 0xe3, 0x1c, 0x10, 0x93, 0xe5,
+        0x02, 0x1a, 0x81, 0xe3, 0x1c, 0x10, 0x83, 0xe5, 0x58, 0x11, 0x9f, 0xe5, 0x30, 0x10, 0x80, 0xe5,
+        0x54, 0x11, 0x9f, 0xe5, 0x34, 0x10, 0x80, 0xe5, 0x38, 0x10, 0x80, 0xe5, 0x3c, 0x10, 0x80, 0xe5,
+        0x10, 0x10, 0x90, 0xe5, 0x08, 0x00, 0x90, 0xe5, 0x1e, 0xff, 0x2f, 0xe1, 0xf3, 0x16, 0xa0, 0xe3,
+        0x08, 0x00, 0x91, 0xe5, 0x05, 0x00, 0xa0, 0xe3, 0x0c, 0x00, 0x81, 0xe5, 0x10, 0x00, 0x91, 0xe5,
+        0x02, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0xff, 0x00, 0xa0, 0xe3, 0x0c, 0x00, 0x81, 0xe5,
+        0x10, 0x00, 0x91, 0xe5, 0x02, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x91, 0xe5,
+        0x10, 0x00, 0x91, 0xe5, 0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x91, 0xe5,
+        0xff, 0x00, 0x00, 0xe2, 0x1e, 0xff, 0x2f, 0xe1, 0x30, 0x40, 0x2d, 0xe9, 0x00, 0x50, 0xa0, 0xe1,
+        0x03, 0x40, 0xa0, 0xe1, 0xa2, 0x02, 0xa0, 0xe1, 0x08, 0x00, 0x00, 0xe2, 0x03, 0x00, 0x80, 0xe2,
+        0xd8, 0x10, 0x9f, 0xe5, 0x00, 0x00, 0xc1, 0xe5, 0x01, 0x20, 0xc1, 0xe5, 0xe2, 0xff, 0xff, 0xeb,
+        0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x1a, 0x14, 0x00, 0xa0, 0xe3, 0xc4, 0xff, 0xff, 0xeb,
+        0x04, 0x20, 0xa0, 0xe1, 0x05, 0x10, 0xa0, 0xe1, 0x02, 0x00, 0xa0, 0xe3, 0x01, 0x00, 0x00, 0xeb,
+        0x30, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1, 0x70, 0x40, 0x2d, 0xe9, 0xf3, 0x46, 0xa0, 0xe3,
+        0x00, 0x30, 0xa0, 0xe3, 0x00, 0x00, 0x50, 0xe3, 0x08, 0x00, 0x00, 0x9a, 0x8c, 0x50, 0x9f, 0xe5,
+        0x03, 0x60, 0xd5, 0xe7, 0x0c, 0x60, 0x84, 0xe5, 0x10, 0x60, 0x94, 0xe5, 0x02, 0x00, 0x16, 0xe3,
+        0xfc, 0xff, 0xff, 0x0a, 0x01, 0x30, 0x83, 0xe2, 0x00, 0x00, 0x53, 0xe1, 0xf7, 0xff, 0xff, 0x3a,
+        0xff, 0x30, 0xa0, 0xe3, 0x0c, 0x30, 0x84, 0xe5, 0x08, 0x00, 0x94, 0xe5, 0x10, 0x00, 0x94, 0xe5,
+        0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x94, 0xe5, 0x00, 0x00, 0xa0, 0xe3,
+        0x00, 0x00, 0x52, 0xe3, 0x0b, 0x00, 0x00, 0x9a, 0x10, 0x50, 0x94, 0xe5, 0x02, 0x00, 0x15, 0xe3,
+        0xfc, 0xff, 0xff, 0x0a, 0x0c, 0x30, 0x84, 0xe5, 0x10, 0x50, 0x94, 0xe5, 0x01, 0x00, 0x15, 0xe3,
+        0xfc, 0xff, 0xff, 0x0a, 0x08, 0x50, 0x94, 0xe5, 0x01, 0x50, 0xc1, 0xe4, 0x01, 0x00, 0x80, 0xe2,
+        0x02, 0x00, 0x50, 0xe1, 0xf3, 0xff, 0xff, 0x3a, 0xc8, 0x00, 0xa0, 0xe3, 0x98, 0xff, 0xff, 0xeb,
+        0x70, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1, 0x01, 0x0c, 0x00, 0x02, 0x01, 0x02, 0x00, 0x02,
+        0x00, 0x01, 0x00, 0x02
 };
 
 struct atmel_private {
@@ -433,7 +433,7 @@ struct atmel_private {
         struct net_device *dev;
         struct device *sys_dev;
         struct iw_statistics wstats;
-        spinlock_t irqlock, timerlock;  // spinlocks
+        spinlock_t irqlock, timerlock;  /* spinlocks */
         enum { BUS_TYPE_PCCARD, BUS_TYPE_PCI } bus_type;
         enum {
                 CARD_TYPE_PARALLEL_FLASH,
@@ -541,7 +541,7 @@ struct atmel_private {
         u8 rx_buf[MAX_WIRELESS_BODY];
 };
 
-static u8 atmel_basic_rates[4] = {0x82,0x84,0x0b,0x16};
+static u8 atmel_basic_rates[4] = {0x82, 0x84, 0x0b, 0x16};
 
 static const struct {
         int reg_domain;
@@ -1283,17 +1283,17 @@ static struct iw_statistics *atmel_get_wireless_stats(struct net_device *dev)
 
 static int atmel_change_mtu(struct net_device *dev, int new_mtu)
 {
-        if ((new_mtu < 68) || (new_mtu > 2312))
-                return -EINVAL;
-        dev->mtu = new_mtu;
-        return 0;
+        if ((new_mtu < 68) || (new_mtu > 2312))
+                return -EINVAL;
+        dev->mtu = new_mtu;
+        return 0;
 }
 
 static int atmel_set_mac_address(struct net_device *dev, void *p)
 {
         struct sockaddr *addr = p;
 
-        memcpy (dev->dev_addr, addr->sa_data, dev->addr_len);
+        memcpy (dev->dev_addr, addr->sa_data, dev->addr_len);
         return atmel_open(dev);
 }
 
@@ -1420,10 +1420,17 @@ static int atmel_proc_output (char *buf, struct atmel_private *priv)
                                      priv->firmware_id);
 
                 switch (priv->card_type) {
-                case CARD_TYPE_PARALLEL_FLASH: c = "Parallel flash"; break;
-                case CARD_TYPE_SPI_FLASH: c = "SPI flash\n"; break;
-                case CARD_TYPE_EEPROM: c = "EEPROM"; break;
-                default: c = "<unknown>";
+                case CARD_TYPE_PARALLEL_FLASH:
+                        c = "Parallel flash";
+                        break;
+                case CARD_TYPE_SPI_FLASH:
+                        c = "SPI flash\n";
+                        break;
+                case CARD_TYPE_EEPROM:
+                        c = "EEPROM";
+                        break;
+                default:
+                        c = "<unknown>";
                 }
 
                 r = "<unknown>";
@@ -1439,16 +1446,33 @@ static int atmel_proc_output (char *buf, struct atmel_private *priv)
                              priv->use_wpa ? "Yes" : "No");
         }
 
-        switch(priv->station_state) {
-        case STATION_STATE_SCANNING: s = "Scanning"; break;
-        case STATION_STATE_JOINNING: s = "Joining"; break;
-        case STATION_STATE_AUTHENTICATING: s = "Authenticating"; break;
-        case STATION_STATE_ASSOCIATING: s = "Associating"; break;
-        case STATION_STATE_READY: s = "Ready"; break;
-        case STATION_STATE_REASSOCIATING: s = "Reassociating"; break;
-        case STATION_STATE_MGMT_ERROR: s = "Management error"; break;
-        case STATION_STATE_DOWN: s = "Down"; break;
-        default: s = "<unknown>";
+        switch (priv->station_state) {
+        case STATION_STATE_SCANNING:
+                s = "Scanning";
+                break;
+        case STATION_STATE_JOINNING:
+                s = "Joining";
+                break;
+        case STATION_STATE_AUTHENTICATING:
+                s = "Authenticating";
+                break;
+        case STATION_STATE_ASSOCIATING:
+                s = "Associating";
+                break;
+        case STATION_STATE_READY:
+                s = "Ready";
+                break;
+        case STATION_STATE_REASSOCIATING:
+                s = "Reassociating";
+                break;
+        case STATION_STATE_MGMT_ERROR:
+                s = "Management error";
+                break;
+        case STATION_STATE_DOWN:
+                s = "Down";
+                break;
+        default:
+                s = "<unknown>";
         }
 
         p += sprintf(p, "Current state:\t\t%s\n", s);
@@ -1458,14 +1482,17 @@ static int atmel_proc_output (char *buf, struct atmel_private *priv)
 static int atmel_read_proc(char *page, char **start, off_t off,
                            int count, int *eof, void *data)
 {
-        struct atmel_private *priv = data;
+        struct atmel_private *priv = data;
         int len = atmel_proc_output (page, priv);
-        if (len <= off+count) *eof = 1;
-        *start = page + off;
-        len -= off;
-        if (len>count) len = count;
-        if (len<0) len = 0;
-        return len;
+        if (len <= off+count)
+                *eof = 1;
+        *start = page + off;
+        len -= off;
+        if (len > count)
+                len = count;
+        if (len < 0)
+                len = 0;
+        return len;
 }
 
 struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
@@ -1479,11 +1506,11 @@ struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
         int rc;
 
         /* Create the network device object. */
-        dev = alloc_etherdev(sizeof(*priv));
-        if (!dev) {
+        dev = alloc_etherdev(sizeof(*priv));
+        if (!dev) {
                 printk(KERN_ERR "atmel: Couldn't alloc_etherdev\n");
                 return NULL;
-        }
+        }
         if (dev_alloc_name(dev, dev->name) < 0) {
                 printk(KERN_ERR "atmel: Couldn't get name!\n");
                 goto err_out_free;
@@ -1577,7 +1604,7 @@ struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
         if (register_netdev(dev))
                 goto err_out_res;
 
-        if (!probe_atmel_card(dev)){
+        if (!probe_atmel_card(dev)) {
                 unregister_netdev(dev);
                 goto err_out_res;
         }
@@ -1594,7 +1621,7 @@ struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
         return dev;
 
 err_out_res:
-        release_region( dev->base_addr, 32);
+        release_region(dev->base_addr, 32);
 err_out_irq:
         free_irq(dev->irq, dev);
 err_out_free:
@@ -1632,7 +1659,7 @@ static int atmel_set_essid(struct net_device *dev,
         struct atmel_private *priv = netdev_priv(dev);
 
         /* Check if we asked for `any' */
-        if(dwrq->flags == 0) {
+        if (dwrq->flags == 0) {
                 priv->connect_to_any_BSS = 1;
         } else {
                 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
@@ -1768,7 +1795,7 @@ static int atmel_set_encode(struct net_device *dev,
         }
         if (dwrq->flags & IW_ENCODE_RESTRICTED)
                 priv->exclude_unencrypted = 1;
-        if(dwrq->flags & IW_ENCODE_OPEN)
+        if (dwrq->flags & IW_ENCODE_OPEN)
                 priv->exclude_unencrypted = 0;
 
         return -EINPROGRESS;            /* Call commit handler */
@@ -1797,7 +1824,7 @@ static int atmel_get_encode(struct net_device *dev,
         /* Copy the key to the user buffer */
         dwrq->length = priv->wep_key_len[index];
         if (dwrq->length > 16) {
-                dwrq->length=0;
+                dwrq->length = 0;
         } else {
                 memset(extra, 0, 16);
                 memcpy(extra, priv->wep_keys[index], dwrq->length);
@@ -2013,11 +2040,20 @@ static int atmel_set_rate(struct net_device *dev,
                 } else {
                 /* Setting by frequency value */
                         switch (vwrq->value) {
-                        case  1000000: priv->tx_rate = 0; break;
-                        case  2000000: priv->tx_rate = 1; break;
-                        case  5500000: priv->tx_rate = 2; break;
-                        case 11000000: priv->tx_rate = 3; break;
-                        default: return -EINVAL;
+                        case  1000000:
+                                priv->tx_rate = 0;
+                                break;
+                        case  2000000:
+                                priv->tx_rate = 1;
+                                break;
+                        case  5500000:
+                                priv->tx_rate = 2;
+                                break;
+                        case 11000000:
+                                priv->tx_rate = 3;
+                                break;
+                        default:
+                                return -EINVAL;
                         }
                 }
         }
@@ -2062,11 +2098,19 @@ static int atmel_get_rate(struct net_device *dev,
                 vwrq->value = 11000000;
         } else {
                 vwrq->fixed = 1;
-                switch(priv->tx_rate) {
-                case 0: vwrq->value =  1000000; break;
-                case 1: vwrq->value =  2000000; break;
-                case 2: vwrq->value =  5500000; break;
-                case 3: vwrq->value = 11000000; break;
+                switch (priv->tx_rate) {
+                case 0:
+                        vwrq->value =  1000000;
+                        break;
+                case 1:
+                        vwrq->value =  2000000;
+                        break;
+                case 2:
+                        vwrq->value =  5500000;
+                        break;
+                case 3:
+                        vwrq->value = 11000000;
+                        break;
                 }
         }
         return 0;
@@ -2576,8 +2620,7 @@ static const struct iw_priv_args atmel_private_args[] = {
         },
 };
 
-static const struct iw_handler_def atmel_handler_def =
-{
+static const struct iw_handler_def atmel_handler_def = {
         .num_standard   = ARRAY_SIZE(atmel_handler),
         .num_private    = ARRAY_SIZE(atmel_private_handler),
         .num_private_args = ARRAY_SIZE(atmel_private_args),
@@ -2834,7 +2877,7 @@ static void send_authentication_request(struct atmel_private *priv, u16 system,
 
         if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1)
                 /* no WEP for authentication frames with TrSeqNo 1 */
-                header.frame_control |=  cpu_to_le16(IEEE80211_FCTL_PROTECTED);
+                header.frame_control |=  cpu_to_le16(IEEE80211_FCTL_PROTECTED);
 
         auth.alg = cpu_to_le16(system);
 
@@ -2969,7 +3012,7 @@ static void store_bss_info(struct atmel_private *priv,
                 if (memcmp(bss, priv->BSSinfo[i].BSSID, 6) == 0)
                         index = i;
 
-        /* If we process a probe and an entry from this BSS exists
+        /* If we process a probe and an entry from this BSS exists
            we will update the BSS entry with the info from this BSS.
            If we process a beacon we will only update RSSI */
 
@@ -2995,7 +3038,7 @@ static void store_bss_info(struct atmel_private *priv,
         if (capability & WLAN_CAPABILITY_IBSS)
                 priv->BSSinfo[index].BSStype = IW_MODE_ADHOC;
         else if (capability & WLAN_CAPABILITY_ESS)
-                priv->BSSinfo[index].BSStype =IW_MODE_INFRA;
+                priv->BSSinfo[index].BSStype = IW_MODE_INFRA;
 
         priv->BSSinfo[index].preamble = capability & WLAN_CAPABILITY_SHORT_PREAMBLE ?
                 SHORT_PREAMBLE : LONG_PREAMBLE;
@@ -3042,7 +3085,7 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
                 }
 
                 if (should_associate) {
-                        if(priv->station_was_associated) {
+                        if (priv->station_was_associated) {
                                 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
                                 send_association_request(priv, 1);
                                 return;
@@ -3063,8 +3106,8 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
                         priv->exclude_unencrypted = 1;
                         send_authentication_request(priv, WLAN_AUTH_SHARED_KEY, NULL, 0);
                         return;
-                } else if (   system == WLAN_AUTH_SHARED_KEY
-                           && priv->wep_is_on) {
+                } else if (system == WLAN_AUTH_SHARED_KEY
+                           && priv->wep_is_on) {
                         priv->CurrentAuthentTransactionSeqNum = 0x001;
                         priv->exclude_unencrypted = 0;
                         send_authentication_request(priv, WLAN_AUTH_OPEN, NULL, 0);
@@ -3252,11 +3295,11 @@ static void smooth_rssi(struct atmel_private *priv, u8 rssi)
         u8 max_rssi = 42; /* 502-rmfd-revd max by experiment, default for now */
 
         switch (priv->firmware_type) {
-                case ATMEL_FW_TYPE_502E:
-                        max_rssi = 63; /* 502-rmfd-reve max by experiment */
-                        break;
-                default:
-                        break;
+        case ATMEL_FW_TYPE_502E:
+                max_rssi = 63; /* 502-rmfd-reve max by experiment */
+                break;
+        default:
+                break;
         }
 
         rssi = rssi * 100 / max_rssi;
@@ -3473,8 +3516,7 @@ static void atmel_command_irq(struct atmel_private *priv)
             status == CMD_STATUS_IN_PROGRESS)
                 return;
 
-        switch (command){
-
+        switch (command) {
         case CMD_Start:
                 if (status == CMD_STATUS_COMPLETE) {
                         priv->station_was_associated = priv->station_is_associated;
@@ -3709,7 +3751,7 @@ static int probe_atmel_card(struct net_device *dev)
 
         if (rc) {
                 if (dev->dev_addr[0] == 0xFF) {
-                        u8 default_mac[] = {0x00,0x04, 0x25, 0x00, 0x00, 0x00};
+                        u8 default_mac[] = {0x00, 0x04, 0x25, 0x00, 0x00, 0x00};
                         printk(KERN_ALERT "%s: *** Invalid MAC address. UPGRADE Firmware ****\n", dev->name);
                         memcpy(dev->dev_addr, default_mac, 6);
                 }
@@ -3803,7 +3845,7 @@ static void build_wpa_mib(struct atmel_private *priv)
                                 } else {
                                         mib.group_key = i;
                                         priv->group_cipher_suite = priv->pairwise_cipher_suite;
-                                        mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1;
+                                        mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1;
                                         mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite;
                                 }
                         }
@@ -3913,7 +3955,7 @@ static int reset_atmel_card(struct net_device *dev)
                         len = fw_entry->size;
                 }
 
-                if (len <= 0x6000) {
+                if (len <= 0x6000) {
                         atmel_write16(priv->dev, BSR, BSS_IRAM);
                         atmel_copy_to_card(priv->dev, 0, fw, len);
                         atmel_set_gcr(priv->dev, GCR_REMAP);
@@ -3942,7 +3984,7 @@ static int reset_atmel_card(struct net_device *dev)
         priv->use_wpa = (priv->host_info.major_version == 4);
         priv->radio_on_broken = (priv->host_info.major_version == 5);
 
-        /* unmask all irq sources */
+        /* unmask all irq sources */
         atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_MASK_OFFSET), 0xff);
 
         /* int Tx system and enable Tx */
@@ -3975,7 +4017,7 @@ static int reset_atmel_card(struct net_device *dev)
                     CMD_STATUS_REJECTED_RADIO_OFF) {
                         printk(KERN_INFO "%s: cannot turn the radio on.\n",
                                dev->name);
-                        return -EIO;
+                        return -EIO;
                 }
         }
 
@@ -3999,8 +4041,7 @@ static int reset_atmel_card(struct net_device *dev)
         else
                 build_wep_mib(priv);
 
-        if (old_state == STATION_STATE_READY)
-        {
+        if (old_state == STATION_STATE_READY) {
                 union iwreq_data wrqu;
 
                 wrqu.data.length = 0;
@@ -4277,24 +4318,24 @@ static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data)
         .set NVRAM_LENGTH, 0x0200
         .set MAC_ADDRESS_MIB, SRAM_BASE
         .set MAC_ADDRESS_LENGTH, 6
-        .set MAC_BOOT_FLAG, 0x10
+        .set MAC_BOOT_FLAG, 0x10
         .set MR1, 0
         .set MR2, 4
         .set MR3, 8
         .set MR4, 0xC
 RESET_VECTOR:
-        b RESET_HANDLER
+        b RESET_HANDLER
 UNDEF_VECTOR:
-        b HALT1
+        b HALT1
 SWI_VECTOR:
-        b HALT1
+        b HALT1
 IABORT_VECTOR:
-        b HALT1
+        b HALT1
 DABORT_VECTOR:
 RESERVED_VECTOR:
-        b HALT1
+        b HALT1
 IRQ_VECTOR:
-        b HALT1
+        b HALT1
 FIQ_VECTOR:
         b HALT1
 HALT1:  b HALT1
@@ -4306,7 +4347,7 @@ RESET_HANDLER:
         ldr     r0, =SPI_CGEN_BASE
         mov     r1, #0
         mov     r1, r1, lsl #3
-        orr     r1,r1, #0
+        orr     r1, r1, #0
         str     r1, [r0]
         ldr     r1, [r0, #28]
         bic     r1, r1, #16
diff --git a/drivers/net/wireless/ipw2x00/ieee80211.h b/drivers/net/wireless/ipw2x00/ieee80211.h
index 7515fad00f92..f82435eae49d 100644
--- a/drivers/net/wireless/ipw2x00/ieee80211.h
+++ b/drivers/net/wireless/ipw2x00/ieee80211.h
@@ -54,65 +54,12 @@
 #define MIN_FRAG_THRESHOLD     256U
 #define MAX_FRAG_THRESHOLD     2346U
 
-/* Frame control field constants */
-#define IEEE80211_FCTL_VERS             0x0003
-#define IEEE80211_FCTL_FTYPE            0x000c
-#define IEEE80211_FCTL_STYPE            0x00f0
-#define IEEE80211_FCTL_TODS             0x0100
-#define IEEE80211_FCTL_FROMDS           0x0200
-#define IEEE80211_FCTL_MOREFRAGS        0x0400
-#define IEEE80211_FCTL_RETRY            0x0800
-#define IEEE80211_FCTL_PM               0x1000
-#define IEEE80211_FCTL_MOREDATA         0x2000
-#define IEEE80211_FCTL_PROTECTED        0x4000
-#define IEEE80211_FCTL_ORDER            0x8000
-
-#define IEEE80211_FTYPE_MGMT            0x0000
-#define IEEE80211_FTYPE_CTL             0x0004
-#define IEEE80211_FTYPE_DATA            0x0008
-
-/* management */
-#define IEEE80211_STYPE_ASSOC_REQ       0x0000
-#define IEEE80211_STYPE_ASSOC_RESP      0x0010
-#define IEEE80211_STYPE_REASSOC_REQ     0x0020
-#define IEEE80211_STYPE_REASSOC_RESP    0x0030
-#define IEEE80211_STYPE_PROBE_REQ       0x0040
-#define IEEE80211_STYPE_PROBE_RESP      0x0050
-#define IEEE80211_STYPE_BEACON          0x0080
-#define IEEE80211_STYPE_ATIM            0x0090
-#define IEEE80211_STYPE_DISASSOC        0x00A0
-#define IEEE80211_STYPE_AUTH            0x00B0
-#define IEEE80211_STYPE_DEAUTH          0x00C0
-#define IEEE80211_STYPE_ACTION          0x00D0
-
-/* control */
-#define IEEE80211_STYPE_PSPOLL          0x00A0
-#define IEEE80211_STYPE_RTS             0x00B0
-#define IEEE80211_STYPE_CTS             0x00C0
-#define IEEE80211_STYPE_ACK             0x00D0
-#define IEEE80211_STYPE_CFEND           0x00E0
-#define IEEE80211_STYPE_CFENDACK        0x00F0
-
-/* data */
-#define IEEE80211_STYPE_DATA            0x0000
-#define IEEE80211_STYPE_DATA_CFACK      0x0010
-#define IEEE80211_STYPE_DATA_CFPOLL     0x0020
-#define IEEE80211_STYPE_DATA_CFACKPOLL  0x0030
-#define IEEE80211_STYPE_NULLFUNC        0x0040
-#define IEEE80211_STYPE_CFACK           0x0050
-#define IEEE80211_STYPE_CFPOLL          0x0060
-#define IEEE80211_STYPE_CFACKPOLL       0x0070
-#define IEEE80211_STYPE_QOS_DATA        0x0080
-
-#define IEEE80211_SCTL_FRAG             0x000F
-#define IEEE80211_SCTL_SEQ              0xFFF0
-
 /* QOS control */
 #define IEEE80211_QCTL_TID              0x000F
 
 /* debug macros */
 
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
 extern u32 ieee80211_debug_level;
 #define IEEE80211_DEBUG(level, fmt, args...) \
 do { if (ieee80211_debug_level & (level)) \
@@ -128,7 +75,7 @@ static inline bool ieee80211_ratelimit_debug(u32 level)
 {
         return false;
 }
-#endif                          /* CONFIG_IEEE80211_DEBUG */
+#endif                          /* CONFIG_LIBIPW_DEBUG */
 
 /*
  * To use the debug system:
@@ -152,7 +99,7 @@ static inline bool ieee80211_ratelimit_debug(u32 level)
  * you simply need to add your entry to the ieee80211_debug_level array.
  *
  * If you do not see debug_level in /proc/net/ieee80211 then you do not have
- * CONFIG_IEEE80211_DEBUG defined in your kernel configuration
+ * CONFIG_LIBIPW_DEBUG defined in your kernel configuration
  *
  */
 
@@ -217,23 +164,6 @@ struct ieee80211_snap_hdr {
 #define WLAN_GET_SEQ_FRAG(seq) ((seq) & IEEE80211_SCTL_FRAG)
 #define WLAN_GET_SEQ_SEQ(seq)  (((seq) & IEEE80211_SCTL_SEQ) >> 4)
 
-/* Action categories - 802.11h */
-enum ieee80211_actioncategories {
-        WLAN_ACTION_SPECTRUM_MGMT = 0,
-        /* Reserved 1-127  */
-        /* Error    128-255 */
-};
-
-/* Action details - 802.11h */
-enum ieee80211_actiondetails {
-        WLAN_ACTION_CATEGORY_MEASURE_REQUEST = 0,
-        WLAN_ACTION_CATEGORY_MEASURE_REPORT = 1,
-        WLAN_ACTION_CATEGORY_TPC_REQUEST = 2,
-        WLAN_ACTION_CATEGORY_TPC_REPORT = 3,
-        WLAN_ACTION_CATEGORY_CHANNEL_SWITCH = 4,
-        /* 5 - 255 Reserved */
-};
-
 #define IEEE80211_STATMASK_SIGNAL (1<<0)
 #define IEEE80211_STATMASK_RSSI (1<<1)
 #define IEEE80211_STATMASK_NOISE (1<<2)
@@ -411,37 +341,6 @@ Total: 28-2340 bytes
 
 #define BEACON_PROBE_SSID_ID_POSITION 12
 
-/* Management Frame Information Element Types */
-enum ieee80211_mfie {
-        MFIE_TYPE_SSID = 0,
-        MFIE_TYPE_RATES = 1,
-        MFIE_TYPE_FH_SET = 2,
-        MFIE_TYPE_DS_SET = 3,
-        MFIE_TYPE_CF_SET = 4,
-        MFIE_TYPE_TIM = 5,
-        MFIE_TYPE_IBSS_SET = 6,
-        MFIE_TYPE_COUNTRY = 7,
-        MFIE_TYPE_HOP_PARAMS = 8,
-        MFIE_TYPE_HOP_TABLE = 9,
-        MFIE_TYPE_REQUEST = 10,
-        MFIE_TYPE_CHALLENGE = 16,
-        MFIE_TYPE_POWER_CONSTRAINT = 32,
-        MFIE_TYPE_POWER_CAPABILITY = 33,
-        MFIE_TYPE_TPC_REQUEST = 34,
-        MFIE_TYPE_TPC_REPORT = 35,
-        MFIE_TYPE_SUPP_CHANNELS = 36,
-        MFIE_TYPE_CSA = 37,
-        MFIE_TYPE_MEASURE_REQUEST = 38,
-        MFIE_TYPE_MEASURE_REPORT = 39,
-        MFIE_TYPE_QUIET = 40,
-        MFIE_TYPE_IBSS_DFS = 41,
-        MFIE_TYPE_ERP_INFO = 42,
-        MFIE_TYPE_RSN = 48,
-        MFIE_TYPE_RATES_EX = 50,
-        MFIE_TYPE_GENERIC = 221,
-        MFIE_TYPE_QOS_PARAMETER = 222,
-};
-
 struct ieee80211_hdr_1addr {
         __le16 frame_ctl;
         __le16 duration_id;
diff --git a/drivers/net/wireless/ipw2x00/libipw_module.c b/drivers/net/wireless/ipw2x00/libipw_module.c
index ec7753446bd3..f4803fc05413 100644
--- a/drivers/net/wireless/ipw2x00/libipw_module.c
+++ b/drivers/net/wireless/ipw2x00/libipw_module.c
@@ -221,7 +221,7 @@ void free_ieee80211(struct net_device *dev)
         free_netdev(dev);
 }
 
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
 
 static int debug = 0;
 u32 ieee80211_debug_level = 0;
@@ -252,11 +252,11 @@ static int store_debug_level(struct file *file, const char __user * buffer,
 
         return strnlen(buf, len);
 }
-#endif                          /* CONFIG_IEEE80211_DEBUG */
+#endif                          /* CONFIG_LIBIPW_DEBUG */
 
 static int __init ieee80211_init(void)
 {
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
         struct proc_dir_entry *e;
 
         ieee80211_debug_level = debug;
@@ -276,7 +276,7 @@ static int __init ieee80211_init(void)
         e->read_proc = show_debug_level;
         e->write_proc = store_debug_level;
         e->data = NULL;
-#endif                          /* CONFIG_IEEE80211_DEBUG */
+#endif                          /* CONFIG_LIBIPW_DEBUG */
 
         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
@@ -286,20 +286,20 @@ static int __init ieee80211_init(void)
 
 static void __exit ieee80211_exit(void)
 {
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
         if (ieee80211_proc) {
                 remove_proc_entry("debug_level", ieee80211_proc);
                 remove_proc_entry(DRV_NAME, init_net.proc_net);
                 ieee80211_proc = NULL;
         }
-#endif                          /* CONFIG_IEEE80211_DEBUG */
+#endif                          /* CONFIG_LIBIPW_DEBUG */
 }
 
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
 #include <linux/moduleparam.h>
 module_param(debug, int, 0444);
 MODULE_PARM_DESC(debug, "debug output mask");
-#endif                          /* CONFIG_IEEE80211_DEBUG */
+#endif                          /* CONFIG_LIBIPW_DEBUG */
 
 module_exit(ieee80211_exit);
 module_init(ieee80211_init);
diff --git a/drivers/net/wireless/ipw2x00/libipw_rx.c b/drivers/net/wireless/ipw2x00/libipw_rx.c
index 8d9e96f9eb28..079007936d8a 100644
--- a/drivers/net/wireless/ipw2x00/libipw_rx.c
+++ b/drivers/net/wireless/ipw2x00/libipw_rx.c
@@ -1080,37 +1080,37 @@ static int ieee80211_parse_qos_info_param_IE(struct ieee80211_info_element
         return rc;
 }
 
-#ifdef CONFIG_IEEE80211_DEBUG
-#define MFIE_STRING(x) case MFIE_TYPE_ ##x: return #x
+#ifdef CONFIG_LIBIPW_DEBUG
+#define MFIE_STRING(x) case WLAN_EID_ ##x: return #x
 
 static const char *get_info_element_string(u16 id)
 {
         switch (id) {
                 MFIE_STRING(SSID);
-                MFIE_STRING(RATES);
-                MFIE_STRING(FH_SET);
-                MFIE_STRING(DS_SET);
-                MFIE_STRING(CF_SET);
+                MFIE_STRING(SUPP_RATES);
+                MFIE_STRING(FH_PARAMS);
+                MFIE_STRING(DS_PARAMS);
+                MFIE_STRING(CF_PARAMS);
                 MFIE_STRING(TIM);
-                MFIE_STRING(IBSS_SET);
+                MFIE_STRING(IBSS_PARAMS);
                 MFIE_STRING(COUNTRY);
-                MFIE_STRING(HOP_PARAMS);
-                MFIE_STRING(HOP_TABLE);
+                MFIE_STRING(HP_PARAMS);
+                MFIE_STRING(HP_TABLE);
                 MFIE_STRING(REQUEST);
                 MFIE_STRING(CHALLENGE);
-                MFIE_STRING(POWER_CONSTRAINT);
-                MFIE_STRING(POWER_CAPABILITY);
+                MFIE_STRING(PWR_CONSTRAINT);
+                MFIE_STRING(PWR_CAPABILITY);
                 MFIE_STRING(TPC_REQUEST);
                 MFIE_STRING(TPC_REPORT);
-                MFIE_STRING(SUPP_CHANNELS);
-                MFIE_STRING(CSA);
+                MFIE_STRING(SUPPORTED_CHANNELS);
+                MFIE_STRING(CHANNEL_SWITCH);
                 MFIE_STRING(MEASURE_REQUEST);
                 MFIE_STRING(MEASURE_REPORT);
                 MFIE_STRING(QUIET);
                 MFIE_STRING(IBSS_DFS);
                 MFIE_STRING(ERP_INFO);
                 MFIE_STRING(RSN);
-                MFIE_STRING(RATES_EX);
+                MFIE_STRING(EXT_SUPP_RATES);
                 MFIE_STRING(GENERIC);
                 MFIE_STRING(QOS_PARAMETER);
         default:
@@ -1125,7 +1125,7 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
 {
         DECLARE_SSID_BUF(ssid);
         u8 i;
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
         char rates_str[64];
         char *p;
 #endif
@@ -1145,7 +1145,7 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                 }
 
                 switch (info_element->id) {
-                case MFIE_TYPE_SSID:
+                case WLAN_EID_SSID:
                         network->ssid_len = min(info_element->len,
                                                 (u8) IW_ESSID_MAX_SIZE);
                         memcpy(network->ssid, info_element->data,
@@ -1154,21 +1154,21 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                                 memset(network->ssid + network->ssid_len, 0,
                                        IW_ESSID_MAX_SIZE - network->ssid_len);
 
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_SSID: '%s' len=%d.\n",
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_SSID: '%s' len=%d.\n",
                                              print_ssid(ssid, network->ssid,
                                                         network->ssid_len),
                                              network->ssid_len);
                         break;
 
-                case MFIE_TYPE_RATES:
-#ifdef CONFIG_IEEE80211_DEBUG
+                case WLAN_EID_SUPP_RATES:
+#ifdef CONFIG_LIBIPW_DEBUG
                         p = rates_str;
 #endif
                         network->rates_len = min(info_element->len,
                                                  MAX_RATES_LENGTH);
                         for (i = 0; i < network->rates_len; i++) {
                                 network->rates[i] = info_element->data[i];
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
                                 p += snprintf(p, sizeof(rates_str) -
                                               (p - rates_str), "%02X ",
                                               network->rates[i]);
@@ -1183,19 +1183,19 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                                 }
                         }
 
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_RATES: '%s' (%d)\n",
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_SUPP_RATES: '%s' (%d)\n",
                                              rates_str, network->rates_len);
                         break;
 
-                case MFIE_TYPE_RATES_EX:
-#ifdef CONFIG_IEEE80211_DEBUG
+                case WLAN_EID_EXT_SUPP_RATES:
+#ifdef CONFIG_LIBIPW_DEBUG
                         p = rates_str;
 #endif
                         network->rates_ex_len = min(info_element->len,
                                                     MAX_RATES_EX_LENGTH);
                         for (i = 0; i < network->rates_ex_len; i++) {
                                 network->rates_ex[i] = info_element->data[i];
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
                                 p += snprintf(p, sizeof(rates_str) -
                                               (p - rates_str), "%02X ",
                                               network->rates[i]);
@@ -1210,49 +1210,49 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                                 }
                         }
 
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_RATES_EX: '%s' (%d)\n",
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_EXT_SUPP_RATES: '%s' (%d)\n",
                                              rates_str, network->rates_ex_len);
                         break;
 
-                case MFIE_TYPE_DS_SET:
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_DS_SET: %d\n",
+                case WLAN_EID_DS_PARAMS:
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_DS_PARAMS: %d\n",
                                              info_element->data[0]);
                         network->channel = info_element->data[0];
                         break;
 
-                case MFIE_TYPE_FH_SET:
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_FH_SET: ignored\n");
+                case WLAN_EID_FH_PARAMS:
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_FH_PARAMS: ignored\n");
                         break;
 
-                case MFIE_TYPE_CF_SET:
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_CF_SET: ignored\n");
+                case WLAN_EID_CF_PARAMS:
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_CF_PARAMS: ignored\n");
                         break;
 
-                case MFIE_TYPE_TIM:
+                case WLAN_EID_TIM:
                         network->tim.tim_count = info_element->data[0];
                         network->tim.tim_period = info_element->data[1];
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_TIM: partially ignored\n");
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_TIM: partially ignored\n");
                         break;
 
-                case MFIE_TYPE_ERP_INFO:
+                case WLAN_EID_ERP_INFO:
                         network->erp_value = info_element->data[0];
                         network->flags |= NETWORK_HAS_ERP_VALUE;
                         IEEE80211_DEBUG_MGMT("MFIE_TYPE_ERP_SET: %d\n",
                                              network->erp_value);
                         break;
 
-                case MFIE_TYPE_IBSS_SET:
+                case WLAN_EID_IBSS_PARAMS:
                         network->atim_window = info_element->data[0];
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_IBSS_SET: %d\n",
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_IBSS_PARAMS: %d\n",
                                              network->atim_window);
                         break;
 
-                case MFIE_TYPE_CHALLENGE:
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_CHALLENGE: ignored\n");
+                case WLAN_EID_CHALLENGE:
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_CHALLENGE: ignored\n");
                         break;
 
-                case MFIE_TYPE_GENERIC:
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_GENERIC: %d bytes\n",
+                case WLAN_EID_GENERIC:
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_GENERIC: %d bytes\n",
                                              info_element->len);
                         if (!ieee80211_parse_qos_info_param_IE(info_element,
                                                                network))
@@ -1270,8 +1270,8 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                         }
                         break;
 
-                case MFIE_TYPE_RSN:
-                        IEEE80211_DEBUG_MGMT("MFIE_TYPE_RSN: %d bytes\n",
+                case WLAN_EID_RSN:
+                        IEEE80211_DEBUG_MGMT("WLAN_EID_RSN: %d bytes\n",
                                              info_element->len);
                         network->rsn_ie_len = min(info_element->len + 2,
                                                   MAX_WPA_IE_LEN);
@@ -1279,22 +1279,22 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                                network->rsn_ie_len);
                         break;
 
-                case MFIE_TYPE_QOS_PARAMETER:
+                case WLAN_EID_QOS_PARAMETER:
                         printk(KERN_ERR
                                "QoS Error need to parse QOS_PARAMETER IE\n");
                         break;
                         /* 802.11h */
-                case MFIE_TYPE_POWER_CONSTRAINT:
+                case WLAN_EID_PWR_CONSTRAINT:
                         network->power_constraint = info_element->data[0];
                         network->flags |= NETWORK_HAS_POWER_CONSTRAINT;
                         break;
 
-                case MFIE_TYPE_CSA:
+                case WLAN_EID_CHANNEL_SWITCH:
                         network->power_constraint = info_element->data[0];
                         network->flags |= NETWORK_HAS_CSA;
                         break;
 
-                case MFIE_TYPE_QUIET:
+                case WLAN_EID_QUIET:
                         network->quiet.count = info_element->data[0];
                         network->quiet.period = info_element->data[1];
                         network->quiet.duration = info_element->data[2];
@@ -1302,7 +1302,7 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                         network->flags |= NETWORK_HAS_QUIET;
                         break;
 
-                case MFIE_TYPE_IBSS_DFS:
+                case WLAN_EID_IBSS_DFS:
                         if (network->ibss_dfs)
                                 break;
                         network->ibss_dfs = kmemdup(info_element->data,
@@ -1313,7 +1313,7 @@ static int ieee80211_parse_info_param(struct ieee80211_info_element
                         network->flags |= NETWORK_HAS_IBSS_DFS;
                         break;
 
-                case MFIE_TYPE_TPC_REPORT:
+                case WLAN_EID_TPC_REPORT:
                         network->tpc_report.transmit_power =
                             info_element->data[0];
                         network->tpc_report.link_margin = info_element->data[1];
@@ -1562,7 +1562,7 @@ static void ieee80211_process_probe_response(struct ieee80211_device
         };
         struct ieee80211_network *target;
         struct ieee80211_network *oldest = NULL;
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
         struct ieee80211_info_element *info_element = beacon->info_element;
 #endif
         unsigned long flags;
@@ -1640,7 +1640,7 @@ static void ieee80211_process_probe_response(struct ieee80211_device
                         list_del(ieee->network_free_list.next);
                 }
 
-#ifdef CONFIG_IEEE80211_DEBUG
+#ifdef CONFIG_LIBIPW_DEBUG
                 IEEE80211_DEBUG_SCAN("Adding '%s' (%pM) via %s.\n",
                                      print_ssid(ssid, network.ssid,
                                                  network.ssid_len),
diff --git a/drivers/net/wireless/iwlwifi/Kconfig b/drivers/net/wireless/iwlwifi/Kconfig
index 6cc5a54d35c5..8304f6406a17 100644
--- a/drivers/net/wireless/iwlwifi/Kconfig
+++ b/drivers/net/wireless/iwlwifi/Kconfig
@@ -6,11 +6,9 @@ config IWLWIFI
         select MAC80211_LEDS if IWLWIFI_LEDS
         select LEDS_CLASS if IWLWIFI_LEDS
         select RFKILL if IWLWIFI_RFKILL
-        select MAC80211_LEDS if IWL3945_LEDS
-        select LEDS_CLASS if IWL3945_LEDS
 
 config IWLWIFI_LEDS
-        bool "Enable LED support in iwlagn driver"
+        bool "Enable LED support in iwlagn and iwl3945 drivers"
         depends on IWLWIFI
 
 config IWLWIFI_RFKILL
@@ -87,7 +85,7 @@ config IWL4965
           This option enables support for Intel Wireless WiFi Link 4965AGN
 
 config IWL5000
-        bool "Intel Wireless WiFi 5000AGN; Intel WiFi Link 100, 6000, and 6050 Series"
+        bool "Intel Wireless WiFi 5000AGN; Intel WiFi Link 1000, 6000, and 6050 Series"
         depends on IWLAGN
         ---help---
           This option enables support for Intel Wireless WiFi Link 5000AGN Family
@@ -122,9 +120,3 @@ config IWL3945_SPECTRUM_MEASUREMENT
         depends on IWL3945
         ---help---
           This option will enable spectrum measurement for the iwl3945 driver.
-
-config IWL3945_LEDS
-        bool "Enable LEDS features in iwl3945 driver"
-        depends on IWL3945
-        ---help---
-          This option enables LEDS for the iwl3945 driver.
diff --git a/drivers/net/wireless/iwlwifi/Makefile b/drivers/net/wireless/iwlwifi/Makefile
index 48af523ceab7..d79d97ad61a5 100644
--- a/drivers/net/wireless/iwlwifi/Makefile
+++ b/drivers/net/wireless/iwlwifi/Makefile
@@ -13,10 +13,9 @@ iwlagn-objs		:= iwl-agn.o iwl-agn-rs.o
 iwlagn-$(CONFIG_IWL4965) += iwl-4965.o
 iwlagn-$(CONFIG_IWL5000) += iwl-5000.o
 iwlagn-$(CONFIG_IWL5000) += iwl-6000.o
-iwlagn-$(CONFIG_IWL5000) += iwl-100.o
+iwlagn-$(CONFIG_IWL5000) += iwl-1000.o
 
 obj-$(CONFIG_IWL3945)   += iwl3945.o
-iwl3945-objs            := iwl3945-base.o iwl-3945.o iwl-3945-rs.o
-iwl3945-$(CONFIG_IWL3945_LEDS) += iwl-3945-led.o
+iwl3945-objs            := iwl3945-base.o iwl-3945.o iwl-3945-rs.o iwl-3945-led.o
 
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-100.c b/drivers/net/wireless/iwlwifi/iwl-1000.c
index 11d206abb710..7da52f1cc1d6 100644
--- a/drivers/net/wireless/iwlwifi/iwl-100.c
+++ b/drivers/net/wireless/iwlwifi/iwl-1000.c
@@ -46,20 +46,20 @@
 #include "iwl-5000-hw.h"
 
 /* Highest firmware API version supported */
-#define IWL100_UCODE_API_MAX 2
+#define IWL1000_UCODE_API_MAX 2
 
 /* Lowest firmware API version supported */
-#define IWL100_UCODE_API_MIN 1
+#define IWL1000_UCODE_API_MIN 1
 
-#define IWL100_FW_PRE "iwlwifi-100-"
-#define _IWL100_MODULE_FIRMWARE(api) IWL100_FW_PRE #api ".ucode"
-#define IWL100_MODULE_FIRMWARE(api) _IWL100_MODULE_FIRMWARE(api)
+#define IWL1000_FW_PRE "iwlwifi-1000-"
+#define _IWL1000_MODULE_FIRMWARE(api) IWL1000_FW_PRE #api ".ucode"
+#define IWL1000_MODULE_FIRMWARE(api) _IWL1000_MODULE_FIRMWARE(api)
 
-struct iwl_cfg iwl100_bgn_cfg = {
-        .name = "100 Series BGN",
-        .fw_name_pre = IWL100_FW_PRE,
-        .ucode_api_max = IWL100_UCODE_API_MAX,
-        .ucode_api_min = IWL100_UCODE_API_MIN,
+struct iwl_cfg iwl1000_bgn_cfg = {
+        .name = "1000 Series BGN",
+        .fw_name_pre = IWL1000_FW_PRE,
+        .ucode_api_max = IWL1000_UCODE_API_MAX,
+        .ucode_api_min = IWL1000_UCODE_API_MIN,
         .sku = IWL_SKU_G|IWL_SKU_N,
         .ops = &iwl5000_ops,
         .eeprom_size = IWL_5000_EEPROM_IMG_SIZE,
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945-led.c b/drivers/net/wireless/iwlwifi/iwl-3945-led.c
index a973ac13a1d5..ac22f59be9ef 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945-led.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945-led.c
@@ -24,6 +24,7 @@
  *
  *****************************************************************************/
 
+#ifdef CONFIG_IWLWIFI_LEDS
 
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -163,8 +164,8 @@ static int iwl3945_led_associated(struct iwl_priv *priv, int led_id)
 static void iwl3945_led_brightness_set(struct led_classdev *led_cdev,
                                 enum led_brightness brightness)
 {
-        struct iwl3945_led *led = container_of(led_cdev,
-                                               struct iwl3945_led, led_dev);
+        struct iwl_led *led = container_of(led_cdev,
+                                               struct iwl_led, led_dev);
         struct iwl_priv *priv = led->priv;
 
         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
@@ -202,7 +203,7 @@ static void iwl3945_led_brightness_set(struct led_classdev *led_cdev,
  * Register led class with the system
  */
 static int iwl3945_led_register_led(struct iwl_priv *priv,
-                                   struct iwl3945_led *led,
+                                   struct iwl_led *led,
                                    enum led_type type, u8 set_led,
                                    char *trigger)
 {
@@ -315,66 +316,66 @@ int iwl3945_led_register(struct iwl_priv *priv)
         priv->allow_blinking = 0;
 
         trigger = ieee80211_get_radio_led_name(priv->hw);
-        snprintf(priv->led39[IWL_LED_TRG_RADIO].name,
-                 sizeof(priv->led39[IWL_LED_TRG_RADIO].name), "iwl-%s::radio",
+        snprintf(priv->led[IWL_LED_TRG_RADIO].name,
+                 sizeof(priv->led[IWL_LED_TRG_RADIO].name), "iwl-%s::radio",
                  wiphy_name(priv->hw->wiphy));
 
-        priv->led39[IWL_LED_TRG_RADIO].led_on = iwl3945_led_on;
-        priv->led39[IWL_LED_TRG_RADIO].led_off = iwl3945_led_off;
-        priv->led39[IWL_LED_TRG_RADIO].led_pattern = NULL;
+        priv->led[IWL_LED_TRG_RADIO].led_on = iwl3945_led_on;
+        priv->led[IWL_LED_TRG_RADIO].led_off = iwl3945_led_off;
+        priv->led[IWL_LED_TRG_RADIO].led_pattern = NULL;
 
         ret = iwl3945_led_register_led(priv,
-                                   &priv->led39[IWL_LED_TRG_RADIO],
+                                   &priv->led[IWL_LED_TRG_RADIO],
                                    IWL_LED_TRG_RADIO, 1, trigger);
 
         if (ret)
                 goto exit_fail;
 
         trigger = ieee80211_get_assoc_led_name(priv->hw);
-        snprintf(priv->led39[IWL_LED_TRG_ASSOC].name,
-                 sizeof(priv->led39[IWL_LED_TRG_ASSOC].name), "iwl-%s::assoc",
+        snprintf(priv->led[IWL_LED_TRG_ASSOC].name,
+                 sizeof(priv->led[IWL_LED_TRG_ASSOC].name), "iwl-%s::assoc",
                  wiphy_name(priv->hw->wiphy));
 
         ret = iwl3945_led_register_led(priv,
-                                   &priv->led39[IWL_LED_TRG_ASSOC],
+                                   &priv->led[IWL_LED_TRG_ASSOC],
                                    IWL_LED_TRG_ASSOC, 0, trigger);
 
         /* for assoc always turn led on */
-        priv->led39[IWL_LED_TRG_ASSOC].led_on = iwl3945_led_on;
-        priv->led39[IWL_LED_TRG_ASSOC].led_off = iwl3945_led_on;
-        priv->led39[IWL_LED_TRG_ASSOC].led_pattern = NULL;
+        priv->led[IWL_LED_TRG_ASSOC].led_on = iwl3945_led_on;
+        priv->led[IWL_LED_TRG_ASSOC].led_off = iwl3945_led_on;
+        priv->led[IWL_LED_TRG_ASSOC].led_pattern = NULL;
 
         if (ret)
                 goto exit_fail;
 
         trigger = ieee80211_get_rx_led_name(priv->hw);
-        snprintf(priv->led39[IWL_LED_TRG_RX].name,
-                 sizeof(priv->led39[IWL_LED_TRG_RX].name), "iwl-%s::RX",
+        snprintf(priv->led[IWL_LED_TRG_RX].name,
+                 sizeof(priv->led[IWL_LED_TRG_RX].name), "iwl-%s::RX",
                  wiphy_name(priv->hw->wiphy));
 
         ret = iwl3945_led_register_led(priv,
-                                   &priv->led39[IWL_LED_TRG_RX],
+                                   &priv->led[IWL_LED_TRG_RX],
                                    IWL_LED_TRG_RX, 0, trigger);
 
-        priv->led39[IWL_LED_TRG_RX].led_on = iwl3945_led_associated;
-        priv->led39[IWL_LED_TRG_RX].led_off = iwl3945_led_associated;
-        priv->led39[IWL_LED_TRG_RX].led_pattern = iwl3945_led_pattern;
+        priv->led[IWL_LED_TRG_RX].led_on = iwl3945_led_associated;
+        priv->led[IWL_LED_TRG_RX].led_off = iwl3945_led_associated;
+        priv->led[IWL_LED_TRG_RX].led_pattern = iwl3945_led_pattern;
 
         if (ret)
                 goto exit_fail;
 
         trigger = ieee80211_get_tx_led_name(priv->hw);
-        snprintf(priv->led39[IWL_LED_TRG_TX].name,
-                 sizeof(priv->led39[IWL_LED_TRG_TX].name), "iwl-%s::TX",
+        snprintf(priv->led[IWL_LED_TRG_TX].name,
+                 sizeof(priv->led[IWL_LED_TRG_TX].name), "iwl-%s::TX",
                  wiphy_name(priv->hw->wiphy));
 
         ret = iwl3945_led_register_led(priv,
-                                   &priv->led39[IWL_LED_TRG_TX],
+                                   &priv->led[IWL_LED_TRG_TX],
                                    IWL_LED_TRG_TX, 0, trigger);
 
-        priv->led39[IWL_LED_TRG_TX].led_on = iwl3945_led_associated;
-        priv->led39[IWL_LED_TRG_TX].led_off = iwl3945_led_associated;
-        priv->led39[IWL_LED_TRG_TX].led_pattern = iwl3945_led_pattern;
+        priv->led[IWL_LED_TRG_TX].led_on = iwl3945_led_associated;
+        priv->led[IWL_LED_TRG_TX].led_off = iwl3945_led_associated;
+        priv->led[IWL_LED_TRG_TX].led_pattern = iwl3945_led_pattern;
 
         if (ret)
                 goto exit_fail;
@@ -388,7 +389,7 @@ exit_fail:
 
 
 /* unregister led class */
-static void iwl3945_led_unregister_led(struct iwl3945_led *led, u8 set_led)
+static void iwl3945_led_unregister_led(struct iwl_led *led, u8 set_led)
 {
         if (!led->registered)
                 return;
@@ -403,9 +404,10 @@ static void iwl3945_led_unregister_led(struct iwl3945_led *led, u8 set_led)
 /* Unregister all led handlers */
 void iwl3945_led_unregister(struct iwl_priv *priv)
 {
-        iwl3945_led_unregister_led(&priv->led39[IWL_LED_TRG_ASSOC], 0);
-        iwl3945_led_unregister_led(&priv->led39[IWL_LED_TRG_RX], 0);
-        iwl3945_led_unregister_led(&priv->led39[IWL_LED_TRG_TX], 0);
-        iwl3945_led_unregister_led(&priv->led39[IWL_LED_TRG_RADIO], 1);
+        iwl3945_led_unregister_led(&priv->led[IWL_LED_TRG_ASSOC], 0);
+        iwl3945_led_unregister_led(&priv->led[IWL_LED_TRG_RX], 0);
+        iwl3945_led_unregister_led(&priv->led[IWL_LED_TRG_TX], 0);
+        iwl3945_led_unregister_led(&priv->led[IWL_LED_TRG_RADIO], 1);
 }
 
+#endif
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945-led.h b/drivers/net/wireless/iwlwifi/iwl-3945-led.h
index 88185a6ccd6a..3b65642258ca 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945-led.h
+++ b/drivers/net/wireless/iwlwifi/iwl-3945-led.h
@@ -29,24 +29,10 @@
 
 struct iwl_priv;
 
-#ifdef CONFIG_IWL3945_LEDS
+#ifdef CONFIG_IWLWIFI_LEDS
 
 #include "iwl-led.h"
 
-struct iwl3945_led {
-        struct iwl_priv *priv;
-        struct led_classdev led_dev;
-        char name[32];
-
-        int (*led_on) (struct iwl_priv *priv, int led_id);
-        int (*led_off) (struct iwl_priv *priv, int led_id);
-        int (*led_pattern) (struct iwl_priv *priv, int led_id,
-                            unsigned int idx);
-
-        enum led_type type;
-        unsigned int registered;
-};
-
 extern int iwl3945_led_register(struct iwl_priv *priv);
 extern void iwl3945_led_unregister(struct iwl_priv *priv);
 extern void iwl3945_led_background(struct iwl_priv *priv);
@@ -55,6 +41,6 @@ extern void iwl3945_led_background(struct iwl_priv *priv);
 static inline int iwl3945_led_register(struct iwl_priv *priv) { return 0; }
 static inline void iwl3945_led_unregister(struct iwl_priv *priv) {}
 static inline void iwl3945_led_background(struct iwl_priv *priv) {}
-#endif /* CONFIG_IWL3945_LEDS */
 
+#endif /* IWLWIFI_LEDS*/
 #endif /* IWL3945_LEDS_H */
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
index a2664589c884..f65c308a6714 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
@@ -127,6 +127,7 @@ static struct iwl3945_tpt_entry iwl3945_tpt_table_g[] = {
 #define IWL_RATE_MIN_FAILURE_TH       8
 #define IWL_RATE_MIN_SUCCESS_TH       8
 #define IWL_RATE_DECREASE_TH       1920
+#define IWL_RATE_RETRY_TH            15
 
 static u8 iwl3945_get_rate_index_by_rssi(s32 rssi, enum ieee80211_band band)
 {
@@ -298,37 +299,53 @@ static void iwl3945_collect_tx_data(struct iwl3945_rs_sta *rs_sta,
         }
 
         spin_lock_irqsave(&rs_sta->lock, flags);
-        while (retries--) {
 
-                /* If we have filled up the window then subtract one from the
-                 * success counter if the high-bit is counting toward
-                 * success */
-                if (window->counter == IWL_RATE_MAX_WINDOW) {
-                        if (window->data & (1ULL << (IWL_RATE_MAX_WINDOW - 1)))
+        /*
+         * Keep track of only the latest 62 tx frame attempts in this rate's
+         * history window; anything older isn't really relevant any more.
+         * If we have filled up the sliding window, drop the oldest attempt;
+         * if the oldest attempt (highest bit in bitmap) shows "success",
+         * subtract "1" from the success counter (this is the main reason
+         * we keep these bitmaps!).
+         * */
+        while (retries > 0) {
+                if (window->counter >= IWL_RATE_MAX_WINDOW) {
+
+                        /* remove earliest */
+                        window->counter = IWL_RATE_MAX_WINDOW - 1;
+
+                        if (window->data & (1ULL << (IWL_RATE_MAX_WINDOW - 1))) {
+                                window->data &= ~(1ULL << (IWL_RATE_MAX_WINDOW - 1));
                                 window->success_counter--;
-                } else
-                        window->counter++;
+                        }
+                }
 
-                /* Slide the window to the left one bit */
-                window->data = (window->data << 1);
+                /* Increment frames-attempted counter */
+                window->counter++;
 
-                /* If this packet was a success then set the low bit high */
-                if (success) {
+                /* Shift bitmap by one frame (throw away oldest history),
+                 * OR in "1", and increment "success" if this
+                 * frame was successful. */
+                window->data <<= 1;
+                if (success > 0) {
                         window->success_counter++;
-                        window->data |= 1;
+                        window->data |= 0x1;
+                        success--;
                 }
 
-                /* window->counter can't be 0 -- it is either >0 or
-                 * IWL_RATE_MAX_WINDOW */
-                window->success_ratio = 12800 * window->success_counter /
-                    window->counter;
-
-                /* Tag this window as having been updated */
-                window->stamp = jiffies;
-
+                retries--;
         }
 
+        /* Calculate current success ratio, avoid divide-by-0! */
+        if (window->counter > 0)
+                window->success_ratio = 128 * (100 * window->success_counter)
+                                        / window->counter;
+        else
+                window->success_ratio = IWL_INVALID_VALUE;
+
         fail_count = window->counter - window->success_counter;
+
+        /* Calculate average throughput, if we have enough history. */
         if ((fail_count >= IWL_RATE_MIN_FAILURE_TH) ||
             (window->success_counter >= IWL_RATE_MIN_SUCCESS_TH))
                 window->average_tpt = ((window->success_ratio *
@@ -336,6 +353,9 @@ static void iwl3945_collect_tx_data(struct iwl3945_rs_sta *rs_sta,
         else
                 window->average_tpt = IWL_INVALID_VALUE;
 
+        /* Tag this window as having been updated */
+        window->stamp = jiffies;
+
         spin_unlock_irqrestore(&rs_sta->lock, flags);
 
 }
@@ -468,7 +488,10 @@ static void rs_tx_status(void *priv_rate, struct ieee80211_supported_band *sband
 
         IWL_DEBUG_RATE(priv, "enter\n");
 
-        retries = info->status.rates[0].count;
+        retries = info->status.rates[0].count - 1;
+        /* Sanity Check for retries */
+        if (retries > IWL_RATE_RETRY_TH)
+                retries = IWL_RATE_RETRY_TH;
 
         first_index = sband->bitrates[info->status.rates[0].idx].hw_value;
         if ((first_index < 0) || (first_index >= IWL_RATE_COUNT_3945)) {
@@ -724,7 +747,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
 
         fail_count = window->counter - window->success_counter;
 
-        if (((fail_count <= IWL_RATE_MIN_FAILURE_TH) &&
+        if (((fail_count < IWL_RATE_MIN_FAILURE_TH) &&
              (window->success_counter < IWL_RATE_MIN_SUCCESS_TH))) {
                 spin_unlock_irqrestore(&rs_sta->lock, flags);
 
@@ -735,6 +758,9 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
                                window->counter,
                                window->success_counter,
                                rs_sta->expected_tpt ? "not " : "");
+
+           /* Can't calculate this yet; not enough history */
+                window->average_tpt = IWL_INVALID_VALUE;
                 goto out;
 
         }
@@ -750,6 +776,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
         if ((max_rate_idx != -1) && (max_rate_idx < high))
                 high = IWL_RATE_INVALID;
 
+        /* Collect Measured throughputs of adjacent rates */
         if (low != IWL_RATE_INVALID)
                 low_tpt = rs_sta->win[low].average_tpt;
 
@@ -758,24 +785,43 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
 
         spin_unlock_irqrestore(&rs_sta->lock, flags);
 
-        scale_action = 1;
+        scale_action = 0;
 
+        /* Low success ratio , need to drop the rate */
         if ((window->success_ratio < IWL_RATE_DECREASE_TH) || !current_tpt) {
                 IWL_DEBUG_RATE(priv, "decrease rate because of low success_ratio\n");
                 scale_action = -1;
+
+        /* No throughput measured yet for adjacent rates,
+         * try increase */
         } else if ((low_tpt == IWL_INVALID_VALUE) &&
-                   (high_tpt == IWL_INVALID_VALUE))
-                scale_action = 1;
-        else if ((low_tpt != IWL_INVALID_VALUE) &&
+                   (high_tpt == IWL_INVALID_VALUE)) {
+
+                if (high != IWL_RATE_INVALID && window->success_counter >= IWL_RATE_INCREASE_TH)
+                        scale_action = 1;
+                else if (low != IWL_RATE_INVALID)
+                        scale_action = -1;
+
+        /* Both adjacent throughputs are measured, but neither one has
+         * better throughput; we're using the best rate, don't change
+         * it! */
+        } else if ((low_tpt != IWL_INVALID_VALUE) &&
                  (high_tpt != IWL_INVALID_VALUE) &&
                  (low_tpt < current_tpt) && (high_tpt < current_tpt)) {
+
                 IWL_DEBUG_RATE(priv, "No action -- low [%d] & high [%d] < "
                                "current_tpt [%d]\n",
                                low_tpt, high_tpt, current_tpt);
                 scale_action = 0;
+
+        /* At least one of the rates has better throughput */
         } else {
                 if (high_tpt != IWL_INVALID_VALUE) {
-                        if (high_tpt > current_tpt)
+
+                        /* High rate has better throughput, Increase
+                         * rate */
+                        if (high_tpt > current_tpt &&
+                                window->success_ratio >= IWL_RATE_INCREASE_TH)
                                 scale_action = 1;
                         else {
                                 IWL_DEBUG_RATE(priv,
@@ -787,29 +833,31 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
                                 IWL_DEBUG_RATE(priv,
                                     "decrease rate because of low tpt\n");
                                 scale_action = -1;
-                        } else
+                        } else if (window->success_counter >= IWL_RATE_INCREASE_TH) {
+                                /* Lower rate has better
+                                 * throughput,decrease rate */
                                 scale_action = 1;
+                        }
                 }
         }
 
-        if (scale_action == -1) {
-                if (window->success_ratio > IWL_SUCCESS_DOWN_TH)
-                        scale_action = 0;
-        } else if (scale_action == 1) {
-                if (window->success_ratio < IWL_SUCCESS_UP_TH) {
-                        IWL_DEBUG_RATE(priv, "No action -- success_ratio [%d] < "
-                               "SUCCESS UP\n", window->success_ratio);
-                        scale_action = 0;
-                }
-        }
+        /* Sanity check; asked for decrease, but success rate or throughput
+         * has been good at old rate.  Don't change it. */
+        if ((scale_action == -1) && (low != IWL_RATE_INVALID) &&
+                    ((window->success_ratio > IWL_RATE_HIGH_TH) ||
+                     (current_tpt > (100 * rs_sta->expected_tpt[low]))))
+                scale_action = 0;
 
         switch (scale_action) {
         case -1:
+
+                /* Decrese rate */
                 if (low != IWL_RATE_INVALID)
                         index = low;
                 break;
 
         case 1:
+                /* Increase rate */
                 if (high != IWL_RATE_INVALID)
                         index = high;
 
@@ -817,6 +865,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
 
         case 0:
         default:
+                /* No change */
                 break;
         }
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c
index 0a750534ddf2..ba7e720e73c1 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
@@ -554,7 +554,7 @@ static void iwl3945_pass_packet_to_mac80211(struct iwl_priv *priv,
                                    struct ieee80211_rx_status *stats)
 {
         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
-#ifdef CONFIG_IWL3945_LEDS
+#ifdef CONFIG_IWLWIFI_LEDS
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)IWL_RX_DATA(pkt);
 #endif
         struct iwl3945_rx_frame_hdr *rx_hdr = IWL_RX_HDR(pkt);
@@ -583,7 +583,7 @@ static void iwl3945_pass_packet_to_mac80211(struct iwl_priv *priv,
                                        (struct ieee80211_hdr *)rxb->skb->data,
                                        le32_to_cpu(rx_end->status), stats);
 
-#ifdef CONFIG_IWL3945_LEDS
+#ifdef CONFIG_IWLWIFI_LEDS
         if (ieee80211_is_data(hdr->frame_control))
                 priv->rxtxpackets += len;
 #endif
@@ -741,7 +741,8 @@ int iwl3945_hw_txq_attach_buf_to_tfd(struct iwl_priv *priv,
 void iwl3945_hw_txq_free_tfd(struct iwl_priv *priv, struct iwl_tx_queue *txq)
 {
         struct iwl3945_tfd *tfd_tmp = (struct iwl3945_tfd *)txq->tfds;
-        struct iwl3945_tfd *tfd = &tfd_tmp[txq->q.read_ptr];
+        int index = txq->q.read_ptr;
+        struct iwl3945_tfd *tfd = &tfd_tmp[index];
         struct pci_dev *dev = priv->pci_dev;
         int i;
         int counter;
@@ -759,6 +760,13 @@ void iwl3945_hw_txq_free_tfd(struct iwl_priv *priv, struct iwl_tx_queue *txq)
                 return;
         }
 
+        /* Unmap tx_cmd */
+        if (counter)
+                pci_unmap_single(dev,
+                                pci_unmap_addr(&txq->cmd[index]->meta, mapping),
+                                pci_unmap_len(&txq->cmd[index]->meta, len),
+                                PCI_DMA_TODEVICE);
+
         /* unmap chunks if any */
 
         for (i = 1; i < counter; i++) {
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
index 99da40678878..cab7842a73aa 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
@@ -801,7 +801,10 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
             !(info->flags & IEEE80211_TX_STAT_AMPDU))
                 return;
 
-        retries = info->status.rates[0].count - 1;
+        if (info->flags & IEEE80211_TX_STAT_AMPDU)
+                retries = 0;
+        else
+                retries = info->status.rates[0].count - 1;
 
         if (retries > 15)
                 retries = 15;
@@ -913,7 +916,7 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
                         tpt = search_tbl->expected_tpt[rs_index];
                 else
                         tpt = 0;
-                if (info->flags & IEEE80211_TX_CTL_AMPDU)
+                if (info->flags & IEEE80211_TX_STAT_AMPDU)
                         rs_collect_tx_data(search_win, rs_index, tpt,
                                            info->status.ampdu_ack_len,
                                            info->status.ampdu_ack_map);
@@ -929,7 +932,7 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
                         tpt = curr_tbl->expected_tpt[rs_index];
                 else
                         tpt = 0;
-                if (info->flags & IEEE80211_TX_CTL_AMPDU)
+                if (info->flags & IEEE80211_TX_STAT_AMPDU)
                         rs_collect_tx_data(window, rs_index, tpt,
                                            info->status.ampdu_ack_len,
                                            info->status.ampdu_ack_map);
@@ -941,7 +944,7 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
         /* If not searching for new mode, increment success/failed counter
          * ... these help determine when to start searching again */
         if (lq_sta->stay_in_tbl) {
-                if (info->flags & IEEE80211_TX_CTL_AMPDU) {
+                if (info->flags & IEEE80211_TX_STAT_AMPDU) {
                         lq_sta->total_success += info->status.ampdu_ack_map;
                         lq_sta->total_failed +=
                              (info->status.ampdu_ack_len - info->status.ampdu_ack_map);
@@ -1700,6 +1703,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
         u16 high_low;
         s32 sr;
         u8 tid = MAX_TID_COUNT;
+        struct iwl_tid_data *tid_data;
 
         IWL_DEBUG_RATE(priv, "rate scale calculate new rate for skb\n");
 
@@ -1896,7 +1900,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
                 if (high != IWL_RATE_INVALID && sr >= IWL_RATE_INCREASE_TH)
                         scale_action = 1;
                 else if (low != IWL_RATE_INVALID)
-                        scale_action = -1;
+                        scale_action = 0;
         }
 
         /* Both adjacent throughputs are measured, but neither one has better
@@ -1917,9 +1921,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
                                         sr >= IWL_RATE_INCREASE_TH) {
                                 scale_action = 1;
                         } else {
-                                IWL_DEBUG_RATE(priv,
-                                    "decrease rate because of high tpt\n");
-                                scale_action = -1;
+                                scale_action = 0;
                         }
 
                 /* Lower adjacent rate's throughput is measured */
@@ -2035,8 +2037,15 @@ lq_update:
                         if ((lq_sta->last_tpt > IWL_AGG_TPT_THREHOLD) &&
                             (lq_sta->tx_agg_tid_en & (1 << tid)) &&
                             (tid != MAX_TID_COUNT)) {
-                                IWL_DEBUG_RATE(priv, "try to aggregate tid %d\n", tid);
-                                rs_tl_turn_on_agg(priv, tid, lq_sta, sta);
+                                tid_data =
+                                   &priv->stations[lq_sta->lq.sta_id].tid[tid];
+                                if (tid_data->agg.state == IWL_AGG_OFF) {
+                                        IWL_DEBUG_RATE(priv,
+                                                       "try to aggregate tid %d\n",
+                                                       tid);
+                                        rs_tl_turn_on_agg(priv, tid,
+                                                          lq_sta, sta);
+                                }
                         }
                         lq_sta->action_counter = 0;
                         rs_set_stay_in_table(priv, 0, lq_sta);
@@ -2464,18 +2473,25 @@ static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
                              u32 *rate_n_flags, int index)
 {
         struct iwl_priv *priv;
+        u8 valid_tx_ant;
+        u8 ant_sel_tx;
 
         priv = lq_sta->drv;
+        valid_tx_ant = priv->hw_params.valid_tx_ant;
         if (lq_sta->dbg_fixed_rate) {
-                if (index < 12) {
+                ant_sel_tx =
+                  ((lq_sta->dbg_fixed_rate & RATE_MCS_ANT_ABC_MSK)
+                  >> RATE_MCS_ANT_POS);
+                if ((valid_tx_ant & ant_sel_tx) == ant_sel_tx) {
                         *rate_n_flags = lq_sta->dbg_fixed_rate;
+                        IWL_DEBUG_RATE(priv, "Fixed rate ON\n");
                 } else {
-                        if (lq_sta->band == IEEE80211_BAND_5GHZ)
-                                *rate_n_flags = 0x800D;
-                        else
-                                *rate_n_flags = 0x820A;
+                        lq_sta->dbg_fixed_rate = 0;
+                        IWL_ERR(priv,
+                            "Invalid antenna selection 0x%X, Valid is 0x%X\n",
+                            ant_sel_tx, valid_tx_ant);
+                        IWL_DEBUG_RATE(priv, "Fixed rate OFF\n");
                 }
-                IWL_DEBUG_RATE(priv, "Fixed rate ON\n");
         } else {
                 IWL_DEBUG_RATE(priv, "Fixed rate OFF\n");
         }
@@ -2526,7 +2542,10 @@ static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file,
         ssize_t ret;
 
         struct iwl_lq_sta *lq_sta = file->private_data;
+        struct iwl_priv *priv;
+        struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
 
+        priv = lq_sta->drv;
         buff = kmalloc(1024, GFP_KERNEL);
         if (!buff)
                 return -ENOMEM;
@@ -2537,6 +2556,20 @@ static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file,
                         lq_sta->active_legacy_rate);
         desc += sprintf(buff+desc, "fixed rate 0x%X\n",
                         lq_sta->dbg_fixed_rate);
+        desc += sprintf(buff+desc, "valid_tx_ant %s%s%s\n",
+            (priv->hw_params.valid_tx_ant & ANT_A) ? "ANT_A," : "",
+            (priv->hw_params.valid_tx_ant & ANT_B) ? "ANT_B," : "",
+            (priv->hw_params.valid_tx_ant & ANT_C) ? "ANT_C" : "");
+        desc += sprintf(buff+desc, "lq type %s\n",
+           (is_legacy(tbl->lq_type)) ? "legacy" : "HT");
+        if (is_Ht(tbl->lq_type)) {
+                desc += sprintf(buff+desc, " %s",
+                   (is_siso(tbl->lq_type)) ? "SISO" :
+                   ((is_mimo2(tbl->lq_type)) ? "MIMO2" : "MIMO3"));
+                   desc += sprintf(buff+desc, " %s",
+                   (tbl->is_fat) ? "40MHz" : "20MHz");
+                desc += sprintf(buff+desc, " %s\n", (tbl->is_SGI) ? "SGI" : "");
+        }
         desc += sprintf(buff+desc, "general:"
                 "flags=0x%X mimo-d=%d s-ant0x%x d-ant=0x%x\n",
                 lq_sta->lq.general_params.flags,
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-rs.h b/drivers/net/wireless/iwlwifi/iwl-agn-rs.h
index 345806dd8870..ab59acc405d9 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-rs.h
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-rs.h
@@ -231,7 +231,7 @@ enum {
 #define IWL_RS_GOOD_RATIO               12800   /* 100% */
 #define IWL_RATE_SCALE_SWITCH           10880   /*  85% */
 #define IWL_RATE_HIGH_TH                10880   /*  85% */
-#define IWL_RATE_INCREASE_TH            8960    /*  70% */
+#define IWL_RATE_INCREASE_TH            6400    /*  50% */
 #define IWL_RATE_DECREASE_TH            1920    /*  15% */
 
 /* possible actions when in legacy mode */
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 7902d22da663..0db3bc011ac2 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -3359,7 +3359,7 @@ static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         /* amp init */
         err = priv->cfg->ops->lib->apm_ops.init(priv);
         if (err < 0) {
-                IWL_DEBUG_INFO(priv, "Failed to init APMG\n");
+                IWL_ERR(priv, "Failed to init APMG\n");
                 goto out_iounmap;
         }
         /*****************
@@ -3643,9 +3643,9 @@ static struct pci_device_id iwl_hw_card_ids[] = {
         {IWL_PCI_DEVICE(0x0087, PCI_ANY_ID, iwl6050_2agn_cfg)},
         {IWL_PCI_DEVICE(0x0088, PCI_ANY_ID, iwl6050_3agn_cfg)},
         {IWL_PCI_DEVICE(0x0089, PCI_ANY_ID, iwl6050_2agn_cfg)},
-/* 100 Series WiFi */
-        {IWL_PCI_DEVICE(0x0083, PCI_ANY_ID, iwl100_bgn_cfg)},
-        {IWL_PCI_DEVICE(0x0084, PCI_ANY_ID, iwl100_bgn_cfg)},
+/* 1000 Series WiFi */
+        {IWL_PCI_DEVICE(0x0083, PCI_ANY_ID, iwl1000_bgn_cfg)},
+        {IWL_PCI_DEVICE(0x0084, PCI_ANY_ID, iwl1000_bgn_cfg)},
 #endif /* CONFIG_IWL5000 */
 
         {0}
diff --git a/drivers/net/wireless/iwlwifi/iwl-csr.h b/drivers/net/wireless/iwlwifi/iwl-csr.h
index 5028c781275b..2f1242447b3b 100644
--- a/drivers/net/wireless/iwlwifi/iwl-csr.h
+++ b/drivers/net/wireless/iwlwifi/iwl-csr.h
@@ -211,7 +211,7 @@
 #define CSR_HW_REV_TYPE_5350           (0x0000030)
 #define CSR_HW_REV_TYPE_5100           (0x0000050)
 #define CSR_HW_REV_TYPE_5150           (0x0000040)
-#define CSR_HW_REV_TYPE_100            (0x0000060)
+#define CSR_HW_REV_TYPE_1000           (0x0000060)
 #define CSR_HW_REV_TYPE_6x00           (0x0000070)
 #define CSR_HW_REV_TYPE_6x50           (0x0000080)
 #define CSR_HW_REV_TYPE_NONE           (0x00000F0)
diff --git a/drivers/net/wireless/iwlwifi/iwl-dev.h b/drivers/net/wireless/iwlwifi/iwl-dev.h
index b3e23abb9117..0baae8022824 100644
--- a/drivers/net/wireless/iwlwifi/iwl-dev.h
+++ b/drivers/net/wireless/iwlwifi/iwl-dev.h
@@ -62,7 +62,7 @@ extern struct iwl_cfg iwl6000_2agn_cfg;
 extern struct iwl_cfg iwl6000_3agn_cfg;
 extern struct iwl_cfg iwl6050_2agn_cfg;
 extern struct iwl_cfg iwl6050_3agn_cfg;
-extern struct iwl_cfg iwl100_bgn_cfg;
+extern struct iwl_cfg iwl1000_bgn_cfg;
 
 /* shared structures from iwl-5000.c */
 extern struct iwl_mod_params iwl50_mod_params;
@@ -926,19 +926,12 @@ struct iwl_priv {
         struct rfkill *rfkill;
 #endif
 
-#if defined(CONFIG_IWLWIFI_LEDS) || defined(CONFIG_IWL3945_LEDS)
+#ifdef CONFIG_IWLWIFI_LEDS
         unsigned long last_blink_time;
         u8 last_blink_rate;
         u8 allow_blinking;
         u64 led_tpt;
-#endif
-
-#ifdef CONFIG_IWLWIFI_LEDS
         struct iwl_led led[IWL_LED_TRG_MAX];
-#endif
-
-#ifdef CONFIG_IWL3945_LEDS
-        struct iwl3945_led led39[IWL_LED_TRG_MAX];
         unsigned int rxtxpackets;
 #endif
         u16 active_rate;
diff --git a/drivers/net/wireless/iwlwifi/iwl-io.h b/drivers/net/wireless/iwlwifi/iwl-io.h
index c7b8e5bb4e42..083ea1ffbe87 100644
--- a/drivers/net/wireless/iwlwifi/iwl-io.h
+++ b/drivers/net/wireless/iwlwifi/iwl-io.h
@@ -156,6 +156,7 @@ static inline void __iwl_clear_bit(const char *f, u32 l,
 static inline int _iwl_grab_nic_access(struct iwl_priv *priv)
 {
         int ret;
+        u32 val;
 #ifdef CONFIG_IWLWIFI_DEBUG
         if (atomic_read(&priv->restrict_refcnt))
                 return 0;
@@ -167,7 +168,8 @@ static inline int _iwl_grab_nic_access(struct iwl_priv *priv)
                            (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
                             CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 15000);
         if (ret < 0) {
-                IWL_ERR(priv, "MAC is in deep sleep!\n");
+                val = _iwl_read32(priv, CSR_GP_CNTRL);
+                IWL_ERR(priv, "MAC is in deep sleep!.  CSR_GP_CNTRL = 0x%08X\n", val);
                 return -EIO;
         }
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-led.h b/drivers/net/wireless/iwlwifi/iwl-led.h
index 140fd8fa4855..ef9b174c37ff 100644
--- a/drivers/net/wireless/iwlwifi/iwl-led.h
+++ b/drivers/net/wireless/iwlwifi/iwl-led.h
@@ -30,7 +30,7 @@
 
 struct iwl_priv;
 
-#if defined(CONFIG_IWLWIFI_LEDS) || defined(CONFIG_IWL3945_LEDS)
+#ifdef CONFIG_IWLWIFI_LEDS
 #include <linux/leds.h>
 
 #define IWL_LED_SOLID 11
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
index 0ea08d080928..1684490d93c0 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.c
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.c
@@ -472,6 +472,7 @@ EXPORT_SYMBOL(iwl_remove_station);
 void iwl_clear_stations_table(struct iwl_priv *priv)
 {
         unsigned long flags;
+        int i;
 
         spin_lock_irqsave(&priv->sta_lock, flags);
 
@@ -486,6 +487,12 @@ void iwl_clear_stations_table(struct iwl_priv *priv)
         /* clean ucode key table bit map */
         priv->ucode_key_table = 0;
 
+        /* keep track of static keys */
+        for (i = 0; i < WEP_KEYS_MAX ; i++) {
+                if (priv->wep_keys[i].key_size)
+                        test_and_set_bit(i, &priv->ucode_key_table);
+        }
+
         spin_unlock_irqrestore(&priv->sta_lock, flags);
 }
 EXPORT_SYMBOL(iwl_clear_stations_table);
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index d37679c69a5c..4465320f2735 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -328,6 +328,8 @@ static int iwl3945_commit_rxon(struct iwl_priv *priv)
         struct iwl3945_rxon_cmd *active_rxon = (void *)&priv->active_rxon;
         struct iwl3945_rxon_cmd *staging_rxon = (void *)&priv->staging_rxon;
         int rc = 0;
+        bool new_assoc =
+                !!(priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK);
 
         if (!iwl_is_alive(priv))
                 return -1;
@@ -366,8 +368,7 @@ static int iwl3945_commit_rxon(struct iwl_priv *priv)
          * an RXON_ASSOC and the new config wants the associated mask enabled,
          * we must clear the associated from the active configuration
          * before we apply the new config */
-        if (iwl_is_associated(priv) &&
-            (staging_rxon->filter_flags & RXON_FILTER_ASSOC_MSK)) {
+        if (iwl_is_associated(priv) && new_assoc) {
                 IWL_DEBUG_INFO(priv, "Toggling associated bit on current RXON\n");
                 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 
@@ -395,8 +396,7 @@ static int iwl3945_commit_rxon(struct iwl_priv *priv)
                        "* with%s RXON_FILTER_ASSOC_MSK\n"
                        "* channel = %d\n"
                        "* bssid = %pM\n",
-                       ((priv->staging_rxon.filter_flags &
-                         RXON_FILTER_ASSOC_MSK) ? "" : "out"),
+                       (new_assoc ? "" : "out"),
                        le16_to_cpu(staging_rxon->channel),
                        staging_rxon->bssid_addr);
 
@@ -542,7 +542,7 @@ static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
         return 0;
 }
 
-int iwl3945_set_dynamic_key(struct iwl_priv *priv,
+static int iwl3945_set_dynamic_key(struct iwl_priv *priv,
                         struct ieee80211_key_conf *keyconf, u8 sta_id)
 {
         int ret = 0;
@@ -890,7 +890,7 @@ static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
                         tx->timeout.pm_frame_timeout = cpu_to_le16(2);
         } else {
                 tx->timeout.pm_frame_timeout = 0;
-#ifdef CONFIG_IWL3945_LEDS
+#ifdef CONFIG_IWLWIFI_LEDS
                 priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
 #endif
         }
@@ -1479,85 +1479,6 @@ static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
         iwl3945_hw_rx_handler_setup(priv);
 }
 
-/**
- * iwl3945_cmd_queue_reclaim - Reclaim CMD queue entries
- * When FW advances 'R' index, all entries between old and new 'R' index
- * need to be reclaimed.
- */
-static void iwl3945_cmd_queue_reclaim(struct iwl_priv *priv,
-                                      int txq_id, int index)
-{
-        struct iwl_tx_queue *txq = &priv->txq[txq_id];
-        struct iwl_queue *q = &txq->q;
-        int nfreed = 0;
-
-        if ((index >= q->n_bd) || (iwl_queue_used(q, index) == 0)) {
-                IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
-                          "is out of range [0-%d] %d %d.\n", txq_id,
-                          index, q->n_bd, q->write_ptr, q->read_ptr);
-                return;
-        }
-
-        for (index = iwl_queue_inc_wrap(index, q->n_bd); q->read_ptr != index;
-                q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
-                if (nfreed > 1) {
-                        IWL_ERR(priv, "HCMD skipped: index (%d) %d %d\n", index,
-                                        q->write_ptr, q->read_ptr);
-                        queue_work(priv->workqueue, &priv->restart);
-                        break;
-                }
-                nfreed++;
-        }
-}
-
-
-/**
- * iwl3945_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
- * @rxb: Rx buffer to reclaim
- *
- * If an Rx buffer has an async callback associated with it the callback
- * will be executed.  The attached skb (if present) will only be freed
- * if the callback returns 1
- */
-static void iwl3945_tx_cmd_complete(struct iwl_priv *priv,
-                                struct iwl_rx_mem_buffer *rxb)
-{
-        struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
-        u16 sequence = le16_to_cpu(pkt->hdr.sequence);
-        int txq_id = SEQ_TO_QUEUE(sequence);
-        int index = SEQ_TO_INDEX(sequence);
-        int huge =  !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
-        int cmd_index;
-        struct iwl_cmd *cmd;
-
-        if (WARN(txq_id != IWL_CMD_QUEUE_NUM,
-                 "wrong command queue %d, sequence 0x%X readp=%d writep=%d\n",
-                  txq_id, sequence,
-                  priv->txq[IWL_CMD_QUEUE_NUM].q.read_ptr,
-                  priv->txq[IWL_CMD_QUEUE_NUM].q.write_ptr)) {
-                iwl_print_hex_dump(priv, IWL_DL_INFO , rxb, 32);
-                return;
-        }
-
-        cmd_index = get_cmd_index(&priv->txq[IWL_CMD_QUEUE_NUM].q, index, huge);
-        cmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_index];
-
-        /* Input error checking is done when commands are added to queue. */
-        if (cmd->meta.flags & CMD_WANT_SKB) {
-                cmd->meta.source->u.skb = rxb->skb;
-                rxb->skb = NULL;
-        } else if (cmd->meta.u.callback &&
-                   !cmd->meta.u.callback(priv, cmd, rxb->skb))
-                rxb->skb = NULL;
-
-        iwl3945_cmd_queue_reclaim(priv, txq_id, index);
-
-        if (!(cmd->meta.flags & CMD_ASYNC)) {
-                clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
-                wake_up_interruptible(&priv->wait_command_queue);
-        }
-}
-
 /************************** RX-FUNCTIONS ****************************/
 /*
  * Rx theory of operation
@@ -1917,7 +1838,7 @@ static void iwl3945_rx_handle(struct iwl_priv *priv)
                          * fire off the (possibly) blocking iwl_send_cmd()
                          * as we reclaim the driver command queue */
                         if (rxb && rxb->skb)
-                                iwl3945_tx_cmd_complete(priv, rxb);
+                                iwl_tx_cmd_complete(priv, rxb);
                         else
                                 IWL_WARN(priv, "Claim null rxb?\n");
                 }
diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
index fce49ba061d5..a15078bcad73 100644
--- a/drivers/net/wireless/mac80211_hwsim.c
+++ b/drivers/net/wireless/mac80211_hwsim.c
@@ -10,7 +10,6 @@
 /*
  * TODO:
  * - IBSS mode simulation (Beacon transmission with competition for "air time")
- * - IEEE 802.11a and 802.11n modes
  * - RX filtering based on filter configuration (data->rx_filter)
  */
 
@@ -31,6 +30,112 @@ static int radios = 2;
 module_param(radios, int, 0444);
 MODULE_PARM_DESC(radios, "Number of simulated radios");
 
+/**
+ * enum hwsim_regtest - the type of regulatory tests we offer
+ *
+ * These are the different values you can use for the regtest
+ * module parameter. This is useful to help test world roaming
+ * and the driver regulatory_hint() call and combinations of these.
+ * If you want to do specific alpha2 regulatory domain tests simply
+ * use the userspace regulatory request as that will be respected as
+ * well without the need of this module parameter. This is designed
+ * only for testing the driver regulatory request, world roaming
+ * and all possible combinations.
+ *
+ * @HWSIM_REGTEST_DISABLED: No regulatory tests are performed,
+ *      this is the default value.
+ * @HWSIM_REGTEST_DRIVER_REG_FOLLOW: Used for testing the driver regulatory
+ *      hint, only one driver regulatory hint will be sent as such the
+ *      secondary radios are expected to follow.
+ * @HWSIM_REGTEST_DRIVER_REG_ALL: Used for testing the driver regulatory
+ *      request with all radios reporting the same regulatory domain.
+ * @HWSIM_REGTEST_DIFF_COUNTRY: Used for testing the drivers calling
+ *      different regulatory domains requests. Expected behaviour is for
+ *      an intersection to occur but each device will still use their
+ *      respective regulatory requested domains. Subsequent radios will
+ *      use the resulting intersection.
+ * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We acomplish
+ *      this by using a custom beacon-capable regulatory domain for the first
+ *      radio. All other device world roam.
+ * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory
+ *      domain requests. All radios will adhere to this custom world regulatory
+ *      domain.
+ * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory
+ *      domain requests. The first radio will adhere to the first custom world
+ *      regulatory domain, the second one to the second custom world regulatory
+ *      domain. All other devices will world roam.
+ * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain
+ *      settings, only the first radio will send a regulatory domain request
+ *      and use strict settings. The rest of the radios are expected to follow.
+ * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain
+ *      settings. All radios will adhere to this.
+ * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory
+ *      domain settings, combined with secondary driver regulatory domain
+ *      settings. The first radio will get a strict regulatory domain setting
+ *      using the first driver regulatory request and the second radio will use
+ *      non-strict settings using the second driver regulatory request. All
+ *      other devices should follow the intersection created between the
+ *      first two.
+ * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need
+ *      at least 6 radios for a complete test. We will test in this order:
+ *      1 - driver custom world regulatory domain
+ *      2 - second custom world regulatory domain
+ *      3 - first driver regulatory domain request
+ *      4 - second driver regulatory domain request
+ *      5 - strict regulatory domain settings using the third driver regulatory
+ *          domain request
+ *      6 and on - should follow the intersection of the 3rd, 4rth and 5th radio
+ *                 regulatory requests.
+ */
+enum hwsim_regtest {
+        HWSIM_REGTEST_DISABLED = 0,
+        HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
+        HWSIM_REGTEST_DRIVER_REG_ALL = 2,
+        HWSIM_REGTEST_DIFF_COUNTRY = 3,
+        HWSIM_REGTEST_WORLD_ROAM = 4,
+        HWSIM_REGTEST_CUSTOM_WORLD = 5,
+        HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
+        HWSIM_REGTEST_STRICT_FOLLOW = 7,
+        HWSIM_REGTEST_STRICT_ALL = 8,
+        HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
+        HWSIM_REGTEST_ALL = 10,
+};
+
+/* Set to one of the HWSIM_REGTEST_* values above */
+static int regtest = HWSIM_REGTEST_DISABLED;
+module_param(regtest, int, 0444);
+MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run");
+
+static const char *hwsim_alpha2s[] = {
+        "FI",
+        "AL",
+        "US",
+        "DE",
+        "JP",
+        "AL",
+};
+
+static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = {
+        .n_reg_rules = 4,
+        .alpha2 =  "99",
+        .reg_rules = {
+                REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
+                REG_RULE(2484-10, 2484+10, 40, 0, 20, 0),
+                REG_RULE(5150-10, 5240+10, 40, 0, 30, 0),
+                REG_RULE(5745-10, 5825+10, 40, 0, 30, 0),
+        }
+};
+
+static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
+        .n_reg_rules = 2,
+        .alpha2 =  "99",
+        .reg_rules = {
+                REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
+                REG_RULE(5725-10, 5850+10, 40, 0, 30,
+                        NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
+        }
+};
+
 struct hwsim_vif_priv {
         u32 magic;
         u8 bssid[ETH_ALEN];
@@ -86,22 +191,65 @@ static struct class *hwsim_class;
 
 static struct net_device *hwsim_mon; /* global monitor netdev */
 
+#define CHAN2G(_freq)  { \
+        .band = IEEE80211_BAND_2GHZ, \
+        .center_freq = (_freq), \
+        .hw_value = (_freq), \
+        .max_power = 20, \
+}
+
+#define CHAN5G(_freq) { \
+        .band = IEEE80211_BAND_5GHZ, \
+        .center_freq = (_freq), \
+        .hw_value = (_freq), \
+        .max_power = 20, \
+}
+
+static const struct ieee80211_channel hwsim_channels_2ghz[] = {
+        CHAN2G(2412), /* Channel 1 */
+        CHAN2G(2417), /* Channel 2 */
+        CHAN2G(2422), /* Channel 3 */
+        CHAN2G(2427), /* Channel 4 */
+        CHAN2G(2432), /* Channel 5 */
+        CHAN2G(2437), /* Channel 6 */
+        CHAN2G(2442), /* Channel 7 */
+        CHAN2G(2447), /* Channel 8 */
+        CHAN2G(2452), /* Channel 9 */
+        CHAN2G(2457), /* Channel 10 */
+        CHAN2G(2462), /* Channel 11 */
+        CHAN2G(2467), /* Channel 12 */
+        CHAN2G(2472), /* Channel 13 */
+        CHAN2G(2484), /* Channel 14 */
+};
 
-static const struct ieee80211_channel hwsim_channels[] = {
-        { .center_freq = 2412 },
-        { .center_freq = 2417 },
-        { .center_freq = 2422 },
-        { .center_freq = 2427 },
-        { .center_freq = 2432 },
-        { .center_freq = 2437 },
-        { .center_freq = 2442 },
-        { .center_freq = 2447 },
-        { .center_freq = 2452 },
-        { .center_freq = 2457 },
-        { .center_freq = 2462 },
-        { .center_freq = 2467 },
-        { .center_freq = 2472 },
-        { .center_freq = 2484 },
+static const struct ieee80211_channel hwsim_channels_5ghz[] = {
+        CHAN5G(5180), /* Channel 36 */
+        CHAN5G(5200), /* Channel 40 */
+        CHAN5G(5220), /* Channel 44 */
+        CHAN5G(5240), /* Channel 48 */
+
+        CHAN5G(5260), /* Channel 52 */
+        CHAN5G(5280), /* Channel 56 */
+        CHAN5G(5300), /* Channel 60 */
+        CHAN5G(5320), /* Channel 64 */
+
+        CHAN5G(5500), /* Channel 100 */
+        CHAN5G(5520), /* Channel 104 */
+        CHAN5G(5540), /* Channel 108 */
+        CHAN5G(5560), /* Channel 112 */
+        CHAN5G(5580), /* Channel 116 */
+        CHAN5G(5600), /* Channel 120 */
+        CHAN5G(5620), /* Channel 124 */
+        CHAN5G(5640), /* Channel 128 */
+        CHAN5G(5660), /* Channel 132 */
+        CHAN5G(5680), /* Channel 136 */
+        CHAN5G(5700), /* Channel 140 */
+
+        CHAN5G(5745), /* Channel 149 */
+        CHAN5G(5765), /* Channel 153 */
+        CHAN5G(5785), /* Channel 157 */
+        CHAN5G(5805), /* Channel 161 */
+        CHAN5G(5825), /* Channel 165 */
 };
 
 static const struct ieee80211_rate hwsim_rates[] = {
@@ -126,8 +274,9 @@ struct mac80211_hwsim_data {
         struct list_head list;
         struct ieee80211_hw *hw;
         struct device *dev;
-        struct ieee80211_supported_band band;
-        struct ieee80211_channel channels[ARRAY_SIZE(hwsim_channels)];
+        struct ieee80211_supported_band bands[2];
+        struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
+        struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
         struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
 
         struct ieee80211_channel *channel;
@@ -728,6 +877,7 @@ static int __init init_mac80211_hwsim(void)
         u8 addr[ETH_ALEN];
         struct mac80211_hwsim_data *data;
         struct ieee80211_hw *hw;
+        enum ieee80211_band band;
 
         if (radios < 1 || radios > 100)
                 return -EINVAL;
@@ -785,25 +935,105 @@ static int __init init_mac80211_hwsim(void)
                 hw->vif_data_size = sizeof(struct hwsim_vif_priv);
                 hw->sta_data_size = sizeof(struct hwsim_sta_priv);
 
-                memcpy(data->channels, hwsim_channels, sizeof(hwsim_channels));
+                memcpy(data->channels_2ghz, hwsim_channels_2ghz,
+                        sizeof(hwsim_channels_2ghz));
+                memcpy(data->channels_5ghz, hwsim_channels_5ghz,
+                        sizeof(hwsim_channels_5ghz));
                 memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
-                data->band.channels = data->channels;
-                data->band.n_channels = ARRAY_SIZE(hwsim_channels);
-                data->band.bitrates = data->rates;
-                data->band.n_bitrates = ARRAY_SIZE(hwsim_rates);
-                data->band.ht_cap.ht_supported = true;
-                data->band.ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
-                        IEEE80211_HT_CAP_GRN_FLD |
-                        IEEE80211_HT_CAP_SGI_40 |
-                        IEEE80211_HT_CAP_DSSSCCK40;
-                data->band.ht_cap.ampdu_factor = 0x3;
-                data->band.ht_cap.ampdu_density = 0x6;
-                memset(&data->band.ht_cap.mcs, 0,
-                       sizeof(data->band.ht_cap.mcs));
-                data->band.ht_cap.mcs.rx_mask[0] = 0xff;
-                data->band.ht_cap.mcs.rx_mask[1] = 0xff;
-                data->band.ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &data->band;
+
+                for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) {
+                        struct ieee80211_supported_band *sband = &data->bands[band];
+                        switch (band) {
+                        case IEEE80211_BAND_2GHZ:
+                                sband->channels = data->channels_2ghz;
+                                sband->n_channels =
+                                        ARRAY_SIZE(hwsim_channels_2ghz);
+                                break;
+                        case IEEE80211_BAND_5GHZ:
+                                sband->channels = data->channels_5ghz;
+                                sband->n_channels =
+                                        ARRAY_SIZE(hwsim_channels_5ghz);
+                                break;
+                        default:
+                                break;
+                        }
+
+                        sband->bitrates = data->rates;
+                        sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
+
+                        sband->ht_cap.ht_supported = true;
+                        sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
+                                IEEE80211_HT_CAP_GRN_FLD |
+                                IEEE80211_HT_CAP_SGI_40 |
+                                IEEE80211_HT_CAP_DSSSCCK40;
+                        sband->ht_cap.ampdu_factor = 0x3;
+                        sband->ht_cap.ampdu_density = 0x6;
+                        memset(&sband->ht_cap.mcs, 0,
+                               sizeof(sband->ht_cap.mcs));
+                        sband->ht_cap.mcs.rx_mask[0] = 0xff;
+                        sband->ht_cap.mcs.rx_mask[1] = 0xff;
+                        sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
+
+                        hw->wiphy->bands[band] = sband;
+                }
+
+                /* Work to be done prior to ieee80211_register_hw() */
+                switch (regtest) {
+                case HWSIM_REGTEST_DISABLED:
+                case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
+                case HWSIM_REGTEST_DRIVER_REG_ALL:
+                case HWSIM_REGTEST_DIFF_COUNTRY:
+                        /*
+                         * Nothing to be done for driver regulatory domain
+                         * hints prior to ieee80211_register_hw()
+                         */
+                        break;
+                case HWSIM_REGTEST_WORLD_ROAM:
+                        if (i == 0) {
+                                hw->wiphy->custom_regulatory = true;
+                                wiphy_apply_custom_regulatory(hw->wiphy,
+                                        &hwsim_world_regdom_custom_01);
+                        }
+                        break;
+                case HWSIM_REGTEST_CUSTOM_WORLD:
+                        hw->wiphy->custom_regulatory = true;
+                        wiphy_apply_custom_regulatory(hw->wiphy,
+                                &hwsim_world_regdom_custom_01);
+                        break;
+                case HWSIM_REGTEST_CUSTOM_WORLD_2:
+                        if (i == 0) {
+                                hw->wiphy->custom_regulatory = true;
+                                wiphy_apply_custom_regulatory(hw->wiphy,
+                                        &hwsim_world_regdom_custom_01);
+                        } else if (i == 1) {
+                                hw->wiphy->custom_regulatory = true;
+                                wiphy_apply_custom_regulatory(hw->wiphy,
+                                        &hwsim_world_regdom_custom_02);
+                        }
+                        break;
+                case HWSIM_REGTEST_STRICT_ALL:
+                        hw->wiphy->strict_regulatory = true;
+                        break;
+                case HWSIM_REGTEST_STRICT_FOLLOW:
+                case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
+                        if (i == 0)
+                                hw->wiphy->strict_regulatory = true;
+                        break;
+                case HWSIM_REGTEST_ALL:
+                        if (i == 0) {
+                                hw->wiphy->custom_regulatory = true;
+                                wiphy_apply_custom_regulatory(hw->wiphy,
+                                        &hwsim_world_regdom_custom_01);
+                        } else if (i == 1) {
+                                hw->wiphy->custom_regulatory = true;
+                                wiphy_apply_custom_regulatory(hw->wiphy,
+                                        &hwsim_world_regdom_custom_02);
+                        } else if (i == 4)
+                                hw->wiphy->strict_regulatory = true;
+                        break;
+                default:
+                        break;
+                }
 
                 err = ieee80211_register_hw(hw);
                 if (err < 0) {
@@ -812,6 +1042,52 @@ static int __init init_mac80211_hwsim(void)
                         goto failed_hw;
                 }
 
+                /* Work to be done after to ieee80211_register_hw() */
+                switch (regtest) {
+                case HWSIM_REGTEST_WORLD_ROAM:
+                case HWSIM_REGTEST_DISABLED:
+                        break;
+                case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
+                        if (!i)
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                        break;
+                case HWSIM_REGTEST_DRIVER_REG_ALL:
+                case HWSIM_REGTEST_STRICT_ALL:
+                        regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                        break;
+                case HWSIM_REGTEST_DIFF_COUNTRY:
+                        if (i < ARRAY_SIZE(hwsim_alpha2s))
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[i]);
+                        break;
+                case HWSIM_REGTEST_CUSTOM_WORLD:
+                case HWSIM_REGTEST_CUSTOM_WORLD_2:
+                        /*
+                         * Nothing to be done for custom world regulatory
+                         * domains after to ieee80211_register_hw
+                         */
+                        break;
+                case HWSIM_REGTEST_STRICT_FOLLOW:
+                        if (i == 0)
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                        break;
+                case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
+                        if (i == 0)
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                        else if (i == 1)
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[1]);
+                        break;
+                case HWSIM_REGTEST_ALL:
+                        if (i == 2)
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[0]);
+                        else if (i == 3)
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[1]);
+                        else if (i == 4)
+                                regulatory_hint(hw->wiphy, hwsim_alpha2s[2]);
+                        break;
+                default:
+                        break;
+                }
+
                 printk(KERN_DEBUG "%s: hwaddr %pM registered\n",
                        wiphy_name(hw->wiphy),
                        hw->wiphy->perm_addr);
diff --git a/drivers/net/wireless/mwl8k.c b/drivers/net/wireless/mwl8k.c
new file mode 100644
index 000000000000..57a0268d1bae
--- /dev/null
+++ b/drivers/net/wireless/mwl8k.c
@@ -0,0 +1,3789 @@
+/*
+ * drivers/net/wireless/mwl8k.c driver for Marvell TOPDOG 802.11 Wireless cards
+ *
+ * Copyright (C) 2008 Marvell Semiconductor Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/completion.h>
+#include <linux/etherdevice.h>
+#include <net/mac80211.h>
+#include <linux/moduleparam.h>
+#include <linux/firmware.h>
+#include <linux/workqueue.h>
+
+#define MWL8K_DESC      "Marvell TOPDOG(R) 802.11 Wireless Network Driver"
+#define MWL8K_NAME      KBUILD_MODNAME
+#define MWL8K_VERSION   "0.9.1"
+
+MODULE_DESCRIPTION(MWL8K_DESC);
+MODULE_VERSION(MWL8K_VERSION);
+MODULE_AUTHOR("Lennert Buytenhek <buytenh@marvell.com>");
+MODULE_LICENSE("GPL");
+
+static DEFINE_PCI_DEVICE_TABLE(mwl8k_table) = {
+        { PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = 8687, },
+        { PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = 8687, },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, mwl8k_table);
+
+#define IEEE80211_ADDR_LEN                      ETH_ALEN
+
+/* Register definitions */
+#define MWL8K_HIU_GEN_PTR                       0x00000c10
+#define  MWL8K_MODE_STA                         0x0000005a
+#define  MWL8K_MODE_AP                          0x000000a5
+#define MWL8K_HIU_INT_CODE                      0x00000c14
+#define  MWL8K_FWSTA_READY                      0xf0f1f2f4
+#define  MWL8K_FWAP_READY                       0xf1f2f4a5
+#define  MWL8K_INT_CODE_CMD_FINISHED            0x00000005
+#define MWL8K_HIU_SCRATCH                       0x00000c40
+
+/* Host->device communications */
+#define MWL8K_HIU_H2A_INTERRUPT_EVENTS          0x00000c18
+#define MWL8K_HIU_H2A_INTERRUPT_STATUS          0x00000c1c
+#define MWL8K_HIU_H2A_INTERRUPT_MASK            0x00000c20
+#define MWL8K_HIU_H2A_INTERRUPT_CLEAR_SEL       0x00000c24
+#define MWL8K_HIU_H2A_INTERRUPT_STATUS_MASK     0x00000c28
+#define  MWL8K_H2A_INT_DUMMY                    (1 << 20)
+#define  MWL8K_H2A_INT_RESET                    (1 << 15)
+#define  MWL8K_H2A_INT_PS                       (1 << 2)
+#define  MWL8K_H2A_INT_DOORBELL                 (1 << 1)
+#define  MWL8K_H2A_INT_PPA_READY                (1 << 0)
+
+/* Device->host communications */
+#define MWL8K_HIU_A2H_INTERRUPT_EVENTS          0x00000c2c
+#define MWL8K_HIU_A2H_INTERRUPT_STATUS          0x00000c30
+#define MWL8K_HIU_A2H_INTERRUPT_MASK            0x00000c34
+#define MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL       0x00000c38
+#define MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK     0x00000c3c
+#define  MWL8K_A2H_INT_DUMMY                    (1 << 20)
+#define  MWL8K_A2H_INT_CHNL_SWITCHED            (1 << 11)
+#define  MWL8K_A2H_INT_QUEUE_EMPTY              (1 << 10)
+#define  MWL8K_A2H_INT_RADAR_DETECT             (1 << 7)
+#define  MWL8K_A2H_INT_RADIO_ON                 (1 << 6)
+#define  MWL8K_A2H_INT_RADIO_OFF                (1 << 5)
+#define  MWL8K_A2H_INT_MAC_EVENT                (1 << 3)
+#define  MWL8K_A2H_INT_OPC_DONE                 (1 << 2)
+#define  MWL8K_A2H_INT_RX_READY                 (1 << 1)
+#define  MWL8K_A2H_INT_TX_DONE                  (1 << 0)
+
+#define MWL8K_A2H_EVENTS        (MWL8K_A2H_INT_DUMMY | \
+                                 MWL8K_A2H_INT_CHNL_SWITCHED | \
+                                 MWL8K_A2H_INT_QUEUE_EMPTY | \
+                                 MWL8K_A2H_INT_RADAR_DETECT | \
+                                 MWL8K_A2H_INT_RADIO_ON | \
+                                 MWL8K_A2H_INT_RADIO_OFF | \
+                                 MWL8K_A2H_INT_MAC_EVENT | \
+                                 MWL8K_A2H_INT_OPC_DONE | \
+                                 MWL8K_A2H_INT_RX_READY | \
+                                 MWL8K_A2H_INT_TX_DONE)
+
+/* WME stream classes */
+#define WME_AC_BE       0               /* best effort */
+#define WME_AC_BK       1               /* background */
+#define WME_AC_VI       2               /* video */
+#define WME_AC_VO       3               /* voice */
+
+#define MWL8K_RX_QUEUES         1
+#define MWL8K_TX_QUEUES         4
+
+struct mwl8k_rx_queue {
+        int rx_desc_count;
+
+        /* hw receives here */
+        int rx_head;
+
+        /* refill descs here */
+        int rx_tail;
+
+        struct mwl8k_rx_desc *rx_desc_area;
+        dma_addr_t rx_desc_dma;
+        struct sk_buff **rx_skb;
+};
+
+struct mwl8k_skb {
+        /*
+         * The DMA engine requires a modification to the payload.
+         * If the skbuff is shared/cloned, it needs to be unshared.
+         * This method is used to ensure the stack always gets back
+         * the skbuff it sent for transmission.
+         */
+        struct sk_buff *clone;
+        struct sk_buff *skb;
+};
+
+struct mwl8k_tx_queue {
+        /* hw transmits here */
+        int tx_head;
+
+        /* sw appends here */
+        int tx_tail;
+
+        struct ieee80211_tx_queue_stats tx_stats;
+        struct mwl8k_tx_desc *tx_desc_area;
+        dma_addr_t tx_desc_dma;
+        struct mwl8k_skb *tx_skb;
+};
+
+/* Pointers to the firmware data and meta information about it.  */
+struct mwl8k_firmware {
+        /* Microcode */
+        struct firmware *ucode;
+
+        /* Boot helper code */
+        struct firmware *helper;
+};
+
+struct mwl8k_priv {
+        void __iomem *regs;
+        struct ieee80211_hw *hw;
+
+        struct pci_dev *pdev;
+        u8 name[16];
+        /* firmware access lock */
+        spinlock_t fw_lock;
+
+        /* firmware files and meta data */
+        struct mwl8k_firmware fw;
+        u32 part_num;
+
+        /* lock held over TX and TX reap */
+        spinlock_t tx_lock;
+        u32 int_mask;
+
+        struct ieee80211_vif *vif;
+        struct list_head vif_list;
+
+        struct ieee80211_channel *current_channel;
+
+        /* power management status cookie from firmware */
+        u32 *cookie;
+        dma_addr_t cookie_dma;
+
+        u16 num_mcaddrs;
+        u16 region_code;
+        u8 hw_rev;
+        __le32 fw_rev;
+        u32 wep_enabled;
+
+        /*
+         * Running count of TX packets in flight, to avoid
+         * iterating over the transmit rings each time.
+         */
+        int pending_tx_pkts;
+
+        struct mwl8k_rx_queue rxq[MWL8K_RX_QUEUES];
+        struct mwl8k_tx_queue txq[MWL8K_TX_QUEUES];
+
+        /* PHY parameters */
+        struct ieee80211_supported_band band;
+        struct ieee80211_channel channels[14];
+        struct ieee80211_rate rates[12];
+
+        /* RF preamble: Short, Long or Auto */
+        u8      radio_preamble;
+        u8      radio_state;
+
+        /* WMM MODE 1 for enabled; 0 for disabled */
+        bool wmm_mode;
+
+        /* Set if PHY config is in progress */
+        bool inconfig;
+
+        /* XXX need to convert this to handle multiple interfaces */
+        bool capture_beacon;
+        u8 capture_bssid[IEEE80211_ADDR_LEN];
+        struct sk_buff *beacon_skb;
+
+        /*
+         * This FJ worker has to be global as it is scheduled from the
+         * RX handler.  At this point we don't know which interface it
+         * belongs to until the list of bssids waiting to complete join
+         * is checked.
+         */
+        struct work_struct finalize_join_worker;
+
+        /* Tasklet to reclaim TX descriptors and buffers after tx */
+        struct tasklet_struct tx_reclaim_task;
+
+        /* Work thread to serialize configuration requests */
+        struct workqueue_struct *config_wq;
+        struct completion *hostcmd_wait;
+        struct completion *tx_wait;
+};
+
+/* Per interface specific private data */
+struct mwl8k_vif {
+        struct list_head node;
+
+        /* backpointer to parent config block */
+        struct mwl8k_priv *priv;
+
+        /* BSS config of AP or IBSS from mac80211*/
+        struct ieee80211_bss_conf bss_info;
+
+        /* BSSID of AP or IBSS */
+        u8      bssid[IEEE80211_ADDR_LEN];
+        u8      mac_addr[IEEE80211_ADDR_LEN];
+
+        /*
+         * Subset of supported legacy rates.
+         * Intersection of AP and STA supported rates.
+         */
+        struct ieee80211_rate legacy_rates[12];
+
+        /* number of supported legacy rates */
+        u8      legacy_nrates;
+
+        /* Number of supported MCS rates. Work in progress */
+        u8      mcs_nrates;
+
+         /* Index into station database.Returned by update_sta_db call */
+        u8      peer_id;
+
+        /* Non AMPDU sequence number assigned by driver */
+        u16     seqno;
+
+        /* Note:There is no channel info,
+         * refer to the master channel info in priv
+         */
+};
+
+#define MWL8K_VIF(_vif) (struct mwl8k_vif *)(&((_vif)->drv_priv))
+
+static const struct ieee80211_channel mwl8k_channels[] = {
+        { .center_freq = 2412, .hw_value = 1, },
+        { .center_freq = 2417, .hw_value = 2, },
+        { .center_freq = 2422, .hw_value = 3, },
+        { .center_freq = 2427, .hw_value = 4, },
+        { .center_freq = 2432, .hw_value = 5, },
+        { .center_freq = 2437, .hw_value = 6, },
+        { .center_freq = 2442, .hw_value = 7, },
+        { .center_freq = 2447, .hw_value = 8, },
+        { .center_freq = 2452, .hw_value = 9, },
+        { .center_freq = 2457, .hw_value = 10, },
+        { .center_freq = 2462, .hw_value = 11, },
+};
+
+static const struct ieee80211_rate mwl8k_rates[] = {
+        { .bitrate = 10, .hw_value = 2, },
+        { .bitrate = 20, .hw_value = 4, },
+        { .bitrate = 55, .hw_value = 11, },
+        { .bitrate = 60, .hw_value = 12, },
+        { .bitrate = 90, .hw_value = 18, },
+        { .bitrate = 110, .hw_value = 22, },
+        { .bitrate = 120, .hw_value = 24, },
+        { .bitrate = 180, .hw_value = 36, },
+        { .bitrate = 240, .hw_value = 48, },
+        { .bitrate = 360, .hw_value = 72, },
+        { .bitrate = 480, .hw_value = 96, },
+        { .bitrate = 540, .hw_value = 108, },
+};
+
+/* Radio settings */
+#define MWL8K_RADIO_FORCE               0x2
+#define MWL8K_RADIO_ENABLE              0x1
+#define MWL8K_RADIO_DISABLE             0x0
+#define MWL8K_RADIO_AUTO_PREAMBLE       0x0005
+#define MWL8K_RADIO_SHORT_PREAMBLE      0x0003
+#define MWL8K_RADIO_LONG_PREAMBLE       0x0001
+
+/* WMM */
+#define MWL8K_WMM_ENABLE                1
+#define MWL8K_WMM_DISABLE               0
+
+#define MWL8K_RADIO_DEFAULT_PREAMBLE    MWL8K_RADIO_LONG_PREAMBLE
+
+/* Slot time */
+
+/* Short Slot: 9us slot time */
+#define MWL8K_SHORT_SLOTTIME            1
+
+/* Long slot: 20us slot time */
+#define MWL8K_LONG_SLOTTIME             0
+
+/* Set or get info from Firmware */
+#define MWL8K_CMD_SET                   0x0001
+#define MWL8K_CMD_GET                   0x0000
+
+/* Firmware command codes */
+#define MWL8K_CMD_CODE_DNLD             0x0001
+#define MWL8K_CMD_GET_HW_SPEC           0x0003
+#define MWL8K_CMD_MAC_MULTICAST_ADR     0x0010
+#define MWL8K_CMD_GET_STAT              0x0014
+#define MWL8K_CMD_RADIO_CONTROL         0x001C
+#define MWL8K_CMD_RF_TX_POWER           0x001E
+#define MWL8K_CMD_SET_PRE_SCAN          0x0107
+#define MWL8K_CMD_SET_POST_SCAN         0x0108
+#define MWL8K_CMD_SET_RF_CHANNEL        0x010A
+#define MWL8K_CMD_SET_SLOT              0x0114
+#define MWL8K_CMD_MIMO_CONFIG           0x0125
+#define MWL8K_CMD_ENABLE_SNIFFER        0x0150
+#define MWL8K_CMD_SET_WMM_MODE          0x0123
+#define MWL8K_CMD_SET_EDCA_PARAMS       0x0115
+#define MWL8K_CMD_SET_FINALIZE_JOIN     0x0111
+#define MWL8K_CMD_UPDATE_STADB          0x1123
+#define MWL8K_CMD_SET_RATEADAPT_MODE    0x0203
+#define MWL8K_CMD_SET_LINKADAPT_MODE    0x0129
+#define MWL8K_CMD_SET_AID               0x010d
+#define MWL8K_CMD_SET_RATE              0x0110
+#define MWL8K_CMD_USE_FIXED_RATE        0x0126
+#define MWL8K_CMD_RTS_THRESHOLD         0x0113
+#define MWL8K_CMD_ENCRYPTION            0x1122
+
+static const char *mwl8k_cmd_name(u16 cmd, char *buf, int bufsize)
+{
+#define MWL8K_CMDNAME(x)        case MWL8K_CMD_##x: do {\
+                                        snprintf(buf, bufsize, "%s", #x);\
+                                        return buf;\
+                                        } while (0)
+        switch (cmd & (~0x8000)) {
+                MWL8K_CMDNAME(CODE_DNLD);
+                MWL8K_CMDNAME(GET_HW_SPEC);
+                MWL8K_CMDNAME(MAC_MULTICAST_ADR);
+                MWL8K_CMDNAME(GET_STAT);
+                MWL8K_CMDNAME(RADIO_CONTROL);
+                MWL8K_CMDNAME(RF_TX_POWER);
+                MWL8K_CMDNAME(SET_PRE_SCAN);
+                MWL8K_CMDNAME(SET_POST_SCAN);
+                MWL8K_CMDNAME(SET_RF_CHANNEL);
+                MWL8K_CMDNAME(SET_SLOT);
+                MWL8K_CMDNAME(MIMO_CONFIG);
+                MWL8K_CMDNAME(ENABLE_SNIFFER);
+                MWL8K_CMDNAME(SET_WMM_MODE);
+                MWL8K_CMDNAME(SET_EDCA_PARAMS);
+                MWL8K_CMDNAME(SET_FINALIZE_JOIN);
+                MWL8K_CMDNAME(UPDATE_STADB);
+                MWL8K_CMDNAME(SET_RATEADAPT_MODE);
+                MWL8K_CMDNAME(SET_LINKADAPT_MODE);
+                MWL8K_CMDNAME(SET_AID);
+                MWL8K_CMDNAME(SET_RATE);
+                MWL8K_CMDNAME(USE_FIXED_RATE);
+                MWL8K_CMDNAME(RTS_THRESHOLD);
+                MWL8K_CMDNAME(ENCRYPTION);
+        default:
+                snprintf(buf, bufsize, "0x%x", cmd);
+        }
+#undef MWL8K_CMDNAME
+
+        return buf;
+}
+
+/* Hardware and firmware reset */
+static void mwl8k_hw_reset(struct mwl8k_priv *priv)
+{
+        iowrite32(MWL8K_H2A_INT_RESET,
+                priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+        iowrite32(MWL8K_H2A_INT_RESET,
+                priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+        msleep(20);
+}
+
+/* Release fw image */
+static void mwl8k_release_fw(struct firmware **fw)
+{
+        if (*fw == NULL)
+                return;
+        release_firmware(*fw);
+        *fw = NULL;
+}
+
+static void mwl8k_release_firmware(struct mwl8k_priv *priv)
+{
+        mwl8k_release_fw(&priv->fw.ucode);
+        mwl8k_release_fw(&priv->fw.helper);
+}
+
+/* Request fw image */
+static int mwl8k_request_fw(struct mwl8k_priv *priv,
+                                const char *fname, struct firmware **fw)
+{
+        /* release current image */
+        if (*fw != NULL)
+                mwl8k_release_fw(fw);
+
+        return request_firmware((const struct firmware **)fw,
+                                                fname, &priv->pdev->dev);
+}
+
+static int mwl8k_request_firmware(struct mwl8k_priv *priv, u32 part_num)
+{
+        u8 filename[64];
+        int rc;
+
+        priv->part_num = part_num;
+
+        snprintf(filename, sizeof(filename),
+                 "mwl8k/helper_%u.fw", priv->part_num);
+
+        rc = mwl8k_request_fw(priv, filename, &priv->fw.helper);
+        if (rc) {
+                printk(KERN_ERR
+                        "%s Error requesting helper firmware file %s\n",
+                        pci_name(priv->pdev), filename);
+                return rc;
+        }
+
+        snprintf(filename, sizeof(filename),
+                 "mwl8k/fmimage_%u.fw", priv->part_num);
+
+        rc = mwl8k_request_fw(priv, filename, &priv->fw.ucode);
+        if (rc) {
+                printk(KERN_ERR "%s Error requesting firmware file %s\n",
+                                        pci_name(priv->pdev), filename);
+                mwl8k_release_fw(&priv->fw.helper);
+                return rc;
+        }
+
+        return 0;
+}
+
+struct mwl8k_cmd_pkt {
+        __le16  code;
+        __le16  length;
+        __le16  seq_num;
+        __le16  result;
+        char    payload[0];
+} __attribute__((packed));
+
+/*
+ * Firmware loading.
+ */
+static int
+mwl8k_send_fw_load_cmd(struct mwl8k_priv *priv, void *data, int length)
+{
+        void __iomem *regs = priv->regs;
+        dma_addr_t dma_addr;
+        int rc;
+        int loops;
+
+        dma_addr = pci_map_single(priv->pdev, data, length, PCI_DMA_TODEVICE);
+        if (pci_dma_mapping_error(priv->pdev, dma_addr))
+                return -ENOMEM;
+
+        iowrite32(dma_addr, regs + MWL8K_HIU_GEN_PTR);
+        iowrite32(0, regs + MWL8K_HIU_INT_CODE);
+        iowrite32(MWL8K_H2A_INT_DOORBELL,
+                regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+        iowrite32(MWL8K_H2A_INT_DUMMY,
+                regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+
+        rc = -ETIMEDOUT;
+        loops = 1000;
+        do {
+                u32 int_code;
+
+                int_code = ioread32(regs + MWL8K_HIU_INT_CODE);
+                if (int_code == MWL8K_INT_CODE_CMD_FINISHED) {
+                        iowrite32(0, regs + MWL8K_HIU_INT_CODE);
+                        rc = 0;
+                        break;
+                }
+
+                udelay(1);
+        } while (--loops);
+
+        pci_unmap_single(priv->pdev, dma_addr, length, PCI_DMA_TODEVICE);
+
+        /*
+         * Clear 'command done' interrupt bit.
+         */
+        loops = 1000;
+        do {
+                u32 status;
+
+                status = ioread32(priv->regs +
+                                MWL8K_HIU_A2H_INTERRUPT_STATUS);
+                if (status & MWL8K_A2H_INT_OPC_DONE) {
+                        iowrite32(~MWL8K_A2H_INT_OPC_DONE,
+                                priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+                        ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+                        break;
+                }
+
+                udelay(1);
+        } while (--loops);
+
+        return rc;
+}
+
+static int mwl8k_load_fw_image(struct mwl8k_priv *priv,
+                                const u8 *data, size_t length)
+{
+        struct mwl8k_cmd_pkt *cmd;
+        int done;
+        int rc = 0;
+
+        cmd = kmalloc(sizeof(*cmd) + 256, GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->code = cpu_to_le16(MWL8K_CMD_CODE_DNLD);
+        cmd->seq_num = 0;
+        cmd->result = 0;
+
+        done = 0;
+        while (length) {
+                int block_size = length > 256 ? 256 : length;
+
+                memcpy(cmd->payload, data + done, block_size);
+                cmd->length = cpu_to_le16(block_size);
+
+                rc = mwl8k_send_fw_load_cmd(priv, cmd,
+                                                sizeof(*cmd) + block_size);
+                if (rc)
+                        break;
+
+                done += block_size;
+                length -= block_size;
+        }
+
+        if (!rc) {
+                cmd->length = 0;
+                rc = mwl8k_send_fw_load_cmd(priv, cmd, sizeof(*cmd));
+        }
+
+        kfree(cmd);
+
+        return rc;
+}
+
+static int mwl8k_feed_fw_image(struct mwl8k_priv *priv,
+                                const u8 *data, size_t length)
+{
+        unsigned char *buffer;
+        int may_continue, rc = 0;
+        u32 done, prev_block_size;
+
+        buffer = kmalloc(1024, GFP_KERNEL);
+        if (buffer == NULL)
+                return -ENOMEM;
+
+        done = 0;
+        prev_block_size = 0;
+        may_continue = 1000;
+        while (may_continue > 0) {
+                u32 block_size;
+
+                block_size = ioread32(priv->regs + MWL8K_HIU_SCRATCH);
+                if (block_size & 1) {
+                        block_size &= ~1;
+                        may_continue--;
+                } else {
+                        done += prev_block_size;
+                        length -= prev_block_size;
+                }
+
+                if (block_size > 1024 || block_size > length) {
+                        rc = -EOVERFLOW;
+                        break;
+                }
+
+                if (length == 0) {
+                        rc = 0;
+                        break;
+                }
+
+                if (block_size == 0) {
+                        rc = -EPROTO;
+                        may_continue--;
+                        udelay(1);
+                        continue;
+                }
+
+                prev_block_size = block_size;
+                memcpy(buffer, data + done, block_size);
+
+                rc = mwl8k_send_fw_load_cmd(priv, buffer, block_size);
+                if (rc)
+                        break;
+        }
+
+        if (!rc && length != 0)
+                rc = -EREMOTEIO;
+
+        kfree(buffer);
+
+        return rc;
+}
+
+static int mwl8k_load_firmware(struct mwl8k_priv *priv)
+{
+        int loops, rc;
+
+        const u8 *ucode = priv->fw.ucode->data;
+        size_t ucode_len = priv->fw.ucode->size;
+        const u8 *helper = priv->fw.helper->data;
+        size_t helper_len = priv->fw.helper->size;
+
+        if (!memcmp(ucode, "\x01\x00\x00\x00", 4)) {
+                rc = mwl8k_load_fw_image(priv, helper, helper_len);
+                if (rc) {
+                        printk(KERN_ERR "%s: unable to load firmware "
+                                "helper image\n", pci_name(priv->pdev));
+                        return rc;
+                }
+                msleep(1);
+
+                rc = mwl8k_feed_fw_image(priv, ucode, ucode_len);
+        } else {
+                rc = mwl8k_load_fw_image(priv, ucode, ucode_len);
+        }
+
+        if (rc) {
+                printk(KERN_ERR "%s: unable to load firmware data\n",
+                        pci_name(priv->pdev));
+                return rc;
+        }
+
+        iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR);
+        msleep(1);
+
+        loops = 200000;
+        do {
+                if (ioread32(priv->regs + MWL8K_HIU_INT_CODE)
+                                                == MWL8K_FWSTA_READY)
+                        break;
+                udelay(1);
+        } while (--loops);
+
+        return loops ? 0 : -ETIMEDOUT;
+}
+
+
+/*
+ * Defines shared between transmission and reception.
+ */
+/* HT control fields for firmware */
+struct ewc_ht_info {
+        __le16  control1;
+        __le16  control2;
+        __le16  control3;
+} __attribute__((packed));
+
+/* Firmware Station database operations */
+#define MWL8K_STA_DB_ADD_ENTRY          0
+#define MWL8K_STA_DB_MODIFY_ENTRY       1
+#define MWL8K_STA_DB_DEL_ENTRY          2
+#define MWL8K_STA_DB_FLUSH              3
+
+/* Peer Entry flags - used to define the type of the peer node */
+#define MWL8K_PEER_TYPE_ACCESSPOINT     2
+#define MWL8K_PEER_TYPE_ADHOC_STATION   4
+
+#define MWL8K_IEEE_LEGACY_DATA_RATES    12
+#define MWL8K_MCS_BITMAP_SIZE           16
+#define pad_size                        16
+
+struct peer_capability_info {
+        /* Peer type - AP vs. STA.  */
+        __u8    peer_type;
+
+        /* Basic 802.11 capabilities from assoc resp.  */
+        __le16  basic_caps;
+
+        /* Set if peer supports 802.11n high throughput (HT).  */
+        __u8    ht_support;
+
+        /* Valid if HT is supported.  */
+        __le16  ht_caps;
+        __u8    extended_ht_caps;
+        struct ewc_ht_info      ewc_info;
+
+        /* Legacy rate table. Intersection of our rates and peer rates.  */
+        __u8    legacy_rates[MWL8K_IEEE_LEGACY_DATA_RATES];
+
+        /* HT rate table. Intersection of our rates and peer rates.  */
+        __u8    ht_rates[MWL8K_MCS_BITMAP_SIZE];
+        __u8    pad[pad_size];
+
+        /* If set, interoperability mode, no proprietary extensions.  */
+        __u8    interop;
+        __u8    pad2;
+        __u8    station_id;
+        __le16  amsdu_enabled;
+} __attribute__((packed));
+
+/* Inline functions to manipulate QoS field in data descriptor.  */
+static inline u16 mwl8k_qos_setbit_tid(u16 qos, u8 tid)
+{
+        u16 val_mask = 0x000f;
+        u16 qos_mask = ~val_mask;
+
+        /* TID bits 0-3 */
+        return (qos & qos_mask) | (tid & val_mask);
+}
+
+static inline u16 mwl8k_qos_setbit_eosp(u16 qos)
+{
+        u16 val_mask = 1 << 4;
+
+        /* End of Service Period Bit 4 */
+        return qos | val_mask;
+}
+
+static inline u16 mwl8k_qos_setbit_ack(u16 qos, u8 ack_policy)
+{
+        u16 val_mask = 0x3;
+        u8      shift = 5;
+        u16 qos_mask = ~(val_mask << shift);
+
+        /* Ack Policy Bit 5-6 */
+        return (qos & qos_mask) | ((ack_policy & val_mask) << shift);
+}
+
+static inline u16 mwl8k_qos_setbit_amsdu(u16 qos)
+{
+        u16 val_mask = 1 << 7;
+
+        /* AMSDU present Bit 7 */
+        return qos | val_mask;
+}
+
+static inline u16 mwl8k_qos_setbit_qlen(u16 qos, u8 len)
+{
+        u16 val_mask = 0xff;
+        u8      shift = 8;
+        u16 qos_mask = ~(val_mask << shift);
+
+        /* Queue Length Bits 8-15 */
+        return (qos & qos_mask) | ((len & val_mask) << shift);
+}
+
+/* DMA header used by firmware and hardware.  */
+struct mwl8k_dma_data {
+        __le16 fwlen;
+        struct ieee80211_hdr wh;
+} __attribute__((packed));
+
+/* Routines to add/remove DMA header from skb.  */
+static inline int mwl8k_remove_dma_header(struct sk_buff *skb)
+{
+        struct mwl8k_dma_data *tr = (struct mwl8k_dma_data *)(skb->data);
+        void *dst, *src = &tr->wh;
+        __le16 fc = tr->wh.frame_control;
+        int hdrlen = ieee80211_hdrlen(fc);
+        u16 space = sizeof(struct mwl8k_dma_data) - hdrlen;
+
+        dst = (void *)tr + space;
+        if (dst != src) {
+                memmove(dst, src, hdrlen);
+                skb_pull(skb, space);
+        }
+
+        return 0;
+}
+
+static inline struct sk_buff *mwl8k_add_dma_header(struct sk_buff *skb)
+{
+        struct ieee80211_hdr *wh;
+        u32 hdrlen, pktlen;
+        struct mwl8k_dma_data *tr;
+
+        wh = (struct ieee80211_hdr *)skb->data;
+        hdrlen = ieee80211_hdrlen(wh->frame_control);
+        pktlen = skb->len;
+
+        /*
+         * Copy up/down the 802.11 header; the firmware requires
+         * we present a 2-byte payload length followed by a
+         * 4-address header (w/o QoS), followed (optionally) by
+         * any WEP/ExtIV header (but only filled in for CCMP).
+         */
+        if (hdrlen != sizeof(struct mwl8k_dma_data))
+                skb_push(skb, sizeof(struct mwl8k_dma_data) - hdrlen);
+
+        tr = (struct mwl8k_dma_data *)skb->data;
+        if (wh != &tr->wh)
+                memmove(&tr->wh, wh, hdrlen);
+
+        /* Clear addr4 */
+        memset(tr->wh.addr4, 0, IEEE80211_ADDR_LEN);
+
+        /*
+         * Firmware length is the length of the fully formed "802.11
+         * payload".  That is, everything except for the 802.11 header.
+         * This includes all crypto material including the MIC.
+         */
+        tr->fwlen = cpu_to_le16(pktlen - hdrlen);
+
+        return skb;
+}
+
+
+/*
+ * Packet reception.
+ */
+#define MWL8K_RX_CTRL_KEY_INDEX_MASK    0x30
+#define MWL8K_RX_CTRL_OWNED_BY_HOST     0x02
+#define MWL8K_RX_CTRL_AMPDU             0x01
+
+struct mwl8k_rx_desc {
+        __le16 pkt_len;
+        __u8 link_quality;
+        __u8 noise_level;
+        __le32 pkt_phys_addr;
+        __le32 next_rx_desc_phys_addr;
+        __le16 qos_control;
+        __le16 rate_info;
+        __le32 pad0[4];
+        __u8 rssi;
+        __u8 channel;
+        __le16 pad1;
+        __u8 rx_ctrl;
+        __u8 rx_status;
+        __u8 pad2[2];
+} __attribute__((packed));
+
+#define MWL8K_RX_DESCS          256
+#define MWL8K_RX_MAXSZ          3800
+
+static int mwl8k_rxq_init(struct ieee80211_hw *hw, int index)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_rx_queue *rxq = priv->rxq + index;
+        int size;
+        int i;
+
+        rxq->rx_desc_count = 0;
+        rxq->rx_head = 0;
+        rxq->rx_tail = 0;
+
+        size = MWL8K_RX_DESCS * sizeof(struct mwl8k_rx_desc);
+
+        rxq->rx_desc_area =
+                pci_alloc_consistent(priv->pdev, size, &rxq->rx_desc_dma);
+        if (rxq->rx_desc_area == NULL) {
+                printk(KERN_ERR "%s: failed to alloc RX descriptors\n",
+                       priv->name);
+                return -ENOMEM;
+        }
+        memset(rxq->rx_desc_area, 0, size);
+
+        rxq->rx_skb = kmalloc(MWL8K_RX_DESCS *
+                                sizeof(*rxq->rx_skb), GFP_KERNEL);
+        if (rxq->rx_skb == NULL) {
+                printk(KERN_ERR "%s: failed to alloc RX skbuff list\n",
+                        priv->name);
+                pci_free_consistent(priv->pdev, size,
+                                    rxq->rx_desc_area, rxq->rx_desc_dma);
+                return -ENOMEM;
+        }
+        memset(rxq->rx_skb, 0, MWL8K_RX_DESCS * sizeof(*rxq->rx_skb));
+
+        for (i = 0; i < MWL8K_RX_DESCS; i++) {
+                struct mwl8k_rx_desc *rx_desc;
+                int nexti;
+
+                rx_desc = rxq->rx_desc_area + i;
+                nexti = (i + 1) % MWL8K_RX_DESCS;
+
+                rx_desc->next_rx_desc_phys_addr =
+                        cpu_to_le32(rxq->rx_desc_dma
+                                                + nexti * sizeof(*rx_desc));
+                rx_desc->rx_ctrl =
+                        cpu_to_le32(MWL8K_RX_CTRL_OWNED_BY_HOST);
+        }
+
+        return 0;
+}
+
+static int rxq_refill(struct ieee80211_hw *hw, int index, int limit)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_rx_queue *rxq = priv->rxq + index;
+        int refilled;
+
+        refilled = 0;
+        while (rxq->rx_desc_count < MWL8K_RX_DESCS && limit--) {
+                struct sk_buff *skb;
+                int rx;
+
+                skb = dev_alloc_skb(MWL8K_RX_MAXSZ);
+                if (skb == NULL)
+                        break;
+
+                rxq->rx_desc_count++;
+
+                rx = rxq->rx_tail;
+                rxq->rx_tail = (rx + 1) % MWL8K_RX_DESCS;
+
+                rxq->rx_desc_area[rx].pkt_phys_addr =
+                        cpu_to_le32(pci_map_single(priv->pdev, skb->data,
+                                        MWL8K_RX_MAXSZ, DMA_FROM_DEVICE));
+
+                rxq->rx_desc_area[rx].pkt_len = cpu_to_le16(MWL8K_RX_MAXSZ);
+                rxq->rx_skb[rx] = skb;
+                wmb();
+                rxq->rx_desc_area[rx].rx_ctrl = 0;
+
+                refilled++;
+        }
+
+        return refilled;
+}
+
+/* Must be called only when the card's reception is completely halted */
+static void mwl8k_rxq_deinit(struct ieee80211_hw *hw, int index)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_rx_queue *rxq = priv->rxq + index;
+        int i;
+
+        for (i = 0; i < MWL8K_RX_DESCS; i++) {
+                if (rxq->rx_skb[i] != NULL) {
+                        unsigned long addr;
+
+                        addr = le32_to_cpu(rxq->rx_desc_area[i].pkt_phys_addr);
+                        pci_unmap_single(priv->pdev, addr, MWL8K_RX_MAXSZ,
+                                         PCI_DMA_FROMDEVICE);
+                        kfree_skb(rxq->rx_skb[i]);
+                        rxq->rx_skb[i] = NULL;
+                }
+        }
+
+        kfree(rxq->rx_skb);
+        rxq->rx_skb = NULL;
+
+        pci_free_consistent(priv->pdev,
+                            MWL8K_RX_DESCS * sizeof(struct mwl8k_rx_desc),
+                            rxq->rx_desc_area, rxq->rx_desc_dma);
+        rxq->rx_desc_area = NULL;
+}
+
+
+/*
+ * Scan a list of BSSIDs to process for finalize join.
+ * Allows for extension to process multiple BSSIDs.
+ */
+static inline int
+mwl8k_capture_bssid(struct mwl8k_priv *priv, struct ieee80211_hdr *wh)
+{
+        return priv->capture_beacon &&
+                ieee80211_is_beacon(wh->frame_control) &&
+                !compare_ether_addr(wh->addr3, priv->capture_bssid);
+}
+
+static inline void mwl8k_save_beacon(struct mwl8k_priv *priv,
+                                                        struct sk_buff *skb)
+{
+        priv->capture_beacon = false;
+        memset(priv->capture_bssid, 0, IEEE80211_ADDR_LEN);
+
+        /*
+         * Use GFP_ATOMIC as rxq_process is called from
+         * the primary interrupt handler, memory allocation call
+         * must not sleep.
+         */
+        priv->beacon_skb = skb_copy(skb, GFP_ATOMIC);
+        if (priv->beacon_skb != NULL)
+                queue_work(priv->config_wq,
+                                &priv->finalize_join_worker);
+}
+
+static int rxq_process(struct ieee80211_hw *hw, int index, int limit)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_rx_queue *rxq = priv->rxq + index;
+        int processed;
+
+        processed = 0;
+        while (rxq->rx_desc_count && limit--) {
+                struct mwl8k_rx_desc *rx_desc;
+                struct sk_buff *skb;
+                struct ieee80211_rx_status status;
+                unsigned long addr;
+                struct ieee80211_hdr *wh;
+
+                rx_desc = rxq->rx_desc_area + rxq->rx_head;
+                if (!(rx_desc->rx_ctrl & MWL8K_RX_CTRL_OWNED_BY_HOST))
+                        break;
+                rmb();
+
+                skb = rxq->rx_skb[rxq->rx_head];
+                rxq->rx_skb[rxq->rx_head] = NULL;
+
+                rxq->rx_head = (rxq->rx_head + 1) % MWL8K_RX_DESCS;
+                rxq->rx_desc_count--;
+
+                addr = le32_to_cpu(rx_desc->pkt_phys_addr);
+                pci_unmap_single(priv->pdev, addr,
+                                        MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
+
+                skb_put(skb, le16_to_cpu(rx_desc->pkt_len));
+                if (mwl8k_remove_dma_header(skb)) {
+                        dev_kfree_skb(skb);
+                        continue;
+                }
+
+                wh = (struct ieee80211_hdr *)skb->data;
+
+                /*
+                 * Check for pending join operation. save a copy of
+                 * the beacon and schedule a tasklet to send finalize
+                 * join command to the firmware.
+                 */
+                if (mwl8k_capture_bssid(priv, wh))
+                        mwl8k_save_beacon(priv, skb);
+
+                memset(&status, 0, sizeof(status));
+                status.mactime = 0;
+                status.signal = -rx_desc->rssi;
+                status.noise = -rx_desc->noise_level;
+                status.qual = rx_desc->link_quality;
+                status.antenna = 1;
+                status.rate_idx = 1;
+                status.flag = 0;
+                status.band = IEEE80211_BAND_2GHZ;
+                status.freq = ieee80211_channel_to_frequency(rx_desc->channel);
+                ieee80211_rx_irqsafe(hw, skb, &status);
+
+                processed++;
+        }
+
+        return processed;
+}
+
+
+/*
+ * Packet transmission.
+ */
+
+/* Transmit queue assignment.  */
+enum {
+        MWL8K_WME_AC_BK = 0,            /* background access */
+        MWL8K_WME_AC_BE = 1,            /* best effort access */
+        MWL8K_WME_AC_VI = 2,            /* video access */
+        MWL8K_WME_AC_VO = 3,            /* voice access */
+};
+
+/* Transmit packet ACK policy */
+#define MWL8K_TXD_ACK_POLICY_NORMAL             0
+#define MWL8K_TXD_ACK_POLICY_NONE               1
+#define MWL8K_TXD_ACK_POLICY_NO_EXPLICIT        2
+#define MWL8K_TXD_ACK_POLICY_BLOCKACK           3
+
+#define GET_TXQ(_ac) (\
+                ((_ac) == WME_AC_VO) ? MWL8K_WME_AC_VO : \
+                ((_ac) == WME_AC_VI) ? MWL8K_WME_AC_VI : \
+                ((_ac) == WME_AC_BK) ? MWL8K_WME_AC_BK : \
+                MWL8K_WME_AC_BE)
+
+#define MWL8K_TXD_STATUS_IDLE                   0x00000000
+#define MWL8K_TXD_STATUS_USED                   0x00000001
+#define MWL8K_TXD_STATUS_OK                     0x00000001
+#define MWL8K_TXD_STATUS_OK_RETRY               0x00000002
+#define MWL8K_TXD_STATUS_OK_MORE_RETRY          0x00000004
+#define MWL8K_TXD_STATUS_MULTICAST_TX           0x00000008
+#define MWL8K_TXD_STATUS_BROADCAST_TX           0x00000010
+#define MWL8K_TXD_STATUS_FAILED_LINK_ERROR      0x00000020
+#define MWL8K_TXD_STATUS_FAILED_EXCEED_LIMIT    0x00000040
+#define MWL8K_TXD_STATUS_FAILED_AGING           0x00000080
+#define MWL8K_TXD_STATUS_HOST_CMD               0x40000000
+#define MWL8K_TXD_STATUS_FW_OWNED               0x80000000
+#define  MWL8K_TXD_SOFTSTALE                            0x80
+#define  MWL8K_TXD_SOFTSTALE_MGMT_RETRY                 0x01
+
+struct mwl8k_tx_desc {
+        __le32 status;
+        __u8 data_rate;
+        __u8 tx_priority;
+        __le16 qos_control;
+        __le32 pkt_phys_addr;
+        __le16 pkt_len;
+        __u8 dest_MAC_addr[IEEE80211_ADDR_LEN];
+        __le32 next_tx_desc_phys_addr;
+        __le32 reserved;
+        __le16 rate_info;
+        __u8 peer_id;
+        __u8 tx_frag_cnt;
+} __attribute__((packed));
+
+#define MWL8K_TX_DESCS          128
+
+static int mwl8k_txq_init(struct ieee80211_hw *hw, int index)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_tx_queue *txq = priv->txq + index;
+        int size;
+        int i;
+
+        memset(&txq->tx_stats, 0,
+                sizeof(struct ieee80211_tx_queue_stats));
+        txq->tx_stats.limit = MWL8K_TX_DESCS;
+        txq->tx_head = 0;
+        txq->tx_tail = 0;
+
+        size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);
+
+        txq->tx_desc_area =
+                pci_alloc_consistent(priv->pdev, size, &txq->tx_desc_dma);
+        if (txq->tx_desc_area == NULL) {
+                printk(KERN_ERR "%s: failed to alloc TX descriptors\n",
+                       priv->name);
+                return -ENOMEM;
+        }
+        memset(txq->tx_desc_area, 0, size);
+
+        txq->tx_skb = kmalloc(MWL8K_TX_DESCS * sizeof(*txq->tx_skb),
+                                                                GFP_KERNEL);
+        if (txq->tx_skb == NULL) {
+                printk(KERN_ERR "%s: failed to alloc TX skbuff list\n",
+                       priv->name);
+                pci_free_consistent(priv->pdev, size,
+                                    txq->tx_desc_area, txq->tx_desc_dma);
+                return -ENOMEM;
+        }
+        memset(txq->tx_skb, 0, MWL8K_TX_DESCS * sizeof(*txq->tx_skb));
+
+        for (i = 0; i < MWL8K_TX_DESCS; i++) {
+                struct mwl8k_tx_desc *tx_desc;
+                int nexti;
+
+                tx_desc = txq->tx_desc_area + i;
+                nexti = (i + 1) % MWL8K_TX_DESCS;
+
+                tx_desc->status = 0;
+                tx_desc->next_tx_desc_phys_addr =
+                        cpu_to_le32(txq->tx_desc_dma +
+                                                nexti * sizeof(*tx_desc));
+        }
+
+        return 0;
+}
+
+static inline void mwl8k_tx_start(struct mwl8k_priv *priv)
+{
+        iowrite32(MWL8K_H2A_INT_PPA_READY,
+                priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+        iowrite32(MWL8K_H2A_INT_DUMMY,
+                priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+        ioread32(priv->regs + MWL8K_HIU_INT_CODE);
+}
+
+static inline int mwl8k_txq_busy(struct mwl8k_priv *priv)
+{
+        return priv->pending_tx_pkts;
+}
+
+struct mwl8k_txq_info {
+        u32 fw_owned;
+        u32 drv_owned;
+        u32 unused;
+        u32 len;
+        u32 head;
+        u32 tail;
+};
+
+static int mwl8k_scan_tx_ring(struct mwl8k_priv *priv,
+                                struct mwl8k_txq_info txinfo[],
+                                u32 num_queues)
+{
+        int count, desc, status;
+        struct mwl8k_tx_queue *txq;
+        struct mwl8k_tx_desc *tx_desc;
+        int ndescs = 0;
+
+        memset(txinfo, 0, num_queues * sizeof(struct mwl8k_txq_info));
+        spin_lock_bh(&priv->tx_lock);
+        for (count = 0; count < num_queues; count++) {
+                txq = priv->txq + count;
+                txinfo[count].len = txq->tx_stats.len;
+                txinfo[count].head = txq->tx_head;
+                txinfo[count].tail = txq->tx_tail;
+                for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
+                        tx_desc = txq->tx_desc_area + desc;
+                        status = le32_to_cpu(tx_desc->status);
+
+                        if (status & MWL8K_TXD_STATUS_FW_OWNED)
+                                txinfo[count].fw_owned++;
+                        else
+                                txinfo[count].drv_owned++;
+
+                        if (tx_desc->pkt_len == 0)
+                                txinfo[count].unused++;
+                }
+        }
+        spin_unlock_bh(&priv->tx_lock);
+
+        return ndescs;
+}
+
+static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw, u32 delay_ms)
+{
+        u32 count = 0;
+        unsigned long timeout = 0;
+        struct mwl8k_priv *priv = hw->priv;
+        DECLARE_COMPLETION_ONSTACK(cmd_wait);
+
+        might_sleep();
+
+        if (priv->tx_wait != NULL)
+                printk(KERN_ERR "WARNING Previous TXWaitEmpty instance\n");
+
+        spin_lock_bh(&priv->tx_lock);
+        count = mwl8k_txq_busy(priv);
+        if (count) {
+                priv->tx_wait = &cmd_wait;
+                if (priv->radio_state)
+                        mwl8k_tx_start(priv);
+        }
+        spin_unlock_bh(&priv->tx_lock);
+
+        if (count) {
+                struct mwl8k_txq_info txinfo[4];
+                int index;
+                int newcount;
+
+                timeout = wait_for_completion_timeout(&cmd_wait,
+                                        msecs_to_jiffies(delay_ms));
+                if (timeout)
+                        return 0;
+
+                spin_lock_bh(&priv->tx_lock);
+                priv->tx_wait = NULL;
+                newcount = mwl8k_txq_busy(priv);
+                spin_unlock_bh(&priv->tx_lock);
+
+                printk(KERN_ERR "%s(%u) TIMEDOUT:%ums Pend:%u-->%u\n",
+                       __func__, __LINE__, delay_ms, count, newcount);
+
+                mwl8k_scan_tx_ring(priv, txinfo, 4);
+                for (index = 0 ; index < 4; index++)
+                        printk(KERN_ERR
+                                "TXQ:%u L:%u H:%u T:%u FW:%u DRV:%u U:%u\n",
+                                        index,
+                                        txinfo[index].len,
+                                        txinfo[index].head,
+                                        txinfo[index].tail,
+                                        txinfo[index].fw_owned,
+                                        txinfo[index].drv_owned,
+                                        txinfo[index].unused);
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+#define MWL8K_TXD_OK    (MWL8K_TXD_STATUS_OK | \
+                         MWL8K_TXD_STATUS_OK_RETRY | \
+                         MWL8K_TXD_STATUS_OK_MORE_RETRY)
+#define MWL8K_TXD_SUCCESS(stat)         ((stat) & MWL8K_TXD_OK)
+#define MWL8K_TXD_FAIL_RETRY(stat)      \
+        ((stat) & (MWL8K_TXD_STATUS_FAILED_EXCEED_LIMIT))
+
+static void mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int force)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_tx_queue *txq = priv->txq + index;
+        int wake = 0;
+
+        while (txq->tx_stats.len > 0) {
+                int tx;
+                int rc;
+                struct mwl8k_tx_desc *tx_desc;
+                unsigned long addr;
+                size_t size;
+                struct sk_buff *skb;
+                struct ieee80211_tx_info *info;
+                u32 status;
+
+                rc = 0;
+                tx = txq->tx_head;
+                tx_desc = txq->tx_desc_area + tx;
+
+                status = le32_to_cpu(tx_desc->status);
+
+                if (status & MWL8K_TXD_STATUS_FW_OWNED) {
+                        if (!force)
+                                break;
+                        tx_desc->status &=
+                                ~cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED);
+                }
+
+                txq->tx_head = (tx + 1) % MWL8K_TX_DESCS;
+                BUG_ON(txq->tx_stats.len == 0);
+                txq->tx_stats.len--;
+                priv->pending_tx_pkts--;
+
+                addr = le32_to_cpu(tx_desc->pkt_phys_addr);
+                size = (u32)(le16_to_cpu(tx_desc->pkt_len));
+                skb = txq->tx_skb[tx].skb;
+                txq->tx_skb[tx].skb = NULL;
+
+                BUG_ON(skb == NULL);
+                pci_unmap_single(priv->pdev, addr, size, PCI_DMA_TODEVICE);
+
+                rc = mwl8k_remove_dma_header(skb);
+
+                /* Mark descriptor as unused */
+                tx_desc->pkt_phys_addr = 0;
+                tx_desc->pkt_len = 0;
+
+                if (txq->tx_skb[tx].clone) {
+                        /* Replace with original skb
+                         * before returning to stack
+                         * as buffer has been cloned
+                         */
+                        dev_kfree_skb(skb);
+                        skb = txq->tx_skb[tx].clone;
+                        txq->tx_skb[tx].clone = NULL;
+                }
+
+                if (rc) {
+                        /* Something has gone wrong here.
+                         * Failed to remove DMA header.
+                         * Print error message and drop packet.
+                         */
+                        printk(KERN_ERR "%s: Error removing DMA header from "
+                                        "tx skb 0x%p.\n", priv->name, skb);
+
+                        dev_kfree_skb(skb);
+                        continue;
+                }
+
+                info = IEEE80211_SKB_CB(skb);
+                ieee80211_tx_info_clear_status(info);
+
+                /* Convert firmware status stuff into tx_status */
+                if (MWL8K_TXD_SUCCESS(status)) {
+                        /* Transmit OK */
+                        info->flags |= IEEE80211_TX_STAT_ACK;
+                }
+
+                ieee80211_tx_status_irqsafe(hw, skb);
+
+                wake = !priv->inconfig && priv->radio_state;
+        }
+
+        if (wake)
+                ieee80211_wake_queue(hw, index);
+}
+
+/* must be called only when the card's transmit is completely halted */
+static void mwl8k_txq_deinit(struct ieee80211_hw *hw, int index)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_tx_queue *txq = priv->txq + index;
+
+        mwl8k_txq_reclaim(hw, index, 1);
+
+        kfree(txq->tx_skb);
+        txq->tx_skb = NULL;
+
+        pci_free_consistent(priv->pdev,
+                            MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
+                            txq->tx_desc_area, txq->tx_desc_dma);
+        txq->tx_desc_area = NULL;
+}
+
+static int
+mwl8k_txq_xmit(struct ieee80211_hw *hw, int index, struct sk_buff *skb)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct ieee80211_tx_info *tx_info;
+        struct ieee80211_hdr *wh;
+        struct mwl8k_tx_queue *txq;
+        struct mwl8k_tx_desc *tx;
+        struct mwl8k_dma_data *tr;
+        struct mwl8k_vif *mwl8k_vif;
+        struct sk_buff *org_skb = skb;
+        dma_addr_t dma;
+        u16 qos = 0;
+        bool qosframe = false, ampduframe = false;
+        bool mcframe = false, eapolframe = false;
+        bool amsduframe = false;
+        __le16 fc;
+
+        txq = priv->txq + index;
+        tx = txq->tx_desc_area + txq->tx_tail;
+
+        BUG_ON(txq->tx_skb[txq->tx_tail].skb != NULL);
+
+        /*
+         * Append HW DMA header to start of packet.  Drop packet if
+         * there is not enough space or a failure to unshare/unclone
+         * the skb.
+         */
+        skb = mwl8k_add_dma_header(skb);
+
+        if (skb == NULL) {
+                printk(KERN_DEBUG "%s: failed to prepend HW DMA "
+                        "header, dropping TX frame.\n", priv->name);
+                dev_kfree_skb(org_skb);
+                return NETDEV_TX_OK;
+        }
+
+        tx_info = IEEE80211_SKB_CB(skb);
+        mwl8k_vif = MWL8K_VIF(tx_info->control.vif);
+        tr = (struct mwl8k_dma_data *)skb->data;
+        wh = &tr->wh;
+        fc = wh->frame_control;
+        qosframe = ieee80211_is_data_qos(fc);
+        mcframe = is_multicast_ether_addr(wh->addr1);
+        ampduframe = !!(tx_info->flags & IEEE80211_TX_CTL_AMPDU);
+
+        if (tx_info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
+                u16 seqno = mwl8k_vif->seqno;
+                wh->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
+                wh->seq_ctrl |= cpu_to_le16(seqno << 4);
+                mwl8k_vif->seqno = seqno++ % 4096;
+        }
+
+        if (qosframe)
+                qos = le16_to_cpu(*((__le16 *)ieee80211_get_qos_ctl(wh)));
+
+        dma = pci_map_single(priv->pdev, skb->data,
+                                skb->len, PCI_DMA_TODEVICE);
+
+        if (pci_dma_mapping_error(priv->pdev, dma)) {
+                printk(KERN_DEBUG "%s: failed to dma map skb, "
+                        "dropping TX frame.\n", priv->name);
+
+                if (org_skb != NULL)
+                        dev_kfree_skb(org_skb);
+                if (skb != NULL)
+                        dev_kfree_skb(skb);
+                return NETDEV_TX_OK;
+        }
+
+        /* Set desc header, cpu bit order.  */
+        tx->status = 0;
+        tx->data_rate = 0;
+        tx->tx_priority = index;
+        tx->qos_control = 0;
+        tx->rate_info = 0;
+        tx->peer_id = mwl8k_vif->peer_id;
+
+        amsduframe = !!(qos & IEEE80211_QOS_CONTROL_A_MSDU_PRESENT);
+
+        /* Setup firmware control bit fields for each frame type.  */
+        if (ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc)) {
+                tx->data_rate = 0;
+                qos = mwl8k_qos_setbit_eosp(qos);
+                /* Set Queue size to unspecified */
+                qos = mwl8k_qos_setbit_qlen(qos, 0xff);
+        } else if (ieee80211_is_data(fc)) {
+                tx->data_rate = 1;
+                if (mcframe)
+                        tx->status |= MWL8K_TXD_STATUS_MULTICAST_TX;
+
+                /*
+                 * Tell firmware to not send EAPOL pkts in an
+                 * aggregate.  Verify against mac80211 tx path.  If
+                 * stack turns off AMPDU for an EAPOL frame this
+                 * check will be removed.
+                 */
+                if (eapolframe) {
+                        qos = mwl8k_qos_setbit_ack(qos,
+                                MWL8K_TXD_ACK_POLICY_NORMAL);
+                } else {
+                        /* Send pkt in an aggregate if AMPDU frame.  */
+                        if (ampduframe)
+                                qos = mwl8k_qos_setbit_ack(qos,
+                                        MWL8K_TXD_ACK_POLICY_BLOCKACK);
+                        else
+                                qos = mwl8k_qos_setbit_ack(qos,
+                                        MWL8K_TXD_ACK_POLICY_NORMAL);
+
+                        if (amsduframe)
+                                qos = mwl8k_qos_setbit_amsdu(qos);
+                }
+        }
+
+        /* Convert to little endian */
+        tx->qos_control = cpu_to_le16(qos);
+        tx->status = cpu_to_le32(tx->status);
+        tx->pkt_phys_addr = cpu_to_le32(dma);
+        tx->pkt_len = cpu_to_le16(skb->len);
+
+        txq->tx_skb[txq->tx_tail].skb = skb;
+        txq->tx_skb[txq->tx_tail].clone =
+                skb == org_skb ? NULL : org_skb;
+
+        spin_lock_bh(&priv->tx_lock);
+
+        tx->status = cpu_to_le32(MWL8K_TXD_STATUS_OK |
+                                        MWL8K_TXD_STATUS_FW_OWNED);
+        wmb();
+        txq->tx_stats.len++;
+        priv->pending_tx_pkts++;
+        txq->tx_stats.count++;
+        txq->tx_tail++;
+
+        if (txq->tx_tail == MWL8K_TX_DESCS)
+                txq->tx_tail = 0;
+        if (txq->tx_head == txq->tx_tail)
+                ieee80211_stop_queue(hw, index);
+
+        if (priv->inconfig) {
+                /*
+                 * Silently queue packet when we are in the middle of
+                 * a config cycle.  Notify firmware only if we are
+                 * waiting for TXQs to empty.  If a packet is sent
+                 * before .config() is complete, perhaps it is better
+                 * to drop the packet, as the channel is being changed
+                 * and the packet will end up on the wrong channel.
+                 */
+                printk(KERN_ERR "%s(): WARNING TX activity while "
+                        "in config\n", __func__);
+
+                if (priv->tx_wait != NULL)
+                        mwl8k_tx_start(priv);
+        } else
+                mwl8k_tx_start(priv);
+
+        spin_unlock_bh(&priv->tx_lock);
+
+        return NETDEV_TX_OK;
+}
+
+
+/*
+ * Command processing.
+ */
+
+/* Timeout firmware commands after 2000ms */
+#define MWL8K_CMD_TIMEOUT_MS    2000
+
+static int mwl8k_post_cmd(struct ieee80211_hw *hw, struct mwl8k_cmd_pkt *cmd)
+{
+        DECLARE_COMPLETION_ONSTACK(cmd_wait);
+        struct mwl8k_priv *priv = hw->priv;
+        void __iomem *regs = priv->regs;
+        dma_addr_t dma_addr;
+        unsigned int dma_size;
+        int rc;
+        u16 __iomem *result;
+        unsigned long timeout = 0;
+        u8 buf[32];
+
+        cmd->result = 0xFFFF;
+        dma_size = le16_to_cpu(cmd->length);
+        dma_addr = pci_map_single(priv->pdev, cmd, dma_size,
+                                  PCI_DMA_BIDIRECTIONAL);
+        if (pci_dma_mapping_error(priv->pdev, dma_addr))
+                return -ENOMEM;
+
+        if (priv->hostcmd_wait != NULL)
+                printk(KERN_ERR "WARNING host command in progress\n");
+
+        spin_lock_irq(&priv->fw_lock);
+        priv->hostcmd_wait = &cmd_wait;
+        iowrite32(dma_addr, regs + MWL8K_HIU_GEN_PTR);
+        iowrite32(MWL8K_H2A_INT_DOORBELL,
+                regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+        iowrite32(MWL8K_H2A_INT_DUMMY,
+                regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
+        spin_unlock_irq(&priv->fw_lock);
+
+        timeout = wait_for_completion_timeout(&cmd_wait,
+                                msecs_to_jiffies(MWL8K_CMD_TIMEOUT_MS));
+
+        result = &cmd->result;
+        if (!timeout) {
+                spin_lock_irq(&priv->fw_lock);
+                priv->hostcmd_wait = NULL;
+                spin_unlock_irq(&priv->fw_lock);
+                printk(KERN_ERR "%s: Command %s timeout after %u ms\n",
+                       priv->name,
+                       mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
+                       MWL8K_CMD_TIMEOUT_MS);
+                rc = -ETIMEDOUT;
+        } else {
+                rc = *result ? -EINVAL : 0;
+                if (rc)
+                        printk(KERN_ERR "%s: Command %s error 0x%x\n",
+                               priv->name,
+                               mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
+                               *result);
+        }
+
+        pci_unmap_single(priv->pdev, dma_addr, dma_size,
+                                        PCI_DMA_BIDIRECTIONAL);
+        return rc;
+}
+
+/*
+ * GET_HW_SPEC.
+ */
+struct mwl8k_cmd_get_hw_spec {
+        struct mwl8k_cmd_pkt header;
+        __u8 hw_rev;
+        __u8 host_interface;
+        __le16 num_mcaddrs;
+        __u8 perm_addr[IEEE80211_ADDR_LEN];
+        __le16 region_code;
+        __le32 fw_rev;
+        __le32 ps_cookie;
+        __le32 caps;
+        __u8 mcs_bitmap[16];
+        __le32 rx_queue_ptr;
+        __le32 num_tx_queues;
+        __le32 tx_queue_ptrs[MWL8K_TX_QUEUES];
+        __le32 caps2;
+        __le32 num_tx_desc_per_queue;
+        __le32 total_rx_desc;
+} __attribute__((packed));
+
+static int mwl8k_cmd_get_hw_spec(struct ieee80211_hw *hw)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_cmd_get_hw_spec *cmd;
+        int rc;
+        int i;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_HW_SPEC);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+
+        memset(cmd->perm_addr, 0xff, sizeof(cmd->perm_addr));
+        cmd->ps_cookie = cpu_to_le32(priv->cookie_dma);
+        cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rx_desc_dma);
+        cmd->num_tx_queues = MWL8K_TX_QUEUES;
+        for (i = 0; i < MWL8K_TX_QUEUES; i++)
+                cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].tx_desc_dma);
+        cmd->num_tx_desc_per_queue = MWL8K_TX_DESCS;
+        cmd->total_rx_desc = MWL8K_RX_DESCS;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+
+        if (!rc) {
+                SET_IEEE80211_PERM_ADDR(hw, cmd->perm_addr);
+                priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs);
+                priv->fw_rev = cmd->fw_rev;
+                priv->hw_rev = cmd->hw_rev;
+                priv->region_code = le16_to_cpu(cmd->region_code);
+        }
+
+        kfree(cmd);
+        return rc;
+}
+
+/*
+ * CMD_MAC_MULTICAST_ADR.
+ */
+struct mwl8k_cmd_mac_multicast_adr {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __le16 numaddr;
+        __u8 addr[1][IEEE80211_ADDR_LEN];
+};
+
+#define MWL8K_ENABLE_RX_MULTICAST 0x000F
+static int mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw,
+                                        int mc_count,
+                                        struct dev_addr_list *mclist)
+{
+        struct mwl8k_cmd_mac_multicast_adr *cmd;
+        int index = 0;
+        int rc;
+        int size = sizeof(*cmd) + ((mc_count - 1) * IEEE80211_ADDR_LEN);
+        cmd = kzalloc(size, GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
+        cmd->header.length = cpu_to_le16(size);
+        cmd->action = cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
+        cmd->numaddr = cpu_to_le16(mc_count);
+        while ((index < mc_count) && mclist) {
+                if (mclist->da_addrlen != IEEE80211_ADDR_LEN) {
+                        rc = -EINVAL;
+                        goto mwl8k_cmd_mac_multicast_adr_exit;
+                }
+                memcpy(cmd->addr[index], mclist->da_addr, IEEE80211_ADDR_LEN);
+                index++;
+                mclist = mclist->next;
+        }
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+
+mwl8k_cmd_mac_multicast_adr_exit:
+        kfree(cmd);
+        return rc;
+}
+
+/*
+ * CMD_802_11_GET_STAT.
+ */
+struct mwl8k_cmd_802_11_get_stat {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __le32 stats[64];
+} __attribute__((packed));
+
+#define MWL8K_STAT_ACK_FAILURE  9
+#define MWL8K_STAT_RTS_FAILURE  12
+#define MWL8K_STAT_FCS_ERROR    24
+#define MWL8K_STAT_RTS_SUCCESS  11
+
+static int mwl8k_cmd_802_11_get_stat(struct ieee80211_hw *hw,
+                                struct ieee80211_low_level_stats *stats)
+{
+        struct mwl8k_cmd_802_11_get_stat *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_STAT);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le16(MWL8K_CMD_GET);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        if (!rc) {
+                stats->dot11ACKFailureCount =
+                        le32_to_cpu(cmd->stats[MWL8K_STAT_ACK_FAILURE]);
+                stats->dot11RTSFailureCount =
+                        le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_FAILURE]);
+                stats->dot11FCSErrorCount =
+                        le32_to_cpu(cmd->stats[MWL8K_STAT_FCS_ERROR]);
+                stats->dot11RTSSuccessCount =
+                        le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_SUCCESS]);
+        }
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_802_11_RADIO_CONTROL.
+ */
+struct mwl8k_cmd_802_11_radio_control {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __le16 control;
+        __le16 radio_on;
+} __attribute__((packed));
+
+static int mwl8k_cmd_802_11_radio_control(struct ieee80211_hw *hw, int enable)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_cmd_802_11_radio_control *cmd;
+        int rc;
+
+        if (((enable & MWL8K_RADIO_ENABLE) == priv->radio_state) &&
+            !(enable & MWL8K_RADIO_FORCE))
+                return 0;
+
+        enable &= MWL8K_RADIO_ENABLE;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_RADIO_CONTROL);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le16(MWL8K_CMD_SET);
+        cmd->control = cpu_to_le16(priv->radio_preamble);
+        cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        if (!rc)
+                priv->radio_state = enable;
+
+        return rc;
+}
+
+static int
+mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
+{
+        struct mwl8k_priv *priv;
+
+        if (hw == NULL || hw->priv == NULL)
+                return -EINVAL;
+        priv = hw->priv;
+
+        priv->radio_preamble = (short_preamble ?
+                MWL8K_RADIO_SHORT_PREAMBLE :
+                MWL8K_RADIO_LONG_PREAMBLE);
+
+        return mwl8k_cmd_802_11_radio_control(hw,
+                        MWL8K_RADIO_ENABLE | MWL8K_RADIO_FORCE);
+}
+
+/*
+ * CMD_802_11_RF_TX_POWER.
+ */
+#define MWL8K_TX_POWER_LEVEL_TOTAL      8
+
+struct mwl8k_cmd_802_11_rf_tx_power {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __le16 support_level;
+        __le16 current_level;
+        __le16 reserved;
+        __le16 power_level_list[MWL8K_TX_POWER_LEVEL_TOTAL];
+} __attribute__((packed));
+
+static int mwl8k_cmd_802_11_rf_tx_power(struct ieee80211_hw *hw, int dBm)
+{
+        struct mwl8k_cmd_802_11_rf_tx_power *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_RF_TX_POWER);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le16(MWL8K_CMD_SET);
+        cmd->support_level = cpu_to_le16(dBm);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_PRE_SCAN.
+ */
+struct mwl8k_cmd_set_pre_scan {
+        struct mwl8k_cmd_pkt header;
+} __attribute__((packed));
+
+static int mwl8k_cmd_set_pre_scan(struct ieee80211_hw *hw)
+{
+        struct mwl8k_cmd_set_pre_scan *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_PRE_SCAN);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_POST_SCAN.
+ */
+struct mwl8k_cmd_set_post_scan {
+        struct mwl8k_cmd_pkt header;
+        __le32 isibss;
+        __u8 bssid[IEEE80211_ADDR_LEN];
+} __attribute__((packed));
+
+static int
+mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, __u8 mac[IEEE80211_ADDR_LEN])
+{
+        struct mwl8k_cmd_set_post_scan *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_POST_SCAN);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->isibss = 0;
+        memcpy(cmd->bssid, mac, IEEE80211_ADDR_LEN);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_RF_CHANNEL.
+ */
+struct mwl8k_cmd_set_rf_channel {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __u8 current_channel;
+        __le32 channel_flags;
+} __attribute__((packed));
+
+static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
+                                    struct ieee80211_channel *channel)
+{
+        struct mwl8k_cmd_set_rf_channel *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RF_CHANNEL);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le16(MWL8K_CMD_SET);
+        cmd->current_channel = channel->hw_value;
+        if (channel->band == IEEE80211_BAND_2GHZ)
+                cmd->channel_flags = cpu_to_le32(0x00000081);
+        else
+                cmd->channel_flags = cpu_to_le32(0x00000000);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_SLOT.
+ */
+struct mwl8k_cmd_set_slot {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __u8 short_slot;
+} __attribute__((packed));
+
+static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, int slot_time)
+{
+        struct mwl8k_cmd_set_slot *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le16(MWL8K_CMD_SET);
+        cmd->short_slot = slot_time == MWL8K_SHORT_SLOTTIME ? 1 : 0;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_MIMO_CONFIG.
+ */
+struct mwl8k_cmd_mimo_config {
+        struct mwl8k_cmd_pkt header;
+        __le32 action;
+        __u8 rx_antenna_map;
+        __u8 tx_antenna_map;
+} __attribute__((packed));
+
+static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
+{
+        struct mwl8k_cmd_mimo_config *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
+        cmd->rx_antenna_map = rx;
+        cmd->tx_antenna_map = tx;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_ENABLE_SNIFFER.
+ */
+struct mwl8k_cmd_enable_sniffer {
+        struct mwl8k_cmd_pkt header;
+        __le32 action;
+} __attribute__((packed));
+
+static int mwl8k_enable_sniffer(struct ieee80211_hw *hw, bool enable)
+{
+        struct mwl8k_cmd_enable_sniffer *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_ENABLE_SNIFFER);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = enable ? cpu_to_le32((u32)MWL8K_CMD_SET) : 0;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_RATE_ADAPT_MODE.
+ */
+struct mwl8k_cmd_set_rate_adapt_mode {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __le16 mode;
+} __attribute__((packed));
+
+static int mwl8k_cmd_setrateadaptmode(struct ieee80211_hw *hw, __u16 mode)
+{
+        struct mwl8k_cmd_set_rate_adapt_mode *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATEADAPT_MODE);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le16(MWL8K_CMD_SET);
+        cmd->mode = cpu_to_le16(mode);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_WMM_MODE.
+ */
+struct mwl8k_cmd_set_wmm {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+} __attribute__((packed));
+
+static int mwl8k_set_wmm(struct ieee80211_hw *hw, bool enable)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_cmd_set_wmm *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = enable ? cpu_to_le16(MWL8K_CMD_SET) : 0;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        if (!rc)
+                priv->wmm_mode = enable;
+
+        return rc;
+}
+
+/*
+ * CMD_SET_RTS_THRESHOLD.
+ */
+struct mwl8k_cmd_rts_threshold {
+        struct mwl8k_cmd_pkt header;
+        __le16 action;
+        __le16 threshold;
+} __attribute__((packed));
+
+static int mwl8k_rts_threshold(struct ieee80211_hw *hw,
+                               u16 action, u16 *threshold)
+{
+        struct mwl8k_cmd_rts_threshold *cmd;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->action = cpu_to_le16(action);
+        cmd->threshold = cpu_to_le16(*threshold);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_EDCA_PARAMS.
+ */
+struct mwl8k_cmd_set_edca_params {
+        struct mwl8k_cmd_pkt header;
+
+        /* See MWL8K_SET_EDCA_XXX below */
+        __le16 action;
+
+        /* TX opportunity in units of 32 us */
+        __le16 txop;
+
+        /* Log exponent of max contention period: 0...15*/
+        __u8 log_cw_max;
+
+        /* Log exponent of min contention period: 0...15 */
+        __u8 log_cw_min;
+
+        /* Adaptive interframe spacing in units of 32us */
+        __u8 aifs;
+
+        /* TX queue to configure */
+        __u8 txq;
+} __attribute__((packed));
+
+#define MWL8K_GET_EDCA_ALL      0
+#define MWL8K_SET_EDCA_CW       0x01
+#define MWL8K_SET_EDCA_TXOP     0x02
+#define MWL8K_SET_EDCA_AIFS     0x04
+
+#define MWL8K_SET_EDCA_ALL      (MWL8K_SET_EDCA_CW | \
+                                 MWL8K_SET_EDCA_TXOP | \
+                                 MWL8K_SET_EDCA_AIFS)
+
+static int
+mwl8k_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
+                __u16 cw_min, __u16 cw_max,
+                __u8 aifs, __u16 txop)
+{
+        struct mwl8k_cmd_set_edca_params *cmd;
+        u32 log_cw_min, log_cw_max;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        log_cw_min = ilog2(cw_min+1);
+        log_cw_max = ilog2(cw_max+1);
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_EDCA_PARAMS);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+
+        cmd->action = cpu_to_le16(MWL8K_SET_EDCA_ALL);
+        cmd->txop = cpu_to_le16(txop);
+        cmd->log_cw_max = (u8)log_cw_max;
+        cmd->log_cw_min = (u8)log_cw_min;
+        cmd->aifs = aifs;
+        cmd->txq = qnum;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_FINALIZE_JOIN.
+ */
+
+/* FJ beacon buffer size is compiled into the firmware.  */
+#define MWL8K_FJ_BEACON_MAXLEN  128
+
+struct mwl8k_cmd_finalize_join {
+        struct mwl8k_cmd_pkt header;
+        __le32 sleep_interval;  /* Number of beacon periods to sleep */
+        __u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
+} __attribute__((packed));
+
+static int mwl8k_finalize_join(struct ieee80211_hw *hw, void *frame,
+                                __u16 framelen, __u16 dtim)
+{
+        struct mwl8k_cmd_finalize_join *cmd;
+        struct ieee80211_mgmt *payload = frame;
+        u16 hdrlen;
+        u32 payload_len;
+        int rc;
+
+        if (frame == NULL)
+                return -EINVAL;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+
+        if (dtim)
+                cmd->sleep_interval = cpu_to_le32(dtim);
+        else
+                cmd->sleep_interval = cpu_to_le32(1);
+
+        hdrlen = ieee80211_hdrlen(payload->frame_control);
+
+        payload_len = framelen > hdrlen ? framelen - hdrlen : 0;
+
+        /* XXX TBD Might just have to abort and return an error */
+        if (payload_len > MWL8K_FJ_BEACON_MAXLEN)
+                printk(KERN_ERR "%s(): WARNING: Incomplete beacon "
+                        "sent to firmware. Sz=%u MAX=%u\n", __func__,
+                        payload_len, MWL8K_FJ_BEACON_MAXLEN);
+
+        payload_len = payload_len > MWL8K_FJ_BEACON_MAXLEN ?
+                                MWL8K_FJ_BEACON_MAXLEN : payload_len;
+
+        if (payload && payload_len)
+                memcpy(cmd->beacon_data, &payload->u.beacon, payload_len);
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+        return rc;
+}
+
+/*
+ * CMD_UPDATE_STADB.
+ */
+struct mwl8k_cmd_update_sta_db {
+        struct mwl8k_cmd_pkt header;
+
+        /* See STADB_ACTION_TYPE */
+        __le32  action;
+
+        /* Peer MAC address */
+        __u8    peer_addr[IEEE80211_ADDR_LEN];
+
+        __le32  reserved;
+
+        /* Peer info - valid during add/update.  */
+        struct peer_capability_info     peer_info;
+} __attribute__((packed));
+
+static int mwl8k_cmd_update_sta_db(struct ieee80211_hw *hw,
+                struct ieee80211_vif *vif, __u32 action)
+{
+        struct mwl8k_vif *mv_vif = MWL8K_VIF(vif);
+        struct ieee80211_bss_conf *info = &mv_vif->bss_info;
+        struct mwl8k_cmd_update_sta_db *cmd;
+        struct peer_capability_info *peer_info;
+        struct ieee80211_rate *bitrates = mv_vif->legacy_rates;
+        DECLARE_MAC_BUF(mac);
+        int rc;
+        __u8 count, *rates;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+
+        cmd->action = cpu_to_le32(action);
+        peer_info = &cmd->peer_info;
+        memcpy(cmd->peer_addr, mv_vif->bssid, IEEE80211_ADDR_LEN);
+
+        switch (action) {
+        case MWL8K_STA_DB_ADD_ENTRY:
+        case MWL8K_STA_DB_MODIFY_ENTRY:
+                /* Build peer_info block */
+                peer_info->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
+                peer_info->basic_caps = cpu_to_le16(info->assoc_capability);
+                peer_info->interop = 1;
+                peer_info->amsdu_enabled = 0;
+
+                rates = peer_info->legacy_rates;
+                for (count = 0 ; count < mv_vif->legacy_nrates; count++)
+                        rates[count] = bitrates[count].hw_value;
+
+                rc = mwl8k_post_cmd(hw, &cmd->header);
+                if (rc == 0)
+                        mv_vif->peer_id = peer_info->station_id;
+
+                break;
+
+        case MWL8K_STA_DB_DEL_ENTRY:
+        case MWL8K_STA_DB_FLUSH:
+        default:
+                rc = mwl8k_post_cmd(hw, &cmd->header);
+                if (rc == 0)
+                        mv_vif->peer_id = 0;
+                break;
+        }
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_AID.
+ */
+#define IEEE80211_OPMODE_DISABLED                       0x00
+#define IEEE80211_OPMODE_NON_MEMBER_PROT_MODE           0x01
+#define IEEE80211_OPMODE_ONE_20MHZ_STA_PROT_MODE        0x02
+#define IEEE80211_OPMODE_HTMIXED_PROT_MODE              0x03
+
+#define MWL8K_RATE_INDEX_MAX_ARRAY                      14
+
+#define MWL8K_FRAME_PROT_DISABLED                       0x00
+#define MWL8K_FRAME_PROT_11G                            0x07
+#define MWL8K_FRAME_PROT_11N_HT_40MHZ_ONLY              0x02
+#define MWL8K_FRAME_PROT_11N_HT_ALL                     0x06
+#define MWL8K_FRAME_PROT_MASK                           0x07
+
+struct mwl8k_cmd_update_set_aid {
+        struct  mwl8k_cmd_pkt header;
+        __le16  aid;
+
+         /* AP's MAC address (BSSID) */
+        __u8    bssid[IEEE80211_ADDR_LEN];
+        __le16  protection_mode;
+        __u8    supp_rates[MWL8K_RATE_INDEX_MAX_ARRAY];
+} __attribute__((packed));
+
+static int mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
+                                        struct ieee80211_vif *vif)
+{
+        struct mwl8k_vif *mv_vif = MWL8K_VIF(vif);
+        struct ieee80211_bss_conf *info = &mv_vif->bss_info;
+        struct mwl8k_cmd_update_set_aid *cmd;
+        struct ieee80211_rate *bitrates = mv_vif->legacy_rates;
+        int count;
+        u16 prot_mode;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+        cmd->aid = cpu_to_le16(info->aid);
+
+        memcpy(cmd->bssid, mv_vif->bssid, IEEE80211_ADDR_LEN);
+
+        prot_mode = MWL8K_FRAME_PROT_DISABLED;
+
+        if (info->use_cts_prot) {
+                prot_mode = MWL8K_FRAME_PROT_11G;
+        } else {
+                switch (info->ht.operation_mode &
+                        IEEE80211_HT_OP_MODE_PROTECTION) {
+                case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
+                        prot_mode = MWL8K_FRAME_PROT_11N_HT_40MHZ_ONLY;
+                        break;
+                case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
+                        prot_mode = MWL8K_FRAME_PROT_11N_HT_ALL;
+                        break;
+                default:
+                        prot_mode = MWL8K_FRAME_PROT_DISABLED;
+                        break;
+                }
+        }
+
+        cmd->protection_mode = cpu_to_le16(prot_mode);
+
+        for (count = 0; count < mv_vif->legacy_nrates; count++)
+                cmd->supp_rates[count] = bitrates[count].hw_value;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_SET_RATE.
+ */
+struct mwl8k_cmd_update_rateset {
+        struct  mwl8k_cmd_pkt header;
+        __u8    legacy_rates[MWL8K_RATE_INDEX_MAX_ARRAY];
+
+        /* Bitmap for supported MCS codes.  */
+        __u8    mcs_set[MWL8K_IEEE_LEGACY_DATA_RATES];
+        __u8    reserved[MWL8K_IEEE_LEGACY_DATA_RATES];
+} __attribute__((packed));
+
+static int mwl8k_update_rateset(struct ieee80211_hw *hw,
+                struct ieee80211_vif *vif)
+{
+        struct mwl8k_vif *mv_vif = MWL8K_VIF(vif);
+        struct mwl8k_cmd_update_rateset *cmd;
+        struct ieee80211_rate *bitrates = mv_vif->legacy_rates;
+        int count;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+
+        for (count = 0; count < mv_vif->legacy_nrates; count++)
+                cmd->legacy_rates[count] = bitrates[count].hw_value;
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+/*
+ * CMD_USE_FIXED_RATE.
+ */
+#define MWL8K_RATE_TABLE_SIZE   8
+#define MWL8K_UCAST_RATE        0
+#define MWL8K_MCAST_RATE        1
+#define MWL8K_BCAST_RATE        2
+
+#define MWL8K_USE_FIXED_RATE    0x0001
+#define MWL8K_USE_AUTO_RATE     0x0002
+
+struct mwl8k_rate_entry {
+        /* Set to 1 if HT rate, 0 if legacy.  */
+        __le32  is_ht_rate;
+
+        /* Set to 1 to use retry_count field.  */
+        __le32  enable_retry;
+
+        /* Specified legacy rate or MCS.  */
+        __le32  rate;
+
+        /* Number of allowed retries.  */
+        __le32  retry_count;
+} __attribute__((packed));
+
+struct mwl8k_rate_table {
+        /* 1 to allow specified rate and below */
+        __le32  allow_rate_drop;
+        __le32  num_rates;
+        struct mwl8k_rate_entry rate_entry[MWL8K_RATE_TABLE_SIZE];
+} __attribute__((packed));
+
+struct mwl8k_cmd_use_fixed_rate {
+        struct  mwl8k_cmd_pkt header;
+        __le32  action;
+        struct mwl8k_rate_table rate_table;
+
+        /* Unicast, Broadcast or Multicast */
+        __le32  rate_type;
+        __le32  reserved1;
+        __le32  reserved2;
+} __attribute__((packed));
+
+static int mwl8k_cmd_use_fixed_rate(struct ieee80211_hw *hw,
+        u32 action, u32 rate_type, struct mwl8k_rate_table *rate_table)
+{
+        struct mwl8k_cmd_use_fixed_rate *cmd;
+        int count;
+        int rc;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+        if (cmd == NULL)
+                return -ENOMEM;
+
+        cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE);
+        cmd->header.length = cpu_to_le16(sizeof(*cmd));
+
+        cmd->action = cpu_to_le32(action);
+        cmd->rate_type = cpu_to_le32(rate_type);
+
+        if (rate_table != NULL) {
+                /* Copy over each field manually so
+                * that bitflipping can be done
+                */
+                cmd->rate_table.allow_rate_drop =
+                                cpu_to_le32(rate_table->allow_rate_drop);
+                cmd->rate_table.num_rates =
+                                cpu_to_le32(rate_table->num_rates);
+
+                for (count = 0; count < rate_table->num_rates; count++) {
+                        struct mwl8k_rate_entry *dst =
+                                &cmd->rate_table.rate_entry[count];
+                        struct mwl8k_rate_entry *src =
+                                &rate_table->rate_entry[count];
+
+                        dst->is_ht_rate = cpu_to_le32(src->is_ht_rate);
+                        dst->enable_retry = cpu_to_le32(src->enable_retry);
+                        dst->rate = cpu_to_le32(src->rate);
+                        dst->retry_count = cpu_to_le32(src->retry_count);
+                }
+        }
+
+        rc = mwl8k_post_cmd(hw, &cmd->header);
+        kfree(cmd);
+
+        return rc;
+}
+
+
+/*
+ * Interrupt handling.
+ */
+static irqreturn_t mwl8k_interrupt(int irq, void *dev_id)
+{
+        struct ieee80211_hw *hw = dev_id;
+        struct mwl8k_priv *priv = hw->priv;
+        u32 status;
+
+        status = ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+        iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+
+        status &= priv->int_mask;
+        if (!status)
+                return IRQ_NONE;
+
+        if (status & MWL8K_A2H_INT_TX_DONE)
+                tasklet_schedule(&priv->tx_reclaim_task);
+
+        if (status & MWL8K_A2H_INT_RX_READY) {
+                while (rxq_process(hw, 0, 1))
+                        rxq_refill(hw, 0, 1);
+        }
+
+        if (status & MWL8K_A2H_INT_OPC_DONE) {
+                if (priv->hostcmd_wait != NULL) {
+                        complete(priv->hostcmd_wait);
+                        priv->hostcmd_wait = NULL;
+                }
+        }
+
+        if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
+                if (!priv->inconfig &&
+                        priv->radio_state &&
+                        mwl8k_txq_busy(priv))
+                                mwl8k_tx_start(priv);
+        }
+
+        return IRQ_HANDLED;
+}
+
+
+/*
+ * Core driver operations.
+ */
+static int mwl8k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        int index = skb_get_queue_mapping(skb);
+        int rc;
+
+        if (priv->current_channel == NULL) {
+                printk(KERN_DEBUG "%s: dropped TX frame since radio "
+                       "disabled\n", priv->name);
+                dev_kfree_skb(skb);
+                return NETDEV_TX_OK;
+        }
+
+        rc = mwl8k_txq_xmit(hw, index, skb);
+
+        return rc;
+}
+
+struct mwl8k_work_struct {
+        /* Initialized by mwl8k_queue_work().  */
+        struct work_struct wt;
+
+        /* Required field passed in to mwl8k_queue_work().  */
+        struct ieee80211_hw *hw;
+
+        /* Required field passed in to mwl8k_queue_work().  */
+        int (*wfunc)(struct work_struct *w);
+
+        /* Initialized by mwl8k_queue_work().  */
+        struct completion *cmd_wait;
+
+        /* Result code.  */
+        int rc;
+
+        /*
+         * Optional field. Refer to explanation of MWL8K_WQ_XXX_XXX
+         * flags for explanation.  Defaults to MWL8K_WQ_DEFAULT_OPTIONS.
+         */
+        u32 options;
+
+        /* Optional field.  Defaults to MWL8K_CONFIG_TIMEOUT_MS.  */
+        unsigned long timeout_ms;
+
+        /* Optional field.  Defaults to MWL8K_WQ_TXWAIT_ATTEMPTS.  */
+        u32 txwait_attempts;
+
+        /* Optional field.  Defaults to MWL8K_TXWAIT_MS.  */
+        u32 tx_timeout_ms;
+        u32 step;
+};
+
+/* Flags controlling behavior of config queue requests */
+
+/* Caller spins while waiting for completion.  */
+#define MWL8K_WQ_SPIN                   0x00000001
+
+/* Wait for TX queues to empty before proceeding with configuration.  */
+#define MWL8K_WQ_TX_WAIT_EMPTY          0x00000002
+
+/* Queue request and return immediately.  */
+#define MWL8K_WQ_POST_REQUEST           0x00000004
+
+/*
+ * Caller sleeps and waits for task complete notification.
+ * Do not use in atomic context.
+ */
+#define MWL8K_WQ_SLEEP                  0x00000008
+
+/* Free work struct when task is done.  */
+#define MWL8K_WQ_FREE_WORKSTRUCT        0x00000010
+
+/*
+ * Config request is queued and returns to caller imediately.  Use
+ * this in atomic context. Work struct is freed by mwl8k_queue_work()
+ * when this flag is set.
+ */
+#define MWL8K_WQ_QUEUE_ONLY     (MWL8K_WQ_POST_REQUEST | \
+                                 MWL8K_WQ_FREE_WORKSTRUCT)
+
+/* Default work queue behavior is to sleep and wait for tx completion.  */
+#define MWL8K_WQ_DEFAULT_OPTIONS (MWL8K_WQ_SLEEP | MWL8K_WQ_TX_WAIT_EMPTY)
+
+/*
+ * Default config request timeout.  Add adjustments to make sure the
+ * config thread waits long enough for both tx wait and cmd wait before
+ * timing out.
+ */
+
+/* Time to wait for all TXQs to drain.  TX Doorbell is pressed each time.  */
+#define MWL8K_TXWAIT_TIMEOUT_MS         1000
+
+/* Default number of TX wait attempts.  */
+#define MWL8K_WQ_TXWAIT_ATTEMPTS        4
+
+/* Total time to wait for TXQ to drain.  */
+#define MWL8K_TXWAIT_MS                 (MWL8K_TXWAIT_TIMEOUT_MS * \
+                                                MWL8K_WQ_TXWAIT_ATTEMPTS)
+
+/* Scheduling slop.  */
+#define MWL8K_OS_SCHEDULE_OVERHEAD_MS   200
+
+#define MWL8K_CONFIG_TIMEOUT_MS (MWL8K_CMD_TIMEOUT_MS + \
+                                 MWL8K_TXWAIT_MS + \
+                                 MWL8K_OS_SCHEDULE_OVERHEAD_MS)
+
+static void mwl8k_config_thread(struct work_struct *wt)
+{
+        struct mwl8k_work_struct *worker = (struct mwl8k_work_struct *)wt;
+        struct ieee80211_hw *hw = worker->hw;
+        struct mwl8k_priv *priv = hw->priv;
+        int rc = 0;
+
+        spin_lock_irq(&priv->tx_lock);
+        priv->inconfig = true;
+        spin_unlock_irq(&priv->tx_lock);
+
+        ieee80211_stop_queues(hw);
+
+        /*
+         * Wait for host queues to drain before doing PHY
+         * reconfiguration. This avoids interrupting any in-flight
+         * DMA transfers to the hardware.
+         */
+        if (worker->options & MWL8K_WQ_TX_WAIT_EMPTY) {
+                u32 timeout;
+                u32 time_remaining;
+                u32 iter;
+                u32 tx_wait_attempts = worker->txwait_attempts;
+
+                time_remaining = worker->tx_timeout_ms;
+                if (!tx_wait_attempts)
+                        tx_wait_attempts = 1;
+
+                timeout = worker->tx_timeout_ms/tx_wait_attempts;
+                if (!timeout)
+                        timeout = 1;
+
+                iter = tx_wait_attempts;
+                do {
+                        int wait_time;
+
+                        if (time_remaining > timeout) {
+                                time_remaining -= timeout;
+                                wait_time = timeout;
+                        } else
+                                wait_time = time_remaining;
+
+                        if (!wait_time)
+                                wait_time = 1;
+
+                        rc = mwl8k_tx_wait_empty(hw, wait_time);
+                        if (rc)
+                                printk(KERN_ERR "%s() txwait timeout=%ums "
+                                        "Retry:%u/%u\n", __func__, timeout,
+                                        tx_wait_attempts - iter + 1,
+                                        tx_wait_attempts);
+
+                } while (rc && --iter);
+
+                rc = iter ? 0 : -ETIMEDOUT;
+        }
+        if (!rc)
+                rc = worker->wfunc(wt);
+
+        spin_lock_irq(&priv->tx_lock);
+        priv->inconfig = false;
+        if (priv->pending_tx_pkts && priv->radio_state)
+                mwl8k_tx_start(priv);
+        spin_unlock_irq(&priv->tx_lock);
+        ieee80211_wake_queues(hw);
+
+        worker->rc = rc;
+        if (worker->options & MWL8K_WQ_SLEEP)
+                complete(worker->cmd_wait);
+
+        if (worker->options & MWL8K_WQ_FREE_WORKSTRUCT)
+                kfree(wt);
+}
+
+static int mwl8k_queue_work(struct ieee80211_hw *hw,
+                                struct mwl8k_work_struct *worker,
+                                struct workqueue_struct *wqueue,
+                                int (*wfunc)(struct work_struct *w))
+{
+        unsigned long timeout = 0;
+        int rc = 0;
+
+        DECLARE_COMPLETION_ONSTACK(cmd_wait);
+
+        if (!worker->timeout_ms)
+                worker->timeout_ms = MWL8K_CONFIG_TIMEOUT_MS;
+
+        if (!worker->options)
+                worker->options = MWL8K_WQ_DEFAULT_OPTIONS;
+
+        if (!worker->txwait_attempts)
+                worker->txwait_attempts = MWL8K_WQ_TXWAIT_ATTEMPTS;
+
+        if (!worker->tx_timeout_ms)
+                worker->tx_timeout_ms = MWL8K_TXWAIT_MS;
+
+        worker->hw = hw;
+        worker->cmd_wait = &cmd_wait;
+        worker->rc = 1;
+        worker->wfunc = wfunc;
+
+        INIT_WORK(&worker->wt, mwl8k_config_thread);
+        queue_work(wqueue, &worker->wt);
+
+        if (worker->options & MWL8K_WQ_POST_REQUEST) {
+                rc = 0;
+        } else {
+                if (worker->options & MWL8K_WQ_SPIN) {
+                        timeout = worker->timeout_ms;
+                        while (timeout && (worker->rc > 0)) {
+                                mdelay(1);
+                                timeout--;
+                        }
+                } else if (worker->options & MWL8K_WQ_SLEEP)
+                        timeout = wait_for_completion_timeout(&cmd_wait,
+                                msecs_to_jiffies(worker->timeout_ms));
+
+                if (timeout)
+                        rc = worker->rc;
+                else {
+                        cancel_work_sync(&worker->wt);
+                        rc = -ETIMEDOUT;
+                }
+        }
+
+        return rc;
+}
+
+struct mwl8k_start_worker {
+        struct mwl8k_work_struct header;
+};
+
+static int mwl8k_start_wt(struct work_struct *wt)
+{
+        struct mwl8k_start_worker *worker = (struct mwl8k_start_worker *)wt;
+        struct ieee80211_hw *hw = worker->header.hw;
+        struct mwl8k_priv *priv = hw->priv;
+        int rc = 0;
+
+        if (priv->vif != NULL) {
+                rc = -EIO;
+                goto mwl8k_start_exit;
+        }
+
+        /* Turn on radio */
+        if (mwl8k_cmd_802_11_radio_control(hw, MWL8K_RADIO_ENABLE)) {
+                rc = -EIO;
+                goto mwl8k_start_exit;
+        }
+
+        /* Purge TX/RX HW queues */
+        if (mwl8k_cmd_set_pre_scan(hw)) {
+                rc = -EIO;
+                goto mwl8k_start_exit;
+        }
+
+        if (mwl8k_cmd_set_post_scan(hw, "\x00\x00\x00\x00\x00\x00")) {
+                rc = -EIO;
+                goto mwl8k_start_exit;
+        }
+
+        /* Enable firmware rate adaptation */
+        if (mwl8k_cmd_setrateadaptmode(hw, 0)) {
+                rc = -EIO;
+                goto mwl8k_start_exit;
+        }
+
+        /* Disable WMM. WMM gets enabled when stack sends WMM parms */
+        if (mwl8k_set_wmm(hw, MWL8K_WMM_DISABLE)) {
+                rc = -EIO;
+                goto mwl8k_start_exit;
+        }
+
+        /* Disable sniffer mode */
+        if (mwl8k_enable_sniffer(hw, 0))
+                rc = -EIO;
+
+mwl8k_start_exit:
+        return rc;
+}
+
+static int mwl8k_start(struct ieee80211_hw *hw)
+{
+        struct mwl8k_start_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+        int rc;
+
+        /* Enable tx reclaim tasklet */
+        tasklet_enable(&priv->tx_reclaim_task);
+
+        rc = request_irq(priv->pdev->irq, &mwl8k_interrupt,
+                         IRQF_SHARED, MWL8K_NAME, hw);
+        if (rc) {
+                printk(KERN_ERR "%s: failed to register IRQ handler\n",
+                       priv->name);
+                rc = -EIO;
+                goto mwl8k_start_disable_tasklet;
+        }
+
+        /* Enable interrupts */
+        iowrite32(priv->int_mask, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
+
+        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
+        if (worker == NULL) {
+                rc = -ENOMEM;
+                goto mwl8k_start_disable_irq;
+        }
+
+        rc = mwl8k_queue_work(hw, &worker->header,
+                              priv->config_wq, mwl8k_start_wt);
+        kfree(worker);
+        if (!rc)
+                return rc;
+
+        if (rc == -ETIMEDOUT)
+                printk(KERN_ERR "%s() timed out\n", __func__);
+
+        rc = -EIO;
+
+mwl8k_start_disable_irq:
+        spin_lock_irq(&priv->tx_lock);
+        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
+        spin_unlock_irq(&priv->tx_lock);
+        free_irq(priv->pdev->irq, hw);
+
+mwl8k_start_disable_tasklet:
+        tasklet_disable(&priv->tx_reclaim_task);
+
+        return rc;
+}
+
+struct mwl8k_stop_worker {
+        struct mwl8k_work_struct header;
+};
+
+static int mwl8k_stop_wt(struct work_struct *wt)
+{
+        struct mwl8k_stop_worker *worker = (struct mwl8k_stop_worker *)wt;
+        struct ieee80211_hw *hw = worker->header.hw;
+        int rc;
+
+        rc = mwl8k_cmd_802_11_radio_control(hw, MWL8K_RADIO_DISABLE);
+
+        return rc;
+}
+
+static void mwl8k_stop(struct ieee80211_hw *hw)
+{
+        int rc;
+        struct mwl8k_stop_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+        int i;
+
+        if (priv->vif != NULL)
+                return;
+
+        ieee80211_stop_queues(hw);
+
+        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
+        if (worker == NULL)
+                return;
+
+        rc = mwl8k_queue_work(hw, &worker->header,
+                              priv->config_wq, mwl8k_stop_wt);
+        kfree(worker);
+        if (rc == -ETIMEDOUT)
+                printk(KERN_ERR "%s() timed out\n", __func__);
+
+        /* Disable interrupts */
+        spin_lock_irq(&priv->tx_lock);
+        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
+        spin_unlock_irq(&priv->tx_lock);
+        free_irq(priv->pdev->irq, hw);
+
+        /* Stop finalize join worker */
+        cancel_work_sync(&priv->finalize_join_worker);
+        if (priv->beacon_skb != NULL)
+                dev_kfree_skb(priv->beacon_skb);
+
+        /* Stop tx reclaim tasklet */
+        tasklet_disable(&priv->tx_reclaim_task);
+
+        /* Stop config thread */
+        flush_workqueue(priv->config_wq);
+
+        /* Return all skbs to mac80211 */
+        for (i = 0; i < MWL8K_TX_QUEUES; i++)
+                mwl8k_txq_reclaim(hw, i, 1);
+}
+
+static int mwl8k_add_interface(struct ieee80211_hw *hw,
+                                struct ieee80211_if_init_conf *conf)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_vif *mwl8k_vif;
+
+        /*
+         * We only support one active interface at a time.
+         */
+        if (priv->vif != NULL)
+                return -EBUSY;
+
+        /*
+         * We only support managed interfaces for now.
+         */
+        if (conf->type != NL80211_IFTYPE_STATION &&
+            conf->type != NL80211_IFTYPE_MONITOR)
+                return -EINVAL;
+
+        /* Clean out driver private area */
+        mwl8k_vif = MWL8K_VIF(conf->vif);
+        memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
+
+        /* Save the mac address */
+        memcpy(mwl8k_vif->mac_addr, conf->mac_addr, IEEE80211_ADDR_LEN);
+
+        /* Back pointer to parent config block */
+        mwl8k_vif->priv = priv;
+
+        /* Setup initial PHY parameters */
+        memcpy(mwl8k_vif->legacy_rates ,
+                priv->rates, sizeof(mwl8k_vif->legacy_rates));
+        mwl8k_vif->legacy_nrates = ARRAY_SIZE(priv->rates);
+
+        /* Set Initial sequence number to zero */
+        mwl8k_vif->seqno = 0;
+
+        priv->vif = conf->vif;
+        priv->current_channel = NULL;
+
+        return 0;
+}
+
+static void mwl8k_remove_interface(struct ieee80211_hw *hw,
+                                   struct ieee80211_if_init_conf *conf)
+{
+        struct mwl8k_priv *priv = hw->priv;
+
+        if (priv->vif == NULL)
+                return;
+
+        priv->vif = NULL;
+}
+
+struct mwl8k_config_worker {
+        struct mwl8k_work_struct header;
+        u32 changed;
+};
+
+static int mwl8k_config_wt(struct work_struct *wt)
+{
+        struct mwl8k_config_worker *worker =
+                (struct mwl8k_config_worker *)wt;
+        struct ieee80211_hw *hw = worker->header.hw;
+        struct ieee80211_conf *conf = &hw->conf;
+        struct mwl8k_priv *priv = hw->priv;
+        int rc = 0;
+
+        if (!conf->radio_enabled) {
+                mwl8k_cmd_802_11_radio_control(hw, MWL8K_RADIO_DISABLE);
+                priv->current_channel = NULL;
+                rc = 0;
+                goto mwl8k_config_exit;
+        }
+
+        if (mwl8k_cmd_802_11_radio_control(hw, MWL8K_RADIO_ENABLE)) {
+                rc = -EINVAL;
+                goto mwl8k_config_exit;
+        }
+
+        priv->current_channel = conf->channel;
+
+        if (mwl8k_cmd_set_rf_channel(hw, conf->channel)) {
+                rc = -EINVAL;
+                goto mwl8k_config_exit;
+        }
+
+        if (conf->power_level > 18)
+                conf->power_level = 18;
+        if (mwl8k_cmd_802_11_rf_tx_power(hw, conf->power_level)) {
+                rc = -EINVAL;
+                goto mwl8k_config_exit;
+        }
+
+        if (mwl8k_cmd_mimo_config(hw, 0x7, 0x7))
+                rc = -EINVAL;
+
+mwl8k_config_exit:
+        return rc;
+}
+
+static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
+{
+        int rc = 0;
+        struct mwl8k_config_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+
+        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
+        if (worker == NULL)
+                return -ENOMEM;
+
+        worker->changed = changed;
+        rc = mwl8k_queue_work(hw, &worker->header,
+                              priv->config_wq, mwl8k_config_wt);
+        if (rc == -ETIMEDOUT) {
+                printk(KERN_ERR "%s() timed out.\n", __func__);
+                rc = -EINVAL;
+        }
+
+        kfree(worker);
+
+        /*
+         * mac80211 will crash on anything other than -EINVAL on
+         * error. Looks like wireless extensions which calls mac80211
+         * may be the actual culprit...
+         */
+        return rc ? -EINVAL : 0;
+}
+
+static int mwl8k_config_interface(struct ieee80211_hw *hw,
+                                  struct ieee80211_vif *vif,
+                                  struct ieee80211_if_conf *conf)
+{
+        struct mwl8k_vif *mv_vif = MWL8K_VIF(vif);
+        u32 changed = conf->changed;
+
+        if (changed & IEEE80211_IFCC_BSSID)
+                memcpy(mv_vif->bssid, conf->bssid, IEEE80211_ADDR_LEN);
+
+        return 0;
+}
+
+struct mwl8k_bss_info_changed_worker {
+        struct mwl8k_work_struct header;
+        struct ieee80211_vif *vif;
+        struct ieee80211_bss_conf *info;
+        u32 changed;
+};
+
+static int mwl8k_bss_info_changed_wt(struct work_struct *wt)
+{
+        struct mwl8k_bss_info_changed_worker *worker =
+                (struct mwl8k_bss_info_changed_worker *)wt;
+        struct ieee80211_hw *hw = worker->header.hw;
+        struct ieee80211_vif *vif = worker->vif;
+        struct ieee80211_bss_conf *info = worker->info;
+        u32 changed;
+        int rc;
+
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
+
+        changed = worker->changed;
+        priv->capture_beacon = false;
+
+        if (info->assoc) {
+                memcpy(&mwl8k_vif->bss_info, info,
+                        sizeof(struct ieee80211_bss_conf));
+
+                /* Install rates */
+                if (mwl8k_update_rateset(hw, vif))
+                        goto mwl8k_bss_info_changed_exit;
+
+                /* Turn on rate adaptation */
+                if (mwl8k_cmd_use_fixed_rate(hw, MWL8K_USE_AUTO_RATE,
+                        MWL8K_UCAST_RATE, NULL))
+                        goto mwl8k_bss_info_changed_exit;
+
+                /* Set radio preamble */
+                if (mwl8k_set_radio_preamble(hw,
+                                info->use_short_preamble))
+                        goto mwl8k_bss_info_changed_exit;
+
+                /* Set slot time */
+                if (mwl8k_cmd_set_slot(hw, info->use_short_slot ?
+                                MWL8K_SHORT_SLOTTIME : MWL8K_LONG_SLOTTIME))
+                        goto mwl8k_bss_info_changed_exit;
+
+                /* Update peer rate info */
+                if (mwl8k_cmd_update_sta_db(hw, vif,
+                                MWL8K_STA_DB_MODIFY_ENTRY))
+                        goto mwl8k_bss_info_changed_exit;
+
+                /* Set AID */
+                if (mwl8k_cmd_set_aid(hw, vif))
+                        goto mwl8k_bss_info_changed_exit;
+
+                /*
+                 * Finalize the join.  Tell rx handler to process
+                 * next beacon from our BSSID.
+                 */
+                memcpy(priv->capture_bssid,
+                                mwl8k_vif->bssid, IEEE80211_ADDR_LEN);
+                priv->capture_beacon = true;
+        } else {
+                mwl8k_cmd_update_sta_db(hw, vif, MWL8K_STA_DB_DEL_ENTRY);
+                memset(&mwl8k_vif->bss_info, 0,
+                        sizeof(struct ieee80211_bss_conf));
+                memset(mwl8k_vif->bssid, 0, IEEE80211_ADDR_LEN);
+        }
+
+mwl8k_bss_info_changed_exit:
+        rc = 0;
+        return rc;
+}
+
+static void mwl8k_bss_info_changed(struct ieee80211_hw *hw,
+                                   struct ieee80211_vif *vif,
+                                   struct ieee80211_bss_conf *info,
+                                   u32 changed)
+{
+        struct mwl8k_bss_info_changed_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+        int rc;
+
+        if ((changed & BSS_CHANGED_ASSOC) == 0)
+                return;
+
+        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
+        if (worker == NULL)
+                return;
+
+        worker->vif = vif;
+        worker->info = info;
+        worker->changed = changed;
+        rc = mwl8k_queue_work(hw, &worker->header,
+                              priv->config_wq,
+                              mwl8k_bss_info_changed_wt);
+        kfree(worker);
+        if (rc == -ETIMEDOUT)
+                printk(KERN_ERR "%s() timed out\n", __func__);
+}
+
+struct mwl8k_configure_filter_worker {
+        struct mwl8k_work_struct header;
+        unsigned int changed_flags;
+        unsigned int *total_flags;
+        int mc_count;
+        struct dev_addr_list *mclist;
+};
+
+#define MWL8K_SUPPORTED_IF_FLAGS        FIF_BCN_PRBRESP_PROMISC
+
+static int mwl8k_configure_filter_wt(struct work_struct *wt)
+{
+        struct mwl8k_configure_filter_worker *worker =
+                (struct mwl8k_configure_filter_worker *)wt;
+
+        struct ieee80211_hw *hw = worker->header.hw;
+        unsigned int changed_flags = worker->changed_flags;
+        unsigned int *total_flags = worker->total_flags;
+        int mc_count = worker->mc_count;
+        struct dev_addr_list *mclist = worker->mclist;
+
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_vif *mv_vif;
+        int rc = 0;
+
+        if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
+                if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
+                        rc = mwl8k_cmd_set_pre_scan(hw);
+                else {
+                        mv_vif = MWL8K_VIF(priv->vif);
+                        rc = mwl8k_cmd_set_post_scan(hw, mv_vif->bssid);
+                }
+        }
+
+        if (rc)
+                goto mwl8k_configure_filter_exit;
+        if (mc_count) {
+                mc_count = mc_count < priv->num_mcaddrs ?
+                                mc_count : priv->num_mcaddrs;
+                rc = mwl8k_cmd_mac_multicast_adr(hw, mc_count, mclist);
+                if (rc)
+                        printk(KERN_ERR
+                        "%s()Error setting multicast addresses\n",
+                        __func__);
+        }
+
+mwl8k_configure_filter_exit:
+        return rc;
+}
+
+static void mwl8k_configure_filter(struct ieee80211_hw *hw,
+                                   unsigned int changed_flags,
+                                   unsigned int *total_flags,
+                                   int mc_count,
+                                   struct dev_addr_list *mclist)
+{
+
+        struct mwl8k_configure_filter_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+
+        /* Clear unsupported feature flags */
+        *total_flags &= MWL8K_SUPPORTED_IF_FLAGS;
+
+        if (!(changed_flags & MWL8K_SUPPORTED_IF_FLAGS) && !mc_count)
+                return;
+
+        worker = kzalloc(sizeof(*worker), GFP_ATOMIC);
+        if (worker == NULL)
+                return;
+
+        worker->header.options = MWL8K_WQ_QUEUE_ONLY | MWL8K_WQ_TX_WAIT_EMPTY;
+        worker->changed_flags = changed_flags;
+        worker->total_flags = total_flags;
+        worker->mc_count = mc_count;
+        worker->mclist = mclist;
+
+        mwl8k_queue_work(hw, &worker->header, priv->config_wq,
+                         mwl8k_configure_filter_wt);
+}
+
+struct mwl8k_set_rts_threshold_worker {
+        struct mwl8k_work_struct header;
+        u32 value;
+};
+
+static int mwl8k_set_rts_threshold_wt(struct work_struct *wt)
+{
+        struct mwl8k_set_rts_threshold_worker *worker =
+                (struct mwl8k_set_rts_threshold_worker *)wt;
+
+        struct ieee80211_hw *hw = worker->header.hw;
+        u16 threshold = (u16)(worker->value);
+        int rc;
+
+        rc = mwl8k_rts_threshold(hw, MWL8K_CMD_SET, &threshold);
+
+        return rc;
+}
+
+static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
+{
+        int rc;
+        struct mwl8k_set_rts_threshold_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+
+        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
+        if (worker == NULL)
+                return -ENOMEM;
+
+        worker->value = value;
+
+        rc = mwl8k_queue_work(hw, &worker->header,
+                              priv->config_wq,
+                              mwl8k_set_rts_threshold_wt);
+        kfree(worker);
+
+        if (rc == -ETIMEDOUT) {
+                printk(KERN_ERR "%s() timed out\n", __func__);
+                rc = -EINVAL;
+        }
+
+        return rc;
+}
+
+struct mwl8k_conf_tx_worker {
+        struct mwl8k_work_struct header;
+        u16 queue;
+        const struct ieee80211_tx_queue_params *params;
+};
+
+static int mwl8k_conf_tx_wt(struct work_struct *wt)
+{
+        struct mwl8k_conf_tx_worker *worker =
+        (struct mwl8k_conf_tx_worker *)wt;
+
+        struct ieee80211_hw *hw = worker->header.hw;
+        u16 queue = worker->queue;
+        const struct ieee80211_tx_queue_params *params = worker->params;
+
+        struct mwl8k_priv *priv = hw->priv;
+        int rc = 0;
+
+        if (priv->wmm_mode == MWL8K_WMM_DISABLE)
+                if (mwl8k_set_wmm(hw, MWL8K_WMM_ENABLE)) {
+                        rc = -EINVAL;
+                        goto mwl8k_conf_tx_exit;
+        }
+
+        if (mwl8k_set_edca_params(hw, GET_TXQ(queue), params->cw_min,
+                params->cw_max, params->aifs, params->txop))
+                        rc = -EINVAL;
+mwl8k_conf_tx_exit:
+        return rc;
+}
+
+static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
+                         const struct ieee80211_tx_queue_params *params)
+{
+        int rc;
+        struct mwl8k_conf_tx_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+
+        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
+        if (worker == NULL)
+                return -ENOMEM;
+
+        worker->queue = queue;
+        worker->params = params;
+        rc = mwl8k_queue_work(hw, &worker->header,
+                              priv->config_wq, mwl8k_conf_tx_wt);
+        kfree(worker);
+        if (rc == -ETIMEDOUT) {
+                printk(KERN_ERR "%s() timed out\n", __func__);
+                rc = -EINVAL;
+        }
+        return rc;
+}
+
+static int mwl8k_get_tx_stats(struct ieee80211_hw *hw,
+                              struct ieee80211_tx_queue_stats *stats)
+{
+        struct mwl8k_priv *priv = hw->priv;
+        struct mwl8k_tx_queue *txq;
+        int index;
+
+        spin_lock_bh(&priv->tx_lock);
+        for (index = 0; index < MWL8K_TX_QUEUES; index++) {
+                txq = priv->txq + index;
+                memcpy(&stats[index], &txq->tx_stats,
+                        sizeof(struct ieee80211_tx_queue_stats));
+        }
+        spin_unlock_bh(&priv->tx_lock);
+        return 0;
+}
+
+struct mwl8k_get_stats_worker {
+        struct mwl8k_work_struct header;
+        struct ieee80211_low_level_stats *stats;
+};
+
+static int mwl8k_get_stats_wt(struct work_struct *wt)
+{
+        struct mwl8k_get_stats_worker *worker =
+                (struct mwl8k_get_stats_worker *)wt;
+
+        return mwl8k_cmd_802_11_get_stat(worker->header.hw, worker->stats);
+}
+
+static int mwl8k_get_stats(struct ieee80211_hw *hw,
+                           struct ieee80211_low_level_stats *stats)
+{
+        int rc;
+        struct mwl8k_get_stats_worker *worker;
+        struct mwl8k_priv *priv = hw->priv;
+
+        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
+        if (worker == NULL)
+                return -ENOMEM;
+
+        worker->stats = stats;
+        rc = mwl8k_queue_work(hw, &worker->header,
+                              priv->config_wq, mwl8k_get_stats_wt);
+
+        kfree(worker);
+        if (rc == -ETIMEDOUT) {
+                printk(KERN_ERR "%s() timed out\n", __func__);
+                rc = -EINVAL;
+        }
+
+        return rc;
+}
+
+static const struct ieee80211_ops mwl8k_ops = {
+        .tx                     = mwl8k_tx,
+        .start                  = mwl8k_start,
+        .stop                   = mwl8k_stop,
+        .add_interface          = mwl8k_add_interface,
+        .remove_interface       = mwl8k_remove_interface,
+        .config                 = mwl8k_config,
+        .config_interface       = mwl8k_config_interface,
+        .bss_info_changed       = mwl8k_bss_info_changed,
+        .configure_filter       = mwl8k_configure_filter,
+        .set_rts_threshold      = mwl8k_set_rts_threshold,
+        .conf_tx                = mwl8k_conf_tx,
+        .get_tx_stats           = mwl8k_get_tx_stats,
+        .get_stats              = mwl8k_get_stats,
+};
+
+static void mwl8k_tx_reclaim_handler(unsigned long data)
+{
+        int i;
+        struct ieee80211_hw *hw = (struct ieee80211_hw *) data;
+        struct mwl8k_priv *priv = hw->priv;
+
+        spin_lock_bh(&priv->tx_lock);
+        for (i = 0; i < MWL8K_TX_QUEUES; i++)
+                mwl8k_txq_reclaim(hw, i, 0);
+
+        if (priv->tx_wait != NULL) {
+                int count = mwl8k_txq_busy(priv);
+                if (count == 0) {
+                        complete(priv->tx_wait);
+                        priv->tx_wait = NULL;
+                }
+        }
+        spin_unlock_bh(&priv->tx_lock);
+}
+
+static void mwl8k_finalize_join_worker(struct work_struct *work)
+{
+        struct mwl8k_priv *priv =
+                container_of(work, struct mwl8k_priv, finalize_join_worker);
+        struct sk_buff *skb = priv->beacon_skb;
+        u8 dtim = (MWL8K_VIF(priv->vif))->bss_info.dtim_period;
+
+        mwl8k_finalize_join(priv->hw, skb->data, skb->len, dtim);
+        dev_kfree_skb(skb);
+
+        priv->beacon_skb = NULL;
+}
+
+static int __devinit mwl8k_probe(struct pci_dev *pdev,
+                                 const struct pci_device_id *id)
+{
+        struct ieee80211_hw *hw;
+        struct mwl8k_priv *priv;
+        DECLARE_MAC_BUF(mac);
+        int rc;
+        int i;
+        u8 *fw;
+
+        rc = pci_enable_device(pdev);
+        if (rc) {
+                printk(KERN_ERR "%s: Cannot enable new PCI device\n",
+                       MWL8K_NAME);
+                return rc;
+        }
+
+        rc = pci_request_regions(pdev, MWL8K_NAME);
+        if (rc) {
+                printk(KERN_ERR "%s: Cannot obtain PCI resources\n",
+                       MWL8K_NAME);
+                return rc;
+        }
+
+        pci_set_master(pdev);
+
+        hw = ieee80211_alloc_hw(sizeof(*priv), &mwl8k_ops);
+        if (hw == NULL) {
+                printk(KERN_ERR "%s: ieee80211 alloc failed\n", MWL8K_NAME);
+                rc = -ENOMEM;
+                goto err_free_reg;
+        }
+
+        priv = hw->priv;
+        priv->hw = hw;
+        priv->pdev = pdev;
+        priv->hostcmd_wait = NULL;
+        priv->tx_wait = NULL;
+        priv->inconfig = false;
+        priv->wep_enabled = 0;
+        priv->wmm_mode = false;
+        priv->pending_tx_pkts = 0;
+        strncpy(priv->name, MWL8K_NAME, sizeof(priv->name));
+
+        spin_lock_init(&priv->fw_lock);
+
+        SET_IEEE80211_DEV(hw, &pdev->dev);
+        pci_set_drvdata(pdev, hw);
+
+        priv->regs = pci_iomap(pdev, 1, 0x10000);
+        if (priv->regs == NULL) {
+                printk(KERN_ERR "%s: Cannot map device memory\n", priv->name);
+                goto err_iounmap;
+        }
+
+        memcpy(priv->channels, mwl8k_channels, sizeof(mwl8k_channels));
+        priv->band.band = IEEE80211_BAND_2GHZ;
+        priv->band.channels = priv->channels;
+        priv->band.n_channels = ARRAY_SIZE(mwl8k_channels);
+        priv->band.bitrates = priv->rates;
+        priv->band.n_bitrates = ARRAY_SIZE(mwl8k_rates);
+        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
+
+        BUILD_BUG_ON(sizeof(priv->rates) != sizeof(mwl8k_rates));
+        memcpy(priv->rates, mwl8k_rates, sizeof(mwl8k_rates));
+
+        /*
+         * Extra headroom is the size of the required DMA header
+         * minus the size of the smallest 802.11 frame (CTS frame).
+         */
+        hw->extra_tx_headroom =
+                sizeof(struct mwl8k_dma_data) - sizeof(struct ieee80211_cts);
+
+        hw->channel_change_time = 10;
+
+        hw->queues = MWL8K_TX_QUEUES;
+
+        hw->wiphy->interface_modes =
+                BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_MONITOR);
+
+        /* Set rssi and noise values to dBm */
+        hw->flags |= (IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_NOISE_DBM);
+        hw->vif_data_size = sizeof(struct mwl8k_vif);
+        priv->vif = NULL;
+
+        /* Set default radio state and preamble */
+        priv->radio_preamble = MWL8K_RADIO_DEFAULT_PREAMBLE;
+        priv->radio_state = MWL8K_RADIO_DISABLE;
+
+        /* Finalize join worker */
+        INIT_WORK(&priv->finalize_join_worker, mwl8k_finalize_join_worker);
+
+        /* TX reclaim tasklet */
+        tasklet_init(&priv->tx_reclaim_task,
+                        mwl8k_tx_reclaim_handler, (unsigned long)hw);
+        tasklet_disable(&priv->tx_reclaim_task);
+
+        /* Config workthread */
+        priv->config_wq = create_singlethread_workqueue("mwl8k_config");
+        if (priv->config_wq == NULL)
+                goto err_iounmap;
+
+        /* Power management cookie */
+        priv->cookie = pci_alloc_consistent(priv->pdev, 4, &priv->cookie_dma);
+        if (priv->cookie == NULL)
+                goto err_iounmap;
+
+        rc = mwl8k_rxq_init(hw, 0);
+        if (rc)
+                goto err_iounmap;
+        rxq_refill(hw, 0, INT_MAX);
+
+        spin_lock_init(&priv->tx_lock);
+
+        for (i = 0; i < MWL8K_TX_QUEUES; i++) {
+                rc = mwl8k_txq_init(hw, i);
+                if (rc)
+                        goto err_free_queues;
+        }
+
+        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
+        priv->int_mask = 0;
+        iowrite32(priv->int_mask, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
+        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
+        iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);
+
+        rc = request_irq(priv->pdev->irq, &mwl8k_interrupt,
+                         IRQF_SHARED, MWL8K_NAME, hw);
+        if (rc) {
+                printk(KERN_ERR "%s: failed to register IRQ handler\n",
+                       priv->name);
+                goto err_free_queues;
+        }
+
+        /* Reset firmware and hardware */
+        mwl8k_hw_reset(priv);
+
+        /* Ask userland hotplug daemon for the device firmware */
+        rc = mwl8k_request_firmware(priv, (u32)id->driver_data);
+        if (rc) {
+                printk(KERN_ERR "%s: Firmware files not found\n", priv->name);
+                goto err_free_irq;
+        }
+
+        /* Load firmware into hardware */
+        rc = mwl8k_load_firmware(priv);
+        if (rc) {
+                printk(KERN_ERR "%s: Cannot start firmware\n", priv->name);
+                goto err_stop_firmware;
+        }
+
+        /* Reclaim memory once firmware is successfully loaded */
+        mwl8k_release_firmware(priv);
+
+        /*
+         * Temporarily enable interrupts.  Initial firmware host
+         * commands use interrupts and avoids polling.  Disable
+         * interrupts when done.
+         */
+        priv->int_mask |= MWL8K_A2H_EVENTS;
+
+        iowrite32(priv->int_mask, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
+
+        /* Get config data, mac addrs etc */
+        rc = mwl8k_cmd_get_hw_spec(hw);
+        if (rc) {
+                printk(KERN_ERR "%s: Cannot initialise firmware\n", priv->name);
+                goto err_stop_firmware;
+        }
+
+        /* Turn radio off */
+        rc = mwl8k_cmd_802_11_radio_control(hw, MWL8K_RADIO_DISABLE);
+        if (rc) {
+                printk(KERN_ERR "%s: Cannot disable\n", priv->name);
+                goto err_stop_firmware;
+        }
+
+        /* Disable interrupts */
+        spin_lock_irq(&priv->tx_lock);
+        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
+        spin_unlock_irq(&priv->tx_lock);
+        free_irq(priv->pdev->irq, hw);
+
+        rc = ieee80211_register_hw(hw);
+        if (rc) {
+                printk(KERN_ERR "%s: Cannot register device\n", priv->name);
+                goto err_stop_firmware;
+        }
+
+        fw = (u8 *)&priv->fw_rev;
+        printk(KERN_INFO "%s: 88W%u %s\n", priv->name, priv->part_num,
+                MWL8K_DESC);
+        printk(KERN_INFO "%s: Driver Ver:%s  Firmware Ver:%u.%u.%u.%u\n",
+                priv->name, MWL8K_VERSION, fw[3], fw[2], fw[1], fw[0]);
+        printk(KERN_INFO "%s: MAC Address: %s\n", priv->name,
+               print_mac(mac, hw->wiphy->perm_addr));
+
+        return 0;
+
+err_stop_firmware:
+        mwl8k_hw_reset(priv);
+        mwl8k_release_firmware(priv);
+
+err_free_irq:
+        spin_lock_irq(&priv->tx_lock);
+        iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
+        spin_unlock_irq(&priv->tx_lock);
+        free_irq(priv->pdev->irq, hw);
+
+err_free_queues:
+        for (i = 0; i < MWL8K_TX_QUEUES; i++)
+                mwl8k_txq_deinit(hw, i);
+        mwl8k_rxq_deinit(hw, 0);
+
+err_iounmap:
+        if (priv->cookie != NULL)
+                pci_free_consistent(priv->pdev, 4,
+                                priv->cookie, priv->cookie_dma);
+
+        if (priv->regs != NULL)
+                pci_iounmap(pdev, priv->regs);
+
+        if (priv->config_wq != NULL)
+                destroy_workqueue(priv->config_wq);
+
+        pci_set_drvdata(pdev, NULL);
+        ieee80211_free_hw(hw);
+
+err_free_reg:
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+
+        return rc;
+}
+
+static void __devexit mwl8k_remove(struct pci_dev *pdev)
+{
+        printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
+}
+
+static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
+{
+        struct ieee80211_hw *hw = pci_get_drvdata(pdev);
+        struct mwl8k_priv *priv;
+        int i;
+
+        if (hw == NULL)
+                return;
+        priv = hw->priv;
+
+        ieee80211_stop_queues(hw);
+
+        /* Remove tx reclaim tasklet */
+        tasklet_kill(&priv->tx_reclaim_task);
+
+        /* Stop config thread */
+        destroy_workqueue(priv->config_wq);
+
+        /* Stop hardware */
+        mwl8k_hw_reset(priv);
+
+        /* Return all skbs to mac80211 */
+        for (i = 0; i < MWL8K_TX_QUEUES; i++)
+                mwl8k_txq_reclaim(hw, i, 1);
+
+        ieee80211_unregister_hw(hw);
+
+        for (i = 0; i < MWL8K_TX_QUEUES; i++)
+                mwl8k_txq_deinit(hw, i);
+
+        mwl8k_rxq_deinit(hw, 0);
+
+        pci_free_consistent(priv->pdev, 4,
+                                priv->cookie, priv->cookie_dma);
+
+        pci_iounmap(pdev, priv->regs);
+        pci_set_drvdata(pdev, NULL);
+        ieee80211_free_hw(hw);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+
+static struct pci_driver mwl8k_driver = {
+        .name           = MWL8K_NAME,
+        .id_table       = mwl8k_table,
+        .probe          = mwl8k_probe,
+        .remove         = __devexit_p(mwl8k_remove),
+        .shutdown       = __devexit_p(mwl8k_shutdown),
+};
+
+static int __init mwl8k_init(void)
+{
+        return pci_register_driver(&mwl8k_driver);
+}
+
+static void __exit mwl8k_exit(void)
+{
+        pci_unregister_driver(&mwl8k_driver);
+}
+
+module_init(mwl8k_init);
+module_exit(mwl8k_exit);
diff --git a/drivers/net/wireless/orinoco/fw.c b/drivers/net/wireless/orinoco/fw.c
index e7abb45d6753..1084b43e04bc 100644
--- a/drivers/net/wireless/orinoco/fw.c
+++ b/drivers/net/wireless/orinoco/fw.c
@@ -70,6 +70,19 @@ static const char *validate_fw(const struct orinoco_fw_header *hdr, size_t len)
         return NULL;
 }
 
+#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
+static inline const struct firmware *
+orinoco_cached_fw_get(struct orinoco_private *priv, bool primary)
+{
+        if (primary)
+                return priv->cached_pri_fw;
+        else
+                return priv->cached_fw;
+}
+#else
+#define orinoco_cached_fw_get(priv, primary) (NULL)
+#endif
+
 /* Download either STA or AP firmware into the card. */
 static int
 orinoco_dl_firmware(struct orinoco_private *priv,
@@ -107,7 +120,7 @@ orinoco_dl_firmware(struct orinoco_private *priv,
         if (err)
                 goto free;
 
-        if (!priv->cached_fw) {
+        if (!orinoco_cached_fw_get(priv, false)) {
                 err = request_firmware(&fw_entry, firmware, priv->dev);
 
                 if (err) {
@@ -117,7 +130,7 @@ orinoco_dl_firmware(struct orinoco_private *priv,
                         goto free;
                 }
         } else
-                fw_entry = priv->cached_fw;
+                fw_entry = orinoco_cached_fw_get(priv, false);
 
         hdr = (const struct orinoco_fw_header *) fw_entry->data;
 
@@ -170,7 +183,7 @@ orinoco_dl_firmware(struct orinoco_private *priv,
 
 abort:
         /* If we requested the firmware, release it. */
-        if (!priv->cached_fw)
+        if (!orinoco_cached_fw_get(priv, false))
                 release_firmware(fw_entry);
 
 free:
@@ -273,20 +286,20 @@ symbol_dl_firmware(struct orinoco_private *priv,
         int ret;
         const struct firmware *fw_entry;
 
-        if (!priv->cached_pri_fw) {
+        if (!orinoco_cached_fw_get(priv, true)) {
                 if (request_firmware(&fw_entry, fw->pri_fw, priv->dev) != 0) {
                         printk(KERN_ERR "%s: Cannot find firmware: %s\n",
                                dev->name, fw->pri_fw);
                         return -ENOENT;
                 }
         } else
-                fw_entry = priv->cached_pri_fw;
+                fw_entry = orinoco_cached_fw_get(priv, true);
 
         /* Load primary firmware */
         ret = symbol_dl_image(priv, fw, fw_entry->data,
                               fw_entry->data + fw_entry->size, 0);
 
-        if (!priv->cached_pri_fw)
+        if (!orinoco_cached_fw_get(priv, true))
                 release_firmware(fw_entry);
         if (ret) {
                 printk(KERN_ERR "%s: Primary firmware download failed\n",
@@ -294,19 +307,19 @@ symbol_dl_firmware(struct orinoco_private *priv,
                 return ret;
         }
 
-        if (!priv->cached_fw) {
+        if (!orinoco_cached_fw_get(priv, false)) {
                 if (request_firmware(&fw_entry, fw->sta_fw, priv->dev) != 0) {
                         printk(KERN_ERR "%s: Cannot find firmware: %s\n",
                                dev->name, fw->sta_fw);
                         return -ENOENT;
                 }
         } else
-                fw_entry = priv->cached_fw;
+                fw_entry = orinoco_cached_fw_get(priv, false);
 
         /* Load secondary firmware */
         ret = symbol_dl_image(priv, fw, fw_entry->data,
                               fw_entry->data + fw_entry->size, 1);
-        if (!priv->cached_fw)
+        if (!orinoco_cached_fw_get(priv, false))
                 release_firmware(fw_entry);
         if (ret) {
                 printk(KERN_ERR "%s: Secondary firmware download failed\n",
@@ -340,9 +353,9 @@ int orinoco_download(struct orinoco_private *priv)
         return err;
 }
 
+#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
 void orinoco_cache_fw(struct orinoco_private *priv, int ap)
 {
-#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
         const struct firmware *fw_entry = NULL;
         const char *pri_fw;
         const char *fw;
@@ -362,12 +375,10 @@ void orinoco_cache_fw(struct orinoco_private *priv, int ap)
                 if (request_firmware(&fw_entry, fw, priv->dev) == 0)
                         priv->cached_fw = fw_entry;
         }
-#endif
 }
 
 void orinoco_uncache_fw(struct orinoco_private *priv)
 {
-#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
         if (priv->cached_pri_fw)
                 release_firmware(priv->cached_pri_fw);
         if (priv->cached_fw)
@@ -375,5 +386,5 @@ void orinoco_uncache_fw(struct orinoco_private *priv)
 
         priv->cached_pri_fw = NULL;
         priv->cached_fw = NULL;
-#endif
 }
+#endif
diff --git a/drivers/net/wireless/orinoco/fw.h b/drivers/net/wireless/orinoco/fw.h
index 2290f0845d59..89fc26d25b06 100644
--- a/drivers/net/wireless/orinoco/fw.h
+++ b/drivers/net/wireless/orinoco/fw.h
@@ -10,7 +10,12 @@ struct orinoco_private;
 
 int orinoco_download(struct orinoco_private *priv);
 
+#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
 void orinoco_cache_fw(struct orinoco_private *priv, int ap);
 void orinoco_uncache_fw(struct orinoco_private *priv);
+#else
+#define orinoco_cache_fw(priv, ap) do { } while(0)
+#define orinoco_uncache_fw(priv) do { } while (0)
+#endif
 
 #endif /* _ORINOCO_FW_H_ */
diff --git a/drivers/net/wireless/orinoco/main.c b/drivers/net/wireless/orinoco/main.c
index e9b1db77a735..345593c4accb 100644
--- a/drivers/net/wireless/orinoco/main.c
+++ b/drivers/net/wireless/orinoco/main.c
@@ -2580,8 +2580,10 @@ struct net_device
         netif_carrier_off(dev);
         priv->last_linkstatus = 0xffff;
 
+#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
         priv->cached_pri_fw = NULL;
         priv->cached_fw = NULL;
+#endif
 
         /* Register PM notifiers */
         orinoco_register_pm_notifier(priv);
diff --git a/drivers/net/wireless/orinoco/orinoco.h b/drivers/net/wireless/orinoco/orinoco.h
index f3f94b28ce6d..8e5a72cc297f 100644
--- a/drivers/net/wireless/orinoco/orinoco.h
+++ b/drivers/net/wireless/orinoco/orinoco.h
@@ -159,9 +159,11 @@ struct orinoco_private {
         unsigned int tkip_cm_active:1;
         unsigned int key_mgmt:3;
 
+#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
         /* Cached in memory firmware to use during ->resume. */
         const struct firmware *cached_pri_fw;
         const struct firmware *cached_fw;
+#endif
 
         struct notifier_block pm_notifier;
 };
diff --git a/drivers/net/wireless/p54/p54.h b/drivers/net/wireless/p54/p54.h
index 94c3acd1fcaf..2dda5fe418b6 100644
--- a/drivers/net/wireless/p54/p54.h
+++ b/drivers/net/wireless/p54/p54.h
@@ -14,6 +14,10 @@
  * published by the Free Software Foundation.
  */
 
+#ifdef CONFIG_MAC80211_LEDS
+#include <linux/leds.h>
+#endif /* CONFIG_MAC80211_LEDS */
+
 enum p54_control_frame_types {
         P54_CONTROL_TYPE_SETUP = 0,
         P54_CONTROL_TYPE_SCAN,
@@ -112,6 +116,21 @@ enum fw_state {
         FW_STATE_RESETTING,
 };
 
+#ifdef CONFIG_MAC80211_LEDS
+
+#define P54_LED_MAX_NAME_LEN 31
+
+struct p54_led_dev {
+        struct ieee80211_hw *hw_dev;
+        struct led_classdev led_dev;
+        char name[P54_LED_MAX_NAME_LEN + 1];
+
+        unsigned int index;
+        unsigned int registered;
+};
+
+#endif /* CONFIG_MAC80211_LEDS */
+
 struct p54_common {
         struct ieee80211_hw *hw;
         u32 rx_start;
@@ -157,6 +176,12 @@ struct p54_common {
         struct completion eeprom_comp;
         u8 privacy_caps;
         u8 rx_keycache_size;
+        /* LED management */
+        #ifdef CONFIG_MAC80211_LEDS
+        struct p54_led_dev assoc_led;
+        struct p54_led_dev tx_led;
+        #endif /* CONFIG_MAC80211_LEDS */
+        u16 softled_state;              /* bit field of glowing LEDs */
 };
 
 int p54_rx(struct ieee80211_hw *dev, struct sk_buff *skb);
@@ -165,6 +190,7 @@ int p54_parse_firmware(struct ieee80211_hw *dev, const struct firmware *fw);
 int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len);
 int p54_read_eeprom(struct ieee80211_hw *dev);
 struct ieee80211_hw *p54_init_common(size_t priv_data_len);
+int p54_register_common(struct ieee80211_hw *dev, struct device *pdev);
 void p54_free_common(struct ieee80211_hw *dev);
 
 #endif /* P54_H */
diff --git a/drivers/net/wireless/p54/p54common.c b/drivers/net/wireless/p54/p54common.c
index 14438a642fdd..0a989834b70d 100644
--- a/drivers/net/wireless/p54/p54common.c
+++ b/drivers/net/wireless/p54/p54common.c
@@ -21,6 +21,9 @@
 #include <linux/etherdevice.h>
 
 #include <net/mac80211.h>
+#ifdef CONFIG_MAC80211_LEDS
+#include <linux/leds.h>
+#endif /* CONFIG_MAC80211_LEDS */
 
 #include "p54.h"
 #include "p54common.h"
@@ -735,10 +738,7 @@ static int p54_rx_data(struct ieee80211_hw *dev, struct sk_buff *skb)
                 return 0;
 
         if (!(hdr->flags & cpu_to_le16(P54_HDR_FLAG_DATA_IN_FCS_GOOD))) {
-                if (priv->filter_flags & FIF_FCSFAIL)
-                        rx_status.flag |= RX_FLAG_FAILED_FCS_CRC;
-                else
-                        return 0;
+                return 0;
         }
 
         if (hdr->decrypt_status == P54_DECRYPT_OK)
@@ -1680,7 +1680,7 @@ static int p54_setup_mac(struct ieee80211_hw *dev)
                         mode = P54_FILTER_TYPE_PROMISCUOUS;
                         break;
                 default:
-                        mode = P54_FILTER_TYPE_NONE;
+                        mode = P54_FILTER_TYPE_HIBERNATE;
                         break;
                 }
 
@@ -1693,7 +1693,7 @@ static int p54_setup_mac(struct ieee80211_hw *dev)
                     (mode != P54_FILTER_TYPE_PROMISCUOUS))
                         mode |= P54_FILTER_TYPE_TRANSPARENT;
         } else
-                mode = P54_FILTER_TYPE_RX_DISABLED;
+                mode = P54_FILTER_TYPE_HIBERNATE;
 
         setup->mac_mode = cpu_to_le16(mode);
         memcpy(setup->mac_addr, priv->mac_addr, ETH_ALEN);
@@ -1871,7 +1871,7 @@ static int p54_scan(struct ieee80211_hw *dev, u16 mode, u16 dwell)
         return -EINVAL;
 }
 
-static int p54_set_leds(struct ieee80211_hw *dev, int mode, int link, int act)
+static int p54_set_leds(struct ieee80211_hw *dev)
 {
         struct p54_common *priv = dev->priv;
         struct sk_buff *skb;
@@ -1882,11 +1882,11 @@ static int p54_set_leds(struct ieee80211_hw *dev, int mode, int link, int act)
         if (!skb)
                 return -ENOMEM;
 
-        led = (struct p54_led *)skb_put(skb, sizeof(*led));
-        led->mode = cpu_to_le16(mode);
-        led->led_permanent = cpu_to_le16(link);
-        led->led_temporary = cpu_to_le16(act);
-        led->duration = cpu_to_le16(1000);
+        led = (struct p54_led *) skb_put(skb, sizeof(*led));
+        led->flags = cpu_to_le16(0x0003);
+        led->mask[0] = led->mask[1] = cpu_to_le16(priv->softled_state);
+        led->delay[0] = cpu_to_le16(1);
+        led->delay[1] = cpu_to_le16(0);
         priv->tx(dev, skb);
         return 0;
 }
@@ -2070,6 +2070,9 @@ static int p54_start(struct ieee80211_hw *dev)
 
         queue_delayed_work(dev->workqueue, &priv->work, 0);
 
+        priv->softled_state = 0;
+        err = p54_set_leds(dev);
+
 out:
         mutex_unlock(&priv->conf_mutex);
         return err;
@@ -2082,6 +2085,9 @@ static void p54_stop(struct ieee80211_hw *dev)
 
         mutex_lock(&priv->conf_mutex);
         priv->mode = NL80211_IFTYPE_UNSPECIFIED;
+        priv->softled_state = 0;
+        p54_set_leds(dev);
+
         cancel_delayed_work_sync(&priv->work);
         if (priv->cached_beacon)
                 p54_tx_cancel(dev, priv->cached_beacon);
@@ -2119,7 +2125,6 @@ static int p54_add_interface(struct ieee80211_hw *dev,
 
         memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
         p54_setup_mac(dev);
-        p54_set_leds(dev, 1, 0, 0);
         mutex_unlock(&priv->conf_mutex);
         return 0;
 }
@@ -2199,8 +2204,6 @@ static int p54_config_interface(struct ieee80211_hw *dev,
                         goto out;
         }
 
-        ret = p54_set_leds(dev, 1, !is_multicast_ether_addr(priv->bssid), 0);
-
 out:
         mutex_unlock(&priv->conf_mutex);
         return ret;
@@ -2214,9 +2217,7 @@ static void p54_configure_filter(struct ieee80211_hw *dev,
         struct p54_common *priv = dev->priv;
 
         *total_flags &= FIF_PROMISC_IN_BSS |
-                        FIF_OTHER_BSS |
-                        (*total_flags & FIF_PROMISC_IN_BSS ?
-                                FIF_FCSFAIL : 0);
+                        FIF_OTHER_BSS;
 
         priv->filter_flags = *total_flags;
 
@@ -2419,6 +2420,96 @@ static int p54_set_key(struct ieee80211_hw *dev, enum set_key_cmd cmd,
         return 0;
 }
 
+#ifdef CONFIG_MAC80211_LEDS
+static void p54_led_brightness_set(struct led_classdev *led_dev,
+                                   enum led_brightness brightness)
+{
+        struct p54_led_dev *led = container_of(led_dev, struct p54_led_dev,
+                                               led_dev);
+        struct ieee80211_hw *dev = led->hw_dev;
+        struct p54_common *priv = dev->priv;
+        int err;
+
+        /* Don't toggle the LED, when the device is down. */
+        if (priv->mode == NL80211_IFTYPE_UNSPECIFIED)
+                return ;
+
+        if (brightness != LED_OFF)
+                priv->softled_state |= BIT(led->index);
+        else
+                priv->softled_state &= ~BIT(led->index);
+
+        err = p54_set_leds(dev);
+        if (err && net_ratelimit())
+                printk(KERN_ERR "%s: failed to update %s LED.\n",
+                        wiphy_name(dev->wiphy), led_dev->name);
+}
+
+static int p54_register_led(struct ieee80211_hw *dev,
+                            struct p54_led_dev *led,
+                            unsigned int led_index,
+                            char *name, char *trigger)
+{
+        int err;
+
+        if (led->registered)
+                return -EEXIST;
+
+        snprintf(led->name, sizeof(led->name), "p54-%s::%s",
+                 wiphy_name(dev->wiphy), name);
+        led->hw_dev = dev;
+        led->index = led_index;
+        led->led_dev.name = led->name;
+        led->led_dev.default_trigger = trigger;
+        led->led_dev.brightness_set = p54_led_brightness_set;
+
+        err = led_classdev_register(wiphy_dev(dev->wiphy), &led->led_dev);
+        if (err)
+                printk(KERN_ERR "%s: Failed to register %s LED.\n",
+                        wiphy_name(dev->wiphy), name);
+        else
+                led->registered = 1;
+
+        return err;
+}
+
+static int p54_init_leds(struct ieee80211_hw *dev)
+{
+        struct p54_common *priv = dev->priv;
+        int err;
+
+        /*
+         * TODO:
+         * Figure out if the EEPROM contains some hints about the number
+         * of available/programmable LEDs of the device.
+         * But for now, we can assume that we have two programmable LEDs.
+         */
+
+        err = p54_register_led(dev, &priv->assoc_led, 0, "assoc",
+                               ieee80211_get_assoc_led_name(dev));
+        if (err)
+                return err;
+
+        err = p54_register_led(dev, &priv->tx_led, 1, "tx",
+                               ieee80211_get_tx_led_name(dev));
+        if (err)
+                return err;
+
+        err = p54_set_leds(dev);
+        return err;
+}
+
+static void p54_unregister_leds(struct ieee80211_hw *dev)
+{
+        struct p54_common *priv = dev->priv;
+
+        if (priv->tx_led.registered)
+                led_classdev_unregister(&priv->tx_led.led_dev);
+        if (priv->assoc_led.registered)
+                led_classdev_unregister(&priv->assoc_led.led_dev);
+}
+#endif /* CONFIG_MAC80211_LEDS */
+
 static const struct ieee80211_ops p54_ops = {
         .tx                     = p54_tx,
         .start                  = p54_start,
@@ -2452,6 +2543,8 @@ struct ieee80211_hw *p54_init_common(size_t priv_data_len)
         priv->basic_rate_mask = 0x15f;
         skb_queue_head_init(&priv->tx_queue);
         dev->flags = IEEE80211_HW_RX_INCLUDES_FCS |
+                     IEEE80211_HW_SUPPORTS_PS |
+                     IEEE80211_HW_PS_NULLFUNC_STACK |
                      IEEE80211_HW_SIGNAL_DBM |
                      IEEE80211_HW_NOISE_DBM;
 
@@ -2489,12 +2582,37 @@ struct ieee80211_hw *p54_init_common(size_t priv_data_len)
 }
 EXPORT_SYMBOL_GPL(p54_init_common);
 
+int p54_register_common(struct ieee80211_hw *dev, struct device *pdev)
+{
+        int err;
+
+        err = ieee80211_register_hw(dev);
+        if (err) {
+                dev_err(pdev, "Cannot register device (%d).\n", err);
+                return err;
+        }
+
+        #ifdef CONFIG_MAC80211_LEDS
+        err = p54_init_leds(dev);
+        if (err)
+                return err;
+        #endif /* CONFIG_MAC80211_LEDS */
+
+        dev_info(pdev, "is registered as '%s'\n", wiphy_name(dev->wiphy));
+        return 0;
+}
+EXPORT_SYMBOL_GPL(p54_register_common);
+
 void p54_free_common(struct ieee80211_hw *dev)
 {
         struct p54_common *priv = dev->priv;
         kfree(priv->iq_autocal);
         kfree(priv->output_limit);
         kfree(priv->curve_data);
+
+        #ifdef CONFIG_MAC80211_LEDS
+        p54_unregister_leds(dev);
+        #endif /* CONFIG_MAC80211_LEDS */
 }
 EXPORT_SYMBOL_GPL(p54_free_common);
 
diff --git a/drivers/net/wireless/p54/p54common.h b/drivers/net/wireless/p54/p54common.h
index def23b1f49ec..75ead7a150fc 100644
--- a/drivers/net/wireless/p54/p54common.h
+++ b/drivers/net/wireless/p54/p54common.h
@@ -515,10 +515,9 @@ struct p54_scan_tail_rate {
 } __attribute__ ((packed));
 
 struct p54_led {
-        __le16 mode;
-        __le16 led_temporary;
-        __le16 led_permanent;
-        __le16 duration;
+        __le16 flags;
+        __le16 mask[2];
+        __le16 delay[2];
 } __attribute__ ((packed));
 
 struct p54_edcf {
diff --git a/drivers/net/wireless/p54/p54pci.c b/drivers/net/wireless/p54/p54pci.c
index 3f9a6b04ea95..e3569a0a952d 100644
--- a/drivers/net/wireless/p54/p54pci.c
+++ b/drivers/net/wireless/p54/p54pci.c
@@ -413,8 +413,7 @@ static int p54p_open(struct ieee80211_hw *dev)
         err = request_irq(priv->pdev->irq, &p54p_interrupt,
                           IRQF_SHARED, "p54pci", dev);
         if (err) {
-                printk(KERN_ERR "%s: failed to register IRQ handler\n",
-                       wiphy_name(dev->wiphy));
+                dev_err(&priv->pdev->dev, "failed to register IRQ handler\n");
                 return err;
         }
 
@@ -476,30 +475,26 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
 
         err = pci_enable_device(pdev);
         if (err) {
-                printk(KERN_ERR "%s (p54pci): Cannot enable new PCI device\n",
-                       pci_name(pdev));
+                dev_err(&pdev->dev, "Cannot enable new PCI device\n");
                 return err;
         }
 
         mem_addr = pci_resource_start(pdev, 0);
         mem_len = pci_resource_len(pdev, 0);
         if (mem_len < sizeof(struct p54p_csr)) {
-                printk(KERN_ERR "%s (p54pci): Too short PCI resources\n",
-                       pci_name(pdev));
+                dev_err(&pdev->dev, "Too short PCI resources\n");
                 goto err_disable_dev;
         }
 
         err = pci_request_regions(pdev, "p54pci");
         if (err) {
-                printk(KERN_ERR "%s (p54pci): Cannot obtain PCI resources\n",
-                       pci_name(pdev));
+                dev_err(&pdev->dev, "Cannot obtain PCI resources\n");
                 goto err_disable_dev;
         }
 
         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) ||
             pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
-                printk(KERN_ERR "%s (p54pci): No suitable DMA available\n",
-                       pci_name(pdev));
+                dev_err(&pdev->dev, "No suitable DMA available\n");
                 goto err_free_reg;
         }
 
@@ -511,8 +506,7 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
 
         dev = p54_init_common(sizeof(*priv));
         if (!dev) {
-                printk(KERN_ERR "%s (p54pci): ieee80211 alloc failed\n",
-                       pci_name(pdev));
+                dev_err(&pdev->dev, "ieee80211 alloc failed\n");
                 err = -ENOMEM;
                 goto err_free_reg;
         }
@@ -525,17 +519,15 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
 
         priv->map = ioremap(mem_addr, mem_len);
         if (!priv->map) {
-                printk(KERN_ERR "%s (p54pci): Cannot map device memory\n",
-                       pci_name(pdev));
-                err = -EINVAL;  // TODO: use a better error code?
+                dev_err(&pdev->dev, "Cannot map device memory\n");
+                err = -ENOMEM;
                 goto err_free_dev;
         }
 
         priv->ring_control = pci_alloc_consistent(pdev, sizeof(*priv->ring_control),
                                                   &priv->ring_control_dma);
         if (!priv->ring_control) {
-                printk(KERN_ERR "%s (p54pci): Cannot allocate rings\n",
-                       pci_name(pdev));
+                dev_err(&pdev->dev, "Cannot allocate rings\n");
                 err = -ENOMEM;
                 goto err_iounmap;
         }
@@ -549,8 +541,7 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
         err = request_firmware(&priv->firmware, "isl3886pci",
                                &priv->pdev->dev);
         if (err) {
-                printk(KERN_ERR "%s (p54pci): cannot find firmware "
-                        "(isl3886pci)\n", pci_name(priv->pdev));
+                dev_err(&pdev->dev, "Cannot find firmware (isl3886pci)\n");
                 err = request_firmware(&priv->firmware, "isl3886",
                                        &priv->pdev->dev);
                 if (err)
@@ -565,12 +556,9 @@ static int __devinit p54p_probe(struct pci_dev *pdev,
         if (err)
                 goto err_free_common;
 
-        err = ieee80211_register_hw(dev);
-        if (err) {
-                printk(KERN_ERR "%s (p54pci): Cannot register netdevice\n",
-                       pci_name(pdev));
+        err = p54_register_common(dev, &pdev->dev);
+        if (err)
                 goto err_free_common;
-        }
 
         return 0;
 
diff --git a/drivers/net/wireless/p54/p54spi.c b/drivers/net/wireless/p54/p54spi.c
index 7fde243b3d5d..2b222aaa6f0a 100644
--- a/drivers/net/wireless/p54/p54spi.c
+++ b/drivers/net/wireless/p54/p54spi.c
@@ -694,15 +694,10 @@ static int __devinit p54spi_probe(struct spi_device *spi)
         if (ret)
                 goto err_free_common;
 
-        ret = ieee80211_register_hw(hw);
-        if (ret) {
-                dev_err(&priv->spi->dev, "unable to register "
-                                         "mac80211 hw: %d", ret);
+        ret = p54_register_common(hw, &priv->spi->dev);
+        if (ret)
                 goto err_free_common;
-        }
 
-        dev_info(&priv->spi->dev, "device is bound to %s\n",
-                 wiphy_name(hw->wiphy));
         return 0;
 
 err_free_common:
diff --git a/drivers/net/wireless/p54/p54usb.c b/drivers/net/wireless/p54/p54usb.c
index 9539ddcf379f..da6640afc835 100644
--- a/drivers/net/wireless/p54/p54usb.c
+++ b/drivers/net/wireless/p54/p54usb.c
@@ -976,11 +976,9 @@ static int __devinit p54u_probe(struct usb_interface *intf,
         if (err)
                 goto err_free_dev;
 
-        err = ieee80211_register_hw(dev);
-        if (err) {
-                dev_err(&udev->dev, "(p54usb) Cannot register netdevice\n");
+        err = p54_register_common(dev, &udev->dev);
+        if (err)
                 goto err_free_dev;
-        }
 
         return 0;
 
@@ -1024,6 +1022,7 @@ static struct usb_driver p54u_driver = {
         .disconnect = p54u_disconnect,
         .pre_reset = p54u_pre_reset,
         .post_reset = p54u_post_reset,
+        .soft_unbind = 1,
 };
 
 static int __init p54u_init(void)
diff --git a/drivers/net/wireless/ray_cs.c b/drivers/net/wireless/ray_cs.c
index 99ec7d622518..7370edb4e0ce 100644
--- a/drivers/net/wireless/ray_cs.c
+++ b/drivers/net/wireless/ray_cs.c
@@ -8,7 +8,7 @@
  * Copyright (c) 1998  Corey Thomas (corey@world.std.com)
  *
  * This driver is free software; you can redistribute it and/or modify
- * it under the terms of version 2 only of the GNU General Public License as 
+ * it under the terms of version 2 only of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * It is distributed in the hope that it will be useful,
@@ -27,7 +27,7 @@
  *
  * Daniele Bellucci <bellucda@tiscali.it> - 07/10/2003
  * - Audit copy_to_user in ioctl(SIOCGIWESSID)
- * 
+ *
 =============================================================================*/
 
 #include <linux/module.h>
@@ -65,8 +65,8 @@
 /* Warning : these stuff will slow down the driver... */
 #define WIRELESS_SPY            /* Enable spying addresses */
 /* Definitions we need for spy */
-typedef struct iw_statistics    iw_stats;
-typedef u_char  mac_addr[ETH_ALEN];     /* Hardware address */
+typedef struct iw_statistics iw_stats;
+typedef u_char mac_addr[ETH_ALEN];      /* Hardware address */
 
 #include "rayctl.h"
 #include "ray_cs.h"
@@ -86,7 +86,7 @@ static int ray_debug;
 static int pc_debug = PCMCIA_DEBUG;
 module_param(pc_debug, int, 0);
 /* #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args); */
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(args);
+#define DEBUG(n, args...) if (pc_debug > (n)) printk(args);
 #else
 #define DEBUG(n, args...)
 #endif
@@ -108,12 +108,12 @@ static int ray_dev_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static void set_multicast_list(struct net_device *dev);
 static void ray_update_multi_list(struct net_device *dev, int all);
 static int translate_frame(ray_dev_t *local, struct tx_msg __iomem *ptx,
-                unsigned char *data, int len);
-static void ray_build_header(ray_dev_t *local, struct tx_msg __iomem *ptx, UCHAR msg_type,
-                unsigned char *data);
+                           unsigned char *data, int len);
+static void ray_build_header(ray_dev_t *local, struct tx_msg __iomem *ptx,
+                             UCHAR msg_type, unsigned char *data);
 static void untranslate(ray_dev_t *local, struct sk_buff *skb, int len);
-static iw_stats * ray_get_wireless_stats(struct net_device *    dev);
-static const struct iw_handler_def      ray_handler_def;
+static iw_stats *ray_get_wireless_stats(struct net_device *dev);
+static const struct iw_handler_def ray_handler_def;
 
 /***** Prototypes for raylink functions **************************************/
 static int asc_to_int(char a);
@@ -124,7 +124,7 @@ static int get_free_ccs(ray_dev_t *local);
 static int get_free_tx_ccs(ray_dev_t *local);
 static void init_startup_params(ray_dev_t *local);
 static int parse_addr(char *in_str, UCHAR *out);
-static int ray_hw_xmit(unsigned char* data, int len, struct net_device* dev, UCHAR type);
+static int ray_hw_xmit(unsigned char *data, int len, struct net_device *dev, UCHAR type);
 static int ray_init(struct net_device *dev);
 static int interrupt_ecf(ray_dev_t *local, int ccs);
 static void ray_reset(struct net_device *dev);
@@ -132,17 +132,17 @@ static void ray_update_parm(struct net_device *dev, UCHAR objid, UCHAR *value, i
 static void verify_dl_startup(u_long);
 
 /* Prototypes for interrpt time functions **********************************/
-static irqreturn_t ray_interrupt (int reg, void *dev_id);
+static irqreturn_t ray_interrupt(int reg, void *dev_id);
 static void clear_interrupt(ray_dev_t *local);
-static void rx_deauthenticate(ray_dev_t *local, struct rcs __iomem *prcs, 
-                       unsigned int pkt_addr, int rx_len);
+static void rx_deauthenticate(ray_dev_t *local, struct rcs __iomem *prcs,
+                              unsigned int pkt_addr, int rx_len);
 static int copy_from_rx_buff(ray_dev_t *local, UCHAR *dest, int pkt_addr, int len);
 static void ray_rx(struct net_device *dev, ray_dev_t *local, struct rcs __iomem *prcs);
 static void release_frag_chain(ray_dev_t *local, struct rcs __iomem *prcs);
 static void rx_authenticate(ray_dev_t *local, struct rcs __iomem *prcs,
-                     unsigned int pkt_addr, int rx_len);
-static void rx_data(struct net_device *dev, struct rcs __iomem *prcs, unsigned int pkt_addr, 
-             int rx_len);
+                            unsigned int pkt_addr, int rx_len);
+static void rx_data(struct net_device *dev, struct rcs __iomem *prcs,
+                    unsigned int pkt_addr, int rx_len);
 static void associate(ray_dev_t *local);
 
 /* Card command functions */
@@ -219,82 +219,84 @@ module_param(phy_addr, charp, 0);
 module_param(ray_mem_speed, int, 0);
 
 static UCHAR b5_default_startup_parms[] = {
-    0,   0,                         /* Adhoc station */
-   'L','I','N','U','X', 0,  0,  0,  /* 32 char ESSID */
-    0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,
-    1,  0,                          /* Active scan, CA Mode */
-    0,  0,  0,  0,  0,  0,          /* No default MAC addr  */
-    0x7f, 0xff,                     /* Frag threshold */
-    0x00, 0x80,                     /* Hop time 128 Kus*/
-    0x01, 0x00,                     /* Beacon period 256 Kus */
-    0x01, 0x07, 0xa3,               /* DTIM, retries, ack timeout*/
-    0x1d, 0x82, 0x4e,               /* SIFS, DIFS, PIFS */
-    0x7f, 0xff,                     /* RTS threshold */
-    0x04, 0xe2, 0x38, 0xA4,         /* scan_dwell, max_scan_dwell */
-    0x05,                           /* assoc resp timeout thresh */
-    0x08, 0x02, 0x08,               /* adhoc, infra, super cycle max*/
-    0,                              /* Promiscuous mode */
-    0x0c, 0x0bd,                    /* Unique word */
-    0x32,                           /* Slot time */
-    0xff, 0xff,                     /* roam-low snr, low snr count */
-    0x05, 0xff,                     /* Infra, adhoc missed bcn thresh */
-    0x01, 0x0b, 0x4f,               /* USA, hop pattern, hop pat length */
+        0, 0,                   /* Adhoc station */
+        'L', 'I', 'N', 'U', 'X', 0, 0, 0,       /* 32 char ESSID */
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 0,                   /* Active scan, CA Mode */
+        0, 0, 0, 0, 0, 0,       /* No default MAC addr  */
+        0x7f, 0xff,             /* Frag threshold */
+        0x00, 0x80,             /* Hop time 128 Kus */
+        0x01, 0x00,             /* Beacon period 256 Kus */
+        0x01, 0x07, 0xa3,       /* DTIM, retries, ack timeout */
+        0x1d, 0x82, 0x4e,       /* SIFS, DIFS, PIFS */
+        0x7f, 0xff,             /* RTS threshold */
+        0x04, 0xe2, 0x38, 0xA4, /* scan_dwell, max_scan_dwell */
+        0x05,                   /* assoc resp timeout thresh */
+        0x08, 0x02, 0x08,       /* adhoc, infra, super cycle max */
+        0,                      /* Promiscuous mode */
+        0x0c, 0x0bd,            /* Unique word */
+        0x32,                   /* Slot time */
+        0xff, 0xff,             /* roam-low snr, low snr count */
+        0x05, 0xff,             /* Infra, adhoc missed bcn thresh */
+        0x01, 0x0b, 0x4f,       /* USA, hop pattern, hop pat length */
 /* b4 - b5 differences start here */
-    0x00, 0x3f,                     /* CW max */
-    0x00, 0x0f,                     /* CW min */
-    0x04, 0x08,                     /* Noise gain, limit offset */
-    0x28, 0x28,                     /* det rssi, med busy offsets */
-    7,                              /* det sync thresh */
-    0, 2, 2,                        /* test mode, min, max */
-    0,                              /* allow broadcast SSID probe resp */
-    0, 0,                           /* privacy must start, can join */
-    2, 0, 0, 0, 0, 0, 0, 0          /* basic rate set */
+        0x00, 0x3f,             /* CW max */
+        0x00, 0x0f,             /* CW min */
+        0x04, 0x08,             /* Noise gain, limit offset */
+        0x28, 0x28,             /* det rssi, med busy offsets */
+        7,                      /* det sync thresh */
+        0, 2, 2,                /* test mode, min, max */
+        0,                      /* allow broadcast SSID probe resp */
+        0, 0,                   /* privacy must start, can join */
+        2, 0, 0, 0, 0, 0, 0, 0  /* basic rate set */
 };
 
 static UCHAR b4_default_startup_parms[] = {
-    0,   0,                         /* Adhoc station */
-   'L','I','N','U','X', 0,  0,  0,  /* 32 char ESSID */
-    0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,
-    1,  0,                          /* Active scan, CA Mode */
-    0,  0,  0,  0,  0,  0,          /* No default MAC addr  */
-    0x7f, 0xff,                     /* Frag threshold */
-    0x02, 0x00,                     /* Hop time */
-    0x00, 0x01,                     /* Beacon period */
-    0x01, 0x07, 0xa3,               /* DTIM, retries, ack timeout*/
-    0x1d, 0x82, 0xce,               /* SIFS, DIFS, PIFS */
-    0x7f, 0xff,                     /* RTS threshold */
-    0xfb, 0x1e, 0xc7, 0x5c,         /* scan_dwell, max_scan_dwell */
-    0x05,                           /* assoc resp timeout thresh */
-    0x04, 0x02, 0x4,                /* adhoc, infra, super cycle max*/
-    0,                              /* Promiscuous mode */
-    0x0c, 0x0bd,                    /* Unique word */
-    0x4e,                           /* Slot time (TBD seems wrong)*/
-    0xff, 0xff,                     /* roam-low snr, low snr count */
-    0x05, 0xff,                     /* Infra, adhoc missed bcn thresh */
-    0x01, 0x0b, 0x4e,               /* USA, hop pattern, hop pat length */
+        0, 0,                   /* Adhoc station */
+        'L', 'I', 'N', 'U', 'X', 0, 0, 0,       /* 32 char ESSID */
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 0,                   /* Active scan, CA Mode */
+        0, 0, 0, 0, 0, 0,       /* No default MAC addr  */
+        0x7f, 0xff,             /* Frag threshold */
+        0x02, 0x00,             /* Hop time */
+        0x00, 0x01,             /* Beacon period */
+        0x01, 0x07, 0xa3,       /* DTIM, retries, ack timeout */
+        0x1d, 0x82, 0xce,       /* SIFS, DIFS, PIFS */
+        0x7f, 0xff,             /* RTS threshold */
+        0xfb, 0x1e, 0xc7, 0x5c, /* scan_dwell, max_scan_dwell */
+        0x05,                   /* assoc resp timeout thresh */
+        0x04, 0x02, 0x4,        /* adhoc, infra, super cycle max */
+        0,                      /* Promiscuous mode */
+        0x0c, 0x0bd,            /* Unique word */
+        0x4e,                   /* Slot time (TBD seems wrong) */
+        0xff, 0xff,             /* roam-low snr, low snr count */
+        0x05, 0xff,             /* Infra, adhoc missed bcn thresh */
+        0x01, 0x0b, 0x4e,       /* USA, hop pattern, hop pat length */
 /* b4 - b5 differences start here */
-    0x3f, 0x0f,                     /* CW max, min */
-    0x04, 0x08,                     /* Noise gain, limit offset */
-    0x28, 0x28,                     /* det rssi, med busy offsets */
-    7,                              /* det sync thresh */
-    0, 2, 2                         /* test mode, min, max*/
+        0x3f, 0x0f,             /* CW max, min */
+        0x04, 0x08,             /* Noise gain, limit offset */
+        0x28, 0x28,             /* det rssi, med busy offsets */
+        7,                      /* det sync thresh */
+        0, 2, 2                 /* test mode, min, max */
 };
+
 /*===========================================================================*/
-static unsigned char eth2_llc[] = {0xaa, 0xaa, 3, 0, 0, 0};
+static unsigned char eth2_llc[] = { 0xaa, 0xaa, 3, 0, 0, 0 };
 
 static char hop_pattern_length[] = { 1,
-             USA_HOP_MOD,             EUROPE_HOP_MOD,
-             JAPAN_HOP_MOD,           KOREA_HOP_MOD,
-             SPAIN_HOP_MOD,           FRANCE_HOP_MOD,
-             ISRAEL_HOP_MOD,          AUSTRALIA_HOP_MOD,
-             JAPAN_TEST_HOP_MOD
+        USA_HOP_MOD, EUROPE_HOP_MOD,
+        JAPAN_HOP_MOD, KOREA_HOP_MOD,
+        SPAIN_HOP_MOD, FRANCE_HOP_MOD,
+        ISRAEL_HOP_MOD, AUSTRALIA_HOP_MOD,
+        JAPAN_TEST_HOP_MOD
 };
 
-static char rcsid[] = "Raylink/WebGear wireless LAN - Corey <Thomas corey@world.std.com>";
+static char rcsid[] =
+    "Raylink/WebGear wireless LAN - Corey <Thomas corey@world.std.com>";
 
 /*=============================================================================
     ray_attach() creates an "instance" of the driver, allocating
@@ -306,71 +308,72 @@ static char rcsid[] = "Raylink/WebGear wireless LAN - Corey <Thomas corey@world.
 =============================================================================*/
 static int ray_probe(struct pcmcia_device *p_dev)
 {
-    ray_dev_t *local;
-    struct net_device *dev;
-
-    DEBUG(1, "ray_attach()\n");
-
-    /* Allocate space for private device-specific data */
-    dev = alloc_etherdev(sizeof(ray_dev_t));
-    if (!dev)
-            goto fail_alloc_dev;
-
-    local = netdev_priv(dev);
-    local->finder = p_dev;
-
-    /* The io structure describes IO port mapping. None used here */
-    p_dev->io.NumPorts1 = 0;
-    p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
-    p_dev->io.IOAddrLines = 5;
-
-    /* Interrupt setup. For PCMCIA, driver takes what's given */
-    p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
-    p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
-    p_dev->irq.Handler = &ray_interrupt;
-
-    /* General socket configuration */
-    p_dev->conf.Attributes = CONF_ENABLE_IRQ;
-    p_dev->conf.IntType = INT_MEMORY_AND_IO;
-    p_dev->conf.ConfigIndex = 1;
-
-    p_dev->priv = dev;
-    p_dev->irq.Instance = dev;
-    
-    local->finder = p_dev;
-    local->card_status = CARD_INSERTED;
-    local->authentication_state = UNAUTHENTICATED;
-    local->num_multi = 0;
-    DEBUG(2,"ray_attach p_dev = %p,  dev = %p,  local = %p, intr = %p\n",
-          p_dev,dev,local,&ray_interrupt);
-
-    /* Raylink entries in the device structure */
-    dev->hard_start_xmit = &ray_dev_start_xmit;
-    dev->set_config = &ray_dev_config;
-    dev->get_stats  = &ray_get_stats;
-    SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
-    dev->wireless_handlers = &ray_handler_def;
+        ray_dev_t *local;
+        struct net_device *dev;
+
+        DEBUG(1, "ray_attach()\n");
+
+        /* Allocate space for private device-specific data */
+        dev = alloc_etherdev(sizeof(ray_dev_t));
+        if (!dev)
+                goto fail_alloc_dev;
+
+        local = netdev_priv(dev);
+        local->finder = p_dev;
+
+        /* The io structure describes IO port mapping. None used here */
+        p_dev->io.NumPorts1 = 0;
+        p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
+        p_dev->io.IOAddrLines = 5;
+
+        /* Interrupt setup. For PCMCIA, driver takes what's given */
+        p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
+        p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
+        p_dev->irq.Handler = &ray_interrupt;
+
+        /* General socket configuration */
+        p_dev->conf.Attributes = CONF_ENABLE_IRQ;
+        p_dev->conf.IntType = INT_MEMORY_AND_IO;
+        p_dev->conf.ConfigIndex = 1;
+
+        p_dev->priv = dev;
+        p_dev->irq.Instance = dev;
+
+        local->finder = p_dev;
+        local->card_status = CARD_INSERTED;
+        local->authentication_state = UNAUTHENTICATED;
+        local->num_multi = 0;
+        DEBUG(2, "ray_attach p_dev = %p,  dev = %p,  local = %p, intr = %p\n",
+              p_dev, dev, local, &ray_interrupt);
+
+        /* Raylink entries in the device structure */
+        dev->hard_start_xmit = &ray_dev_start_xmit;
+        dev->set_config = &ray_dev_config;
+        dev->get_stats = &ray_get_stats;
+        SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
+        dev->wireless_handlers = &ray_handler_def;
 #ifdef WIRELESS_SPY
-    local->wireless_data.spy_data = &local->spy_data;
-    dev->wireless_data = &local->wireless_data;
-#endif  /* WIRELESS_SPY */
+        local->wireless_data.spy_data = &local->spy_data;
+        dev->wireless_data = &local->wireless_data;
+#endif /* WIRELESS_SPY */
 
-    dev->set_multicast_list = &set_multicast_list;
+        dev->set_multicast_list = &set_multicast_list;
 
-    DEBUG(2,"ray_cs ray_attach calling ether_setup.)\n");
-    dev->init = &ray_dev_init;
-    dev->open = &ray_open;
-    dev->stop = &ray_dev_close;
-    netif_stop_queue(dev);
+        DEBUG(2, "ray_cs ray_attach calling ether_setup.)\n");
+        dev->init = &ray_dev_init;
+        dev->open = &ray_open;
+        dev->stop = &ray_dev_close;
+        netif_stop_queue(dev);
 
-    init_timer(&local->timer);
+        init_timer(&local->timer);
 
-    this_device = p_dev;
-    return ray_config(p_dev);
+        this_device = p_dev;
+        return ray_config(p_dev);
 
 fail_alloc_dev:
-    return -ENOMEM;
+        return -ENOMEM;
 } /* ray_attach */
+
 /*=============================================================================
     This deletes a driver "instance".  The device is de-registered
     with Card Services.  If it has been released, all local data
@@ -379,25 +382,27 @@ fail_alloc_dev:
 =============================================================================*/
 static void ray_detach(struct pcmcia_device *link)
 {
-    struct net_device *dev;
-    ray_dev_t *local;
+        struct net_device *dev;
+        ray_dev_t *local;
 
-    DEBUG(1, "ray_detach(0x%p)\n", link);
+        DEBUG(1, "ray_detach(0x%p)\n", link);
 
-    this_device = NULL;
-    dev = link->priv;
+        this_device = NULL;
+        dev = link->priv;
 
-    ray_release(link);
+        ray_release(link);
 
-    local = netdev_priv(dev);
-    del_timer(&local->timer);
+        local = netdev_priv(dev);
+        del_timer(&local->timer);
 
-    if (link->priv) {
-        if (link->dev_node) unregister_netdev(dev);
-        free_netdev(dev);
-    }
-    DEBUG(2,"ray_cs ray_detach ending\n");
+        if (link->priv) {
+                if (link->dev_node)
+                        unregister_netdev(dev);
+                free_netdev(dev);
+        }
+        DEBUG(2, "ray_cs ray_detach ending\n");
 } /* ray_detach */
+
 /*=============================================================================
     ray_config() is run after a CARD_INSERTION event
     is received, to configure the PCMCIA socket, and to make the
@@ -408,92 +413,101 @@ do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 #define MAX_TUPLE_SIZE 128
 static int ray_config(struct pcmcia_device *link)
 {
-    int last_fn = 0, last_ret = 0;
-    int i;
-    win_req_t req;
-    memreq_t mem;
-    struct net_device *dev = (struct net_device *)link->priv;
-    ray_dev_t *local = netdev_priv(dev);
-
-    DEBUG(1, "ray_config(0x%p)\n", link);
-
-    /* Determine card type and firmware version */
-    printk(KERN_INFO "ray_cs Detected: %s%s%s%s\n",
-           link->prod_id[0] ? link->prod_id[0] : " ",
-           link->prod_id[1] ? link->prod_id[1] : " ",
-           link->prod_id[2] ? link->prod_id[2] : " ",
-           link->prod_id[3] ? link->prod_id[3] : " ");
-
-    /* Now allocate an interrupt line.  Note that this does not
-       actually assign a handler to the interrupt.
-    */
-    CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
-    dev->irq = link->irq.AssignedIRQ;
-    
-    /* This actually configures the PCMCIA socket -- setting up
-       the I/O windows and the interrupt mapping.
-    */
-    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
+        int last_fn = 0, last_ret = 0;
+        int i;
+        win_req_t req;
+        memreq_t mem;
+        struct net_device *dev = (struct net_device *)link->priv;
+        ray_dev_t *local = netdev_priv(dev);
+
+        DEBUG(1, "ray_config(0x%p)\n", link);
+
+        /* Determine card type and firmware version */
+        printk(KERN_INFO "ray_cs Detected: %s%s%s%s\n",
+               link->prod_id[0] ? link->prod_id[0] : " ",
+               link->prod_id[1] ? link->prod_id[1] : " ",
+               link->prod_id[2] ? link->prod_id[2] : " ",
+               link->prod_id[3] ? link->prod_id[3] : " ");
+
+        /* Now allocate an interrupt line.  Note that this does not
+           actually assign a handler to the interrupt.
+         */
+        CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
+        dev->irq = link->irq.AssignedIRQ;
+
+        /* This actually configures the PCMCIA socket -- setting up
+           the I/O windows and the interrupt mapping.
+         */
+        CS_CHECK(RequestConfiguration,
+                 pcmcia_request_configuration(link, &link->conf));
 
 /*** Set up 32k window for shared memory (transmit and control) ************/
-    req.Attributes = WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
-    req.Base = 0;
-    req.Size = 0x8000;
-    req.AccessSpeed = ray_mem_speed;
-    CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &link->win));
-    mem.CardOffset = 0x0000; mem.Page = 0;
-    CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
-    local->sram = ioremap(req.Base,req.Size);
+        req.Attributes =
+            WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
+        req.Base = 0;
+        req.Size = 0x8000;
+        req.AccessSpeed = ray_mem_speed;
+        CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &link->win));
+        mem.CardOffset = 0x0000;
+        mem.Page = 0;
+        CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
+        local->sram = ioremap(req.Base, req.Size);
 
 /*** Set up 16k window for shared memory (receive buffer) ***************/
-    req.Attributes = WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
-    req.Base = 0;
-    req.Size = 0x4000;
-    req.AccessSpeed = ray_mem_speed;
-    CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &local->rmem_handle));
-    mem.CardOffset = 0x8000; mem.Page = 0;
-    CS_CHECK(MapMemPage, pcmcia_map_mem_page(local->rmem_handle, &mem));
-    local->rmem = ioremap(req.Base,req.Size);
+        req.Attributes =
+            WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
+        req.Base = 0;
+        req.Size = 0x4000;
+        req.AccessSpeed = ray_mem_speed;
+        CS_CHECK(RequestWindow,
+                 pcmcia_request_window(&link, &req, &local->rmem_handle));
+        mem.CardOffset = 0x8000;
+        mem.Page = 0;
+        CS_CHECK(MapMemPage, pcmcia_map_mem_page(local->rmem_handle, &mem));
+        local->rmem = ioremap(req.Base, req.Size);
 
 /*** Set up window for attribute memory ***********************************/
-    req.Attributes = WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_AM | WIN_ENABLE | WIN_USE_WAIT;
-    req.Base = 0;
-    req.Size = 0x1000;
-    req.AccessSpeed = ray_mem_speed;
-    CS_CHECK(RequestWindow, pcmcia_request_window(&link, &req, &local->amem_handle));
-    mem.CardOffset = 0x0000; mem.Page = 0;
-    CS_CHECK(MapMemPage, pcmcia_map_mem_page(local->amem_handle, &mem));
-    local->amem = ioremap(req.Base,req.Size);
-
-    DEBUG(3,"ray_config sram=%p\n",local->sram);
-    DEBUG(3,"ray_config rmem=%p\n",local->rmem);
-    DEBUG(3,"ray_config amem=%p\n",local->amem);
-    if (ray_init(dev) < 0) {
-        ray_release(link);
-        return -ENODEV;
-    }
-
-    SET_NETDEV_DEV(dev, &handle_to_dev(link));
-    i = register_netdev(dev);
-    if (i != 0) {
-        printk("ray_config register_netdev() failed\n");
-        ray_release(link);
-        return i;
-    }
-
-    strcpy(local->node.dev_name, dev->name);
-    link->dev_node = &local->node;
-
-    printk(KERN_INFO "%s: RayLink, irq %d, hw_addr %pM\n",
-       dev->name, dev->irq, dev->dev_addr);
-
-    return 0;
+        req.Attributes =
+            WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_AM | WIN_ENABLE | WIN_USE_WAIT;
+        req.Base = 0;
+        req.Size = 0x1000;
+        req.AccessSpeed = ray_mem_speed;
+        CS_CHECK(RequestWindow,
+                 pcmcia_request_window(&link, &req, &local->amem_handle));
+        mem.CardOffset = 0x0000;
+        mem.Page = 0;
+        CS_CHECK(MapMemPage, pcmcia_map_mem_page(local->amem_handle, &mem));
+        local->amem = ioremap(req.Base, req.Size);
+
+        DEBUG(3, "ray_config sram=%p\n", local->sram);
+        DEBUG(3, "ray_config rmem=%p\n", local->rmem);
+        DEBUG(3, "ray_config amem=%p\n", local->amem);
+        if (ray_init(dev) < 0) {
+                ray_release(link);
+                return -ENODEV;
+        }
+
+        SET_NETDEV_DEV(dev, &handle_to_dev(link));
+        i = register_netdev(dev);
+        if (i != 0) {
+                printk("ray_config register_netdev() failed\n");
+                ray_release(link);
+                return i;
+        }
+
+        strcpy(local->node.dev_name, dev->name);
+        link->dev_node = &local->node;
+
+        printk(KERN_INFO "%s: RayLink, irq %d, hw_addr %pM\n",
+               dev->name, dev->irq, dev->dev_addr);
+
+        return 0;
 
 cs_failed:
-    cs_error(link, last_fn, last_ret);
+        cs_error(link, last_fn, last_ret);
 
-    ray_release(link);
-    return -ENODEV;
+        ray_release(link);
+        return -ENODEV;
 } /* ray_config */
 
 static inline struct ccs __iomem *ccs_base(ray_dev_t *dev)
@@ -516,267 +530,278 @@ static inline struct rcs __iomem *rcs_base(ray_dev_t *dev)
 /*===========================================================================*/
 static int ray_init(struct net_device *dev)
 {
-    int i;
-    UCHAR *p;
-    struct ccs __iomem *pccs;
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link = local->finder;
-    DEBUG(1, "ray_init(0x%p)\n", dev);
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(0,"ray_init - device not present\n");
-        return -1;
-    }
-
-    local->net_type = net_type;
-    local->sta_type = TYPE_STA;
-
-    /* Copy the startup results to local memory */
-    memcpy_fromio(&local->startup_res, local->sram + ECF_TO_HOST_BASE,\
-           sizeof(struct startup_res_6));
-
-    /* Check Power up test status and get mac address from card */
-    if (local->startup_res.startup_word != 0x80) {
-    printk(KERN_INFO "ray_init ERROR card status = %2x\n",
-           local->startup_res.startup_word);
-        local->card_status = CARD_INIT_ERROR;
-        return -1;
-    }
-
-    local->fw_ver = local->startup_res.firmware_version[0];
-    local->fw_bld = local->startup_res.firmware_version[1];
-    local->fw_var = local->startup_res.firmware_version[2];
-    DEBUG(1,"ray_init firmware version %d.%d \n",local->fw_ver, local->fw_bld);
-
-    local->tib_length = 0x20;
-    if ((local->fw_ver == 5) && (local->fw_bld >= 30))
-        local->tib_length = local->startup_res.tib_length;
-    DEBUG(2,"ray_init tib_length = 0x%02x\n", local->tib_length);
-    /* Initialize CCS's to buffer free state */
-    pccs = ccs_base(local);
-    for (i=0;  i<NUMBER_OF_CCS;  i++) {
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-    }
-    init_startup_params(local);
-
-    /* copy mac address to startup parameters */
-    if (parse_addr(phy_addr, local->sparm.b4.a_mac_addr))
-    {
-        p = local->sparm.b4.a_mac_addr;
-    }
-    else
-    {
-        memcpy(&local->sparm.b4.a_mac_addr,
-               &local->startup_res.station_addr, ADDRLEN);
-        p = local->sparm.b4.a_mac_addr;
-    }
-
-    clear_interrupt(local); /* Clear any interrupt from the card */
-    local->card_status = CARD_AWAITING_PARAM;
-    DEBUG(2,"ray_init ending\n");
-    return 0;
+        int i;
+        UCHAR *p;
+        struct ccs __iomem *pccs;
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+        DEBUG(1, "ray_init(0x%p)\n", dev);
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(0, "ray_init - device not present\n");
+                return -1;
+        }
+
+        local->net_type = net_type;
+        local->sta_type = TYPE_STA;
+
+        /* Copy the startup results to local memory */
+        memcpy_fromio(&local->startup_res, local->sram + ECF_TO_HOST_BASE,
+                      sizeof(struct startup_res_6));
+
+        /* Check Power up test status and get mac address from card */
+        if (local->startup_res.startup_word != 0x80) {
+                printk(KERN_INFO "ray_init ERROR card status = %2x\n",
+                       local->startup_res.startup_word);
+                local->card_status = CARD_INIT_ERROR;
+                return -1;
+        }
+
+        local->fw_ver = local->startup_res.firmware_version[0];
+        local->fw_bld = local->startup_res.firmware_version[1];
+        local->fw_var = local->startup_res.firmware_version[2];
+        DEBUG(1, "ray_init firmware version %d.%d \n", local->fw_ver,
+              local->fw_bld);
+
+        local->tib_length = 0x20;
+        if ((local->fw_ver == 5) && (local->fw_bld >= 30))
+                local->tib_length = local->startup_res.tib_length;
+        DEBUG(2, "ray_init tib_length = 0x%02x\n", local->tib_length);
+        /* Initialize CCS's to buffer free state */
+        pccs = ccs_base(local);
+        for (i = 0; i < NUMBER_OF_CCS; i++) {
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+        }
+        init_startup_params(local);
+
+        /* copy mac address to startup parameters */
+        if (parse_addr(phy_addr, local->sparm.b4.a_mac_addr)) {
+                p = local->sparm.b4.a_mac_addr;
+        } else {
+                memcpy(&local->sparm.b4.a_mac_addr,
+                       &local->startup_res.station_addr, ADDRLEN);
+                p = local->sparm.b4.a_mac_addr;
+        }
+
+        clear_interrupt(local); /* Clear any interrupt from the card */
+        local->card_status = CARD_AWAITING_PARAM;
+        DEBUG(2, "ray_init ending\n");
+        return 0;
 } /* ray_init */
+
 /*===========================================================================*/
 /* Download startup parameters to the card and command it to read them       */
 static int dl_startup_params(struct net_device *dev)
 {
-    int ccsindex;
-    ray_dev_t *local = netdev_priv(dev);
-    struct ccs __iomem *pccs;
-    struct pcmcia_device *link = local->finder;
-
-    DEBUG(1,"dl_startup_params entered\n");
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs dl_startup_params - device not present\n");
-        return -1;
-    }
-    
-    /* Copy parameters to host to ECF area */
-    if (local->fw_ver == 0x55) 
-        memcpy_toio(local->sram + HOST_TO_ECF_BASE, &local->sparm.b4,
-               sizeof(struct b4_startup_params));
-    else
-        memcpy_toio(local->sram + HOST_TO_ECF_BASE, &local->sparm.b5,
-               sizeof(struct b5_startup_params));
-
-    
-    /* Fill in the CCS fields for the ECF */
-    if ((ccsindex = get_free_ccs(local)) < 0) return -1;
-    local->dl_param_ccs = ccsindex;
-    pccs = ccs_base(local) + ccsindex;
-    writeb(CCS_DOWNLOAD_STARTUP_PARAMS, &pccs->cmd);
-    DEBUG(2,"dl_startup_params start ccsindex = %d\n", local->dl_param_ccs);
-    /* Interrupt the firmware to process the command */
-    if (interrupt_ecf(local, ccsindex)) {
-        printk(KERN_INFO "ray dl_startup_params failed - "
-           "ECF not ready for intr\n");
-        local->card_status = CARD_DL_PARAM_ERROR;
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-        return -2;
-    }
-    local->card_status = CARD_DL_PARAM;
-    /* Start kernel timer to wait for dl startup to complete. */
-    local->timer.expires = jiffies + HZ/2;
-    local->timer.data = (long)local;
-    local->timer.function = &verify_dl_startup;
-    add_timer(&local->timer);
-    DEBUG(2,"ray_cs dl_startup_params started timer for verify_dl_startup\n");
-    return 0;
+        int ccsindex;
+        ray_dev_t *local = netdev_priv(dev);
+        struct ccs __iomem *pccs;
+        struct pcmcia_device *link = local->finder;
+
+        DEBUG(1, "dl_startup_params entered\n");
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs dl_startup_params - device not present\n");
+                return -1;
+        }
+
+        /* Copy parameters to host to ECF area */
+        if (local->fw_ver == 0x55)
+                memcpy_toio(local->sram + HOST_TO_ECF_BASE, &local->sparm.b4,
+                            sizeof(struct b4_startup_params));
+        else
+                memcpy_toio(local->sram + HOST_TO_ECF_BASE, &local->sparm.b5,
+                            sizeof(struct b5_startup_params));
+
+        /* Fill in the CCS fields for the ECF */
+        if ((ccsindex = get_free_ccs(local)) < 0)
+                return -1;
+        local->dl_param_ccs = ccsindex;
+        pccs = ccs_base(local) + ccsindex;
+        writeb(CCS_DOWNLOAD_STARTUP_PARAMS, &pccs->cmd);
+        DEBUG(2, "dl_startup_params start ccsindex = %d\n",
+              local->dl_param_ccs);
+        /* Interrupt the firmware to process the command */
+        if (interrupt_ecf(local, ccsindex)) {
+                printk(KERN_INFO "ray dl_startup_params failed - "
+                       "ECF not ready for intr\n");
+                local->card_status = CARD_DL_PARAM_ERROR;
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+                return -2;
+        }
+        local->card_status = CARD_DL_PARAM;
+        /* Start kernel timer to wait for dl startup to complete. */
+        local->timer.expires = jiffies + HZ / 2;
+        local->timer.data = (long)local;
+        local->timer.function = &verify_dl_startup;
+        add_timer(&local->timer);
+        DEBUG(2,
+              "ray_cs dl_startup_params started timer for verify_dl_startup\n");
+        return 0;
 } /* dl_startup_params */
+
 /*===========================================================================*/
 static void init_startup_params(ray_dev_t *local)
 {
-    int i; 
-
-    if (country > JAPAN_TEST) country = USA;
-    else
-        if (country < USA) country = USA;
-    /* structure for hop time and beacon period is defined here using 
-     * New 802.11D6.1 format.  Card firmware is still using old format
-     * until version 6.
-     *    Before                    After
-     *    a_hop_time ms byte        a_hop_time ms byte
-     *    a_hop_time 2s byte        a_hop_time ls byte
-     *    a_hop_time ls byte        a_beacon_period ms byte
-     *    a_beacon_period           a_beacon_period ls byte
-     *
-     *    a_hop_time = uS           a_hop_time = KuS
-     *    a_beacon_period = hops    a_beacon_period = KuS
-     */                             /* 64ms = 010000 */
-    if (local->fw_ver == 0x55)  {
-        memcpy((UCHAR *)&local->sparm.b4, b4_default_startup_parms, 
-               sizeof(struct b4_startup_params));
-        /* Translate sane kus input values to old build 4/5 format */
-        /* i = hop time in uS truncated to 3 bytes */
-        i = (hop_dwell * 1024) & 0xffffff;
-        local->sparm.b4.a_hop_time[0] = (i >> 16) & 0xff;
-        local->sparm.b4.a_hop_time[1] = (i >> 8) & 0xff;
-        local->sparm.b4.a_beacon_period[0] = 0;
-        local->sparm.b4.a_beacon_period[1] =
-            ((beacon_period/hop_dwell) - 1) & 0xff;
-        local->sparm.b4.a_curr_country_code = country;
-        local->sparm.b4.a_hop_pattern_length = 
-            hop_pattern_length[(int)country] - 1;
-        if (bc)
-        {
-            local->sparm.b4.a_ack_timeout = 0x50;
-            local->sparm.b4.a_sifs = 0x3f;
-        }
-    }
-    else {    /* Version 5 uses real kus values */
-        memcpy((UCHAR *)&local->sparm.b5, b5_default_startup_parms, 
-               sizeof(struct b5_startup_params));
-
-        local->sparm.b5.a_hop_time[0] = (hop_dwell >> 8) & 0xff;
-        local->sparm.b5.a_hop_time[1] = hop_dwell & 0xff;
-        local->sparm.b5.a_beacon_period[0] = (beacon_period >> 8) & 0xff;
-        local->sparm.b5.a_beacon_period[1] = beacon_period & 0xff;
-        if (psm)
-            local->sparm.b5.a_power_mgt_state = 1;
-        local->sparm.b5.a_curr_country_code = country;
-        local->sparm.b5.a_hop_pattern_length = 
-            hop_pattern_length[(int)country];
-    }
-    
-    local->sparm.b4.a_network_type = net_type & 0x01;
-    local->sparm.b4.a_acting_as_ap_status = TYPE_STA;
-
-    if (essid != NULL)
-        strncpy(local->sparm.b4.a_current_ess_id, essid, ESSID_SIZE);
-} /* init_startup_params */ 
+        int i;
+
+        if (country > JAPAN_TEST)
+                country = USA;
+        else if (country < USA)
+                country = USA;
+        /* structure for hop time and beacon period is defined here using
+         * New 802.11D6.1 format.  Card firmware is still using old format
+         * until version 6.
+         *    Before                    After
+         *    a_hop_time ms byte        a_hop_time ms byte
+         *    a_hop_time 2s byte        a_hop_time ls byte
+         *    a_hop_time ls byte        a_beacon_period ms byte
+         *    a_beacon_period           a_beacon_period ls byte
+         *
+         *    a_hop_time = uS           a_hop_time = KuS
+         *    a_beacon_period = hops    a_beacon_period = KuS
+         *//* 64ms = 010000 */
+        if (local->fw_ver == 0x55) {
+                memcpy((UCHAR *) &local->sparm.b4, b4_default_startup_parms,
+                       sizeof(struct b4_startup_params));
+                /* Translate sane kus input values to old build 4/5 format */
+                /* i = hop time in uS truncated to 3 bytes */
+                i = (hop_dwell * 1024) & 0xffffff;
+                local->sparm.b4.a_hop_time[0] = (i >> 16) & 0xff;
+                local->sparm.b4.a_hop_time[1] = (i >> 8) & 0xff;
+                local->sparm.b4.a_beacon_period[0] = 0;
+                local->sparm.b4.a_beacon_period[1] =
+                    ((beacon_period / hop_dwell) - 1) & 0xff;
+                local->sparm.b4.a_curr_country_code = country;
+                local->sparm.b4.a_hop_pattern_length =
+                    hop_pattern_length[(int)country] - 1;
+                if (bc) {
+                        local->sparm.b4.a_ack_timeout = 0x50;
+                        local->sparm.b4.a_sifs = 0x3f;
+                }
+        } else { /* Version 5 uses real kus values */
+                memcpy((UCHAR *) &local->sparm.b5, b5_default_startup_parms,
+                       sizeof(struct b5_startup_params));
+
+                local->sparm.b5.a_hop_time[0] = (hop_dwell >> 8) & 0xff;
+                local->sparm.b5.a_hop_time[1] = hop_dwell & 0xff;
+                local->sparm.b5.a_beacon_period[0] =
+                    (beacon_period >> 8) & 0xff;
+                local->sparm.b5.a_beacon_period[1] = beacon_period & 0xff;
+                if (psm)
+                        local->sparm.b5.a_power_mgt_state = 1;
+                local->sparm.b5.a_curr_country_code = country;
+                local->sparm.b5.a_hop_pattern_length =
+                    hop_pattern_length[(int)country];
+        }
+
+        local->sparm.b4.a_network_type = net_type & 0x01;
+        local->sparm.b4.a_acting_as_ap_status = TYPE_STA;
+
+        if (essid != NULL)
+                strncpy(local->sparm.b4.a_current_ess_id, essid, ESSID_SIZE);
+} /* init_startup_params */
+
 /*===========================================================================*/
 static void verify_dl_startup(u_long data)
 {
-    ray_dev_t *local = (ray_dev_t *)data;
-    struct ccs __iomem *pccs = ccs_base(local) + local->dl_param_ccs;
-    UCHAR status;
-    struct pcmcia_device *link = local->finder;
+        ray_dev_t *local = (ray_dev_t *) data;
+        struct ccs __iomem *pccs = ccs_base(local) + local->dl_param_ccs;
+        UCHAR status;
+        struct pcmcia_device *link = local->finder;
 
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs verify_dl_startup - device not present\n");
-        return;
-    }
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs verify_dl_startup - device not present\n");
+                return;
+        }
 #ifdef PCMCIA_DEBUG
-    if (pc_debug > 2) {
-    int i;
-    printk(KERN_DEBUG "verify_dl_startup parameters sent via ccs %d:\n",
-           local->dl_param_ccs);
-        for (i=0; i<sizeof(struct b5_startup_params); i++) {
-            printk(" %2x", (unsigned int) readb(local->sram + HOST_TO_ECF_BASE + i));
-        }
-    printk("\n");
-    }
+        if (pc_debug > 2) {
+                int i;
+                printk(KERN_DEBUG
+                       "verify_dl_startup parameters sent via ccs %d:\n",
+                       local->dl_param_ccs);
+                for (i = 0; i < sizeof(struct b5_startup_params); i++) {
+                        printk(" %2x",
+                               (unsigned int)readb(local->sram +
+                                                   HOST_TO_ECF_BASE + i));
+                }
+                printk("\n");
+        }
 #endif
 
-    status = readb(&pccs->buffer_status);
-    if (status!= CCS_BUFFER_FREE)
-    {
-        printk(KERN_INFO "Download startup params failed.  Status = %d\n",
-           status);
-        local->card_status = CARD_DL_PARAM_ERROR;
-        return;
-    }
-    if (local->sparm.b4.a_network_type == ADHOC)
-        start_net((u_long)local);
-    else
-        join_net((u_long)local);
-
-    return;
+        status = readb(&pccs->buffer_status);
+        if (status != CCS_BUFFER_FREE) {
+                printk(KERN_INFO
+                       "Download startup params failed.  Status = %d\n",
+                       status);
+                local->card_status = CARD_DL_PARAM_ERROR;
+                return;
+        }
+        if (local->sparm.b4.a_network_type == ADHOC)
+                start_net((u_long) local);
+        else
+                join_net((u_long) local);
+
+        return;
 } /* end verify_dl_startup */
+
 /*===========================================================================*/
 /* Command card to start a network */
 static void start_net(u_long data)
 {
-    ray_dev_t *local = (ray_dev_t *)data;
-    struct ccs __iomem *pccs;
-    int ccsindex;
-    struct pcmcia_device *link = local->finder;
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs start_net - device not present\n");
-        return;
-    }
-    /* Fill in the CCS fields for the ECF */
-    if ((ccsindex = get_free_ccs(local)) < 0) return;
-    pccs = ccs_base(local) + ccsindex;
-    writeb(CCS_START_NETWORK, &pccs->cmd);
-    writeb(0, &pccs->var.start_network.update_param);
-    /* Interrupt the firmware to process the command */
-    if (interrupt_ecf(local, ccsindex)) {
-        DEBUG(1,"ray start net failed - card not ready for intr\n");
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-        return;
-    }
-    local->card_status = CARD_DOING_ACQ;
-    return;
+        ray_dev_t *local = (ray_dev_t *) data;
+        struct ccs __iomem *pccs;
+        int ccsindex;
+        struct pcmcia_device *link = local->finder;
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs start_net - device not present\n");
+                return;
+        }
+        /* Fill in the CCS fields for the ECF */
+        if ((ccsindex = get_free_ccs(local)) < 0)
+                return;
+        pccs = ccs_base(local) + ccsindex;
+        writeb(CCS_START_NETWORK, &pccs->cmd);
+        writeb(0, &pccs->var.start_network.update_param);
+        /* Interrupt the firmware to process the command */
+        if (interrupt_ecf(local, ccsindex)) {
+                DEBUG(1, "ray start net failed - card not ready for intr\n");
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+                return;
+        }
+        local->card_status = CARD_DOING_ACQ;
+        return;
 } /* end start_net */
+
 /*===========================================================================*/
 /* Command card to join a network */
 static void join_net(u_long data)
 {
-    ray_dev_t *local = (ray_dev_t *)data;
-
-    struct ccs __iomem *pccs;
-    int ccsindex;
-    struct pcmcia_device *link = local->finder;
-    
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs join_net - device not present\n");
-        return;
-    }
-    /* Fill in the CCS fields for the ECF */
-    if ((ccsindex = get_free_ccs(local)) < 0) return;
-    pccs = ccs_base(local) + ccsindex;
-    writeb(CCS_JOIN_NETWORK, &pccs->cmd);
-    writeb(0, &pccs->var.join_network.update_param);
-    writeb(0, &pccs->var.join_network.net_initiated);
-    /* Interrupt the firmware to process the command */
-    if (interrupt_ecf(local, ccsindex)) {
-        DEBUG(1,"ray join net failed - card not ready for intr\n");
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-        return;
-    }
-    local->card_status = CARD_DOING_ACQ;
-    return;
+        ray_dev_t *local = (ray_dev_t *) data;
+
+        struct ccs __iomem *pccs;
+        int ccsindex;
+        struct pcmcia_device *link = local->finder;
+
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs join_net - device not present\n");
+                return;
+        }
+        /* Fill in the CCS fields for the ECF */
+        if ((ccsindex = get_free_ccs(local)) < 0)
+                return;
+        pccs = ccs_base(local) + ccsindex;
+        writeb(CCS_JOIN_NETWORK, &pccs->cmd);
+        writeb(0, &pccs->var.join_network.update_param);
+        writeb(0, &pccs->var.join_network.net_initiated);
+        /* Interrupt the firmware to process the command */
+        if (interrupt_ecf(local, ccsindex)) {
+                DEBUG(1, "ray join net failed - card not ready for intr\n");
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+                return;
+        }
+        local->card_status = CARD_DOING_ACQ;
+        return;
 }
+
 /*============================================================================
     After a card is removed, ray_release() will unregister the net
     device, and release the PCMCIA configuration.  If the device is
@@ -784,25 +809,27 @@ static void join_net(u_long data)
 =============================================================================*/
 static void ray_release(struct pcmcia_device *link)
 {
-    struct net_device *dev = link->priv; 
-    ray_dev_t *local = netdev_priv(dev);
-    int i;
-    
-    DEBUG(1, "ray_release(0x%p)\n", link);
-
-    del_timer(&local->timer);
-
-    iounmap(local->sram);
-    iounmap(local->rmem);
-    iounmap(local->amem);
-    /* Do bother checking to see if these succeed or not */
-    i = pcmcia_release_window(local->amem_handle);
-    if ( i != 0 ) DEBUG(0,"ReleaseWindow(local->amem) ret = %x\n",i);
-    i = pcmcia_release_window(local->rmem_handle);
-    if ( i != 0 ) DEBUG(0,"ReleaseWindow(local->rmem) ret = %x\n",i);
-    pcmcia_disable_device(link);
-
-    DEBUG(2,"ray_release ending\n");
+        struct net_device *dev = link->priv;
+        ray_dev_t *local = netdev_priv(dev);
+        int i;
+
+        DEBUG(1, "ray_release(0x%p)\n", link);
+
+        del_timer(&local->timer);
+
+        iounmap(local->sram);
+        iounmap(local->rmem);
+        iounmap(local->amem);
+        /* Do bother checking to see if these succeed or not */
+        i = pcmcia_release_window(local->amem_handle);
+        if (i != 0)
+                DEBUG(0, "ReleaseWindow(local->amem) ret = %x\n", i);
+        i = pcmcia_release_window(local->rmem_handle);
+        if (i != 0)
+                DEBUG(0, "ReleaseWindow(local->rmem) ret = %x\n", i);
+        pcmcia_disable_device(link);
+
+        DEBUG(2, "ray_release ending\n");
 }
 
 static int ray_suspend(struct pcmcia_device *link)
@@ -831,237 +858,243 @@ static int ray_resume(struct pcmcia_device *link)
 static int ray_dev_init(struct net_device *dev)
 {
 #ifdef RAY_IMMEDIATE_INIT
-    int i;
-#endif  /* RAY_IMMEDIATE_INIT */
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link = local->finder;
-
-    DEBUG(1,"ray_dev_init(dev=%p)\n",dev);
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_dev_init - device not present\n");
-        return -1;
-    }
+        int i;
+#endif /* RAY_IMMEDIATE_INIT */
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+
+        DEBUG(1, "ray_dev_init(dev=%p)\n", dev);
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_dev_init - device not present\n");
+                return -1;
+        }
 #ifdef RAY_IMMEDIATE_INIT
-    /* Download startup parameters */
-    if ( (i = dl_startup_params(dev)) < 0)
-    {
-        printk(KERN_INFO "ray_dev_init dl_startup_params failed - "
-           "returns 0x%x\n",i);
-        return -1;
-    }
-#else   /* RAY_IMMEDIATE_INIT */
-    /* Postpone the card init so that we can still configure the card,
-     * for example using the Wireless Extensions. The init will happen
-     * in ray_open() - Jean II */
-    DEBUG(1,"ray_dev_init: postponing card init to ray_open() ; Status = %d\n",
-          local->card_status);
-#endif  /* RAY_IMMEDIATE_INIT */
-
-    /* copy mac and broadcast addresses to linux device */
-    memcpy(&dev->dev_addr, &local->sparm.b4.a_mac_addr, ADDRLEN);
-    memset(dev->broadcast, 0xff, ETH_ALEN);
-
-    DEBUG(2,"ray_dev_init ending\n");
-    return 0;
+        /* Download startup parameters */
+        if ((i = dl_startup_params(dev)) < 0) {
+                printk(KERN_INFO "ray_dev_init dl_startup_params failed - "
+                       "returns 0x%x\n", i);
+                return -1;
+        }
+#else /* RAY_IMMEDIATE_INIT */
+        /* Postpone the card init so that we can still configure the card,
+         * for example using the Wireless Extensions. The init will happen
+         * in ray_open() - Jean II */
+        DEBUG(1,
+              "ray_dev_init: postponing card init to ray_open() ; Status = %d\n",
+              local->card_status);
+#endif /* RAY_IMMEDIATE_INIT */
+
+        /* copy mac and broadcast addresses to linux device */
+        memcpy(&dev->dev_addr, &local->sparm.b4.a_mac_addr, ADDRLEN);
+        memset(dev->broadcast, 0xff, ETH_ALEN);
+
+        DEBUG(2, "ray_dev_init ending\n");
+        return 0;
 }
+
 /*===========================================================================*/
 static int ray_dev_config(struct net_device *dev, struct ifmap *map)
 {
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link = local->finder;
-    /* Dummy routine to satisfy device structure */
-    DEBUG(1,"ray_dev_config(dev=%p,ifmap=%p)\n",dev,map);
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_dev_config - device not present\n");
-        return -1;
-    }
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+        /* Dummy routine to satisfy device structure */
+        DEBUG(1, "ray_dev_config(dev=%p,ifmap=%p)\n", dev, map);
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_dev_config - device not present\n");
+                return -1;
+        }
 
-    return 0;
+        return 0;
 }
+
 /*===========================================================================*/
 static int ray_dev_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link = local->finder;
-    short length = skb->len;
-
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_dev_start_xmit - device not present\n");
-        return -1;
-    }
-    DEBUG(3,"ray_dev_start_xmit(skb=%p, dev=%p)\n",skb,dev);
-    if (local->authentication_state == NEED_TO_AUTH) {
-        DEBUG(0,"ray_cs Sending authentication request.\n");
-        if (!build_auth_frame (local, local->auth_id, OPEN_AUTH_REQUEST)) {
-            local->authentication_state = AUTHENTICATED;
-            netif_stop_queue(dev);
-            return 1;
-        }
-    }
-
-    if (length < ETH_ZLEN)
-    {
-        if (skb_padto(skb, ETH_ZLEN))
-                return 0;
-        length = ETH_ZLEN;
-    }
-    switch (ray_hw_xmit( skb->data, length, dev, DATA_TYPE)) {
-        case XMIT_NO_CCS:
-        case XMIT_NEED_AUTH:
-            netif_stop_queue(dev);
-            return 1;
-        case XMIT_NO_INTR:
-        case XMIT_MSG_BAD:
-        case XMIT_OK:
-        default:
-            dev->trans_start = jiffies;
-            dev_kfree_skb(skb);
-            return 0;
-    }
-    return 0;
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+        short length = skb->len;
+
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_dev_start_xmit - device not present\n");
+                return -1;
+        }
+        DEBUG(3, "ray_dev_start_xmit(skb=%p, dev=%p)\n", skb, dev);
+        if (local->authentication_state == NEED_TO_AUTH) {
+                DEBUG(0, "ray_cs Sending authentication request.\n");
+                if (!build_auth_frame(local, local->auth_id, OPEN_AUTH_REQUEST)) {
+                        local->authentication_state = AUTHENTICATED;
+                        netif_stop_queue(dev);
+                        return 1;
+                }
+        }
+
+        if (length < ETH_ZLEN) {
+                if (skb_padto(skb, ETH_ZLEN))
+                        return 0;
+                length = ETH_ZLEN;
+        }
+        switch (ray_hw_xmit(skb->data, length, dev, DATA_TYPE)) {
+        case XMIT_NO_CCS:
+        case XMIT_NEED_AUTH:
+                netif_stop_queue(dev);
+                return 1;
+        case XMIT_NO_INTR:
+        case XMIT_MSG_BAD:
+        case XMIT_OK:
+        default:
+                dev->trans_start = jiffies;
+                dev_kfree_skb(skb);
+                return 0;
+        }
+        return 0;
 } /* ray_dev_start_xmit */
+
 /*===========================================================================*/
-static int ray_hw_xmit(unsigned char* data, int len, struct net_device* dev, 
-                UCHAR msg_type)
-{
-    ray_dev_t *local = netdev_priv(dev);
-    struct ccs __iomem *pccs;
-    int ccsindex;
-    int offset;
-    struct tx_msg __iomem *ptx; /* Address of xmit buffer in PC space */
-    short int addr;     /* Address of xmit buffer in card space */
-    
-    DEBUG(3,"ray_hw_xmit(data=%p, len=%d, dev=%p)\n",data,len,dev);
-    if (len + TX_HEADER_LENGTH > TX_BUF_SIZE)
-    {
-        printk(KERN_INFO "ray_hw_xmit packet too large: %d bytes\n",len);
-        return XMIT_MSG_BAD;
-    }
+static int ray_hw_xmit(unsigned char *data, int len, struct net_device *dev,
+                       UCHAR msg_type)
+{
+        ray_dev_t *local = netdev_priv(dev);
+        struct ccs __iomem *pccs;
+        int ccsindex;
+        int offset;
+        struct tx_msg __iomem *ptx;     /* Address of xmit buffer in PC space */
+        short int addr;         /* Address of xmit buffer in card space */
+
+        DEBUG(3, "ray_hw_xmit(data=%p, len=%d, dev=%p)\n", data, len, dev);
+        if (len + TX_HEADER_LENGTH > TX_BUF_SIZE) {
+                printk(KERN_INFO "ray_hw_xmit packet too large: %d bytes\n",
+                       len);
+                return XMIT_MSG_BAD;
+        }
         switch (ccsindex = get_free_tx_ccs(local)) {
         case ECCSBUSY:
-                DEBUG(2,"ray_hw_xmit tx_ccs table busy\n");
+                DEBUG(2, "ray_hw_xmit tx_ccs table busy\n");
         case ECCSFULL:
-        DEBUG(2,"ray_hw_xmit No free tx ccs\n");
+                DEBUG(2, "ray_hw_xmit No free tx ccs\n");
         case ECARDGONE:
-        netif_stop_queue(dev);
-        return XMIT_NO_CCS;
+                netif_stop_queue(dev);
+                return XMIT_NO_CCS;
         default:
                 break;
         }
-    addr = TX_BUF_BASE + (ccsindex << 11);
-
-    if (msg_type == DATA_TYPE) {
-        local->stats.tx_bytes += len;
-        local->stats.tx_packets++;
-    }
-
-    ptx = local->sram + addr;
-
-    ray_build_header(local, ptx, msg_type, data);
-    if (translate) {
-        offset = translate_frame(local, ptx, data, len);
-    }
-    else { /* Encapsulate frame */
-        /* TBD TIB length will move address of ptx->var */
-        memcpy_toio(&ptx->var, data, len);
-        offset = 0;
-    }
-
-    /* fill in the CCS */
-    pccs = ccs_base(local) + ccsindex;
-    len += TX_HEADER_LENGTH + offset;
-    writeb(CCS_TX_REQUEST, &pccs->cmd);
-    writeb(addr >> 8, &pccs->var.tx_request.tx_data_ptr[0]);
-    writeb(local->tib_length, &pccs->var.tx_request.tx_data_ptr[1]);
-    writeb(len >> 8, &pccs->var.tx_request.tx_data_length[0]);
-    writeb(len & 0xff, &pccs->var.tx_request.tx_data_length[1]);
+        addr = TX_BUF_BASE + (ccsindex << 11);
+
+        if (msg_type == DATA_TYPE) {
+                local->stats.tx_bytes += len;
+                local->stats.tx_packets++;
+        }
+
+        ptx = local->sram + addr;
+
+        ray_build_header(local, ptx, msg_type, data);
+        if (translate) {
+                offset = translate_frame(local, ptx, data, len);
+        } else { /* Encapsulate frame */
+                /* TBD TIB length will move address of ptx->var */
+                memcpy_toio(&ptx->var, data, len);
+                offset = 0;
+        }
+
+        /* fill in the CCS */
+        pccs = ccs_base(local) + ccsindex;
+        len += TX_HEADER_LENGTH + offset;
+        writeb(CCS_TX_REQUEST, &pccs->cmd);
+        writeb(addr >> 8, &pccs->var.tx_request.tx_data_ptr[0]);
+        writeb(local->tib_length, &pccs->var.tx_request.tx_data_ptr[1]);
+        writeb(len >> 8, &pccs->var.tx_request.tx_data_length[0]);
+        writeb(len & 0xff, &pccs->var.tx_request.tx_data_length[1]);
 /* TBD still need psm_cam? */
-    writeb(PSM_CAM, &pccs->var.tx_request.pow_sav_mode);
-    writeb(local->net_default_tx_rate, &pccs->var.tx_request.tx_rate);
-    writeb(0, &pccs->var.tx_request.antenna);
-    DEBUG(3,"ray_hw_xmit default_tx_rate = 0x%x\n",\
-          local->net_default_tx_rate);
-
-    /* Interrupt the firmware to process the command */
-    if (interrupt_ecf(local, ccsindex)) {
-        DEBUG(2,"ray_hw_xmit failed - ECF not ready for intr\n");
+        writeb(PSM_CAM, &pccs->var.tx_request.pow_sav_mode);
+        writeb(local->net_default_tx_rate, &pccs->var.tx_request.tx_rate);
+        writeb(0, &pccs->var.tx_request.antenna);
+        DEBUG(3, "ray_hw_xmit default_tx_rate = 0x%x\n",
+              local->net_default_tx_rate);
+
+        /* Interrupt the firmware to process the command */
+        if (interrupt_ecf(local, ccsindex)) {
+                DEBUG(2, "ray_hw_xmit failed - ECF not ready for intr\n");
 /* TBD very inefficient to copy packet to buffer, and then not
    send it, but the alternative is to queue the messages and that
    won't be done for a while.  Maybe set tbusy until a CCS is free?
 */
-        writeb(CCS_BUFFER_FREE, &pccs->buffer_status);
-        return XMIT_NO_INTR;
-    }
-    return XMIT_OK;
+                writeb(CCS_BUFFER_FREE, &pccs->buffer_status);
+                return XMIT_NO_INTR;
+        }
+        return XMIT_OK;
 } /* end ray_hw_xmit */
+
 /*===========================================================================*/
-static int translate_frame(ray_dev_t *local, struct tx_msg __iomem *ptx, unsigned char *data,
-                    int len)
-{
-    __be16 proto = ((struct ethhdr *)data)->h_proto;
-    if (ntohs(proto) >= 1536) { /* DIX II ethernet frame */
-        DEBUG(3,"ray_cs translate_frame DIX II\n");
-        /* Copy LLC header to card buffer */
-        memcpy_toio(&ptx->var, eth2_llc, sizeof(eth2_llc));
-        memcpy_toio( ((void __iomem *)&ptx->var) + sizeof(eth2_llc), (UCHAR *)&proto, 2);
-        if (proto == htons(ETH_P_AARP) || proto == htons(ETH_P_IPX)) {
-            /* This is the selective translation table, only 2 entries */
-            writeb(0xf8, &((struct snaphdr_t __iomem *)ptx->var)->org[3]);
-        }
-        /* Copy body of ethernet packet without ethernet header */
-        memcpy_toio((void __iomem *)&ptx->var + sizeof(struct snaphdr_t), \
-                    data + ETH_HLEN,  len - ETH_HLEN);
-        return (int) sizeof(struct snaphdr_t) - ETH_HLEN;
-    }
-    else { /* already  802 type, and proto is length */
-        DEBUG(3,"ray_cs translate_frame 802\n");
-        if (proto == htons(0xffff)) { /* evil netware IPX 802.3 without LLC */
-        DEBUG(3,"ray_cs translate_frame evil IPX\n");
-            memcpy_toio(&ptx->var, data + ETH_HLEN,  len - ETH_HLEN);
-            return 0 - ETH_HLEN;
-        }
-        memcpy_toio(&ptx->var, data + ETH_HLEN,  len - ETH_HLEN);
-        return 0 - ETH_HLEN;
-    }
-    /* TBD do other frame types */
+static int translate_frame(ray_dev_t *local, struct tx_msg __iomem *ptx,
+                           unsigned char *data, int len)
+{
+        __be16 proto = ((struct ethhdr *)data)->h_proto;
+        if (ntohs(proto) >= 1536) { /* DIX II ethernet frame */
+                DEBUG(3, "ray_cs translate_frame DIX II\n");
+                /* Copy LLC header to card buffer */
+                memcpy_toio(&ptx->var, eth2_llc, sizeof(eth2_llc));
+                memcpy_toio(((void __iomem *)&ptx->var) + sizeof(eth2_llc),
+                            (UCHAR *) &proto, 2);
+                if (proto == htons(ETH_P_AARP) || proto == htons(ETH_P_IPX)) {
+                        /* This is the selective translation table, only 2 entries */
+                        writeb(0xf8,
+                               &((struct snaphdr_t __iomem *)ptx->var)->org[3]);
+                }
+                /* Copy body of ethernet packet without ethernet header */
+                memcpy_toio((void __iomem *)&ptx->var +
+                            sizeof(struct snaphdr_t), data + ETH_HLEN,
+                            len - ETH_HLEN);
+                return (int)sizeof(struct snaphdr_t) - ETH_HLEN;
+        } else { /* already  802 type, and proto is length */
+                DEBUG(3, "ray_cs translate_frame 802\n");
+                if (proto == htons(0xffff)) { /* evil netware IPX 802.3 without LLC */
+                        DEBUG(3, "ray_cs translate_frame evil IPX\n");
+                        memcpy_toio(&ptx->var, data + ETH_HLEN, len - ETH_HLEN);
+                        return 0 - ETH_HLEN;
+                }
+                memcpy_toio(&ptx->var, data + ETH_HLEN, len - ETH_HLEN);
+                return 0 - ETH_HLEN;
+        }
+        /* TBD do other frame types */
 } /* end translate_frame */
+
 /*===========================================================================*/
-static void ray_build_header(ray_dev_t *local, struct tx_msg __iomem *ptx, UCHAR msg_type,
-                unsigned char *data)
+static void ray_build_header(ray_dev_t *local, struct tx_msg __iomem *ptx,
+                             UCHAR msg_type, unsigned char *data)
 {
-    writeb(PROTOCOL_VER | msg_type, &ptx->mac.frame_ctl_1);
+        writeb(PROTOCOL_VER | msg_type, &ptx->mac.frame_ctl_1);
 /*** IEEE 802.11 Address field assignments *************
-                TODS FROMDS   addr_1     addr_2          addr_3   addr_4
-Adhoc           0    0        dest       src (terminal)  BSSID    N/A
-AP to Terminal  0    1        dest       AP(BSSID)       source   N/A
-Terminal to AP  1    0        AP(BSSID)  src (terminal)  dest     N/A
-AP to AP        1    1        dest AP    src AP          dest     source      
+                TODS    FROMDS  addr_1          addr_2          addr_3  addr_4
+Adhoc           0       0       dest            src (terminal)  BSSID   N/A
+AP to Terminal  0       1       dest            AP(BSSID)       source  N/A
+Terminal to AP  1       0       AP(BSSID)       src (terminal)  dest    N/A
+AP to AP        1       1       dest AP         src AP          dest    source
 *******************************************************/
-    if (local->net_type == ADHOC) {   
-        writeb(0, &ptx->mac.frame_ctl_2);
-        memcpy_toio(ptx->mac.addr_1, ((struct ethhdr *)data)->h_dest, 2 * ADDRLEN);
-        memcpy_toio(ptx->mac.addr_3, local->bss_id, ADDRLEN);
-    }
-    else /* infrastructure */
-    {
-        if (local->sparm.b4.a_acting_as_ap_status)
-        {
-            writeb(FC2_FROM_DS, &ptx->mac.frame_ctl_2);
-            memcpy_toio(ptx->mac.addr_1, ((struct ethhdr *)data)->h_dest, ADDRLEN);
-            memcpy_toio(ptx->mac.addr_2, local->bss_id, 6);
-            memcpy_toio(ptx->mac.addr_3, ((struct ethhdr *)data)->h_source, ADDRLEN);
-        }
-        else /* Terminal */
-        {
-            writeb(FC2_TO_DS, &ptx->mac.frame_ctl_2);
-            memcpy_toio(ptx->mac.addr_1, local->bss_id, ADDRLEN);
-            memcpy_toio(ptx->mac.addr_2, ((struct ethhdr *)data)->h_source, ADDRLEN);
-            memcpy_toio(ptx->mac.addr_3, ((struct ethhdr *)data)->h_dest, ADDRLEN);
-        }
-    }
+        if (local->net_type == ADHOC) {
+                writeb(0, &ptx->mac.frame_ctl_2);
+                memcpy_toio(ptx->mac.addr_1, ((struct ethhdr *)data)->h_dest,
+                            2 * ADDRLEN);
+                memcpy_toio(ptx->mac.addr_3, local->bss_id, ADDRLEN);
+        } else { /* infrastructure */
+
+                if (local->sparm.b4.a_acting_as_ap_status) {
+                        writeb(FC2_FROM_DS, &ptx->mac.frame_ctl_2);
+                        memcpy_toio(ptx->mac.addr_1,
+                                    ((struct ethhdr *)data)->h_dest, ADDRLEN);
+                        memcpy_toio(ptx->mac.addr_2, local->bss_id, 6);
+                        memcpy_toio(ptx->mac.addr_3,
+                                    ((struct ethhdr *)data)->h_source, ADDRLEN);
+                } else { /* Terminal */
+
+                        writeb(FC2_TO_DS, &ptx->mac.frame_ctl_2);
+                        memcpy_toio(ptx->mac.addr_1, local->bss_id, ADDRLEN);
+                        memcpy_toio(ptx->mac.addr_2,
+                                    ((struct ethhdr *)data)->h_source, ADDRLEN);
+                        memcpy_toio(ptx->mac.addr_3,
+                                    ((struct ethhdr *)data)->h_dest, ADDRLEN);
+                }
+        }
 } /* end encapsulate_frame */
 
-
 /*===========================================================================*/
 
 static void netdev_get_drvinfo(struct net_device *dev,
@@ -1071,7 +1104,7 @@ static void netdev_get_drvinfo(struct net_device *dev,
 }
 
 static const struct ethtool_ops netdev_ethtool_ops = {
-        .get_drvinfo            = netdev_get_drvinfo,
+        .get_drvinfo = netdev_get_drvinfo,
 };
 
 /*====================================================================*/
@@ -1081,9 +1114,7 @@ static const struct ethtool_ops netdev_ethtool_ops = {
  * Wireless Handler : get protocol name
  */
 static int ray_get_name(struct net_device *dev,
-                        struct iw_request_info *info,
-                        char *cwrq,
-                        char *extra)
+                        struct iw_request_info *info, char *cwrq, char *extra)
 {
         strcpy(cwrq, "IEEE 802.11-FH");
         return 0;
@@ -1095,14 +1126,13 @@ static int ray_get_name(struct net_device *dev,
  */
 static int ray_set_freq(struct net_device *dev,
                         struct iw_request_info *info,
-                        struct iw_freq *fwrq,
-                        char *extra)
+                        struct iw_freq *fwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
-        int err = -EINPROGRESS;         /* Call commit handler */
+        int err = -EINPROGRESS; /* Call commit handler */
 
         /* Reject if card is already initialised */
-        if(local->card_status != CARD_AWAITING_PARAM)
+        if (local->card_status != CARD_AWAITING_PARAM)
                 return -EBUSY;
 
         /* Setting by channel number */
@@ -1113,15 +1143,14 @@ static int ray_set_freq(struct net_device *dev,
 
         return err;
 }
- 
+
 /*------------------------------------------------------------------*/
 /*
  * Wireless Handler : get frequency
  */
 static int ray_get_freq(struct net_device *dev,
                         struct iw_request_info *info,
-                        struct iw_freq *fwrq,
-                        char *extra)
+                        struct iw_freq *fwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
@@ -1136,22 +1165,21 @@ static int ray_get_freq(struct net_device *dev,
  */
 static int ray_set_essid(struct net_device *dev,
                          struct iw_request_info *info,
-                         struct iw_point *dwrq,
-                         char *extra)
+                         struct iw_point *dwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
         /* Reject if card is already initialised */
-        if(local->card_status != CARD_AWAITING_PARAM)
+        if (local->card_status != CARD_AWAITING_PARAM)
                 return -EBUSY;
 
         /* Check if we asked for `any' */
-        if(dwrq->flags == 0) {
+        if (dwrq->flags == 0) {
                 /* Corey : can you do that ? */
                 return -EOPNOTSUPP;
         } else {
                 /* Check the size of the string */
-                if(dwrq->length > IW_ESSID_MAX_SIZE) {
+                if (dwrq->length > IW_ESSID_MAX_SIZE) {
                         return -E2BIG;
                 }
 
@@ -1160,7 +1188,7 @@ static int ray_set_essid(struct net_device *dev,
                 memcpy(local->sparm.b5.a_current_ess_id, extra, dwrq->length);
         }
 
-        return -EINPROGRESS;            /* Call commit handler */
+        return -EINPROGRESS;    /* Call commit handler */
 }
 
 /*------------------------------------------------------------------*/
@@ -1169,8 +1197,7 @@ static int ray_set_essid(struct net_device *dev,
  */
 static int ray_get_essid(struct net_device *dev,
                          struct iw_request_info *info,
-                         struct iw_point *dwrq,
-                         char *extra)
+                         struct iw_point *dwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
@@ -1179,7 +1206,7 @@ static int ray_get_essid(struct net_device *dev,
 
         /* Push it out ! */
         dwrq->length = strlen(extra);
-        dwrq->flags = 1; /* active */
+        dwrq->flags = 1;        /* active */
 
         return 0;
 }
@@ -1189,9 +1216,8 @@ static int ray_get_essid(struct net_device *dev,
  * Wireless Handler : get AP address
  */
 static int ray_get_wap(struct net_device *dev,
-                        struct iw_request_info *info,
-                        struct sockaddr *awrq,
-                        char *extra)
+                       struct iw_request_info *info,
+                       struct sockaddr *awrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
@@ -1207,25 +1233,24 @@ static int ray_get_wap(struct net_device *dev,
  */
 static int ray_set_rate(struct net_device *dev,
                         struct iw_request_info *info,
-                        struct iw_param *vwrq,
-                        char *extra)
+                        struct iw_param *vwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
         /* Reject if card is already initialised */
-        if(local->card_status != CARD_AWAITING_PARAM)
+        if (local->card_status != CARD_AWAITING_PARAM)
                 return -EBUSY;
 
         /* Check if rate is in range */
-        if((vwrq->value != 1000000) && (vwrq->value != 2000000))
+        if ((vwrq->value != 1000000) && (vwrq->value != 2000000))
                 return -EINVAL;
 
         /* Hack for 1.5 Mb/s instead of 2 Mb/s */
-        if((local->fw_ver == 0x55) &&           /* Please check */
-           (vwrq->value == 2000000))
+        if ((local->fw_ver == 0x55) &&  /* Please check */
+            (vwrq->value == 2000000))
                 local->net_default_tx_rate = 3;
         else
-                local->net_default_tx_rate = vwrq->value/500000;
+                local->net_default_tx_rate = vwrq->value / 500000;
 
         return 0;
 }
@@ -1236,16 +1261,15 @@ static int ray_set_rate(struct net_device *dev,
  */
 static int ray_get_rate(struct net_device *dev,
                         struct iw_request_info *info,
-                        struct iw_param *vwrq,
-                        char *extra)
+                        struct iw_param *vwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
-        if(local->net_default_tx_rate == 3)
-                vwrq->value = 2000000;          /* Hum... */
+        if (local->net_default_tx_rate == 3)
+                vwrq->value = 2000000;  /* Hum... */
         else
                 vwrq->value = local->net_default_tx_rate * 500000;
-        vwrq->fixed = 0;                /* We are in auto mode */
+        vwrq->fixed = 0;        /* We are in auto mode */
 
         return 0;
 }
@@ -1256,43 +1280,40 @@ static int ray_get_rate(struct net_device *dev,
  */
 static int ray_set_rts(struct net_device *dev,
                        struct iw_request_info *info,
-                       struct iw_param *vwrq,
-                       char *extra)
+                       struct iw_param *vwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
         int rthr = vwrq->value;
 
         /* Reject if card is already initialised */
-        if(local->card_status != CARD_AWAITING_PARAM)
+        if (local->card_status != CARD_AWAITING_PARAM)
                 return -EBUSY;
 
         /* if(wrq->u.rts.fixed == 0) we should complain */
-        if(vwrq->disabled)
+        if (vwrq->disabled)
                 rthr = 32767;
         else {
-                if((rthr < 0) || (rthr > 2347)) /* What's the max packet size ??? */
+                if ((rthr < 0) || (rthr > 2347))   /* What's the max packet size ??? */
                         return -EINVAL;
         }
         local->sparm.b5.a_rts_threshold[0] = (rthr >> 8) & 0xFF;
         local->sparm.b5.a_rts_threshold[1] = rthr & 0xFF;
 
-        return -EINPROGRESS;            /* Call commit handler */
+        return -EINPROGRESS;    /* Call commit handler */
 }
 
-
 /*------------------------------------------------------------------*/
 /*
  * Wireless Handler : get RTS threshold
  */
 static int ray_get_rts(struct net_device *dev,
                        struct iw_request_info *info,
-                       struct iw_param *vwrq,
-                       char *extra)
+                       struct iw_param *vwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
         vwrq->value = (local->sparm.b5.a_rts_threshold[0] << 8)
-                + local->sparm.b5.a_rts_threshold[1];
+            + local->sparm.b5.a_rts_threshold[1];
         vwrq->disabled = (vwrq->value == 32767);
         vwrq->fixed = 1;
 
@@ -1305,27 +1326,26 @@ static int ray_get_rts(struct net_device *dev,
  */
 static int ray_set_frag(struct net_device *dev,
                         struct iw_request_info *info,
-                        struct iw_param *vwrq,
-                        char *extra)
+                        struct iw_param *vwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
         int fthr = vwrq->value;
 
         /* Reject if card is already initialised */
-        if(local->card_status != CARD_AWAITING_PARAM)
+        if (local->card_status != CARD_AWAITING_PARAM)
                 return -EBUSY;
 
         /* if(wrq->u.frag.fixed == 0) should complain */
-        if(vwrq->disabled)
+        if (vwrq->disabled)
                 fthr = 32767;
         else {
-                if((fthr < 256) || (fthr > 2347)) /* To check out ! */
+                if ((fthr < 256) || (fthr > 2347))      /* To check out ! */
                         return -EINVAL;
         }
         local->sparm.b5.a_frag_threshold[0] = (fthr >> 8) & 0xFF;
         local->sparm.b5.a_frag_threshold[1] = fthr & 0xFF;
 
-        return -EINPROGRESS;            /* Call commit handler */
+        return -EINPROGRESS;    /* Call commit handler */
 }
 
 /*------------------------------------------------------------------*/
@@ -1334,13 +1354,12 @@ static int ray_set_frag(struct net_device *dev,
  */
 static int ray_get_frag(struct net_device *dev,
                         struct iw_request_info *info,
-                        struct iw_param *vwrq,
-                        char *extra)
+                        struct iw_param *vwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
         vwrq->value = (local->sparm.b5.a_frag_threshold[0] << 8)
-                + local->sparm.b5.a_frag_threshold[1];
+            + local->sparm.b5.a_frag_threshold[1];
         vwrq->disabled = (vwrq->value == 32767);
         vwrq->fixed = 1;
 
@@ -1352,23 +1371,20 @@ static int ray_get_frag(struct net_device *dev,
  * Wireless Handler : set Mode of Operation
  */
 static int ray_set_mode(struct net_device *dev,
-                        struct iw_request_info *info,
-                        __u32 *uwrq,
-                        char *extra)
+                        struct iw_request_info *info, __u32 *uwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
-        int err = -EINPROGRESS;         /* Call commit handler */
+        int err = -EINPROGRESS; /* Call commit handler */
         char card_mode = 1;
 
         /* Reject if card is already initialised */
-        if(local->card_status != CARD_AWAITING_PARAM)
+        if (local->card_status != CARD_AWAITING_PARAM)
                 return -EBUSY;
 
-        switch (*uwrq)
-        {
+        switch (*uwrq) {
         case IW_MODE_ADHOC:
                 card_mode = 0;
-                // Fall through
+                /* Fall through */
         case IW_MODE_INFRA:
                 local->sparm.b5.a_network_type = card_mode;
                 break;
@@ -1384,13 +1400,11 @@ static int ray_set_mode(struct net_device *dev,
  * Wireless Handler : get Mode of Operation
  */
 static int ray_get_mode(struct net_device *dev,
-                        struct iw_request_info *info,
-                        __u32 *uwrq,
-                        char *extra)
+                        struct iw_request_info *info, __u32 *uwrq, char *extra)
 {
         ray_dev_t *local = netdev_priv(dev);
 
-        if(local->sparm.b5.a_network_type)
+        if (local->sparm.b5.a_network_type)
                 *uwrq = IW_MODE_INFRA;
         else
                 *uwrq = IW_MODE_ADHOC;
@@ -1404,12 +1418,11 @@ static int ray_get_mode(struct net_device *dev,
  */
 static int ray_get_range(struct net_device *dev,
                          struct iw_request_info *info,
-                         struct iw_point *dwrq,
-                         char *extra)
+                         struct iw_point *dwrq, char *extra)
 {
-        struct iw_range *range = (struct iw_range *) extra;
+        struct iw_range *range = (struct iw_range *)extra;
 
-        memset((char *) range, 0, sizeof(struct iw_range));
+        memset((char *)range, 0, sizeof(struct iw_range));
 
         /* Set the length (very important for backward compatibility) */
         dwrq->length = sizeof(struct iw_range);
@@ -1420,7 +1433,7 @@ static int ray_get_range(struct net_device *dev,
 
         /* Set information in the range struct */
         range->throughput = 1.1 * 1000 * 1000;  /* Put the right number here */
-        range->num_channels = hop_pattern_length[(int)country]; 
+        range->num_channels = hop_pattern_length[(int)country];
         range->num_frequency = 0;
         range->max_qual.qual = 0;
         range->max_qual.level = 255;    /* What's the correct value ? */
@@ -1437,8 +1450,7 @@ static int ray_get_range(struct net_device *dev,
  */
 static int ray_set_framing(struct net_device *dev,
                            struct iw_request_info *info,
-                           union iwreq_data *wrqu,
-                           char *extra)
+                           union iwreq_data *wrqu, char *extra)
 {
         translate = *(extra);   /* Set framing mode */
 
@@ -1451,8 +1463,7 @@ static int ray_set_framing(struct net_device *dev,
  */
 static int ray_get_framing(struct net_device *dev,
                            struct iw_request_info *info,
-                           union iwreq_data *wrqu,
-                           char *extra)
+                           union iwreq_data *wrqu, char *extra)
 {
         *(extra) = translate;
 
@@ -1465,8 +1476,7 @@ static int ray_get_framing(struct net_device *dev,
  */
 static int ray_get_country(struct net_device *dev,
                            struct iw_request_info *info,
-                           union iwreq_data *wrqu,
-                           char *extra)
+                           union iwreq_data *wrqu, char *extra)
 {
         *(extra) = country;
 
@@ -1477,11 +1487,10 @@ static int ray_get_country(struct net_device *dev,
 /*
  * Commit handler : called after a bunch of SET operations
  */
-static int ray_commit(struct net_device *dev,
-                      struct iw_request_info *info,     /* NULL */
-                      void *zwrq,                       /* NULL */
-                      char *extra)                      /* NULL */
-{
+static int ray_commit(struct net_device *dev, struct iw_request_info *info,     /* NULL */
+                      void *zwrq,       /* NULL */
+                      char *extra)
+{ /* NULL */
         return 0;
 }
 
@@ -1489,33 +1498,34 @@ static int ray_commit(struct net_device *dev,
 /*
  * Stats handler : return Wireless Stats
  */
-static iw_stats * ray_get_wireless_stats(struct net_device *    dev)
+static iw_stats *ray_get_wireless_stats(struct net_device *dev)
 {
-  ray_dev_t *   local = netdev_priv(dev);
-  struct pcmcia_device *link = local->finder;
-  struct status __iomem *p = local->sram + STATUS_BASE;
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+        struct status __iomem *p = local->sram + STATUS_BASE;
 
-  if(local == (ray_dev_t *) NULL)
-    return (iw_stats *) NULL;
+        if (local == (ray_dev_t *) NULL)
+                return (iw_stats *) NULL;
 
-  local->wstats.status = local->card_status;
+        local->wstats.status = local->card_status;
 #ifdef WIRELESS_SPY
-  if((local->spy_data.spy_number > 0) && (local->sparm.b5.a_network_type == 0))
-    {
-      /* Get it from the first node in spy list */
-      local->wstats.qual.qual = local->spy_data.spy_stat[0].qual;
-      local->wstats.qual.level = local->spy_data.spy_stat[0].level;
-      local->wstats.qual.noise = local->spy_data.spy_stat[0].noise;
-      local->wstats.qual.updated = local->spy_data.spy_stat[0].updated;
-    }
+        if ((local->spy_data.spy_number > 0)
+            && (local->sparm.b5.a_network_type == 0)) {
+                /* Get it from the first node in spy list */
+                local->wstats.qual.qual = local->spy_data.spy_stat[0].qual;
+                local->wstats.qual.level = local->spy_data.spy_stat[0].level;
+                local->wstats.qual.noise = local->spy_data.spy_stat[0].noise;
+                local->wstats.qual.updated =
+                    local->spy_data.spy_stat[0].updated;
+        }
 #endif /* WIRELESS_SPY */
 
-  if(pcmcia_dev_present(link)) {
-    local->wstats.qual.noise = readb(&p->rxnoise);
-    local->wstats.qual.updated |= 4;
-  }
+        if (pcmcia_dev_present(link)) {
+                local->wstats.qual.noise = readb(&p->rxnoise);
+                local->wstats.qual.updated |= 4;
+        }
 
-  return &local->wstats;
+        return &local->wstats;
 } /* end ray_get_wireless_stats */
 
 /*------------------------------------------------------------------*/
@@ -1523,1159 +1533,1264 @@ static iw_stats * ray_get_wireless_stats(struct net_device *	dev)
  * Structures to export the Wireless Handlers
  */
 
-static const iw_handler ray_handler[] = {
-        [SIOCSIWCOMMIT-SIOCIWFIRST] = (iw_handler) ray_commit,
-        [SIOCGIWNAME  -SIOCIWFIRST] = (iw_handler) ray_get_name,
-        [SIOCSIWFREQ  -SIOCIWFIRST] = (iw_handler) ray_set_freq,
-        [SIOCGIWFREQ  -SIOCIWFIRST] = (iw_handler) ray_get_freq,
-        [SIOCSIWMODE  -SIOCIWFIRST] = (iw_handler) ray_set_mode,
-        [SIOCGIWMODE  -SIOCIWFIRST] = (iw_handler) ray_get_mode,
-        [SIOCGIWRANGE -SIOCIWFIRST] = (iw_handler) ray_get_range,
+static const iw_handler ray_handler[] = {
+        [SIOCSIWCOMMIT - SIOCIWFIRST] = (iw_handler) ray_commit,
+        [SIOCGIWNAME - SIOCIWFIRST] = (iw_handler) ray_get_name,
+        [SIOCSIWFREQ - SIOCIWFIRST] = (iw_handler) ray_set_freq,
+        [SIOCGIWFREQ - SIOCIWFIRST] = (iw_handler) ray_get_freq,
+        [SIOCSIWMODE - SIOCIWFIRST] = (iw_handler) ray_set_mode,
+        [SIOCGIWMODE - SIOCIWFIRST] = (iw_handler) ray_get_mode,
+        [SIOCGIWRANGE - SIOCIWFIRST] = (iw_handler) ray_get_range,
 #ifdef WIRELESS_SPY
-        [SIOCSIWSPY   -SIOCIWFIRST] = (iw_handler) iw_handler_set_spy,
-        [SIOCGIWSPY   -SIOCIWFIRST] = (iw_handler) iw_handler_get_spy,
-        [SIOCSIWTHRSPY-SIOCIWFIRST] = (iw_handler) iw_handler_set_thrspy,
-        [SIOCGIWTHRSPY-SIOCIWFIRST] = (iw_handler) iw_handler_get_thrspy,
-#endif  /* WIRELESS_SPY */
-        [SIOCGIWAP    -SIOCIWFIRST] = (iw_handler) ray_get_wap,
-        [SIOCSIWESSID -SIOCIWFIRST] = (iw_handler) ray_set_essid,
-        [SIOCGIWESSID -SIOCIWFIRST] = (iw_handler) ray_get_essid,
-        [SIOCSIWRATE  -SIOCIWFIRST] = (iw_handler) ray_set_rate,
-        [SIOCGIWRATE  -SIOCIWFIRST] = (iw_handler) ray_get_rate,
-        [SIOCSIWRTS   -SIOCIWFIRST] = (iw_handler) ray_set_rts,
-        [SIOCGIWRTS   -SIOCIWFIRST] = (iw_handler) ray_get_rts,
-        [SIOCSIWFRAG  -SIOCIWFIRST] = (iw_handler) ray_set_frag,
-        [SIOCGIWFRAG  -SIOCIWFIRST] = (iw_handler) ray_get_frag,
+        [SIOCSIWSPY - SIOCIWFIRST] = (iw_handler) iw_handler_set_spy,
+        [SIOCGIWSPY - SIOCIWFIRST] = (iw_handler) iw_handler_get_spy,
+        [SIOCSIWTHRSPY - SIOCIWFIRST] = (iw_handler) iw_handler_set_thrspy,
+        [SIOCGIWTHRSPY - SIOCIWFIRST] = (iw_handler) iw_handler_get_thrspy,
+#endif /* WIRELESS_SPY */
+        [SIOCGIWAP - SIOCIWFIRST] = (iw_handler) ray_get_wap,
+        [SIOCSIWESSID - SIOCIWFIRST] = (iw_handler) ray_set_essid,
+        [SIOCGIWESSID - SIOCIWFIRST] = (iw_handler) ray_get_essid,
+        [SIOCSIWRATE - SIOCIWFIRST] = (iw_handler) ray_set_rate,
+        [SIOCGIWRATE - SIOCIWFIRST] = (iw_handler) ray_get_rate,
+        [SIOCSIWRTS - SIOCIWFIRST] = (iw_handler) ray_set_rts,
+        [SIOCGIWRTS - SIOCIWFIRST] = (iw_handler) ray_get_rts,
+        [SIOCSIWFRAG - SIOCIWFIRST] = (iw_handler) ray_set_frag,
+        [SIOCGIWFRAG - SIOCIWFIRST] = (iw_handler) ray_get_frag,
 };
 
-#define SIOCSIPFRAMING  SIOCIWFIRSTPRIV         /* Set framing mode */
+#define SIOCSIPFRAMING  SIOCIWFIRSTPRIV /* Set framing mode */
 #define SIOCGIPFRAMING  SIOCIWFIRSTPRIV + 1     /* Get framing mode */
 #define SIOCGIPCOUNTRY  SIOCIWFIRSTPRIV + 3     /* Get country code */
 
-static const iw_handler ray_private_handler[] = {
+static const iw_handler ray_private_handler[] = {
         [0] = (iw_handler) ray_set_framing,
         [1] = (iw_handler) ray_get_framing,
         [3] = (iw_handler) ray_get_country,
 };
 
-static const struct iw_priv_args        ray_private_args[] = {
+static const struct iw_priv_args ray_private_args[] = {
 /* cmd,         set_args,       get_args,       name */
-{ SIOCSIPFRAMING, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "set_framing" },
-{ SIOCGIPFRAMING, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "get_framing" },
-{ SIOCGIPCOUNTRY, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "get_country" },
+        {SIOCSIPFRAMING, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0,
+         "set_framing"},
+        {SIOCGIPFRAMING, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
+         "get_framing"},
+        {SIOCGIPCOUNTRY, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
+         "get_country"},
 };
 
-static const struct iw_handler_def      ray_handler_def =
-{
-        .num_standard   = ARRAY_SIZE(ray_handler),
-        .num_private    = ARRAY_SIZE(ray_private_handler),
+static const struct iw_handler_def ray_handler_def = {
+        .num_standard = ARRAY_SIZE(ray_handler),
+        .num_private = ARRAY_SIZE(ray_private_handler),
         .num_private_args = ARRAY_SIZE(ray_private_args),
-        .standard       = ray_handler,
-        .private        = ray_private_handler,
-        .private_args   = ray_private_args,
+        .standard = ray_handler,
+        .private = ray_private_handler,
+        .private_args = ray_private_args,
         .get_wireless_stats = ray_get_wireless_stats,
 };
 
 /*===========================================================================*/
 static int ray_open(struct net_device *dev)
 {
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link;
-    link = local->finder;
-    
-    DEBUG(1, "ray_open('%s')\n", dev->name);
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link;
+        link = local->finder;
 
-    if (link->open == 0)
-            local->num_multi = 0;
-    link->open++;
+        DEBUG(1, "ray_open('%s')\n", dev->name);
 
-    /* If the card is not started, time to start it ! - Jean II */
-    if(local->card_status == CARD_AWAITING_PARAM) {
-        int i;
+        if (link->open == 0)
+                local->num_multi = 0;
+        link->open++;
 
-        DEBUG(1,"ray_open: doing init now !\n");
+        /* If the card is not started, time to start it ! - Jean II */
+        if (local->card_status == CARD_AWAITING_PARAM) {
+                int i;
 
-        /* Download startup parameters */
-        if ( (i = dl_startup_params(dev)) < 0)
-          {
-            printk(KERN_INFO "ray_dev_init dl_startup_params failed - "
-                   "returns 0x%x\n",i);
-            return -1;
-          }
-     }
-
-    if (sniffer) netif_stop_queue(dev);
-    else         netif_start_queue(dev);
-
-    DEBUG(2,"ray_open ending\n");
-    return 0;
+                DEBUG(1, "ray_open: doing init now !\n");
+
+                /* Download startup parameters */
+                if ((i = dl_startup_params(dev)) < 0) {
+                        printk(KERN_INFO
+                               "ray_dev_init dl_startup_params failed - "
+                               "returns 0x%x\n", i);
+                        return -1;
+                }
+        }
+
+        if (sniffer)
+                netif_stop_queue(dev);
+        else
+                netif_start_queue(dev);
+
+        DEBUG(2, "ray_open ending\n");
+        return 0;
 } /* end ray_open */
+
 /*===========================================================================*/
 static int ray_dev_close(struct net_device *dev)
 {
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link;
-    link = local->finder;
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link;
+        link = local->finder;
 
-    DEBUG(1, "ray_dev_close('%s')\n", dev->name);
+        DEBUG(1, "ray_dev_close('%s')\n", dev->name);
 
-    link->open--;
-    netif_stop_queue(dev);
+        link->open--;
+        netif_stop_queue(dev);
 
-    /* In here, we should stop the hardware (stop card from beeing active)
-     * and set local->card_status to CARD_AWAITING_PARAM, so that while the
-     * card is closed we can chage its configuration.
-     * Probably also need a COR reset to get sane state - Jean II */
+        /* In here, we should stop the hardware (stop card from beeing active)
+         * and set local->card_status to CARD_AWAITING_PARAM, so that while the
+         * card is closed we can chage its configuration.
+         * Probably also need a COR reset to get sane state - Jean II */
 
-    return 0;
+        return 0;
 } /* end ray_dev_close */
+
 /*===========================================================================*/
-static void ray_reset(struct net_device *dev) {
-    DEBUG(1,"ray_reset entered\n");
-    return;
+static void ray_reset(struct net_device *dev)
+{
+        DEBUG(1, "ray_reset entered\n");
+        return;
 }
+
 /*===========================================================================*/
 /* Cause a firmware interrupt if it is ready for one                         */
 /* Return nonzero if not ready                                               */
 static int interrupt_ecf(ray_dev_t *local, int ccs)
 {
-    int i = 50;
-    struct pcmcia_device *link = local->finder;
-
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs interrupt_ecf - device not present\n");
-        return -1;
-    }
-    DEBUG(2,"interrupt_ecf(local=%p, ccs = 0x%x\n",local,ccs);
-
-    while ( i && 
-            (readb(local->amem + CIS_OFFSET + ECF_INTR_OFFSET) & ECF_INTR_SET))
-        i--;
-    if (i == 0) {
-        DEBUG(2,"ray_cs interrupt_ecf card not ready for interrupt\n");
-        return -1;
-    }
+        int i = 50;
+        struct pcmcia_device *link = local->finder;
+
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs interrupt_ecf - device not present\n");
+                return -1;
+        }
+        DEBUG(2, "interrupt_ecf(local=%p, ccs = 0x%x\n", local, ccs);
+
+        while (i &&
+               (readb(local->amem + CIS_OFFSET + ECF_INTR_OFFSET) &
+                ECF_INTR_SET))
+                i--;
+        if (i == 0) {
+                DEBUG(2, "ray_cs interrupt_ecf card not ready for interrupt\n");
+                return -1;
+        }
         /* Fill the mailbox, then kick the card */
-    writeb(ccs, local->sram + SCB_BASE);
-    writeb(ECF_INTR_SET, local->amem + CIS_OFFSET + ECF_INTR_OFFSET);
-    return 0;
+        writeb(ccs, local->sram + SCB_BASE);
+        writeb(ECF_INTR_SET, local->amem + CIS_OFFSET + ECF_INTR_OFFSET);
+        return 0;
 } /* interrupt_ecf */
+
 /*===========================================================================*/
 /* Get next free transmit CCS                                                */
 /* Return - index of current tx ccs                                          */
 static int get_free_tx_ccs(ray_dev_t *local)
 {
-    int i;
-    struct ccs __iomem *pccs = ccs_base(local);
-    struct pcmcia_device *link = local->finder;
+        int i;
+        struct ccs __iomem *pccs = ccs_base(local);
+        struct pcmcia_device *link = local->finder;
 
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs get_free_tx_ccs - device not present\n");
-        return ECARDGONE;
-    }
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs get_free_tx_ccs - device not present\n");
+                return ECARDGONE;
+        }
 
-    if (test_and_set_bit(0,&local->tx_ccs_lock)) {
-        DEBUG(1,"ray_cs tx_ccs_lock busy\n");
-        return ECCSBUSY;
-    } 
+        if (test_and_set_bit(0, &local->tx_ccs_lock)) {
+                DEBUG(1, "ray_cs tx_ccs_lock busy\n");
+                return ECCSBUSY;
+        }
 
-    for (i=0; i < NUMBER_OF_TX_CCS; i++) {
-        if (readb(&(pccs+i)->buffer_status) == CCS_BUFFER_FREE) {
-            writeb(CCS_BUFFER_BUSY, &(pccs+i)->buffer_status);
-            writeb(CCS_END_LIST, &(pccs+i)->link);
+        for (i = 0; i < NUMBER_OF_TX_CCS; i++) {
+                if (readb(&(pccs + i)->buffer_status) == CCS_BUFFER_FREE) {
+                        writeb(CCS_BUFFER_BUSY, &(pccs + i)->buffer_status);
+                        writeb(CCS_END_LIST, &(pccs + i)->link);
                         local->tx_ccs_lock = 0;
-            return i;
-        }
-    }
+                        return i;
+                }
+        }
         local->tx_ccs_lock = 0;
-    DEBUG(2,"ray_cs ERROR no free tx CCS for raylink card\n");
-    return ECCSFULL;
+        DEBUG(2, "ray_cs ERROR no free tx CCS for raylink card\n");
+        return ECCSFULL;
 } /* get_free_tx_ccs */
+
 /*===========================================================================*/
 /* Get next free CCS                                                         */
 /* Return - index of current ccs                                             */
 static int get_free_ccs(ray_dev_t *local)
 {
-    int i;
-    struct ccs __iomem *pccs = ccs_base(local);
-    struct pcmcia_device *link = local->finder;
-
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs get_free_ccs - device not present\n");
-        return ECARDGONE;
-    }
-    if (test_and_set_bit(0,&local->ccs_lock)) {
-        DEBUG(1,"ray_cs ccs_lock busy\n");
-        return ECCSBUSY;
-    } 
-
-    for (i = NUMBER_OF_TX_CCS; i < NUMBER_OF_CCS; i++) {
-        if (readb(&(pccs+i)->buffer_status) == CCS_BUFFER_FREE) {
-            writeb(CCS_BUFFER_BUSY, &(pccs+i)->buffer_status);
-            writeb(CCS_END_LIST, &(pccs+i)->link);
+        int i;
+        struct ccs __iomem *pccs = ccs_base(local);
+        struct pcmcia_device *link = local->finder;
+
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs get_free_ccs - device not present\n");
+                return ECARDGONE;
+        }
+        if (test_and_set_bit(0, &local->ccs_lock)) {
+                DEBUG(1, "ray_cs ccs_lock busy\n");
+                return ECCSBUSY;
+        }
+
+        for (i = NUMBER_OF_TX_CCS; i < NUMBER_OF_CCS; i++) {
+                if (readb(&(pccs + i)->buffer_status) == CCS_BUFFER_FREE) {
+                        writeb(CCS_BUFFER_BUSY, &(pccs + i)->buffer_status);
+                        writeb(CCS_END_LIST, &(pccs + i)->link);
                         local->ccs_lock = 0;
-            return i;
-        }
-    }
+                        return i;
+                }
+        }
         local->ccs_lock = 0;
-    DEBUG(1,"ray_cs ERROR no free CCS for raylink card\n");
-    return ECCSFULL;
+        DEBUG(1, "ray_cs ERROR no free CCS for raylink card\n");
+        return ECCSFULL;
 } /* get_free_ccs */
+
 /*===========================================================================*/
 static void authenticate_timeout(u_long data)
 {
-    ray_dev_t *local = (ray_dev_t *)data;
-    del_timer(&local->timer);
-    printk(KERN_INFO "ray_cs Authentication with access point failed"
-       " - timeout\n");
-    join_net((u_long)local);
+        ray_dev_t *local = (ray_dev_t *) data;
+        del_timer(&local->timer);
+        printk(KERN_INFO "ray_cs Authentication with access point failed"
+               " - timeout\n");
+        join_net((u_long) local);
 }
+
 /*===========================================================================*/
 static int asc_to_int(char a)
 {
-    if (a < '0') return -1;
-    if (a <= '9') return (a - '0');
-    if (a < 'A') return -1;
-    if (a <= 'F') return (10 + a - 'A');
-    if (a < 'a') return -1;
-    if (a <= 'f') return (10 + a - 'a');
-    return -1;
+        if (a < '0')
+                return -1;
+        if (a <= '9')
+                return (a - '0');
+        if (a < 'A')
+                return -1;
+        if (a <= 'F')
+                return (10 + a - 'A');
+        if (a < 'a')
+                return -1;
+        if (a <= 'f')
+                return (10 + a - 'a');
+        return -1;
 }
+
 /*===========================================================================*/
 static int parse_addr(char *in_str, UCHAR *out)
 {
-    int len;
-    int i,j,k;
-    int status;
-    
-    if (in_str == NULL) return 0;
-    if ((len = strlen(in_str)) < 2) return 0;
-    memset(out, 0, ADDRLEN);
-
-    status = 1;
-    j = len - 1;
-    if (j > 12) j = 12;
-    i = 5;
-    
-    while (j > 0)
-    {
-        if ((k = asc_to_int(in_str[j--])) != -1) out[i] = k;
-        else return 0;
-
-        if (j == 0) break;
-        if ((k = asc_to_int(in_str[j--])) != -1) out[i] += k << 4;
-        else return 0;
-        if (!i--) break;
-    }
-    return status;
+        int len;
+        int i, j, k;
+        int status;
+
+        if (in_str == NULL)
+                return 0;
+        if ((len = strlen(in_str)) < 2)
+                return 0;
+        memset(out, 0, ADDRLEN);
+
+        status = 1;
+        j = len - 1;
+        if (j > 12)
+                j = 12;
+        i = 5;
+
+        while (j > 0) {
+                if ((k = asc_to_int(in_str[j--])) != -1)
+                        out[i] = k;
+                else
+                        return 0;
+
+                if (j == 0)
+                        break;
+                if ((k = asc_to_int(in_str[j--])) != -1)
+                        out[i] += k << 4;
+                else
+                        return 0;
+                if (!i--)
+                        break;
+        }
+        return status;
 }
+
 /*===========================================================================*/
 static struct net_device_stats *ray_get_stats(struct net_device *dev)
 {
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link = local->finder;
-    struct status __iomem *p = local->sram + STATUS_BASE;
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs net_device_stats - device not present\n");
-        return &local->stats;
-    }
-    if (readb(&p->mrx_overflow_for_host))
-    {
-        local->stats.rx_over_errors += swab16(readw(&p->mrx_overflow));
-        writeb(0,&p->mrx_overflow);
-        writeb(0,&p->mrx_overflow_for_host);
-    }
-    if (readb(&p->mrx_checksum_error_for_host))
-    {
-        local->stats.rx_crc_errors += swab16(readw(&p->mrx_checksum_error));
-        writeb(0,&p->mrx_checksum_error);
-        writeb(0,&p->mrx_checksum_error_for_host);
-    }
-    if (readb(&p->rx_hec_error_for_host))
-    {
-        local->stats.rx_frame_errors += swab16(readw(&p->rx_hec_error));
-        writeb(0,&p->rx_hec_error);
-        writeb(0,&p->rx_hec_error_for_host);
-    }
-    return &local->stats;
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+        struct status __iomem *p = local->sram + STATUS_BASE;
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs net_device_stats - device not present\n");
+                return &local->stats;
+        }
+        if (readb(&p->mrx_overflow_for_host)) {
+                local->stats.rx_over_errors += swab16(readw(&p->mrx_overflow));
+                writeb(0, &p->mrx_overflow);
+                writeb(0, &p->mrx_overflow_for_host);
+        }
+        if (readb(&p->mrx_checksum_error_for_host)) {
+                local->stats.rx_crc_errors +=
+                    swab16(readw(&p->mrx_checksum_error));
+                writeb(0, &p->mrx_checksum_error);
+                writeb(0, &p->mrx_checksum_error_for_host);
+        }
+        if (readb(&p->rx_hec_error_for_host)) {
+                local->stats.rx_frame_errors += swab16(readw(&p->rx_hec_error));
+                writeb(0, &p->rx_hec_error);
+                writeb(0, &p->rx_hec_error_for_host);
+        }
+        return &local->stats;
 }
+
 /*===========================================================================*/
-static void ray_update_parm(struct net_device *dev, UCHAR objid, UCHAR *value, int len)
-{
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link = local->finder;
-    int ccsindex;
-    int i;
-    struct ccs __iomem *pccs;
-
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_update_parm - device not present\n");
-        return;
-    }
-
-    if ((ccsindex = get_free_ccs(local)) < 0)
-    {
-        DEBUG(0,"ray_update_parm - No free ccs\n");
-        return;
-    }
-    pccs = ccs_base(local) + ccsindex;
-    writeb(CCS_UPDATE_PARAMS, &pccs->cmd);
-    writeb(objid, &pccs->var.update_param.object_id);
-    writeb(1, &pccs->var.update_param.number_objects);
-    writeb(0, &pccs->var.update_param.failure_cause);
-    for (i=0; i<len; i++) {
-        writeb(value[i], local->sram + HOST_TO_ECF_BASE);
-    }
-    /* Interrupt the firmware to process the command */
-    if (interrupt_ecf(local, ccsindex)) {
-        DEBUG(0,"ray_cs associate failed - ECF not ready for intr\n");
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-    }
+static void ray_update_parm(struct net_device *dev, UCHAR objid, UCHAR *value,
+                            int len)
+{
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+        int ccsindex;
+        int i;
+        struct ccs __iomem *pccs;
+
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_update_parm - device not present\n");
+                return;
+        }
+
+        if ((ccsindex = get_free_ccs(local)) < 0) {
+                DEBUG(0, "ray_update_parm - No free ccs\n");
+                return;
+        }
+        pccs = ccs_base(local) + ccsindex;
+        writeb(CCS_UPDATE_PARAMS, &pccs->cmd);
+        writeb(objid, &pccs->var.update_param.object_id);
+        writeb(1, &pccs->var.update_param.number_objects);
+        writeb(0, &pccs->var.update_param.failure_cause);
+        for (i = 0; i < len; i++) {
+                writeb(value[i], local->sram + HOST_TO_ECF_BASE);
+        }
+        /* Interrupt the firmware to process the command */
+        if (interrupt_ecf(local, ccsindex)) {
+                DEBUG(0, "ray_cs associate failed - ECF not ready for intr\n");
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+        }
 }
+
 /*===========================================================================*/
 static void ray_update_multi_list(struct net_device *dev, int all)
 {
-    struct dev_mc_list *dmi, **dmip;
-    int ccsindex;
-    struct ccs __iomem *pccs;
-    int i = 0;
-    ray_dev_t *local = netdev_priv(dev);
-    struct pcmcia_device *link = local->finder;
-    void __iomem *p = local->sram + HOST_TO_ECF_BASE;
-
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_update_multi_list - device not present\n");
-        return;
-    }
-    else 
-        DEBUG(2,"ray_update_multi_list(%p)\n",dev);
-    if ((ccsindex = get_free_ccs(local)) < 0)
-    {
-        DEBUG(1,"ray_update_multi - No free ccs\n");
-        return;
-    }
-    pccs = ccs_base(local) + ccsindex;
-    writeb(CCS_UPDATE_MULTICAST_LIST, &pccs->cmd);
-
-    if (all) {
-        writeb(0xff, &pccs->var);
-        local->num_multi = 0xff;
-    }
-    else {
-        /* Copy the kernel's list of MC addresses to card */
-        for (dmip=&dev->mc_list; (dmi=*dmip)!=NULL; dmip=&dmi->next) {
-            memcpy_toio(p, dmi->dmi_addr, ETH_ALEN);
-            DEBUG(1,"ray_update_multi add addr %02x%02x%02x%02x%02x%02x\n",dmi->dmi_addr[0],dmi->dmi_addr[1],dmi->dmi_addr[2],dmi->dmi_addr[3],dmi->dmi_addr[4],dmi->dmi_addr[5]);
-            p += ETH_ALEN;
-            i++;
-        }
-        if (i > 256/ADDRLEN) i = 256/ADDRLEN;
-        writeb((UCHAR)i, &pccs->var);
-        DEBUG(1,"ray_cs update_multi %d addresses in list\n", i);
-        /* Interrupt the firmware to process the command */
-        local->num_multi = i;
-    }
-    if (interrupt_ecf(local, ccsindex)) {
-        DEBUG(1,"ray_cs update_multi failed - ECF not ready for intr\n");
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-    }
+        struct dev_mc_list *dmi, **dmip;
+        int ccsindex;
+        struct ccs __iomem *pccs;
+        int i = 0;
+        ray_dev_t *local = netdev_priv(dev);
+        struct pcmcia_device *link = local->finder;
+        void __iomem *p = local->sram + HOST_TO_ECF_BASE;
+
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_update_multi_list - device not present\n");
+                return;
+        } else
+                DEBUG(2, "ray_update_multi_list(%p)\n", dev);
+        if ((ccsindex = get_free_ccs(local)) < 0) {
+                DEBUG(1, "ray_update_multi - No free ccs\n");
+                return;
+        }
+        pccs = ccs_base(local) + ccsindex;
+        writeb(CCS_UPDATE_MULTICAST_LIST, &pccs->cmd);
+
+        if (all) {
+                writeb(0xff, &pccs->var);
+                local->num_multi = 0xff;
+        } else {
+                /* Copy the kernel's list of MC addresses to card */
+                for (dmip = &dev->mc_list; (dmi = *dmip) != NULL;
+                     dmip = &dmi->next) {
+                        memcpy_toio(p, dmi->dmi_addr, ETH_ALEN);
+                        DEBUG(1,
+                              "ray_update_multi add addr %02x%02x%02x%02x%02x%02x\n",
+                              dmi->dmi_addr[0], dmi->dmi_addr[1],
+                              dmi->dmi_addr[2], dmi->dmi_addr[3],
+                              dmi->dmi_addr[4], dmi->dmi_addr[5]);
+                        p += ETH_ALEN;
+                        i++;
+                }
+                if (i > 256 / ADDRLEN)
+                        i = 256 / ADDRLEN;
+                writeb((UCHAR) i, &pccs->var);
+                DEBUG(1, "ray_cs update_multi %d addresses in list\n", i);
+                /* Interrupt the firmware to process the command */
+                local->num_multi = i;
+        }
+        if (interrupt_ecf(local, ccsindex)) {
+                DEBUG(1,
+                      "ray_cs update_multi failed - ECF not ready for intr\n");
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+        }
 } /* end ray_update_multi_list */
+
 /*===========================================================================*/
 static void set_multicast_list(struct net_device *dev)
 {
-    ray_dev_t *local = netdev_priv(dev);
-    UCHAR promisc;
-
-    DEBUG(2,"ray_cs set_multicast_list(%p)\n",dev);
-
-    if (dev->flags & IFF_PROMISC)
-    {
-        if (local->sparm.b5.a_promiscuous_mode == 0) {
-            DEBUG(1,"ray_cs set_multicast_list promisc on\n");
-            local->sparm.b5.a_promiscuous_mode = 1;
-            promisc = 1;
-            ray_update_parm(dev,  OBJID_promiscuous_mode, \
-                            &promisc, sizeof(promisc));
-        }
-    }
-    else {
-        if (local->sparm.b5.a_promiscuous_mode == 1) {
-            DEBUG(1,"ray_cs set_multicast_list promisc off\n");
-            local->sparm.b5.a_promiscuous_mode = 0;
-            promisc = 0;
-            ray_update_parm(dev,  OBJID_promiscuous_mode, \
-                            &promisc, sizeof(promisc));
-        }
-    }
-
-    if (dev->flags & IFF_ALLMULTI) ray_update_multi_list(dev, 1);
-    else
-    {
-        if (local->num_multi != dev->mc_count) ray_update_multi_list(dev, 0);
-    }
+        ray_dev_t *local = netdev_priv(dev);
+        UCHAR promisc;
+
+        DEBUG(2, "ray_cs set_multicast_list(%p)\n", dev);
+
+        if (dev->flags & IFF_PROMISC) {
+                if (local->sparm.b5.a_promiscuous_mode == 0) {
+                        DEBUG(1, "ray_cs set_multicast_list promisc on\n");
+                        local->sparm.b5.a_promiscuous_mode = 1;
+                        promisc = 1;
+                        ray_update_parm(dev, OBJID_promiscuous_mode,
+                                        &promisc, sizeof(promisc));
+                }
+        } else {
+                if (local->sparm.b5.a_promiscuous_mode == 1) {
+                        DEBUG(1, "ray_cs set_multicast_list promisc off\n");
+                        local->sparm.b5.a_promiscuous_mode = 0;
+                        promisc = 0;
+                        ray_update_parm(dev, OBJID_promiscuous_mode,
+                                        &promisc, sizeof(promisc));
+                }
+        }
+
+        if (dev->flags & IFF_ALLMULTI)
+                ray_update_multi_list(dev, 1);
+        else {
+                if (local->num_multi != dev->mc_count)
+                        ray_update_multi_list(dev, 0);
+        }
 } /* end set_multicast_list */
+
 /*=============================================================================
  * All routines below here are run at interrupt time.
 =============================================================================*/
 static irqreturn_t ray_interrupt(int irq, void *dev_id)
 {
-    struct net_device *dev = (struct net_device *)dev_id;
-    struct pcmcia_device *link;
-    ray_dev_t *local;
-    struct ccs __iomem *pccs;
-    struct rcs __iomem *prcs;
-    UCHAR rcsindex;
-    UCHAR tmp;
-    UCHAR cmd;
-    UCHAR status;
-
-    if (dev == NULL) /* Note that we want interrupts with dev->start == 0 */
-        return IRQ_NONE;
-
-    DEBUG(4,"ray_cs: interrupt for *dev=%p\n",dev);
-
-    local = netdev_priv(dev);
-    link = (struct pcmcia_device *)local->finder;
-    if (!pcmcia_dev_present(link)) {
-        DEBUG(2,"ray_cs interrupt from device not present or suspended.\n");
-        return IRQ_NONE;
-    }
-    rcsindex = readb(&((struct scb __iomem *)(local->sram))->rcs_index);
-
-    if (rcsindex >= (NUMBER_OF_CCS + NUMBER_OF_RCS))
-    {
-        DEBUG(1,"ray_cs interrupt bad rcsindex = 0x%x\n",rcsindex);
-        clear_interrupt(local);
-        return IRQ_HANDLED;
-    }
-    if (rcsindex < NUMBER_OF_CCS) /* If it's a returned CCS */
-    {
-        pccs = ccs_base(local) + rcsindex;
-        cmd = readb(&pccs->cmd);
-        status = readb(&pccs->buffer_status);
-        switch (cmd)
-        {
-        case CCS_DOWNLOAD_STARTUP_PARAMS: /* Happens in firmware someday */
-            del_timer(&local->timer);
-            if (status == CCS_COMMAND_COMPLETE) {
-                DEBUG(1,"ray_cs interrupt download_startup_parameters OK\n");
-            }
-            else {
-                DEBUG(1,"ray_cs interrupt download_startup_parameters fail\n");
-            }
-            break;
-        case CCS_UPDATE_PARAMS:
-            DEBUG(1,"ray_cs interrupt update params done\n");
-            if (status != CCS_COMMAND_COMPLETE) {
-                tmp = readb(&pccs->var.update_param.failure_cause);
-            DEBUG(0,"ray_cs interrupt update params failed - reason %d\n",tmp);
-            }
-            break;
-        case CCS_REPORT_PARAMS:
-            DEBUG(1,"ray_cs interrupt report params done\n");
-            break;
-        case CCS_UPDATE_MULTICAST_LIST: /* Note that this CCS isn't returned */
-            DEBUG(1,"ray_cs interrupt CCS Update Multicast List done\n");
-            break;
-        case CCS_UPDATE_POWER_SAVINGS_MODE:
-            DEBUG(1,"ray_cs interrupt update power save mode done\n");
-            break;
-        case CCS_START_NETWORK:
-        case CCS_JOIN_NETWORK:
-            if (status == CCS_COMMAND_COMPLETE) {
-                if (readb(&pccs->var.start_network.net_initiated) == 1) {
-                    DEBUG(0,"ray_cs interrupt network \"%s\" started\n",\
-                          local->sparm.b4.a_current_ess_id);
-                }
-                else {
-                    DEBUG(0,"ray_cs interrupt network \"%s\" joined\n",\
-                          local->sparm.b4.a_current_ess_id);
-                }
-                memcpy_fromio(&local->bss_id,pccs->var.start_network.bssid,ADDRLEN);
-
-                if (local->fw_ver == 0x55) local->net_default_tx_rate = 3;
-                else local->net_default_tx_rate = 
-                         readb(&pccs->var.start_network.net_default_tx_rate);
-                local->encryption = readb(&pccs->var.start_network.encryption);
-                if (!sniffer && (local->net_type == INFRA)
-                    && !(local->sparm.b4.a_acting_as_ap_status)) {
-                    authenticate(local);
-                }
-                local->card_status = CARD_ACQ_COMPLETE;
-            }
-            else {
-                local->card_status = CARD_ACQ_FAILED;
-
-                del_timer(&local->timer);
-                local->timer.expires = jiffies + HZ*5;
-                local->timer.data = (long)local;
-                if (status == CCS_START_NETWORK) {
-                    DEBUG(0,"ray_cs interrupt network \"%s\" start failed\n",\
-                          local->sparm.b4.a_current_ess_id);
-                    local->timer.function = &start_net;
-                }
-                else {
-                    DEBUG(0,"ray_cs interrupt network \"%s\" join failed\n",\
-                          local->sparm.b4.a_current_ess_id);
-                    local->timer.function = &join_net;
-                }
-                add_timer(&local->timer);
-            }
-            break;
-        case CCS_START_ASSOCIATION:
-            if (status == CCS_COMMAND_COMPLETE) {
-                local->card_status = CARD_ASSOC_COMPLETE;
-                DEBUG(0,"ray_cs association successful\n");
-            }
-            else
-            {
-                DEBUG(0,"ray_cs association failed,\n");
-                local->card_status = CARD_ASSOC_FAILED;
-                join_net((u_long)local);
-            }
-            break;
-        case CCS_TX_REQUEST:
-            if (status == CCS_COMMAND_COMPLETE) {
-                DEBUG(3,"ray_cs interrupt tx request complete\n");
-            }
-            else {
-                DEBUG(1,"ray_cs interrupt tx request failed\n");
-            }
-            if (!sniffer) netif_start_queue(dev);
-            netif_wake_queue(dev);
-            break;
-        case CCS_TEST_MEMORY:
-            DEBUG(1,"ray_cs interrupt mem test done\n");
-            break;
-        case CCS_SHUTDOWN:
-            DEBUG(1,"ray_cs interrupt Unexpected CCS returned - Shutdown\n");
-            break;
-        case CCS_DUMP_MEMORY:
-            DEBUG(1,"ray_cs interrupt dump memory done\n");
-            break;
-        case CCS_START_TIMER:
-            DEBUG(2,"ray_cs interrupt DING - raylink timer expired\n");
-            break;
-        default:
-            DEBUG(1,"ray_cs interrupt Unexpected CCS 0x%x returned 0x%x\n",\
-                  rcsindex, cmd);
-        }
-        writeb(CCS_BUFFER_FREE, &pccs->buffer_status);
-    }
-    else /* It's an RCS */
-    {
-        prcs = rcs_base(local) + rcsindex;
-    
-        switch (readb(&prcs->interrupt_id))
-        {
-        case PROCESS_RX_PACKET:
-            ray_rx(dev, local, prcs);
-            break;
-        case REJOIN_NET_COMPLETE:
-            DEBUG(1,"ray_cs interrupt rejoin net complete\n");
-            local->card_status = CARD_ACQ_COMPLETE;
-            /* do we need to clear tx buffers CCS's? */
-            if (local->sparm.b4.a_network_type == ADHOC) {
-                if (!sniffer) netif_start_queue(dev);
-            }
-            else {
-                memcpy_fromio(&local->bss_id, prcs->var.rejoin_net_complete.bssid, ADDRLEN);
-                DEBUG(1,"ray_cs new BSSID = %02x%02x%02x%02x%02x%02x\n",\
-                      local->bss_id[0], local->bss_id[1], local->bss_id[2],\
-                      local->bss_id[3], local->bss_id[4], local->bss_id[5]);
-                if (!sniffer) authenticate(local);
-            }
-            break;
-        case ROAMING_INITIATED:
-            DEBUG(1,"ray_cs interrupt roaming initiated\n"); 
-            netif_stop_queue(dev);
-            local->card_status = CARD_DOING_ACQ;
-            break;
-        case JAPAN_CALL_SIGN_RXD:
-            DEBUG(1,"ray_cs interrupt japan call sign rx\n");
-            break;
-        default:
-            DEBUG(1,"ray_cs Unexpected interrupt for RCS 0x%x cmd = 0x%x\n",\
-                  rcsindex, (unsigned int) readb(&prcs->interrupt_id));
-            break;
-        }
-        writeb(CCS_BUFFER_FREE, &prcs->buffer_status);
-    }
-    clear_interrupt(local);
-    return IRQ_HANDLED;
+        struct net_device *dev = (struct net_device *)dev_id;
+        struct pcmcia_device *link;
+        ray_dev_t *local;
+        struct ccs __iomem *pccs;
+        struct rcs __iomem *prcs;
+        UCHAR rcsindex;
+        UCHAR tmp;
+        UCHAR cmd;
+        UCHAR status;
+
+        if (dev == NULL)        /* Note that we want interrupts with dev->start == 0 */
+                return IRQ_NONE;
+
+        DEBUG(4, "ray_cs: interrupt for *dev=%p\n", dev);
+
+        local = netdev_priv(dev);
+        link = (struct pcmcia_device *)local->finder;
+        if (!pcmcia_dev_present(link)) {
+                DEBUG(2,
+                      "ray_cs interrupt from device not present or suspended.\n");
+                return IRQ_NONE;
+        }
+        rcsindex = readb(&((struct scb __iomem *)(local->sram))->rcs_index);
+
+        if (rcsindex >= (NUMBER_OF_CCS + NUMBER_OF_RCS)) {
+                DEBUG(1, "ray_cs interrupt bad rcsindex = 0x%x\n", rcsindex);
+                clear_interrupt(local);
+                return IRQ_HANDLED;
+        }
+        if (rcsindex < NUMBER_OF_CCS) { /* If it's a returned CCS */
+                pccs = ccs_base(local) + rcsindex;
+                cmd = readb(&pccs->cmd);
+                status = readb(&pccs->buffer_status);
+                switch (cmd) {
+                case CCS_DOWNLOAD_STARTUP_PARAMS:       /* Happens in firmware someday */
+                        del_timer(&local->timer);
+                        if (status == CCS_COMMAND_COMPLETE) {
+                                DEBUG(1,
+                                      "ray_cs interrupt download_startup_parameters OK\n");
+                        } else {
+                                DEBUG(1,
+                                      "ray_cs interrupt download_startup_parameters fail\n");
+                        }
+                        break;
+                case CCS_UPDATE_PARAMS:
+                        DEBUG(1, "ray_cs interrupt update params done\n");
+                        if (status != CCS_COMMAND_COMPLETE) {
+                                tmp =
+                                    readb(&pccs->var.update_param.
+                                          failure_cause);
+                                DEBUG(0,
+                                      "ray_cs interrupt update params failed - reason %d\n",
+                                      tmp);
+                        }
+                        break;
+                case CCS_REPORT_PARAMS:
+                        DEBUG(1, "ray_cs interrupt report params done\n");
+                        break;
+                case CCS_UPDATE_MULTICAST_LIST: /* Note that this CCS isn't returned */
+                        DEBUG(1,
+                              "ray_cs interrupt CCS Update Multicast List done\n");
+                        break;
+                case CCS_UPDATE_POWER_SAVINGS_MODE:
+                        DEBUG(1,
+                              "ray_cs interrupt update power save mode done\n");
+                        break;
+                case CCS_START_NETWORK:
+                case CCS_JOIN_NETWORK:
+                        if (status == CCS_COMMAND_COMPLETE) {
+                                if (readb
+                                    (&pccs->var.start_network.net_initiated) ==
+                                    1) {
+                                        DEBUG(0,
+                                              "ray_cs interrupt network \"%s\" started\n",
+                                              local->sparm.b4.a_current_ess_id);
+                                } else {
+                                        DEBUG(0,
+                                              "ray_cs interrupt network \"%s\" joined\n",
+                                              local->sparm.b4.a_current_ess_id);
+                                }
+                                memcpy_fromio(&local->bss_id,
+                                              pccs->var.start_network.bssid,
+                                              ADDRLEN);
+
+                                if (local->fw_ver == 0x55)
+                                        local->net_default_tx_rate = 3;
+                                else
+                                        local->net_default_tx_rate =
+                                            readb(&pccs->var.start_network.
+                                                  net_default_tx_rate);
+                                local->encryption =
+                                    readb(&pccs->var.start_network.encryption);
+                                if (!sniffer && (local->net_type == INFRA)
+                                    && !(local->sparm.b4.a_acting_as_ap_status)) {
+                                        authenticate(local);
+                                }
+                                local->card_status = CARD_ACQ_COMPLETE;
+                        } else {
+                                local->card_status = CARD_ACQ_FAILED;
+
+                                del_timer(&local->timer);
+                                local->timer.expires = jiffies + HZ * 5;
+                                local->timer.data = (long)local;
+                                if (status == CCS_START_NETWORK) {
+                                        DEBUG(0,
+                                              "ray_cs interrupt network \"%s\" start failed\n",
+                                              local->sparm.b4.a_current_ess_id);
+                                        local->timer.function = &start_net;
+                                } else {
+                                        DEBUG(0,
+                                              "ray_cs interrupt network \"%s\" join failed\n",
+                                              local->sparm.b4.a_current_ess_id);
+                                        local->timer.function = &join_net;
+                                }
+                                add_timer(&local->timer);
+                        }
+                        break;
+                case CCS_START_ASSOCIATION:
+                        if (status == CCS_COMMAND_COMPLETE) {
+                                local->card_status = CARD_ASSOC_COMPLETE;
+                                DEBUG(0, "ray_cs association successful\n");
+                        } else {
+                                DEBUG(0, "ray_cs association failed,\n");
+                                local->card_status = CARD_ASSOC_FAILED;
+                                join_net((u_long) local);
+                        }
+                        break;
+                case CCS_TX_REQUEST:
+                        if (status == CCS_COMMAND_COMPLETE) {
+                                DEBUG(3,
+                                      "ray_cs interrupt tx request complete\n");
+                        } else {
+                                DEBUG(1,
+                                      "ray_cs interrupt tx request failed\n");
+                        }
+                        if (!sniffer)
+                                netif_start_queue(dev);
+                        netif_wake_queue(dev);
+                        break;
+                case CCS_TEST_MEMORY:
+                        DEBUG(1, "ray_cs interrupt mem test done\n");
+                        break;
+                case CCS_SHUTDOWN:
+                        DEBUG(1,
+                              "ray_cs interrupt Unexpected CCS returned - Shutdown\n");
+                        break;
+                case CCS_DUMP_MEMORY:
+                        DEBUG(1, "ray_cs interrupt dump memory done\n");
+                        break;
+                case CCS_START_TIMER:
+                        DEBUG(2,
+                              "ray_cs interrupt DING - raylink timer expired\n");
+                        break;
+                default:
+                        DEBUG(1,
+                              "ray_cs interrupt Unexpected CCS 0x%x returned 0x%x\n",
+                              rcsindex, cmd);
+                }
+                writeb(CCS_BUFFER_FREE, &pccs->buffer_status);
+        } else { /* It's an RCS */
+
+                prcs = rcs_base(local) + rcsindex;
+
+                switch (readb(&prcs->interrupt_id)) {
+                case PROCESS_RX_PACKET:
+                        ray_rx(dev, local, prcs);
+                        break;
+                case REJOIN_NET_COMPLETE:
+                        DEBUG(1, "ray_cs interrupt rejoin net complete\n");
+                        local->card_status = CARD_ACQ_COMPLETE;
+                        /* do we need to clear tx buffers CCS's? */
+                        if (local->sparm.b4.a_network_type == ADHOC) {
+                                if (!sniffer)
+                                        netif_start_queue(dev);
+                        } else {
+                                memcpy_fromio(&local->bss_id,
+                                              prcs->var.rejoin_net_complete.
+                                              bssid, ADDRLEN);
+                                DEBUG(1,
+                                      "ray_cs new BSSID = %02x%02x%02x%02x%02x%02x\n",
+                                      local->bss_id[0], local->bss_id[1],
+                                      local->bss_id[2], local->bss_id[3],
+                                      local->bss_id[4], local->bss_id[5]);
+                                if (!sniffer)
+                                        authenticate(local);
+                        }
+                        break;
+                case ROAMING_INITIATED:
+                        DEBUG(1, "ray_cs interrupt roaming initiated\n");
+                        netif_stop_queue(dev);
+                        local->card_status = CARD_DOING_ACQ;
+                        break;
+                case JAPAN_CALL_SIGN_RXD:
+                        DEBUG(1, "ray_cs interrupt japan call sign rx\n");
+                        break;
+                default:
+                        DEBUG(1,
+                              "ray_cs Unexpected interrupt for RCS 0x%x cmd = 0x%x\n",
+                              rcsindex,
+                              (unsigned int)readb(&prcs->interrupt_id));
+                        break;
+                }
+                writeb(CCS_BUFFER_FREE, &prcs->buffer_status);
+        }
+        clear_interrupt(local);
+        return IRQ_HANDLED;
 } /* ray_interrupt */
+
 /*===========================================================================*/
-static void ray_rx(struct net_device *dev, ray_dev_t *local, struct rcs __iomem *prcs)
-{
-    int rx_len;
-    unsigned int pkt_addr;
-    void __iomem *pmsg;
-    DEBUG(4,"ray_rx process rx packet\n");
-
-    /* Calculate address of packet within Rx buffer */
-    pkt_addr = ((readb(&prcs->var.rx_packet.rx_data_ptr[0]) << 8)
-                + readb(&prcs->var.rx_packet.rx_data_ptr[1])) & RX_BUFF_END;
-    /* Length of first packet fragment */
-    rx_len = (readb(&prcs->var.rx_packet.rx_data_length[0]) << 8)
-        + readb(&prcs->var.rx_packet.rx_data_length[1]);
-
-    local->last_rsl = readb(&prcs->var.rx_packet.rx_sig_lev);
-    pmsg = local->rmem + pkt_addr;
-    switch(readb(pmsg))
-    {
-    case DATA_TYPE:
-        DEBUG(4,"ray_rx data type\n");
-        rx_data(dev, prcs, pkt_addr, rx_len);
-        break;
-    case AUTHENTIC_TYPE:
-        DEBUG(4,"ray_rx authentic type\n");
-        if (sniffer) rx_data(dev, prcs, pkt_addr, rx_len);
-        else rx_authenticate(local, prcs, pkt_addr, rx_len);
-        break;
-    case DEAUTHENTIC_TYPE:
-        DEBUG(4,"ray_rx deauth type\n");
-        if (sniffer) rx_data(dev, prcs, pkt_addr, rx_len);
-        else rx_deauthenticate(local, prcs, pkt_addr, rx_len);
-        break;
-    case NULL_MSG_TYPE:
-        DEBUG(3,"ray_cs rx NULL msg\n");
-        break;
-    case BEACON_TYPE:
-        DEBUG(4,"ray_rx beacon type\n");
-        if (sniffer) rx_data(dev, prcs, pkt_addr, rx_len);
-
-        copy_from_rx_buff(local, (UCHAR *)&local->last_bcn, pkt_addr, 
-                          rx_len < sizeof(struct beacon_rx) ? 
-                          rx_len : sizeof(struct beacon_rx));
-
-        local->beacon_rxed = 1;
-        /* Get the statistics so the card counters never overflow */
-        ray_get_stats(dev);
-            break;
-    default:
-        DEBUG(0,"ray_cs unknown pkt type %2x\n", (unsigned int) readb(pmsg));
-        break;
-    }
+static void ray_rx(struct net_device *dev, ray_dev_t *local,
+                   struct rcs __iomem *prcs)
+{
+        int rx_len;
+        unsigned int pkt_addr;
+        void __iomem *pmsg;
+        DEBUG(4, "ray_rx process rx packet\n");
+
+        /* Calculate address of packet within Rx buffer */
+        pkt_addr = ((readb(&prcs->var.rx_packet.rx_data_ptr[0]) << 8)
+                    + readb(&prcs->var.rx_packet.rx_data_ptr[1])) & RX_BUFF_END;
+        /* Length of first packet fragment */
+        rx_len = (readb(&prcs->var.rx_packet.rx_data_length[0]) << 8)
+            + readb(&prcs->var.rx_packet.rx_data_length[1]);
+
+        local->last_rsl = readb(&prcs->var.rx_packet.rx_sig_lev);
+        pmsg = local->rmem + pkt_addr;
+        switch (readb(pmsg)) {
+        case DATA_TYPE:
+                DEBUG(4, "ray_rx data type\n");
+                rx_data(dev, prcs, pkt_addr, rx_len);
+                break;
+        case AUTHENTIC_TYPE:
+                DEBUG(4, "ray_rx authentic type\n");
+                if (sniffer)
+                        rx_data(dev, prcs, pkt_addr, rx_len);
+                else
+                        rx_authenticate(local, prcs, pkt_addr, rx_len);
+                break;
+        case DEAUTHENTIC_TYPE:
+                DEBUG(4, "ray_rx deauth type\n");
+                if (sniffer)
+                        rx_data(dev, prcs, pkt_addr, rx_len);
+                else
+                        rx_deauthenticate(local, prcs, pkt_addr, rx_len);
+                break;
+        case NULL_MSG_TYPE:
+                DEBUG(3, "ray_cs rx NULL msg\n");
+                break;
+        case BEACON_TYPE:
+                DEBUG(4, "ray_rx beacon type\n");
+                if (sniffer)
+                        rx_data(dev, prcs, pkt_addr, rx_len);
+
+                copy_from_rx_buff(local, (UCHAR *) &local->last_bcn, pkt_addr,
+                                  rx_len < sizeof(struct beacon_rx) ?
+                                  rx_len : sizeof(struct beacon_rx));
+
+                local->beacon_rxed = 1;
+                /* Get the statistics so the card counters never overflow */
+                ray_get_stats(dev);
+                break;
+        default:
+                DEBUG(0, "ray_cs unknown pkt type %2x\n",
+                      (unsigned int)readb(pmsg));
+                break;
+        }
 
 } /* end ray_rx */
+
 /*===========================================================================*/
-static void rx_data(struct net_device *dev, struct rcs __iomem *prcs, unsigned int pkt_addr, 
-             int rx_len)
-{
-    struct sk_buff *skb = NULL;
-    struct rcs __iomem *prcslink = prcs;
-    ray_dev_t *local = netdev_priv(dev);
-    UCHAR *rx_ptr;
-    int total_len;
-    int tmp;
+static void rx_data(struct net_device *dev, struct rcs __iomem *prcs,
+                    unsigned int pkt_addr, int rx_len)
+{
+        struct sk_buff *skb = NULL;
+        struct rcs __iomem *prcslink = prcs;
+        ray_dev_t *local = netdev_priv(dev);
+        UCHAR *rx_ptr;
+        int total_len;
+        int tmp;
 #ifdef WIRELESS_SPY
-    int siglev = local->last_rsl;
-    u_char linksrcaddr[ETH_ALEN];       /* Other end of the wireless link */
+        int siglev = local->last_rsl;
+        u_char linksrcaddr[ETH_ALEN];   /* Other end of the wireless link */
 #endif
 
-    if (!sniffer) {
-        if (translate) {
+        if (!sniffer) {
+                if (translate) {
 /* TBD length needs fixing for translated header */
-            if (rx_len < (ETH_HLEN + RX_MAC_HEADER_LENGTH) ||
-                rx_len > (dev->mtu + RX_MAC_HEADER_LENGTH + ETH_HLEN + FCS_LEN)) 
-            {
-                DEBUG(0,"ray_cs invalid packet length %d received \n",rx_len);
-                return;
-            }
-        }
-        else /* encapsulated ethernet */ {
-            if (rx_len < (ETH_HLEN + RX_MAC_HEADER_LENGTH) ||
-                rx_len > (dev->mtu + RX_MAC_HEADER_LENGTH + ETH_HLEN + FCS_LEN))
-            {
-                DEBUG(0,"ray_cs invalid packet length %d received \n",rx_len);
-                return;
-            }
-        }
-    }
-    DEBUG(4,"ray_cs rx_data packet\n");
-    /* If fragmented packet, verify sizes of fragments add up */
-    if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF) {
-        DEBUG(1,"ray_cs rx'ed fragment\n");
-        tmp = (readb(&prcs->var.rx_packet.totalpacketlength[0]) << 8)
-            +  readb(&prcs->var.rx_packet.totalpacketlength[1]);
-        total_len = tmp;
-        prcslink = prcs;
-        do {
-            tmp -= (readb(&prcslink->var.rx_packet.rx_data_length[0]) << 8)
-                +   readb(&prcslink->var.rx_packet.rx_data_length[1]);
-            if (readb(&prcslink->var.rx_packet.next_frag_rcs_index) == 0xFF
-                || tmp < 0) break;
-            prcslink = rcs_base(local)
-                + readb(&prcslink->link_field);
-        } while (1);
-
-        if (tmp < 0)
-        {
-            DEBUG(0,"ray_cs rx_data fragment lengths don't add up\n");
-            local->stats.rx_dropped++; 
-            release_frag_chain(local, prcs);
-            return;
-        }
-    }
-    else { /* Single unfragmented packet */
-        total_len = rx_len;
-    }
-
-    skb = dev_alloc_skb( total_len+5 );
-    if (skb == NULL)
-    {
-        DEBUG(0,"ray_cs rx_data could not allocate skb\n");
-        local->stats.rx_dropped++; 
-        if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF)
-            release_frag_chain(local, prcs);
-        return;
-    }
-    skb_reserve( skb, 2);   /* Align IP on 16 byte (TBD check this)*/
-
-    DEBUG(4,"ray_cs rx_data total_len = %x, rx_len = %x\n",total_len,rx_len);
+                        if (rx_len < (ETH_HLEN + RX_MAC_HEADER_LENGTH) ||
+                            rx_len >
+                            (dev->mtu + RX_MAC_HEADER_LENGTH + ETH_HLEN +
+                             FCS_LEN)) {
+                                DEBUG(0,
+                                      "ray_cs invalid packet length %d received \n",
+                                      rx_len);
+                                return;
+                        }
+                } else { /* encapsulated ethernet */
+
+                        if (rx_len < (ETH_HLEN + RX_MAC_HEADER_LENGTH) ||
+                            rx_len >
+                            (dev->mtu + RX_MAC_HEADER_LENGTH + ETH_HLEN +
+                             FCS_LEN)) {
+                                DEBUG(0,
+                                      "ray_cs invalid packet length %d received \n",
+                                      rx_len);
+                                return;
+                        }
+                }
+        }
+        DEBUG(4, "ray_cs rx_data packet\n");
+        /* If fragmented packet, verify sizes of fragments add up */
+        if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF) {
+                DEBUG(1, "ray_cs rx'ed fragment\n");
+                tmp = (readb(&prcs->var.rx_packet.totalpacketlength[0]) << 8)
+                    + readb(&prcs->var.rx_packet.totalpacketlength[1]);
+                total_len = tmp;
+                prcslink = prcs;
+                do {
+                        tmp -=
+                            (readb(&prcslink->var.rx_packet.rx_data_length[0])
+                             << 8)
+                            + readb(&prcslink->var.rx_packet.rx_data_length[1]);
+                        if (readb(&prcslink->var.rx_packet.next_frag_rcs_index)
+                            == 0xFF || tmp < 0)
+                                break;
+                        prcslink = rcs_base(local)
+                            + readb(&prcslink->link_field);
+                } while (1);
+
+                if (tmp < 0) {
+                        DEBUG(0,
+                              "ray_cs rx_data fragment lengths don't add up\n");
+                        local->stats.rx_dropped++;
+                        release_frag_chain(local, prcs);
+                        return;
+                }
+        } else { /* Single unfragmented packet */
+                total_len = rx_len;
+        }
+
+        skb = dev_alloc_skb(total_len + 5);
+        if (skb == NULL) {
+                DEBUG(0, "ray_cs rx_data could not allocate skb\n");
+                local->stats.rx_dropped++;
+                if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF)
+                        release_frag_chain(local, prcs);
+                return;
+        }
+        skb_reserve(skb, 2);    /* Align IP on 16 byte (TBD check this) */
+
+        DEBUG(4, "ray_cs rx_data total_len = %x, rx_len = %x\n", total_len,
+              rx_len);
 
 /************************/
-    /* Reserve enough room for the whole damn packet. */
-    rx_ptr = skb_put( skb, total_len);
-    /* Copy the whole packet to sk_buff */
-    rx_ptr += copy_from_rx_buff(local, rx_ptr, pkt_addr & RX_BUFF_END, rx_len);
-    /* Get source address */
+        /* Reserve enough room for the whole damn packet. */
+        rx_ptr = skb_put(skb, total_len);
+        /* Copy the whole packet to sk_buff */
+        rx_ptr +=
+            copy_from_rx_buff(local, rx_ptr, pkt_addr & RX_BUFF_END, rx_len);
+        /* Get source address */
 #ifdef WIRELESS_SPY
-    skb_copy_from_linear_data_offset(skb, offsetof(struct mac_header, addr_2),
-                                     linksrcaddr, ETH_ALEN);
+        skb_copy_from_linear_data_offset(skb,
+                                         offsetof(struct mac_header, addr_2),
+                                         linksrcaddr, ETH_ALEN);
 #endif
-    /* Now, deal with encapsulation/translation/sniffer */
-    if (!sniffer) {
-        if (!translate) { 
-            /* Encapsulated ethernet, so just lop off 802.11 MAC header */
+        /* Now, deal with encapsulation/translation/sniffer */
+        if (!sniffer) {
+                if (!translate) {
+                        /* Encapsulated ethernet, so just lop off 802.11 MAC header */
 /* TBD reserve            skb_reserve( skb, RX_MAC_HEADER_LENGTH); */
-            skb_pull( skb, RX_MAC_HEADER_LENGTH);
-        }
-        else {
-            /* Do translation */
-            untranslate(local, skb, total_len);
-        }
-    }
-    else 
-    {  /* sniffer mode, so just pass whole packet */  };
+                        skb_pull(skb, RX_MAC_HEADER_LENGTH);
+                } else {
+                        /* Do translation */
+                        untranslate(local, skb, total_len);
+                }
+        } else { /* sniffer mode, so just pass whole packet */
+        };
 
 /************************/
-    /* Now pick up the rest of the fragments if any */
-    tmp = 17; 
-    if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF) {
-        prcslink = prcs;
-        DEBUG(1,"ray_cs rx_data in fragment loop\n");
-        do {
-            prcslink = rcs_base(local)
-                + readb(&prcslink->var.rx_packet.next_frag_rcs_index);
-            rx_len = (( readb(&prcslink->var.rx_packet.rx_data_length[0]) << 8)
-                      + readb(&prcslink->var.rx_packet.rx_data_length[1]))
-                & RX_BUFF_END;
-            pkt_addr = (( readb(&prcslink->var.rx_packet.rx_data_ptr[0]) << 8)
-                        + readb(&prcslink->var.rx_packet.rx_data_ptr[1]))
-                & RX_BUFF_END;
-
-            rx_ptr += copy_from_rx_buff(local, rx_ptr, pkt_addr, rx_len);
-
-        } while (tmp-- && 
-                 readb(&prcslink->var.rx_packet.next_frag_rcs_index) != 0xFF);
-        release_frag_chain(local, prcs);
-    }
-
-    skb->protocol = eth_type_trans(skb,dev);
-    netif_rx(skb);
-    local->stats.rx_packets++;
-    local->stats.rx_bytes += total_len;
-
-    /* Gather signal strength per address */
+        /* Now pick up the rest of the fragments if any */
+        tmp = 17;
+        if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF) {
+                prcslink = prcs;
+                DEBUG(1, "ray_cs rx_data in fragment loop\n");
+                do {
+                        prcslink = rcs_base(local)
+                            +
+                            readb(&prcslink->var.rx_packet.next_frag_rcs_index);
+                        rx_len =
+                            ((readb(&prcslink->var.rx_packet.rx_data_length[0])
+                              << 8)
+                             +
+                             readb(&prcslink->var.rx_packet.rx_data_length[1]))
+                            & RX_BUFF_END;
+                        pkt_addr =
+                            ((readb(&prcslink->var.rx_packet.rx_data_ptr[0]) <<
+                              8)
+                             + readb(&prcslink->var.rx_packet.rx_data_ptr[1]))
+                            & RX_BUFF_END;
+
+                        rx_ptr +=
+                            copy_from_rx_buff(local, rx_ptr, pkt_addr, rx_len);
+
+                } while (tmp-- &&
+                         readb(&prcslink->var.rx_packet.next_frag_rcs_index) !=
+                         0xFF);
+                release_frag_chain(local, prcs);
+        }
+
+        skb->protocol = eth_type_trans(skb, dev);
+        netif_rx(skb);
+        local->stats.rx_packets++;
+        local->stats.rx_bytes += total_len;
+
+        /* Gather signal strength per address */
 #ifdef WIRELESS_SPY
-    /* For the Access Point or the node having started the ad-hoc net
-     * note : ad-hoc work only in some specific configurations, but we
-     * kludge in ray_get_wireless_stats... */
-    if(!memcmp(linksrcaddr, local->bss_id, ETH_ALEN))
-      {
-        /* Update statistics */
-        /*local->wstats.qual.qual = none ? */
-        local->wstats.qual.level = siglev;
-        /*local->wstats.qual.noise = none ? */
-        local->wstats.qual.updated = 0x2;
-      }
-    /* Now, update the spy stuff */
-    {
-        struct iw_quality wstats;
-        wstats.level = siglev;
-        /* wstats.noise = none ? */
-        /* wstats.qual = none ? */
-        wstats.updated = 0x2;
-        /* Update spy records */
-        wireless_spy_update(dev, linksrcaddr, &wstats);
-    }
-#endif  /* WIRELESS_SPY */
+        /* For the Access Point or the node having started the ad-hoc net
+         * note : ad-hoc work only in some specific configurations, but we
+         * kludge in ray_get_wireless_stats... */
+        if (!memcmp(linksrcaddr, local->bss_id, ETH_ALEN)) {
+                /* Update statistics */
+                /*local->wstats.qual.qual = none ? */
+                local->wstats.qual.level = siglev;
+                /*local->wstats.qual.noise = none ? */
+                local->wstats.qual.updated = 0x2;
+        }
+        /* Now, update the spy stuff */
+        {
+                struct iw_quality wstats;
+                wstats.level = siglev;
+                /* wstats.noise = none ? */
+                /* wstats.qual = none ? */
+                wstats.updated = 0x2;
+                /* Update spy records */
+                wireless_spy_update(dev, linksrcaddr, &wstats);
+        }
+#endif /* WIRELESS_SPY */
 } /* end rx_data */
+
 /*===========================================================================*/
 static void untranslate(ray_dev_t *local, struct sk_buff *skb, int len)
 {
-    snaphdr_t *psnap = (snaphdr_t *)(skb->data + RX_MAC_HEADER_LENGTH);
-    struct ieee80211_hdr *pmac = (struct ieee80211_hdr *)skb->data;
-    __be16 type = *(__be16 *)psnap->ethertype;
-    int delta;
-    struct ethhdr *peth;
-    UCHAR srcaddr[ADDRLEN];
-    UCHAR destaddr[ADDRLEN];
-    static UCHAR org_bridge[3] = {0, 0, 0xf8};
-    static UCHAR org_1042[3] = {0, 0, 0};
+        snaphdr_t *psnap = (snaphdr_t *) (skb->data + RX_MAC_HEADER_LENGTH);
+        struct ieee80211_hdr *pmac = (struct ieee80211_hdr *)skb->data;
+        __be16 type = *(__be16 *) psnap->ethertype;
+        int delta;
+        struct ethhdr *peth;
+        UCHAR srcaddr[ADDRLEN];
+        UCHAR destaddr[ADDRLEN];
+        static UCHAR org_bridge[3] = { 0, 0, 0xf8 };
+        static UCHAR org_1042[3] = { 0, 0, 0 };
 
-    memcpy(destaddr, ieee80211_get_DA(pmac), ADDRLEN);
-    memcpy(srcaddr, ieee80211_get_SA(pmac), ADDRLEN);
+        memcpy(destaddr, ieee80211_get_DA(pmac), ADDRLEN);
+        memcpy(srcaddr, ieee80211_get_SA(pmac), ADDRLEN);
 
 #ifdef PCMCIA_DEBUG
-    if (pc_debug > 3) {
-    int i;
-    printk(KERN_DEBUG "skb->data before untranslate");
-    for (i=0;i<64;i++) 
-        printk("%02x ",skb->data[i]);
-    printk("\n" KERN_DEBUG "type = %08x, xsap = %02x%02x%02x, org = %02x02x02x\n",
-           ntohs(type),
-           psnap->dsap, psnap->ssap, psnap->ctrl,
-           psnap->org[0], psnap->org[1], psnap->org[2]);
-    printk(KERN_DEBUG "untranslate skb->data = %p\n",skb->data);
-    }
+        if (pc_debug > 3) {
+                int i;
+                printk(KERN_DEBUG "skb->data before untranslate");
+                for (i = 0; i < 64; i++)
+                        printk("%02x ", skb->data[i]);
+                printk("\n" KERN_DEBUG
+                       "type = %08x, xsap = %02x%02x%02x, org = %02x02x02x\n",
+                       ntohs(type), psnap->dsap, psnap->ssap, psnap->ctrl,
+                       psnap->org[0], psnap->org[1], psnap->org[2]);
+                printk(KERN_DEBUG "untranslate skb->data = %p\n", skb->data);
+        }
 #endif
 
-    if (psnap->dsap != 0xaa || psnap->ssap != 0xaa || psnap->ctrl != 3) {
-        /* not a snap type so leave it alone */
-        DEBUG(3,"ray_cs untranslate NOT SNAP %02x %02x %02x\n",
-                psnap->dsap, psnap->ssap, psnap->ctrl);
-
-        delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
-        peth = (struct ethhdr *)(skb->data + delta);
-        peth->h_proto = htons(len - RX_MAC_HEADER_LENGTH);
-    }
-    else { /* Its a SNAP */
-        if (memcmp(psnap->org, org_bridge, 3) == 0) { /* EtherII and nuke the LLC  */
-        DEBUG(3,"ray_cs untranslate Bridge encap\n");
-            delta = RX_MAC_HEADER_LENGTH 
-                + sizeof(struct snaphdr_t) - ETH_HLEN;
-            peth = (struct ethhdr *)(skb->data + delta);
-            peth->h_proto = type;
-        } else if (memcmp(psnap->org, org_1042, 3) == 0) {
-                switch (ntohs(type)) {
-                case ETH_P_IPX:
-                case ETH_P_AARP:
-                    DEBUG(3,"ray_cs untranslate RFC IPX/AARP\n");
-                    delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
-                    peth = (struct ethhdr *)(skb->data + delta);
-                    peth->h_proto = htons(len - RX_MAC_HEADER_LENGTH);
-                    break;
-                default:
-                    DEBUG(3,"ray_cs untranslate RFC default\n");
-                    delta = RX_MAC_HEADER_LENGTH + 
-                        sizeof(struct snaphdr_t) - ETH_HLEN;
-                    peth = (struct ethhdr *)(skb->data + delta);
-                    peth->h_proto = type;
-                    break;
-                }
-        } else {
-                printk("ray_cs untranslate very confused by packet\n");
-                delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
-                peth = (struct ethhdr *)(skb->data + delta);
-                peth->h_proto = type;
+        if (psnap->dsap != 0xaa || psnap->ssap != 0xaa || psnap->ctrl != 3) {
+                /* not a snap type so leave it alone */
+                DEBUG(3, "ray_cs untranslate NOT SNAP %02x %02x %02x\n",
+                      psnap->dsap, psnap->ssap, psnap->ctrl);
+
+                delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
+                peth = (struct ethhdr *)(skb->data + delta);
+                peth->h_proto = htons(len - RX_MAC_HEADER_LENGTH);
+        } else { /* Its a SNAP */
+                if (memcmp(psnap->org, org_bridge, 3) == 0) {
+                /* EtherII and nuke the LLC */
+                        DEBUG(3, "ray_cs untranslate Bridge encap\n");
+                        delta = RX_MAC_HEADER_LENGTH
+                            + sizeof(struct snaphdr_t) - ETH_HLEN;
+                        peth = (struct ethhdr *)(skb->data + delta);
+                        peth->h_proto = type;
+                } else if (memcmp(psnap->org, org_1042, 3) == 0) {
+                        switch (ntohs(type)) {
+                        case ETH_P_IPX:
+                        case ETH_P_AARP:
+                                DEBUG(3, "ray_cs untranslate RFC IPX/AARP\n");
+                                delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
+                                peth = (struct ethhdr *)(skb->data + delta);
+                                peth->h_proto =
+                                    htons(len - RX_MAC_HEADER_LENGTH);
+                                break;
+                        default:
+                                DEBUG(3, "ray_cs untranslate RFC default\n");
+                                delta = RX_MAC_HEADER_LENGTH +
+                                    sizeof(struct snaphdr_t) - ETH_HLEN;
+                                peth = (struct ethhdr *)(skb->data + delta);
+                                peth->h_proto = type;
+                                break;
+                        }
+                } else {
+                        printk("ray_cs untranslate very confused by packet\n");
+                        delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
+                        peth = (struct ethhdr *)(skb->data + delta);
+                        peth->h_proto = type;
+                }
         }
-    }
 /* TBD reserve  skb_reserve(skb, delta); */
-    skb_pull(skb, delta);
-    DEBUG(3,"untranslate after skb_pull(%d), skb->data = %p\n",delta,skb->data);
-    memcpy(peth->h_dest, destaddr, ADDRLEN);
-    memcpy(peth->h_source, srcaddr, ADDRLEN);
+        skb_pull(skb, delta);
+        DEBUG(3, "untranslate after skb_pull(%d), skb->data = %p\n", delta,
+              skb->data);
+        memcpy(peth->h_dest, destaddr, ADDRLEN);
+        memcpy(peth->h_source, srcaddr, ADDRLEN);
 #ifdef PCMCIA_DEBUG
-    if (pc_debug > 3) {
-    int i;
-    printk(KERN_DEBUG "skb->data after untranslate:");
-    for (i=0;i<64;i++)
-        printk("%02x ",skb->data[i]);
-    printk("\n");
-    }
+        if (pc_debug > 3) {
+                int i;
+                printk(KERN_DEBUG "skb->data after untranslate:");
+                for (i = 0; i < 64; i++)
+                        printk("%02x ", skb->data[i]);
+                printk("\n");
+        }
 #endif
 } /* end untranslate */
+
 /*===========================================================================*/
 /* Copy data from circular receive buffer to PC memory.
  * dest     = destination address in PC memory
  * pkt_addr = source address in receive buffer
  * len      = length of packet to copy
  */
-static int copy_from_rx_buff(ray_dev_t *local, UCHAR *dest, int pkt_addr, int length)
-{
-    int wrap_bytes = (pkt_addr + length) - (RX_BUFF_END + 1);
-    if (wrap_bytes <= 0)
-    {
-        memcpy_fromio(dest,local->rmem + pkt_addr,length);
-    }
-    else /* Packet wrapped in circular buffer */
-    {
-        memcpy_fromio(dest,local->rmem+pkt_addr,length - wrap_bytes);
-        memcpy_fromio(dest + length - wrap_bytes, local->rmem, wrap_bytes);
-    }
-    return length;
+static int copy_from_rx_buff(ray_dev_t *local, UCHAR *dest, int pkt_addr,
+                             int length)
+{
+        int wrap_bytes = (pkt_addr + length) - (RX_BUFF_END + 1);
+        if (wrap_bytes <= 0) {
+                memcpy_fromio(dest, local->rmem + pkt_addr, length);
+        } else { /* Packet wrapped in circular buffer */
+
+                memcpy_fromio(dest, local->rmem + pkt_addr,
+                              length - wrap_bytes);
+                memcpy_fromio(dest + length - wrap_bytes, local->rmem,
+                              wrap_bytes);
+        }
+        return length;
 }
+
 /*===========================================================================*/
-static void release_frag_chain(ray_dev_t *local, struct rcs __iomem * prcs)
-{
-    struct rcs __iomem *prcslink = prcs;
-    int tmp = 17;
-    unsigned rcsindex = readb(&prcs->var.rx_packet.next_frag_rcs_index);
-
-    while (tmp--) {
-        writeb(CCS_BUFFER_FREE, &prcslink->buffer_status);
-        if (rcsindex >= (NUMBER_OF_CCS + NUMBER_OF_RCS)) {
-            DEBUG(1,"ray_cs interrupt bad rcsindex = 0x%x\n",rcsindex);
-            break;      
-        }   
-        prcslink = rcs_base(local) + rcsindex;
-        rcsindex = readb(&prcslink->var.rx_packet.next_frag_rcs_index);
-    }
-    writeb(CCS_BUFFER_FREE, &prcslink->buffer_status);
+static void release_frag_chain(ray_dev_t *local, struct rcs __iomem *prcs)
+{
+        struct rcs __iomem *prcslink = prcs;
+        int tmp = 17;
+        unsigned rcsindex = readb(&prcs->var.rx_packet.next_frag_rcs_index);
+
+        while (tmp--) {
+                writeb(CCS_BUFFER_FREE, &prcslink->buffer_status);
+                if (rcsindex >= (NUMBER_OF_CCS + NUMBER_OF_RCS)) {
+                        DEBUG(1, "ray_cs interrupt bad rcsindex = 0x%x\n",
+                              rcsindex);
+                        break;
+                }
+                prcslink = rcs_base(local) + rcsindex;
+                rcsindex = readb(&prcslink->var.rx_packet.next_frag_rcs_index);
+        }
+        writeb(CCS_BUFFER_FREE, &prcslink->buffer_status);
 }
+
 /*===========================================================================*/
 static void authenticate(ray_dev_t *local)
 {
-    struct pcmcia_device *link = local->finder;
-    DEBUG(0,"ray_cs Starting authentication.\n");
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs authenticate - device not present\n");
-        return;
-    }
-
-    del_timer(&local->timer);
-    if (build_auth_frame(local, local->bss_id, OPEN_AUTH_REQUEST)) {
-        local->timer.function = &join_net;
-    }
-    else {
-        local->timer.function = &authenticate_timeout;
-    }
-    local->timer.expires = jiffies + HZ*2;
-    local->timer.data = (long)local;
-    add_timer(&local->timer);
-    local->authentication_state = AWAITING_RESPONSE;
+        struct pcmcia_device *link = local->finder;
+        DEBUG(0, "ray_cs Starting authentication.\n");
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs authenticate - device not present\n");
+                return;
+        }
+
+        del_timer(&local->timer);
+        if (build_auth_frame(local, local->bss_id, OPEN_AUTH_REQUEST)) {
+                local->timer.function = &join_net;
+        } else {
+                local->timer.function = &authenticate_timeout;
+        }
+        local->timer.expires = jiffies + HZ * 2;
+        local->timer.data = (long)local;
+        add_timer(&local->timer);
+        local->authentication_state = AWAITING_RESPONSE;
 } /* end authenticate */
+
 /*===========================================================================*/
 static void rx_authenticate(ray_dev_t *local, struct rcs __iomem *prcs,
-                     unsigned int pkt_addr, int rx_len)
-{
-    UCHAR buff[256];
-    struct rx_msg *msg = (struct rx_msg *)buff;
-    
-    del_timer(&local->timer);
-
-    copy_from_rx_buff(local, buff, pkt_addr, rx_len & 0xff);
-    /* if we are trying to get authenticated */
-    if (local->sparm.b4.a_network_type == ADHOC) {
-        DEBUG(1,"ray_cs rx_auth var= %02x %02x %02x %02x %02x %02x\n", msg->var[0],msg->var[1],msg->var[2],msg->var[3],msg->var[4],msg->var[5]);
-        if (msg->var[2] == 1) {
-                    DEBUG(0,"ray_cs Sending authentication response.\n");
-                    if (!build_auth_frame (local, msg->mac.addr_2, OPEN_AUTH_RESPONSE)) {
-                        local->authentication_state = NEED_TO_AUTH;
-                        memcpy(local->auth_id, msg->mac.addr_2, ADDRLEN);
-                    }
-        }
-    }
-    else /* Infrastructure network */
-    {
-        if (local->authentication_state == AWAITING_RESPONSE) {
-            /* Verify authentication sequence #2 and success */
-            if (msg->var[2] == 2) {
-                if ((msg->var[3] | msg->var[4]) == 0) {
-                    DEBUG(1,"Authentication successful\n");
-                    local->card_status = CARD_AUTH_COMPLETE;
-                    associate(local);
-                    local->authentication_state = AUTHENTICATED;
-                }
-                else {
-                    DEBUG(0,"Authentication refused\n");
-                    local->card_status = CARD_AUTH_REFUSED;
-                    join_net((u_long)local);
-                    local->authentication_state = UNAUTHENTICATED;
-                }
-            }
-        }
-    }
+                            unsigned int pkt_addr, int rx_len)
+{
+        UCHAR buff[256];
+        struct rx_msg *msg = (struct rx_msg *)buff;
+
+        del_timer(&local->timer);
+
+        copy_from_rx_buff(local, buff, pkt_addr, rx_len & 0xff);
+        /* if we are trying to get authenticated */
+        if (local->sparm.b4.a_network_type == ADHOC) {
+                DEBUG(1, "ray_cs rx_auth var= %02x %02x %02x %02x %02x %02x\n",
+                      msg->var[0], msg->var[1], msg->var[2], msg->var[3],
+                      msg->var[4], msg->var[5]);
+                if (msg->var[2] == 1) {
+                        DEBUG(0, "ray_cs Sending authentication response.\n");
+                        if (!build_auth_frame
+                            (local, msg->mac.addr_2, OPEN_AUTH_RESPONSE)) {
+                                local->authentication_state = NEED_TO_AUTH;
+                                memcpy(local->auth_id, msg->mac.addr_2,
+                                       ADDRLEN);
+                        }
+                }
+        } else { /* Infrastructure network */
+
+                if (local->authentication_state == AWAITING_RESPONSE) {
+                        /* Verify authentication sequence #2 and success */
+                        if (msg->var[2] == 2) {
+                                if ((msg->var[3] | msg->var[4]) == 0) {
+                                        DEBUG(1, "Authentication successful\n");
+                                        local->card_status = CARD_AUTH_COMPLETE;
+                                        associate(local);
+                                        local->authentication_state =
+                                            AUTHENTICATED;
+                                } else {
+                                        DEBUG(0, "Authentication refused\n");
+                                        local->card_status = CARD_AUTH_REFUSED;
+                                        join_net((u_long) local);
+                                        local->authentication_state =
+                                            UNAUTHENTICATED;
+                                }
+                        }
+                }
+        }
 
 } /* end rx_authenticate */
+
 /*===========================================================================*/
 static void associate(ray_dev_t *local)
 {
-    struct ccs __iomem *pccs;
-    struct pcmcia_device *link = local->finder;
-    struct net_device *dev = link->priv;
-    int ccsindex;
-    if (!(pcmcia_dev_present(link))) {
-        DEBUG(2,"ray_cs associate - device not present\n");
-        return;
-    }
-    /* If no tx buffers available, return*/
-    if ((ccsindex = get_free_ccs(local)) < 0)
-    {
+        struct ccs __iomem *pccs;
+        struct pcmcia_device *link = local->finder;
+        struct net_device *dev = link->priv;
+        int ccsindex;
+        if (!(pcmcia_dev_present(link))) {
+                DEBUG(2, "ray_cs associate - device not present\n");
+                return;
+        }
+        /* If no tx buffers available, return */
+        if ((ccsindex = get_free_ccs(local)) < 0) {
 /* TBD should never be here but... what if we are? */
-        DEBUG(1,"ray_cs associate - No free ccs\n");
-        return;
-    }
-    DEBUG(1,"ray_cs Starting association with access point\n");
-    pccs = ccs_base(local) + ccsindex;
-    /* fill in the CCS */
-    writeb(CCS_START_ASSOCIATION, &pccs->cmd);
-    /* Interrupt the firmware to process the command */
-    if (interrupt_ecf(local, ccsindex)) {
-        DEBUG(1,"ray_cs associate failed - ECF not ready for intr\n");
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-
-        del_timer(&local->timer);
-        local->timer.expires = jiffies + HZ*2;
-        local->timer.data = (long)local;
-        local->timer.function = &join_net;
-        add_timer(&local->timer);
-        local->card_status = CARD_ASSOC_FAILED;
-        return;
-    }
-    if (!sniffer) netif_start_queue(dev);
+                DEBUG(1, "ray_cs associate - No free ccs\n");
+                return;
+        }
+        DEBUG(1, "ray_cs Starting association with access point\n");
+        pccs = ccs_base(local) + ccsindex;
+        /* fill in the CCS */
+        writeb(CCS_START_ASSOCIATION, &pccs->cmd);
+        /* Interrupt the firmware to process the command */
+        if (interrupt_ecf(local, ccsindex)) {
+                DEBUG(1, "ray_cs associate failed - ECF not ready for intr\n");
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+
+                del_timer(&local->timer);
+                local->timer.expires = jiffies + HZ * 2;
+                local->timer.data = (long)local;
+                local->timer.function = &join_net;
+                add_timer(&local->timer);
+                local->card_status = CARD_ASSOC_FAILED;
+                return;
+        }
+        if (!sniffer)
+                netif_start_queue(dev);
 
 } /* end associate */
+
 /*===========================================================================*/
-static void rx_deauthenticate(ray_dev_t *local, struct rcs __iomem *prcs, 
-                       unsigned int pkt_addr, int rx_len)
+static void rx_deauthenticate(ray_dev_t *local, struct rcs __iomem *prcs,
+                              unsigned int pkt_addr, int rx_len)
 {
 /*  UCHAR buff[256];
     struct rx_msg *msg = (struct rx_msg *)buff;
 */
-    DEBUG(0,"Deauthentication frame received\n");
-    local->authentication_state = UNAUTHENTICATED;
-    /* Need to reauthenticate or rejoin depending on reason code */
+        DEBUG(0, "Deauthentication frame received\n");
+        local->authentication_state = UNAUTHENTICATED;
+        /* Need to reauthenticate or rejoin depending on reason code */
 /*  copy_from_rx_buff(local, buff, pkt_addr, rx_len & 0xff);
  */
 }
+
 /*===========================================================================*/
 static void clear_interrupt(ray_dev_t *local)
 {
-    writeb(0, local->amem + CIS_OFFSET + HCS_INTR_OFFSET);
+        writeb(0, local->amem + CIS_OFFSET + HCS_INTR_OFFSET);
 }
+
 /*===========================================================================*/
 #ifdef CONFIG_PROC_FS
 #define MAXDATA (PAGE_SIZE - 80)
 
 static char *card_status[] = {
-    "Card inserted - uninitialized",     /* 0 */
-    "Card not downloaded",               /* 1 */
-    "Waiting for download parameters",   /* 2 */
-    "Card doing acquisition",            /* 3 */
-    "Acquisition complete",              /* 4 */
-    "Authentication complete",           /* 5 */
-    "Association complete",              /* 6 */
-    "???", "???", "???", "???",          /* 7 8 9 10 undefined */
-    "Card init error",                   /* 11 */
-    "Download parameters error",         /* 12 */
-    "???",                               /* 13 */
-    "Acquisition failed",                /* 14 */
-    "Authentication refused",            /* 15 */
-    "Association failed"                 /* 16 */
+        "Card inserted - uninitialized",        /* 0 */
+        "Card not downloaded",                  /* 1 */
+        "Waiting for download parameters",      /* 2 */
+        "Card doing acquisition",               /* 3 */
+        "Acquisition complete",                 /* 4 */
+        "Authentication complete",              /* 5 */
+        "Association complete",                 /* 6 */
+        "???", "???", "???", "???",             /* 7 8 9 10 undefined */
+        "Card init error",                      /* 11 */
+        "Download parameters error",            /* 12 */
+        "???",                                  /* 13 */
+        "Acquisition failed",                   /* 14 */
+        "Authentication refused",               /* 15 */
+        "Association failed"                    /* 16 */
 };
 
-static char *nettype[] = {"Adhoc", "Infra "};
-static char *framing[] = {"Encapsulation", "Translation"}
+static char *nettype[] = { "Adhoc", "Infra " };
+static char *framing[] = { "Encapsulation", "Translation" }
+
 ;
 /*===========================================================================*/
 static int ray_cs_proc_show(struct seq_file *m, void *v)
 {
 /* Print current values which are not available via other means
- * eg ifconfig 
+ * eg ifconfig
  */
-    int i;
-    struct pcmcia_device *link;
-    struct net_device *dev;
-    ray_dev_t *local;
-    UCHAR *p;
-    struct freq_hop_element *pfh;
-    UCHAR c[33];
-
-    link = this_device;
-    if (!link)
-        return 0;
-    dev = (struct net_device *)link->priv;
-    if (!dev)
-        return 0;
-    local = netdev_priv(dev);
-    if (!local)
-        return 0;
-
-    seq_puts(m, "Raylink Wireless LAN driver status\n");
-    seq_printf(m, "%s\n", rcsid);
-    /* build 4 does not report version, and field is 0x55 after memtest */
-    seq_puts(m, "Firmware version     = ");
-    if (local->fw_ver == 0x55)
-        seq_puts(m, "4 - Use dump_cis for more details\n");
-    else
-        seq_printf(m, "%2d.%02d.%02d\n",
-                   local->fw_ver, local->fw_bld, local->fw_var);
-
-    for (i=0; i<32; i++) c[i] = local->sparm.b5.a_current_ess_id[i];
-    c[32] = 0;
-    seq_printf(m, "%s network ESSID = \"%s\"\n",
-                   nettype[local->sparm.b5.a_network_type], c);
-
-    p = local->bss_id;
-    seq_printf(m, "BSSID                = %pM\n", p);
-
-    seq_printf(m, "Country code         = %d\n",
-                   local->sparm.b5.a_curr_country_code);
-
-    i = local->card_status;
-    if (i < 0) i = 10;
-    if (i > 16) i = 10;
-    seq_printf(m, "Card status          = %s\n", card_status[i]);
-
-    seq_printf(m, "Framing mode         = %s\n",framing[translate]);
-
-    seq_printf(m, "Last pkt signal lvl  = %d\n", local->last_rsl);
-
-    if (local->beacon_rxed) {
-        /* Pull some fields out of last beacon received */
-        seq_printf(m, "Beacon Interval      = %d Kus\n",
-                       local->last_bcn.beacon_intvl[0]
-                       + 256 * local->last_bcn.beacon_intvl[1]);
-    
-    p = local->last_bcn.elements;
-    if (p[0] == C_ESSID_ELEMENT_ID) p += p[1] + 2;
-    else {
-        seq_printf(m, "Parse beacon failed at essid element id = %d\n",p[0]);
-        return 0;
-    }
-
-    if (p[0] == C_SUPPORTED_RATES_ELEMENT_ID) {
-        seq_puts(m, "Supported rate codes = ");
-        for (i=2; i<p[1] + 2; i++) 
-            seq_printf(m, "0x%02x ", p[i]);
-        seq_putc(m, '\n');
-        p += p[1] + 2;
-    }
-    else {
-        seq_puts(m, "Parse beacon failed at rates element\n");
-        return 0;
-    }
-
-        if (p[0] == C_FH_PARAM_SET_ELEMENT_ID) {
-            pfh = (struct freq_hop_element *)p;
-            seq_printf(m, "Hop dwell            = %d Kus\n",
-                           pfh->dwell_time[0] + 256 * pfh->dwell_time[1]);
-            seq_printf(m, "Hop set              = %d \n", pfh->hop_set);
-            seq_printf(m, "Hop pattern          = %d \n", pfh->hop_pattern);
-            seq_printf(m, "Hop index            = %d \n", pfh->hop_index);
-            p += p[1] + 2;
-        }
-        else {
-            seq_puts(m, "Parse beacon failed at FH param element\n");
-            return 0;
+        int i;
+        struct pcmcia_device *link;
+        struct net_device *dev;
+        ray_dev_t *local;
+        UCHAR *p;
+        struct freq_hop_element *pfh;
+        UCHAR c[33];
+
+        link = this_device;
+        if (!link)
+                return 0;
+        dev = (struct net_device *)link->priv;
+        if (!dev)
+                return 0;
+        local = netdev_priv(dev);
+        if (!local)
+                return 0;
+
+        seq_puts(m, "Raylink Wireless LAN driver status\n");
+        seq_printf(m, "%s\n", rcsid);
+        /* build 4 does not report version, and field is 0x55 after memtest */
+        seq_puts(m, "Firmware version     = ");
+        if (local->fw_ver == 0x55)
+                seq_puts(m, "4 - Use dump_cis for more details\n");
+        else
+                seq_printf(m, "%2d.%02d.%02d\n",
+                           local->fw_ver, local->fw_bld, local->fw_var);
+
+        for (i = 0; i < 32; i++)
+                c[i] = local->sparm.b5.a_current_ess_id[i];
+        c[32] = 0;
+        seq_printf(m, "%s network ESSID = \"%s\"\n",
+                   nettype[local->sparm.b5.a_network_type], c);
+
+        p = local->bss_id;
+        seq_printf(m, "BSSID                = %pM\n", p);
+
+        seq_printf(m, "Country code         = %d\n",
+                   local->sparm.b5.a_curr_country_code);
+
+        i = local->card_status;
+        if (i < 0)
+                i = 10;
+        if (i > 16)
+                i = 10;
+        seq_printf(m, "Card status          = %s\n", card_status[i]);
+
+        seq_printf(m, "Framing mode         = %s\n", framing[translate]);
+
+        seq_printf(m, "Last pkt signal lvl  = %d\n", local->last_rsl);
+
+        if (local->beacon_rxed) {
+                /* Pull some fields out of last beacon received */
+                seq_printf(m, "Beacon Interval      = %d Kus\n",
+                           local->last_bcn.beacon_intvl[0]
+                           + 256 * local->last_bcn.beacon_intvl[1]);
+
+                p = local->last_bcn.elements;
+                if (p[0] == C_ESSID_ELEMENT_ID)
+                        p += p[1] + 2;
+                else {
+                        seq_printf(m,
+                                   "Parse beacon failed at essid element id = %d\n",
+                                   p[0]);
+                        return 0;
+                }
+
+                if (p[0] == C_SUPPORTED_RATES_ELEMENT_ID) {
+                        seq_puts(m, "Supported rate codes = ");
+                        for (i = 2; i < p[1] + 2; i++)
+                                seq_printf(m, "0x%02x ", p[i]);
+                        seq_putc(m, '\n');
+                        p += p[1] + 2;
+                } else {
+                        seq_puts(m, "Parse beacon failed at rates element\n");
+                        return 0;
+                }
+
+                if (p[0] == C_FH_PARAM_SET_ELEMENT_ID) {
+                        pfh = (struct freq_hop_element *)p;
+                        seq_printf(m, "Hop dwell            = %d Kus\n",
+                                   pfh->dwell_time[0] +
+                                   256 * pfh->dwell_time[1]);
+                        seq_printf(m, "Hop set              = %d \n",
+                                   pfh->hop_set);
+                        seq_printf(m, "Hop pattern          = %d \n",
+                                   pfh->hop_pattern);
+                        seq_printf(m, "Hop index            = %d \n",
+                                   pfh->hop_index);
+                        p += p[1] + 2;
+                } else {
+                        seq_puts(m,
+                                 "Parse beacon failed at FH param element\n");
+                        return 0;
+                }
+        } else {
+                seq_puts(m, "No beacons received\n");
         }
-    } else {
-        seq_puts(m, "No beacons received\n");
-    }
-    return 0;
+        return 0;
 }
 
 static int ray_cs_proc_open(struct inode *inode, struct file *file)
@@ -2684,74 +2799,77 @@ static int ray_cs_proc_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations ray_cs_proc_fops = {
-        .owner          = THIS_MODULE,
-        .open           = ray_cs_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
+        .owner = THIS_MODULE,
+        .open = ray_cs_proc_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
 };
 #endif
 /*===========================================================================*/
 static int build_auth_frame(ray_dev_t *local, UCHAR *dest, int auth_type)
 {
-    int addr;
-    struct ccs __iomem *pccs;
-    struct tx_msg __iomem *ptx;
-    int ccsindex;
-
-    /* If no tx buffers available, return */
-    if ((ccsindex = get_free_tx_ccs(local)) < 0)
-    {
-        DEBUG(1,"ray_cs send authenticate - No free tx ccs\n");
-        return -1;
-    }
-
-    pccs = ccs_base(local) + ccsindex;
-
-    /* Address in card space */
-    addr = TX_BUF_BASE + (ccsindex << 11);
-    /* fill in the CCS */
-    writeb(CCS_TX_REQUEST, &pccs->cmd);
-    writeb(addr >> 8, pccs->var.tx_request.tx_data_ptr);
-    writeb(0x20, pccs->var.tx_request.tx_data_ptr + 1);
-    writeb(TX_AUTHENTICATE_LENGTH_MSB, pccs->var.tx_request.tx_data_length);
-    writeb(TX_AUTHENTICATE_LENGTH_LSB,pccs->var.tx_request.tx_data_length + 1);
-    writeb(0, &pccs->var.tx_request.pow_sav_mode);
-
-    ptx = local->sram + addr;
-    /* fill in the mac header */
-    writeb(PROTOCOL_VER | AUTHENTIC_TYPE, &ptx->mac.frame_ctl_1);
-    writeb(0, &ptx->mac.frame_ctl_2);
-
-    memcpy_toio(ptx->mac.addr_1, dest, ADDRLEN);
-    memcpy_toio(ptx->mac.addr_2, local->sparm.b4.a_mac_addr, ADDRLEN);
-    memcpy_toio(ptx->mac.addr_3, local->bss_id, ADDRLEN);
-
-    /* Fill in msg body with protocol 00 00, sequence 01 00 ,status 00 00 */
-    memset_io(ptx->var, 0, 6);
-    writeb(auth_type & 0xff, ptx->var + 2);
-
-    /* Interrupt the firmware to process the command */
-    if (interrupt_ecf(local, ccsindex)) {
-        DEBUG(1,"ray_cs send authentication request failed - ECF not ready for intr\n");
-        writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
-        return -1;
-    }
-    return 0;
+        int addr;
+        struct ccs __iomem *pccs;
+        struct tx_msg __iomem *ptx;
+        int ccsindex;
+
+        /* If no tx buffers available, return */
+        if ((ccsindex = get_free_tx_ccs(local)) < 0) {
+                DEBUG(1, "ray_cs send authenticate - No free tx ccs\n");
+                return -1;
+        }
+
+        pccs = ccs_base(local) + ccsindex;
+
+        /* Address in card space */
+        addr = TX_BUF_BASE + (ccsindex << 11);
+        /* fill in the CCS */
+        writeb(CCS_TX_REQUEST, &pccs->cmd);
+        writeb(addr >> 8, pccs->var.tx_request.tx_data_ptr);
+        writeb(0x20, pccs->var.tx_request.tx_data_ptr + 1);
+        writeb(TX_AUTHENTICATE_LENGTH_MSB, pccs->var.tx_request.tx_data_length);
+        writeb(TX_AUTHENTICATE_LENGTH_LSB,
+               pccs->var.tx_request.tx_data_length + 1);
+        writeb(0, &pccs->var.tx_request.pow_sav_mode);
+
+        ptx = local->sram + addr;
+        /* fill in the mac header */
+        writeb(PROTOCOL_VER | AUTHENTIC_TYPE, &ptx->mac.frame_ctl_1);
+        writeb(0, &ptx->mac.frame_ctl_2);
+
+        memcpy_toio(ptx->mac.addr_1, dest, ADDRLEN);
+        memcpy_toio(ptx->mac.addr_2, local->sparm.b4.a_mac_addr, ADDRLEN);
+        memcpy_toio(ptx->mac.addr_3, local->bss_id, ADDRLEN);
+
+        /* Fill in msg body with protocol 00 00, sequence 01 00 ,status 00 00 */
+        memset_io(ptx->var, 0, 6);
+        writeb(auth_type & 0xff, ptx->var + 2);
+
+        /* Interrupt the firmware to process the command */
+        if (interrupt_ecf(local, ccsindex)) {
+                DEBUG(1,
+                      "ray_cs send authentication request failed - ECF not ready for intr\n");
+                writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
+                return -1;
+        }
+        return 0;
 } /* End build_auth_frame */
 
 /*===========================================================================*/
 #ifdef CONFIG_PROC_FS
 static void raycs_write(const char *name, write_proc_t *w, void *data)
 {
-        struct proc_dir_entry * entry = create_proc_entry(name, S_IFREG | S_IWUSR, NULL);
+        struct proc_dir_entry *entry =
+            create_proc_entry(name, S_IFREG | S_IWUSR, NULL);
         if (entry) {
                 entry->write_proc = w;
                 entry->data = data;
         }
 }
 
-static int write_essid(struct file *file, const char __user *buffer, unsigned long count, void *data)
+static int write_essid(struct file *file, const char __user *buffer,
+                       unsigned long count, void *data)
 {
         static char proc_essid[33];
         int len = count;
@@ -2765,7 +2883,8 @@ static int write_essid(struct file *file, const char __user *buffer, unsigned lo
         return count;
 }
 
-static int write_int(struct file *file, const char __user *buffer, unsigned long count, void *data)
+static int write_int(struct file *file, const char __user *buffer,
+                     unsigned long count, void *data)
 {
         static char proc_number[10];
         char *p;
@@ -2785,7 +2904,7 @@ static int write_int(struct file *file, const char __user *buffer, unsigned long
                 unsigned int c = *p - '0';
                 if (c > 9)
                         return -EINVAL;
-                nr = nr*10 + c;
+                nr = nr * 10 + c;
                 p++;
         } while (--len);
         *(int *)data = nr;
@@ -2797,55 +2916,58 @@ static struct pcmcia_device_id ray_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0x01a6, 0x0000),
         PCMCIA_DEVICE_NULL,
 };
+
 MODULE_DEVICE_TABLE(pcmcia, ray_ids);
 
 static struct pcmcia_driver ray_driver = {
-        .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "ray_cs",
-        },
-        .probe          = ray_probe,
-        .remove         = ray_detach,
-        .id_table       = ray_ids,
-        .suspend        = ray_suspend,
-        .resume         = ray_resume,
+        .owner = THIS_MODULE,
+        .drv = {
+                .name = "ray_cs",
+                },
+        .probe = ray_probe,
+        .remove = ray_detach,
+        .id_table = ray_ids,
+        .suspend = ray_suspend,
+        .resume = ray_resume,
 };
 
 static int __init init_ray_cs(void)
 {
-    int rc;
-    
-    DEBUG(1, "%s\n", rcsid);
-    rc = pcmcia_register_driver(&ray_driver);
-    DEBUG(1, "raylink init_module register_pcmcia_driver returns 0x%x\n",rc);
+        int rc;
+
+        DEBUG(1, "%s\n", rcsid);
+        rc = pcmcia_register_driver(&ray_driver);
+        DEBUG(1, "raylink init_module register_pcmcia_driver returns 0x%x\n",
+              rc);
 
 #ifdef CONFIG_PROC_FS
-    proc_mkdir("driver/ray_cs", NULL);
+        proc_mkdir("driver/ray_cs", NULL);
 
-    proc_create("driver/ray_cs/ray_cs", 0, NULL, &ray_cs_proc_fops);
-    raycs_write("driver/ray_cs/essid", write_essid, NULL);
-    raycs_write("driver/ray_cs/net_type", write_int, &net_type);
-    raycs_write("driver/ray_cs/translate", write_int, &translate);
+        proc_create("driver/ray_cs/ray_cs", 0, NULL, &ray_cs_proc_fops);
+        raycs_write("driver/ray_cs/essid", write_essid, NULL);
+        raycs_write("driver/ray_cs/net_type", write_int, &net_type);
+        raycs_write("driver/ray_cs/translate", write_int, &translate);
 #endif
-    if (translate != 0) translate = 1;
-    return 0;
+        if (translate != 0)
+                translate = 1;
+        return 0;
 } /* init_ray_cs */
 
 /*===========================================================================*/
 
 static void __exit exit_ray_cs(void)
 {
-    DEBUG(0, "ray_cs: cleanup_module\n");
+        DEBUG(0, "ray_cs: cleanup_module\n");
 
 #ifdef CONFIG_PROC_FS
-    remove_proc_entry("driver/ray_cs/ray_cs", NULL);
-    remove_proc_entry("driver/ray_cs/essid", NULL);
-    remove_proc_entry("driver/ray_cs/net_type", NULL);
-    remove_proc_entry("driver/ray_cs/translate", NULL);
-    remove_proc_entry("driver/ray_cs", NULL);
+        remove_proc_entry("driver/ray_cs/ray_cs", NULL);
+        remove_proc_entry("driver/ray_cs/essid", NULL);
+        remove_proc_entry("driver/ray_cs/net_type", NULL);
+        remove_proc_entry("driver/ray_cs/translate", NULL);
+        remove_proc_entry("driver/ray_cs", NULL);
 #endif
 
-    pcmcia_unregister_driver(&ray_driver);
+        pcmcia_unregister_driver(&ray_driver);
 } /* exit_ray_cs */
 
 module_init(init_ray_cs);
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index f6e56370ea65..f33aa08dd9b3 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -150,6 +150,17 @@
  * @NL80211_CMD_SCAN_ABORTED: scan was aborted, for unspecified reasons,
  *      partial scan results may be available
  *
+ * @NL80211_CMD_REG_CHANGE: indicates to userspace the regulatory domain
+ *      has been changed and provides details of the request information
+ *      that caused the change such as who initiated the regulatory request
+ *      (%NL80211_ATTR_REG_INITIATOR), the wiphy_idx
+ *      (%NL80211_ATTR_REG_ALPHA2) on which the request was made from if
+ *      the initiator was %NL80211_REGDOM_SET_BY_COUNTRY_IE or
+ *      %NL80211_REGDOM_SET_BY_DRIVER, the type of regulatory domain
+ *      set (%NL80211_ATTR_REG_TYPE), if the type of regulatory domain is
+ *      %NL80211_REG_TYPE_COUNTRY the alpha2 to which we have moved on
+ *      to (%NL80211_ATTR_REG_ALPHA2).
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -204,6 +215,8 @@ enum nl80211_commands {
         NL80211_CMD_NEW_SCAN_RESULTS,
         NL80211_CMD_SCAN_ABORTED,
 
+        NL80211_CMD_REG_CHANGE,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -218,6 +231,8 @@ enum nl80211_commands {
 #define NL80211_CMD_SET_BSS NL80211_CMD_SET_BSS
 #define NL80211_CMD_SET_MGMT_EXTRA_IE NL80211_CMD_SET_MGMT_EXTRA_IE
 
+#define NL80211_CMD_REG_CHANGE NL80211_CMD_REG_CHANGE
+
 /**
  * enum nl80211_attrs - nl80211 netlink attributes
  *
@@ -329,6 +344,11 @@ enum nl80211_commands {
  *      messages carried the same generation number)
  * @NL80211_ATTR_BSS: scan result BSS
  *
+ * @NL80211_ATTR_REG_INITIATOR: indicates who requested the regulatory domain
+ *      currently in effect. This could be any of the %NL80211_REGDOM_SET_BY_*
+ * @NL80211_ATTR_REG_TYPE: indicates the type of the regulatory domain currently
+ *      set. This can be one of the nl80211_reg_type (%NL80211_REGDOM_TYPE_*)
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -403,6 +423,9 @@ enum nl80211_attrs {
         NL80211_ATTR_SCAN_GENERATION,
         NL80211_ATTR_BSS,
 
+        NL80211_ATTR_REG_INITIATOR,
+        NL80211_ATTR_REG_TYPE,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -420,6 +443,8 @@ enum nl80211_attrs {
 #define NL80211_ATTR_WIPHY_CHANNEL_TYPE NL80211_ATTR_WIPHY_CHANNEL_TYPE
 #define NL80211_ATTR_MGMT_SUBTYPE NL80211_ATTR_MGMT_SUBTYPE
 #define NL80211_ATTR_IE NL80211_ATTR_IE
+#define NL80211_ATTR_REG_INITIATOR NL80211_ATTR_REG_INITIATOR
+#define NL80211_ATTR_REG_TYPE NL80211_ATTR_REG_TYPE
 
 #define NL80211_MAX_SUPP_RATES                  32
 #define NL80211_MAX_SUPP_REG_RULES              32
@@ -673,6 +698,48 @@ enum nl80211_bitrate_attr {
 };
 
 /**
+ * enum nl80211_initiator - Indicates the initiator of a reg domain request
+ * @NL80211_REGDOM_SET_BY_CORE: Core queried CRDA for a dynamic world
+ *      regulatory domain.
+ * @NL80211_REGDOM_SET_BY_USER: User asked the wireless core to set the
+ *      regulatory domain.
+ * @NL80211_REGDOM_SET_BY_DRIVER: a wireless drivers has hinted to the
+ *      wireless core it thinks its knows the regulatory domain we should be in.
+ * @NL80211_REGDOM_SET_BY_COUNTRY_IE: the wireless core has received an
+ *      802.11 country information element with regulatory information it
+ *      thinks we should consider.
+ */
+enum nl80211_reg_initiator {
+        NL80211_REGDOM_SET_BY_CORE,
+        NL80211_REGDOM_SET_BY_USER,
+        NL80211_REGDOM_SET_BY_DRIVER,
+        NL80211_REGDOM_SET_BY_COUNTRY_IE,
+};
+
+/**
+ * enum nl80211_reg_type - specifies the type of regulatory domain
+ * @NL80211_REGDOM_TYPE_COUNTRY: the regulatory domain set is one that pertains
+ *      to a specific country. When this is set you can count on the
+ *      ISO / IEC 3166 alpha2 country code being valid.
+ * @NL80211_REGDOM_TYPE_WORLD: the regulatory set domain is the world regulatory
+ *      domain.
+ * @NL80211_REGDOM_TYPE_CUSTOM_WORLD: the regulatory domain set is a custom
+ *      driver specific world regulatory domain. These do not apply system-wide
+ *      and are only applicable to the individual devices which have requested
+ *      them to be applied.
+ * @NL80211_REGDOM_TYPE_INTERSECTION: the regulatory domain set is the product
+ *      of an intersection between two regulatory domains -- the previously
+ *      set regulatory domain on the system and the last accepted regulatory
+ *      domain request to be processed.
+ */
+enum nl80211_reg_type {
+        NL80211_REGDOM_TYPE_COUNTRY,
+        NL80211_REGDOM_TYPE_WORLD,
+        NL80211_REGDOM_TYPE_CUSTOM_WORLD,
+        NL80211_REGDOM_TYPE_INTERSECTION,
+};
+
+/**
  * enum nl80211_reg_rule_attr - regulatory rule attributes
  * @NL80211_ATTR_REG_RULE_FLAGS: a set of flags which specify additional
  *      considerations for a given frequency range. These are the
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 75fa556728ce..50f3fd9ff524 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -349,30 +349,9 @@ struct bss_parameters {
 };
 
 /**
- * enum reg_set_by - Indicates who is trying to set the regulatory domain
- * @REGDOM_SET_BY_INIT: regulatory domain was set by initialization. We will be
- *      using a static world regulatory domain by default.
- * @REGDOM_SET_BY_CORE: Core queried CRDA for a dynamic world regulatory domain.
- * @REGDOM_SET_BY_USER: User asked the wireless core to set the
- *      regulatory domain.
- * @REGDOM_SET_BY_DRIVER: a wireless drivers has hinted to the wireless core
- *      it thinks its knows the regulatory domain we should be in.
- * @REGDOM_SET_BY_COUNTRY_IE: the wireless core has received an 802.11 country
- *      information element with regulatory information it thinks we
- *      should consider.
- */
-enum reg_set_by {
-        REGDOM_SET_BY_INIT,
-        REGDOM_SET_BY_CORE,
-        REGDOM_SET_BY_USER,
-        REGDOM_SET_BY_DRIVER,
-        REGDOM_SET_BY_COUNTRY_IE,
-};
-
-/**
  * enum environment_cap - Environment parsed from country IE
  * @ENVIRON_ANY: indicates country IE applies to both indoor and
- *      outdoor operation.
+ *      outdoor operation.
  * @ENVIRON_INDOOR: indicates country IE applies only to indoor operation
  * @ENVIRON_OUTDOOR: indicates country IE applies only to outdoor operation
  */
@@ -391,7 +370,7 @@ enum environment_cap {
  *      and potentially inform users of which devices specifically
  *      cased the conflicts.
  * @initiator: indicates who sent this request, could be any of
- *      of those set in reg_set_by, %REGDOM_SET_BY_*
+ *      of those set in nl80211_reg_initiator (%NL80211_REGDOM_SET_BY_*)
  * @alpha2: the ISO / IEC 3166 alpha2 country code of the requested
  *      regulatory domain. We have a few special codes:
  *      00 - World regulatory domain
@@ -408,7 +387,7 @@ enum environment_cap {
  */
 struct regulatory_request {
         int wiphy_idx;
-        enum reg_set_by initiator;
+        enum nl80211_reg_initiator initiator;
         char alpha2[2];
         bool intersect;
         u32 country_ie_checksum;
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index ecbc8e0cb3e7..fbb91f1aebb2 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -972,6 +972,7 @@ int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata,
                                char *ie, size_t len);
 
 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
+void ieee80211_scan_failed(struct ieee80211_local *local);
 int ieee80211_start_scan(struct ieee80211_sub_if_data *scan_sdata,
                          struct cfg80211_scan_request *req);
 struct ieee80211_bss *
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index 2acc416e77e1..f9f27b9cadbe 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -370,6 +370,18 @@ static int ieee80211_stop(struct net_device *dev)
         rcu_read_unlock();
 
         /*
+         * Announce that we are leaving the network, in case we are a
+         * station interface type. This must be done before removing
+         * all stations associated with sta_info_flush, otherwise STA
+         * information will be gone and no announce being done.
+         */
+        if (sdata->vif.type == NL80211_IFTYPE_STATION) {
+                if (sdata->u.mgd.state != IEEE80211_STA_MLME_DISABLED)
+                        ieee80211_sta_deauthenticate(sdata,
+                                WLAN_REASON_DEAUTH_LEAVING);
+        }
+
+        /*
          * Remove all stations associated with this interface.
          *
          * This must be done before calling ops->remove_interface()
@@ -454,10 +466,6 @@ static int ieee80211_stop(struct net_device *dev)
                 netif_addr_unlock_bh(local->mdev);
                 break;
         case NL80211_IFTYPE_STATION:
-                /* Announce that we are leaving the network. */
-                if (sdata->u.mgd.state != IEEE80211_STA_MLME_DISABLED)
-                        ieee80211_sta_deauthenticate(sdata,
-                                                WLAN_REASON_DEAUTH_LEAVING);
                 memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
                 del_timer_sync(&sdata->u.mgd.chswitch_timer);
                 del_timer_sync(&sdata->u.mgd.timer);
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 391445c6b892..841b8450b3de 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -417,9 +417,6 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
 
         memset(&params, 0, sizeof(params));
 
-        if (!local->ops->conf_tx)
-                return;
-
         local->wmm_acm = 0;
         for (; left >= 4; left -= 4, pos += 4) {
                 int aci = (pos[0] >> 5) & 0x03;
@@ -427,26 +424,26 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
                 int queue;
 
                 switch (aci) {
-                case 1:
+                case 1: /* AC_BK */
                         queue = 3;
                         if (acm)
-                                local->wmm_acm |= BIT(0) | BIT(3);
+                                local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
                         break;
-                case 2:
+                case 2: /* AC_VI */
                         queue = 1;
                         if (acm)
-                                local->wmm_acm |= BIT(4) | BIT(5);
+                                local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
                         break;
-                case 3:
+                case 3: /* AC_VO */
                         queue = 0;
                         if (acm)
-                                local->wmm_acm |= BIT(6) | BIT(7);
+                                local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
                         break;
-                case 0:
+                case 0: /* AC_BE */
                 default:
                         queue = 2;
                         if (acm)
-                                local->wmm_acm |= BIT(1) | BIT(2);
+                                local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
                         break;
                 }
 
@@ -460,9 +457,8 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
                        local->mdev->name, queue, aci, acm, params.aifs, params.cw_min,
                        params.cw_max, params.txop);
 #endif
-                /* TODO: handle ACM (block TX, fallback to next lowest allowed
-                 * AC for now) */
-                if (local->ops->conf_tx(local_to_hw(local), queue, &params)) {
+                if (local->ops->conf_tx &&
+                    local->ops->conf_tx(local_to_hw(local), queue, &params)) {
                         printk(KERN_DEBUG "%s: failed to set TX queue "
                                "parameters for queue %d\n", local->mdev->name, queue);
                 }
@@ -1724,7 +1720,10 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata)
                                 local->int_scan_req.ssids[0].ssid_len = 0;
                         else
                                 local->int_scan_req.ssids[0].ssid_len = ifmgd->ssid_len;
-                        ieee80211_start_scan(sdata, &local->int_scan_req);
+
+                        if (ieee80211_start_scan(sdata, &local->int_scan_req))
+                                ieee80211_scan_failed(local);
+
                         ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
                         set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
                 } else {
@@ -1761,7 +1760,14 @@ static void ieee80211_sta_work(struct work_struct *work)
             ifmgd->state != IEEE80211_STA_MLME_AUTHENTICATE &&
             ifmgd->state != IEEE80211_STA_MLME_ASSOCIATE &&
             test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request)) {
-                ieee80211_start_scan(sdata, local->scan_req);
+                /*
+                 * The call to ieee80211_start_scan can fail but ieee80211_request_scan
+                 * (which queued ieee80211_sta_work) did not return an error. Thus, call
+                 * ieee80211_scan_failed here if ieee80211_start_scan fails in order to
+                 * notify the scan requester.
+                 */
+                if (ieee80211_start_scan(sdata, local->scan_req))
+                        ieee80211_scan_failed(local);
                 return;
         }
 
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index 0e81e1633a66..5030a3c87509 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -202,6 +202,18 @@ ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
         return RX_QUEUED;
 }
 
+void ieee80211_scan_failed(struct ieee80211_local *local)
+{
+        if (WARN_ON(!local->scan_req))
+                return;
+
+        /* notify cfg80211 about the failed scan */
+        if (local->scan_req != &local->int_scan_req)
+                cfg80211_scan_done(local->scan_req, true);
+
+        local->scan_req = NULL;
+}
+
 void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
 {
         struct ieee80211_local *local = hw_to_local(hw);
diff --git a/net/mac80211/wme.c b/net/mac80211/wme.c
index 093a4ab7f28b..0b8ad1f4ecdd 100644
--- a/net/mac80211/wme.c
+++ b/net/mac80211/wme.c
@@ -99,10 +99,13 @@ static u16 classify80211(struct ieee80211_local *local, struct sk_buff *skb)
         /* in case we are a client verify acm is not set for this ac */
         while (unlikely(local->wmm_acm & BIT(skb->priority))) {
                 if (wme_downgrade_ac(skb)) {
-                        /* The old code would drop the packet in this
-                         * case.
+                        /*
+                         * This should not really happen. The AP has marked all
+                         * lower ACs to require admission control which is not
+                         * a reasonable configuration. Allow the frame to be
+                         * transmitted using AC_BK as a workaround.
                          */
-                        return 0;
+                        break;
                 }
         }
 
diff --git a/net/wireless/core.c b/net/wireless/core.c
index dd7f222919fe..17fe39049740 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -350,7 +350,7 @@ int wiphy_register(struct wiphy *wiphy)
         mutex_lock(&cfg80211_mutex);
 
         /* set up regulatory info */
-        wiphy_update_regulatory(wiphy, REGDOM_SET_BY_CORE);
+        wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
 
         res = device_add(&drv->wiphy.dev);
         if (res)
@@ -365,6 +365,17 @@ int wiphy_register(struct wiphy *wiphy)
         if (IS_ERR(drv->wiphy.debugfsdir))
                 drv->wiphy.debugfsdir = NULL;
 
+        if (wiphy->custom_regulatory) {
+                struct regulatory_request request;
+
+                request.wiphy_idx = get_wiphy_idx(wiphy);
+                request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
+                request.alpha2[0] = '9';
+                request.alpha2[1] = '9';
+
+                nl80211_send_reg_change_event(&request);
+        }
+
         res = 0;
 out_unlock:
         mutex_unlock(&cfg80211_mutex);
diff --git a/net/wireless/core.h b/net/wireless/core.h
index f6c53f5807f4..6acd483a61f8 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -136,7 +136,8 @@ extern int cfg80211_dev_rename(struct cfg80211_registered_device *drv,
                                char *newname);
 
 void ieee80211_set_bitrate_flags(struct wiphy *wiphy);
-void wiphy_update_regulatory(struct wiphy *wiphy, enum reg_set_by setby);
+void wiphy_update_regulatory(struct wiphy *wiphy,
+                             enum nl80211_reg_initiator setby);
 
 void cfg80211_bss_expire(struct cfg80211_registered_device *dev);
 void cfg80211_bss_age(struct cfg80211_registered_device *dev,
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 531bb67cf502..8ac3d26014a8 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -2739,6 +2739,9 @@ static struct genl_multicast_group nl80211_config_mcgrp = {
 static struct genl_multicast_group nl80211_scan_mcgrp = {
         .name = "scan",
 };
+static struct genl_multicast_group nl80211_regulatory_mcgrp = {
+        .name = "regulatory",
+};
 
 /* notification functions */
 
@@ -2818,6 +2821,61 @@ void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
         genlmsg_multicast(msg, 0, nl80211_scan_mcgrp.id, GFP_KERNEL);
 }
 
+/*
+ * This can happen on global regulatory changes or device specific settings
+ * based on custom world regulatory domains.
+ */
+void nl80211_send_reg_change_event(struct regulatory_request *request)
+{
+        struct sk_buff *msg;
+        void *hdr;
+
+        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        /* Userspace can always count this one always being set */
+        NLA_PUT_U8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator);
+
+        if (request->alpha2[0] == '0' && request->alpha2[1] == '0')
+                NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
+                           NL80211_REGDOM_TYPE_WORLD);
+        else if (request->alpha2[0] == '9' && request->alpha2[1] == '9')
+                NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
+                           NL80211_REGDOM_TYPE_CUSTOM_WORLD);
+        else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
+                 request->intersect)
+                NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
+                           NL80211_REGDOM_TYPE_INTERSECTION);
+        else {
+                NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
+                           NL80211_REGDOM_TYPE_COUNTRY);
+                NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, request->alpha2);
+        }
+
+        if (wiphy_idx_valid(request->wiphy_idx))
+                NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_regulatory_mcgrp.id, GFP_KERNEL);
+
+        return;
+
+nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+}
+
 /* initialisation/exit functions */
 
 int nl80211_init(void)
@@ -2842,6 +2900,10 @@ int nl80211_init(void)
         if (err)
                 goto err_out;
 
+        err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
+        if (err)
+                goto err_out;
+
         return 0;
  err_out:
         genl_unregister_family(&nl80211_fam);
diff --git a/net/wireless/nl80211.h b/net/wireless/nl80211.h
index 69787b621365..e65a3c38c52f 100644
--- a/net/wireless/nl80211.h
+++ b/net/wireless/nl80211.h
@@ -11,6 +11,7 @@ extern void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
                                    struct net_device *netdev);
 extern void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
                                       struct net_device *netdev);
+extern void nl80211_send_reg_change_event(struct regulatory_request *request);
 #else
 static inline int nl80211_init(void)
 {
@@ -31,6 +32,10 @@ static inline void nl80211_send_scan_aborted(
                                         struct cfg80211_registered_device *rdev,
                                         struct net_device *netdev)
 {}
+static inline void
+nl80211_send_reg_change_event(struct regulatory_request *request)
+{
+}
 #endif /* CONFIG_NL80211 */
 
 #endif /* __NET_WIRELESS_NL80211_H */
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 58df98f10990..eb8b8ed16155 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -41,6 +41,7 @@
 #include <net/cfg80211.h>
 #include "core.h"
 #include "reg.h"
+#include "nl80211.h"
 
 /* Receipt of information from last regulatory request */
 static struct regulatory_request *last_request;
@@ -86,20 +87,31 @@ struct reg_beacon {
 
 /* We keep a static world regulatory domain in case of the absence of CRDA */
 static const struct ieee80211_regdomain world_regdom = {
-        .n_reg_rules = 3,
+        .n_reg_rules = 5,
         .alpha2 =  "00",
         .reg_rules = {
                 /* IEEE 802.11b/g, channels 1..11 */
                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
-                /* IEEE 802.11a, channel 36..48 */
-                REG_RULE(5180-10, 5240+10, 40, 6, 23,
+                /* IEEE 802.11b/g, channels 12..13. No HT40
+                 * channel fits here. */
+                REG_RULE(2467-10, 2472+10, 20, 6, 20,
                         NL80211_RRF_PASSIVE_SCAN |
                         NL80211_RRF_NO_IBSS),
+                /* IEEE 802.11 channel 14 - Only JP enables
+                 * this and for 802.11b only */
+                REG_RULE(2484-10, 2484+10, 20, 6, 20,
+                        NL80211_RRF_PASSIVE_SCAN |
+                        NL80211_RRF_NO_IBSS |
+                        NL80211_RRF_NO_OFDM),
+                /* IEEE 802.11a, channel 36..48 */
+                REG_RULE(5180-10, 5240+10, 40, 6, 20,
+                        NL80211_RRF_PASSIVE_SCAN |
+                        NL80211_RRF_NO_IBSS),
 
                 /* NB: 5260 MHz - 5700 MHz requies DFS */
 
                 /* IEEE 802.11a, channel 149..165 */
-                REG_RULE(5745-10, 5825+10, 40, 6, 23,
+                REG_RULE(5745-10, 5825+10, 40, 6, 20,
                         NL80211_RRF_PASSIVE_SCAN |
                         NL80211_RRF_NO_IBSS),
         }
@@ -846,8 +858,8 @@ static int freq_reg_info_regd(struct wiphy *wiphy,
          * Follow the driver's regulatory domain, if present, unless a country
          * IE has been processed or a user wants to help complaince further
          */
-        if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE &&
-            last_request->initiator != REGDOM_SET_BY_USER &&
+        if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
+            last_request->initiator != NL80211_REGDOM_SET_BY_USER &&
             wiphy->regd)
                 regd = wiphy->regd;
 
@@ -932,7 +944,8 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
                  * http://tinyurl.com/11d-clarification
                  */
                 if (r == -ERANGE &&
-                    last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
+                    last_request->initiator ==
+                    NL80211_REGDOM_SET_BY_COUNTRY_IE) {
 #ifdef CONFIG_CFG80211_REG_DEBUG
                         printk(KERN_DEBUG "cfg80211: Leaving channel %d MHz "
                                 "intact on %s - no rule found in band on "
@@ -945,7 +958,8 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
                  * for the band so we respect its band definitions
                  */
 #ifdef CONFIG_CFG80211_REG_DEBUG
-                        if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
+                        if (last_request->initiator ==
+                            NL80211_REGDOM_SET_BY_COUNTRY_IE)
                                 printk(KERN_DEBUG "cfg80211: Disabling "
                                         "channel %d MHz on %s due to "
                                         "Country IE\n",
@@ -959,7 +973,7 @@ static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
 
         power_rule = &reg_rule->power_rule;
 
-        if (last_request->initiator == REGDOM_SET_BY_DRIVER &&
+        if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
             request_wiphy && request_wiphy == wiphy &&
             request_wiphy->strict_regulatory) {
                 /*
@@ -1000,11 +1014,12 @@ static void handle_band(struct wiphy *wiphy, enum ieee80211_band band)
                 handle_channel(wiphy, band, i);
 }
 
-static bool ignore_reg_update(struct wiphy *wiphy, enum reg_set_by setby)
+static bool ignore_reg_update(struct wiphy *wiphy,
+                              enum nl80211_reg_initiator initiator)
 {
         if (!last_request)
                 return true;
-        if (setby == REGDOM_SET_BY_CORE &&
+        if (initiator == NL80211_REGDOM_SET_BY_CORE &&
                   wiphy->custom_regulatory)
                 return true;
         /*
@@ -1017,12 +1032,12 @@ static bool ignore_reg_update(struct wiphy *wiphy, enum reg_set_by setby)
         return false;
 }
 
-static void update_all_wiphy_regulatory(enum reg_set_by setby)
+static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
 {
         struct cfg80211_registered_device *drv;
 
         list_for_each_entry(drv, &cfg80211_drv_list, list)
-                wiphy_update_regulatory(&drv->wiphy, setby);
+                wiphy_update_regulatory(&drv->wiphy, initiator);
 }
 
 static void handle_reg_beacon(struct wiphy *wiphy,
@@ -1113,7 +1128,7 @@ static bool reg_is_world_roaming(struct wiphy *wiphy)
         if (is_world_regdom(cfg80211_regdomain->alpha2) ||
             (wiphy->regd && is_world_regdom(wiphy->regd->alpha2)))
                 return true;
-        if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE &&
+        if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
             wiphy->custom_regulatory)
                 return true;
         return false;
@@ -1127,11 +1142,12 @@ static void reg_process_beacons(struct wiphy *wiphy)
         wiphy_update_beacon_reg(wiphy);
 }
 
-void wiphy_update_regulatory(struct wiphy *wiphy, enum reg_set_by setby)
+void wiphy_update_regulatory(struct wiphy *wiphy,
+                             enum nl80211_reg_initiator initiator)
 {
         enum ieee80211_band band;
 
-        if (ignore_reg_update(wiphy, setby))
+        if (ignore_reg_update(wiphy, initiator))
                 goto out;
         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
                 if (wiphy->bands[band])
@@ -1244,17 +1260,16 @@ static int ignore_request(struct wiphy *wiphy,
                 return 0;
 
         switch (pending_request->initiator) {
-        case REGDOM_SET_BY_INIT:
+        case NL80211_REGDOM_SET_BY_CORE:
                 return -EINVAL;
-        case REGDOM_SET_BY_CORE:
-                return -EINVAL;
-        case REGDOM_SET_BY_COUNTRY_IE:
+        case NL80211_REGDOM_SET_BY_COUNTRY_IE:
 
                 last_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
 
                 if (unlikely(!is_an_alpha2(pending_request->alpha2)))
                         return -EINVAL;
-                if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
+                if (last_request->initiator ==
+                    NL80211_REGDOM_SET_BY_COUNTRY_IE) {
                         if (last_wiphy != wiphy) {
                                 /*
                                  * Two cards with two APs claiming different
@@ -1275,8 +1290,8 @@ static int ignore_request(struct wiphy *wiphy,
                         return -EALREADY;
                 }
                 return REG_INTERSECT;
-        case REGDOM_SET_BY_DRIVER:
-                if (last_request->initiator == REGDOM_SET_BY_CORE) {
+        case NL80211_REGDOM_SET_BY_DRIVER:
+                if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE) {
                         if (is_old_static_regdom(cfg80211_regdomain))
                                 return 0;
                         if (regdom_changes(pending_request->alpha2))
@@ -1289,28 +1304,28 @@ static int ignore_request(struct wiphy *wiphy,
                  * back in or if you add a new device for which the previously
                  * loaded card also agrees on the regulatory domain.
                  */
-                if (last_request->initiator == REGDOM_SET_BY_DRIVER &&
+                if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
                     !regdom_changes(pending_request->alpha2))
                         return -EALREADY;
 
                 return REG_INTERSECT;
-        case REGDOM_SET_BY_USER:
-                if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
+        case NL80211_REGDOM_SET_BY_USER:
+                if (last_request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
                         return REG_INTERSECT;
                 /*
                  * If the user knows better the user should set the regdom
                  * to their country before the IE is picked up
                  */
-                if (last_request->initiator == REGDOM_SET_BY_USER &&
+                if (last_request->initiator == NL80211_REGDOM_SET_BY_USER &&
                           last_request->intersect)
                         return -EOPNOTSUPP;
                 /*
                  * Process user requests only after previous user/driver/core
                  * requests have been processed
                  */
-                if (last_request->initiator == REGDOM_SET_BY_CORE ||
-                    last_request->initiator == REGDOM_SET_BY_DRIVER ||
-                    last_request->initiator == REGDOM_SET_BY_USER) {
+                if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE ||
+                    last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
+                    last_request->initiator == NL80211_REGDOM_SET_BY_USER) {
                         if (regdom_changes(last_request->alpha2))
                                 return -EAGAIN;
                 }
@@ -1350,7 +1365,8 @@ static int __regulatory_hint(struct wiphy *wiphy,
         r = ignore_request(wiphy, pending_request);
 
         if (r == REG_INTERSECT) {
-                if (pending_request->initiator == REGDOM_SET_BY_DRIVER) {
+                if (pending_request->initiator ==
+                    NL80211_REGDOM_SET_BY_DRIVER) {
                         r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
                         if (r) {
                                 kfree(pending_request);
@@ -1365,7 +1381,8 @@ static int __regulatory_hint(struct wiphy *wiphy,
                  * wiphy
                  */
                 if (r == -EALREADY &&
-                    pending_request->initiator == REGDOM_SET_BY_DRIVER) {
+                    pending_request->initiator ==
+                    NL80211_REGDOM_SET_BY_DRIVER) {
                         r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
                         if (r) {
                                 kfree(pending_request);
@@ -1387,8 +1404,16 @@ new_request:
         pending_request = NULL;
 
         /* When r == REG_INTERSECT we do need to call CRDA */
-        if (r < 0)
+        if (r < 0) {
+                /*
+                 * Since CRDA will not be called in this case as we already
+                 * have applied the requested regulatory domain before we just
+                 * inform userspace we have processed the request
+                 */
+                if (r == -EALREADY)
+                        nl80211_send_reg_change_event(last_request);
                 return r;
+        }
 
         /*
          * Note: When CONFIG_WIRELESS_OLD_REGULATORY is enabled
@@ -1416,7 +1441,7 @@ static void reg_process_hint(struct regulatory_request *reg_request)
         if (wiphy_idx_valid(reg_request->wiphy_idx))
                 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
 
-        if (reg_request->initiator == REGDOM_SET_BY_DRIVER &&
+        if (reg_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
             !wiphy) {
                 kfree(reg_request);
                 goto out;
@@ -1430,7 +1455,7 @@ out:
         mutex_unlock(&cfg80211_mutex);
 }
 
-/* Processes regulatory hints, this is all the REGDOM_SET_BY_* */
+/* Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_* */
 static void reg_process_pending_hints(void)
         {
         struct regulatory_request *reg_request;
@@ -1514,7 +1539,7 @@ static int regulatory_hint_core(const char *alpha2)
 
         request->alpha2[0] = alpha2[0];
         request->alpha2[1] = alpha2[1];
-        request->initiator = REGDOM_SET_BY_CORE;
+        request->initiator = NL80211_REGDOM_SET_BY_CORE;
 
         queue_regulatory_request(request);
 
@@ -1535,7 +1560,7 @@ int regulatory_hint_user(const char *alpha2)
         request->wiphy_idx = WIPHY_IDX_STALE;
         request->alpha2[0] = alpha2[0];
         request->alpha2[1] = alpha2[1];
-        request->initiator = REGDOM_SET_BY_USER,
+        request->initiator = NL80211_REGDOM_SET_BY_USER,
 
         queue_regulatory_request(request);
 
@@ -1561,7 +1586,7 @@ int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
 
         request->alpha2[0] = alpha2[0];
         request->alpha2[1] = alpha2[1];
-        request->initiator = REGDOM_SET_BY_DRIVER;
+        request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
 
         queue_regulatory_request(request);
 
@@ -1710,7 +1735,7 @@ void regulatory_hint_11d(struct wiphy *wiphy,
         request->wiphy_idx = get_wiphy_idx(wiphy);
         request->alpha2[0] = rd->alpha2[0];
         request->alpha2[1] = rd->alpha2[1];
-        request->initiator = REGDOM_SET_BY_COUNTRY_IE;
+        request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
         request->country_ie_checksum = checksum;
         request->country_ie_env = env;
 
@@ -1818,7 +1843,8 @@ static void print_regdomain(const struct ieee80211_regdomain *rd)
 
         if (is_intersected_alpha2(rd->alpha2)) {
 
-                if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
+                if (last_request->initiator ==
+                    NL80211_REGDOM_SET_BY_COUNTRY_IE) {
                         struct cfg80211_registered_device *drv;
                         drv = cfg80211_drv_by_wiphy_idx(
                                 last_request->wiphy_idx);
@@ -1910,7 +1936,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
          * rd is non static (it means CRDA was present and was used last)
          * and the pending request came in from a country IE
          */
-        if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
+        if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
                 /*
                  * If someone else asked us to change the rd lets only bother
                  * checking if the alpha2 changes if CRDA was already called
@@ -1942,7 +1968,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
         if (!last_request->intersect) {
                 int r;
 
-                if (last_request->initiator != REGDOM_SET_BY_DRIVER) {
+                if (last_request->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
                         reset_regdomains();
                         cfg80211_regdomain = rd;
                         return 0;
@@ -1966,7 +1992,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
 
         /* Intersection requires a bit more work */
 
-        if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
+        if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
 
                 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
                 if (!intersected_rd)
@@ -1977,7 +2003,7 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                  * However if a driver requested this specific regulatory
                  * domain we keep it for its private use
                  */
-                if (last_request->initiator == REGDOM_SET_BY_DRIVER)
+                if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER)
                         request_wiphy->regd = rd;
                 else
                         kfree(rd);
@@ -2067,6 +2093,8 @@ int set_regdom(const struct ieee80211_regdomain *rd)
 
         print_regdomain(cfg80211_regdomain);
 
+        nl80211_send_reg_change_event(last_request);
+
         return r;
 }