Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next-2.6

16 files changed, 224 insertions, 232 deletions

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");
                 }