12 files changed, 448 insertions, 113 deletions

diff --git a/drivers/net/wireless/p54/Kconfig b/drivers/net/wireless/p54/Kconfig
index b0342a520bf1..0ec55b50798e 100644
--- a/drivers/net/wireless/p54/Kconfig
+++ b/drivers/net/wireless/p54/Kconfig
@@ -2,13 +2,14 @@ config P54_COMMON
         tristate "Softmac Prism54 support"
         depends on MAC80211 && EXPERIMENTAL
         select FW_LOADER
+        select CRC_CCITT
         ---help---
           This is common code for isl38xx/stlc45xx based modules.
           This module does nothing by itself - the USB/PCI/SPI front-ends
           also need to be enabled in order to support any devices.
 
           These devices require softmac firmware which can be found at
-          http://prism54.org/
+          <http://wireless.kernel.org/en/users/Drivers/p54>
 
           If you choose to build a module, it'll be called p54common.
 
@@ -20,7 +21,7 @@ config P54_USB
           This driver is for USB isl38xx based wireless cards.
 
           These devices require softmac firmware which can be found at
-          http://prism54.org/
+          <http://wireless.kernel.org/en/users/Drivers/p54>
 
           If you choose to build a module, it'll be called p54usb.
 
@@ -34,7 +35,7 @@ config P54_PCI
           supported by the fullmac driver/firmware.
 
           This driver requires softmac firmware which can be found at
-          http://prism54.org/
+          <http://wireless.kernel.org/en/users/Drivers/p54>
 
           If you choose to build a module, it'll be called p54pci.
 
@@ -42,12 +43,28 @@ config P54_SPI
         tristate "Prism54 SPI (stlc45xx) support"
         depends on P54_COMMON && SPI_MASTER && GENERIC_HARDIRQS
         ---help---
-          This driver is for stlc4550 or stlc4560 based wireless chips.
-          This driver is experimental, untested and will probably only work on
-          Nokia's N800/N810 Portable Internet Tablet.
+          This driver is for stlc4550 or stlc4560 based wireless chips
+          such as Nokia's N800/N810 Portable Internet Tablet.
 
           If you choose to build a module, it'll be called p54spi.
 
+config P54_SPI_DEFAULT_EEPROM
+        bool "Include fallback EEPROM blob"
+        depends on P54_SPI
+        default n
+        ---help---
+         Unlike the PCI or USB devices, the SPI variants don't have
+         a dedicated EEPROM chip to store all device specific values
+         for calibration, country and interface settings.
+
+         The driver will try to load the image "3826.eeprom", if the
+         file is put at the right place. (usually /lib/firmware.)
+
+         Only if this request fails, this option will provide a
+         backup set of generic values to get the device working.
+
+         Enabling this option adds about 4k to p54spi.
+
 config P54_LEDS
         bool
         depends on P54_COMMON && MAC80211_LEDS && (LEDS_CLASS = y || LEDS_CLASS = P54_COMMON)
diff --git a/drivers/net/wireless/p54/eeprom.c b/drivers/net/wireless/p54/eeprom.c
index 78347041ec40..54cc0bba66b9 100644
--- a/drivers/net/wireless/p54/eeprom.c
+++ b/drivers/net/wireless/p54/eeprom.c
@@ -23,6 +23,7 @@
 #include <linux/slab.h>
 
 #include <net/mac80211.h>
+#include <linux/crc-ccitt.h>
 
 #include "p54.h"
 #include "eeprom.h"
@@ -54,6 +55,17 @@ static struct ieee80211_rate p54_arates[] = {
         { .bitrate = 540, .hw_value = 11, },
 };
 
+static struct p54_rssi_db_entry p54_rssi_default = {
+        /*
+         * The defaults are taken from usb-logs of the
+         * vendor driver. So, they should be safe to
+         * use in case we can't get a match from the
+         * rssi <-> dBm conversion database.
+         */
+        .mul = 130,
+        .add = -398,
+};
+
 #define CHAN_HAS_CAL            BIT(0)
 #define CHAN_HAS_LIMIT          BIT(1)
 #define CHAN_HAS_CURVE          BIT(2)
@@ -86,13 +98,27 @@ static int p54_get_band_from_freq(u16 freq)
         return -1;
 }
 
+static int same_band(u16 freq, u16 freq2)
+{
+        return p54_get_band_from_freq(freq) == p54_get_band_from_freq(freq2);
+}
+
 static int p54_compare_channels(const void *_a,
                                 const void *_b)
 {
         const struct p54_channel_entry *a = _a;
         const struct p54_channel_entry *b = _b;
 
-        return a->index - b->index;
+        return a->freq - b->freq;
+}
+
+static int p54_compare_rssichan(const void *_a,
+                                const void *_b)
+{
+        const struct p54_rssi_db_entry *a = _a;
+        const struct p54_rssi_db_entry *b = _b;
+
+        return a->freq - b->freq;
 }
 
 static int p54_fill_band_bitrates(struct ieee80211_hw *dev,
@@ -144,25 +170,26 @@ static int p54_generate_band(struct ieee80211_hw *dev,
 
         for (i = 0, j = 0; (j < list->band_channel_num[band]) &&
                            (i < list->entries); i++) {
+                struct p54_channel_entry *chan = &list->channels[i];
 
-                if (list->channels[i].band != band)
+                if (chan->band != band)
                         continue;
 
-                if (list->channels[i].data != CHAN_HAS_ALL) {
-                        wiphy_err(dev->wiphy,
-                                  "%s%s%s is/are missing for channel:%d [%d MHz].\n",
-                                  (list->channels[i].data & CHAN_HAS_CAL ? "" :
+                if (chan->data != CHAN_HAS_ALL) {
+                        wiphy_err(dev->wiphy, "%s%s%s is/are missing for "
+                                  "channel:%d [%d MHz].\n",
+                                  (chan->data & CHAN_HAS_CAL ? "" :
                                    " [iqauto calibration data]"),
-                                  (list->channels[i].data & CHAN_HAS_LIMIT ? "" :
+                                  (chan->data & CHAN_HAS_LIMIT ? "" :
                                    " [output power limits]"),
-                                  (list->channels[i].data & CHAN_HAS_CURVE ? "" :
+                                  (chan->data & CHAN_HAS_CURVE ? "" :
                                    " [curve data]"),
-                                  list->channels[i].index, list->channels[i].freq);
+                                  chan->index, chan->freq);
                         continue;
                 }
 
-                tmp->channels[j].band = list->channels[i].band;
-                tmp->channels[j].center_freq = list->channels[i].freq;
+                tmp->channels[j].band = chan->band;
+                tmp->channels[j].center_freq = chan->freq;
                 j++;
         }
 
@@ -260,8 +287,10 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev)
         list->max_entries = max_channel_num;
         list->channels = kzalloc(sizeof(struct p54_channel_entry) *
                                  max_channel_num, GFP_KERNEL);
-        if (!list->channels)
+        if (!list->channels) {
+                ret = -ENOMEM;
                 goto free;
+        }
 
         for (i = 0; i < max_channel_num; i++) {
                 if (i < priv->iq_autocal_len) {
@@ -288,7 +317,7 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev)
                 }
         }
 
-        /* sort the list by the channel index */
+        /* sort the channel list by frequency */
         sort(list->channels, list->entries, sizeof(struct p54_channel_entry),
              p54_compare_channels, NULL);
 
@@ -407,33 +436,121 @@ static int p54_convert_rev1(struct ieee80211_hw *dev,
 static const char *p54_rf_chips[] = { "INVALID-0", "Duette3", "Duette2",
         "Frisbee", "Xbow", "Longbow", "INVALID-6", "INVALID-7" };
 
-static void p54_parse_rssical(struct ieee80211_hw *dev, void *data, int len,
-                             u16 type)
+static int p54_parse_rssical(struct ieee80211_hw *dev,
+                             u8 *data, int len, u16 type)
 {
         struct p54_common *priv = dev->priv;
-        int offset = (type == PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED) ? 2 : 0;
-        int entry_size = sizeof(struct pda_rssi_cal_entry) + offset;
-        int num_entries = (type == PDR_RSSI_LINEAR_APPROXIMATION) ? 1 : 2;
-        int i;
+        struct p54_rssi_db_entry *entry;
+        size_t db_len, entries;
+        int offset = 0, i;
+
+        if (type != PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED) {
+                entries = (type == PDR_RSSI_LINEAR_APPROXIMATION) ? 1 : 2;
+                if (len != sizeof(struct pda_rssi_cal_entry) * entries) {
+                        wiphy_err(dev->wiphy, "rssical size mismatch.\n");
+                        goto err_data;
+                }
+        } else {
+                /*
+                 * Some devices (Dell 1450 USB, Xbow 5GHz card, etc...)
+                 * have an empty two byte header.
+                 */
+                if (*((__le16 *)&data[offset]) == cpu_to_le16(0))
+                        offset += 2;
 
-        if (len != (entry_size * num_entries)) {
-                wiphy_err(dev->wiphy,
-                          "unknown rssi calibration data packing type:(%x) len:%d.\n",
-                          type, len);
+                entries = (len - offset) /
+                        sizeof(struct pda_rssi_cal_ext_entry);
 
-                print_hex_dump_bytes("rssical:", DUMP_PREFIX_NONE,
-                                     data, len);
+                if ((len - offset) % sizeof(struct pda_rssi_cal_ext_entry) ||
+                    entries <= 0) {
+                        wiphy_err(dev->wiphy, "invalid rssi database.\n");
+                        goto err_data;
+                }
+        }
 
-                wiphy_err(dev->wiphy, "please report this issue.\n");
-                return;
+        db_len = sizeof(*entry) * entries;
+        priv->rssi_db = kzalloc(db_len + sizeof(*priv->rssi_db), GFP_KERNEL);
+        if (!priv->rssi_db)
+                return -ENOMEM;
+
+        priv->rssi_db->offset = 0;
+        priv->rssi_db->entries = entries;
+        priv->rssi_db->entry_size = sizeof(*entry);
+        priv->rssi_db->len = db_len;
+
+        entry = (void *)((unsigned long)priv->rssi_db->data + priv->rssi_db->offset);
+        if (type == PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED) {
+                struct pda_rssi_cal_ext_entry *cal = (void *) &data[offset];
+
+                for (i = 0; i < entries; i++) {
+                        entry[i].freq = le16_to_cpu(cal[i].freq);
+                        entry[i].mul = (s16) le16_to_cpu(cal[i].mul);
+                        entry[i].add = (s16) le16_to_cpu(cal[i].add);
+                }
+        } else {
+                struct pda_rssi_cal_entry *cal = (void *) &data[offset];
+
+                for (i = 0; i < entries; i++) {
+                        u16 freq = 0;
+                        switch (i) {
+                        case IEEE80211_BAND_2GHZ:
+                                freq = 2437;
+                                break;
+                        case IEEE80211_BAND_5GHZ:
+                                freq = 5240;
+                                break;
+                        }
+
+                        entry[i].freq = freq;
+                        entry[i].mul = (s16) le16_to_cpu(cal[i].mul);
+                        entry[i].add = (s16) le16_to_cpu(cal[i].add);
+                }
         }
 
-        for (i = 0; i < num_entries; i++) {
-                struct pda_rssi_cal_entry *cal = data +
-                                                 (offset + i * entry_size);
-                priv->rssical_db[i].mul = (s16) le16_to_cpu(cal->mul);
-                priv->rssical_db[i].add = (s16) le16_to_cpu(cal->add);
+        /* sort the list by channel frequency */
+        sort(entry, entries, sizeof(*entry), p54_compare_rssichan, NULL);
+        return 0;
+
+err_data:
+        wiphy_err(dev->wiphy,
+                  "rssi calibration data packing type:(%x) len:%d.\n",
+                  type, len);
+
+        print_hex_dump_bytes("rssical:", DUMP_PREFIX_NONE, data, len);
+
+        wiphy_err(dev->wiphy, "please report this issue.\n");
+        return -EINVAL;
+}
+
+struct p54_rssi_db_entry *p54_rssi_find(struct p54_common *priv, const u16 freq)
+{
+        struct p54_rssi_db_entry *entry;
+        int i, found = -1;
+
+        if (!priv->rssi_db)
+                return &p54_rssi_default;
+
+        entry = (void *)(priv->rssi_db->data + priv->rssi_db->offset);
+        for (i = 0; i < priv->rssi_db->entries; i++) {
+                if (!same_band(freq, entry[i].freq))
+                        continue;
+
+                if (found == -1) {
+                        found = i;
+                        continue;
+                }
+
+                /* nearest match */
+                if (abs(freq - entry[i].freq) <
+                    abs(freq - entry[found].freq)) {
+                        found = i;
+                        continue;
+                } else {
+                        break;
+                }
         }
+
+        return found < 0 ? &p54_rssi_default : &entry[found];
 }
 
 static void p54_parse_default_country(struct ieee80211_hw *dev,
@@ -540,6 +657,7 @@ int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
         int err;
         u8 *end = (u8 *)eeprom + len;
         u16 synth = 0;
+        u16 crc16 = ~0;
 
         wrap = (struct eeprom_pda_wrap *) eeprom;
         entry = (void *)wrap->data + le16_to_cpu(wrap->len);
@@ -623,21 +741,30 @@ int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                 case PDR_RSSI_LINEAR_APPROXIMATION:
                 case PDR_RSSI_LINEAR_APPROXIMATION_DUAL_BAND:
                 case PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED:
-                        p54_parse_rssical(dev, entry->data, data_len,
-                                          le16_to_cpu(entry->code));
+                        err = p54_parse_rssical(dev, entry->data, data_len,
+                                                le16_to_cpu(entry->code));
+                        if (err)
+                                goto err;
                         break;
-                case PDR_RSSI_LINEAR_APPROXIMATION_CUSTOM: {
-                        __le16 *src = (void *) entry->data;
-                        s16 *dst = (void *) &priv->rssical_db;
+                case PDR_RSSI_LINEAR_APPROXIMATION_CUSTOMV2: {
+                        struct pda_custom_wrapper *pda = (void *) entry->data;
+                        __le16 *src;
+                        u16 *dst;
                         int i;
 
-                        if (data_len != sizeof(priv->rssical_db)) {
-                                err = -EINVAL;
-                                goto err;
-                        }
-                        for (i = 0; i < sizeof(priv->rssical_db) /
-                                        sizeof(*src); i++)
+                        if (priv->rssi_db || data_len < sizeof(*pda))
+                                break;
+
+                        priv->rssi_db = p54_convert_db(pda, data_len);
+                        if (!priv->rssi_db)
+                                break;
+
+                        src = (void *) priv->rssi_db->data;
+                        dst = (void *) priv->rssi_db->data;
+
+                        for (i = 0; i < priv->rssi_db->entries; i++)
                                 *(dst++) = (s16) le16_to_cpu(*(src++));
+
                         }
                         break;
                 case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS_CUSTOM: {
@@ -655,16 +782,29 @@ int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                         }
                         break;
                 case PDR_END:
-                        /* make it overrun */
-                        entry_len = len;
+                        crc16 = ~crc_ccitt(crc16, (u8 *) entry, sizeof(*entry));
+                        if (crc16 != le16_to_cpup((__le16 *)entry->data)) {
+                                wiphy_err(dev->wiphy, "eeprom failed checksum "
+                                         "test!\n");
+                                err = -ENOMSG;
+                                goto err;
+                        } else {
+                                goto good_eeprom;
+                        }
                         break;
                 default:
                         break;
                 }
 
-                entry = (void *)entry + (entry_len + 1)*2;
+                crc16 = crc_ccitt(crc16, (u8 *)entry, (entry_len + 1) * 2);
+                entry = (void *)entry + (entry_len + 1) * 2;
         }
 
+        wiphy_err(dev->wiphy, "unexpected end of eeprom data.\n");
+        err = -ENODATA;
+        goto err;
+
+good_eeprom:
         if (!synth || !priv->iq_autocal || !priv->output_limit ||
             !priv->curve_data) {
                 wiphy_err(dev->wiphy,
@@ -700,6 +840,8 @@ int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                 SET_IEEE80211_PERM_ADDR(dev, perm_addr);
         }
 
+        priv->cur_rssi = &p54_rssi_default;
+
         wiphy_info(dev->wiphy, "hwaddr %pM, MAC:isl38%02x RF:%s\n",
                    dev->wiphy->perm_addr, priv->version,
                    p54_rf_chips[priv->rxhw]);
@@ -710,9 +852,11 @@ err:
         kfree(priv->iq_autocal);
         kfree(priv->output_limit);
         kfree(priv->curve_data);
+        kfree(priv->rssi_db);
         priv->iq_autocal = NULL;
         priv->output_limit = NULL;
         priv->curve_data = NULL;
+        priv->rssi_db = NULL;
 
         wiphy_err(dev->wiphy, "eeprom parse failed!\n");
         return err;
diff --git a/drivers/net/wireless/p54/eeprom.h b/drivers/net/wireless/p54/eeprom.h
index 9051aef11249..afde72b84606 100644
--- a/drivers/net/wireless/p54/eeprom.h
+++ b/drivers/net/wireless/p54/eeprom.h
@@ -81,6 +81,12 @@ struct pda_pa_curve_data {
         u8 data[0];
 } __packed;
 
+struct pda_rssi_cal_ext_entry {
+        __le16 freq;
+        __le16 mul;
+        __le16 add;
+} __packed;
+
 struct pda_rssi_cal_entry {
         __le16 mul;
         __le16 add;
@@ -179,6 +185,7 @@ struct pda_custom_wrapper {
 
 /* used by our modificated eeprom image */
 #define PDR_RSSI_LINEAR_APPROXIMATION_CUSTOM            0xDEAD
+#define PDR_RSSI_LINEAR_APPROXIMATION_CUSTOMV2          0xCAFF
 #define PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS_CUSTOM     0xBEEF
 #define PDR_PRISM_PA_CAL_CURVE_DATA_CUSTOM              0xB05D
 
diff --git a/drivers/net/wireless/p54/fwio.c b/drivers/net/wireless/p54/fwio.c
index 15b20c29a604..b6a061cbbdec 100644
--- a/drivers/net/wireless/p54/fwio.c
+++ b/drivers/net/wireless/p54/fwio.c
@@ -123,10 +123,14 @@ int p54_parse_firmware(struct ieee80211_hw *dev, const struct firmware *fw)
                 bootrec = (struct bootrec *)&bootrec->data[len];
         }
 
-        if (fw_version)
+        if (fw_version) {
                 wiphy_info(priv->hw->wiphy,
                            "FW rev %s - Softmac protocol %x.%x\n",
                            fw_version, priv->fw_var >> 8, priv->fw_var & 0xff);
+                snprintf(dev->wiphy->fw_version, sizeof(dev->wiphy->fw_version),
+                                "%s - %x.%x", fw_version,
+                                priv->fw_var >> 8, priv->fw_var & 0xff);
+        }
 
         if (priv->fw_var < 0x500)
                 wiphy_info(priv->hw->wiphy,
@@ -393,9 +397,9 @@ int p54_scan(struct p54_common *priv, u16 mode, u16 dwell)
         union p54_scan_body_union *body;
         struct p54_scan_tail_rate *rate;
         struct pda_rssi_cal_entry *rssi;
+        struct p54_rssi_db_entry *rssi_data;
         unsigned int i;
         void *entry;
-        int band = priv->hw->conf.channel->band;
         __le16 freq = cpu_to_le16(priv->hw->conf.channel->center_freq);
 
         skb = p54_alloc_skb(priv, P54_HDR_FLAG_CONTROL_OPSET, sizeof(*head) +
@@ -499,13 +503,14 @@ int p54_scan(struct p54_common *priv, u16 mode, u16 dwell)
         }
 
         rssi = (struct pda_rssi_cal_entry *) skb_put(skb, sizeof(*rssi));
-        rssi->mul = cpu_to_le16(priv->rssical_db[band].mul);
-        rssi->add = cpu_to_le16(priv->rssical_db[band].add);
+        rssi_data = p54_rssi_find(priv, le16_to_cpu(freq));
+        rssi->mul = cpu_to_le16(rssi_data->mul);
+        rssi->add = cpu_to_le16(rssi_data->add);
         if (priv->rxhw == PDR_SYNTH_FRONTEND_LONGBOW) {
                 /* Longbow frontend needs ever more */
                 rssi = (void *) skb_put(skb, sizeof(*rssi));
-                rssi->mul = cpu_to_le16(priv->rssical_db[band].longbow_unkn);
-                rssi->add = cpu_to_le16(priv->rssical_db[band].longbow_unk2);
+                rssi->mul = cpu_to_le16(rssi_data->longbow_unkn);
+                rssi->add = cpu_to_le16(rssi_data->longbow_unk2);
         }
 
         if (priv->fw_var >= 0x509) {
@@ -519,6 +524,7 @@ int p54_scan(struct p54_common *priv, u16 mode, u16 dwell)
         hdr->len = cpu_to_le16(skb->len - sizeof(*hdr));
 
         p54_tx(priv, skb);
+        priv->cur_rssi = rssi_data;
         return 0;
 
 err:
@@ -553,6 +559,7 @@ int p54_set_edcf(struct p54_common *priv)
 {
         struct sk_buff *skb;
         struct p54_edcf *edcf;
+        u8 rtd;
 
         skb = p54_alloc_skb(priv, P54_HDR_FLAG_CONTROL_OPSET, sizeof(*edcf),
                             P54_CONTROL_TYPE_DCFINIT, GFP_ATOMIC);
@@ -569,9 +576,15 @@ int p54_set_edcf(struct p54_common *priv)
                 edcf->sifs = 0x0a;
                 edcf->eofpad = 0x06;
         }
+        /*
+         * calculate the extra round trip delay according to the
+         * formula from 802.11-2007 17.3.8.6.
+         */
+        rtd = 3 * priv->coverage_class;
+        edcf->slottime += rtd;
+        edcf->round_trip_delay = cpu_to_le16(rtd);
         /* (see prism54/isl_oid.h for further details) */
         edcf->frameburst = cpu_to_le16(0);
-        edcf->round_trip_delay = cpu_to_le16(0);
         edcf->flags = 0;
         memset(edcf->mapping, 0, sizeof(edcf->mapping));
         memcpy(edcf->queue, priv->qos_params, sizeof(edcf->queue));
@@ -714,3 +727,34 @@ int p54_fetch_statistics(struct p54_common *priv)
         p54_tx(priv, skb);
         return 0;
 }
+
+int p54_set_groupfilter(struct p54_common *priv)
+{
+        struct p54_group_address_table *grp;
+        struct sk_buff *skb;
+        bool on = false;
+
+        skb = p54_alloc_skb(priv, P54_HDR_FLAG_CONTROL_OPSET, sizeof(*grp),
+                            P54_CONTROL_TYPE_GROUP_ADDRESS_TABLE, GFP_KERNEL);
+        if (!skb)
+                return -ENOMEM;
+
+        grp = (struct p54_group_address_table *)skb_put(skb, sizeof(*grp));
+
+        on = !(priv->filter_flags & FIF_ALLMULTI) &&
+             (priv->mc_maclist_num > 0 &&
+              priv->mc_maclist_num <= MC_FILTER_ADDRESS_NUM);
+
+        if (on) {
+                grp->filter_enable = cpu_to_le16(1);
+                grp->num_address = cpu_to_le16(priv->mc_maclist_num);
+                memcpy(grp->mac_list, priv->mc_maclist, sizeof(grp->mac_list));
+        } else {
+                grp->filter_enable = cpu_to_le16(0);
+                grp->num_address = cpu_to_le16(0);
+                memset(grp->mac_list, 0, sizeof(grp->mac_list));
+        }
+
+        p54_tx(priv, skb);
+        return 0;
+}
diff --git a/drivers/net/wireless/p54/lmac.h b/drivers/net/wireless/p54/lmac.h
index 04b63ec80fa4..3d8d622bec55 100644
--- a/drivers/net/wireless/p54/lmac.h
+++ b/drivers/net/wireless/p54/lmac.h
@@ -526,7 +526,7 @@ int p54_init_leds(struct p54_common *priv);
 void p54_unregister_leds(struct p54_common *priv);
 
 /* xmit functions */
-int p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb);
+void p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb);
 int p54_tx_cancel(struct p54_common *priv, __le32 req_id);
 void p54_tx(struct p54_common *priv, struct sk_buff *skb);
 
@@ -540,6 +540,7 @@ int p54_update_beacon_tim(struct p54_common *priv, u16 aid, bool set);
 int p54_setup_mac(struct p54_common *priv);
 int p54_set_ps(struct p54_common *priv);
 int p54_fetch_statistics(struct p54_common *priv);
+int p54_set_groupfilter(struct p54_common *priv);
 
 /* e/v DCF setup */
 int p54_set_edcf(struct p54_common *priv);
@@ -551,6 +552,7 @@ int p54_upload_key(struct p54_common *priv, u8 algo, int slot,
 /* eeprom */
 int p54_download_eeprom(struct p54_common *priv, void *buf,
                         u16 offset, u16 len);
+struct p54_rssi_db_entry *p54_rssi_find(struct p54_common *p, const u16 freq);
 
 /* utility */
 u8 *p54_find_ie(struct sk_buff *skb, u8 ie);
diff --git a/drivers/net/wireless/p54/main.c b/drivers/net/wireless/p54/main.c
index 47db439b63bf..a5a6d9e647bb 100644
--- a/drivers/net/wireless/p54/main.c
+++ b/drivers/net/wireless/p54/main.c
@@ -157,7 +157,7 @@ static int p54_beacon_update(struct p54_common *priv,
          * to cancel the old beacon template by hand, instead the firmware
          * will release the previous one through the feedback mechanism.
          */
-        WARN_ON(p54_tx_80211(priv->hw, beacon));
+        p54_tx_80211(priv->hw, beacon);
         priv->tsf_high32 = 0;
         priv->tsf_low32 = 0;
 
@@ -308,6 +308,31 @@ out:
         return ret;
 }
 
+static u64 p54_prepare_multicast(struct ieee80211_hw *dev,
+                                 struct netdev_hw_addr_list *mc_list)
+{
+        struct p54_common *priv = dev->priv;
+        struct netdev_hw_addr *ha;
+        int i;
+
+        BUILD_BUG_ON(ARRAY_SIZE(priv->mc_maclist) !=
+                ARRAY_SIZE(((struct p54_group_address_table *)NULL)->mac_list));
+        /*
+         * The first entry is reserved for the global broadcast MAC.
+         * Otherwise the firmware will drop it and ARP will no longer work.
+         */
+        i = 1;
+        priv->mc_maclist_num = netdev_hw_addr_list_count(mc_list) + i;
+        netdev_hw_addr_list_for_each(ha, mc_list) {
+                memcpy(&priv->mc_maclist[i], ha->addr, ETH_ALEN);
+                i++;
+                if (i >= ARRAY_SIZE(priv->mc_maclist))
+                        break;
+        }
+
+        return 1; /* update */
+}
+
 static void p54_configure_filter(struct ieee80211_hw *dev,
                                  unsigned int changed_flags,
                                  unsigned int *total_flags,
@@ -316,12 +341,16 @@ static void p54_configure_filter(struct ieee80211_hw *dev,
         struct p54_common *priv = dev->priv;
 
         *total_flags &= FIF_PROMISC_IN_BSS |
+                        FIF_ALLMULTI |
                         FIF_OTHER_BSS;
 
         priv->filter_flags = *total_flags;
 
         if (changed_flags & (FIF_PROMISC_IN_BSS | FIF_OTHER_BSS))
                 p54_setup_mac(priv);
+
+        if (changed_flags & FIF_ALLMULTI || multicast)
+                p54_set_groupfilter(priv);
 }
 
 static int p54_conf_tx(struct ieee80211_hw *dev, u16 queue,
@@ -429,8 +458,8 @@ static int p54_set_key(struct ieee80211_hw *dev, enum set_key_cmd cmd,
 
         mutex_lock(&priv->conf_mutex);
         if (cmd == SET_KEY) {
-                switch (key->alg) {
-                case ALG_TKIP:
+                switch (key->cipher) {
+                case WLAN_CIPHER_SUITE_TKIP:
                         if (!(priv->privacy_caps & (BR_DESC_PRIV_CAP_MICHAEL |
                               BR_DESC_PRIV_CAP_TKIP))) {
                                 ret = -EOPNOTSUPP;
@@ -439,7 +468,8 @@ static int p54_set_key(struct ieee80211_hw *dev, enum set_key_cmd cmd,
                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
                         algo = P54_CRYPTO_TKIPMICHAEL;
                         break;
-                case ALG_WEP:
+                case WLAN_CIPHER_SUITE_WEP40:
+                case WLAN_CIPHER_SUITE_WEP104:
                         if (!(priv->privacy_caps & BR_DESC_PRIV_CAP_WEP)) {
                                 ret = -EOPNOTSUPP;
                                 goto out_unlock;
@@ -447,7 +477,7 @@ static int p54_set_key(struct ieee80211_hw *dev, enum set_key_cmd cmd,
                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
                         algo = P54_CRYPTO_WEP;
                         break;
-                case ALG_CCMP:
+                case WLAN_CIPHER_SUITE_CCMP:
                         if (!(priv->privacy_caps & BR_DESC_PRIV_CAP_AESCCMP)) {
                                 ret = -EOPNOTSUPP;
                                 goto out_unlock;
@@ -464,7 +494,7 @@ static int p54_set_key(struct ieee80211_hw *dev, enum set_key_cmd cmd,
 
                 if (slot < 0) {
                         /*
-                         * The device supports the choosen algorithm, but the
+                         * The device supports the chosen algorithm, but the
                          * firmware does not provide enough key slots to store
                          * all of them.
                          * But encryption offload for outgoing frames is always
@@ -523,6 +553,59 @@ static int p54_get_survey(struct ieee80211_hw *dev, int idx,
         return 0;
 }
 
+static unsigned int p54_flush_count(struct p54_common *priv)
+{
+        unsigned int total = 0, i;
+
+        BUILD_BUG_ON(P54_QUEUE_NUM > ARRAY_SIZE(priv->tx_stats));
+
+        /*
+         * Because the firmware has the sole control over any frames
+         * in the P54_QUEUE_BEACON or P54_QUEUE_SCAN queues, they
+         * don't really count as pending or active.
+         */
+        for (i = P54_QUEUE_MGMT; i < P54_QUEUE_NUM; i++)
+                total += priv->tx_stats[i].len;
+        return total;
+}
+
+static void p54_flush(struct ieee80211_hw *dev, bool drop)
+{
+        struct p54_common *priv = dev->priv;
+        unsigned int total, i;
+
+        /*
+         * Currently, it wouldn't really matter if we wait for one second
+         * or 15 minutes. But once someone gets around and completes the
+         * TODOs [ancel stuck frames / reset device] in p54_work, it will
+         * suddenly make sense to wait that long.
+         */
+        i = P54_STATISTICS_UPDATE * 2 / 20;
+
+        /*
+         * In this case no locking is required because as we speak the
+         * queues have already been stopped and no new frames can sneak
+         * up from behind.
+         */
+        while ((total = p54_flush_count(priv) && i--)) {
+                /* waste time */
+                msleep(20);
+        }
+
+        WARN(total, "tx flush timeout, unresponsive firmware");
+}
+
+static void p54_set_coverage_class(struct ieee80211_hw *dev, u8 coverage_class)
+{
+        struct p54_common *priv = dev->priv;
+
+        mutex_lock(&priv->conf_mutex);
+        /* support all coverage class values as in 802.11-2007 Table 7-27 */
+        priv->coverage_class = clamp_t(u8, coverage_class, 0, 31);
+        p54_set_edcf(priv);
+        mutex_unlock(&priv->conf_mutex);
+}
+
 static const struct ieee80211_ops p54_ops = {
         .tx                     = p54_tx_80211,
         .start                  = p54_start,
@@ -535,11 +618,14 @@ static const struct ieee80211_ops p54_ops = {
         .sta_remove             = p54_sta_add_remove,
         .set_key                = p54_set_key,
         .config                 = p54_config,
+        .flush                  = p54_flush,
         .bss_info_changed       = p54_bss_info_changed,
+        .prepare_multicast      = p54_prepare_multicast,
         .configure_filter       = p54_configure_filter,
         .conf_tx                = p54_conf_tx,
         .get_stats              = p54_get_stats,
         .get_survey             = p54_get_survey,
+        .set_coverage_class     = p54_set_coverage_class,
 };
 
 struct ieee80211_hw *p54_init_common(size_t priv_data_len)
@@ -604,13 +690,14 @@ struct ieee80211_hw *p54_init_common(size_t priv_data_len)
         init_completion(&priv->beacon_comp);
         INIT_DELAYED_WORK(&priv->work, p54_work);
 
+        memset(&priv->mc_maclist[0], ~0, ETH_ALEN);
         return dev;
 }
 EXPORT_SYMBOL_GPL(p54_init_common);
 
 int p54_register_common(struct ieee80211_hw *dev, struct device *pdev)
 {
-        struct p54_common *priv = dev->priv;
+        struct p54_common __maybe_unused *priv = dev->priv;
         int err;
 
         err = ieee80211_register_hw(dev);
@@ -641,10 +728,12 @@ void p54_free_common(struct ieee80211_hw *dev)
         kfree(priv->iq_autocal);
         kfree(priv->output_limit);
         kfree(priv->curve_data);
+        kfree(priv->rssi_db);
         kfree(priv->used_rxkeys);
         priv->iq_autocal = NULL;
         priv->output_limit = NULL;
         priv->curve_data = NULL;
+        priv->rssi_db = NULL;
         priv->used_rxkeys = NULL;
         ieee80211_free_hw(dev);
 }
diff --git a/drivers/net/wireless/p54/p54.h b/drivers/net/wireless/p54/p54.h
index 43a3b2ead81a..799d05e12595 100644
--- a/drivers/net/wireless/p54/p54.h
+++ b/drivers/net/wireless/p54/p54.h
@@ -116,7 +116,8 @@ struct p54_edcf_queue_param {
         __le16 txop;
 } __packed;
 
-struct p54_rssi_linear_approximation {
+struct p54_rssi_db_entry {
+        u16 freq;
         s16 mul;
         s16 add;
         s16 longbow_unkn;
@@ -197,24 +198,28 @@ struct p54_common {
         u8 rx_diversity_mask;
         u8 tx_diversity_mask;
         unsigned int output_power;
+        struct p54_rssi_db_entry *cur_rssi;
         int noise;
         /* calibration, output power limit and rssi<->dBm conversation data */
         struct pda_iq_autocal_entry *iq_autocal;
         unsigned int iq_autocal_len;
         struct p54_cal_database *curve_data;
         struct p54_cal_database *output_limit;
-        struct p54_rssi_linear_approximation rssical_db[IEEE80211_NUM_BANDS];
+        struct p54_cal_database *rssi_db;
         struct ieee80211_supported_band *band_table[IEEE80211_NUM_BANDS];
 
         /* BBP/MAC state */
         u8 mac_addr[ETH_ALEN];
         u8 bssid[ETH_ALEN];
+        u8 mc_maclist[4][ETH_ALEN];
         u16 wakeup_timer;
         unsigned int filter_flags;
+        int mc_maclist_num;
         int mode;
         u32 tsf_low32, tsf_high32;
         u32 basic_rate_mask;
         u16 aid;
+        u8 coverage_class;
         bool powersave_override;
         __le32 beacon_req_id;
         struct completion beacon_comp;
diff --git a/drivers/net/wireless/p54/p54pci.c b/drivers/net/wireless/p54/p54pci.c
index 1eacba4daa5b..1b753173680f 100644
--- a/drivers/net/wireless/p54/p54pci.c
+++ b/drivers/net/wireless/p54/p54pci.c
@@ -199,6 +199,7 @@ static void p54p_check_rx_ring(struct ieee80211_hw *dev, u32 *index,
         while (i != idx) {
                 u16 len;
                 struct sk_buff *skb;
+                dma_addr_t dma_addr;
                 desc = &ring[i];
                 len = le16_to_cpu(desc->len);
                 skb = rx_buf[i];
@@ -216,17 +217,20 @@ static void p54p_check_rx_ring(struct ieee80211_hw *dev, u32 *index,
 
                         len = priv->common.rx_mtu;
                 }
+                dma_addr = le32_to_cpu(desc->host_addr);
+                pci_dma_sync_single_for_cpu(priv->pdev, dma_addr,
+                        priv->common.rx_mtu + 32, PCI_DMA_FROMDEVICE);
                 skb_put(skb, len);
 
                 if (p54_rx(dev, skb)) {
-                        pci_unmap_single(priv->pdev,
-                                         le32_to_cpu(desc->host_addr),
-                                         priv->common.rx_mtu + 32,
-                                         PCI_DMA_FROMDEVICE);
+                        pci_unmap_single(priv->pdev, dma_addr,
+                                priv->common.rx_mtu + 32, PCI_DMA_FROMDEVICE);
                         rx_buf[i] = NULL;
-                        desc->host_addr = 0;
+                        desc->host_addr = cpu_to_le32(0);
                 } else {
                         skb_trim(skb, 0);
+                        pci_dma_sync_single_for_device(priv->pdev, dma_addr,
+                                priv->common.rx_mtu + 32, PCI_DMA_FROMDEVICE);
                         desc->len = cpu_to_le16(priv->common.rx_mtu + 32);
                 }
 
@@ -327,10 +331,9 @@ static void p54p_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
         struct p54p_ring_control *ring_control = priv->ring_control;
         struct p54p_desc *desc;
         dma_addr_t mapping;
-        u32 device_idx, idx, i;
+        u32 idx, i;
 
         spin_lock_irqsave(&priv->lock, flags);
-        device_idx = le32_to_cpu(ring_control->device_idx[1]);
         idx = le32_to_cpu(ring_control->host_idx[1]);
         i = idx % ARRAY_SIZE(ring_control->tx_data);
 
diff --git a/drivers/net/wireless/p54/p54spi.c b/drivers/net/wireless/p54/p54spi.c
index 087bf0698a5a..6d9204fef90b 100644
--- a/drivers/net/wireless/p54/p54spi.c
+++ b/drivers/net/wireless/p54/p54spi.c
@@ -32,11 +32,14 @@
 #include <linux/slab.h>
 
 #include "p54spi.h"
-#include "p54spi_eeprom.h"
 #include "p54.h"
 
 #include "lmac.h"
 
+#ifdef CONFIG_P54_SPI_DEFAULT_EEPROM
+#include "p54spi_eeprom.h"
+#endif /* CONFIG_P54_SPI_DEFAULT_EEPROM */
+
 MODULE_FIRMWARE("3826.arm");
 MODULE_ALIAS("stlc45xx");
 
@@ -195,9 +198,13 @@ static int p54spi_request_eeprom(struct ieee80211_hw *dev)
 
         ret = request_firmware(&eeprom, "3826.eeprom", &priv->spi->dev);
         if (ret < 0) {
+#ifdef CONFIG_P54_SPI_DEFAULT_EEPROM
                 dev_info(&priv->spi->dev, "loading default eeprom...\n");
                 ret = p54_parse_eeprom(dev, (void *) p54spi_eeprom,
                                        sizeof(p54spi_eeprom));
+#else
+                dev_err(&priv->spi->dev, "Failed to request user eeprom\n");
+#endif /* CONFIG_P54_SPI_DEFAULT_EEPROM */
         } else {
                 dev_info(&priv->spi->dev, "loading user eeprom...\n");
                 ret = p54_parse_eeprom(dev, (void *) eeprom->data,
@@ -280,7 +287,7 @@ static void p54spi_power_on(struct p54s_priv *priv)
         enable_irq(gpio_to_irq(p54spi_gpio_irq));
 
         /*
-         * need to wait a while before device can be accessed, the lenght
+         * need to wait a while before device can be accessed, the length
          * is just a guess
          */
         msleep(10);
@@ -642,8 +649,7 @@ static int __devinit p54spi_probe(struct spi_device *spi)
                 goto err_free_common;
         }
 
-        set_irq_type(gpio_to_irq(p54spi_gpio_irq),
-                     IRQ_TYPE_EDGE_RISING);
+        irq_set_irq_type(gpio_to_irq(p54spi_gpio_irq), IRQ_TYPE_EDGE_RISING);
 
         disable_irq(gpio_to_irq(p54spi_gpio_irq));
 
diff --git a/drivers/net/wireless/p54/p54spi_eeprom.h b/drivers/net/wireless/p54/p54spi_eeprom.h
index 1ea1050911d9..0b7bfb0adcf2 100644
--- a/drivers/net/wireless/p54/p54spi_eeprom.h
+++ b/drivers/net/wireless/p54/p54spi_eeprom.h
@@ -65,9 +65,10 @@ static unsigned char p54spi_eeprom[] = {
 0x03, 0x00, 0x00, 0x11,         /* PDR_ANTENNA_GAIN */
         0x08, 0x08, 0x08, 0x08,
 
-0x09, 0x00, 0xad, 0xde,         /* PDR_RSSI_LINEAR_APPROXIMATION_CUSTOM */
-        0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x0a, 0x00, 0xff, 0xca,         /* PDR_RSSI_LINEAR_APPROXIMATION_CUSTOMV2 */
+        0x01, 0x00, 0x0a, 0x00,
+        0x00, 0x00, 0x0a, 0x00,
+                0x85, 0x09, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00,
 
 /* struct pda_custom_wrapper */
 0x10, 0x06, 0x5d, 0xb0,         /* PDR_PRISM_PA_CAL_CURVE_DATA_CUSTOM */
@@ -671,7 +672,7 @@ static unsigned char p54spi_eeprom[] = {
         0xa8, 0x09, 0x25, 0x00, 0xf5, 0xff, 0xf9, 0xff, 0x00, 0x01,
 
 0x02, 0x00, 0x00, 0x00,         /* PDR_END */
-        0xa8, 0xf5                      /* bogus data */
+        0xb6, 0x04,
 };
 
 #endif /* P54SPI_EEPROM_H */
diff --git a/drivers/net/wireless/p54/p54usb.c b/drivers/net/wireless/p54/p54usb.c
index ad595958b7df..a8f3bc740dfa 100644
--- a/drivers/net/wireless/p54/p54usb.c
+++ b/drivers/net/wireless/p54/p54usb.c
@@ -33,8 +33,18 @@ MODULE_ALIAS("prism54usb");
 MODULE_FIRMWARE("isl3886usb");
 MODULE_FIRMWARE("isl3887usb");
 
+/*
+ * Note:
+ *
+ * Always update our wiki's device list (located at:
+ * http://wireless.kernel.org/en/users/Drivers/p54/devices ),
+ * whenever you add a new device.
+ */
+
 static struct usb_device_id p54u_table[] __devinitdata = {
         /* Version 1 devices (pci chip + net2280) */
+        {USB_DEVICE(0x0411, 0x0050)},   /* Buffalo WLI2-USB2-G54 */
+        {USB_DEVICE(0x045e, 0x00c2)},   /* Microsoft MN-710 */
         {USB_DEVICE(0x0506, 0x0a11)},   /* 3COM 3CRWE254G72 */
         {USB_DEVICE(0x06b9, 0x0120)},   /* Thomson SpeedTouch 120g */
         {USB_DEVICE(0x0707, 0xee06)},   /* SMC 2862W-G */
@@ -46,12 +56,20 @@ static struct usb_device_id p54u_table[] __devinitdata = {
         {USB_DEVICE(0x0846, 0x4210)},   /* Netgear WG121 the second ? */
         {USB_DEVICE(0x0846, 0x4220)},   /* Netgear WG111 */
         {USB_DEVICE(0x09aa, 0x1000)},   /* Spinnaker Proto board */
+        {USB_DEVICE(0x0bf8, 0x1007)},   /* Fujitsu E-5400 USB */
         {USB_DEVICE(0x0cde, 0x0006)},   /* Medion 40900, Roper Europe */
+        {USB_DEVICE(0x0db0, 0x6826)},   /* MSI UB54G (MS-6826) */
+        {USB_DEVICE(0x107b, 0x55f2)},   /* Gateway WGU-210 (Gemtek) */
         {USB_DEVICE(0x124a, 0x4023)},   /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
+        {USB_DEVICE(0x1435, 0x0210)},   /* Inventel UR054G */
+        {USB_DEVICE(0x15a9, 0x0002)},   /* Gemtek WUBI-100GW 802.11g */
+        {USB_DEVICE(0x1630, 0x0005)},   /* 2Wire 802.11g USB (v1) / Z-Com */
+        {USB_DEVICE(0x182d, 0x096b)},   /* Sitecom WL-107 */
         {USB_DEVICE(0x1915, 0x2234)},   /* Linksys WUSB54G OEM */
         {USB_DEVICE(0x1915, 0x2235)},   /* Linksys WUSB54G Portable OEM */
         {USB_DEVICE(0x2001, 0x3701)},   /* DLink DWL-G120 Spinnaker */
         {USB_DEVICE(0x2001, 0x3703)},   /* DLink DWL-G122 */
+        {USB_DEVICE(0x2001, 0x3762)},   /* Conceptronic C54U */
         {USB_DEVICE(0x5041, 0x2234)},   /* Linksys WUSB54G */
         {USB_DEVICE(0x5041, 0x2235)},   /* Linksys WUSB54G Portable */
 
@@ -60,9 +78,11 @@ static struct usb_device_id p54u_table[] __devinitdata = {
         {USB_DEVICE(0x050d, 0x7050)},   /* Belkin F5D7050 ver 1000 */
         {USB_DEVICE(0x0572, 0x2000)},   /* Cohiba Proto board */
         {USB_DEVICE(0x0572, 0x2002)},   /* Cohiba Proto board */
+        {USB_DEVICE(0x06a9, 0x000e)},   /* Westell 802.11g USB (A90-211WG-01) */
         {USB_DEVICE(0x06b9, 0x0121)},   /* Thomson SpeedTouch 121g */
         {USB_DEVICE(0x0707, 0xee13)},   /* SMC 2862W-G version 2 */
         {USB_DEVICE(0x083a, 0x4521)},   /* Siemens Gigaset USB Adapter 54 version 2 */
+        {USB_DEVICE(0x083a, 0xc501)},   /* Zoom Wireless-G 4410 */
         {USB_DEVICE(0x083a, 0xf503)},   /* Accton FD7050E ver 1010ec  */
         {USB_DEVICE(0x0846, 0x4240)},   /* Netgear WG111 (v2) */
         {USB_DEVICE(0x0915, 0x2000)},   /* Cohiba Proto board */
@@ -80,7 +100,10 @@ static struct usb_device_id p54u_table[] __devinitdata = {
         {USB_DEVICE(0x13B1, 0x000C)},   /* Linksys WUSB54AG */
         {USB_DEVICE(0x1413, 0x5400)},   /* Telsey 802.11g USB2.0 Adapter */
         {USB_DEVICE(0x1435, 0x0427)},   /* Inventel UR054G */
+        {USB_DEVICE(0x1668, 0x1050)},   /* Actiontec 802UIG-1 */
+        {USB_DEVICE(0x1740, 0x1000)},   /* Senao NUB-350 */
         {USB_DEVICE(0x2001, 0x3704)},   /* DLink DWL-G122 rev A2 */
+        {USB_DEVICE(0x2001, 0x3705)},   /* D-Link DWL-G120 rev C1 */
         {USB_DEVICE(0x413c, 0x5513)},   /* Dell WLA3310 USB Wireless Adapter */
         {USB_DEVICE(0x413c, 0x8102)},   /* Spinnaker DUT */
         {USB_DEVICE(0x413c, 0x8104)},   /* Cohiba Proto board */
@@ -170,7 +193,7 @@ static void p54u_rx_cb(struct urb *urb)
 static void p54u_tx_cb(struct urb *urb)
 {
         struct sk_buff *skb = urb->context;
-        struct ieee80211_hw *dev = (struct ieee80211_hw *)
+        struct ieee80211_hw *dev =
                 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
 
         p54_free_skb(dev, skb);
@@ -930,8 +953,8 @@ static int __devinit p54u_probe(struct usb_interface *intf,
 #ifdef CONFIG_PM
                 /* ISL3887 needs a full reset on resume */
                 udev->reset_resume = 1;
+#endif /* CONFIG_PM */
                 err = p54u_device_reset(dev);
-#endif
 
                 priv->hw_type = P54U_3887;
                 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
diff --git a/drivers/net/wireless/p54/txrx.c b/drivers/net/wireless/p54/txrx.c
index 0e937dc0c9c4..042842e704de 100644
--- a/drivers/net/wireless/p54/txrx.c
+++ b/drivers/net/wireless/p54/txrx.c
@@ -273,17 +273,15 @@ void p54_tx(struct p54_common *priv, struct sk_buff *skb)
 
 static int p54_rssi_to_dbm(struct p54_common *priv, int rssi)
 {
-        int band = priv->hw->conf.channel->band;
-
-        if (priv->rxhw != 5)
-                return ((rssi * priv->rssical_db[band].mul) / 64 +
-                         priv->rssical_db[band].add) / 4;
-        else
+        if (priv->rxhw != 5) {
+                return ((rssi * priv->cur_rssi->mul) / 64 +
+                         priv->cur_rssi->add) / 4;
+        } else {
                 /*
                  * TODO: find the correct formula
                  */
-                return ((rssi * priv->rssical_db[band].mul) / 64 +
-                         priv->rssical_db[band].add) / 4;
+                return rssi / 2 - 110;
+        }
 }
 
 /*
@@ -369,7 +367,7 @@ static int p54_rx_data(struct p54_common *priv, struct sk_buff *skb)
         rx_status->mactime = ((u64)priv->tsf_high32) << 32 | tsf32;
         priv->tsf_low32 = tsf32;
 
-        rx_status->flag |= RX_FLAG_TSFT;
+        rx_status->flag |= RX_FLAG_MACTIME_MPDU;
 
         if (hdr->flags & cpu_to_le16(P54_HDR_FLAG_DATA_ALIGN))
                 header_len += hdr->align[0];
@@ -618,7 +616,7 @@ static void p54_tx_80211_header(struct p54_common *priv, struct sk_buff *skb,
         else
                 *burst_possible = false;
 
-        if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ)
+        if (!(info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ))
                 *flags |= P54_HDR_FLAG_DATA_OUT_SEQNR;
 
         if (info->flags & IEEE80211_TX_CTL_PSPOLL_RESPONSE)
@@ -683,28 +681,29 @@ static void p54_tx_80211_header(struct p54_common *priv, struct sk_buff *skb,
         }
 }
 
-static u8 p54_convert_algo(enum ieee80211_key_alg alg)
+static u8 p54_convert_algo(u32 cipher)
 {
-        switch (alg) {
-        case ALG_WEP:
+        switch (cipher) {
+        case WLAN_CIPHER_SUITE_WEP40:
+        case WLAN_CIPHER_SUITE_WEP104:
                 return P54_CRYPTO_WEP;
-        case ALG_TKIP:
+        case WLAN_CIPHER_SUITE_TKIP:
                 return P54_CRYPTO_TKIPMICHAEL;
-        case ALG_CCMP:
+        case WLAN_CIPHER_SUITE_CCMP:
                 return P54_CRYPTO_AESCCMP;
         default:
                 return 0;
         }
 }
 
-int p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb)
+void p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb)
 {
         struct p54_common *priv = dev->priv;
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct p54_tx_info *p54info;
         struct p54_hdr *hdr;
         struct p54_tx_data *txhdr;
-        unsigned int padding, len, extra_len;
+        unsigned int padding, len, extra_len = 0;
         int i, j, ridx;
         u16 hdr_flags = 0, aid = 0;
         u8 rate, queue = 0, crypt_offset = 0;
@@ -718,12 +717,8 @@ int p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb)
                             &hdr_flags, &aid, &burst_allowed);
 
         if (p54_tx_qos_accounting_alloc(priv, skb, queue)) {
-                if (!IS_QOS_QUEUE(queue)) {
-                        dev_kfree_skb_any(skb);
-                        return NETDEV_TX_OK;
-                } else {
-                        return NETDEV_TX_BUSY;
-                }
+                dev_kfree_skb_any(skb);
+                return;
         }
 
         padding = (unsigned long)(skb->data - (sizeof(*hdr) + sizeof(*txhdr))) & 3;
@@ -731,7 +726,7 @@ int p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb)
 
         if (info->control.hw_key) {
                 crypt_offset = ieee80211_get_hdrlen_from_skb(skb);
-                if (info->control.hw_key->alg == ALG_TKIP) {
+                if (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) {
                         u8 *iv = (u8 *)(skb->data + crypt_offset);
                         /*
                          * The firmware excepts that the IV has to have
@@ -827,10 +822,10 @@ int p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb)
         hdr->tries = ridx;
         txhdr->rts_rate_idx = 0;
         if (info->control.hw_key) {
-                txhdr->key_type = p54_convert_algo(info->control.hw_key->alg);
+                txhdr->key_type = p54_convert_algo(info->control.hw_key->cipher);
                 txhdr->key_len = min((u8)16, info->control.hw_key->keylen);
                 memcpy(txhdr->key, info->control.hw_key->key, txhdr->key_len);
-                if (info->control.hw_key->alg == ALG_TKIP) {
+                if (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP) {
                         /* reserve space for the MIC key */
                         len += 8;
                         memcpy(skb_put(skb, 8), &(info->control.hw_key->key
@@ -866,5 +861,4 @@ int p54_tx_80211(struct ieee80211_hw *dev, struct sk_buff *skb)
         p54info->extra_len = extra_len;
 
         p54_tx(priv, skb);
-        return NETDEV_TX_OK;
 }