iwlegacy: move under intel directory
authorKalle Valo <kvalo@codeaurora.org>
Tue, 17 Nov 2015 18:37:11 +0000 (20:37 +0200)
committerKalle Valo <kvalo@codeaurora.org>
Wed, 18 Nov 2015 12:28:30 +0000 (14:28 +0200)
Part of reorganising wireless drivers directory and Kconfig.

Signed-off-by: Kalle Valo <kvalo@codeaurora.org>
45 files changed:
MAINTAINERS
drivers/net/wireless/Kconfig
drivers/net/wireless/Makefile
drivers/net/wireless/intel/Kconfig
drivers/net/wireless/intel/Makefile
drivers/net/wireless/intel/iwlegacy/3945-debug.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/3945-mac.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/3945-rs.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/3945.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/3945.h [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/4965-calib.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/4965-debug.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/4965-mac.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/4965-rs.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/4965.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/4965.h [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/Kconfig [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/Makefile [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/commands.h [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/common.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/common.h [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/csr.h [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/debug.c [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/iwl-spectrum.h [new file with mode: 0644]
drivers/net/wireless/intel/iwlegacy/prph.h [new file with mode: 0644]
drivers/net/wireless/iwlegacy/3945-debug.c [deleted file]
drivers/net/wireless/iwlegacy/3945-mac.c [deleted file]
drivers/net/wireless/iwlegacy/3945-rs.c [deleted file]
drivers/net/wireless/iwlegacy/3945.c [deleted file]
drivers/net/wireless/iwlegacy/3945.h [deleted file]
drivers/net/wireless/iwlegacy/4965-calib.c [deleted file]
drivers/net/wireless/iwlegacy/4965-debug.c [deleted file]
drivers/net/wireless/iwlegacy/4965-mac.c [deleted file]
drivers/net/wireless/iwlegacy/4965-rs.c [deleted file]
drivers/net/wireless/iwlegacy/4965.c [deleted file]
drivers/net/wireless/iwlegacy/4965.h [deleted file]
drivers/net/wireless/iwlegacy/Kconfig [deleted file]
drivers/net/wireless/iwlegacy/Makefile [deleted file]
drivers/net/wireless/iwlegacy/commands.h [deleted file]
drivers/net/wireless/iwlegacy/common.c [deleted file]
drivers/net/wireless/iwlegacy/common.h [deleted file]
drivers/net/wireless/iwlegacy/csr.h [deleted file]
drivers/net/wireless/iwlegacy/debug.c [deleted file]
drivers/net/wireless/iwlegacy/iwl-spectrum.h [deleted file]
drivers/net/wireless/iwlegacy/prph.h [deleted file]

index b341dabeb57916bb7ad12a6f4adf9377cb36fa6c..83f9c2ba696280e1647e2517bc2303c42e3e99a0 100644 (file)
@@ -5641,7 +5641,7 @@ INTEL WIRELESS 3945ABG/BG, 4965AGN (iwlegacy)
 M:     Stanislaw Gruszka <sgruszka@redhat.com>
 L:     linux-wireless@vger.kernel.org
 S:     Supported
-F:     drivers/net/wireless/iwlegacy/
+F:     drivers/net/wireless/intel/iwlegacy/
 
 INTEL WIRELESS WIFI LINK (iwlwifi)
 M:     Johannes Berg <johannes.berg@intel.com>
index 73e3b53caf4520d21263857529e58b23fb4d7bbd..f293831e28780f55228605981a1780dd855bf281 100644 (file)
@@ -163,7 +163,6 @@ config MWL8K
 source "drivers/net/wireless/ath/Kconfig"
 source "drivers/net/wireless/hostap/Kconfig"
 source "drivers/net/wireless/iwlwifi/Kconfig"
-source "drivers/net/wireless/iwlegacy/Kconfig"
 source "drivers/net/wireless/libertas/Kconfig"
 source "drivers/net/wireless/orinoco/Kconfig"
 source "drivers/net/wireless/p54/Kconfig"
index 52946d8dd31d527f4356ff6518ad84f78c22e0cc..135aa8753f69e0095fb32c666db0a8a62a794d11 100644 (file)
@@ -31,7 +31,6 @@ obj-$(CONFIG_LIBERTAS_THINFIRM)       += libertas_tf/
 obj-$(CONFIG_MWL8K)    += mwl8k.o
 
 obj-$(CONFIG_IWLWIFI)  += iwlwifi/
-obj-$(CONFIG_IWLEGACY) += iwlegacy/
 obj-$(CONFIG_RT2X00)   += rt2x00/
 
 obj-$(CONFIG_WL_MEDIATEK)      += mediatek/
index 3f8eacc4209a51a6d259767f011c5e850b0678e1..0a7cd61e528c90b7b25551a52b01fd963b472c0d 100644 (file)
@@ -12,5 +12,6 @@ config WLAN_VENDOR_INTEL
 if WLAN_VENDOR_INTEL
 
 source "drivers/net/wireless/intel/ipw2x00/Kconfig"
+source "drivers/net/wireless/intel/iwlegacy/Kconfig"
 
 endif # WLAN_VENDOR_INTEL
index 8e5dcb2d425eec97935383a0e72b827bbebbd1b3..cec507d3c6bf80c3122becdc5de805ffd3515690 100644 (file)
@@ -1,2 +1,4 @@
 obj-$(CONFIG_IPW2100) += ipw2x00/
 obj-$(CONFIG_IPW2200) += ipw2x00/
+
+obj-$(CONFIG_IWLEGACY) += iwlegacy/
diff --git a/drivers/net/wireless/intel/iwlegacy/3945-debug.c b/drivers/net/wireless/intel/iwlegacy/3945-debug.c
new file mode 100644 (file)
index 0000000..c1b4441
--- /dev/null
@@ -0,0 +1,511 @@
+/******************************************************************************
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *****************************************************************************/
+
+#include "common.h"
+#include "3945.h"
+
+static int
+il3945_stats_flag(struct il_priv *il, char *buf, int bufsz)
+{
+       int p = 0;
+
+       p += scnprintf(buf + p, bufsz - p, "Statistics Flag(0x%X):\n",
+                      le32_to_cpu(il->_3945.stats.flag));
+       if (le32_to_cpu(il->_3945.stats.flag) & UCODE_STATS_CLEAR_MSK)
+               p += scnprintf(buf + p, bufsz - p,
+                              "\tStatistics have been cleared\n");
+       p += scnprintf(buf + p, bufsz - p, "\tOperational Frequency: %s\n",
+                      (le32_to_cpu(il->_3945.stats.flag) &
+                       UCODE_STATS_FREQUENCY_MSK) ? "2.4 GHz" : "5.2 GHz");
+       p += scnprintf(buf + p, bufsz - p, "\tTGj Narrow Band: %s\n",
+                      (le32_to_cpu(il->_3945.stats.flag) &
+                       UCODE_STATS_NARROW_BAND_MSK) ? "enabled" : "disabled");
+       return p;
+}
+
+static ssize_t
+il3945_ucode_rx_stats_read(struct file *file, char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char *buf;
+       int bufsz =
+           sizeof(struct iwl39_stats_rx_phy) * 40 +
+           sizeof(struct iwl39_stats_rx_non_phy) * 40 + 400;
+       ssize_t ret;
+       struct iwl39_stats_rx_phy *ofdm, *accum_ofdm, *delta_ofdm, *max_ofdm;
+       struct iwl39_stats_rx_phy *cck, *accum_cck, *delta_cck, *max_cck;
+       struct iwl39_stats_rx_non_phy *general, *accum_general;
+       struct iwl39_stats_rx_non_phy *delta_general, *max_general;
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       /*
+        * The statistic information display here is based on
+        * the last stats notification from uCode
+        * might not reflect the current uCode activity
+        */
+       ofdm = &il->_3945.stats.rx.ofdm;
+       cck = &il->_3945.stats.rx.cck;
+       general = &il->_3945.stats.rx.general;
+       accum_ofdm = &il->_3945.accum_stats.rx.ofdm;
+       accum_cck = &il->_3945.accum_stats.rx.cck;
+       accum_general = &il->_3945.accum_stats.rx.general;
+       delta_ofdm = &il->_3945.delta_stats.rx.ofdm;
+       delta_cck = &il->_3945.delta_stats.rx.cck;
+       delta_general = &il->_3945.delta_stats.rx.general;
+       max_ofdm = &il->_3945.max_delta.rx.ofdm;
+       max_cck = &il->_3945.max_delta.rx.cck;
+       max_general = &il->_3945.max_delta.rx.general;
+
+       pos += il3945_stats_flag(il, buf, bufsz);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "%-32s     current"
+                     "acumulative       delta         max\n",
+                     "Statistics_Rx - OFDM:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "ina_cnt:",
+                     le32_to_cpu(ofdm->ina_cnt), accum_ofdm->ina_cnt,
+                     delta_ofdm->ina_cnt, max_ofdm->ina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_cnt:",
+                     le32_to_cpu(ofdm->fina_cnt), accum_ofdm->fina_cnt,
+                     delta_ofdm->fina_cnt, max_ofdm->fina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "plcp_err:",
+                     le32_to_cpu(ofdm->plcp_err), accum_ofdm->plcp_err,
+                     delta_ofdm->plcp_err, max_ofdm->plcp_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_err:",
+                     le32_to_cpu(ofdm->crc32_err), accum_ofdm->crc32_err,
+                     delta_ofdm->crc32_err, max_ofdm->crc32_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "overrun_err:",
+                     le32_to_cpu(ofdm->overrun_err), accum_ofdm->overrun_err,
+                     delta_ofdm->overrun_err, max_ofdm->overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "early_overrun_err:",
+                     le32_to_cpu(ofdm->early_overrun_err),
+                     accum_ofdm->early_overrun_err,
+                     delta_ofdm->early_overrun_err,
+                     max_ofdm->early_overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_good:",
+                     le32_to_cpu(ofdm->crc32_good), accum_ofdm->crc32_good,
+                     delta_ofdm->crc32_good, max_ofdm->crc32_good);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "false_alarm_cnt:",
+                     le32_to_cpu(ofdm->false_alarm_cnt),
+                     accum_ofdm->false_alarm_cnt, delta_ofdm->false_alarm_cnt,
+                     max_ofdm->false_alarm_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_sync_err_cnt:",
+                     le32_to_cpu(ofdm->fina_sync_err_cnt),
+                     accum_ofdm->fina_sync_err_cnt,
+                     delta_ofdm->fina_sync_err_cnt,
+                     max_ofdm->fina_sync_err_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "sfd_timeout:",
+                     le32_to_cpu(ofdm->sfd_timeout), accum_ofdm->sfd_timeout,
+                     delta_ofdm->sfd_timeout, max_ofdm->sfd_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_timeout:",
+                     le32_to_cpu(ofdm->fina_timeout), accum_ofdm->fina_timeout,
+                     delta_ofdm->fina_timeout, max_ofdm->fina_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "unresponded_rts:",
+                     le32_to_cpu(ofdm->unresponded_rts),
+                     accum_ofdm->unresponded_rts, delta_ofdm->unresponded_rts,
+                     max_ofdm->unresponded_rts);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n",
+                     "rxe_frame_lmt_ovrun:",
+                     le32_to_cpu(ofdm->rxe_frame_limit_overrun),
+                     accum_ofdm->rxe_frame_limit_overrun,
+                     delta_ofdm->rxe_frame_limit_overrun,
+                     max_ofdm->rxe_frame_limit_overrun);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_ack_cnt:",
+                     le32_to_cpu(ofdm->sent_ack_cnt), accum_ofdm->sent_ack_cnt,
+                     delta_ofdm->sent_ack_cnt, max_ofdm->sent_ack_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_cts_cnt:",
+                     le32_to_cpu(ofdm->sent_cts_cnt), accum_ofdm->sent_cts_cnt,
+                     delta_ofdm->sent_cts_cnt, max_ofdm->sent_cts_cnt);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "%-32s     current"
+                     "acumulative       delta         max\n",
+                     "Statistics_Rx - CCK:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "ina_cnt:",
+                     le32_to_cpu(cck->ina_cnt), accum_cck->ina_cnt,
+                     delta_cck->ina_cnt, max_cck->ina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_cnt:",
+                     le32_to_cpu(cck->fina_cnt), accum_cck->fina_cnt,
+                     delta_cck->fina_cnt, max_cck->fina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "plcp_err:",
+                     le32_to_cpu(cck->plcp_err), accum_cck->plcp_err,
+                     delta_cck->plcp_err, max_cck->plcp_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_err:",
+                     le32_to_cpu(cck->crc32_err), accum_cck->crc32_err,
+                     delta_cck->crc32_err, max_cck->crc32_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "overrun_err:",
+                     le32_to_cpu(cck->overrun_err), accum_cck->overrun_err,
+                     delta_cck->overrun_err, max_cck->overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "early_overrun_err:",
+                     le32_to_cpu(cck->early_overrun_err),
+                     accum_cck->early_overrun_err,
+                     delta_cck->early_overrun_err, max_cck->early_overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_good:",
+                     le32_to_cpu(cck->crc32_good), accum_cck->crc32_good,
+                     delta_cck->crc32_good, max_cck->crc32_good);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "false_alarm_cnt:",
+                     le32_to_cpu(cck->false_alarm_cnt),
+                     accum_cck->false_alarm_cnt, delta_cck->false_alarm_cnt,
+                     max_cck->false_alarm_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_sync_err_cnt:",
+                     le32_to_cpu(cck->fina_sync_err_cnt),
+                     accum_cck->fina_sync_err_cnt,
+                     delta_cck->fina_sync_err_cnt, max_cck->fina_sync_err_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "sfd_timeout:",
+                     le32_to_cpu(cck->sfd_timeout), accum_cck->sfd_timeout,
+                     delta_cck->sfd_timeout, max_cck->sfd_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_timeout:",
+                     le32_to_cpu(cck->fina_timeout), accum_cck->fina_timeout,
+                     delta_cck->fina_timeout, max_cck->fina_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "unresponded_rts:",
+                     le32_to_cpu(cck->unresponded_rts),
+                     accum_cck->unresponded_rts, delta_cck->unresponded_rts,
+                     max_cck->unresponded_rts);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n",
+                     "rxe_frame_lmt_ovrun:",
+                     le32_to_cpu(cck->rxe_frame_limit_overrun),
+                     accum_cck->rxe_frame_limit_overrun,
+                     delta_cck->rxe_frame_limit_overrun,
+                     max_cck->rxe_frame_limit_overrun);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_ack_cnt:",
+                     le32_to_cpu(cck->sent_ack_cnt), accum_cck->sent_ack_cnt,
+                     delta_cck->sent_ack_cnt, max_cck->sent_ack_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_cts_cnt:",
+                     le32_to_cpu(cck->sent_cts_cnt), accum_cck->sent_cts_cnt,
+                     delta_cck->sent_cts_cnt, max_cck->sent_cts_cnt);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "%-32s     current"
+                     "acumulative       delta         max\n",
+                     "Statistics_Rx - GENERAL:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "bogus_cts:",
+                     le32_to_cpu(general->bogus_cts), accum_general->bogus_cts,
+                     delta_general->bogus_cts, max_general->bogus_cts);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "bogus_ack:",
+                     le32_to_cpu(general->bogus_ack), accum_general->bogus_ack,
+                     delta_general->bogus_ack, max_general->bogus_ack);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "non_bssid_frames:",
+                     le32_to_cpu(general->non_bssid_frames),
+                     accum_general->non_bssid_frames,
+                     delta_general->non_bssid_frames,
+                     max_general->non_bssid_frames);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "filtered_frames:",
+                     le32_to_cpu(general->filtered_frames),
+                     accum_general->filtered_frames,
+                     delta_general->filtered_frames,
+                     max_general->filtered_frames);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n",
+                     "non_channel_beacons:",
+                     le32_to_cpu(general->non_channel_beacons),
+                     accum_general->non_channel_beacons,
+                     delta_general->non_channel_beacons,
+                     max_general->non_channel_beacons);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il3945_ucode_tx_stats_read(struct file *file, char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char *buf;
+       int bufsz = (sizeof(struct iwl39_stats_tx) * 48) + 250;
+       ssize_t ret;
+       struct iwl39_stats_tx *tx, *accum_tx, *delta_tx, *max_tx;
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       /*
+        * The statistic information display here is based on
+        * the last stats notification from uCode
+        * might not reflect the current uCode activity
+        */
+       tx = &il->_3945.stats.tx;
+       accum_tx = &il->_3945.accum_stats.tx;
+       delta_tx = &il->_3945.delta_stats.tx;
+       max_tx = &il->_3945.max_delta.tx;
+       pos += il3945_stats_flag(il, buf, bufsz);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "%-32s     current"
+                     "acumulative       delta         max\n",
+                     "Statistics_Tx:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "preamble:",
+                     le32_to_cpu(tx->preamble_cnt), accum_tx->preamble_cnt,
+                     delta_tx->preamble_cnt, max_tx->preamble_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "rx_detected_cnt:",
+                     le32_to_cpu(tx->rx_detected_cnt),
+                     accum_tx->rx_detected_cnt, delta_tx->rx_detected_cnt,
+                     max_tx->rx_detected_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "bt_prio_defer_cnt:",
+                     le32_to_cpu(tx->bt_prio_defer_cnt),
+                     accum_tx->bt_prio_defer_cnt, delta_tx->bt_prio_defer_cnt,
+                     max_tx->bt_prio_defer_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "bt_prio_kill_cnt:",
+                     le32_to_cpu(tx->bt_prio_kill_cnt),
+                     accum_tx->bt_prio_kill_cnt, delta_tx->bt_prio_kill_cnt,
+                     max_tx->bt_prio_kill_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "few_bytes_cnt:",
+                     le32_to_cpu(tx->few_bytes_cnt), accum_tx->few_bytes_cnt,
+                     delta_tx->few_bytes_cnt, max_tx->few_bytes_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "cts_timeout:",
+                     le32_to_cpu(tx->cts_timeout), accum_tx->cts_timeout,
+                     delta_tx->cts_timeout, max_tx->cts_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "ack_timeout:",
+                     le32_to_cpu(tx->ack_timeout), accum_tx->ack_timeout,
+                     delta_tx->ack_timeout, max_tx->ack_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "expected_ack_cnt:",
+                     le32_to_cpu(tx->expected_ack_cnt),
+                     accum_tx->expected_ack_cnt, delta_tx->expected_ack_cnt,
+                     max_tx->expected_ack_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "actual_ack_cnt:",
+                     le32_to_cpu(tx->actual_ack_cnt), accum_tx->actual_ack_cnt,
+                     delta_tx->actual_ack_cnt, max_tx->actual_ack_cnt);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il3945_ucode_general_stats_read(struct file *file, char __user *user_buf,
+                               size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char *buf;
+       int bufsz = sizeof(struct iwl39_stats_general) * 10 + 300;
+       ssize_t ret;
+       struct iwl39_stats_general *general, *accum_general;
+       struct iwl39_stats_general *delta_general, *max_general;
+       struct stats_dbg *dbg, *accum_dbg, *delta_dbg, *max_dbg;
+       struct iwl39_stats_div *div, *accum_div, *delta_div, *max_div;
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       /*
+        * The statistic information display here is based on
+        * the last stats notification from uCode
+        * might not reflect the current uCode activity
+        */
+       general = &il->_3945.stats.general;
+       dbg = &il->_3945.stats.general.dbg;
+       div = &il->_3945.stats.general.div;
+       accum_general = &il->_3945.accum_stats.general;
+       delta_general = &il->_3945.delta_stats.general;
+       max_general = &il->_3945.max_delta.general;
+       accum_dbg = &il->_3945.accum_stats.general.dbg;
+       delta_dbg = &il->_3945.delta_stats.general.dbg;
+       max_dbg = &il->_3945.max_delta.general.dbg;
+       accum_div = &il->_3945.accum_stats.general.div;
+       delta_div = &il->_3945.delta_stats.general.div;
+       max_div = &il->_3945.max_delta.general.div;
+       pos += il3945_stats_flag(il, buf, bufsz);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "%-32s     current"
+                     "acumulative       delta         max\n",
+                     "Statistics_General:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "burst_check:",
+                     le32_to_cpu(dbg->burst_check), accum_dbg->burst_check,
+                     delta_dbg->burst_check, max_dbg->burst_check);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "burst_count:",
+                     le32_to_cpu(dbg->burst_count), accum_dbg->burst_count,
+                     delta_dbg->burst_count, max_dbg->burst_count);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "sleep_time:",
+                     le32_to_cpu(general->sleep_time),
+                     accum_general->sleep_time, delta_general->sleep_time,
+                     max_general->sleep_time);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "slots_out:",
+                     le32_to_cpu(general->slots_out), accum_general->slots_out,
+                     delta_general->slots_out, max_general->slots_out);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "slots_idle:",
+                     le32_to_cpu(general->slots_idle),
+                     accum_general->slots_idle, delta_general->slots_idle,
+                     max_general->slots_idle);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "ttl_timestamp:\t\t\t%u\n",
+                     le32_to_cpu(general->ttl_timestamp));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "tx_on_a:",
+                     le32_to_cpu(div->tx_on_a), accum_div->tx_on_a,
+                     delta_div->tx_on_a, max_div->tx_on_a);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "tx_on_b:",
+                     le32_to_cpu(div->tx_on_b), accum_div->tx_on_b,
+                     delta_div->tx_on_b, max_div->tx_on_b);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "exec_time:",
+                     le32_to_cpu(div->exec_time), accum_div->exec_time,
+                     delta_div->exec_time, max_div->exec_time);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "  %-30s %10u  %10u  %10u  %10u\n", "probe_time:",
+                     le32_to_cpu(div->probe_time), accum_div->probe_time,
+                     delta_div->probe_time, max_div->probe_time);
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+const struct il_debugfs_ops il3945_debugfs_ops = {
+       .rx_stats_read = il3945_ucode_rx_stats_read,
+       .tx_stats_read = il3945_ucode_tx_stats_read,
+       .general_stats_read = il3945_ucode_general_stats_read,
+};
diff --git a/drivers/net/wireless/intel/iwlegacy/3945-mac.c b/drivers/net/wireless/intel/iwlegacy/3945-mac.c
new file mode 100644 (file)
index 0000000..af1b3e6
--- /dev/null
@@ -0,0 +1,3959 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
+ *
+ * Portions of this file are derived from the ipw3945 project, as well
+ * as portions of the ieee80211 subsystem header files.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/pci-aspm.h>
+#include <linux/slab.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+#include <linux/firmware.h>
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+
+#include <net/ieee80211_radiotap.h>
+#include <net/mac80211.h>
+
+#include <asm/div64.h>
+
+#define DRV_NAME       "iwl3945"
+
+#include "commands.h"
+#include "common.h"
+#include "3945.h"
+#include "iwl-spectrum.h"
+
+/*
+ * module name, copyright, version, etc.
+ */
+
+#define DRV_DESCRIPTION        \
+"Intel(R) PRO/Wireless 3945ABG/BG Network Connection driver for Linux"
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+#define VD "d"
+#else
+#define VD
+#endif
+
+/*
+ * add "s" to indicate spectrum measurement included.
+ * we add it here to be consistent with previous releases in which
+ * this was configurable.
+ */
+#define DRV_VERSION  IWLWIFI_VERSION VD "s"
+#define DRV_COPYRIGHT  "Copyright(c) 2003-2011 Intel Corporation"
+#define DRV_AUTHOR     "<ilw@linux.intel.com>"
+
+MODULE_DESCRIPTION(DRV_DESCRIPTION);
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
+MODULE_LICENSE("GPL");
+
+ /* module parameters */
+struct il_mod_params il3945_mod_params = {
+       .sw_crypto = 1,
+       .restart_fw = 1,
+       .disable_hw_scan = 1,
+       /* the rest are 0 by default */
+};
+
+/**
+ * il3945_get_antenna_flags - Get antenna flags for RXON command
+ * @il: eeprom and antenna fields are used to determine antenna flags
+ *
+ * il->eeprom39  is used to determine if antenna AUX/MAIN are reversed
+ * il3945_mod_params.antenna specifies the antenna diversity mode:
+ *
+ * IL_ANTENNA_DIVERSITY - NIC selects best antenna by itself
+ * IL_ANTENNA_MAIN      - Force MAIN antenna
+ * IL_ANTENNA_AUX       - Force AUX antenna
+ */
+__le32
+il3945_get_antenna_flags(const struct il_priv *il)
+{
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+
+       switch (il3945_mod_params.antenna) {
+       case IL_ANTENNA_DIVERSITY:
+               return 0;
+
+       case IL_ANTENNA_MAIN:
+               if (eeprom->antenna_switch_type)
+                       return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
+               return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
+
+       case IL_ANTENNA_AUX:
+               if (eeprom->antenna_switch_type)
+                       return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
+               return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
+       }
+
+       /* bad antenna selector value */
+       IL_ERR("Bad antenna selector value (0x%x)\n",
+              il3945_mod_params.antenna);
+
+       return 0;               /* "diversity" is default if error */
+}
+
+static int
+il3945_set_ccmp_dynamic_key_info(struct il_priv *il,
+                                struct ieee80211_key_conf *keyconf, u8 sta_id)
+{
+       unsigned long flags;
+       __le16 key_flags = 0;
+       int ret;
+
+       key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
+       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
+
+       if (sta_id == il->hw_params.bcast_id)
+               key_flags |= STA_KEY_MULTICAST_MSK;
+
+       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
+       keyconf->hw_key_idx = keyconf->keyidx;
+       key_flags &= ~STA_KEY_FLG_INVALID;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
+       il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
+       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
+
+       memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
+
+       if ((il->stations[sta_id].sta.key.
+            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
+               il->stations[sta_id].sta.key.key_offset =
+                   il_get_free_ucode_key_idx(il);
+       /* else, we are overriding an existing key => no need to allocated room
+        * in uCode. */
+
+       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
+            "no space for a new key");
+
+       il->stations[sta_id].sta.key.key_flags = key_flags;
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+
+       D_INFO("hwcrypto: modify ucode station key info\n");
+
+       ret = il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
+
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return ret;
+}
+
+static int
+il3945_set_tkip_dynamic_key_info(struct il_priv *il,
+                                struct ieee80211_key_conf *keyconf, u8 sta_id)
+{
+       return -EOPNOTSUPP;
+}
+
+static int
+il3945_set_wep_dynamic_key_info(struct il_priv *il,
+                               struct ieee80211_key_conf *keyconf, u8 sta_id)
+{
+       return -EOPNOTSUPP;
+}
+
+static int
+il3945_clear_sta_key_info(struct il_priv *il, u8 sta_id)
+{
+       unsigned long flags;
+       struct il_addsta_cmd sta_cmd;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       memset(&il->stations[sta_id].keyinfo, 0, sizeof(struct il_hw_key));
+       memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
+       il->stations[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       D_INFO("hwcrypto: clear ucode station key info\n");
+       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+}
+
+static int
+il3945_set_dynamic_key(struct il_priv *il, struct ieee80211_key_conf *keyconf,
+                      u8 sta_id)
+{
+       int ret = 0;
+
+       keyconf->hw_key_idx = HW_KEY_DYNAMIC;
+
+       switch (keyconf->cipher) {
+       case WLAN_CIPHER_SUITE_CCMP:
+               ret = il3945_set_ccmp_dynamic_key_info(il, keyconf, sta_id);
+               break;
+       case WLAN_CIPHER_SUITE_TKIP:
+               ret = il3945_set_tkip_dynamic_key_info(il, keyconf, sta_id);
+               break;
+       case WLAN_CIPHER_SUITE_WEP40:
+       case WLAN_CIPHER_SUITE_WEP104:
+               ret = il3945_set_wep_dynamic_key_info(il, keyconf, sta_id);
+               break;
+       default:
+               IL_ERR("Unknown alg: %s alg=%x\n", __func__, keyconf->cipher);
+               ret = -EINVAL;
+       }
+
+       D_WEP("Set dynamic key: alg=%x len=%d idx=%d sta=%d ret=%d\n",
+             keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
+
+       return ret;
+}
+
+static int
+il3945_remove_static_key(struct il_priv *il)
+{
+       int ret = -EOPNOTSUPP;
+
+       return ret;
+}
+
+static int
+il3945_set_static_key(struct il_priv *il, struct ieee80211_key_conf *key)
+{
+       if (key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
+           key->cipher == WLAN_CIPHER_SUITE_WEP104)
+               return -EOPNOTSUPP;
+
+       IL_ERR("Static key invalid: cipher %x\n", key->cipher);
+       return -EINVAL;
+}
+
+static void
+il3945_clear_free_frames(struct il_priv *il)
+{
+       struct list_head *element;
+
+       D_INFO("%d frames on pre-allocated heap on clear.\n", il->frames_count);
+
+       while (!list_empty(&il->free_frames)) {
+               element = il->free_frames.next;
+               list_del(element);
+               kfree(list_entry(element, struct il3945_frame, list));
+               il->frames_count--;
+       }
+
+       if (il->frames_count) {
+               IL_WARN("%d frames still in use.  Did we lose one?\n",
+                       il->frames_count);
+               il->frames_count = 0;
+       }
+}
+
+static struct il3945_frame *
+il3945_get_free_frame(struct il_priv *il)
+{
+       struct il3945_frame *frame;
+       struct list_head *element;
+       if (list_empty(&il->free_frames)) {
+               frame = kzalloc(sizeof(*frame), GFP_KERNEL);
+               if (!frame) {
+                       IL_ERR("Could not allocate frame!\n");
+                       return NULL;
+               }
+
+               il->frames_count++;
+               return frame;
+       }
+
+       element = il->free_frames.next;
+       list_del(element);
+       return list_entry(element, struct il3945_frame, list);
+}
+
+static void
+il3945_free_frame(struct il_priv *il, struct il3945_frame *frame)
+{
+       memset(frame, 0, sizeof(*frame));
+       list_add(&frame->list, &il->free_frames);
+}
+
+unsigned int
+il3945_fill_beacon_frame(struct il_priv *il, struct ieee80211_hdr *hdr,
+                        int left)
+{
+
+       if (!il_is_associated(il) || !il->beacon_skb)
+               return 0;
+
+       if (il->beacon_skb->len > left)
+               return 0;
+
+       memcpy(hdr, il->beacon_skb->data, il->beacon_skb->len);
+
+       return il->beacon_skb->len;
+}
+
+static int
+il3945_send_beacon_cmd(struct il_priv *il)
+{
+       struct il3945_frame *frame;
+       unsigned int frame_size;
+       int rc;
+       u8 rate;
+
+       frame = il3945_get_free_frame(il);
+
+       if (!frame) {
+               IL_ERR("Could not obtain free frame buffer for beacon "
+                      "command.\n");
+               return -ENOMEM;
+       }
+
+       rate = il_get_lowest_plcp(il);
+
+       frame_size = il3945_hw_get_beacon_cmd(il, frame, rate);
+
+       rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size, &frame->u.cmd[0]);
+
+       il3945_free_frame(il, frame);
+
+       return rc;
+}
+
+static void
+il3945_unset_hw_params(struct il_priv *il)
+{
+       if (il->_3945.shared_virt)
+               dma_free_coherent(&il->pci_dev->dev,
+                                 sizeof(struct il3945_shared),
+                                 il->_3945.shared_virt, il->_3945.shared_phys);
+}
+
+static void
+il3945_build_tx_cmd_hwcrypto(struct il_priv *il, struct ieee80211_tx_info *info,
+                            struct il_device_cmd *cmd,
+                            struct sk_buff *skb_frag, int sta_id)
+{
+       struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
+       struct il_hw_key *keyinfo = &il->stations[sta_id].keyinfo;
+
+       tx_cmd->sec_ctl = 0;
+
+       switch (keyinfo->cipher) {
+       case WLAN_CIPHER_SUITE_CCMP:
+               tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
+               memcpy(tx_cmd->key, keyinfo->key, keyinfo->keylen);
+               D_TX("tx_cmd with AES hwcrypto\n");
+               break;
+
+       case WLAN_CIPHER_SUITE_TKIP:
+               break;
+
+       case WLAN_CIPHER_SUITE_WEP104:
+               tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
+               /* fall through */
+       case WLAN_CIPHER_SUITE_WEP40:
+               tx_cmd->sec_ctl |=
+                   TX_CMD_SEC_WEP | (info->control.hw_key->
+                                     hw_key_idx & TX_CMD_SEC_MSK) <<
+                   TX_CMD_SEC_SHIFT;
+
+               memcpy(&tx_cmd->key[3], keyinfo->key, keyinfo->keylen);
+
+               D_TX("Configuring packet for WEP encryption " "with key %d\n",
+                    info->control.hw_key->hw_key_idx);
+               break;
+
+       default:
+               IL_ERR("Unknown encode cipher %x\n", keyinfo->cipher);
+               break;
+       }
+}
+
+/*
+ * handle build C_TX command notification.
+ */
+static void
+il3945_build_tx_cmd_basic(struct il_priv *il, struct il_device_cmd *cmd,
+                         struct ieee80211_tx_info *info,
+                         struct ieee80211_hdr *hdr, u8 std_id)
+{
+       struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
+       __le32 tx_flags = tx_cmd->tx_flags;
+       __le16 fc = hdr->frame_control;
+
+       tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
+       if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+               tx_flags |= TX_CMD_FLG_ACK_MSK;
+               if (ieee80211_is_mgmt(fc))
+                       tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
+               if (ieee80211_is_probe_resp(fc) &&
+                   !(le16_to_cpu(hdr->seq_ctrl) & 0xf))
+                       tx_flags |= TX_CMD_FLG_TSF_MSK;
+       } else {
+               tx_flags &= (~TX_CMD_FLG_ACK_MSK);
+               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
+       }
+
+       tx_cmd->sta_id = std_id;
+       if (ieee80211_has_morefrags(fc))
+               tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;
+
+       if (ieee80211_is_data_qos(fc)) {
+               u8 *qc = ieee80211_get_qos_ctl(hdr);
+               tx_cmd->tid_tspec = qc[0] & 0xf;
+               tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
+       } else {
+               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
+       }
+
+       il_tx_cmd_protection(il, info, fc, &tx_flags);
+
+       tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
+       if (ieee80211_is_mgmt(fc)) {
+               if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
+                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
+               else
+                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
+       } else {
+               tx_cmd->timeout.pm_frame_timeout = 0;
+       }
+
+       tx_cmd->driver_txop = 0;
+       tx_cmd->tx_flags = tx_flags;
+       tx_cmd->next_frame_len = 0;
+}
+
+/*
+ * start C_TX command process
+ */
+static int
+il3945_tx_skb(struct il_priv *il,
+             struct ieee80211_sta *sta,
+             struct sk_buff *skb)
+{
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+       struct il3945_tx_cmd *tx_cmd;
+       struct il_tx_queue *txq = NULL;
+       struct il_queue *q = NULL;
+       struct il_device_cmd *out_cmd;
+       struct il_cmd_meta *out_meta;
+       dma_addr_t phys_addr;
+       dma_addr_t txcmd_phys;
+       int txq_id = skb_get_queue_mapping(skb);
+       u16 len, idx, hdr_len;
+       u16 firstlen, secondlen;
+       u8 id;
+       u8 unicast;
+       u8 sta_id;
+       u8 tid = 0;
+       __le16 fc;
+       u8 wait_write_ptr = 0;
+       unsigned long flags;
+
+       spin_lock_irqsave(&il->lock, flags);
+       if (il_is_rfkill(il)) {
+               D_DROP("Dropping - RF KILL\n");
+               goto drop_unlock;
+       }
+
+       if ((ieee80211_get_tx_rate(il->hw, info)->hw_value & 0xFF) ==
+           IL_INVALID_RATE) {
+               IL_ERR("ERROR: No TX rate available.\n");
+               goto drop_unlock;
+       }
+
+       unicast = !is_multicast_ether_addr(hdr->addr1);
+       id = 0;
+
+       fc = hdr->frame_control;
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (ieee80211_is_auth(fc))
+               D_TX("Sending AUTH frame\n");
+       else if (ieee80211_is_assoc_req(fc))
+               D_TX("Sending ASSOC frame\n");
+       else if (ieee80211_is_reassoc_req(fc))
+               D_TX("Sending REASSOC frame\n");
+#endif
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       hdr_len = ieee80211_hdrlen(fc);
+
+       /* Find idx into station table for destination station */
+       sta_id = il_sta_id_or_broadcast(il, sta);
+       if (sta_id == IL_INVALID_STATION) {
+               D_DROP("Dropping - INVALID STATION: %pM\n", hdr->addr1);
+               goto drop;
+       }
+
+       D_RATE("station Id %d\n", sta_id);
+
+       if (ieee80211_is_data_qos(fc)) {
+               u8 *qc = ieee80211_get_qos_ctl(hdr);
+               tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
+               if (unlikely(tid >= MAX_TID_COUNT))
+                       goto drop;
+       }
+
+       /* Descriptor for chosen Tx queue */
+       txq = &il->txq[txq_id];
+       q = &txq->q;
+
+       if ((il_queue_space(q) < q->high_mark))
+               goto drop;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       idx = il_get_cmd_idx(q, q->write_ptr, 0);
+
+       txq->skbs[q->write_ptr] = skb;
+
+       /* Init first empty entry in queue's array of Tx/cmd buffers */
+       out_cmd = txq->cmd[idx];
+       out_meta = &txq->meta[idx];
+       tx_cmd = (struct il3945_tx_cmd *)out_cmd->cmd.payload;
+       memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
+       memset(tx_cmd, 0, sizeof(*tx_cmd));
+
+       /*
+        * Set up the Tx-command (not MAC!) header.
+        * Store the chosen Tx queue and TFD idx within the sequence field;
+        * after Tx, uCode's Tx response will return this value so driver can
+        * locate the frame within the tx queue and do post-tx processing.
+        */
+       out_cmd->hdr.cmd = C_TX;
+       out_cmd->hdr.sequence =
+           cpu_to_le16((u16)
+                       (QUEUE_TO_SEQ(txq_id) | IDX_TO_SEQ(q->write_ptr)));
+
+       /* Copy MAC header from skb into command buffer */
+       memcpy(tx_cmd->hdr, hdr, hdr_len);
+
+       if (info->control.hw_key)
+               il3945_build_tx_cmd_hwcrypto(il, info, out_cmd, skb, sta_id);
+
+       /* TODO need this for burst mode later on */
+       il3945_build_tx_cmd_basic(il, out_cmd, info, hdr, sta_id);
+
+       il3945_hw_build_tx_cmd_rate(il, out_cmd, info, hdr, sta_id);
+
+       /* Total # bytes to be transmitted */
+       tx_cmd->len = cpu_to_le16((u16) skb->len);
+
+       tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
+       tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
+
+       /*
+        * Use the first empty entry in this queue's command buffer array
+        * to contain the Tx command and MAC header concatenated together
+        * (payload data will be in another buffer).
+        * Size of this varies, due to varying MAC header length.
+        * If end is not dword aligned, we'll have 2 extra bytes at the end
+        * of the MAC header (device reads on dword boundaries).
+        * We'll tell device about this padding later.
+        */
+       len =
+           sizeof(struct il3945_tx_cmd) + sizeof(struct il_cmd_header) +
+           hdr_len;
+       firstlen = (len + 3) & ~3;
+
+       /* Physical address of this Tx command's header (not MAC header!),
+        * within command buffer array. */
+       txcmd_phys =
+           pci_map_single(il->pci_dev, &out_cmd->hdr, firstlen,
+                          PCI_DMA_TODEVICE);
+       if (unlikely(pci_dma_mapping_error(il->pci_dev, txcmd_phys)))
+               goto drop_unlock;
+
+       /* Set up TFD's 2nd entry to point directly to remainder of skb,
+        * if any (802.11 null frames have no payload). */
+       secondlen = skb->len - hdr_len;
+       if (secondlen > 0) {
+               phys_addr =
+                   pci_map_single(il->pci_dev, skb->data + hdr_len, secondlen,
+                                  PCI_DMA_TODEVICE);
+               if (unlikely(pci_dma_mapping_error(il->pci_dev, phys_addr)))
+                       goto drop_unlock;
+       }
+
+       /* Add buffer containing Tx command and MAC(!) header to TFD's
+        * first entry */
+       il->ops->txq_attach_buf_to_tfd(il, txq, txcmd_phys, firstlen, 1, 0);
+       dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
+       dma_unmap_len_set(out_meta, len, firstlen);
+       if (secondlen > 0)
+               il->ops->txq_attach_buf_to_tfd(il, txq, phys_addr, secondlen, 0,
+                                              U32_PAD(secondlen));
+
+       if (!ieee80211_has_morefrags(hdr->frame_control)) {
+               txq->need_update = 1;
+       } else {
+               wait_write_ptr = 1;
+               txq->need_update = 0;
+       }
+
+       il_update_stats(il, true, fc, skb->len);
+
+       D_TX("sequence nr = 0X%x\n", le16_to_cpu(out_cmd->hdr.sequence));
+       D_TX("tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
+       il_print_hex_dump(il, IL_DL_TX, tx_cmd, sizeof(*tx_cmd));
+       il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd->hdr,
+                         ieee80211_hdrlen(fc));
+
+       /* Tell device the write idx *just past* this latest filled TFD */
+       q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
+       il_txq_update_write_ptr(il, txq);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       if (il_queue_space(q) < q->high_mark && il->mac80211_registered) {
+               if (wait_write_ptr) {
+                       spin_lock_irqsave(&il->lock, flags);
+                       txq->need_update = 1;
+                       il_txq_update_write_ptr(il, txq);
+                       spin_unlock_irqrestore(&il->lock, flags);
+               }
+
+               il_stop_queue(il, txq);
+       }
+
+       return 0;
+
+drop_unlock:
+       spin_unlock_irqrestore(&il->lock, flags);
+drop:
+       return -1;
+}
+
+static int
+il3945_get_measurement(struct il_priv *il,
+                      struct ieee80211_measurement_params *params, u8 type)
+{
+       struct il_spectrum_cmd spectrum;
+       struct il_rx_pkt *pkt;
+       struct il_host_cmd cmd = {
+               .id = C_SPECTRUM_MEASUREMENT,
+               .data = (void *)&spectrum,
+               .flags = CMD_WANT_SKB,
+       };
+       u32 add_time = le64_to_cpu(params->start_time);
+       int rc;
+       int spectrum_resp_status;
+       int duration = le16_to_cpu(params->duration);
+
+       if (il_is_associated(il))
+               add_time =
+                   il_usecs_to_beacons(il,
+                                       le64_to_cpu(params->start_time) -
+                                       il->_3945.last_tsf,
+                                       le16_to_cpu(il->timing.beacon_interval));
+
+       memset(&spectrum, 0, sizeof(spectrum));
+
+       spectrum.channel_count = cpu_to_le16(1);
+       spectrum.flags =
+           RXON_FLG_TSF2HOST_MSK | RXON_FLG_ANT_A_MSK | RXON_FLG_DIS_DIV_MSK;
+       spectrum.filter_flags = MEASUREMENT_FILTER_FLAG;
+       cmd.len = sizeof(spectrum);
+       spectrum.len = cpu_to_le16(cmd.len - sizeof(spectrum.len));
+
+       if (il_is_associated(il))
+               spectrum.start_time =
+                   il_add_beacon_time(il, il->_3945.last_beacon_time, add_time,
+                                      le16_to_cpu(il->timing.beacon_interval));
+       else
+               spectrum.start_time = 0;
+
+       spectrum.channels[0].duration = cpu_to_le32(duration * TIME_UNIT);
+       spectrum.channels[0].channel = params->channel;
+       spectrum.channels[0].type = type;
+       if (il->active.flags & RXON_FLG_BAND_24G_MSK)
+               spectrum.flags |=
+                   RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK |
+                   RXON_FLG_TGG_PROTECT_MSK;
+
+       rc = il_send_cmd_sync(il, &cmd);
+       if (rc)
+               return rc;
+
+       pkt = (struct il_rx_pkt *)cmd.reply_page;
+       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
+               IL_ERR("Bad return from N_RX_ON_ASSOC command\n");
+               rc = -EIO;
+       }
+
+       spectrum_resp_status = le16_to_cpu(pkt->u.spectrum.status);
+       switch (spectrum_resp_status) {
+       case 0:         /* Command will be handled */
+               if (pkt->u.spectrum.id != 0xff) {
+                       D_INFO("Replaced existing measurement: %d\n",
+                              pkt->u.spectrum.id);
+                       il->measurement_status &= ~MEASUREMENT_READY;
+               }
+               il->measurement_status |= MEASUREMENT_ACTIVE;
+               rc = 0;
+               break;
+
+       case 1:         /* Command will not be handled */
+               rc = -EAGAIN;
+               break;
+       }
+
+       il_free_pages(il, cmd.reply_page);
+
+       return rc;
+}
+
+static void
+il3945_hdl_alive(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_alive_resp *palive;
+       struct delayed_work *pwork;
+
+       palive = &pkt->u.alive_frame;
+
+       D_INFO("Alive ucode status 0x%08X revision " "0x%01X 0x%01X\n",
+              palive->is_valid, palive->ver_type, palive->ver_subtype);
+
+       if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
+               D_INFO("Initialization Alive received.\n");
+               memcpy(&il->card_alive_init, &pkt->u.alive_frame,
+                      sizeof(struct il_alive_resp));
+               pwork = &il->init_alive_start;
+       } else {
+               D_INFO("Runtime Alive received.\n");
+               memcpy(&il->card_alive, &pkt->u.alive_frame,
+                      sizeof(struct il_alive_resp));
+               pwork = &il->alive_start;
+               il3945_disable_events(il);
+       }
+
+       /* We delay the ALIVE response by 5ms to
+        * give the HW RF Kill time to activate... */
+       if (palive->is_valid == UCODE_VALID_OK)
+               queue_delayed_work(il->workqueue, pwork, msecs_to_jiffies(5));
+       else
+               IL_WARN("uCode did not respond OK.\n");
+}
+
+static void
+il3945_hdl_add_sta(struct il_priv *il, struct il_rx_buf *rxb)
+{
+#ifdef CONFIG_IWLEGACY_DEBUG
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+#endif
+
+       D_RX("Received C_ADD_STA: 0x%02X\n", pkt->u.status);
+}
+
+static void
+il3945_hdl_beacon(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il3945_beacon_notif *beacon = &(pkt->u.beacon_status);
+#ifdef CONFIG_IWLEGACY_DEBUG
+       u8 rate = beacon->beacon_notify_hdr.rate;
+
+       D_RX("beacon status %x retries %d iss %d " "tsf %d %d rate %d\n",
+            le32_to_cpu(beacon->beacon_notify_hdr.status) & TX_STATUS_MSK,
+            beacon->beacon_notify_hdr.failure_frame,
+            le32_to_cpu(beacon->ibss_mgr_status),
+            le32_to_cpu(beacon->high_tsf), le32_to_cpu(beacon->low_tsf), rate);
+#endif
+
+       il->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
+
+}
+
+/* Handle notification from uCode that card's power state is changing
+ * due to software, hardware, or critical temperature RFKILL */
+static void
+il3945_hdl_card_state(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
+       unsigned long status = il->status;
+
+       IL_WARN("Card state received: HW:%s SW:%s\n",
+               (flags & HW_CARD_DISABLED) ? "Kill" : "On",
+               (flags & SW_CARD_DISABLED) ? "Kill" : "On");
+
+       _il_wr(il, CSR_UCODE_DRV_GP1_SET, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+
+       if (flags & HW_CARD_DISABLED)
+               set_bit(S_RFKILL, &il->status);
+       else
+               clear_bit(S_RFKILL, &il->status);
+
+       il_scan_cancel(il);
+
+       if ((test_bit(S_RFKILL, &status) !=
+            test_bit(S_RFKILL, &il->status)))
+               wiphy_rfkill_set_hw_state(il->hw->wiphy,
+                                         test_bit(S_RFKILL, &il->status));
+       else
+               wake_up(&il->wait_command_queue);
+}
+
+/**
+ * il3945_setup_handlers - Initialize Rx handler callbacks
+ *
+ * Setup the RX handlers for each of the reply types sent from the uCode
+ * to the host.
+ *
+ * This function chains into the hardware specific files for them to setup
+ * any hardware specific handlers as well.
+ */
+static void
+il3945_setup_handlers(struct il_priv *il)
+{
+       il->handlers[N_ALIVE] = il3945_hdl_alive;
+       il->handlers[C_ADD_STA] = il3945_hdl_add_sta;
+       il->handlers[N_ERROR] = il_hdl_error;
+       il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;
+       il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;
+       il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;
+       il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;
+       il->handlers[N_BEACON] = il3945_hdl_beacon;
+
+       /*
+        * The same handler is used for both the REPLY to a discrete
+        * stats request from the host as well as for the periodic
+        * stats notifications (after received beacons) from the uCode.
+        */
+       il->handlers[C_STATS] = il3945_hdl_c_stats;
+       il->handlers[N_STATS] = il3945_hdl_stats;
+
+       il_setup_rx_scan_handlers(il);
+       il->handlers[N_CARD_STATE] = il3945_hdl_card_state;
+
+       /* Set up hardware specific Rx handlers */
+       il3945_hw_handler_setup(il);
+}
+
+/************************** RX-FUNCTIONS ****************************/
+/*
+ * Rx theory of operation
+ *
+ * The host allocates 32 DMA target addresses and passes the host address
+ * to the firmware at register IL_RFDS_TBL_LOWER + N * RFD_SIZE where N is
+ * 0 to 31
+ *
+ * Rx Queue Indexes
+ * The host/firmware share two idx registers for managing the Rx buffers.
+ *
+ * The READ idx maps to the first position that the firmware may be writing
+ * to -- the driver can read up to (but not including) this position and get
+ * good data.
+ * The READ idx is managed by the firmware once the card is enabled.
+ *
+ * The WRITE idx maps to the last position the driver has read from -- the
+ * position preceding WRITE is the last slot the firmware can place a packet.
+ *
+ * The queue is empty (no good data) if WRITE = READ - 1, and is full if
+ * WRITE = READ.
+ *
+ * During initialization, the host sets up the READ queue position to the first
+ * IDX position, and WRITE to the last (READ - 1 wrapped)
+ *
+ * When the firmware places a packet in a buffer, it will advance the READ idx
+ * and fire the RX interrupt.  The driver can then query the READ idx and
+ * process as many packets as possible, moving the WRITE idx forward as it
+ * resets the Rx queue buffers with new memory.
+ *
+ * The management in the driver is as follows:
+ * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free.  When
+ *   iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
+ *   to replenish the iwl->rxq->rx_free.
+ * + In il3945_rx_replenish (scheduled) if 'processed' != 'read' then the
+ *   iwl->rxq is replenished and the READ IDX is updated (updating the
+ *   'processed' and 'read' driver idxes as well)
+ * + A received packet is processed and handed to the kernel network stack,
+ *   detached from the iwl->rxq.  The driver 'processed' idx is updated.
+ * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
+ *   list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
+ *   IDX is not incremented and iwl->status(RX_STALLED) is set.  If there
+ *   were enough free buffers and RX_STALLED is set it is cleared.
+ *
+ *
+ * Driver sequence:
+ *
+ * il3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
+ *                            il3945_rx_queue_restock
+ * il3945_rx_queue_restock() Moves available buffers from rx_free into Rx
+ *                            queue, updates firmware pointers, and updates
+ *                            the WRITE idx.  If insufficient rx_free buffers
+ *                            are available, schedules il3945_rx_replenish
+ *
+ * -- enable interrupts --
+ * ISR - il3945_rx()         Detach il_rx_bufs from pool up to the
+ *                            READ IDX, detaching the SKB from the pool.
+ *                            Moves the packet buffer from queue to rx_used.
+ *                            Calls il3945_rx_queue_restock to refill any empty
+ *                            slots.
+ * ...
+ *
+ */
+
+/**
+ * il3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
+ */
+static inline __le32
+il3945_dma_addr2rbd_ptr(struct il_priv *il, dma_addr_t dma_addr)
+{
+       return cpu_to_le32((u32) dma_addr);
+}
+
+/**
+ * il3945_rx_queue_restock - refill RX queue from pre-allocated pool
+ *
+ * If there are slots in the RX queue that need to be restocked,
+ * and we have free pre-allocated buffers, fill the ranks as much
+ * as we can, pulling from rx_free.
+ *
+ * This moves the 'write' idx forward to catch up with 'processed', and
+ * also updates the memory address in the firmware to reference the new
+ * target buffer.
+ */
+static void
+il3945_rx_queue_restock(struct il_priv *il)
+{
+       struct il_rx_queue *rxq = &il->rxq;
+       struct list_head *element;
+       struct il_rx_buf *rxb;
+       unsigned long flags;
+       int write;
+
+       spin_lock_irqsave(&rxq->lock, flags);
+       write = rxq->write & ~0x7;
+       while (il_rx_queue_space(rxq) > 0 && rxq->free_count) {
+               /* Get next free Rx buffer, remove from free list */
+               element = rxq->rx_free.next;
+               rxb = list_entry(element, struct il_rx_buf, list);
+               list_del(element);
+
+               /* Point to Rx buffer via next RBD in circular buffer */
+               rxq->bd[rxq->write] =
+                   il3945_dma_addr2rbd_ptr(il, rxb->page_dma);
+               rxq->queue[rxq->write] = rxb;
+               rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
+               rxq->free_count--;
+       }
+       spin_unlock_irqrestore(&rxq->lock, flags);
+       /* If the pre-allocated buffer pool is dropping low, schedule to
+        * refill it */
+       if (rxq->free_count <= RX_LOW_WATERMARK)
+               queue_work(il->workqueue, &il->rx_replenish);
+
+       /* If we've added more space for the firmware to place data, tell it.
+        * Increment device's write pointer in multiples of 8. */
+       if (rxq->write_actual != (rxq->write & ~0x7) ||
+           abs(rxq->write - rxq->read) > 7) {
+               spin_lock_irqsave(&rxq->lock, flags);
+               rxq->need_update = 1;
+               spin_unlock_irqrestore(&rxq->lock, flags);
+               il_rx_queue_update_write_ptr(il, rxq);
+       }
+}
+
+/**
+ * il3945_rx_replenish - Move all used packet from rx_used to rx_free
+ *
+ * When moving to rx_free an SKB is allocated for the slot.
+ *
+ * Also restock the Rx queue via il3945_rx_queue_restock.
+ * This is called as a scheduled work item (except for during initialization)
+ */
+static void
+il3945_rx_allocate(struct il_priv *il, gfp_t priority)
+{
+       struct il_rx_queue *rxq = &il->rxq;
+       struct list_head *element;
+       struct il_rx_buf *rxb;
+       struct page *page;
+       dma_addr_t page_dma;
+       unsigned long flags;
+       gfp_t gfp_mask = priority;
+
+       while (1) {
+               spin_lock_irqsave(&rxq->lock, flags);
+               if (list_empty(&rxq->rx_used)) {
+                       spin_unlock_irqrestore(&rxq->lock, flags);
+                       return;
+               }
+               spin_unlock_irqrestore(&rxq->lock, flags);
+
+               if (rxq->free_count > RX_LOW_WATERMARK)
+                       gfp_mask |= __GFP_NOWARN;
+
+               if (il->hw_params.rx_page_order > 0)
+                       gfp_mask |= __GFP_COMP;
+
+               /* Alloc a new receive buffer */
+               page = alloc_pages(gfp_mask, il->hw_params.rx_page_order);
+               if (!page) {
+                       if (net_ratelimit())
+                               D_INFO("Failed to allocate SKB buffer.\n");
+                       if (rxq->free_count <= RX_LOW_WATERMARK &&
+                           net_ratelimit())
+                               IL_ERR("Failed to allocate SKB buffer with %0x."
+                                      "Only %u free buffers remaining.\n",
+                                      priority, rxq->free_count);
+                       /* We don't reschedule replenish work here -- we will
+                        * call the restock method and if it still needs
+                        * more buffers it will schedule replenish */
+                       break;
+               }
+
+               /* Get physical address of RB/SKB */
+               page_dma =
+                   pci_map_page(il->pci_dev, page, 0,
+                                PAGE_SIZE << il->hw_params.rx_page_order,
+                                PCI_DMA_FROMDEVICE);
+
+               if (unlikely(pci_dma_mapping_error(il->pci_dev, page_dma))) {
+                       __free_pages(page, il->hw_params.rx_page_order);
+                       break;
+               }
+
+               spin_lock_irqsave(&rxq->lock, flags);
+
+               if (list_empty(&rxq->rx_used)) {
+                       spin_unlock_irqrestore(&rxq->lock, flags);
+                       pci_unmap_page(il->pci_dev, page_dma,
+                                      PAGE_SIZE << il->hw_params.rx_page_order,
+                                      PCI_DMA_FROMDEVICE);
+                       __free_pages(page, il->hw_params.rx_page_order);
+                       return;
+               }
+
+               element = rxq->rx_used.next;
+               rxb = list_entry(element, struct il_rx_buf, list);
+               list_del(element);
+
+               rxb->page = page;
+               rxb->page_dma = page_dma;
+               list_add_tail(&rxb->list, &rxq->rx_free);
+               rxq->free_count++;
+               il->alloc_rxb_page++;
+
+               spin_unlock_irqrestore(&rxq->lock, flags);
+       }
+}
+
+void
+il3945_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
+{
+       unsigned long flags;
+       int i;
+       spin_lock_irqsave(&rxq->lock, flags);
+       INIT_LIST_HEAD(&rxq->rx_free);
+       INIT_LIST_HEAD(&rxq->rx_used);
+       /* Fill the rx_used queue with _all_ of the Rx buffers */
+       for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
+               /* In the reset function, these buffers may have been allocated
+                * to an SKB, so we need to unmap and free potential storage */
+               if (rxq->pool[i].page != NULL) {
+                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
+                                      PAGE_SIZE << il->hw_params.rx_page_order,
+                                      PCI_DMA_FROMDEVICE);
+                       __il_free_pages(il, rxq->pool[i].page);
+                       rxq->pool[i].page = NULL;
+               }
+               list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
+       }
+
+       /* Set us so that we have processed and used all buffers, but have
+        * not restocked the Rx queue with fresh buffers */
+       rxq->read = rxq->write = 0;
+       rxq->write_actual = 0;
+       rxq->free_count = 0;
+       spin_unlock_irqrestore(&rxq->lock, flags);
+}
+
+void
+il3945_rx_replenish(void *data)
+{
+       struct il_priv *il = data;
+       unsigned long flags;
+
+       il3945_rx_allocate(il, GFP_KERNEL);
+
+       spin_lock_irqsave(&il->lock, flags);
+       il3945_rx_queue_restock(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+}
+
+static void
+il3945_rx_replenish_now(struct il_priv *il)
+{
+       il3945_rx_allocate(il, GFP_ATOMIC);
+
+       il3945_rx_queue_restock(il);
+}
+
+/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
+ * If an SKB has been detached, the POOL needs to have its SKB set to NULL
+ * This free routine walks the list of POOL entries and if SKB is set to
+ * non NULL it is unmapped and freed
+ */
+static void
+il3945_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
+{
+       int i;
+       for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
+               if (rxq->pool[i].page != NULL) {
+                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
+                                      PAGE_SIZE << il->hw_params.rx_page_order,
+                                      PCI_DMA_FROMDEVICE);
+                       __il_free_pages(il, rxq->pool[i].page);
+                       rxq->pool[i].page = NULL;
+               }
+       }
+
+       dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
+                         rxq->bd_dma);
+       dma_free_coherent(&il->pci_dev->dev, sizeof(struct il_rb_status),
+                         rxq->rb_stts, rxq->rb_stts_dma);
+       rxq->bd = NULL;
+       rxq->rb_stts = NULL;
+}
+
+/* Convert linear signal-to-noise ratio into dB */
+static u8 ratio2dB[100] = {
+/*      0   1   2   3   4   5   6   7   8   9 */
+       0, 0, 6, 10, 12, 14, 16, 17, 18, 19,    /* 00 - 09 */
+       20, 21, 22, 22, 23, 23, 24, 25, 26, 26, /* 10 - 19 */
+       26, 26, 26, 27, 27, 28, 28, 28, 29, 29, /* 20 - 29 */
+       29, 30, 30, 30, 31, 31, 31, 31, 32, 32, /* 30 - 39 */
+       32, 32, 32, 33, 33, 33, 33, 33, 34, 34, /* 40 - 49 */
+       34, 34, 34, 34, 35, 35, 35, 35, 35, 35, /* 50 - 59 */
+       36, 36, 36, 36, 36, 36, 36, 37, 37, 37, /* 60 - 69 */
+       37, 37, 37, 37, 37, 38, 38, 38, 38, 38, /* 70 - 79 */
+       38, 38, 38, 38, 38, 39, 39, 39, 39, 39, /* 80 - 89 */
+       39, 39, 39, 39, 39, 40, 40, 40, 40, 40  /* 90 - 99 */
+};
+
+/* Calculates a relative dB value from a ratio of linear
+ *   (i.e. not dB) signal levels.
+ * Conversion assumes that levels are voltages (20*log), not powers (10*log). */
+int
+il3945_calc_db_from_ratio(int sig_ratio)
+{
+       /* 1000:1 or higher just report as 60 dB */
+       if (sig_ratio >= 1000)
+               return 60;
+
+       /* 100:1 or higher, divide by 10 and use table,
+        *   add 20 dB to make up for divide by 10 */
+       if (sig_ratio >= 100)
+               return 20 + (int)ratio2dB[sig_ratio / 10];
+
+       /* We shouldn't see this */
+       if (sig_ratio < 1)
+               return 0;
+
+       /* Use table for ratios 1:1 - 99:1 */
+       return (int)ratio2dB[sig_ratio];
+}
+
+/**
+ * il3945_rx_handle - Main entry function for receiving responses from uCode
+ *
+ * Uses the il->handlers callback function array to invoke
+ * the appropriate handlers, including command responses,
+ * frame-received notifications, and other notifications.
+ */
+static void
+il3945_rx_handle(struct il_priv *il)
+{
+       struct il_rx_buf *rxb;
+       struct il_rx_pkt *pkt;
+       struct il_rx_queue *rxq = &il->rxq;
+       u32 r, i;
+       int reclaim;
+       unsigned long flags;
+       u8 fill_rx = 0;
+       u32 count = 8;
+       int total_empty = 0;
+
+       /* uCode's read idx (stored in shared DRAM) indicates the last Rx
+        * buffer that the driver may process (last buffer filled by ucode). */
+       r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
+       i = rxq->read;
+
+       /* calculate total frames need to be restock after handling RX */
+       total_empty = r - rxq->write_actual;
+       if (total_empty < 0)
+               total_empty += RX_QUEUE_SIZE;
+
+       if (total_empty > (RX_QUEUE_SIZE / 2))
+               fill_rx = 1;
+       /* Rx interrupt, but nothing sent from uCode */
+       if (i == r)
+               D_RX("r = %d, i = %d\n", r, i);
+
+       while (i != r) {
+               int len;
+
+               rxb = rxq->queue[i];
+
+               /* If an RXB doesn't have a Rx queue slot associated with it,
+                * then a bug has been introduced in the queue refilling
+                * routines -- catch it here */
+               BUG_ON(rxb == NULL);
+
+               rxq->queue[i] = NULL;
+
+               pci_unmap_page(il->pci_dev, rxb->page_dma,
+                              PAGE_SIZE << il->hw_params.rx_page_order,
+                              PCI_DMA_FROMDEVICE);
+               pkt = rxb_addr(rxb);
+
+               len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
+               len += sizeof(u32);     /* account for status word */
+
+               reclaim = il_need_reclaim(il, pkt);
+
+               /* Based on type of command response or notification,
+                *   handle those that need handling via function in
+                *   handlers table.  See il3945_setup_handlers() */
+               if (il->handlers[pkt->hdr.cmd]) {
+                       D_RX("r = %d, i = %d, %s, 0x%02x\n", r, i,
+                            il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
+                       il->isr_stats.handlers[pkt->hdr.cmd]++;
+                       il->handlers[pkt->hdr.cmd] (il, rxb);
+               } else {
+                       /* No handling needed */
+                       D_RX("r %d i %d No handler needed for %s, 0x%02x\n", r,
+                            i, il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
+               }
+
+               /*
+                * XXX: After here, we should always check rxb->page
+                * against NULL before touching it or its virtual
+                * memory (pkt). Because some handler might have
+                * already taken or freed the pages.
+                */
+
+               if (reclaim) {
+                       /* Invoke any callbacks, transfer the buffer to caller,
+                        * and fire off the (possibly) blocking il_send_cmd()
+                        * as we reclaim the driver command queue */
+                       if (rxb->page)
+                               il_tx_cmd_complete(il, rxb);
+                       else
+                               IL_WARN("Claim null rxb?\n");
+               }
+
+               /* Reuse the page if possible. For notification packets and
+                * SKBs that fail to Rx correctly, add them back into the
+                * rx_free list for reuse later. */
+               spin_lock_irqsave(&rxq->lock, flags);
+               if (rxb->page != NULL) {
+                       rxb->page_dma =
+                           pci_map_page(il->pci_dev, rxb->page, 0,
+                                        PAGE_SIZE << il->hw_params.
+                                        rx_page_order, PCI_DMA_FROMDEVICE);
+                       if (unlikely(pci_dma_mapping_error(il->pci_dev,
+                                                          rxb->page_dma))) {
+                               __il_free_pages(il, rxb->page);
+                               rxb->page = NULL;
+                               list_add_tail(&rxb->list, &rxq->rx_used);
+                       } else {
+                               list_add_tail(&rxb->list, &rxq->rx_free);
+                               rxq->free_count++;
+                       }
+               } else
+                       list_add_tail(&rxb->list, &rxq->rx_used);
+
+               spin_unlock_irqrestore(&rxq->lock, flags);
+
+               i = (i + 1) & RX_QUEUE_MASK;
+               /* If there are a lot of unused frames,
+                * restock the Rx queue so ucode won't assert. */
+               if (fill_rx) {
+                       count++;
+                       if (count >= 8) {
+                               rxq->read = i;
+                               il3945_rx_replenish_now(il);
+                               count = 0;
+                       }
+               }
+       }
+
+       /* Backtrack one entry */
+       rxq->read = i;
+       if (fill_rx)
+               il3945_rx_replenish_now(il);
+       else
+               il3945_rx_queue_restock(il);
+}
+
+/* call this function to flush any scheduled tasklet */
+static inline void
+il3945_synchronize_irq(struct il_priv *il)
+{
+       /* wait to make sure we flush pending tasklet */
+       synchronize_irq(il->pci_dev->irq);
+       tasklet_kill(&il->irq_tasklet);
+}
+
+static const char *
+il3945_desc_lookup(int i)
+{
+       switch (i) {
+       case 1:
+               return "FAIL";
+       case 2:
+               return "BAD_PARAM";
+       case 3:
+               return "BAD_CHECKSUM";
+       case 4:
+               return "NMI_INTERRUPT";
+       case 5:
+               return "SYSASSERT";
+       case 6:
+               return "FATAL_ERROR";
+       }
+
+       return "UNKNOWN";
+}
+
+#define ERROR_START_OFFSET  (1 * sizeof(u32))
+#define ERROR_ELEM_SIZE     (7 * sizeof(u32))
+
+void
+il3945_dump_nic_error_log(struct il_priv *il)
+{
+       u32 i;
+       u32 desc, time, count, base, data1;
+       u32 blink1, blink2, ilink1, ilink2;
+
+       base = le32_to_cpu(il->card_alive.error_event_table_ptr);
+
+       if (!il3945_hw_valid_rtc_data_addr(base)) {
+               IL_ERR("Not valid error log pointer 0x%08X\n", base);
+               return;
+       }
+
+       count = il_read_targ_mem(il, base);
+
+       if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
+               IL_ERR("Start IWL Error Log Dump:\n");
+               IL_ERR("Status: 0x%08lX, count: %d\n", il->status, count);
+       }
+
+       IL_ERR("Desc       Time       asrtPC  blink2 "
+              "ilink1  nmiPC   Line\n");
+       for (i = ERROR_START_OFFSET;
+            i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
+            i += ERROR_ELEM_SIZE) {
+               desc = il_read_targ_mem(il, base + i);
+               time = il_read_targ_mem(il, base + i + 1 * sizeof(u32));
+               blink1 = il_read_targ_mem(il, base + i + 2 * sizeof(u32));
+               blink2 = il_read_targ_mem(il, base + i + 3 * sizeof(u32));
+               ilink1 = il_read_targ_mem(il, base + i + 4 * sizeof(u32));
+               ilink2 = il_read_targ_mem(il, base + i + 5 * sizeof(u32));
+               data1 = il_read_targ_mem(il, base + i + 6 * sizeof(u32));
+
+               IL_ERR("%-13s (0x%X) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
+                      il3945_desc_lookup(desc), desc, time, blink1, blink2,
+                      ilink1, ilink2, data1);
+       }
+}
+
+static void
+il3945_irq_tasklet(struct il_priv *il)
+{
+       u32 inta, handled = 0;
+       u32 inta_fh;
+       unsigned long flags;
+#ifdef CONFIG_IWLEGACY_DEBUG
+       u32 inta_mask;
+#endif
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Ack/clear/reset pending uCode interrupts.
+        * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
+        *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
+       inta = _il_rd(il, CSR_INT);
+       _il_wr(il, CSR_INT, inta);
+
+       /* Ack/clear/reset pending flow-handler (DMA) interrupts.
+        * Any new interrupts that happen after this, either while we're
+        * in this tasklet, or later, will show up in next ISR/tasklet. */
+       inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
+       _il_wr(il, CSR_FH_INT_STATUS, inta_fh);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (il_get_debug_level(il) & IL_DL_ISR) {
+               /* just for debug */
+               inta_mask = _il_rd(il, CSR_INT_MASK);
+               D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta,
+                     inta_mask, inta_fh);
+       }
+#endif
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       /* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
+        * atomic, make sure that inta covers all the interrupts that
+        * we've discovered, even if FH interrupt came in just after
+        * reading CSR_INT. */
+       if (inta_fh & CSR39_FH_INT_RX_MASK)
+               inta |= CSR_INT_BIT_FH_RX;
+       if (inta_fh & CSR39_FH_INT_TX_MASK)
+               inta |= CSR_INT_BIT_FH_TX;
+
+       /* Now service all interrupt bits discovered above. */
+       if (inta & CSR_INT_BIT_HW_ERR) {
+               IL_ERR("Hardware error detected.  Restarting.\n");
+
+               /* Tell the device to stop sending interrupts */
+               il_disable_interrupts(il);
+
+               il->isr_stats.hw++;
+               il_irq_handle_error(il);
+
+               handled |= CSR_INT_BIT_HW_ERR;
+
+               return;
+       }
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (il_get_debug_level(il) & (IL_DL_ISR)) {
+               /* NIC fires this, but we don't use it, redundant with WAKEUP */
+               if (inta & CSR_INT_BIT_SCD) {
+                       D_ISR("Scheduler finished to transmit "
+                             "the frame/frames.\n");
+                       il->isr_stats.sch++;
+               }
+
+               /* Alive notification via Rx interrupt will do the real work */
+               if (inta & CSR_INT_BIT_ALIVE) {
+                       D_ISR("Alive interrupt\n");
+                       il->isr_stats.alive++;
+               }
+       }
+#endif
+       /* Safely ignore these bits for debug checks below */
+       inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
+
+       /* Error detected by uCode */
+       if (inta & CSR_INT_BIT_SW_ERR) {
+               IL_ERR("Microcode SW error detected. " "Restarting 0x%X.\n",
+                      inta);
+               il->isr_stats.sw++;
+               il_irq_handle_error(il);
+               handled |= CSR_INT_BIT_SW_ERR;
+       }
+
+       /* uCode wakes up after power-down sleep */
+       if (inta & CSR_INT_BIT_WAKEUP) {
+               D_ISR("Wakeup interrupt\n");
+               il_rx_queue_update_write_ptr(il, &il->rxq);
+
+               spin_lock_irqsave(&il->lock, flags);
+               il_txq_update_write_ptr(il, &il->txq[0]);
+               il_txq_update_write_ptr(il, &il->txq[1]);
+               il_txq_update_write_ptr(il, &il->txq[2]);
+               il_txq_update_write_ptr(il, &il->txq[3]);
+               il_txq_update_write_ptr(il, &il->txq[4]);
+               spin_unlock_irqrestore(&il->lock, flags);
+
+               il->isr_stats.wakeup++;
+               handled |= CSR_INT_BIT_WAKEUP;
+       }
+
+       /* All uCode command responses, including Tx command responses,
+        * Rx "responses" (frame-received notification), and other
+        * notifications from uCode come through here*/
+       if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
+               il3945_rx_handle(il);
+               il->isr_stats.rx++;
+               handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
+       }
+
+       if (inta & CSR_INT_BIT_FH_TX) {
+               D_ISR("Tx interrupt\n");
+               il->isr_stats.tx++;
+
+               _il_wr(il, CSR_FH_INT_STATUS, (1 << 6));
+               il_wr(il, FH39_TCSR_CREDIT(FH39_SRVC_CHNL), 0x0);
+               handled |= CSR_INT_BIT_FH_TX;
+       }
+
+       if (inta & ~handled) {
+               IL_ERR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
+               il->isr_stats.unhandled++;
+       }
+
+       if (inta & ~il->inta_mask) {
+               IL_WARN("Disabled INTA bits 0x%08x were pending\n",
+                       inta & ~il->inta_mask);
+               IL_WARN("   with inta_fh = 0x%08x\n", inta_fh);
+       }
+
+       /* Re-enable all interrupts */
+       /* only Re-enable if disabled by irq */
+       if (test_bit(S_INT_ENABLED, &il->status))
+               il_enable_interrupts(il);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (il_get_debug_level(il) & (IL_DL_ISR)) {
+               inta = _il_rd(il, CSR_INT);
+               inta_mask = _il_rd(il, CSR_INT_MASK);
+               inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
+               D_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
+                     "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
+       }
+#endif
+}
+
+static int
+il3945_get_channels_for_scan(struct il_priv *il, enum ieee80211_band band,
+                            u8 is_active, u8 n_probes,
+                            struct il3945_scan_channel *scan_ch,
+                            struct ieee80211_vif *vif)
+{
+       struct ieee80211_channel *chan;
+       const struct ieee80211_supported_band *sband;
+       const struct il_channel_info *ch_info;
+       u16 passive_dwell = 0;
+       u16 active_dwell = 0;
+       int added, i;
+
+       sband = il_get_hw_mode(il, band);
+       if (!sband)
+               return 0;
+
+       active_dwell = il_get_active_dwell_time(il, band, n_probes);
+       passive_dwell = il_get_passive_dwell_time(il, band, vif);
+
+       if (passive_dwell <= active_dwell)
+               passive_dwell = active_dwell + 1;
+
+       for (i = 0, added = 0; i < il->scan_request->n_channels; i++) {
+               chan = il->scan_request->channels[i];
+
+               if (chan->band != band)
+                       continue;
+
+               scan_ch->channel = chan->hw_value;
+
+               ch_info = il_get_channel_info(il, band, scan_ch->channel);
+               if (!il_is_channel_valid(ch_info)) {
+                       D_SCAN("Channel %d is INVALID for this band.\n",
+                              scan_ch->channel);
+                       continue;
+               }
+
+               scan_ch->active_dwell = cpu_to_le16(active_dwell);
+               scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
+               /* If passive , set up for auto-switch
+                *  and use long active_dwell time.
+                */
+               if (!is_active || il_is_channel_passive(ch_info) ||
+                   (chan->flags & IEEE80211_CHAN_NO_IR)) {
+                       scan_ch->type = 0;      /* passive */
+                       if (IL_UCODE_API(il->ucode_ver) == 1)
+                               scan_ch->active_dwell =
+                                   cpu_to_le16(passive_dwell - 1);
+               } else {
+                       scan_ch->type = 1;      /* active */
+               }
+
+               /* Set direct probe bits. These may be used both for active
+                * scan channels (probes gets sent right away),
+                * or for passive channels (probes get se sent only after
+                * hearing clear Rx packet).*/
+               if (IL_UCODE_API(il->ucode_ver) >= 2) {
+                       if (n_probes)
+                               scan_ch->type |= IL39_SCAN_PROBE_MASK(n_probes);
+               } else {
+                       /* uCode v1 does not allow setting direct probe bits on
+                        * passive channel. */
+                       if ((scan_ch->type & 1) && n_probes)
+                               scan_ch->type |= IL39_SCAN_PROBE_MASK(n_probes);
+               }
+
+               /* Set txpower levels to defaults */
+               scan_ch->tpc.dsp_atten = 110;
+               /* scan_pwr_info->tpc.dsp_atten; */
+
+               /*scan_pwr_info->tpc.tx_gain; */
+               if (band == IEEE80211_BAND_5GHZ)
+                       scan_ch->tpc.tx_gain = ((1 << 5) | (3 << 3)) | 3;
+               else {
+                       scan_ch->tpc.tx_gain = ((1 << 5) | (5 << 3));
+                       /* NOTE: if we were doing 6Mb OFDM for scans we'd use
+                        * power level:
+                        * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
+                        */
+               }
+
+               D_SCAN("Scanning %d [%s %d]\n", scan_ch->channel,
+                      (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
+                      (scan_ch->type & 1) ? active_dwell : passive_dwell);
+
+               scan_ch++;
+               added++;
+       }
+
+       D_SCAN("total channels to scan %d\n", added);
+       return added;
+}
+
+static void
+il3945_init_hw_rates(struct il_priv *il, struct ieee80211_rate *rates)
+{
+       int i;
+
+       for (i = 0; i < RATE_COUNT_LEGACY; i++) {
+               rates[i].bitrate = il3945_rates[i].ieee * 5;
+               rates[i].hw_value = i;  /* Rate scaling will work on idxes */
+               rates[i].hw_value_short = i;
+               rates[i].flags = 0;
+               if (i > IL39_LAST_OFDM_RATE || i < IL_FIRST_OFDM_RATE) {
+                       /*
+                        * If CCK != 1M then set short preamble rate flag.
+                        */
+                       rates[i].flags |=
+                           (il3945_rates[i].plcp ==
+                            10) ? 0 : IEEE80211_RATE_SHORT_PREAMBLE;
+               }
+       }
+}
+
+/******************************************************************************
+ *
+ * uCode download functions
+ *
+ ******************************************************************************/
+
+static void
+il3945_dealloc_ucode_pci(struct il_priv *il)
+{
+       il_free_fw_desc(il->pci_dev, &il->ucode_code);
+       il_free_fw_desc(il->pci_dev, &il->ucode_data);
+       il_free_fw_desc(il->pci_dev, &il->ucode_data_backup);
+       il_free_fw_desc(il->pci_dev, &il->ucode_init);
+       il_free_fw_desc(il->pci_dev, &il->ucode_init_data);
+       il_free_fw_desc(il->pci_dev, &il->ucode_boot);
+}
+
+/**
+ * il3945_verify_inst_full - verify runtime uCode image in card vs. host,
+ *     looking at all data.
+ */
+static int
+il3945_verify_inst_full(struct il_priv *il, __le32 * image, u32 len)
+{
+       u32 val;
+       u32 save_len = len;
+       int rc = 0;
+       u32 errcnt;
+
+       D_INFO("ucode inst image size is %u\n", len);
+
+       il_wr(il, HBUS_TARG_MEM_RADDR, IL39_RTC_INST_LOWER_BOUND);
+
+       errcnt = 0;
+       for (; len > 0; len -= sizeof(u32), image++) {
+               /* read data comes through single port, auto-incr addr */
+               /* NOTE: Use the debugless read so we don't flood kernel log
+                * if IL_DL_IO is set */
+               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
+               if (val != le32_to_cpu(*image)) {
+                       IL_ERR("uCode INST section is invalid at "
+                              "offset 0x%x, is 0x%x, s/b 0x%x\n",
+                              save_len - len, val, le32_to_cpu(*image));
+                       rc = -EIO;
+                       errcnt++;
+                       if (errcnt >= 20)
+                               break;
+               }
+       }
+
+       if (!errcnt)
+               D_INFO("ucode image in INSTRUCTION memory is good\n");
+
+       return rc;
+}
+
+/**
+ * il3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
+ *   using sample data 100 bytes apart.  If these sample points are good,
+ *   it's a pretty good bet that everything between them is good, too.
+ */
+static int
+il3945_verify_inst_sparse(struct il_priv *il, __le32 * image, u32 len)
+{
+       u32 val;
+       int rc = 0;
+       u32 errcnt = 0;
+       u32 i;
+
+       D_INFO("ucode inst image size is %u\n", len);
+
+       for (i = 0; i < len; i += 100, image += 100 / sizeof(u32)) {
+               /* read data comes through single port, auto-incr addr */
+               /* NOTE: Use the debugless read so we don't flood kernel log
+                * if IL_DL_IO is set */
+               il_wr(il, HBUS_TARG_MEM_RADDR, i + IL39_RTC_INST_LOWER_BOUND);
+               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
+               if (val != le32_to_cpu(*image)) {
+#if 0                          /* Enable this if you want to see details */
+                       IL_ERR("uCode INST section is invalid at "
+                              "offset 0x%x, is 0x%x, s/b 0x%x\n", i, val,
+                              *image);
+#endif
+                       rc = -EIO;
+                       errcnt++;
+                       if (errcnt >= 3)
+                               break;
+               }
+       }
+
+       return rc;
+}
+
+/**
+ * il3945_verify_ucode - determine which instruction image is in SRAM,
+ *    and verify its contents
+ */
+static int
+il3945_verify_ucode(struct il_priv *il)
+{
+       __le32 *image;
+       u32 len;
+       int rc = 0;
+
+       /* Try bootstrap */
+       image = (__le32 *) il->ucode_boot.v_addr;
+       len = il->ucode_boot.len;
+       rc = il3945_verify_inst_sparse(il, image, len);
+       if (rc == 0) {
+               D_INFO("Bootstrap uCode is good in inst SRAM\n");
+               return 0;
+       }
+
+       /* Try initialize */
+       image = (__le32 *) il->ucode_init.v_addr;
+       len = il->ucode_init.len;
+       rc = il3945_verify_inst_sparse(il, image, len);
+       if (rc == 0) {
+               D_INFO("Initialize uCode is good in inst SRAM\n");
+               return 0;
+       }
+
+       /* Try runtime/protocol */
+       image = (__le32 *) il->ucode_code.v_addr;
+       len = il->ucode_code.len;
+       rc = il3945_verify_inst_sparse(il, image, len);
+       if (rc == 0) {
+               D_INFO("Runtime uCode is good in inst SRAM\n");
+               return 0;
+       }
+
+       IL_ERR("NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");
+
+       /* Since nothing seems to match, show first several data entries in
+        * instruction SRAM, so maybe visual inspection will give a clue.
+        * Selection of bootstrap image (vs. other images) is arbitrary. */
+       image = (__le32 *) il->ucode_boot.v_addr;
+       len = il->ucode_boot.len;
+       rc = il3945_verify_inst_full(il, image, len);
+
+       return rc;
+}
+
+static void
+il3945_nic_start(struct il_priv *il)
+{
+       /* Remove all resets to allow NIC to operate */
+       _il_wr(il, CSR_RESET, 0);
+}
+
+#define IL3945_UCODE_GET(item)                                         \
+static u32 il3945_ucode_get_##item(const struct il_ucode_header *ucode)\
+{                                                                      \
+       return le32_to_cpu(ucode->v1.item);                             \
+}
+
+static u32
+il3945_ucode_get_header_size(u32 api_ver)
+{
+       return 24;
+}
+
+static u8 *
+il3945_ucode_get_data(const struct il_ucode_header *ucode)
+{
+       return (u8 *) ucode->v1.data;
+}
+
+IL3945_UCODE_GET(inst_size);
+IL3945_UCODE_GET(data_size);
+IL3945_UCODE_GET(init_size);
+IL3945_UCODE_GET(init_data_size);
+IL3945_UCODE_GET(boot_size);
+
+/**
+ * il3945_read_ucode - Read uCode images from disk file.
+ *
+ * Copy into buffers for card to fetch via bus-mastering
+ */
+static int
+il3945_read_ucode(struct il_priv *il)
+{
+       const struct il_ucode_header *ucode;
+       int ret = -EINVAL, idx;
+       const struct firmware *ucode_raw;
+       /* firmware file name contains uCode/driver compatibility version */
+       const char *name_pre = il->cfg->fw_name_pre;
+       const unsigned int api_max = il->cfg->ucode_api_max;
+       const unsigned int api_min = il->cfg->ucode_api_min;
+       char buf[25];
+       u8 *src;
+       size_t len;
+       u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
+
+       /* Ask kernel firmware_class module to get the boot firmware off disk.
+        * request_firmware() is synchronous, file is in memory on return. */
+       for (idx = api_max; idx >= api_min; idx--) {
+               sprintf(buf, "%s%u%s", name_pre, idx, ".ucode");
+               ret = request_firmware(&ucode_raw, buf, &il->pci_dev->dev);
+               if (ret < 0) {
+                       IL_ERR("%s firmware file req failed: %d\n", buf, ret);
+                       if (ret == -ENOENT)
+                               continue;
+                       else
+                               goto error;
+               } else {
+                       if (idx < api_max)
+                               IL_ERR("Loaded firmware %s, "
+                                      "which is deprecated. "
+                                      " Please use API v%u instead.\n", buf,
+                                      api_max);
+                       D_INFO("Got firmware '%s' file "
+                              "(%zd bytes) from disk\n", buf, ucode_raw->size);
+                       break;
+               }
+       }
+
+       if (ret < 0)
+               goto error;
+
+       /* Make sure that we got at least our header! */
+       if (ucode_raw->size < il3945_ucode_get_header_size(1)) {
+               IL_ERR("File size way too small!\n");
+               ret = -EINVAL;
+               goto err_release;
+       }
+
+       /* Data from ucode file:  header followed by uCode images */
+       ucode = (struct il_ucode_header *)ucode_raw->data;
+
+       il->ucode_ver = le32_to_cpu(ucode->ver);
+       api_ver = IL_UCODE_API(il->ucode_ver);
+       inst_size = il3945_ucode_get_inst_size(ucode);
+       data_size = il3945_ucode_get_data_size(ucode);
+       init_size = il3945_ucode_get_init_size(ucode);
+       init_data_size = il3945_ucode_get_init_data_size(ucode);
+       boot_size = il3945_ucode_get_boot_size(ucode);
+       src = il3945_ucode_get_data(ucode);
+
+       /* api_ver should match the api version forming part of the
+        * firmware filename ... but we don't check for that and only rely
+        * on the API version read from firmware header from here on forward */
+
+       if (api_ver < api_min || api_ver > api_max) {
+               IL_ERR("Driver unable to support your firmware API. "
+                      "Driver supports v%u, firmware is v%u.\n", api_max,
+                      api_ver);
+               il->ucode_ver = 0;
+               ret = -EINVAL;
+               goto err_release;
+       }
+       if (api_ver != api_max)
+               IL_ERR("Firmware has old API version. Expected %u, "
+                      "got %u. New firmware can be obtained "
+                      "from http://www.intellinuxwireless.org.\n", api_max,
+                      api_ver);
+
+       IL_INFO("loaded firmware version %u.%u.%u.%u\n",
+               IL_UCODE_MAJOR(il->ucode_ver), IL_UCODE_MINOR(il->ucode_ver),
+               IL_UCODE_API(il->ucode_ver), IL_UCODE_SERIAL(il->ucode_ver));
+
+       snprintf(il->hw->wiphy->fw_version, sizeof(il->hw->wiphy->fw_version),
+                "%u.%u.%u.%u", IL_UCODE_MAJOR(il->ucode_ver),
+                IL_UCODE_MINOR(il->ucode_ver), IL_UCODE_API(il->ucode_ver),
+                IL_UCODE_SERIAL(il->ucode_ver));
+
+       D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver);
+       D_INFO("f/w package hdr runtime inst size = %u\n", inst_size);
+       D_INFO("f/w package hdr runtime data size = %u\n", data_size);
+       D_INFO("f/w package hdr init inst size = %u\n", init_size);
+       D_INFO("f/w package hdr init data size = %u\n", init_data_size);
+       D_INFO("f/w package hdr boot inst size = %u\n", boot_size);
+
+       /* Verify size of file vs. image size info in file's header */
+       if (ucode_raw->size !=
+           il3945_ucode_get_header_size(api_ver) + inst_size + data_size +
+           init_size + init_data_size + boot_size) {
+
+               D_INFO("uCode file size %zd does not match expected size\n",
+                      ucode_raw->size);
+               ret = -EINVAL;
+               goto err_release;
+       }
+
+       /* Verify that uCode images will fit in card's SRAM */
+       if (inst_size > IL39_MAX_INST_SIZE) {
+               D_INFO("uCode instr len %d too large to fit in\n", inst_size);
+               ret = -EINVAL;
+               goto err_release;
+       }
+
+       if (data_size > IL39_MAX_DATA_SIZE) {
+               D_INFO("uCode data len %d too large to fit in\n", data_size);
+               ret = -EINVAL;
+               goto err_release;
+       }
+       if (init_size > IL39_MAX_INST_SIZE) {
+               D_INFO("uCode init instr len %d too large to fit in\n",
+                      init_size);
+               ret = -EINVAL;
+               goto err_release;
+       }
+       if (init_data_size > IL39_MAX_DATA_SIZE) {
+               D_INFO("uCode init data len %d too large to fit in\n",
+                      init_data_size);
+               ret = -EINVAL;
+               goto err_release;
+       }
+       if (boot_size > IL39_MAX_BSM_SIZE) {
+               D_INFO("uCode boot instr len %d too large to fit in\n",
+                      boot_size);
+               ret = -EINVAL;
+               goto err_release;
+       }
+
+       /* Allocate ucode buffers for card's bus-master loading ... */
+
+       /* Runtime instructions and 2 copies of data:
+        * 1) unmodified from disk
+        * 2) backup cache for save/restore during power-downs */
+       il->ucode_code.len = inst_size;
+       il_alloc_fw_desc(il->pci_dev, &il->ucode_code);
+
+       il->ucode_data.len = data_size;
+       il_alloc_fw_desc(il->pci_dev, &il->ucode_data);
+
+       il->ucode_data_backup.len = data_size;
+       il_alloc_fw_desc(il->pci_dev, &il->ucode_data_backup);
+
+       if (!il->ucode_code.v_addr || !il->ucode_data.v_addr ||
+           !il->ucode_data_backup.v_addr)
+               goto err_pci_alloc;
+
+       /* Initialization instructions and data */
+       if (init_size && init_data_size) {
+               il->ucode_init.len = init_size;
+               il_alloc_fw_desc(il->pci_dev, &il->ucode_init);
+
+               il->ucode_init_data.len = init_data_size;
+               il_alloc_fw_desc(il->pci_dev, &il->ucode_init_data);
+
+               if (!il->ucode_init.v_addr || !il->ucode_init_data.v_addr)
+                       goto err_pci_alloc;
+       }
+
+       /* Bootstrap (instructions only, no data) */
+       if (boot_size) {
+               il->ucode_boot.len = boot_size;
+               il_alloc_fw_desc(il->pci_dev, &il->ucode_boot);
+
+               if (!il->ucode_boot.v_addr)
+                       goto err_pci_alloc;
+       }
+
+       /* Copy images into buffers for card's bus-master reads ... */
+
+       /* Runtime instructions (first block of data in file) */
+       len = inst_size;
+       D_INFO("Copying (but not loading) uCode instr len %zd\n", len);
+       memcpy(il->ucode_code.v_addr, src, len);
+       src += len;
+
+       D_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
+              il->ucode_code.v_addr, (u32) il->ucode_code.p_addr);
+
+       /* Runtime data (2nd block)
+        * NOTE:  Copy into backup buffer will be done in il3945_up()  */
+       len = data_size;
+       D_INFO("Copying (but not loading) uCode data len %zd\n", len);
+       memcpy(il->ucode_data.v_addr, src, len);
+       memcpy(il->ucode_data_backup.v_addr, src, len);
+       src += len;
+
+       /* Initialization instructions (3rd block) */
+       if (init_size) {
+               len = init_size;
+               D_INFO("Copying (but not loading) init instr len %zd\n", len);
+               memcpy(il->ucode_init.v_addr, src, len);
+               src += len;
+       }
+
+       /* Initialization data (4th block) */
+       if (init_data_size) {
+               len = init_data_size;
+               D_INFO("Copying (but not loading) init data len %zd\n", len);
+               memcpy(il->ucode_init_data.v_addr, src, len);
+               src += len;
+       }
+
+       /* Bootstrap instructions (5th block) */
+       len = boot_size;
+       D_INFO("Copying (but not loading) boot instr len %zd\n", len);
+       memcpy(il->ucode_boot.v_addr, src, len);
+
+       /* We have our copies now, allow OS release its copies */
+       release_firmware(ucode_raw);
+       return 0;
+
+err_pci_alloc:
+       IL_ERR("failed to allocate pci memory\n");
+       ret = -ENOMEM;
+       il3945_dealloc_ucode_pci(il);
+
+err_release:
+       release_firmware(ucode_raw);
+
+error:
+       return ret;
+}
+
+/**
+ * il3945_set_ucode_ptrs - Set uCode address location
+ *
+ * Tell initialization uCode where to find runtime uCode.
+ *
+ * BSM registers initially contain pointers to initialization uCode.
+ * We need to replace them to load runtime uCode inst and data,
+ * and to save runtime data when powering down.
+ */
+static int
+il3945_set_ucode_ptrs(struct il_priv *il)
+{
+       dma_addr_t pinst;
+       dma_addr_t pdata;
+
+       /* bits 31:0 for 3945 */
+       pinst = il->ucode_code.p_addr;
+       pdata = il->ucode_data_backup.p_addr;
+
+       /* Tell bootstrap uCode where to find image to load */
+       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
+       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
+       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, il->ucode_data.len);
+
+       /* Inst byte count must be last to set up, bit 31 signals uCode
+        *   that all new ptr/size info is in place */
+       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG,
+                  il->ucode_code.len | BSM_DRAM_INST_LOAD);
+
+       D_INFO("Runtime uCode pointers are set.\n");
+
+       return 0;
+}
+
+/**
+ * il3945_init_alive_start - Called after N_ALIVE notification received
+ *
+ * Called after N_ALIVE notification received from "initialize" uCode.
+ *
+ * Tell "initialize" uCode to go ahead and load the runtime uCode.
+ */
+static void
+il3945_init_alive_start(struct il_priv *il)
+{
+       /* Check alive response for "valid" sign from uCode */
+       if (il->card_alive_init.is_valid != UCODE_VALID_OK) {
+               /* We had an error bringing up the hardware, so take it
+                * all the way back down so we can try again */
+               D_INFO("Initialize Alive failed.\n");
+               goto restart;
+       }
+
+       /* Bootstrap uCode has loaded initialize uCode ... verify inst image.
+        * This is a paranoid check, because we would not have gotten the
+        * "initialize" alive if code weren't properly loaded.  */
+       if (il3945_verify_ucode(il)) {
+               /* Runtime instruction load was bad;
+                * take it all the way back down so we can try again */
+               D_INFO("Bad \"initialize\" uCode load.\n");
+               goto restart;
+       }
+
+       /* Send pointers to protocol/runtime uCode image ... init code will
+        * load and launch runtime uCode, which will send us another "Alive"
+        * notification. */
+       D_INFO("Initialization Alive received.\n");
+       if (il3945_set_ucode_ptrs(il)) {
+               /* Runtime instruction load won't happen;
+                * take it all the way back down so we can try again */
+               D_INFO("Couldn't set up uCode pointers.\n");
+               goto restart;
+       }
+       return;
+
+restart:
+       queue_work(il->workqueue, &il->restart);
+}
+
+/**
+ * il3945_alive_start - called after N_ALIVE notification received
+ *                   from protocol/runtime uCode (initialization uCode's
+ *                   Alive gets handled by il3945_init_alive_start()).
+ */
+static void
+il3945_alive_start(struct il_priv *il)
+{
+       int thermal_spin = 0;
+       u32 rfkill;
+
+       D_INFO("Runtime Alive received.\n");
+
+       if (il->card_alive.is_valid != UCODE_VALID_OK) {
+               /* We had an error bringing up the hardware, so take it
+                * all the way back down so we can try again */
+               D_INFO("Alive failed.\n");
+               goto restart;
+       }
+
+       /* Initialize uCode has loaded Runtime uCode ... verify inst image.
+        * This is a paranoid check, because we would not have gotten the
+        * "runtime" alive if code weren't properly loaded.  */
+       if (il3945_verify_ucode(il)) {
+               /* Runtime instruction load was bad;
+                * take it all the way back down so we can try again */
+               D_INFO("Bad runtime uCode load.\n");
+               goto restart;
+       }
+
+       rfkill = il_rd_prph(il, APMG_RFKILL_REG);
+       D_INFO("RFKILL status: 0x%x\n", rfkill);
+
+       if (rfkill & 0x1) {
+               clear_bit(S_RFKILL, &il->status);
+               /* if RFKILL is not on, then wait for thermal
+                * sensor in adapter to kick in */
+               while (il3945_hw_get_temperature(il) == 0) {
+                       thermal_spin++;
+                       udelay(10);
+               }
+
+               if (thermal_spin)
+                       D_INFO("Thermal calibration took %dus\n",
+                              thermal_spin * 10);
+       } else
+               set_bit(S_RFKILL, &il->status);
+
+       /* After the ALIVE response, we can send commands to 3945 uCode */
+       set_bit(S_ALIVE, &il->status);
+
+       /* Enable watchdog to monitor the driver tx queues */
+       il_setup_watchdog(il);
+
+       if (il_is_rfkill(il))
+               return;
+
+       ieee80211_wake_queues(il->hw);
+
+       il->active_rate = RATES_MASK_3945;
+
+       il_power_update_mode(il, true);
+
+       if (il_is_associated(il)) {
+               struct il3945_rxon_cmd *active_rxon =
+                   (struct il3945_rxon_cmd *)(&il->active);
+
+               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
+               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+       } else {
+               /* Initialize our rx_config data */
+               il_connection_init_rx_config(il);
+       }
+
+       /* Configure Bluetooth device coexistence support */
+       il_send_bt_config(il);
+
+       set_bit(S_READY, &il->status);
+
+       /* Configure the adapter for unassociated operation */
+       il3945_commit_rxon(il);
+
+       il3945_reg_txpower_periodic(il);
+
+       D_INFO("ALIVE processing complete.\n");
+       wake_up(&il->wait_command_queue);
+
+       return;
+
+restart:
+       queue_work(il->workqueue, &il->restart);
+}
+
+static void il3945_cancel_deferred_work(struct il_priv *il);
+
+static void
+__il3945_down(struct il_priv *il)
+{
+       unsigned long flags;
+       int exit_pending;
+
+       D_INFO(DRV_NAME " is going down\n");
+
+       il_scan_cancel_timeout(il, 200);
+
+       exit_pending = test_and_set_bit(S_EXIT_PENDING, &il->status);
+
+       /* Stop TX queues watchdog. We need to have S_EXIT_PENDING bit set
+        * to prevent rearm timer */
+       del_timer_sync(&il->watchdog);
+
+       /* Station information will now be cleared in device */
+       il_clear_ucode_stations(il);
+       il_dealloc_bcast_stations(il);
+       il_clear_driver_stations(il);
+
+       /* Unblock any waiting calls */
+       wake_up_all(&il->wait_command_queue);
+
+       /* Wipe out the EXIT_PENDING status bit if we are not actually
+        * exiting the module */
+       if (!exit_pending)
+               clear_bit(S_EXIT_PENDING, &il->status);
+
+       /* stop and reset the on-board processor */
+       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
+
+       /* tell the device to stop sending interrupts */
+       spin_lock_irqsave(&il->lock, flags);
+       il_disable_interrupts(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+       il3945_synchronize_irq(il);
+
+       if (il->mac80211_registered)
+               ieee80211_stop_queues(il->hw);
+
+       /* If we have not previously called il3945_init() then
+        * clear all bits but the RF Kill bits and return */
+       if (!il_is_init(il)) {
+               il->status =
+                   test_bit(S_RFKILL, &il->status) << S_RFKILL |
+                   test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
+                   test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
+               goto exit;
+       }
+
+       /* ...otherwise clear out all the status bits but the RF Kill
+        * bit and continue taking the NIC down. */
+       il->status &=
+           test_bit(S_RFKILL, &il->status) << S_RFKILL |
+           test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
+           test_bit(S_FW_ERROR, &il->status) << S_FW_ERROR |
+           test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
+
+       /*
+        * We disabled and synchronized interrupt, and priv->mutex is taken, so
+        * here is the only thread which will program device registers, but
+        * still have lockdep assertions, so we are taking reg_lock.
+        */
+       spin_lock_irq(&il->reg_lock);
+       /* FIXME: il_grab_nic_access if rfkill is off ? */
+
+       il3945_hw_txq_ctx_stop(il);
+       il3945_hw_rxq_stop(il);
+       /* Power-down device's busmaster DMA clocks */
+       _il_wr_prph(il, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
+       udelay(5);
+       /* Stop the device, and put it in low power state */
+       _il_apm_stop(il);
+
+       spin_unlock_irq(&il->reg_lock);
+
+       il3945_hw_txq_ctx_free(il);
+exit:
+       memset(&il->card_alive, 0, sizeof(struct il_alive_resp));
+
+       if (il->beacon_skb)
+               dev_kfree_skb(il->beacon_skb);
+       il->beacon_skb = NULL;
+
+       /* clear out any free frames */
+       il3945_clear_free_frames(il);
+}
+
+static void
+il3945_down(struct il_priv *il)
+{
+       mutex_lock(&il->mutex);
+       __il3945_down(il);
+       mutex_unlock(&il->mutex);
+
+       il3945_cancel_deferred_work(il);
+}
+
+#define MAX_HW_RESTARTS 5
+
+static int
+il3945_alloc_bcast_station(struct il_priv *il)
+{
+       unsigned long flags;
+       u8 sta_id;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       sta_id = il_prep_station(il, il_bcast_addr, false, NULL);
+       if (sta_id == IL_INVALID_STATION) {
+               IL_ERR("Unable to prepare broadcast station\n");
+               spin_unlock_irqrestore(&il->sta_lock, flags);
+
+               return -EINVAL;
+       }
+
+       il->stations[sta_id].used |= IL_STA_DRIVER_ACTIVE;
+       il->stations[sta_id].used |= IL_STA_BCAST;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return 0;
+}
+
+static int
+__il3945_up(struct il_priv *il)
+{
+       int rc, i;
+
+       rc = il3945_alloc_bcast_station(il);
+       if (rc)
+               return rc;
+
+       if (test_bit(S_EXIT_PENDING, &il->status)) {
+               IL_WARN("Exit pending; will not bring the NIC up\n");
+               return -EIO;
+       }
+
+       if (!il->ucode_data_backup.v_addr || !il->ucode_data.v_addr) {
+               IL_ERR("ucode not available for device bring up\n");
+               return -EIO;
+       }
+
+       /* If platform's RF_KILL switch is NOT set to KILL */
+       if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
+               clear_bit(S_RFKILL, &il->status);
+       else {
+               set_bit(S_RFKILL, &il->status);
+               return -ERFKILL;
+       }
+
+       _il_wr(il, CSR_INT, 0xFFFFFFFF);
+
+       rc = il3945_hw_nic_init(il);
+       if (rc) {
+               IL_ERR("Unable to int nic\n");
+               return rc;
+       }
+
+       /* make sure rfkill handshake bits are cleared */
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+
+       /* clear (again), then enable host interrupts */
+       _il_wr(il, CSR_INT, 0xFFFFFFFF);
+       il_enable_interrupts(il);
+
+       /* really make sure rfkill handshake bits are cleared */
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+
+       /* Copy original ucode data image from disk into backup cache.
+        * This will be used to initialize the on-board processor's
+        * data SRAM for a clean start when the runtime program first loads. */
+       memcpy(il->ucode_data_backup.v_addr, il->ucode_data.v_addr,
+              il->ucode_data.len);
+
+       /* We return success when we resume from suspend and rf_kill is on. */
+       if (test_bit(S_RFKILL, &il->status))
+               return 0;
+
+       for (i = 0; i < MAX_HW_RESTARTS; i++) {
+
+               /* load bootstrap state machine,
+                * load bootstrap program into processor's memory,
+                * prepare to load the "initialize" uCode */
+               rc = il->ops->load_ucode(il);
+
+               if (rc) {
+                       IL_ERR("Unable to set up bootstrap uCode: %d\n", rc);
+                       continue;
+               }
+
+               /* start card; "initialize" will load runtime ucode */
+               il3945_nic_start(il);
+
+               D_INFO(DRV_NAME " is coming up\n");
+
+               return 0;
+       }
+
+       set_bit(S_EXIT_PENDING, &il->status);
+       __il3945_down(il);
+       clear_bit(S_EXIT_PENDING, &il->status);
+
+       /* tried to restart and config the device for as long as our
+        * patience could withstand */
+       IL_ERR("Unable to initialize device after %d attempts.\n", i);
+       return -EIO;
+}
+
+/*****************************************************************************
+ *
+ * Workqueue callbacks
+ *
+ *****************************************************************************/
+
+static void
+il3945_bg_init_alive_start(struct work_struct *data)
+{
+       struct il_priv *il =
+           container_of(data, struct il_priv, init_alive_start.work);
+
+       mutex_lock(&il->mutex);
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               goto out;
+
+       il3945_init_alive_start(il);
+out:
+       mutex_unlock(&il->mutex);
+}
+
+static void
+il3945_bg_alive_start(struct work_struct *data)
+{
+       struct il_priv *il =
+           container_of(data, struct il_priv, alive_start.work);
+
+       mutex_lock(&il->mutex);
+       if (test_bit(S_EXIT_PENDING, &il->status) || il->txq == NULL)
+               goto out;
+
+       il3945_alive_start(il);
+out:
+       mutex_unlock(&il->mutex);
+}
+
+/*
+ * 3945 cannot interrupt driver when hardware rf kill switch toggles;
+ * driver must poll CSR_GP_CNTRL_REG register for change.  This register
+ * *is* readable even when device has been SW_RESET into low power mode
+ * (e.g. during RF KILL).
+ */
+static void
+il3945_rfkill_poll(struct work_struct *data)
+{
+       struct il_priv *il =
+           container_of(data, struct il_priv, _3945.rfkill_poll.work);
+       bool old_rfkill = test_bit(S_RFKILL, &il->status);
+       bool new_rfkill =
+           !(_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW);
+
+       if (new_rfkill != old_rfkill) {
+               if (new_rfkill)
+                       set_bit(S_RFKILL, &il->status);
+               else
+                       clear_bit(S_RFKILL, &il->status);
+
+               wiphy_rfkill_set_hw_state(il->hw->wiphy, new_rfkill);
+
+               D_RF_KILL("RF_KILL bit toggled to %s.\n",
+                         new_rfkill ? "disable radio" : "enable radio");
+       }
+
+       /* Keep this running, even if radio now enabled.  This will be
+        * cancelled in mac_start() if system decides to start again */
+       queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll,
+                          round_jiffies_relative(2 * HZ));
+
+}
+
+int
+il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
+{
+       struct il_host_cmd cmd = {
+               .id = C_SCAN,
+               .len = sizeof(struct il3945_scan_cmd),
+               .flags = CMD_SIZE_HUGE,
+       };
+       struct il3945_scan_cmd *scan;
+       u8 n_probes = 0;
+       enum ieee80211_band band;
+       bool is_active = false;
+       int ret;
+       u16 len;
+
+       lockdep_assert_held(&il->mutex);
+
+       if (!il->scan_cmd) {
+               il->scan_cmd =
+                   kmalloc(sizeof(struct il3945_scan_cmd) + IL_MAX_SCAN_SIZE,
+                           GFP_KERNEL);
+               if (!il->scan_cmd) {
+                       D_SCAN("Fail to allocate scan memory\n");
+                       return -ENOMEM;
+               }
+       }
+       scan = il->scan_cmd;
+       memset(scan, 0, sizeof(struct il3945_scan_cmd) + IL_MAX_SCAN_SIZE);
+
+       scan->quiet_plcp_th = IL_PLCP_QUIET_THRESH;
+       scan->quiet_time = IL_ACTIVE_QUIET_TIME;
+
+       if (il_is_associated(il)) {
+               u16 interval;
+               u32 extra;
+               u32 suspend_time = 100;
+               u32 scan_suspend_time = 100;
+
+               D_INFO("Scanning while associated...\n");
+
+               interval = vif->bss_conf.beacon_int;
+
+               scan->suspend_time = 0;
+               scan->max_out_time = cpu_to_le32(200 * 1024);
+               if (!interval)
+                       interval = suspend_time;
+               /*
+                * suspend time format:
+                *  0-19: beacon interval in usec (time before exec.)
+                * 20-23: 0
+                * 24-31: number of beacons (suspend between channels)
+                */
+
+               extra = (suspend_time / interval) << 24;
+               scan_suspend_time =
+                   0xFF0FFFFF & (extra | ((suspend_time % interval) * 1024));
+
+               scan->suspend_time = cpu_to_le32(scan_suspend_time);
+               D_SCAN("suspend_time 0x%X beacon interval %d\n",
+                      scan_suspend_time, interval);
+       }
+
+       if (il->scan_request->n_ssids) {
+               int i, p = 0;
+               D_SCAN("Kicking off active scan\n");
+               for (i = 0; i < il->scan_request->n_ssids; i++) {
+                       /* always does wildcard anyway */
+                       if (!il->scan_request->ssids[i].ssid_len)
+                               continue;
+                       scan->direct_scan[p].id = WLAN_EID_SSID;
+                       scan->direct_scan[p].len =
+                           il->scan_request->ssids[i].ssid_len;
+                       memcpy(scan->direct_scan[p].ssid,
+                              il->scan_request->ssids[i].ssid,
+                              il->scan_request->ssids[i].ssid_len);
+                       n_probes++;
+                       p++;
+               }
+               is_active = true;
+       } else
+               D_SCAN("Kicking off passive scan.\n");
+
+       /* We don't build a direct scan probe request; the uCode will do
+        * that based on the direct_mask added to each channel entry */
+       scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
+       scan->tx_cmd.sta_id = il->hw_params.bcast_id;
+       scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
+
+       /* flags + rate selection */
+
+       switch (il->scan_band) {
+       case IEEE80211_BAND_2GHZ:
+               scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
+               scan->tx_cmd.rate = RATE_1M_PLCP;
+               band = IEEE80211_BAND_2GHZ;
+               break;
+       case IEEE80211_BAND_5GHZ:
+               scan->tx_cmd.rate = RATE_6M_PLCP;
+               band = IEEE80211_BAND_5GHZ;
+               break;
+       default:
+               IL_WARN("Invalid scan band\n");
+               return -EIO;
+       }
+
+       /*
+        * If active scaning is requested but a certain channel is marked
+        * passive, we can do active scanning if we detect transmissions. For
+        * passive only scanning disable switching to active on any channel.
+        */
+       scan->good_CRC_th =
+           is_active ? IL_GOOD_CRC_TH_DEFAULT : IL_GOOD_CRC_TH_NEVER;
+
+       len =
+           il_fill_probe_req(il, (struct ieee80211_mgmt *)scan->data,
+                             vif->addr, il->scan_request->ie,
+                             il->scan_request->ie_len,
+                             IL_MAX_SCAN_SIZE - sizeof(*scan));
+       scan->tx_cmd.len = cpu_to_le16(len);
+
+       /* select Rx antennas */
+       scan->flags |= il3945_get_antenna_flags(il);
+
+       scan->channel_count =
+           il3945_get_channels_for_scan(il, band, is_active, n_probes,
+                                        (void *)&scan->data[len], vif);
+       if (scan->channel_count == 0) {
+               D_SCAN("channel count %d\n", scan->channel_count);
+               return -EIO;
+       }
+
+       cmd.len +=
+           le16_to_cpu(scan->tx_cmd.len) +
+           scan->channel_count * sizeof(struct il3945_scan_channel);
+       cmd.data = scan;
+       scan->len = cpu_to_le16(cmd.len);
+
+       set_bit(S_SCAN_HW, &il->status);
+       ret = il_send_cmd_sync(il, &cmd);
+       if (ret)
+               clear_bit(S_SCAN_HW, &il->status);
+       return ret;
+}
+
+void
+il3945_post_scan(struct il_priv *il)
+{
+       /*
+        * Since setting the RXON may have been deferred while
+        * performing the scan, fire one off if needed
+        */
+       if (memcmp(&il->staging, &il->active, sizeof(il->staging)))
+               il3945_commit_rxon(il);
+}
+
+static void
+il3945_bg_restart(struct work_struct *data)
+{
+       struct il_priv *il = container_of(data, struct il_priv, restart);
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
+               mutex_lock(&il->mutex);
+               il->is_open = 0;
+               mutex_unlock(&il->mutex);
+               il3945_down(il);
+               ieee80211_restart_hw(il->hw);
+       } else {
+               il3945_down(il);
+
+               mutex_lock(&il->mutex);
+               if (test_bit(S_EXIT_PENDING, &il->status)) {
+                       mutex_unlock(&il->mutex);
+                       return;
+               }
+
+               __il3945_up(il);
+               mutex_unlock(&il->mutex);
+       }
+}
+
+static void
+il3945_bg_rx_replenish(struct work_struct *data)
+{
+       struct il_priv *il = container_of(data, struct il_priv, rx_replenish);
+
+       mutex_lock(&il->mutex);
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               goto out;
+
+       il3945_rx_replenish(il);
+out:
+       mutex_unlock(&il->mutex);
+}
+
+void
+il3945_post_associate(struct il_priv *il)
+{
+       int rc = 0;
+       struct ieee80211_conf *conf = NULL;
+
+       if (!il->vif || !il->is_open)
+               return;
+
+       D_ASSOC("Associated as %d to: %pM\n", il->vif->bss_conf.aid,
+               il->active.bssid_addr);
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       il_scan_cancel_timeout(il, 200);
+
+       conf = &il->hw->conf;
+
+       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+       il3945_commit_rxon(il);
+
+       rc = il_send_rxon_timing(il);
+       if (rc)
+               IL_WARN("C_RXON_TIMING failed - " "Attempting to continue.\n");
+
+       il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
+
+       il->staging.assoc_id = cpu_to_le16(il->vif->bss_conf.aid);
+
+       D_ASSOC("assoc id %d beacon interval %d\n", il->vif->bss_conf.aid,
+               il->vif->bss_conf.beacon_int);
+
+       if (il->vif->bss_conf.use_short_preamble)
+               il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+       else
+               il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+
+       if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
+               if (il->vif->bss_conf.use_short_slot)
+                       il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
+               else
+                       il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
+       }
+
+       il3945_commit_rxon(il);
+
+       switch (il->vif->type) {
+       case NL80211_IFTYPE_STATION:
+               il3945_rate_scale_init(il->hw, IL_AP_ID);
+               break;
+       case NL80211_IFTYPE_ADHOC:
+               il3945_send_beacon_cmd(il);
+               break;
+       default:
+               IL_ERR("%s Should not be called in %d mode\n", __func__,
+                     il->vif->type);
+               break;
+       }
+}
+
+/*****************************************************************************
+ *
+ * mac80211 entry point functions
+ *
+ *****************************************************************************/
+
+#define UCODE_READY_TIMEOUT    (2 * HZ)
+
+static int
+il3945_mac_start(struct ieee80211_hw *hw)
+{
+       struct il_priv *il = hw->priv;
+       int ret;
+
+       /* we should be verifying the device is ready to be opened */
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter\n");
+
+       /* fetch ucode file from disk, alloc and copy to bus-master buffers ...
+        * ucode filename and max sizes are card-specific. */
+
+       if (!il->ucode_code.len) {
+               ret = il3945_read_ucode(il);
+               if (ret) {
+                       IL_ERR("Could not read microcode: %d\n", ret);
+                       mutex_unlock(&il->mutex);
+                       goto out_release_irq;
+               }
+       }
+
+       ret = __il3945_up(il);
+
+       mutex_unlock(&il->mutex);
+
+       if (ret)
+               goto out_release_irq;
+
+       D_INFO("Start UP work.\n");
+
+       /* Wait for START_ALIVE from ucode. Otherwise callbacks from
+        * mac80211 will not be run successfully. */
+       ret = wait_event_timeout(il->wait_command_queue,
+                                test_bit(S_READY, &il->status),
+                                UCODE_READY_TIMEOUT);
+       if (!ret) {
+               if (!test_bit(S_READY, &il->status)) {
+                       IL_ERR("Wait for START_ALIVE timeout after %dms.\n",
+                              jiffies_to_msecs(UCODE_READY_TIMEOUT));
+                       ret = -ETIMEDOUT;
+                       goto out_release_irq;
+               }
+       }
+
+       /* ucode is running and will send rfkill notifications,
+        * no need to poll the killswitch state anymore */
+       cancel_delayed_work(&il->_3945.rfkill_poll);
+
+       il->is_open = 1;
+       D_MAC80211("leave\n");
+       return 0;
+
+out_release_irq:
+       il->is_open = 0;
+       D_MAC80211("leave - failed\n");
+       return ret;
+}
+
+static void
+il3945_mac_stop(struct ieee80211_hw *hw)
+{
+       struct il_priv *il = hw->priv;
+
+       D_MAC80211("enter\n");
+
+       if (!il->is_open) {
+               D_MAC80211("leave - skip\n");
+               return;
+       }
+
+       il->is_open = 0;
+
+       il3945_down(il);
+
+       flush_workqueue(il->workqueue);
+
+       /* start polling the killswitch state again */
+       queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll,
+                          round_jiffies_relative(2 * HZ));
+
+       D_MAC80211("leave\n");
+}
+
+static void
+il3945_mac_tx(struct ieee80211_hw *hw,
+              struct ieee80211_tx_control *control,
+              struct sk_buff *skb)
+{
+       struct il_priv *il = hw->priv;
+
+       D_MAC80211("enter\n");
+
+       D_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
+            ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
+
+       if (il3945_tx_skb(il, control->sta, skb))
+               dev_kfree_skb_any(skb);
+
+       D_MAC80211("leave\n");
+}
+
+void
+il3945_config_ap(struct il_priv *il)
+{
+       struct ieee80211_vif *vif = il->vif;
+       int rc = 0;
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       /* The following should be done only at AP bring up */
+       if (!(il_is_associated(il))) {
+
+               /* RXON - unassoc (to set timing command) */
+               il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+               il3945_commit_rxon(il);
+
+               /* RXON Timing */
+               rc = il_send_rxon_timing(il);
+               if (rc)
+                       IL_WARN("C_RXON_TIMING failed - "
+                               "Attempting to continue.\n");
+
+               il->staging.assoc_id = 0;
+
+               if (vif->bss_conf.use_short_preamble)
+                       il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+               else
+                       il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+
+               if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
+                       if (vif->bss_conf.use_short_slot)
+                               il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
+                       else
+                               il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
+               }
+               /* restore RXON assoc */
+               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
+               il3945_commit_rxon(il);
+       }
+       il3945_send_beacon_cmd(il);
+}
+
+static int
+il3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
+                  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
+                  struct ieee80211_key_conf *key)
+{
+       struct il_priv *il = hw->priv;
+       int ret = 0;
+       u8 sta_id = IL_INVALID_STATION;
+       u8 static_key;
+
+       D_MAC80211("enter\n");
+
+       if (il3945_mod_params.sw_crypto) {
+               D_MAC80211("leave - hwcrypto disabled\n");
+               return -EOPNOTSUPP;
+       }
+
+       /*
+        * To support IBSS RSN, don't program group keys in IBSS, the
+        * hardware will then not attempt to decrypt the frames.
+        */
+       if (vif->type == NL80211_IFTYPE_ADHOC &&
+           !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
+               D_MAC80211("leave - IBSS RSN\n");
+               return -EOPNOTSUPP;
+       }
+
+       static_key = !il_is_associated(il);
+
+       if (!static_key) {
+               sta_id = il_sta_id_or_broadcast(il, sta);
+               if (sta_id == IL_INVALID_STATION) {
+                       D_MAC80211("leave - station not found\n");
+                       return -EINVAL;
+               }
+       }
+
+       mutex_lock(&il->mutex);
+       il_scan_cancel_timeout(il, 100);
+
+       switch (cmd) {
+       case SET_KEY:
+               if (static_key)
+                       ret = il3945_set_static_key(il, key);
+               else
+                       ret = il3945_set_dynamic_key(il, key, sta_id);
+               D_MAC80211("enable hwcrypto key\n");
+               break;
+       case DISABLE_KEY:
+               if (static_key)
+                       ret = il3945_remove_static_key(il);
+               else
+                       ret = il3945_clear_sta_key_info(il, sta_id);
+               D_MAC80211("disable hwcrypto key\n");
+               break;
+       default:
+               ret = -EINVAL;
+       }
+
+       D_MAC80211("leave ret %d\n", ret);
+       mutex_unlock(&il->mutex);
+
+       return ret;
+}
+
+static int
+il3945_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                  struct ieee80211_sta *sta)
+{
+       struct il_priv *il = hw->priv;
+       struct il3945_sta_priv *sta_priv = (void *)sta->drv_priv;
+       int ret;
+       bool is_ap = vif->type == NL80211_IFTYPE_STATION;
+       u8 sta_id;
+
+       mutex_lock(&il->mutex);
+       D_INFO("station %pM\n", sta->addr);
+       sta_priv->common.sta_id = IL_INVALID_STATION;
+
+       ret = il_add_station_common(il, sta->addr, is_ap, sta, &sta_id);
+       if (ret) {
+               IL_ERR("Unable to add station %pM (%d)\n", sta->addr, ret);
+               /* Should we return success if return code is EEXIST ? */
+               mutex_unlock(&il->mutex);
+               return ret;
+       }
+
+       sta_priv->common.sta_id = sta_id;
+
+       /* Initialize rate scaling */
+       D_INFO("Initializing rate scaling for station %pM\n", sta->addr);
+       il3945_rs_rate_init(il, sta, sta_id);
+       mutex_unlock(&il->mutex);
+
+       return 0;
+}
+
+static void
+il3945_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
+                       unsigned int *total_flags, u64 multicast)
+{
+       struct il_priv *il = hw->priv;
+       __le32 filter_or = 0, filter_nand = 0;
+
+#define CHK(test, flag)        do { \
+       if (*total_flags & (test))              \
+               filter_or |= (flag);            \
+       else                                    \
+               filter_nand |= (flag);          \
+       } while (0)
+
+       D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n", changed_flags,
+                  *total_flags);
+
+       CHK(FIF_OTHER_BSS, RXON_FILTER_PROMISC_MSK);
+       CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK);
+       CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
+
+#undef CHK
+
+       mutex_lock(&il->mutex);
+
+       il->staging.filter_flags &= ~filter_nand;
+       il->staging.filter_flags |= filter_or;
+
+       /*
+        * Not committing directly because hardware can perform a scan,
+        * but even if hw is ready, committing here breaks for some reason,
+        * we'll eventually commit the filter flags change anyway.
+        */
+
+       mutex_unlock(&il->mutex);
+
+       /*
+        * Receiving all multicast frames is always enabled by the
+        * default flags setup in il_connection_init_rx_config()
+        * since we currently do not support programming multicast
+        * filters into the device.
+        */
+       *total_flags &=
+           FIF_OTHER_BSS | FIF_ALLMULTI |
+           FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
+}
+
+/*****************************************************************************
+ *
+ * sysfs attributes
+ *
+ *****************************************************************************/
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+
+/*
+ * The following adds a new attribute to the sysfs representation
+ * of this device driver (i.e. a new file in /sys/bus/pci/drivers/iwl/)
+ * used for controlling the debug level.
+ *
+ * See the level definitions in iwl for details.
+ *
+ * The debug_level being managed using sysfs below is a per device debug
+ * level that is used instead of the global debug level if it (the per
+ * device debug level) is set.
+ */
+static ssize_t
+il3945_show_debug_level(struct device *d, struct device_attribute *attr,
+                       char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       return sprintf(buf, "0x%08X\n", il_get_debug_level(il));
+}
+
+static ssize_t
+il3945_store_debug_level(struct device *d, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       unsigned long val;
+       int ret;
+
+       ret = kstrtoul(buf, 0, &val);
+       if (ret)
+               IL_INFO("%s is not in hex or decimal form.\n", buf);
+       else
+               il->debug_level = val;
+
+       return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO, il3945_show_debug_level,
+                  il3945_store_debug_level);
+
+#endif /* CONFIG_IWLEGACY_DEBUG */
+
+static ssize_t
+il3945_show_temperature(struct device *d, struct device_attribute *attr,
+                       char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       return sprintf(buf, "%d\n", il3945_hw_get_temperature(il));
+}
+
+static DEVICE_ATTR(temperature, S_IRUGO, il3945_show_temperature, NULL);
+
+static ssize_t
+il3945_show_tx_power(struct device *d, struct device_attribute *attr, char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       return sprintf(buf, "%d\n", il->tx_power_user_lmt);
+}
+
+static ssize_t
+il3945_store_tx_power(struct device *d, struct device_attribute *attr,
+                     const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       char *p = (char *)buf;
+       u32 val;
+
+       val = simple_strtoul(p, &p, 10);
+       if (p == buf)
+               IL_INFO(": %s is not in decimal form.\n", buf);
+       else
+               il3945_hw_reg_set_txpower(il, val);
+
+       return count;
+}
+
+static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, il3945_show_tx_power,
+                  il3945_store_tx_power);
+
+static ssize_t
+il3945_show_flags(struct device *d, struct device_attribute *attr, char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+
+       return sprintf(buf, "0x%04X\n", il->active.flags);
+}
+
+static ssize_t
+il3945_store_flags(struct device *d, struct device_attribute *attr,
+                  const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       u32 flags = simple_strtoul(buf, NULL, 0);
+
+       mutex_lock(&il->mutex);
+       if (le32_to_cpu(il->staging.flags) != flags) {
+               /* Cancel any currently running scans... */
+               if (il_scan_cancel_timeout(il, 100))
+                       IL_WARN("Could not cancel scan.\n");
+               else {
+                       D_INFO("Committing rxon.flags = 0x%04X\n", flags);
+                       il->staging.flags = cpu_to_le32(flags);
+                       il3945_commit_rxon(il);
+               }
+       }
+       mutex_unlock(&il->mutex);
+
+       return count;
+}
+
+static DEVICE_ATTR(flags, S_IWUSR | S_IRUGO, il3945_show_flags,
+                  il3945_store_flags);
+
+static ssize_t
+il3945_show_filter_flags(struct device *d, struct device_attribute *attr,
+                        char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+
+       return sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.filter_flags));
+}
+
+static ssize_t
+il3945_store_filter_flags(struct device *d, struct device_attribute *attr,
+                         const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       u32 filter_flags = simple_strtoul(buf, NULL, 0);
+
+       mutex_lock(&il->mutex);
+       if (le32_to_cpu(il->staging.filter_flags) != filter_flags) {
+               /* Cancel any currently running scans... */
+               if (il_scan_cancel_timeout(il, 100))
+                       IL_WARN("Could not cancel scan.\n");
+               else {
+                       D_INFO("Committing rxon.filter_flags = " "0x%04X\n",
+                              filter_flags);
+                       il->staging.filter_flags = cpu_to_le32(filter_flags);
+                       il3945_commit_rxon(il);
+               }
+       }
+       mutex_unlock(&il->mutex);
+
+       return count;
+}
+
+static DEVICE_ATTR(filter_flags, S_IWUSR | S_IRUGO, il3945_show_filter_flags,
+                  il3945_store_filter_flags);
+
+static ssize_t
+il3945_show_measurement(struct device *d, struct device_attribute *attr,
+                       char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       struct il_spectrum_notification measure_report;
+       u32 size = sizeof(measure_report), len = 0, ofs = 0;
+       u8 *data = (u8 *) &measure_report;
+       unsigned long flags;
+
+       spin_lock_irqsave(&il->lock, flags);
+       if (!(il->measurement_status & MEASUREMENT_READY)) {
+               spin_unlock_irqrestore(&il->lock, flags);
+               return 0;
+       }
+       memcpy(&measure_report, &il->measure_report, size);
+       il->measurement_status = 0;
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       while (size && PAGE_SIZE - len) {
+               hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
+                                  PAGE_SIZE - len, true);
+               len = strlen(buf);
+               if (PAGE_SIZE - len)
+                       buf[len++] = '\n';
+
+               ofs += 16;
+               size -= min(size, 16U);
+       }
+
+       return len;
+}
+
+static ssize_t
+il3945_store_measurement(struct device *d, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       struct ieee80211_measurement_params params = {
+               .channel = le16_to_cpu(il->active.channel),
+               .start_time = cpu_to_le64(il->_3945.last_tsf),
+               .duration = cpu_to_le16(1),
+       };
+       u8 type = IL_MEASURE_BASIC;
+       u8 buffer[32];
+       u8 channel;
+
+       if (count) {
+               char *p = buffer;
+               strlcpy(buffer, buf, sizeof(buffer));
+               channel = simple_strtoul(p, NULL, 0);
+               if (channel)
+                       params.channel = channel;
+
+               p = buffer;
+               while (*p && *p != ' ')
+                       p++;
+               if (*p)
+                       type = simple_strtoul(p + 1, NULL, 0);
+       }
+
+       D_INFO("Invoking measurement of type %d on " "channel %d (for '%s')\n",
+              type, params.channel, buf);
+       il3945_get_measurement(il, &params, type);
+
+       return count;
+}
+
+static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR, il3945_show_measurement,
+                  il3945_store_measurement);
+
+static ssize_t
+il3945_store_retry_rate(struct device *d, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+
+       il->retry_rate = simple_strtoul(buf, NULL, 0);
+       if (il->retry_rate <= 0)
+               il->retry_rate = 1;
+
+       return count;
+}
+
+static ssize_t
+il3945_show_retry_rate(struct device *d, struct device_attribute *attr,
+                      char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       return sprintf(buf, "%d", il->retry_rate);
+}
+
+static DEVICE_ATTR(retry_rate, S_IWUSR | S_IRUSR, il3945_show_retry_rate,
+                  il3945_store_retry_rate);
+
+static ssize_t
+il3945_show_channels(struct device *d, struct device_attribute *attr, char *buf)
+{
+       /* all this shit doesn't belong into sysfs anyway */
+       return 0;
+}
+
+static DEVICE_ATTR(channels, S_IRUSR, il3945_show_channels, NULL);
+
+static ssize_t
+il3945_show_antenna(struct device *d, struct device_attribute *attr, char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       return sprintf(buf, "%d\n", il3945_mod_params.antenna);
+}
+
+static ssize_t
+il3945_store_antenna(struct device *d, struct device_attribute *attr,
+                    const char *buf, size_t count)
+{
+       struct il_priv *il __maybe_unused = dev_get_drvdata(d);
+       int ant;
+
+       if (count == 0)
+               return 0;
+
+       if (sscanf(buf, "%1i", &ant) != 1) {
+               D_INFO("not in hex or decimal form.\n");
+               return count;
+       }
+
+       if (ant >= 0 && ant <= 2) {
+               D_INFO("Setting antenna select to %d.\n", ant);
+               il3945_mod_params.antenna = (enum il3945_antenna)ant;
+       } else
+               D_INFO("Bad antenna select value %d.\n", ant);
+
+       return count;
+}
+
+static DEVICE_ATTR(antenna, S_IWUSR | S_IRUGO, il3945_show_antenna,
+                  il3945_store_antenna);
+
+static ssize_t
+il3945_show_status(struct device *d, struct device_attribute *attr, char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       if (!il_is_alive(il))
+               return -EAGAIN;
+       return sprintf(buf, "0x%08x\n", (int)il->status);
+}
+
+static DEVICE_ATTR(status, S_IRUGO, il3945_show_status, NULL);
+
+static ssize_t
+il3945_dump_error_log(struct device *d, struct device_attribute *attr,
+                     const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       char *p = (char *)buf;
+
+       if (p[0] == '1')
+               il3945_dump_nic_error_log(il);
+
+       return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(dump_errors, S_IWUSR, NULL, il3945_dump_error_log);
+
+/*****************************************************************************
+ *
+ * driver setup and tear down
+ *
+ *****************************************************************************/
+
+static void
+il3945_setup_deferred_work(struct il_priv *il)
+{
+       il->workqueue = create_singlethread_workqueue(DRV_NAME);
+
+       init_waitqueue_head(&il->wait_command_queue);
+
+       INIT_WORK(&il->restart, il3945_bg_restart);
+       INIT_WORK(&il->rx_replenish, il3945_bg_rx_replenish);
+       INIT_DELAYED_WORK(&il->init_alive_start, il3945_bg_init_alive_start);
+       INIT_DELAYED_WORK(&il->alive_start, il3945_bg_alive_start);
+       INIT_DELAYED_WORK(&il->_3945.rfkill_poll, il3945_rfkill_poll);
+
+       il_setup_scan_deferred_work(il);
+
+       il3945_hw_setup_deferred_work(il);
+
+       setup_timer(&il->watchdog, il_bg_watchdog, (unsigned long)il);
+
+       tasklet_init(&il->irq_tasklet,
+                    (void (*)(unsigned long))il3945_irq_tasklet,
+                    (unsigned long)il);
+}
+
+static void
+il3945_cancel_deferred_work(struct il_priv *il)
+{
+       il3945_hw_cancel_deferred_work(il);
+
+       cancel_delayed_work_sync(&il->init_alive_start);
+       cancel_delayed_work(&il->alive_start);
+
+       il_cancel_scan_deferred_work(il);
+}
+
+static struct attribute *il3945_sysfs_entries[] = {
+       &dev_attr_antenna.attr,
+       &dev_attr_channels.attr,
+       &dev_attr_dump_errors.attr,
+       &dev_attr_flags.attr,
+       &dev_attr_filter_flags.attr,
+       &dev_attr_measurement.attr,
+       &dev_attr_retry_rate.attr,
+       &dev_attr_status.attr,
+       &dev_attr_temperature.attr,
+       &dev_attr_tx_power.attr,
+#ifdef CONFIG_IWLEGACY_DEBUG
+       &dev_attr_debug_level.attr,
+#endif
+       NULL
+};
+
+static struct attribute_group il3945_attribute_group = {
+       .name = NULL,           /* put in device directory */
+       .attrs = il3945_sysfs_entries,
+};
+
+static struct ieee80211_ops il3945_mac_ops __read_mostly = {
+       .tx = il3945_mac_tx,
+       .start = il3945_mac_start,
+       .stop = il3945_mac_stop,
+       .add_interface = il_mac_add_interface,
+       .remove_interface = il_mac_remove_interface,
+       .change_interface = il_mac_change_interface,
+       .config = il_mac_config,
+       .configure_filter = il3945_configure_filter,
+       .set_key = il3945_mac_set_key,
+       .conf_tx = il_mac_conf_tx,
+       .reset_tsf = il_mac_reset_tsf,
+       .bss_info_changed = il_mac_bss_info_changed,
+       .hw_scan = il_mac_hw_scan,
+       .sta_add = il3945_mac_sta_add,
+       .sta_remove = il_mac_sta_remove,
+       .tx_last_beacon = il_mac_tx_last_beacon,
+       .flush = il_mac_flush,
+};
+
+static int
+il3945_init_drv(struct il_priv *il)
+{
+       int ret;
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+
+       il->retry_rate = 1;
+       il->beacon_skb = NULL;
+
+       spin_lock_init(&il->sta_lock);
+       spin_lock_init(&il->hcmd_lock);
+
+       INIT_LIST_HEAD(&il->free_frames);
+
+       mutex_init(&il->mutex);
+
+       il->ieee_channels = NULL;
+       il->ieee_rates = NULL;
+       il->band = IEEE80211_BAND_2GHZ;
+
+       il->iw_mode = NL80211_IFTYPE_STATION;
+       il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
+
+       /* initialize force reset */
+       il->force_reset.reset_duration = IL_DELAY_NEXT_FORCE_FW_RELOAD;
+
+       if (eeprom->version < EEPROM_3945_EEPROM_VERSION) {
+               IL_WARN("Unsupported EEPROM version: 0x%04X\n",
+                       eeprom->version);
+               ret = -EINVAL;
+               goto err;
+       }
+       ret = il_init_channel_map(il);
+       if (ret) {
+               IL_ERR("initializing regulatory failed: %d\n", ret);
+               goto err;
+       }
+
+       /* Set up txpower settings in driver for all channels */
+       if (il3945_txpower_set_from_eeprom(il)) {
+               ret = -EIO;
+               goto err_free_channel_map;
+       }
+
+       ret = il_init_geos(il);
+       if (ret) {
+               IL_ERR("initializing geos failed: %d\n", ret);
+               goto err_free_channel_map;
+       }
+       il3945_init_hw_rates(il, il->ieee_rates);
+
+       return 0;
+
+err_free_channel_map:
+       il_free_channel_map(il);
+err:
+       return ret;
+}
+
+#define IL3945_MAX_PROBE_REQUEST       200
+
+static int
+il3945_setup_mac(struct il_priv *il)
+{
+       int ret;
+       struct ieee80211_hw *hw = il->hw;
+
+       hw->rate_control_algorithm = "iwl-3945-rs";
+       hw->sta_data_size = sizeof(struct il3945_sta_priv);
+       hw->vif_data_size = sizeof(struct il_vif_priv);
+
+       /* Tell mac80211 our characteristics */
+       ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
+       ieee80211_hw_set(hw, SUPPORTS_PS);
+       ieee80211_hw_set(hw, SIGNAL_DBM);
+       ieee80211_hw_set(hw, SPECTRUM_MGMT);
+
+       hw->wiphy->interface_modes =
+           BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
+
+       hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
+       hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
+                                      REGULATORY_DISABLE_BEACON_HINTS;
+
+       hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
+
+       hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX_3945;
+       /* we create the 802.11 header and a zero-length SSID element */
+       hw->wiphy->max_scan_ie_len = IL3945_MAX_PROBE_REQUEST - 24 - 2;
+
+       /* Default value; 4 EDCA QOS priorities */
+       hw->queues = 4;
+
+       if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
+               il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
+                   &il->bands[IEEE80211_BAND_2GHZ];
+
+       if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
+               il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
+                   &il->bands[IEEE80211_BAND_5GHZ];
+
+       il_leds_init(il);
+
+       ret = ieee80211_register_hw(il->hw);
+       if (ret) {
+               IL_ERR("Failed to register hw (error %d)\n", ret);
+               return ret;
+       }
+       il->mac80211_registered = 1;
+
+       return 0;
+}
+
+static int
+il3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+       int err = 0;
+       struct il_priv *il;
+       struct ieee80211_hw *hw;
+       struct il_cfg *cfg = (struct il_cfg *)(ent->driver_data);
+       struct il3945_eeprom *eeprom;
+       unsigned long flags;
+
+       /***********************
+        * 1. Allocating HW data
+        * ********************/
+
+       hw = ieee80211_alloc_hw(sizeof(struct il_priv), &il3945_mac_ops);
+       if (!hw) {
+               err = -ENOMEM;
+               goto out;
+       }
+       il = hw->priv;
+       il->hw = hw;
+       SET_IEEE80211_DEV(hw, &pdev->dev);
+
+       il->cmd_queue = IL39_CMD_QUEUE_NUM;
+
+       /*
+        * Disabling hardware scan means that mac80211 will perform scans
+        * "the hard way", rather than using device's scan.
+        */
+       if (il3945_mod_params.disable_hw_scan) {
+               D_INFO("Disabling hw_scan\n");
+               il3945_mac_ops.hw_scan = NULL;
+       }
+
+       D_INFO("*** LOAD DRIVER ***\n");
+       il->cfg = cfg;
+       il->ops = &il3945_ops;
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       il->debugfs_ops = &il3945_debugfs_ops;
+#endif
+       il->pci_dev = pdev;
+       il->inta_mask = CSR_INI_SET_MASK;
+
+       /***************************
+        * 2. Initializing PCI bus
+        * *************************/
+       pci_disable_link_state(pdev,
+                              PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
+                              PCIE_LINK_STATE_CLKPM);
+
+       if (pci_enable_device(pdev)) {
+               err = -ENODEV;
+               goto out_ieee80211_free_hw;
+       }
+
+       pci_set_master(pdev);
+
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+       if (!err)
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+       if (err) {
+               IL_WARN("No suitable DMA available.\n");
+               goto out_pci_disable_device;
+       }
+
+       pci_set_drvdata(pdev, il);
+       err = pci_request_regions(pdev, DRV_NAME);
+       if (err)
+               goto out_pci_disable_device;
+
+       /***********************
+        * 3. Read REV Register
+        * ********************/
+       il->hw_base = pci_ioremap_bar(pdev, 0);
+       if (!il->hw_base) {
+               err = -ENODEV;
+               goto out_pci_release_regions;
+       }
+
+       D_INFO("pci_resource_len = 0x%08llx\n",
+              (unsigned long long)pci_resource_len(pdev, 0));
+       D_INFO("pci_resource_base = %p\n", il->hw_base);
+
+       /* We disable the RETRY_TIMEOUT register (0x41) to keep
+        * PCI Tx retries from interfering with C3 CPU state */
+       pci_write_config_byte(pdev, 0x41, 0x00);
+
+       /* these spin locks will be used in apm_init and EEPROM access
+        * we should init now
+        */
+       spin_lock_init(&il->reg_lock);
+       spin_lock_init(&il->lock);
+
+       /*
+        * stop and reset the on-board processor just in case it is in a
+        * strange state ... like being left stranded by a primary kernel
+        * and this is now the kdump kernel trying to start up
+        */
+       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
+
+       /***********************
+        * 4. Read EEPROM
+        * ********************/
+
+       /* Read the EEPROM */
+       err = il_eeprom_init(il);
+       if (err) {
+               IL_ERR("Unable to init EEPROM\n");
+               goto out_iounmap;
+       }
+       /* MAC Address location in EEPROM same for 3945/4965 */
+       eeprom = (struct il3945_eeprom *)il->eeprom;
+       D_INFO("MAC address: %pM\n", eeprom->mac_address);
+       SET_IEEE80211_PERM_ADDR(il->hw, eeprom->mac_address);
+
+       /***********************
+        * 5. Setup HW Constants
+        * ********************/
+       /* Device-specific setup */
+       err = il3945_hw_set_hw_params(il);
+       if (err) {
+               IL_ERR("failed to set hw settings\n");
+               goto out_eeprom_free;
+       }
+
+       /***********************
+        * 6. Setup il
+        * ********************/
+
+       err = il3945_init_drv(il);
+       if (err) {
+               IL_ERR("initializing driver failed\n");
+               goto out_unset_hw_params;
+       }
+
+       IL_INFO("Detected Intel Wireless WiFi Link %s\n", il->cfg->name);
+
+       /***********************
+        * 7. Setup Services
+        * ********************/
+
+       spin_lock_irqsave(&il->lock, flags);
+       il_disable_interrupts(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       pci_enable_msi(il->pci_dev);
+
+       err = request_irq(il->pci_dev->irq, il_isr, IRQF_SHARED, DRV_NAME, il);
+       if (err) {
+               IL_ERR("Error allocating IRQ %d\n", il->pci_dev->irq);
+               goto out_disable_msi;
+       }
+
+       err = sysfs_create_group(&pdev->dev.kobj, &il3945_attribute_group);
+       if (err) {
+               IL_ERR("failed to create sysfs device attributes\n");
+               goto out_release_irq;
+       }
+
+       il_set_rxon_channel(il, &il->bands[IEEE80211_BAND_2GHZ].channels[5]);
+       il3945_setup_deferred_work(il);
+       il3945_setup_handlers(il);
+       il_power_initialize(il);
+
+       /*********************************
+        * 8. Setup and Register mac80211
+        * *******************************/
+
+       il_enable_interrupts(il);
+
+       err = il3945_setup_mac(il);
+       if (err)
+               goto out_remove_sysfs;
+
+       err = il_dbgfs_register(il, DRV_NAME);
+       if (err)
+               IL_ERR("failed to create debugfs files. Ignoring error: %d\n",
+                      err);
+
+       /* Start monitoring the killswitch */
+       queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll, 2 * HZ);
+
+       return 0;
+
+out_remove_sysfs:
+       destroy_workqueue(il->workqueue);
+       il->workqueue = NULL;
+       sysfs_remove_group(&pdev->dev.kobj, &il3945_attribute_group);
+out_release_irq:
+       free_irq(il->pci_dev->irq, il);
+out_disable_msi:
+       pci_disable_msi(il->pci_dev);
+       il_free_geos(il);
+       il_free_channel_map(il);
+out_unset_hw_params:
+       il3945_unset_hw_params(il);
+out_eeprom_free:
+       il_eeprom_free(il);
+out_iounmap:
+       iounmap(il->hw_base);
+out_pci_release_regions:
+       pci_release_regions(pdev);
+out_pci_disable_device:
+       pci_disable_device(pdev);
+out_ieee80211_free_hw:
+       ieee80211_free_hw(il->hw);
+out:
+       return err;
+}
+
+static void
+il3945_pci_remove(struct pci_dev *pdev)
+{
+       struct il_priv *il = pci_get_drvdata(pdev);
+       unsigned long flags;
+
+       if (!il)
+               return;
+
+       D_INFO("*** UNLOAD DRIVER ***\n");
+
+       il_dbgfs_unregister(il);
+
+       set_bit(S_EXIT_PENDING, &il->status);
+
+       il_leds_exit(il);
+
+       if (il->mac80211_registered) {
+               ieee80211_unregister_hw(il->hw);
+               il->mac80211_registered = 0;
+       } else {
+               il3945_down(il);
+       }
+
+       /*
+        * Make sure device is reset to low power before unloading driver.
+        * This may be redundant with il_down(), but there are paths to
+        * run il_down() without calling apm_ops.stop(), and there are
+        * paths to avoid running il_down() at all before leaving driver.
+        * This (inexpensive) call *makes sure* device is reset.
+        */
+       il_apm_stop(il);
+
+       /* make sure we flush any pending irq or
+        * tasklet for the driver
+        */
+       spin_lock_irqsave(&il->lock, flags);
+       il_disable_interrupts(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       il3945_synchronize_irq(il);
+
+       sysfs_remove_group(&pdev->dev.kobj, &il3945_attribute_group);
+
+       cancel_delayed_work_sync(&il->_3945.rfkill_poll);
+
+       il3945_dealloc_ucode_pci(il);
+
+       if (il->rxq.bd)
+               il3945_rx_queue_free(il, &il->rxq);
+       il3945_hw_txq_ctx_free(il);
+
+       il3945_unset_hw_params(il);
+
+       /*netif_stop_queue(dev); */
+       flush_workqueue(il->workqueue);
+
+       /* ieee80211_unregister_hw calls il3945_mac_stop, which flushes
+        * il->workqueue... so we can't take down the workqueue
+        * until now... */
+       destroy_workqueue(il->workqueue);
+       il->workqueue = NULL;
+
+       free_irq(pdev->irq, il);
+       pci_disable_msi(pdev);
+
+       iounmap(il->hw_base);
+       pci_release_regions(pdev);
+       pci_disable_device(pdev);
+
+       il_free_channel_map(il);
+       il_free_geos(il);
+       kfree(il->scan_cmd);
+       if (il->beacon_skb)
+               dev_kfree_skb(il->beacon_skb);
+
+       ieee80211_free_hw(il->hw);
+}
+
+/*****************************************************************************
+ *
+ * driver and module entry point
+ *
+ *****************************************************************************/
+
+static struct pci_driver il3945_driver = {
+       .name = DRV_NAME,
+       .id_table = il3945_hw_card_ids,
+       .probe = il3945_pci_probe,
+       .remove = il3945_pci_remove,
+       .driver.pm = IL_LEGACY_PM_OPS,
+};
+
+static int __init
+il3945_init(void)
+{
+
+       int ret;
+       pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
+       pr_info(DRV_COPYRIGHT "\n");
+
+       ret = il3945_rate_control_register();
+       if (ret) {
+               pr_err("Unable to register rate control algorithm: %d\n", ret);
+               return ret;
+       }
+
+       ret = pci_register_driver(&il3945_driver);
+       if (ret) {
+               pr_err("Unable to initialize PCI module\n");
+               goto error_register;
+       }
+
+       return ret;
+
+error_register:
+       il3945_rate_control_unregister();
+       return ret;
+}
+
+static void __exit
+il3945_exit(void)
+{
+       pci_unregister_driver(&il3945_driver);
+       il3945_rate_control_unregister();
+}
+
+MODULE_FIRMWARE(IL3945_MODULE_FIRMWARE(IL3945_UCODE_API_MAX));
+
+module_param_named(antenna, il3945_mod_params.antenna, int, S_IRUGO);
+MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
+module_param_named(swcrypto, il3945_mod_params.sw_crypto, int, S_IRUGO);
+MODULE_PARM_DESC(swcrypto, "using software crypto (default 1 [software])");
+module_param_named(disable_hw_scan, il3945_mod_params.disable_hw_scan, int,
+                  S_IRUGO);
+MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 1)");
+#ifdef CONFIG_IWLEGACY_DEBUG
+module_param_named(debug, il_debug_level, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "debug output mask");
+#endif
+module_param_named(fw_restart, il3945_mod_params.restart_fw, int, S_IRUGO);
+MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
+
+module_exit(il3945_exit);
+module_init(il3945_init);
diff --git a/drivers/net/wireless/intel/iwlegacy/3945-rs.c b/drivers/net/wireless/intel/iwlegacy/3945-rs.c
new file mode 100644 (file)
index 0000000..76b0729
--- /dev/null
@@ -0,0 +1,979 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+#include <net/mac80211.h>
+
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/delay.h>
+
+#include <linux/workqueue.h>
+
+#include "commands.h"
+#include "3945.h"
+
+#define RS_NAME "iwl-3945-rs"
+
+static s32 il3945_expected_tpt_g[RATE_COUNT_3945] = {
+       7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202
+};
+
+static s32 il3945_expected_tpt_g_prot[RATE_COUNT_3945] = {
+       7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125
+};
+
+static s32 il3945_expected_tpt_a[RATE_COUNT_3945] = {
+       0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186
+};
+
+static s32 il3945_expected_tpt_b[RATE_COUNT_3945] = {
+       7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+struct il3945_tpt_entry {
+       s8 min_rssi;
+       u8 idx;
+};
+
+static struct il3945_tpt_entry il3945_tpt_table_a[] = {
+       {-60, RATE_54M_IDX},
+       {-64, RATE_48M_IDX},
+       {-72, RATE_36M_IDX},
+       {-80, RATE_24M_IDX},
+       {-84, RATE_18M_IDX},
+       {-85, RATE_12M_IDX},
+       {-87, RATE_9M_IDX},
+       {-89, RATE_6M_IDX}
+};
+
+static struct il3945_tpt_entry il3945_tpt_table_g[] = {
+       {-60, RATE_54M_IDX},
+       {-64, RATE_48M_IDX},
+       {-68, RATE_36M_IDX},
+       {-80, RATE_24M_IDX},
+       {-84, RATE_18M_IDX},
+       {-85, RATE_12M_IDX},
+       {-86, RATE_11M_IDX},
+       {-88, RATE_5M_IDX},
+       {-90, RATE_2M_IDX},
+       {-92, RATE_1M_IDX}
+};
+
+#define RATE_MAX_WINDOW                62
+#define RATE_FLUSH             (3*HZ)
+#define RATE_WIN_FLUSH         (HZ/2)
+#define IL39_RATE_HIGH_TH      11520
+#define IL_SUCCESS_UP_TH       8960
+#define IL_SUCCESS_DOWN_TH     10880
+#define RATE_MIN_FAILURE_TH    6
+#define RATE_MIN_SUCCESS_TH    8
+#define RATE_DECREASE_TH       1920
+#define RATE_RETRY_TH          15
+
+static u8
+il3945_get_rate_idx_by_rssi(s32 rssi, enum ieee80211_band band)
+{
+       u32 idx = 0;
+       u32 table_size = 0;
+       struct il3945_tpt_entry *tpt_table = NULL;
+
+       if (rssi < IL_MIN_RSSI_VAL || rssi > IL_MAX_RSSI_VAL)
+               rssi = IL_MIN_RSSI_VAL;
+
+       switch (band) {
+       case IEEE80211_BAND_2GHZ:
+               tpt_table = il3945_tpt_table_g;
+               table_size = ARRAY_SIZE(il3945_tpt_table_g);
+               break;
+       case IEEE80211_BAND_5GHZ:
+               tpt_table = il3945_tpt_table_a;
+               table_size = ARRAY_SIZE(il3945_tpt_table_a);
+               break;
+       default:
+               BUG();
+               break;
+       }
+
+       while (idx < table_size && rssi < tpt_table[idx].min_rssi)
+               idx++;
+
+       idx = min(idx, table_size - 1);
+
+       return tpt_table[idx].idx;
+}
+
+static void
+il3945_clear_win(struct il3945_rate_scale_data *win)
+{
+       win->data = 0;
+       win->success_counter = 0;
+       win->success_ratio = -1;
+       win->counter = 0;
+       win->average_tpt = IL_INVALID_VALUE;
+       win->stamp = 0;
+}
+
+/**
+ * il3945_rate_scale_flush_wins - flush out the rate scale wins
+ *
+ * Returns the number of wins that have gathered data but were
+ * not flushed.  If there were any that were not flushed, then
+ * reschedule the rate flushing routine.
+ */
+static int
+il3945_rate_scale_flush_wins(struct il3945_rs_sta *rs_sta)
+{
+       int unflushed = 0;
+       int i;
+       unsigned long flags;
+       struct il_priv *il __maybe_unused = rs_sta->il;
+
+       /*
+        * For each rate, if we have collected data on that rate
+        * and it has been more than RATE_WIN_FLUSH
+        * since we flushed, clear out the gathered stats
+        */
+       for (i = 0; i < RATE_COUNT_3945; i++) {
+               if (!rs_sta->win[i].counter)
+                       continue;
+
+               spin_lock_irqsave(&rs_sta->lock, flags);
+               if (time_after(jiffies, rs_sta->win[i].stamp + RATE_WIN_FLUSH)) {
+                       D_RATE("flushing %d samples of rate " "idx %d\n",
+                              rs_sta->win[i].counter, i);
+                       il3945_clear_win(&rs_sta->win[i]);
+               } else
+                       unflushed++;
+               spin_unlock_irqrestore(&rs_sta->lock, flags);
+       }
+
+       return unflushed;
+}
+
+#define RATE_FLUSH_MAX              5000       /* msec */
+#define RATE_FLUSH_MIN              50 /* msec */
+#define IL_AVERAGE_PACKETS             1500
+
+static void
+il3945_bg_rate_scale_flush(unsigned long data)
+{
+       struct il3945_rs_sta *rs_sta = (void *)data;
+       struct il_priv *il __maybe_unused = rs_sta->il;
+       int unflushed = 0;
+       unsigned long flags;
+       u32 packet_count, duration, pps;
+
+       D_RATE("enter\n");
+
+       unflushed = il3945_rate_scale_flush_wins(rs_sta);
+
+       spin_lock_irqsave(&rs_sta->lock, flags);
+
+       /* Number of packets Rx'd since last time this timer ran */
+       packet_count = (rs_sta->tx_packets - rs_sta->last_tx_packets) + 1;
+
+       rs_sta->last_tx_packets = rs_sta->tx_packets + 1;
+
+       if (unflushed) {
+               duration =
+                   jiffies_to_msecs(jiffies - rs_sta->last_partial_flush);
+
+               D_RATE("Tx'd %d packets in %dms\n", packet_count, duration);
+
+               /* Determine packets per second */
+               if (duration)
+                       pps = (packet_count * 1000) / duration;
+               else
+                       pps = 0;
+
+               if (pps) {
+                       duration = (IL_AVERAGE_PACKETS * 1000) / pps;
+                       if (duration < RATE_FLUSH_MIN)
+                               duration = RATE_FLUSH_MIN;
+                       else if (duration > RATE_FLUSH_MAX)
+                               duration = RATE_FLUSH_MAX;
+               } else
+                       duration = RATE_FLUSH_MAX;
+
+               rs_sta->flush_time = msecs_to_jiffies(duration);
+
+               D_RATE("new flush period: %d msec ave %d\n", duration,
+                      packet_count);
+
+               mod_timer(&rs_sta->rate_scale_flush,
+                         jiffies + rs_sta->flush_time);
+
+               rs_sta->last_partial_flush = jiffies;
+       } else {
+               rs_sta->flush_time = RATE_FLUSH;
+               rs_sta->flush_pending = 0;
+       }
+       /* If there weren't any unflushed entries, we don't schedule the timer
+        * to run again */
+
+       rs_sta->last_flush = jiffies;
+
+       spin_unlock_irqrestore(&rs_sta->lock, flags);
+
+       D_RATE("leave\n");
+}
+
+/**
+ * il3945_collect_tx_data - Update the success/failure sliding win
+ *
+ * We keep a sliding win of the last 64 packets transmitted
+ * at this rate.  win->data contains the bitmask of successful
+ * packets.
+ */
+static void
+il3945_collect_tx_data(struct il3945_rs_sta *rs_sta,
+                      struct il3945_rate_scale_data *win, int success,
+                      int retries, int idx)
+{
+       unsigned long flags;
+       s32 fail_count;
+       struct il_priv *il __maybe_unused = rs_sta->il;
+
+       if (!retries) {
+               D_RATE("leave: retries == 0 -- should be at least 1\n");
+               return;
+       }
+
+       spin_lock_irqsave(&rs_sta->lock, flags);
+
+       /*
+        * Keep track of only the latest 62 tx frame attempts in this rate's
+        * history win; anything older isn't really relevant any more.
+        * If we have filled up the sliding win, 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 (win->counter >= RATE_MAX_WINDOW) {
+
+                       /* remove earliest */
+                       win->counter = RATE_MAX_WINDOW - 1;
+
+                       if (win->data & (1ULL << (RATE_MAX_WINDOW - 1))) {
+                               win->data &= ~(1ULL << (RATE_MAX_WINDOW - 1));
+                               win->success_counter--;
+                       }
+               }
+
+               /* Increment frames-attempted counter */
+               win->counter++;
+
+               /* Shift bitmap by one frame (throw away oldest history),
+                * OR in "1", and increment "success" if this
+                * frame was successful. */
+               win->data <<= 1;
+               if (success > 0) {
+                       win->success_counter++;
+                       win->data |= 0x1;
+                       success--;
+               }
+
+               retries--;
+       }
+
+       /* Calculate current success ratio, avoid divide-by-0! */
+       if (win->counter > 0)
+               win->success_ratio =
+                   128 * (100 * win->success_counter) / win->counter;
+       else
+               win->success_ratio = IL_INVALID_VALUE;
+
+       fail_count = win->counter - win->success_counter;
+
+       /* Calculate average throughput, if we have enough history. */
+       if (fail_count >= RATE_MIN_FAILURE_TH ||
+           win->success_counter >= RATE_MIN_SUCCESS_TH)
+               win->average_tpt =
+                   ((win->success_ratio * rs_sta->expected_tpt[idx] +
+                     64) / 128);
+       else
+               win->average_tpt = IL_INVALID_VALUE;
+
+       /* Tag this win as having been updated */
+       win->stamp = jiffies;
+
+       spin_unlock_irqrestore(&rs_sta->lock, flags);
+}
+
+/*
+ * Called after adding a new station to initialize rate scaling
+ */
+void
+il3945_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
+{
+       struct ieee80211_hw *hw = il->hw;
+       struct ieee80211_conf *conf = &il->hw->conf;
+       struct il3945_sta_priv *psta;
+       struct il3945_rs_sta *rs_sta;
+       struct ieee80211_supported_band *sband;
+       int i;
+
+       D_INFO("enter\n");
+       if (sta_id == il->hw_params.bcast_id)
+               goto out;
+
+       psta = (struct il3945_sta_priv *)sta->drv_priv;
+       rs_sta = &psta->rs_sta;
+       sband = hw->wiphy->bands[conf->chandef.chan->band];
+
+       rs_sta->il = il;
+
+       rs_sta->start_rate = RATE_INVALID;
+
+       /* default to just 802.11b */
+       rs_sta->expected_tpt = il3945_expected_tpt_b;
+
+       rs_sta->last_partial_flush = jiffies;
+       rs_sta->last_flush = jiffies;
+       rs_sta->flush_time = RATE_FLUSH;
+       rs_sta->last_tx_packets = 0;
+
+       rs_sta->rate_scale_flush.data = (unsigned long)rs_sta;
+       rs_sta->rate_scale_flush.function = il3945_bg_rate_scale_flush;
+
+       for (i = 0; i < RATE_COUNT_3945; i++)
+               il3945_clear_win(&rs_sta->win[i]);
+
+       /* TODO: what is a good starting rate for STA? About middle? Maybe not
+        * the lowest or the highest rate.. Could consider using RSSI from
+        * previous packets? Need to have IEEE 802.1X auth succeed immediately
+        * after assoc.. */
+
+       for (i = sband->n_bitrates - 1; i >= 0; i--) {
+               if (sta->supp_rates[sband->band] & (1 << i)) {
+                       rs_sta->last_txrate_idx = i;
+                       break;
+               }
+       }
+
+       il->_3945.sta_supp_rates = sta->supp_rates[sband->band];
+       /* For 5 GHz band it start at IL_FIRST_OFDM_RATE */
+       if (sband->band == IEEE80211_BAND_5GHZ) {
+               rs_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
+               il->_3945.sta_supp_rates <<= IL_FIRST_OFDM_RATE;
+       }
+
+out:
+       il->stations[sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
+
+       D_INFO("leave\n");
+}
+
+static void *
+il3945_rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
+{
+       return hw->priv;
+}
+
+/* rate scale requires free function to be implemented */
+static void
+il3945_rs_free(void *il)
+{
+}
+
+static void *
+il3945_rs_alloc_sta(void *il_priv, struct ieee80211_sta *sta, gfp_t gfp)
+{
+       struct il3945_rs_sta *rs_sta;
+       struct il3945_sta_priv *psta = (void *)sta->drv_priv;
+       struct il_priv *il __maybe_unused = il_priv;
+
+       D_RATE("enter\n");
+
+       rs_sta = &psta->rs_sta;
+
+       spin_lock_init(&rs_sta->lock);
+       init_timer(&rs_sta->rate_scale_flush);
+
+       D_RATE("leave\n");
+
+       return rs_sta;
+}
+
+static void
+il3945_rs_free_sta(void *il_priv, struct ieee80211_sta *sta, void *il_sta)
+{
+       struct il3945_rs_sta *rs_sta = il_sta;
+
+       /*
+        * Be careful not to use any members of il3945_rs_sta (like trying
+        * to use il_priv to print out debugging) since it may not be fully
+        * initialized at this point.
+        */
+       del_timer_sync(&rs_sta->rate_scale_flush);
+}
+
+/**
+ * il3945_rs_tx_status - Update rate control values based on Tx results
+ *
+ * NOTE: Uses il_priv->retry_rate for the # of retries attempted by
+ * the hardware for each rate.
+ */
+static void
+il3945_rs_tx_status(void *il_rate, struct ieee80211_supported_band *sband,
+                   struct ieee80211_sta *sta, void *il_sta,
+                   struct sk_buff *skb)
+{
+       s8 retries = 0, current_count;
+       int scale_rate_idx, first_idx, last_idx;
+       unsigned long flags;
+       struct il_priv *il = (struct il_priv *)il_rate;
+       struct il3945_rs_sta *rs_sta = il_sta;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+
+       D_RATE("enter\n");
+
+       retries = info->status.rates[0].count;
+       /* Sanity Check for retries */
+       if (retries > RATE_RETRY_TH)
+               retries = RATE_RETRY_TH;
+
+       first_idx = sband->bitrates[info->status.rates[0].idx].hw_value;
+       if (first_idx < 0 || first_idx >= RATE_COUNT_3945) {
+               D_RATE("leave: Rate out of bounds: %d\n", first_idx);
+               return;
+       }
+
+       if (!il_sta) {
+               D_RATE("leave: No STA il data to update!\n");
+               return;
+       }
+
+       /* Treat uninitialized rate scaling data same as non-existing. */
+       if (!rs_sta->il) {
+               D_RATE("leave: STA il data uninitialized!\n");
+               return;
+       }
+
+       rs_sta->tx_packets++;
+
+       scale_rate_idx = first_idx;
+       last_idx = first_idx;
+
+       /*
+        * Update the win for each rate.  We determine which rates
+        * were Tx'd based on the total number of retries vs. the number
+        * of retries configured for each rate -- currently set to the
+        * il value 'retry_rate' vs. rate specific
+        *
+        * On exit from this while loop last_idx indicates the rate
+        * at which the frame was finally transmitted (or failed if no
+        * ACK)
+        */
+       while (retries > 1) {
+               if ((retries - 1) < il->retry_rate) {
+                       current_count = (retries - 1);
+                       last_idx = scale_rate_idx;
+               } else {
+                       current_count = il->retry_rate;
+                       last_idx = il3945_rs_next_rate(il, scale_rate_idx);
+               }
+
+               /* Update this rate accounting for as many retries
+                * as was used for it (per current_count) */
+               il3945_collect_tx_data(rs_sta, &rs_sta->win[scale_rate_idx], 0,
+                                      current_count, scale_rate_idx);
+               D_RATE("Update rate %d for %d retries.\n", scale_rate_idx,
+                      current_count);
+
+               retries -= current_count;
+
+               scale_rate_idx = last_idx;
+       }
+
+       /* Update the last idx win with success/failure based on ACK */
+       D_RATE("Update rate %d with %s.\n", last_idx,
+              (info->flags & IEEE80211_TX_STAT_ACK) ? "success" : "failure");
+       il3945_collect_tx_data(rs_sta, &rs_sta->win[last_idx],
+                              info->flags & IEEE80211_TX_STAT_ACK, 1,
+                              last_idx);
+
+       /* We updated the rate scale win -- if its been more than
+        * flush_time since the last run, schedule the flush
+        * again */
+       spin_lock_irqsave(&rs_sta->lock, flags);
+
+       if (!rs_sta->flush_pending &&
+           time_after(jiffies, rs_sta->last_flush + rs_sta->flush_time)) {
+
+               rs_sta->last_partial_flush = jiffies;
+               rs_sta->flush_pending = 1;
+               mod_timer(&rs_sta->rate_scale_flush,
+                         jiffies + rs_sta->flush_time);
+       }
+
+       spin_unlock_irqrestore(&rs_sta->lock, flags);
+
+       D_RATE("leave\n");
+}
+
+static u16
+il3945_get_adjacent_rate(struct il3945_rs_sta *rs_sta, u8 idx, u16 rate_mask,
+                        enum ieee80211_band band)
+{
+       u8 high = RATE_INVALID;
+       u8 low = RATE_INVALID;
+       struct il_priv *il __maybe_unused = rs_sta->il;
+
+       /* 802.11A walks to the next literal adjacent rate in
+        * the rate table */
+       if (unlikely(band == IEEE80211_BAND_5GHZ)) {
+               int i;
+               u32 mask;
+
+               /* Find the previous rate that is in the rate mask */
+               i = idx - 1;
+               for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
+                       if (rate_mask & mask) {
+                               low = i;
+                               break;
+                       }
+               }
+
+               /* Find the next rate that is in the rate mask */
+               i = idx + 1;
+               for (mask = (1 << i); i < RATE_COUNT_3945; i++, mask <<= 1) {
+                       if (rate_mask & mask) {
+                               high = i;
+                               break;
+                       }
+               }
+
+               return (high << 8) | low;
+       }
+
+       low = idx;
+       while (low != RATE_INVALID) {
+               if (rs_sta->tgg)
+                       low = il3945_rates[low].prev_rs_tgg;
+               else
+                       low = il3945_rates[low].prev_rs;
+               if (low == RATE_INVALID)
+                       break;
+               if (rate_mask & (1 << low))
+                       break;
+               D_RATE("Skipping masked lower rate: %d\n", low);
+       }
+
+       high = idx;
+       while (high != RATE_INVALID) {
+               if (rs_sta->tgg)
+                       high = il3945_rates[high].next_rs_tgg;
+               else
+                       high = il3945_rates[high].next_rs;
+               if (high == RATE_INVALID)
+                       break;
+               if (rate_mask & (1 << high))
+                       break;
+               D_RATE("Skipping masked higher rate: %d\n", high);
+       }
+
+       return (high << 8) | low;
+}
+
+/**
+ * il3945_rs_get_rate - find the rate for the requested packet
+ *
+ * Returns the ieee80211_rate structure allocated by the driver.
+ *
+ * The rate control algorithm has no internal mapping between hw_mode's
+ * rate ordering and the rate ordering used by the rate control algorithm.
+ *
+ * The rate control algorithm uses a single table of rates that goes across
+ * the entire A/B/G spectrum vs. being limited to just one particular
+ * hw_mode.
+ *
+ * As such, we can't convert the idx obtained below into the hw_mode's
+ * rate table and must reference the driver allocated rate table
+ *
+ */
+static void
+il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
+                  struct ieee80211_tx_rate_control *txrc)
+{
+       struct ieee80211_supported_band *sband = txrc->sband;
+       struct sk_buff *skb = txrc->skb;
+       u8 low = RATE_INVALID;
+       u8 high = RATE_INVALID;
+       u16 high_low;
+       int idx;
+       struct il3945_rs_sta *rs_sta = il_sta;
+       struct il3945_rate_scale_data *win = NULL;
+       int current_tpt = IL_INVALID_VALUE;
+       int low_tpt = IL_INVALID_VALUE;
+       int high_tpt = IL_INVALID_VALUE;
+       u32 fail_count;
+       s8 scale_action = 0;
+       unsigned long flags;
+       u16 rate_mask;
+       s8 max_rate_idx = -1;
+       struct il_priv *il __maybe_unused = (struct il_priv *)il_r;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+
+       D_RATE("enter\n");
+
+       /* Treat uninitialized rate scaling data same as non-existing. */
+       if (rs_sta && !rs_sta->il) {
+               D_RATE("Rate scaling information not initialized yet.\n");
+               il_sta = NULL;
+       }
+
+       if (rate_control_send_low(sta, il_sta, txrc))
+               return;
+
+       rate_mask = sta->supp_rates[sband->band];
+
+       /* get user max rate if set */
+       max_rate_idx = txrc->max_rate_idx;
+       if (sband->band == IEEE80211_BAND_5GHZ && max_rate_idx != -1)
+               max_rate_idx += IL_FIRST_OFDM_RATE;
+       if (max_rate_idx < 0 || max_rate_idx >= RATE_COUNT)
+               max_rate_idx = -1;
+
+       idx = min(rs_sta->last_txrate_idx & 0xffff, RATE_COUNT_3945 - 1);
+
+       if (sband->band == IEEE80211_BAND_5GHZ)
+               rate_mask = rate_mask << IL_FIRST_OFDM_RATE;
+
+       spin_lock_irqsave(&rs_sta->lock, flags);
+
+       /* for recent assoc, choose best rate regarding
+        * to rssi value
+        */
+       if (rs_sta->start_rate != RATE_INVALID) {
+               if (rs_sta->start_rate < idx &&
+                   (rate_mask & (1 << rs_sta->start_rate)))
+                       idx = rs_sta->start_rate;
+               rs_sta->start_rate = RATE_INVALID;
+       }
+
+       /* force user max rate if set by user */
+       if (max_rate_idx != -1 && max_rate_idx < idx) {
+               if (rate_mask & (1 << max_rate_idx))
+                       idx = max_rate_idx;
+       }
+
+       win = &(rs_sta->win[idx]);
+
+       fail_count = win->counter - win->success_counter;
+
+       if (fail_count < RATE_MIN_FAILURE_TH &&
+           win->success_counter < RATE_MIN_SUCCESS_TH) {
+               spin_unlock_irqrestore(&rs_sta->lock, flags);
+
+               D_RATE("Invalid average_tpt on rate %d: "
+                      "counter: %d, success_counter: %d, "
+                      "expected_tpt is %sNULL\n", idx, win->counter,
+                      win->success_counter,
+                      rs_sta->expected_tpt ? "not " : "");
+
+               /* Can't calculate this yet; not enough history */
+               win->average_tpt = IL_INVALID_VALUE;
+               goto out;
+
+       }
+
+       current_tpt = win->average_tpt;
+
+       high_low =
+           il3945_get_adjacent_rate(rs_sta, idx, rate_mask, sband->band);
+       low = high_low & 0xff;
+       high = (high_low >> 8) & 0xff;
+
+       /* If user set max rate, dont allow higher than user constrain */
+       if (max_rate_idx != -1 && max_rate_idx < high)
+               high = RATE_INVALID;
+
+       /* Collect Measured throughputs of adjacent rates */
+       if (low != RATE_INVALID)
+               low_tpt = rs_sta->win[low].average_tpt;
+
+       if (high != RATE_INVALID)
+               high_tpt = rs_sta->win[high].average_tpt;
+
+       spin_unlock_irqrestore(&rs_sta->lock, flags);
+
+       scale_action = 0;
+
+       /* Low success ratio , need to drop the rate */
+       if (win->success_ratio < RATE_DECREASE_TH || !current_tpt) {
+               D_RATE("decrease rate because of low success_ratio\n");
+               scale_action = -1;
+               /* No throughput measured yet for adjacent rates,
+                * try increase */
+       } else if (low_tpt == IL_INVALID_VALUE && high_tpt == IL_INVALID_VALUE) {
+
+               if (high != RATE_INVALID &&
+                   win->success_ratio >= RATE_INCREASE_TH)
+                       scale_action = 1;
+               else if (low != RATE_INVALID)
+                       scale_action = 0;
+
+               /* 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 != IL_INVALID_VALUE && high_tpt != IL_INVALID_VALUE
+                  && low_tpt < current_tpt && high_tpt < current_tpt) {
+
+               D_RATE("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 != IL_INVALID_VALUE) {
+
+                       /* High rate has better throughput, Increase
+                        * rate */
+                       if (high_tpt > current_tpt &&
+                           win->success_ratio >= RATE_INCREASE_TH)
+                               scale_action = 1;
+                       else {
+                               D_RATE("decrease rate because of high tpt\n");
+                               scale_action = 0;
+                       }
+               } else if (low_tpt != IL_INVALID_VALUE) {
+                       if (low_tpt > current_tpt) {
+                               D_RATE("decrease rate because of low tpt\n");
+                               scale_action = -1;
+                       } else if (win->success_ratio >= RATE_INCREASE_TH) {
+                               /* Lower rate has better
+                                * throughput,decrease rate */
+                               scale_action = 1;
+                       }
+               }
+       }
+
+       /* 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 != RATE_INVALID &&
+           (win->success_ratio > RATE_HIGH_TH ||
+            current_tpt > 100 * rs_sta->expected_tpt[low]))
+               scale_action = 0;
+
+       switch (scale_action) {
+       case -1:
+               /* Decrese rate */
+               if (low != RATE_INVALID)
+                       idx = low;
+               break;
+       case 1:
+               /* Increase rate */
+               if (high != RATE_INVALID)
+                       idx = high;
+
+               break;
+       case 0:
+       default:
+               /* No change */
+               break;
+       }
+
+       D_RATE("Selected %d (action %d) - low %d high %d\n", idx, scale_action,
+              low, high);
+
+out:
+
+       if (sband->band == IEEE80211_BAND_5GHZ) {
+               if (WARN_ON_ONCE(idx < IL_FIRST_OFDM_RATE))
+                       idx = IL_FIRST_OFDM_RATE;
+               rs_sta->last_txrate_idx = idx;
+               info->control.rates[0].idx = idx - IL_FIRST_OFDM_RATE;
+       } else {
+               rs_sta->last_txrate_idx = idx;
+               info->control.rates[0].idx = rs_sta->last_txrate_idx;
+       }
+       info->control.rates[0].count = 1;
+
+       D_RATE("leave: %d\n", idx);
+}
+
+#ifdef CONFIG_MAC80211_DEBUGFS
+
+static ssize_t
+il3945_sta_dbgfs_stats_table_read(struct file *file, char __user *user_buf,
+                                 size_t count, loff_t *ppos)
+{
+       char *buff;
+       int desc = 0;
+       int j;
+       ssize_t ret;
+       struct il3945_rs_sta *lq_sta = file->private_data;
+
+       buff = kmalloc(1024, GFP_KERNEL);
+       if (!buff)
+               return -ENOMEM;
+
+       desc +=
+           sprintf(buff + desc,
+                   "tx packets=%d last rate idx=%d\n"
+                   "rate=0x%X flush time %d\n", lq_sta->tx_packets,
+                   lq_sta->last_txrate_idx, lq_sta->start_rate,
+                   jiffies_to_msecs(lq_sta->flush_time));
+       for (j = 0; j < RATE_COUNT_3945; j++) {
+               desc +=
+                   sprintf(buff + desc, "counter=%d success=%d %%=%d\n",
+                           lq_sta->win[j].counter,
+                           lq_sta->win[j].success_counter,
+                           lq_sta->win[j].success_ratio);
+       }
+       ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
+       kfree(buff);
+       return ret;
+}
+
+static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
+       .read = il3945_sta_dbgfs_stats_table_read,
+       .open = simple_open,
+       .llseek = default_llseek,
+};
+
+static void
+il3945_add_debugfs(void *il, void *il_sta, struct dentry *dir)
+{
+       struct il3945_rs_sta *lq_sta = il_sta;
+
+       lq_sta->rs_sta_dbgfs_stats_table_file =
+           debugfs_create_file("rate_stats_table", 0600, dir, lq_sta,
+                               &rs_sta_dbgfs_stats_table_ops);
+
+}
+
+static void
+il3945_remove_debugfs(void *il, void *il_sta)
+{
+       struct il3945_rs_sta *lq_sta = il_sta;
+       debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
+}
+#endif
+
+/*
+ * Initialization of rate scaling information is done by driver after
+ * the station is added. Since mac80211 calls this function before a
+ * station is added we ignore it.
+ */
+static void
+il3945_rs_rate_init_stub(void *il_r, struct ieee80211_supported_band *sband,
+                        struct cfg80211_chan_def *chandef,
+                        struct ieee80211_sta *sta, void *il_sta)
+{
+}
+
+static const struct rate_control_ops rs_ops = {
+       .name = RS_NAME,
+       .tx_status = il3945_rs_tx_status,
+       .get_rate = il3945_rs_get_rate,
+       .rate_init = il3945_rs_rate_init_stub,
+       .alloc = il3945_rs_alloc,
+       .free = il3945_rs_free,
+       .alloc_sta = il3945_rs_alloc_sta,
+       .free_sta = il3945_rs_free_sta,
+#ifdef CONFIG_MAC80211_DEBUGFS
+       .add_sta_debugfs = il3945_add_debugfs,
+       .remove_sta_debugfs = il3945_remove_debugfs,
+#endif
+
+};
+
+void
+il3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
+{
+       struct il_priv *il = hw->priv;
+       s32 rssi = 0;
+       unsigned long flags;
+       struct il3945_rs_sta *rs_sta;
+       struct ieee80211_sta *sta;
+       struct il3945_sta_priv *psta;
+
+       D_RATE("enter\n");
+
+       rcu_read_lock();
+
+       sta = ieee80211_find_sta(il->vif, il->stations[sta_id].sta.sta.addr);
+       if (!sta) {
+               D_RATE("Unable to find station to initialize rate scaling.\n");
+               rcu_read_unlock();
+               return;
+       }
+
+       psta = (void *)sta->drv_priv;
+       rs_sta = &psta->rs_sta;
+
+       spin_lock_irqsave(&rs_sta->lock, flags);
+
+       rs_sta->tgg = 0;
+       switch (il->band) {
+       case IEEE80211_BAND_2GHZ:
+               /* TODO: this always does G, not a regression */
+               if (il->active.flags & RXON_FLG_TGG_PROTECT_MSK) {
+                       rs_sta->tgg = 1;
+                       rs_sta->expected_tpt = il3945_expected_tpt_g_prot;
+               } else
+                       rs_sta->expected_tpt = il3945_expected_tpt_g;
+               break;
+       case IEEE80211_BAND_5GHZ:
+               rs_sta->expected_tpt = il3945_expected_tpt_a;
+               break;
+       default:
+               BUG();
+               break;
+       }
+
+       spin_unlock_irqrestore(&rs_sta->lock, flags);
+
+       rssi = il->_3945.last_rx_rssi;
+       if (rssi == 0)
+               rssi = IL_MIN_RSSI_VAL;
+
+       D_RATE("Network RSSI: %d\n", rssi);
+
+       rs_sta->start_rate = il3945_get_rate_idx_by_rssi(rssi, il->band);
+
+       D_RATE("leave: rssi %d assign rate idx: " "%d (plcp 0x%x)\n", rssi,
+              rs_sta->start_rate, il3945_rates[rs_sta->start_rate].plcp);
+       rcu_read_unlock();
+}
+
+int
+il3945_rate_control_register(void)
+{
+       return ieee80211_rate_control_register(&rs_ops);
+}
+
+void
+il3945_rate_control_unregister(void)
+{
+       ieee80211_rate_control_unregister(&rs_ops);
+}
diff --git a/drivers/net/wireless/intel/iwlegacy/3945.c b/drivers/net/wireless/intel/iwlegacy/3945.c
new file mode 100644 (file)
index 0000000..93bdf68
--- /dev/null
@@ -0,0 +1,2741 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+#include <linux/firmware.h>
+#include <linux/etherdevice.h>
+#include <asm/unaligned.h>
+#include <net/mac80211.h>
+
+#include "common.h"
+#include "3945.h"
+
+/* Send led command */
+static int
+il3945_send_led_cmd(struct il_priv *il, struct il_led_cmd *led_cmd)
+{
+       struct il_host_cmd cmd = {
+               .id = C_LEDS,
+               .len = sizeof(struct il_led_cmd),
+               .data = led_cmd,
+               .flags = CMD_ASYNC,
+               .callback = NULL,
+       };
+
+       return il_send_cmd(il, &cmd);
+}
+
+#define IL_DECLARE_RATE_INFO(r, ip, in, rp, rn, pp, np)    \
+       [RATE_##r##M_IDX] = { RATE_##r##M_PLCP,   \
+                                   RATE_##r##M_IEEE,   \
+                                   RATE_##ip##M_IDX, \
+                                   RATE_##in##M_IDX, \
+                                   RATE_##rp##M_IDX, \
+                                   RATE_##rn##M_IDX, \
+                                   RATE_##pp##M_IDX, \
+                                   RATE_##np##M_IDX, \
+                                   RATE_##r##M_IDX_TBL, \
+                                   RATE_##ip##M_IDX_TBL }
+
+/*
+ * Parameter order:
+ *   rate, prev rate, next rate, prev tgg rate, next tgg rate
+ *
+ * If there isn't a valid next or previous rate then INV is used which
+ * maps to RATE_INVALID
+ *
+ */
+const struct il3945_rate_info il3945_rates[RATE_COUNT_3945] = {
+       IL_DECLARE_RATE_INFO(1, INV, 2, INV, 2, INV, 2),        /*  1mbps */
+       IL_DECLARE_RATE_INFO(2, 1, 5, 1, 5, 1, 5),      /*  2mbps */
+       IL_DECLARE_RATE_INFO(5, 2, 6, 2, 11, 2, 11),    /*5.5mbps */
+       IL_DECLARE_RATE_INFO(11, 9, 12, 5, 12, 5, 18),  /* 11mbps */
+       IL_DECLARE_RATE_INFO(6, 5, 9, 5, 11, 5, 11),    /*  6mbps */
+       IL_DECLARE_RATE_INFO(9, 6, 11, 5, 11, 5, 11),   /*  9mbps */
+       IL_DECLARE_RATE_INFO(12, 11, 18, 11, 18, 11, 18),       /* 12mbps */
+       IL_DECLARE_RATE_INFO(18, 12, 24, 12, 24, 11, 24),       /* 18mbps */
+       IL_DECLARE_RATE_INFO(24, 18, 36, 18, 36, 18, 36),       /* 24mbps */
+       IL_DECLARE_RATE_INFO(36, 24, 48, 24, 48, 24, 48),       /* 36mbps */
+       IL_DECLARE_RATE_INFO(48, 36, 54, 36, 54, 36, 54),       /* 48mbps */
+       IL_DECLARE_RATE_INFO(54, 48, INV, 48, INV, 48, INV),    /* 54mbps */
+};
+
+static inline u8
+il3945_get_prev_ieee_rate(u8 rate_idx)
+{
+       u8 rate = il3945_rates[rate_idx].prev_ieee;
+
+       if (rate == RATE_INVALID)
+               rate = rate_idx;
+       return rate;
+}
+
+/* 1 = enable the il3945_disable_events() function */
+#define IL_EVT_DISABLE (0)
+#define IL_EVT_DISABLE_SIZE (1532/32)
+
+/**
+ * il3945_disable_events - Disable selected events in uCode event log
+ *
+ * Disable an event by writing "1"s into "disable"
+ *   bitmap in SRAM.  Bit position corresponds to Event # (id/type).
+ *   Default values of 0 enable uCode events to be logged.
+ * Use for only special debugging.  This function is just a placeholder as-is,
+ *   you'll need to provide the special bits! ...
+ *   ... and set IL_EVT_DISABLE to 1. */
+void
+il3945_disable_events(struct il_priv *il)
+{
+       int i;
+       u32 base;               /* SRAM address of event log header */
+       u32 disable_ptr;        /* SRAM address of event-disable bitmap array */
+       u32 array_size;         /* # of u32 entries in array */
+       static const u32 evt_disable[IL_EVT_DISABLE_SIZE] = {
+               0x00000000,     /*   31 -    0  Event id numbers */
+               0x00000000,     /*   63 -   32 */
+               0x00000000,     /*   95 -   64 */
+               0x00000000,     /*  127 -   96 */
+               0x00000000,     /*  159 -  128 */
+               0x00000000,     /*  191 -  160 */
+               0x00000000,     /*  223 -  192 */
+               0x00000000,     /*  255 -  224 */
+               0x00000000,     /*  287 -  256 */
+               0x00000000,     /*  319 -  288 */
+               0x00000000,     /*  351 -  320 */
+               0x00000000,     /*  383 -  352 */
+               0x00000000,     /*  415 -  384 */
+               0x00000000,     /*  447 -  416 */
+               0x00000000,     /*  479 -  448 */
+               0x00000000,     /*  511 -  480 */
+               0x00000000,     /*  543 -  512 */
+               0x00000000,     /*  575 -  544 */
+               0x00000000,     /*  607 -  576 */
+               0x00000000,     /*  639 -  608 */
+               0x00000000,     /*  671 -  640 */
+               0x00000000,     /*  703 -  672 */
+               0x00000000,     /*  735 -  704 */
+               0x00000000,     /*  767 -  736 */
+               0x00000000,     /*  799 -  768 */
+               0x00000000,     /*  831 -  800 */
+               0x00000000,     /*  863 -  832 */
+               0x00000000,     /*  895 -  864 */
+               0x00000000,     /*  927 -  896 */
+               0x00000000,     /*  959 -  928 */
+               0x00000000,     /*  991 -  960 */
+               0x00000000,     /* 1023 -  992 */
+               0x00000000,     /* 1055 - 1024 */
+               0x00000000,     /* 1087 - 1056 */
+               0x00000000,     /* 1119 - 1088 */
+               0x00000000,     /* 1151 - 1120 */
+               0x00000000,     /* 1183 - 1152 */
+               0x00000000,     /* 1215 - 1184 */
+               0x00000000,     /* 1247 - 1216 */
+               0x00000000,     /* 1279 - 1248 */
+               0x00000000,     /* 1311 - 1280 */
+               0x00000000,     /* 1343 - 1312 */
+               0x00000000,     /* 1375 - 1344 */
+               0x00000000,     /* 1407 - 1376 */
+               0x00000000,     /* 1439 - 1408 */
+               0x00000000,     /* 1471 - 1440 */
+               0x00000000,     /* 1503 - 1472 */
+       };
+
+       base = le32_to_cpu(il->card_alive.log_event_table_ptr);
+       if (!il3945_hw_valid_rtc_data_addr(base)) {
+               IL_ERR("Invalid event log pointer 0x%08X\n", base);
+               return;
+       }
+
+       disable_ptr = il_read_targ_mem(il, base + (4 * sizeof(u32)));
+       array_size = il_read_targ_mem(il, base + (5 * sizeof(u32)));
+
+       if (IL_EVT_DISABLE && array_size == IL_EVT_DISABLE_SIZE) {
+               D_INFO("Disabling selected uCode log events at 0x%x\n",
+                      disable_ptr);
+               for (i = 0; i < IL_EVT_DISABLE_SIZE; i++)
+                       il_write_targ_mem(il, disable_ptr + (i * sizeof(u32)),
+                                         evt_disable[i]);
+
+       } else {
+               D_INFO("Selected uCode log events may be disabled\n");
+               D_INFO("  by writing \"1\"s into disable bitmap\n");
+               D_INFO("  in SRAM at 0x%x, size %d u32s\n", disable_ptr,
+                      array_size);
+       }
+
+}
+
+static int
+il3945_hwrate_to_plcp_idx(u8 plcp)
+{
+       int idx;
+
+       for (idx = 0; idx < RATE_COUNT_3945; idx++)
+               if (il3945_rates[idx].plcp == plcp)
+                       return idx;
+       return -1;
+}
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+#define TX_STATUS_ENTRY(x) case TX_3945_STATUS_FAIL_ ## x: return #x
+
+static const char *
+il3945_get_tx_fail_reason(u32 status)
+{
+       switch (status & TX_STATUS_MSK) {
+       case TX_3945_STATUS_SUCCESS:
+               return "SUCCESS";
+               TX_STATUS_ENTRY(SHORT_LIMIT);
+               TX_STATUS_ENTRY(LONG_LIMIT);
+               TX_STATUS_ENTRY(FIFO_UNDERRUN);
+               TX_STATUS_ENTRY(MGMNT_ABORT);
+               TX_STATUS_ENTRY(NEXT_FRAG);
+               TX_STATUS_ENTRY(LIFE_EXPIRE);
+               TX_STATUS_ENTRY(DEST_PS);
+               TX_STATUS_ENTRY(ABORTED);
+               TX_STATUS_ENTRY(BT_RETRY);
+               TX_STATUS_ENTRY(STA_INVALID);
+               TX_STATUS_ENTRY(FRAG_DROPPED);
+               TX_STATUS_ENTRY(TID_DISABLE);
+               TX_STATUS_ENTRY(FRAME_FLUSHED);
+               TX_STATUS_ENTRY(INSUFFICIENT_CF_POLL);
+               TX_STATUS_ENTRY(TX_LOCKED);
+               TX_STATUS_ENTRY(NO_BEACON_ON_RADAR);
+       }
+
+       return "UNKNOWN";
+}
+#else
+static inline const char *
+il3945_get_tx_fail_reason(u32 status)
+{
+       return "";
+}
+#endif
+
+/*
+ * get ieee prev rate from rate scale table.
+ * for A and B mode we need to overright prev
+ * value
+ */
+int
+il3945_rs_next_rate(struct il_priv *il, int rate)
+{
+       int next_rate = il3945_get_prev_ieee_rate(rate);
+
+       switch (il->band) {
+       case IEEE80211_BAND_5GHZ:
+               if (rate == RATE_12M_IDX)
+                       next_rate = RATE_9M_IDX;
+               else if (rate == RATE_6M_IDX)
+                       next_rate = RATE_6M_IDX;
+               break;
+       case IEEE80211_BAND_2GHZ:
+               if (!(il->_3945.sta_supp_rates & IL_OFDM_RATES_MASK) &&
+                   il_is_associated(il)) {
+                       if (rate == RATE_11M_IDX)
+                               next_rate = RATE_5M_IDX;
+               }
+               break;
+
+       default:
+               break;
+       }
+
+       return next_rate;
+}
+
+/**
+ * il3945_tx_queue_reclaim - Reclaim Tx queue entries already Tx'd
+ *
+ * When FW advances 'R' idx, all entries between old and new 'R' idx
+ * need to be reclaimed. As result, some free space forms. If there is
+ * enough free space (> low mark), wake the stack that feeds us.
+ */
+static void
+il3945_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
+{
+       struct il_tx_queue *txq = &il->txq[txq_id];
+       struct il_queue *q = &txq->q;
+       struct sk_buff *skb;
+
+       BUG_ON(txq_id == IL39_CMD_QUEUE_NUM);
+
+       for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
+            q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
+
+               skb = txq->skbs[txq->q.read_ptr];
+               ieee80211_tx_status_irqsafe(il->hw, skb);
+               txq->skbs[txq->q.read_ptr] = NULL;
+               il->ops->txq_free_tfd(il, txq);
+       }
+
+       if (il_queue_space(q) > q->low_mark && txq_id >= 0 &&
+           txq_id != IL39_CMD_QUEUE_NUM && il->mac80211_registered)
+               il_wake_queue(il, txq);
+}
+
+/**
+ * il3945_hdl_tx - Handle Tx response
+ */
+static void
+il3945_hdl_tx(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       u16 sequence = le16_to_cpu(pkt->hdr.sequence);
+       int txq_id = SEQ_TO_QUEUE(sequence);
+       int idx = SEQ_TO_IDX(sequence);
+       struct il_tx_queue *txq = &il->txq[txq_id];
+       struct ieee80211_tx_info *info;
+       struct il3945_tx_resp *tx_resp = (void *)&pkt->u.raw[0];
+       u32 status = le32_to_cpu(tx_resp->status);
+       int rate_idx;
+       int fail;
+
+       if (idx >= txq->q.n_bd || il_queue_used(&txq->q, idx) == 0) {
+               IL_ERR("Read idx for DMA queue txq_id (%d) idx %d "
+                      "is out of range [0-%d] %d %d\n", txq_id, idx,
+                      txq->q.n_bd, txq->q.write_ptr, txq->q.read_ptr);
+               return;
+       }
+
+       /*
+        * Firmware will not transmit frame on passive channel, if it not yet
+        * received some valid frame on that channel. When this error happen
+        * we have to wait until firmware will unblock itself i.e. when we
+        * note received beacon or other frame. We unblock queues in
+        * il3945_pass_packet_to_mac80211 or in il_mac_bss_info_changed.
+        */
+       if (unlikely((status & TX_STATUS_MSK) == TX_STATUS_FAIL_PASSIVE_NO_RX) &&
+           il->iw_mode == NL80211_IFTYPE_STATION) {
+               il_stop_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
+               D_INFO("Stopped queues - RX waiting on passive channel\n");
+       }
+
+       txq->time_stamp = jiffies;
+       info = IEEE80211_SKB_CB(txq->skbs[txq->q.read_ptr]);
+       ieee80211_tx_info_clear_status(info);
+
+       /* Fill the MRR chain with some info about on-chip retransmissions */
+       rate_idx = il3945_hwrate_to_plcp_idx(tx_resp->rate);
+       if (info->band == IEEE80211_BAND_5GHZ)
+               rate_idx -= IL_FIRST_OFDM_RATE;
+
+       fail = tx_resp->failure_frame;
+
+       info->status.rates[0].idx = rate_idx;
+       info->status.rates[0].count = fail + 1; /* add final attempt */
+
+       /* tx_status->rts_retry_count = tx_resp->failure_rts; */
+       info->flags |=
+           ((status & TX_STATUS_MSK) ==
+            TX_STATUS_SUCCESS) ? IEEE80211_TX_STAT_ACK : 0;
+
+       D_TX("Tx queue %d Status %s (0x%08x) plcp rate %d retries %d\n", txq_id,
+            il3945_get_tx_fail_reason(status), status, tx_resp->rate,
+            tx_resp->failure_frame);
+
+       D_TX_REPLY("Tx queue reclaim %d\n", idx);
+       il3945_tx_queue_reclaim(il, txq_id, idx);
+
+       if (status & TX_ABORT_REQUIRED_MSK)
+               IL_ERR("TODO:  Implement Tx ABORT REQUIRED!!!\n");
+}
+
+/*****************************************************************************
+ *
+ * Intel PRO/Wireless 3945ABG/BG Network Connection
+ *
+ *  RX handler implementations
+ *
+ *****************************************************************************/
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+static void
+il3945_accumulative_stats(struct il_priv *il, __le32 * stats)
+{
+       int i;
+       __le32 *prev_stats;
+       u32 *accum_stats;
+       u32 *delta, *max_delta;
+
+       prev_stats = (__le32 *) &il->_3945.stats;
+       accum_stats = (u32 *) &il->_3945.accum_stats;
+       delta = (u32 *) &il->_3945.delta_stats;
+       max_delta = (u32 *) &il->_3945.max_delta;
+
+       for (i = sizeof(__le32); i < sizeof(struct il3945_notif_stats);
+            i +=
+            sizeof(__le32), stats++, prev_stats++, delta++, max_delta++,
+            accum_stats++) {
+               if (le32_to_cpu(*stats) > le32_to_cpu(*prev_stats)) {
+                       *delta =
+                           (le32_to_cpu(*stats) - le32_to_cpu(*prev_stats));
+                       *accum_stats += *delta;
+                       if (*delta > *max_delta)
+                               *max_delta = *delta;
+               }
+       }
+
+       /* reset accumulative stats for "no-counter" type stats */
+       il->_3945.accum_stats.general.temperature =
+           il->_3945.stats.general.temperature;
+       il->_3945.accum_stats.general.ttl_timestamp =
+           il->_3945.stats.general.ttl_timestamp;
+}
+#endif
+
+void
+il3945_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+
+       D_RX("Statistics notification received (%d vs %d).\n",
+            (int)sizeof(struct il3945_notif_stats),
+            le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK);
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       il3945_accumulative_stats(il, (__le32 *) &pkt->u.raw);
+#endif
+
+       memcpy(&il->_3945.stats, pkt->u.raw, sizeof(il->_3945.stats));
+}
+
+void
+il3945_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       __le32 *flag = (__le32 *) &pkt->u.raw;
+
+       if (le32_to_cpu(*flag) & UCODE_STATS_CLEAR_MSK) {
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+               memset(&il->_3945.accum_stats, 0,
+                      sizeof(struct il3945_notif_stats));
+               memset(&il->_3945.delta_stats, 0,
+                      sizeof(struct il3945_notif_stats));
+               memset(&il->_3945.max_delta, 0,
+                      sizeof(struct il3945_notif_stats));
+#endif
+               D_RX("Statistics have been cleared\n");
+       }
+       il3945_hdl_stats(il, rxb);
+}
+
+/******************************************************************************
+ *
+ * Misc. internal state and helper functions
+ *
+ ******************************************************************************/
+
+/* This is necessary only for a number of stats, see the caller. */
+static int
+il3945_is_network_packet(struct il_priv *il, struct ieee80211_hdr *header)
+{
+       /* Filter incoming packets to determine if they are targeted toward
+        * this network, discarding packets coming from ourselves */
+       switch (il->iw_mode) {
+       case NL80211_IFTYPE_ADHOC:      /* Header: Dest. | Source    | BSSID */
+               /* packets to our IBSS update information */
+               return ether_addr_equal_64bits(header->addr3, il->bssid);
+       case NL80211_IFTYPE_STATION:    /* Header: Dest. | AP{BSSID} | Source */
+               /* packets to our IBSS update information */
+               return ether_addr_equal_64bits(header->addr2, il->bssid);
+       default:
+               return 1;
+       }
+}
+
+#define SMALL_PACKET_SIZE 256
+
+static void
+il3945_pass_packet_to_mac80211(struct il_priv *il, struct il_rx_buf *rxb,
+                              struct ieee80211_rx_status *stats)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)IL_RX_DATA(pkt);
+       struct il3945_rx_frame_hdr *rx_hdr = IL_RX_HDR(pkt);
+       struct il3945_rx_frame_end *rx_end = IL_RX_END(pkt);
+       u32 len = le16_to_cpu(rx_hdr->len);
+       struct sk_buff *skb;
+       __le16 fc = hdr->frame_control;
+       u32 fraglen = PAGE_SIZE << il->hw_params.rx_page_order;
+
+       /* We received data from the HW, so stop the watchdog */
+       if (unlikely(len + IL39_RX_FRAME_SIZE > fraglen)) {
+               D_DROP("Corruption detected!\n");
+               return;
+       }
+
+       /* We only process data packets if the interface is open */
+       if (unlikely(!il->is_open)) {
+               D_DROP("Dropping packet while interface is not open.\n");
+               return;
+       }
+
+       if (unlikely(test_bit(IL_STOP_REASON_PASSIVE, &il->stop_reason))) {
+               il_wake_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
+               D_INFO("Woke queues - frame received on passive channel\n");
+       }
+
+       skb = dev_alloc_skb(SMALL_PACKET_SIZE);
+       if (!skb) {
+               IL_ERR("dev_alloc_skb failed\n");
+               return;
+       }
+
+       if (!il3945_mod_params.sw_crypto)
+               il_set_decrypted_flag(il, (struct ieee80211_hdr *)pkt,
+                                     le32_to_cpu(rx_end->status), stats);
+
+       /* If frame is small enough to fit into skb->head, copy it
+        * and do not consume a full page
+        */
+       if (len <= SMALL_PACKET_SIZE) {
+               memcpy(skb_put(skb, len), rx_hdr->payload, len);
+       } else {
+               skb_add_rx_frag(skb, 0, rxb->page,
+                               (void *)rx_hdr->payload - (void *)pkt, len,
+                               fraglen);
+               il->alloc_rxb_page--;
+               rxb->page = NULL;
+       }
+       il_update_stats(il, false, fc, len);
+       memcpy(IEEE80211_SKB_RXCB(skb), stats, sizeof(*stats));
+
+       ieee80211_rx(il->hw, skb);
+}
+
+#define IL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
+
+static void
+il3945_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct ieee80211_hdr *header;
+       struct ieee80211_rx_status rx_status = {};
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il3945_rx_frame_stats *rx_stats = IL_RX_STATS(pkt);
+       struct il3945_rx_frame_hdr *rx_hdr = IL_RX_HDR(pkt);
+       struct il3945_rx_frame_end *rx_end = IL_RX_END(pkt);
+       u16 rx_stats_sig_avg __maybe_unused = le16_to_cpu(rx_stats->sig_avg);
+       u16 rx_stats_noise_diff __maybe_unused =
+           le16_to_cpu(rx_stats->noise_diff);
+       u8 network_packet;
+
+       rx_status.flag = 0;
+       rx_status.mactime = le64_to_cpu(rx_end->timestamp);
+       rx_status.band =
+           (rx_hdr->
+            phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
+           IEEE80211_BAND_5GHZ;
+       rx_status.freq =
+           ieee80211_channel_to_frequency(le16_to_cpu(rx_hdr->channel),
+                                          rx_status.band);
+
+       rx_status.rate_idx = il3945_hwrate_to_plcp_idx(rx_hdr->rate);
+       if (rx_status.band == IEEE80211_BAND_5GHZ)
+               rx_status.rate_idx -= IL_FIRST_OFDM_RATE;
+
+       rx_status.antenna =
+           (le16_to_cpu(rx_hdr->phy_flags) & RX_RES_PHY_FLAGS_ANTENNA_MSK) >>
+           4;
+
+       /* set the preamble flag if appropriate */
+       if (rx_hdr->phy_flags & RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK)
+               rx_status.flag |= RX_FLAG_SHORTPRE;
+
+       if ((unlikely(rx_stats->phy_count > 20))) {
+               D_DROP("dsp size out of range [0,20]: %d\n",
+                      rx_stats->phy_count);
+               return;
+       }
+
+       if (!(rx_end->status & RX_RES_STATUS_NO_CRC32_ERROR) ||
+           !(rx_end->status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
+               D_RX("Bad CRC or FIFO: 0x%08X.\n", rx_end->status);
+               return;
+       }
+
+       /* Convert 3945's rssi indicator to dBm */
+       rx_status.signal = rx_stats->rssi - IL39_RSSI_OFFSET;
+
+       D_STATS("Rssi %d sig_avg %d noise_diff %d\n", rx_status.signal,
+               rx_stats_sig_avg, rx_stats_noise_diff);
+
+       header = (struct ieee80211_hdr *)IL_RX_DATA(pkt);
+
+       network_packet = il3945_is_network_packet(il, header);
+
+       D_STATS("[%c] %d RSSI:%d Signal:%u, Rate:%u\n",
+               network_packet ? '*' : ' ', le16_to_cpu(rx_hdr->channel),
+               rx_status.signal, rx_status.signal, rx_status.rate_idx);
+
+       if (network_packet) {
+               il->_3945.last_beacon_time =
+                   le32_to_cpu(rx_end->beacon_timestamp);
+               il->_3945.last_tsf = le64_to_cpu(rx_end->timestamp);
+               il->_3945.last_rx_rssi = rx_status.signal;
+       }
+
+       il3945_pass_packet_to_mac80211(il, rxb, &rx_status);
+}
+
+int
+il3945_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
+                               dma_addr_t addr, u16 len, u8 reset, u8 pad)
+{
+       int count;
+       struct il_queue *q;
+       struct il3945_tfd *tfd, *tfd_tmp;
+
+       q = &txq->q;
+       tfd_tmp = (struct il3945_tfd *)txq->tfds;
+       tfd = &tfd_tmp[q->write_ptr];
+
+       if (reset)
+               memset(tfd, 0, sizeof(*tfd));
+
+       count = TFD_CTL_COUNT_GET(le32_to_cpu(tfd->control_flags));
+
+       if (count >= NUM_TFD_CHUNKS || count < 0) {
+               IL_ERR("Error can not send more than %d chunks\n",
+                      NUM_TFD_CHUNKS);
+               return -EINVAL;
+       }
+
+       tfd->tbs[count].addr = cpu_to_le32(addr);
+       tfd->tbs[count].len = cpu_to_le32(len);
+
+       count++;
+
+       tfd->control_flags =
+           cpu_to_le32(TFD_CTL_COUNT_SET(count) | TFD_CTL_PAD_SET(pad));
+
+       return 0;
+}
+
+/**
+ * il3945_hw_txq_free_tfd - Free one TFD, those at idx [txq->q.read_ptr]
+ *
+ * Does NOT advance any idxes
+ */
+void
+il3945_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
+{
+       struct il3945_tfd *tfd_tmp = (struct il3945_tfd *)txq->tfds;
+       int idx = txq->q.read_ptr;
+       struct il3945_tfd *tfd = &tfd_tmp[idx];
+       struct pci_dev *dev = il->pci_dev;
+       int i;
+       int counter;
+
+       /* sanity check */
+       counter = TFD_CTL_COUNT_GET(le32_to_cpu(tfd->control_flags));
+       if (counter > NUM_TFD_CHUNKS) {
+               IL_ERR("Too many chunks: %i\n", counter);
+               /* @todo issue fatal error, it is quite serious situation */
+               return;
+       }
+
+       /* Unmap tx_cmd */
+       if (counter)
+               pci_unmap_single(dev, dma_unmap_addr(&txq->meta[idx], mapping),
+                                dma_unmap_len(&txq->meta[idx], len),
+                                PCI_DMA_TODEVICE);
+
+       /* unmap chunks if any */
+
+       for (i = 1; i < counter; i++)
+               pci_unmap_single(dev, le32_to_cpu(tfd->tbs[i].addr),
+                                le32_to_cpu(tfd->tbs[i].len),
+                                PCI_DMA_TODEVICE);
+
+       /* free SKB */
+       if (txq->skbs) {
+               struct sk_buff *skb = txq->skbs[txq->q.read_ptr];
+
+               /* can be called from irqs-disabled context */
+               if (skb) {
+                       dev_kfree_skb_any(skb);
+                       txq->skbs[txq->q.read_ptr] = NULL;
+               }
+       }
+}
+
+/**
+ * il3945_hw_build_tx_cmd_rate - Add rate portion to TX_CMD:
+ *
+*/
+void
+il3945_hw_build_tx_cmd_rate(struct il_priv *il, struct il_device_cmd *cmd,
+                           struct ieee80211_tx_info *info,
+                           struct ieee80211_hdr *hdr, int sta_id)
+{
+       u16 hw_value = ieee80211_get_tx_rate(il->hw, info)->hw_value;
+       u16 rate_idx = min(hw_value & 0xffff, RATE_COUNT_3945 - 1);
+       u16 rate_mask;
+       int rate;
+       const u8 rts_retry_limit = 7;
+       u8 data_retry_limit;
+       __le32 tx_flags;
+       __le16 fc = hdr->frame_control;
+       struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
+
+       rate = il3945_rates[rate_idx].plcp;
+       tx_flags = tx_cmd->tx_flags;
+
+       /* We need to figure out how to get the sta->supp_rates while
+        * in this running context */
+       rate_mask = RATES_MASK_3945;
+
+       /* Set retry limit on DATA packets and Probe Responses */
+       if (ieee80211_is_probe_resp(fc))
+               data_retry_limit = 3;
+       else
+               data_retry_limit = IL_DEFAULT_TX_RETRY;
+       tx_cmd->data_retry_limit = data_retry_limit;
+       /* Set retry limit on RTS packets */
+       tx_cmd->rts_retry_limit = min(data_retry_limit, rts_retry_limit);
+
+       tx_cmd->rate = rate;
+       tx_cmd->tx_flags = tx_flags;
+
+       /* OFDM */
+       tx_cmd->supp_rates[0] =
+           ((rate_mask & IL_OFDM_RATES_MASK) >> IL_FIRST_OFDM_RATE) & 0xFF;
+
+       /* CCK */
+       tx_cmd->supp_rates[1] = (rate_mask & 0xF);
+
+       D_RATE("Tx sta id: %d, rate: %d (plcp), flags: 0x%4X "
+              "cck/ofdm mask: 0x%x/0x%x\n", sta_id, tx_cmd->rate,
+              le32_to_cpu(tx_cmd->tx_flags), tx_cmd->supp_rates[1],
+              tx_cmd->supp_rates[0]);
+}
+
+static u8
+il3945_sync_sta(struct il_priv *il, int sta_id, u16 tx_rate)
+{
+       unsigned long flags_spin;
+       struct il_station_entry *station;
+
+       if (sta_id == IL_INVALID_STATION)
+               return IL_INVALID_STATION;
+
+       spin_lock_irqsave(&il->sta_lock, flags_spin);
+       station = &il->stations[sta_id];
+
+       station->sta.sta.modify_mask = STA_MODIFY_TX_RATE_MSK;
+       station->sta.rate_n_flags = cpu_to_le16(tx_rate);
+       station->sta.mode = STA_CONTROL_MODIFY_MSK;
+       il_send_add_sta(il, &station->sta, CMD_ASYNC);
+       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+
+       D_RATE("SCALE sync station %d to rate %d\n", sta_id, tx_rate);
+       return sta_id;
+}
+
+static void
+il3945_set_pwr_vmain(struct il_priv *il)
+{
+/*
+ * (for documentation purposes)
+ * to set power to V_AUX, do
+
+               if (pci_pme_capable(il->pci_dev, PCI_D3cold)) {
+                       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
+                                       APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
+                                       ~APMG_PS_CTRL_MSK_PWR_SRC);
+
+                       _il_poll_bit(il, CSR_GPIO_IN,
+                                    CSR_GPIO_IN_VAL_VAUX_PWR_SRC,
+                                    CSR_GPIO_IN_BIT_AUX_POWER, 5000);
+               }
+ */
+
+       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
+                             APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
+                             ~APMG_PS_CTRL_MSK_PWR_SRC);
+
+       _il_poll_bit(il, CSR_GPIO_IN, CSR_GPIO_IN_VAL_VMAIN_PWR_SRC,
+                    CSR_GPIO_IN_BIT_AUX_POWER, 5000);
+}
+
+static int
+il3945_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
+{
+       il_wr(il, FH39_RCSR_RBD_BASE(0), rxq->bd_dma);
+       il_wr(il, FH39_RCSR_RPTR_ADDR(0), rxq->rb_stts_dma);
+       il_wr(il, FH39_RCSR_WPTR(0), 0);
+       il_wr(il, FH39_RCSR_CONFIG(0),
+             FH39_RCSR_RX_CONFIG_REG_VAL_DMA_CHNL_EN_ENABLE |
+             FH39_RCSR_RX_CONFIG_REG_VAL_RDRBD_EN_ENABLE |
+             FH39_RCSR_RX_CONFIG_REG_BIT_WR_STTS_EN |
+             FH39_RCSR_RX_CONFIG_REG_VAL_MAX_FRAG_SIZE_128 | (RX_QUEUE_SIZE_LOG
+                                                              <<
+                                                              FH39_RCSR_RX_CONFIG_REG_POS_RBDC_SIZE)
+             | FH39_RCSR_RX_CONFIG_REG_VAL_IRQ_DEST_INT_HOST | (1 <<
+                                                                FH39_RCSR_RX_CONFIG_REG_POS_IRQ_RBTH)
+             | FH39_RCSR_RX_CONFIG_REG_VAL_MSG_MODE_FH);
+
+       /* fake read to flush all prev I/O */
+       il_rd(il, FH39_RSSR_CTRL);
+
+       return 0;
+}
+
+static int
+il3945_tx_reset(struct il_priv *il)
+{
+       /* bypass mode */
+       il_wr_prph(il, ALM_SCD_MODE_REG, 0x2);
+
+       /* RA 0 is active */
+       il_wr_prph(il, ALM_SCD_ARASTAT_REG, 0x01);
+
+       /* all 6 fifo are active */
+       il_wr_prph(il, ALM_SCD_TXFACT_REG, 0x3f);
+
+       il_wr_prph(il, ALM_SCD_SBYP_MODE_1_REG, 0x010000);
+       il_wr_prph(il, ALM_SCD_SBYP_MODE_2_REG, 0x030002);
+       il_wr_prph(il, ALM_SCD_TXF4MF_REG, 0x000004);
+       il_wr_prph(il, ALM_SCD_TXF5MF_REG, 0x000005);
+
+       il_wr(il, FH39_TSSR_CBB_BASE, il->_3945.shared_phys);
+
+       il_wr(il, FH39_TSSR_MSG_CONFIG,
+             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TXPD_ON |
+             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_TXPD_ON |
+             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_MAX_FRAG_SIZE_128B |
+             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TFD_ON |
+             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_CBB_ON |
+             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RSP_WAIT_TH |
+             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_RSP_WAIT_TH);
+
+       return 0;
+}
+
+/**
+ * il3945_txq_ctx_reset - Reset TX queue context
+ *
+ * Destroys all DMA structures and initialize them again
+ */
+static int
+il3945_txq_ctx_reset(struct il_priv *il)
+{
+       int rc, txq_id;
+
+       il3945_hw_txq_ctx_free(il);
+
+       /* allocate tx queue structure */
+       rc = il_alloc_txq_mem(il);
+       if (rc)
+               return rc;
+
+       /* Tx CMD queue */
+       rc = il3945_tx_reset(il);
+       if (rc)
+               goto error;
+
+       /* Tx queue(s) */
+       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
+               rc = il_tx_queue_init(il, txq_id);
+               if (rc) {
+                       IL_ERR("Tx %d queue init failed\n", txq_id);
+                       goto error;
+               }
+       }
+
+       return rc;
+
+error:
+       il3945_hw_txq_ctx_free(il);
+       return rc;
+}
+
+/*
+ * Start up 3945's basic functionality after it has been reset
+ * (e.g. after platform boot, or shutdown via il_apm_stop())
+ * NOTE:  This does not load uCode nor start the embedded processor
+ */
+static int
+il3945_apm_init(struct il_priv *il)
+{
+       int ret = il_apm_init(il);
+
+       /* Clear APMG (NIC's internal power management) interrupts */
+       il_wr_prph(il, APMG_RTC_INT_MSK_REG, 0x0);
+       il_wr_prph(il, APMG_RTC_INT_STT_REG, 0xFFFFFFFF);
+
+       /* Reset radio chip */
+       il_set_bits_prph(il, APMG_PS_CTRL_REG, APMG_PS_CTRL_VAL_RESET_REQ);
+       udelay(5);
+       il_clear_bits_prph(il, APMG_PS_CTRL_REG, APMG_PS_CTRL_VAL_RESET_REQ);
+
+       return ret;
+}
+
+static void
+il3945_nic_config(struct il_priv *il)
+{
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+       unsigned long flags;
+       u8 rev_id = il->pci_dev->revision;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Determine HW type */
+       D_INFO("HW Revision ID = 0x%X\n", rev_id);
+
+       if (rev_id & PCI_CFG_REV_ID_BIT_RTP)
+               D_INFO("RTP type\n");
+       else if (rev_id & PCI_CFG_REV_ID_BIT_BASIC_SKU) {
+               D_INFO("3945 RADIO-MB type\n");
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR39_HW_IF_CONFIG_REG_BIT_3945_MB);
+       } else {
+               D_INFO("3945 RADIO-MM type\n");
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR39_HW_IF_CONFIG_REG_BIT_3945_MM);
+       }
+
+       if (EEPROM_SKU_CAP_OP_MODE_MRC == eeprom->sku_cap) {
+               D_INFO("SKU OP mode is mrc\n");
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR39_HW_IF_CONFIG_REG_BIT_SKU_MRC);
+       } else
+               D_INFO("SKU OP mode is basic\n");
+
+       if ((eeprom->board_revision & 0xF0) == 0xD0) {
+               D_INFO("3945ABG revision is 0x%X\n", eeprom->board_revision);
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
+       } else {
+               D_INFO("3945ABG revision is 0x%X\n", eeprom->board_revision);
+               il_clear_bit(il, CSR_HW_IF_CONFIG_REG,
+                            CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
+       }
+
+       if (eeprom->almgor_m_version <= 1) {
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_A);
+               D_INFO("Card M type A version is 0x%X\n",
+                      eeprom->almgor_m_version);
+       } else {
+               D_INFO("Card M type B version is 0x%X\n",
+                      eeprom->almgor_m_version);
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_B);
+       }
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       if (eeprom->sku_cap & EEPROM_SKU_CAP_SW_RF_KILL_ENABLE)
+               D_RF_KILL("SW RF KILL supported in EEPROM.\n");
+
+       if (eeprom->sku_cap & EEPROM_SKU_CAP_HW_RF_KILL_ENABLE)
+               D_RF_KILL("HW RF KILL supported in EEPROM.\n");
+}
+
+int
+il3945_hw_nic_init(struct il_priv *il)
+{
+       int rc;
+       unsigned long flags;
+       struct il_rx_queue *rxq = &il->rxq;
+
+       spin_lock_irqsave(&il->lock, flags);
+       il3945_apm_init(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       il3945_set_pwr_vmain(il);
+       il3945_nic_config(il);
+
+       /* Allocate the RX queue, or reset if it is already allocated */
+       if (!rxq->bd) {
+               rc = il_rx_queue_alloc(il);
+               if (rc) {
+                       IL_ERR("Unable to initialize Rx queue\n");
+                       return -ENOMEM;
+               }
+       } else
+               il3945_rx_queue_reset(il, rxq);
+
+       il3945_rx_replenish(il);
+
+       il3945_rx_init(il, rxq);
+
+       /* Look at using this instead:
+          rxq->need_update = 1;
+          il_rx_queue_update_write_ptr(il, rxq);
+        */
+
+       il_wr(il, FH39_RCSR_WPTR(0), rxq->write & ~7);
+
+       rc = il3945_txq_ctx_reset(il);
+       if (rc)
+               return rc;
+
+       set_bit(S_INIT, &il->status);
+
+       return 0;
+}
+
+/**
+ * il3945_hw_txq_ctx_free - Free TXQ Context
+ *
+ * Destroy all TX DMA queues and structures
+ */
+void
+il3945_hw_txq_ctx_free(struct il_priv *il)
+{
+       int txq_id;
+
+       /* Tx queues */
+       if (il->txq)
+               for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
+                       if (txq_id == IL39_CMD_QUEUE_NUM)
+                               il_cmd_queue_free(il);
+                       else
+                               il_tx_queue_free(il, txq_id);
+
+       /* free tx queue structure */
+       il_free_txq_mem(il);
+}
+
+void
+il3945_hw_txq_ctx_stop(struct il_priv *il)
+{
+       int txq_id;
+
+       /* stop SCD */
+       _il_wr_prph(il, ALM_SCD_MODE_REG, 0);
+       _il_wr_prph(il, ALM_SCD_TXFACT_REG, 0);
+
+       /* reset TFD queues */
+       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
+               _il_wr(il, FH39_TCSR_CONFIG(txq_id), 0x0);
+               _il_poll_bit(il, FH39_TSSR_TX_STATUS,
+                            FH39_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(txq_id),
+                            FH39_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(txq_id),
+                            1000);
+       }
+}
+
+/**
+ * il3945_hw_reg_adjust_power_by_temp
+ * return idx delta into power gain settings table
+*/
+static int
+il3945_hw_reg_adjust_power_by_temp(int new_reading, int old_reading)
+{
+       return (new_reading - old_reading) * (-11) / 100;
+}
+
+/**
+ * il3945_hw_reg_temp_out_of_range - Keep temperature in sane range
+ */
+static inline int
+il3945_hw_reg_temp_out_of_range(int temperature)
+{
+       return (temperature < -260 || temperature > 25) ? 1 : 0;
+}
+
+int
+il3945_hw_get_temperature(struct il_priv *il)
+{
+       return _il_rd(il, CSR_UCODE_DRV_GP2);
+}
+
+/**
+ * il3945_hw_reg_txpower_get_temperature
+ * get the current temperature by reading from NIC
+*/
+static int
+il3945_hw_reg_txpower_get_temperature(struct il_priv *il)
+{
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+       int temperature;
+
+       temperature = il3945_hw_get_temperature(il);
+
+       /* driver's okay range is -260 to +25.
+        *   human readable okay range is 0 to +285 */
+       D_INFO("Temperature: %d\n", temperature + IL_TEMP_CONVERT);
+
+       /* handle insane temp reading */
+       if (il3945_hw_reg_temp_out_of_range(temperature)) {
+               IL_ERR("Error bad temperature value  %d\n", temperature);
+
+               /* if really really hot(?),
+                *   substitute the 3rd band/group's temp measured at factory */
+               if (il->last_temperature > 100)
+                       temperature = eeprom->groups[2].temperature;
+               else            /* else use most recent "sane" value from driver */
+                       temperature = il->last_temperature;
+       }
+
+       return temperature;     /* raw, not "human readable" */
+}
+
+/* Adjust Txpower only if temperature variance is greater than threshold.
+ *
+ * Both are lower than older versions' 9 degrees */
+#define IL_TEMPERATURE_LIMIT_TIMER   6
+
+/**
+ * il3945_is_temp_calib_needed - determines if new calibration is needed
+ *
+ * records new temperature in tx_mgr->temperature.
+ * replaces tx_mgr->last_temperature *only* if calib needed
+ *    (assumes caller will actually do the calibration!). */
+static int
+il3945_is_temp_calib_needed(struct il_priv *il)
+{
+       int temp_diff;
+
+       il->temperature = il3945_hw_reg_txpower_get_temperature(il);
+       temp_diff = il->temperature - il->last_temperature;
+
+       /* get absolute value */
+       if (temp_diff < 0) {
+               D_POWER("Getting cooler, delta %d,\n", temp_diff);
+               temp_diff = -temp_diff;
+       } else if (temp_diff == 0)
+               D_POWER("Same temp,\n");
+       else
+               D_POWER("Getting warmer, delta %d,\n", temp_diff);
+
+       /* if we don't need calibration, *don't* update last_temperature */
+       if (temp_diff < IL_TEMPERATURE_LIMIT_TIMER) {
+               D_POWER("Timed thermal calib not needed\n");
+               return 0;
+       }
+
+       D_POWER("Timed thermal calib needed\n");
+
+       /* assume that caller will actually do calib ...
+        *   update the "last temperature" value */
+       il->last_temperature = il->temperature;
+       return 1;
+}
+
+#define IL_MAX_GAIN_ENTRIES 78
+#define IL_CCK_FROM_OFDM_POWER_DIFF  -5
+#define IL_CCK_FROM_OFDM_IDX_DIFF (10)
+
+/* radio and DSP power table, each step is 1/2 dB.
+ * 1st number is for RF analog gain, 2nd number is for DSP pre-DAC gain. */
+static struct il3945_tx_power power_gain_table[2][IL_MAX_GAIN_ENTRIES] = {
+       {
+        {251, 127},            /* 2.4 GHz, highest power */
+        {251, 127},
+        {251, 127},
+        {251, 127},
+        {251, 125},
+        {251, 110},
+        {251, 105},
+        {251, 98},
+        {187, 125},
+        {187, 115},
+        {187, 108},
+        {187, 99},
+        {243, 119},
+        {243, 111},
+        {243, 105},
+        {243, 97},
+        {243, 92},
+        {211, 106},
+        {211, 100},
+        {179, 120},
+        {179, 113},
+        {179, 107},
+        {147, 125},
+        {147, 119},
+        {147, 112},
+        {147, 106},
+        {147, 101},
+        {147, 97},
+        {147, 91},
+        {115, 107},
+        {235, 121},
+        {235, 115},
+        {235, 109},
+        {203, 127},
+        {203, 121},
+        {203, 115},
+        {203, 108},
+        {203, 102},
+        {203, 96},
+        {203, 92},
+        {171, 110},
+        {171, 104},
+        {171, 98},
+        {139, 116},
+        {227, 125},
+        {227, 119},
+        {227, 113},
+        {227, 107},
+        {227, 101},
+        {227, 96},
+        {195, 113},
+        {195, 106},
+        {195, 102},
+        {195, 95},
+        {163, 113},
+        {163, 106},
+        {163, 102},
+        {163, 95},
+        {131, 113},
+        {131, 106},
+        {131, 102},
+        {131, 95},
+        {99, 113},
+        {99, 106},
+        {99, 102},
+        {99, 95},
+        {67, 113},
+        {67, 106},
+        {67, 102},
+        {67, 95},
+        {35, 113},
+        {35, 106},
+        {35, 102},
+        {35, 95},
+        {3, 113},
+        {3, 106},
+        {3, 102},
+        {3, 95}                /* 2.4 GHz, lowest power */
+       },
+       {
+        {251, 127},            /* 5.x GHz, highest power */
+        {251, 120},
+        {251, 114},
+        {219, 119},
+        {219, 101},
+        {187, 113},
+        {187, 102},
+        {155, 114},
+        {155, 103},
+        {123, 117},
+        {123, 107},
+        {123, 99},
+        {123, 92},
+        {91, 108},
+        {59, 125},
+        {59, 118},
+        {59, 109},
+        {59, 102},
+        {59, 96},
+        {59, 90},
+        {27, 104},
+        {27, 98},
+        {27, 92},
+        {115, 118},
+        {115, 111},
+        {115, 104},
+        {83, 126},
+        {83, 121},
+        {83, 113},
+        {83, 105},
+        {83, 99},
+        {51, 118},
+        {51, 111},
+        {51, 104},
+        {51, 98},
+        {19, 116},
+        {19, 109},
+        {19, 102},
+        {19, 98},
+        {19, 93},
+        {171, 113},
+        {171, 107},
+        {171, 99},
+        {139, 120},
+        {139, 113},
+        {139, 107},
+        {139, 99},
+        {107, 120},
+        {107, 113},
+        {107, 107},
+        {107, 99},
+        {75, 120},
+        {75, 113},
+        {75, 107},
+        {75, 99},
+        {43, 120},
+        {43, 113},
+        {43, 107},
+        {43, 99},
+        {11, 120},
+        {11, 113},
+        {11, 107},
+        {11, 99},
+        {131, 107},
+        {131, 99},
+        {99, 120},
+        {99, 113},
+        {99, 107},
+        {99, 99},
+        {67, 120},
+        {67, 113},
+        {67, 107},
+        {67, 99},
+        {35, 120},
+        {35, 113},
+        {35, 107},
+        {35, 99},
+        {3, 120}               /* 5.x GHz, lowest power */
+       }
+};
+
+static inline u8
+il3945_hw_reg_fix_power_idx(int idx)
+{
+       if (idx < 0)
+               return 0;
+       if (idx >= IL_MAX_GAIN_ENTRIES)
+               return IL_MAX_GAIN_ENTRIES - 1;
+       return (u8) idx;
+}
+
+/* Kick off thermal recalibration check every 60 seconds */
+#define REG_RECALIB_PERIOD (60)
+
+/**
+ * il3945_hw_reg_set_scan_power - Set Tx power for scan probe requests
+ *
+ * Set (in our channel info database) the direct scan Tx power for 1 Mbit (CCK)
+ * or 6 Mbit (OFDM) rates.
+ */
+static void
+il3945_hw_reg_set_scan_power(struct il_priv *il, u32 scan_tbl_idx, s32 rate_idx,
+                            const s8 *clip_pwrs,
+                            struct il_channel_info *ch_info, int band_idx)
+{
+       struct il3945_scan_power_info *scan_power_info;
+       s8 power;
+       u8 power_idx;
+
+       scan_power_info = &ch_info->scan_pwr_info[scan_tbl_idx];
+
+       /* use this channel group's 6Mbit clipping/saturation pwr,
+        *   but cap at regulatory scan power restriction (set during init
+        *   based on eeprom channel data) for this channel.  */
+       power = min(ch_info->scan_power, clip_pwrs[RATE_6M_IDX_TBL]);
+
+       power = min(power, il->tx_power_user_lmt);
+       scan_power_info->requested_power = power;
+
+       /* find difference between new scan *power* and current "normal"
+        *   Tx *power* for 6Mb.  Use this difference (x2) to adjust the
+        *   current "normal" temperature-compensated Tx power *idx* for
+        *   this rate (1Mb or 6Mb) to yield new temp-compensated scan power
+        *   *idx*. */
+       power_idx =
+           ch_info->power_info[rate_idx].power_table_idx - (power -
+                                                            ch_info->
+                                                            power_info
+                                                            [RATE_6M_IDX_TBL].
+                                                            requested_power) *
+           2;
+
+       /* store reference idx that we use when adjusting *all* scan
+        *   powers.  So we can accommodate user (all channel) or spectrum
+        *   management (single channel) power changes "between" temperature
+        *   feedback compensation procedures.
+        * don't force fit this reference idx into gain table; it may be a
+        *   negative number.  This will help avoid errors when we're at
+        *   the lower bounds (highest gains, for warmest temperatures)
+        *   of the table. */
+
+       /* don't exceed table bounds for "real" setting */
+       power_idx = il3945_hw_reg_fix_power_idx(power_idx);
+
+       scan_power_info->power_table_idx = power_idx;
+       scan_power_info->tpc.tx_gain =
+           power_gain_table[band_idx][power_idx].tx_gain;
+       scan_power_info->tpc.dsp_atten =
+           power_gain_table[band_idx][power_idx].dsp_atten;
+}
+
+/**
+ * il3945_send_tx_power - fill in Tx Power command with gain settings
+ *
+ * Configures power settings for all rates for the current channel,
+ * using values from channel info struct, and send to NIC
+ */
+static int
+il3945_send_tx_power(struct il_priv *il)
+{
+       int rate_idx, i;
+       const struct il_channel_info *ch_info = NULL;
+       struct il3945_txpowertable_cmd txpower = {
+               .channel = il->active.channel,
+       };
+       u16 chan;
+
+       if (WARN_ONCE
+           (test_bit(S_SCAN_HW, &il->status),
+            "TX Power requested while scanning!\n"))
+               return -EAGAIN;
+
+       chan = le16_to_cpu(il->active.channel);
+
+       txpower.band = (il->band == IEEE80211_BAND_5GHZ) ? 0 : 1;
+       ch_info = il_get_channel_info(il, il->band, chan);
+       if (!ch_info) {
+               IL_ERR("Failed to get channel info for channel %d [%d]\n", chan,
+                      il->band);
+               return -EINVAL;
+       }
+
+       if (!il_is_channel_valid(ch_info)) {
+               D_POWER("Not calling TX_PWR_TBL_CMD on " "non-Tx channel.\n");
+               return 0;
+       }
+
+       /* fill cmd with power settings for all rates for current channel */
+       /* Fill OFDM rate */
+       for (rate_idx = IL_FIRST_OFDM_RATE, i = 0;
+            rate_idx <= IL39_LAST_OFDM_RATE; rate_idx++, i++) {
+
+               txpower.power[i].tpc = ch_info->power_info[i].tpc;
+               txpower.power[i].rate = il3945_rates[rate_idx].plcp;
+
+               D_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
+                       le16_to_cpu(txpower.channel), txpower.band,
+                       txpower.power[i].tpc.tx_gain,
+                       txpower.power[i].tpc.dsp_atten, txpower.power[i].rate);
+       }
+       /* Fill CCK rates */
+       for (rate_idx = IL_FIRST_CCK_RATE; rate_idx <= IL_LAST_CCK_RATE;
+            rate_idx++, i++) {
+               txpower.power[i].tpc = ch_info->power_info[i].tpc;
+               txpower.power[i].rate = il3945_rates[rate_idx].plcp;
+
+               D_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
+                       le16_to_cpu(txpower.channel), txpower.band,
+                       txpower.power[i].tpc.tx_gain,
+                       txpower.power[i].tpc.dsp_atten, txpower.power[i].rate);
+       }
+
+       return il_send_cmd_pdu(il, C_TX_PWR_TBL,
+                              sizeof(struct il3945_txpowertable_cmd),
+                              &txpower);
+
+}
+
+/**
+ * il3945_hw_reg_set_new_power - Configures power tables at new levels
+ * @ch_info: Channel to update.  Uses power_info.requested_power.
+ *
+ * Replace requested_power and base_power_idx ch_info fields for
+ * one channel.
+ *
+ * Called if user or spectrum management changes power preferences.
+ * Takes into account h/w and modulation limitations (clip power).
+ *
+ * This does *not* send anything to NIC, just sets up ch_info for one channel.
+ *
+ * NOTE: reg_compensate_for_temperature_dif() *must* be run after this to
+ *      properly fill out the scan powers, and actual h/w gain settings,
+ *      and send changes to NIC
+ */
+static int
+il3945_hw_reg_set_new_power(struct il_priv *il, struct il_channel_info *ch_info)
+{
+       struct il3945_channel_power_info *power_info;
+       int power_changed = 0;
+       int i;
+       const s8 *clip_pwrs;
+       int power;
+
+       /* Get this chnlgrp's rate-to-max/clip-powers table */
+       clip_pwrs = il->_3945.clip_groups[ch_info->group_idx].clip_powers;
+
+       /* Get this channel's rate-to-current-power settings table */
+       power_info = ch_info->power_info;
+
+       /* update OFDM Txpower settings */
+       for (i = RATE_6M_IDX_TBL; i <= RATE_54M_IDX_TBL; i++, ++power_info) {
+               int delta_idx;
+
+               /* limit new power to be no more than h/w capability */
+               power = min(ch_info->curr_txpow, clip_pwrs[i]);
+               if (power == power_info->requested_power)
+                       continue;
+
+               /* find difference between old and new requested powers,
+                *    update base (non-temp-compensated) power idx */
+               delta_idx = (power - power_info->requested_power) * 2;
+               power_info->base_power_idx -= delta_idx;
+
+               /* save new requested power value */
+               power_info->requested_power = power;
+
+               power_changed = 1;
+       }
+
+       /* update CCK Txpower settings, based on OFDM 12M setting ...
+        *    ... all CCK power settings for a given channel are the *same*. */
+       if (power_changed) {
+               power =
+                   ch_info->power_info[RATE_12M_IDX_TBL].requested_power +
+                   IL_CCK_FROM_OFDM_POWER_DIFF;
+
+               /* do all CCK rates' il3945_channel_power_info structures */
+               for (i = RATE_1M_IDX_TBL; i <= RATE_11M_IDX_TBL; i++) {
+                       power_info->requested_power = power;
+                       power_info->base_power_idx =
+                           ch_info->power_info[RATE_12M_IDX_TBL].
+                           base_power_idx + IL_CCK_FROM_OFDM_IDX_DIFF;
+                       ++power_info;
+               }
+       }
+
+       return 0;
+}
+
+/**
+ * il3945_hw_reg_get_ch_txpower_limit - returns new power limit for channel
+ *
+ * NOTE: Returned power limit may be less (but not more) than requested,
+ *      based strictly on regulatory (eeprom and spectrum mgt) limitations
+ *      (no consideration for h/w clipping limitations).
+ */
+static int
+il3945_hw_reg_get_ch_txpower_limit(struct il_channel_info *ch_info)
+{
+       s8 max_power;
+
+#if 0
+       /* if we're using TGd limits, use lower of TGd or EEPROM */
+       if (ch_info->tgd_data.max_power != 0)
+               max_power =
+                   min(ch_info->tgd_data.max_power,
+                       ch_info->eeprom.max_power_avg);
+
+       /* else just use EEPROM limits */
+       else
+#endif
+               max_power = ch_info->eeprom.max_power_avg;
+
+       return min(max_power, ch_info->max_power_avg);
+}
+
+/**
+ * il3945_hw_reg_comp_txpower_temp - Compensate for temperature
+ *
+ * Compensate txpower settings of *all* channels for temperature.
+ * This only accounts for the difference between current temperature
+ *   and the factory calibration temperatures, and bases the new settings
+ *   on the channel's base_power_idx.
+ *
+ * If RxOn is "associated", this sends the new Txpower to NIC!
+ */
+static int
+il3945_hw_reg_comp_txpower_temp(struct il_priv *il)
+{
+       struct il_channel_info *ch_info = NULL;
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+       int delta_idx;
+       const s8 *clip_pwrs;    /* array of h/w max power levels for each rate */
+       u8 a_band;
+       u8 rate_idx;
+       u8 scan_tbl_idx;
+       u8 i;
+       int ref_temp;
+       int temperature = il->temperature;
+
+       if (il->disable_tx_power_cal || test_bit(S_SCANNING, &il->status)) {
+               /* do not perform tx power calibration */
+               return 0;
+       }
+       /* set up new Tx power info for each and every channel, 2.4 and 5.x */
+       for (i = 0; i < il->channel_count; i++) {
+               ch_info = &il->channel_info[i];
+               a_band = il_is_channel_a_band(ch_info);
+
+               /* Get this chnlgrp's factory calibration temperature */
+               ref_temp = (s16) eeprom->groups[ch_info->group_idx].temperature;
+
+               /* get power idx adjustment based on current and factory
+                * temps */
+               delta_idx =
+                   il3945_hw_reg_adjust_power_by_temp(temperature, ref_temp);
+
+               /* set tx power value for all rates, OFDM and CCK */
+               for (rate_idx = 0; rate_idx < RATE_COUNT_3945; rate_idx++) {
+                       int power_idx =
+                           ch_info->power_info[rate_idx].base_power_idx;
+
+                       /* temperature compensate */
+                       power_idx += delta_idx;
+
+                       /* stay within table range */
+                       power_idx = il3945_hw_reg_fix_power_idx(power_idx);
+                       ch_info->power_info[rate_idx].power_table_idx =
+                           (u8) power_idx;
+                       ch_info->power_info[rate_idx].tpc =
+                           power_gain_table[a_band][power_idx];
+               }
+
+               /* Get this chnlgrp's rate-to-max/clip-powers table */
+               clip_pwrs =
+                   il->_3945.clip_groups[ch_info->group_idx].clip_powers;
+
+               /* set scan tx power, 1Mbit for CCK, 6Mbit for OFDM */
+               for (scan_tbl_idx = 0; scan_tbl_idx < IL_NUM_SCAN_RATES;
+                    scan_tbl_idx++) {
+                       s32 actual_idx =
+                           (scan_tbl_idx ==
+                            0) ? RATE_1M_IDX_TBL : RATE_6M_IDX_TBL;
+                       il3945_hw_reg_set_scan_power(il, scan_tbl_idx,
+                                                    actual_idx, clip_pwrs,
+                                                    ch_info, a_band);
+               }
+       }
+
+       /* send Txpower command for current channel to ucode */
+       return il->ops->send_tx_power(il);
+}
+
+int
+il3945_hw_reg_set_txpower(struct il_priv *il, s8 power)
+{
+       struct il_channel_info *ch_info;
+       s8 max_power;
+       u8 a_band;
+       u8 i;
+
+       if (il->tx_power_user_lmt == power) {
+               D_POWER("Requested Tx power same as current " "limit: %ddBm.\n",
+                       power);
+               return 0;
+       }
+
+       D_POWER("Setting upper limit clamp to %ddBm.\n", power);
+       il->tx_power_user_lmt = power;
+
+       /* set up new Tx powers for each and every channel, 2.4 and 5.x */
+
+       for (i = 0; i < il->channel_count; i++) {
+               ch_info = &il->channel_info[i];
+               a_band = il_is_channel_a_band(ch_info);
+
+               /* find minimum power of all user and regulatory constraints
+                *    (does not consider h/w clipping limitations) */
+               max_power = il3945_hw_reg_get_ch_txpower_limit(ch_info);
+               max_power = min(power, max_power);
+               if (max_power != ch_info->curr_txpow) {
+                       ch_info->curr_txpow = max_power;
+
+                       /* this considers the h/w clipping limitations */
+                       il3945_hw_reg_set_new_power(il, ch_info);
+               }
+       }
+
+       /* update txpower settings for all channels,
+        *   send to NIC if associated. */
+       il3945_is_temp_calib_needed(il);
+       il3945_hw_reg_comp_txpower_temp(il);
+
+       return 0;
+}
+
+static int
+il3945_send_rxon_assoc(struct il_priv *il)
+{
+       int rc = 0;
+       struct il_rx_pkt *pkt;
+       struct il3945_rxon_assoc_cmd rxon_assoc;
+       struct il_host_cmd cmd = {
+               .id = C_RXON_ASSOC,
+               .len = sizeof(rxon_assoc),
+               .flags = CMD_WANT_SKB,
+               .data = &rxon_assoc,
+       };
+       const struct il_rxon_cmd *rxon1 = &il->staging;
+       const struct il_rxon_cmd *rxon2 = &il->active;
+
+       if (rxon1->flags == rxon2->flags &&
+           rxon1->filter_flags == rxon2->filter_flags &&
+           rxon1->cck_basic_rates == rxon2->cck_basic_rates &&
+           rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates) {
+               D_INFO("Using current RXON_ASSOC.  Not resending.\n");
+               return 0;
+       }
+
+       rxon_assoc.flags = il->staging.flags;
+       rxon_assoc.filter_flags = il->staging.filter_flags;
+       rxon_assoc.ofdm_basic_rates = il->staging.ofdm_basic_rates;
+       rxon_assoc.cck_basic_rates = il->staging.cck_basic_rates;
+       rxon_assoc.reserved = 0;
+
+       rc = il_send_cmd_sync(il, &cmd);
+       if (rc)
+               return rc;
+
+       pkt = (struct il_rx_pkt *)cmd.reply_page;
+       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
+               IL_ERR("Bad return from C_RXON_ASSOC command\n");
+               rc = -EIO;
+       }
+
+       il_free_pages(il, cmd.reply_page);
+
+       return rc;
+}
+
+/**
+ * il3945_commit_rxon - commit staging_rxon to hardware
+ *
+ * The RXON command in staging_rxon is committed to the hardware and
+ * the active_rxon structure is updated with the new data.  This
+ * function correctly transitions out of the RXON_ASSOC_MSK state if
+ * a HW tune is required based on the RXON structure changes.
+ */
+int
+il3945_commit_rxon(struct il_priv *il)
+{
+       /* cast away the const for active_rxon in this function */
+       struct il3945_rxon_cmd *active_rxon = (void *)&il->active;
+       struct il3945_rxon_cmd *staging_rxon = (void *)&il->staging;
+       int rc = 0;
+       bool new_assoc = !!(staging_rxon->filter_flags & RXON_FILTER_ASSOC_MSK);
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return -EINVAL;
+
+       if (!il_is_alive(il))
+               return -1;
+
+       /* always get timestamp with Rx frame */
+       staging_rxon->flags |= RXON_FLG_TSF2HOST_MSK;
+
+       /* select antenna */
+       staging_rxon->flags &= ~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
+       staging_rxon->flags |= il3945_get_antenna_flags(il);
+
+       rc = il_check_rxon_cmd(il);
+       if (rc) {
+               IL_ERR("Invalid RXON configuration.  Not committing.\n");
+               return -EINVAL;
+       }
+
+       /* If we don't need to send a full RXON, we can use
+        * il3945_rxon_assoc_cmd which is used to reconfigure filter
+        * and other flags for the current radio configuration. */
+       if (!il_full_rxon_required(il)) {
+               rc = il_send_rxon_assoc(il);
+               if (rc) {
+                       IL_ERR("Error setting RXON_ASSOC "
+                              "configuration (%d).\n", rc);
+                       return rc;
+               }
+
+               memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
+               /*
+                * We do not commit tx power settings while channel changing,
+                * do it now if tx power changed.
+                */
+               il_set_tx_power(il, il->tx_power_next, false);
+               return 0;
+       }
+
+       /* If we are currently associated and the new config requires
+        * 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 (il_is_associated(il) && new_assoc) {
+               D_INFO("Toggling associated bit on current RXON\n");
+               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+
+               /*
+                * reserved4 and 5 could have been filled by the iwlcore code.
+                * Let's clear them before pushing to the 3945.
+                */
+               active_rxon->reserved4 = 0;
+               active_rxon->reserved5 = 0;
+               rc = il_send_cmd_pdu(il, C_RXON, sizeof(struct il3945_rxon_cmd),
+                                    &il->active);
+
+               /* If the mask clearing failed then we set
+                * active_rxon back to what it was previously */
+               if (rc) {
+                       active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
+                       IL_ERR("Error clearing ASSOC_MSK on current "
+                              "configuration (%d).\n", rc);
+                       return rc;
+               }
+               il_clear_ucode_stations(il);
+               il_restore_stations(il);
+       }
+
+       D_INFO("Sending RXON\n" "* with%s RXON_FILTER_ASSOC_MSK\n"
+              "* channel = %d\n" "* bssid = %pM\n", (new_assoc ? "" : "out"),
+              le16_to_cpu(staging_rxon->channel), staging_rxon->bssid_addr);
+
+       /*
+        * reserved4 and 5 could have been filled by the iwlcore code.
+        * Let's clear them before pushing to the 3945.
+        */
+       staging_rxon->reserved4 = 0;
+       staging_rxon->reserved5 = 0;
+
+       il_set_rxon_hwcrypto(il, !il3945_mod_params.sw_crypto);
+
+       /* Apply the new configuration */
+       rc = il_send_cmd_pdu(il, C_RXON, sizeof(struct il3945_rxon_cmd),
+                            staging_rxon);
+       if (rc) {
+               IL_ERR("Error setting new configuration (%d).\n", rc);
+               return rc;
+       }
+
+       memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
+
+       if (!new_assoc) {
+               il_clear_ucode_stations(il);
+               il_restore_stations(il);
+       }
+
+       /* If we issue a new RXON command which required a tune then we must
+        * send a new TXPOWER command or we won't be able to Tx any frames */
+       rc = il_set_tx_power(il, il->tx_power_next, true);
+       if (rc) {
+               IL_ERR("Error setting Tx power (%d).\n", rc);
+               return rc;
+       }
+
+       /* Init the hardware's rate fallback order based on the band */
+       rc = il3945_init_hw_rate_table(il);
+       if (rc) {
+               IL_ERR("Error setting HW rate table: %02X\n", rc);
+               return -EIO;
+       }
+
+       return 0;
+}
+
+/**
+ * il3945_reg_txpower_periodic -  called when time to check our temperature.
+ *
+ * -- reset periodic timer
+ * -- see if temp has changed enough to warrant re-calibration ... if so:
+ *     -- correct coeffs for temp (can reset temp timer)
+ *     -- save this temp as "last",
+ *     -- send new set of gain settings to NIC
+ * NOTE:  This should continue working, even when we're not associated,
+ *   so we can keep our internal table of scan powers current. */
+void
+il3945_reg_txpower_periodic(struct il_priv *il)
+{
+       /* This will kick in the "brute force"
+        * il3945_hw_reg_comp_txpower_temp() below */
+       if (!il3945_is_temp_calib_needed(il))
+               goto reschedule;
+
+       /* Set up a new set of temp-adjusted TxPowers, send to NIC.
+        * This is based *only* on current temperature,
+        * ignoring any previous power measurements */
+       il3945_hw_reg_comp_txpower_temp(il);
+
+reschedule:
+       queue_delayed_work(il->workqueue, &il->_3945.thermal_periodic,
+                          REG_RECALIB_PERIOD * HZ);
+}
+
+static void
+il3945_bg_reg_txpower_periodic(struct work_struct *work)
+{
+       struct il_priv *il = container_of(work, struct il_priv,
+                                         _3945.thermal_periodic.work);
+
+       mutex_lock(&il->mutex);
+       if (test_bit(S_EXIT_PENDING, &il->status) || il->txq == NULL)
+               goto out;
+
+       il3945_reg_txpower_periodic(il);
+out:
+       mutex_unlock(&il->mutex);
+}
+
+/**
+ * il3945_hw_reg_get_ch_grp_idx - find the channel-group idx (0-4) for channel.
+ *
+ * This function is used when initializing channel-info structs.
+ *
+ * NOTE: These channel groups do *NOT* match the bands above!
+ *      These channel groups are based on factory-tested channels;
+ *      on A-band, EEPROM's "group frequency" entries represent the top
+ *      channel in each group 1-4.  Group 5 All B/G channels are in group 0.
+ */
+static u16
+il3945_hw_reg_get_ch_grp_idx(struct il_priv *il,
+                            const struct il_channel_info *ch_info)
+{
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+       struct il3945_eeprom_txpower_group *ch_grp = &eeprom->groups[0];
+       u8 group;
+       u16 group_idx = 0;      /* based on factory calib frequencies */
+       u8 grp_channel;
+
+       /* Find the group idx for the channel ... don't use idx 1(?) */
+       if (il_is_channel_a_band(ch_info)) {
+               for (group = 1; group < 5; group++) {
+                       grp_channel = ch_grp[group].group_channel;
+                       if (ch_info->channel <= grp_channel) {
+                               group_idx = group;
+                               break;
+                       }
+               }
+               /* group 4 has a few channels *above* its factory cal freq */
+               if (group == 5)
+                       group_idx = 4;
+       } else
+               group_idx = 0;  /* 2.4 GHz, group 0 */
+
+       D_POWER("Chnl %d mapped to grp %d\n", ch_info->channel, group_idx);
+       return group_idx;
+}
+
+/**
+ * il3945_hw_reg_get_matched_power_idx - Interpolate to get nominal idx
+ *
+ * Interpolate to get nominal (i.e. at factory calibration temperature) idx
+ *   into radio/DSP gain settings table for requested power.
+ */
+static int
+il3945_hw_reg_get_matched_power_idx(struct il_priv *il, s8 requested_power,
+                                   s32 setting_idx, s32 *new_idx)
+{
+       const struct il3945_eeprom_txpower_group *chnl_grp = NULL;
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+       s32 idx0, idx1;
+       s32 power = 2 * requested_power;
+       s32 i;
+       const struct il3945_eeprom_txpower_sample *samples;
+       s32 gains0, gains1;
+       s32 res;
+       s32 denominator;
+
+       chnl_grp = &eeprom->groups[setting_idx];
+       samples = chnl_grp->samples;
+       for (i = 0; i < 5; i++) {
+               if (power == samples[i].power) {
+                       *new_idx = samples[i].gain_idx;
+                       return 0;
+               }
+       }
+
+       if (power > samples[1].power) {
+               idx0 = 0;
+               idx1 = 1;
+       } else if (power > samples[2].power) {
+               idx0 = 1;
+               idx1 = 2;
+       } else if (power > samples[3].power) {
+               idx0 = 2;
+               idx1 = 3;
+       } else {
+               idx0 = 3;
+               idx1 = 4;
+       }
+
+       denominator = (s32) samples[idx1].power - (s32) samples[idx0].power;
+       if (denominator == 0)
+               return -EINVAL;
+       gains0 = (s32) samples[idx0].gain_idx * (1 << 19);
+       gains1 = (s32) samples[idx1].gain_idx * (1 << 19);
+       res =
+           gains0 + (gains1 - gains0) * ((s32) power -
+                                         (s32) samples[idx0].power) /
+           denominator + (1 << 18);
+       *new_idx = res >> 19;
+       return 0;
+}
+
+static void
+il3945_hw_reg_init_channel_groups(struct il_priv *il)
+{
+       u32 i;
+       s32 rate_idx;
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+       const struct il3945_eeprom_txpower_group *group;
+
+       D_POWER("Initializing factory calib info from EEPROM\n");
+
+       for (i = 0; i < IL_NUM_TX_CALIB_GROUPS; i++) {
+               s8 *clip_pwrs;  /* table of power levels for each rate */
+               s8 satur_pwr;   /* saturation power for each chnl group */
+               group = &eeprom->groups[i];
+
+               /* sanity check on factory saturation power value */
+               if (group->saturation_power < 40) {
+                       IL_WARN("Error: saturation power is %d, "
+                               "less than minimum expected 40\n",
+                               group->saturation_power);
+                       return;
+               }
+
+               /*
+                * Derive requested power levels for each rate, based on
+                *   hardware capabilities (saturation power for band).
+                * Basic value is 3dB down from saturation, with further
+                *   power reductions for highest 3 data rates.  These
+                *   backoffs provide headroom for high rate modulation
+                *   power peaks, without too much distortion (clipping).
+                */
+               /* we'll fill in this array with h/w max power levels */
+               clip_pwrs = (s8 *) il->_3945.clip_groups[i].clip_powers;
+
+               /* divide factory saturation power by 2 to find -3dB level */
+               satur_pwr = (s8) (group->saturation_power >> 1);
+
+               /* fill in channel group's nominal powers for each rate */
+               for (rate_idx = 0; rate_idx < RATE_COUNT_3945;
+                    rate_idx++, clip_pwrs++) {
+                       switch (rate_idx) {
+                       case RATE_36M_IDX_TBL:
+                               if (i == 0)     /* B/G */
+                                       *clip_pwrs = satur_pwr;
+                               else    /* A */
+                                       *clip_pwrs = satur_pwr - 5;
+                               break;
+                       case RATE_48M_IDX_TBL:
+                               if (i == 0)
+                                       *clip_pwrs = satur_pwr - 7;
+                               else
+                                       *clip_pwrs = satur_pwr - 10;
+                               break;
+                       case RATE_54M_IDX_TBL:
+                               if (i == 0)
+                                       *clip_pwrs = satur_pwr - 9;
+                               else
+                                       *clip_pwrs = satur_pwr - 12;
+                               break;
+                       default:
+                               *clip_pwrs = satur_pwr;
+                               break;
+                       }
+               }
+       }
+}
+
+/**
+ * il3945_txpower_set_from_eeprom - Set channel power info based on EEPROM
+ *
+ * Second pass (during init) to set up il->channel_info
+ *
+ * Set up Tx-power settings in our channel info database for each VALID
+ * (for this geo/SKU) channel, at all Tx data rates, based on eeprom values
+ * and current temperature.
+ *
+ * Since this is based on current temperature (at init time), these values may
+ * not be valid for very long, but it gives us a starting/default point,
+ * and allows us to active (i.e. using Tx) scan.
+ *
+ * This does *not* write values to NIC, just sets up our internal table.
+ */
+int
+il3945_txpower_set_from_eeprom(struct il_priv *il)
+{
+       struct il_channel_info *ch_info = NULL;
+       struct il3945_channel_power_info *pwr_info;
+       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
+       int delta_idx;
+       u8 rate_idx;
+       u8 scan_tbl_idx;
+       const s8 *clip_pwrs;    /* array of power levels for each rate */
+       u8 gain, dsp_atten;
+       s8 power;
+       u8 pwr_idx, base_pwr_idx, a_band;
+       u8 i;
+       int temperature;
+
+       /* save temperature reference,
+        *   so we can determine next time to calibrate */
+       temperature = il3945_hw_reg_txpower_get_temperature(il);
+       il->last_temperature = temperature;
+
+       il3945_hw_reg_init_channel_groups(il);
+
+       /* initialize Tx power info for each and every channel, 2.4 and 5.x */
+       for (i = 0, ch_info = il->channel_info; i < il->channel_count;
+            i++, ch_info++) {
+               a_band = il_is_channel_a_band(ch_info);
+               if (!il_is_channel_valid(ch_info))
+                       continue;
+
+               /* find this channel's channel group (*not* "band") idx */
+               ch_info->group_idx = il3945_hw_reg_get_ch_grp_idx(il, ch_info);
+
+               /* Get this chnlgrp's rate->max/clip-powers table */
+               clip_pwrs =
+                   il->_3945.clip_groups[ch_info->group_idx].clip_powers;
+
+               /* calculate power idx *adjustment* value according to
+                *  diff between current temperature and factory temperature */
+               delta_idx =
+                   il3945_hw_reg_adjust_power_by_temp(temperature,
+                                                      eeprom->groups[ch_info->
+                                                                     group_idx].
+                                                      temperature);
+
+               D_POWER("Delta idx for channel %d: %d [%d]\n", ch_info->channel,
+                       delta_idx, temperature + IL_TEMP_CONVERT);
+
+               /* set tx power value for all OFDM rates */
+               for (rate_idx = 0; rate_idx < IL_OFDM_RATES; rate_idx++) {
+                       s32 uninitialized_var(power_idx);
+                       int rc;
+
+                       /* use channel group's clip-power table,
+                        *   but don't exceed channel's max power */
+                       s8 pwr = min(ch_info->max_power_avg,
+                                    clip_pwrs[rate_idx]);
+
+                       pwr_info = &ch_info->power_info[rate_idx];
+
+                       /* get base (i.e. at factory-measured temperature)
+                        *    power table idx for this rate's power */
+                       rc = il3945_hw_reg_get_matched_power_idx(il, pwr,
+                                                                ch_info->
+                                                                group_idx,
+                                                                &power_idx);
+                       if (rc) {
+                               IL_ERR("Invalid power idx\n");
+                               return rc;
+                       }
+                       pwr_info->base_power_idx = (u8) power_idx;
+
+                       /* temperature compensate */
+                       power_idx += delta_idx;
+
+                       /* stay within range of gain table */
+                       power_idx = il3945_hw_reg_fix_power_idx(power_idx);
+
+                       /* fill 1 OFDM rate's il3945_channel_power_info struct */
+                       pwr_info->requested_power = pwr;
+                       pwr_info->power_table_idx = (u8) power_idx;
+                       pwr_info->tpc.tx_gain =
+                           power_gain_table[a_band][power_idx].tx_gain;
+                       pwr_info->tpc.dsp_atten =
+                           power_gain_table[a_band][power_idx].dsp_atten;
+               }
+
+               /* set tx power for CCK rates, based on OFDM 12 Mbit settings */
+               pwr_info = &ch_info->power_info[RATE_12M_IDX_TBL];
+               power = pwr_info->requested_power + IL_CCK_FROM_OFDM_POWER_DIFF;
+               pwr_idx = pwr_info->power_table_idx + IL_CCK_FROM_OFDM_IDX_DIFF;
+               base_pwr_idx =
+                   pwr_info->base_power_idx + IL_CCK_FROM_OFDM_IDX_DIFF;
+
+               /* stay within table range */
+               pwr_idx = il3945_hw_reg_fix_power_idx(pwr_idx);
+               gain = power_gain_table[a_band][pwr_idx].tx_gain;
+               dsp_atten = power_gain_table[a_band][pwr_idx].dsp_atten;
+
+               /* fill each CCK rate's il3945_channel_power_info structure
+                * NOTE:  All CCK-rate Txpwrs are the same for a given chnl!
+                * NOTE:  CCK rates start at end of OFDM rates! */
+               for (rate_idx = 0; rate_idx < IL_CCK_RATES; rate_idx++) {
+                       pwr_info =
+                           &ch_info->power_info[rate_idx + IL_OFDM_RATES];
+                       pwr_info->requested_power = power;
+                       pwr_info->power_table_idx = pwr_idx;
+                       pwr_info->base_power_idx = base_pwr_idx;
+                       pwr_info->tpc.tx_gain = gain;
+                       pwr_info->tpc.dsp_atten = dsp_atten;
+               }
+
+               /* set scan tx power, 1Mbit for CCK, 6Mbit for OFDM */
+               for (scan_tbl_idx = 0; scan_tbl_idx < IL_NUM_SCAN_RATES;
+                    scan_tbl_idx++) {
+                       s32 actual_idx =
+                           (scan_tbl_idx ==
+                            0) ? RATE_1M_IDX_TBL : RATE_6M_IDX_TBL;
+                       il3945_hw_reg_set_scan_power(il, scan_tbl_idx,
+                                                    actual_idx, clip_pwrs,
+                                                    ch_info, a_band);
+               }
+       }
+
+       return 0;
+}
+
+int
+il3945_hw_rxq_stop(struct il_priv *il)
+{
+       int ret;
+
+       _il_wr(il, FH39_RCSR_CONFIG(0), 0);
+       ret = _il_poll_bit(il, FH39_RSSR_STATUS,
+                          FH39_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
+                          FH39_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
+                          1000);
+       if (ret < 0)
+               IL_ERR("Can't stop Rx DMA.\n");
+
+       return 0;
+}
+
+int
+il3945_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq)
+{
+       int txq_id = txq->q.id;
+
+       struct il3945_shared *shared_data = il->_3945.shared_virt;
+
+       shared_data->tx_base_ptr[txq_id] = cpu_to_le32((u32) txq->q.dma_addr);
+
+       il_wr(il, FH39_CBCC_CTRL(txq_id), 0);
+       il_wr(il, FH39_CBCC_BASE(txq_id), 0);
+
+       il_wr(il, FH39_TCSR_CONFIG(txq_id),
+             FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_NOINT |
+             FH39_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_TXF |
+             FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_IFTFD |
+             FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL |
+             FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE);
+
+       /* fake read to flush all prev. writes */
+       _il_rd(il, FH39_TSSR_CBB_BASE);
+
+       return 0;
+}
+
+/*
+ * HCMD utils
+ */
+static u16
+il3945_get_hcmd_size(u8 cmd_id, u16 len)
+{
+       switch (cmd_id) {
+       case C_RXON:
+               return sizeof(struct il3945_rxon_cmd);
+       case C_POWER_TBL:
+               return sizeof(struct il3945_powertable_cmd);
+       default:
+               return len;
+       }
+}
+
+static u16
+il3945_build_addsta_hcmd(const struct il_addsta_cmd *cmd, u8 * data)
+{
+       struct il3945_addsta_cmd *addsta = (struct il3945_addsta_cmd *)data;
+       addsta->mode = cmd->mode;
+       memcpy(&addsta->sta, &cmd->sta, sizeof(struct sta_id_modify));
+       memcpy(&addsta->key, &cmd->key, sizeof(struct il4965_keyinfo));
+       addsta->station_flags = cmd->station_flags;
+       addsta->station_flags_msk = cmd->station_flags_msk;
+       addsta->tid_disable_tx = cpu_to_le16(0);
+       addsta->rate_n_flags = cmd->rate_n_flags;
+       addsta->add_immediate_ba_tid = cmd->add_immediate_ba_tid;
+       addsta->remove_immediate_ba_tid = cmd->remove_immediate_ba_tid;
+       addsta->add_immediate_ba_ssn = cmd->add_immediate_ba_ssn;
+
+       return (u16) sizeof(struct il3945_addsta_cmd);
+}
+
+static int
+il3945_add_bssid_station(struct il_priv *il, const u8 * addr, u8 * sta_id_r)
+{
+       int ret;
+       u8 sta_id;
+       unsigned long flags;
+
+       if (sta_id_r)
+               *sta_id_r = IL_INVALID_STATION;
+
+       ret = il_add_station_common(il, addr, 0, NULL, &sta_id);
+       if (ret) {
+               IL_ERR("Unable to add station %pM\n", addr);
+               return ret;
+       }
+
+       if (sta_id_r)
+               *sta_id_r = sta_id;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].used |= IL_STA_LOCAL;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return 0;
+}
+
+static int
+il3945_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
+                          bool add)
+{
+       struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
+       int ret;
+
+       if (add) {
+               ret =
+                   il3945_add_bssid_station(il, vif->bss_conf.bssid,
+                                            &vif_priv->ibss_bssid_sta_id);
+               if (ret)
+                       return ret;
+
+               il3945_sync_sta(il, vif_priv->ibss_bssid_sta_id,
+                               (il->band ==
+                                IEEE80211_BAND_5GHZ) ? RATE_6M_PLCP :
+                               RATE_1M_PLCP);
+               il3945_rate_scale_init(il->hw, vif_priv->ibss_bssid_sta_id);
+
+               return 0;
+       }
+
+       return il_remove_station(il, vif_priv->ibss_bssid_sta_id,
+                                vif->bss_conf.bssid);
+}
+
+/**
+ * il3945_init_hw_rate_table - Initialize the hardware rate fallback table
+ */
+int
+il3945_init_hw_rate_table(struct il_priv *il)
+{
+       int rc, i, idx, prev_idx;
+       struct il3945_rate_scaling_cmd rate_cmd = {
+               .reserved = {0, 0, 0},
+       };
+       struct il3945_rate_scaling_info *table = rate_cmd.table;
+
+       for (i = 0; i < ARRAY_SIZE(il3945_rates); i++) {
+               idx = il3945_rates[i].table_rs_idx;
+
+               table[idx].rate_n_flags = cpu_to_le16(il3945_rates[i].plcp);
+               table[idx].try_cnt = il->retry_rate;
+               prev_idx = il3945_get_prev_ieee_rate(i);
+               table[idx].next_rate_idx = il3945_rates[prev_idx].table_rs_idx;
+       }
+
+       switch (il->band) {
+       case IEEE80211_BAND_5GHZ:
+               D_RATE("Select A mode rate scale\n");
+               /* If one of the following CCK rates is used,
+                * have it fall back to the 6M OFDM rate */
+               for (i = RATE_1M_IDX_TBL; i <= RATE_11M_IDX_TBL; i++)
+                       table[i].next_rate_idx =
+                           il3945_rates[IL_FIRST_OFDM_RATE].table_rs_idx;
+
+               /* Don't fall back to CCK rates */
+               table[RATE_12M_IDX_TBL].next_rate_idx = RATE_9M_IDX_TBL;
+
+               /* Don't drop out of OFDM rates */
+               table[RATE_6M_IDX_TBL].next_rate_idx =
+                   il3945_rates[IL_FIRST_OFDM_RATE].table_rs_idx;
+               break;
+
+       case IEEE80211_BAND_2GHZ:
+               D_RATE("Select B/G mode rate scale\n");
+               /* If an OFDM rate is used, have it fall back to the
+                * 1M CCK rates */
+
+               if (!(il->_3945.sta_supp_rates & IL_OFDM_RATES_MASK) &&
+                   il_is_associated(il)) {
+
+                       idx = IL_FIRST_CCK_RATE;
+                       for (i = RATE_6M_IDX_TBL; i <= RATE_54M_IDX_TBL; i++)
+                               table[i].next_rate_idx =
+                                   il3945_rates[idx].table_rs_idx;
+
+                       idx = RATE_11M_IDX_TBL;
+                       /* CCK shouldn't fall back to OFDM... */
+                       table[idx].next_rate_idx = RATE_5M_IDX_TBL;
+               }
+               break;
+
+       default:
+               WARN_ON(1);
+               break;
+       }
+
+       /* Update the rate scaling for control frame Tx */
+       rate_cmd.table_id = 0;
+       rc = il_send_cmd_pdu(il, C_RATE_SCALE, sizeof(rate_cmd), &rate_cmd);
+       if (rc)
+               return rc;
+
+       /* Update the rate scaling for data frame Tx */
+       rate_cmd.table_id = 1;
+       return il_send_cmd_pdu(il, C_RATE_SCALE, sizeof(rate_cmd), &rate_cmd);
+}
+
+/* Called when initializing driver */
+int
+il3945_hw_set_hw_params(struct il_priv *il)
+{
+       memset((void *)&il->hw_params, 0, sizeof(struct il_hw_params));
+
+       il->_3945.shared_virt =
+           dma_alloc_coherent(&il->pci_dev->dev, sizeof(struct il3945_shared),
+                              &il->_3945.shared_phys, GFP_KERNEL);
+       if (!il->_3945.shared_virt)
+               return -ENOMEM;
+
+       il->hw_params.bcast_id = IL3945_BROADCAST_ID;
+
+       /* Assign number of Usable TX queues */
+       il->hw_params.max_txq_num = il->cfg->num_of_queues;
+
+       il->hw_params.tfd_size = sizeof(struct il3945_tfd);
+       il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_3K);
+       il->hw_params.max_rxq_size = RX_QUEUE_SIZE;
+       il->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
+       il->hw_params.max_stations = IL3945_STATION_COUNT;
+
+       il->sta_key_max_num = STA_KEY_MAX_NUM;
+
+       il->hw_params.rx_wrt_ptr_reg = FH39_RSCSR_CHNL0_WPTR;
+       il->hw_params.max_beacon_itrvl = IL39_MAX_UCODE_BEACON_INTERVAL;
+       il->hw_params.beacon_time_tsf_bits = IL3945_EXT_BEACON_TIME_POS;
+
+       return 0;
+}
+
+unsigned int
+il3945_hw_get_beacon_cmd(struct il_priv *il, struct il3945_frame *frame,
+                        u8 rate)
+{
+       struct il3945_tx_beacon_cmd *tx_beacon_cmd;
+       unsigned int frame_size;
+
+       tx_beacon_cmd = (struct il3945_tx_beacon_cmd *)&frame->u;
+       memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
+
+       tx_beacon_cmd->tx.sta_id = il->hw_params.bcast_id;
+       tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
+
+       frame_size =
+           il3945_fill_beacon_frame(il, tx_beacon_cmd->frame,
+                                    sizeof(frame->u) - sizeof(*tx_beacon_cmd));
+
+       BUG_ON(frame_size > MAX_MPDU_SIZE);
+       tx_beacon_cmd->tx.len = cpu_to_le16((u16) frame_size);
+
+       tx_beacon_cmd->tx.rate = rate;
+       tx_beacon_cmd->tx.tx_flags =
+           (TX_CMD_FLG_SEQ_CTL_MSK | TX_CMD_FLG_TSF_MSK);
+
+       /* supp_rates[0] == OFDM start at IL_FIRST_OFDM_RATE */
+       tx_beacon_cmd->tx.supp_rates[0] =
+           (IL_OFDM_BASIC_RATES_MASK >> IL_FIRST_OFDM_RATE) & 0xFF;
+
+       tx_beacon_cmd->tx.supp_rates[1] = (IL_CCK_BASIC_RATES_MASK & 0xF);
+
+       return sizeof(struct il3945_tx_beacon_cmd) + frame_size;
+}
+
+void
+il3945_hw_handler_setup(struct il_priv *il)
+{
+       il->handlers[C_TX] = il3945_hdl_tx;
+       il->handlers[N_3945_RX] = il3945_hdl_rx;
+}
+
+void
+il3945_hw_setup_deferred_work(struct il_priv *il)
+{
+       INIT_DELAYED_WORK(&il->_3945.thermal_periodic,
+                         il3945_bg_reg_txpower_periodic);
+}
+
+void
+il3945_hw_cancel_deferred_work(struct il_priv *il)
+{
+       cancel_delayed_work(&il->_3945.thermal_periodic);
+}
+
+/* check contents of special bootstrap uCode SRAM */
+static int
+il3945_verify_bsm(struct il_priv *il)
+{
+       __le32 *image = il->ucode_boot.v_addr;
+       u32 len = il->ucode_boot.len;
+       u32 reg;
+       u32 val;
+
+       D_INFO("Begin verify bsm\n");
+
+       /* verify BSM SRAM contents */
+       val = il_rd_prph(il, BSM_WR_DWCOUNT_REG);
+       for (reg = BSM_SRAM_LOWER_BOUND; reg < BSM_SRAM_LOWER_BOUND + len;
+            reg += sizeof(u32), image++) {
+               val = il_rd_prph(il, reg);
+               if (val != le32_to_cpu(*image)) {
+                       IL_ERR("BSM uCode verification failed at "
+                              "addr 0x%08X+%u (of %u), is 0x%x, s/b 0x%x\n",
+                              BSM_SRAM_LOWER_BOUND, reg - BSM_SRAM_LOWER_BOUND,
+                              len, val, le32_to_cpu(*image));
+                       return -EIO;
+               }
+       }
+
+       D_INFO("BSM bootstrap uCode image OK\n");
+
+       return 0;
+}
+
+/******************************************************************************
+ *
+ * EEPROM related functions
+ *
+ ******************************************************************************/
+
+/*
+ * Clear the OWNER_MSK, to establish driver (instead of uCode running on
+ * embedded controller) as EEPROM reader; each read is a series of pulses
+ * to/from the EEPROM chip, not a single event, so even reads could conflict
+ * if they weren't arbitrated by some ownership mechanism.  Here, the driver
+ * simply claims ownership, which should be safe when this function is called
+ * (i.e. before loading uCode!).
+ */
+static int
+il3945_eeprom_acquire_semaphore(struct il_priv *il)
+{
+       _il_clear_bit(il, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
+       return 0;
+}
+
+static void
+il3945_eeprom_release_semaphore(struct il_priv *il)
+{
+       return;
+}
+
+ /**
+  * il3945_load_bsm - Load bootstrap instructions
+  *
+  * BSM operation:
+  *
+  * The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
+  * in special SRAM that does not power down during RFKILL.  When powering back
+  * up after power-saving sleeps (or during initial uCode load), the BSM loads
+  * the bootstrap program into the on-board processor, and starts it.
+  *
+  * The bootstrap program loads (via DMA) instructions and data for a new
+  * program from host DRAM locations indicated by the host driver in the
+  * BSM_DRAM_* registers.  Once the new program is loaded, it starts
+  * automatically.
+  *
+  * When initializing the NIC, the host driver points the BSM to the
+  * "initialize" uCode image.  This uCode sets up some internal data, then
+  * notifies host via "initialize alive" that it is complete.
+  *
+  * The host then replaces the BSM_DRAM_* pointer values to point to the
+  * normal runtime uCode instructions and a backup uCode data cache buffer
+  * (filled initially with starting data values for the on-board processor),
+  * then triggers the "initialize" uCode to load and launch the runtime uCode,
+  * which begins normal operation.
+  *
+  * When doing a power-save shutdown, runtime uCode saves data SRAM into
+  * the backup data cache in DRAM before SRAM is powered down.
+  *
+  * When powering back up, the BSM loads the bootstrap program.  This reloads
+  * the runtime uCode instructions and the backup data cache into SRAM,
+  * and re-launches the runtime uCode from where it left off.
+  */
+static int
+il3945_load_bsm(struct il_priv *il)
+{
+       __le32 *image = il->ucode_boot.v_addr;
+       u32 len = il->ucode_boot.len;
+       dma_addr_t pinst;
+       dma_addr_t pdata;
+       u32 inst_len;
+       u32 data_len;
+       int rc;
+       int i;
+       u32 done;
+       u32 reg_offset;
+
+       D_INFO("Begin load bsm\n");
+
+       /* make sure bootstrap program is no larger than BSM's SRAM size */
+       if (len > IL39_MAX_BSM_SIZE)
+               return -EINVAL;
+
+       /* Tell bootstrap uCode where to find the "Initialize" uCode
+        *   in host DRAM ... host DRAM physical address bits 31:0 for 3945.
+        * NOTE:  il3945_initialize_alive_start() will replace these values,
+        *        after the "initialize" uCode has run, to point to
+        *        runtime/protocol instructions and backup data cache. */
+       pinst = il->ucode_init.p_addr;
+       pdata = il->ucode_init_data.p_addr;
+       inst_len = il->ucode_init.len;
+       data_len = il->ucode_init_data.len;
+
+       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
+       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
+       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
+       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
+
+       /* Fill BSM memory with bootstrap instructions */
+       for (reg_offset = BSM_SRAM_LOWER_BOUND;
+            reg_offset < BSM_SRAM_LOWER_BOUND + len;
+            reg_offset += sizeof(u32), image++)
+               _il_wr_prph(il, reg_offset, le32_to_cpu(*image));
+
+       rc = il3945_verify_bsm(il);
+       if (rc)
+               return rc;
+
+       /* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
+       il_wr_prph(il, BSM_WR_MEM_SRC_REG, 0x0);
+       il_wr_prph(il, BSM_WR_MEM_DST_REG, IL39_RTC_INST_LOWER_BOUND);
+       il_wr_prph(il, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
+
+       /* Load bootstrap code into instruction SRAM now,
+        *   to prepare to load "initialize" uCode */
+       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START);
+
+       /* Wait for load of bootstrap uCode to finish */
+       for (i = 0; i < 100; i++) {
+               done = il_rd_prph(il, BSM_WR_CTRL_REG);
+               if (!(done & BSM_WR_CTRL_REG_BIT_START))
+                       break;
+               udelay(10);
+       }
+       if (i < 100)
+               D_INFO("BSM write complete, poll %d iterations\n", i);
+       else {
+               IL_ERR("BSM write did not complete!\n");
+               return -EIO;
+       }
+
+       /* Enable future boot loads whenever power management unit triggers it
+        *   (e.g. when powering back up after power-save shutdown) */
+       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START_EN);
+
+       return 0;
+}
+
+const struct il_ops il3945_ops = {
+       .txq_attach_buf_to_tfd = il3945_hw_txq_attach_buf_to_tfd,
+       .txq_free_tfd = il3945_hw_txq_free_tfd,
+       .txq_init = il3945_hw_tx_queue_init,
+       .load_ucode = il3945_load_bsm,
+       .dump_nic_error_log = il3945_dump_nic_error_log,
+       .apm_init = il3945_apm_init,
+       .send_tx_power = il3945_send_tx_power,
+       .is_valid_rtc_data_addr = il3945_hw_valid_rtc_data_addr,
+       .eeprom_acquire_semaphore = il3945_eeprom_acquire_semaphore,
+       .eeprom_release_semaphore = il3945_eeprom_release_semaphore,
+
+       .rxon_assoc = il3945_send_rxon_assoc,
+       .commit_rxon = il3945_commit_rxon,
+
+       .get_hcmd_size = il3945_get_hcmd_size,
+       .build_addsta_hcmd = il3945_build_addsta_hcmd,
+       .request_scan = il3945_request_scan,
+       .post_scan = il3945_post_scan,
+
+       .post_associate = il3945_post_associate,
+       .config_ap = il3945_config_ap,
+       .manage_ibss_station = il3945_manage_ibss_station,
+
+       .send_led_cmd = il3945_send_led_cmd,
+};
+
+static struct il_cfg il3945_bg_cfg = {
+       .name = "3945BG",
+       .fw_name_pre = IL3945_FW_PRE,
+       .ucode_api_max = IL3945_UCODE_API_MAX,
+       .ucode_api_min = IL3945_UCODE_API_MIN,
+       .sku = IL_SKU_G,
+       .eeprom_ver = EEPROM_3945_EEPROM_VERSION,
+       .mod_params = &il3945_mod_params,
+       .led_mode = IL_LED_BLINK,
+
+       .eeprom_size = IL3945_EEPROM_IMG_SIZE,
+       .num_of_queues = IL39_NUM_QUEUES,
+       .pll_cfg_val = CSR39_ANA_PLL_CFG_VAL,
+       .set_l0s = false,
+       .use_bsm = true,
+       .led_compensation = 64,
+       .wd_timeout = IL_DEF_WD_TIMEOUT,
+
+       .regulatory_bands = {
+               EEPROM_REGULATORY_BAND_1_CHANNELS,
+               EEPROM_REGULATORY_BAND_2_CHANNELS,
+               EEPROM_REGULATORY_BAND_3_CHANNELS,
+               EEPROM_REGULATORY_BAND_4_CHANNELS,
+               EEPROM_REGULATORY_BAND_5_CHANNELS,
+               EEPROM_REGULATORY_BAND_NO_HT40,
+               EEPROM_REGULATORY_BAND_NO_HT40,
+       },
+};
+
+static struct il_cfg il3945_abg_cfg = {
+       .name = "3945ABG",
+       .fw_name_pre = IL3945_FW_PRE,
+       .ucode_api_max = IL3945_UCODE_API_MAX,
+       .ucode_api_min = IL3945_UCODE_API_MIN,
+       .sku = IL_SKU_A | IL_SKU_G,
+       .eeprom_ver = EEPROM_3945_EEPROM_VERSION,
+       .mod_params = &il3945_mod_params,
+       .led_mode = IL_LED_BLINK,
+
+       .eeprom_size = IL3945_EEPROM_IMG_SIZE,
+       .num_of_queues = IL39_NUM_QUEUES,
+       .pll_cfg_val = CSR39_ANA_PLL_CFG_VAL,
+       .set_l0s = false,
+       .use_bsm = true,
+       .led_compensation = 64,
+       .wd_timeout = IL_DEF_WD_TIMEOUT,
+
+       .regulatory_bands = {
+               EEPROM_REGULATORY_BAND_1_CHANNELS,
+               EEPROM_REGULATORY_BAND_2_CHANNELS,
+               EEPROM_REGULATORY_BAND_3_CHANNELS,
+               EEPROM_REGULATORY_BAND_4_CHANNELS,
+               EEPROM_REGULATORY_BAND_5_CHANNELS,
+               EEPROM_REGULATORY_BAND_NO_HT40,
+               EEPROM_REGULATORY_BAND_NO_HT40,
+       },
+};
+
+const struct pci_device_id il3945_hw_card_ids[] = {
+       {IL_PCI_DEVICE(0x4222, 0x1005, il3945_bg_cfg)},
+       {IL_PCI_DEVICE(0x4222, 0x1034, il3945_bg_cfg)},
+       {IL_PCI_DEVICE(0x4222, 0x1044, il3945_bg_cfg)},
+       {IL_PCI_DEVICE(0x4227, 0x1014, il3945_bg_cfg)},
+       {IL_PCI_DEVICE(0x4222, PCI_ANY_ID, il3945_abg_cfg)},
+       {IL_PCI_DEVICE(0x4227, PCI_ANY_ID, il3945_abg_cfg)},
+       {0}
+};
+
+MODULE_DEVICE_TABLE(pci, il3945_hw_card_ids);
diff --git a/drivers/net/wireless/intel/iwlegacy/3945.h b/drivers/net/wireless/intel/iwlegacy/3945.h
new file mode 100644 (file)
index 0000000..00030d4
--- /dev/null
@@ -0,0 +1,593 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#ifndef __il_3945_h__
+#define __il_3945_h__
+
+#include <linux/pci.h>         /* for struct pci_device_id */
+#include <linux/kernel.h>
+#include <net/ieee80211_radiotap.h>
+
+/* Hardware specific file defines the PCI IDs table for that hardware module */
+extern const struct pci_device_id il3945_hw_card_ids[];
+
+#include "common.h"
+
+extern const struct il_ops il3945_ops;
+
+/* Highest firmware API version supported */
+#define IL3945_UCODE_API_MAX 2
+
+/* Lowest firmware API version supported */
+#define IL3945_UCODE_API_MIN 1
+
+#define IL3945_FW_PRE  "iwlwifi-3945-"
+#define _IL3945_MODULE_FIRMWARE(api) IL3945_FW_PRE #api ".ucode"
+#define IL3945_MODULE_FIRMWARE(api) _IL3945_MODULE_FIRMWARE(api)
+
+/* Default noise level to report when noise measurement is not available.
+ *   This may be because we're:
+ *   1)  Not associated (4965, no beacon stats being sent to driver)
+ *   2)  Scanning (noise measurement does not apply to associated channel)
+ *   3)  Receiving CCK (3945 delivers noise info only for OFDM frames)
+ * Use default noise value of -127 ... this is below the range of measurable
+ *   Rx dBm for either 3945 or 4965, so it can indicate "unmeasurable" to user.
+ *   Also, -127 works better than 0 when averaging frames with/without
+ *   noise info (e.g. averaging might be done in app); measured dBm values are
+ *   always negative ... using a negative value as the default keeps all
+ *   averages within an s8's (used in some apps) range of negative values. */
+#define IL_NOISE_MEAS_NOT_AVAILABLE (-127)
+
+/* Module parameters accessible from iwl-*.c */
+extern struct il_mod_params il3945_mod_params;
+
+struct il3945_rate_scale_data {
+       u64 data;
+       s32 success_counter;
+       s32 success_ratio;
+       s32 counter;
+       s32 average_tpt;
+       unsigned long stamp;
+};
+
+struct il3945_rs_sta {
+       spinlock_t lock;
+       struct il_priv *il;
+       s32 *expected_tpt;
+       unsigned long last_partial_flush;
+       unsigned long last_flush;
+       u32 flush_time;
+       u32 last_tx_packets;
+       u32 tx_packets;
+       u8 tgg;
+       u8 flush_pending;
+       u8 start_rate;
+       struct timer_list rate_scale_flush;
+       struct il3945_rate_scale_data win[RATE_COUNT_3945];
+#ifdef CONFIG_MAC80211_DEBUGFS
+       struct dentry *rs_sta_dbgfs_stats_table_file;
+#endif
+
+       /* used to be in sta_info */
+       int last_txrate_idx;
+};
+
+/*
+ * The common struct MUST be first because it is shared between
+ * 3945 and 4965!
+ */
+struct il3945_sta_priv {
+       struct il_station_priv_common common;
+       struct il3945_rs_sta rs_sta;
+};
+
+enum il3945_antenna {
+       IL_ANTENNA_DIVERSITY,
+       IL_ANTENNA_MAIN,
+       IL_ANTENNA_AUX
+};
+
+/*
+ * RTS threshold here is total size [2347] minus 4 FCS bytes
+ * Per spec:
+ *   a value of 0 means RTS on all data/management packets
+ *   a value > max MSDU size means no RTS
+ * else RTS for data/management frames where MPDU is larger
+ *   than RTS value.
+ */
+#define DEFAULT_RTS_THRESHOLD     2347U
+#define MIN_RTS_THRESHOLD         0U
+#define MAX_RTS_THRESHOLD         2347U
+#define MAX_MSDU_SIZE            2304U
+#define MAX_MPDU_SIZE            2346U
+#define DEFAULT_BEACON_INTERVAL   100U
+#define        DEFAULT_SHORT_RETRY_LIMIT 7U
+#define        DEFAULT_LONG_RETRY_LIMIT  4U
+
+#define IL_TX_FIFO_AC0 0
+#define IL_TX_FIFO_AC1 1
+#define IL_TX_FIFO_AC2 2
+#define IL_TX_FIFO_AC3 3
+#define IL_TX_FIFO_HCCA_1      5
+#define IL_TX_FIFO_HCCA_2      6
+#define IL_TX_FIFO_NONE        7
+
+#define IEEE80211_DATA_LEN              2304
+#define IEEE80211_4ADDR_LEN             30
+#define IEEE80211_HLEN                  (IEEE80211_4ADDR_LEN)
+#define IEEE80211_FRAME_LEN             (IEEE80211_DATA_LEN + IEEE80211_HLEN)
+
+struct il3945_frame {
+       union {
+               struct ieee80211_hdr frame;
+               struct il3945_tx_beacon_cmd beacon;
+               u8 raw[IEEE80211_FRAME_LEN];
+               u8 cmd[360];
+       } u;
+       struct list_head list;
+};
+
+#define SUP_RATE_11A_MAX_NUM_CHANNELS  8
+#define SUP_RATE_11B_MAX_NUM_CHANNELS  4
+#define SUP_RATE_11G_MAX_NUM_CHANNELS  12
+
+#define IL_SUPPORTED_RATES_IE_LEN         8
+
+#define SCAN_INTERVAL 100
+
+#define MAX_TID_COUNT        9
+
+#define IL_INVALID_RATE     0xFF
+#define IL_INVALID_VALUE    -1
+
+#define STA_PS_STATUS_WAKE             0
+#define STA_PS_STATUS_SLEEP            1
+
+struct il3945_ibss_seq {
+       u8 mac[ETH_ALEN];
+       u16 seq_num;
+       u16 frag_num;
+       unsigned long packet_time;
+       struct list_head list;
+};
+
+#define IL_RX_HDR(x) ((struct il3945_rx_frame_hdr *)(\
+                      x->u.rx_frame.stats.payload + \
+                      x->u.rx_frame.stats.phy_count))
+#define IL_RX_END(x) ((struct il3945_rx_frame_end *)(\
+                      IL_RX_HDR(x)->payload + \
+                      le16_to_cpu(IL_RX_HDR(x)->len)))
+#define IL_RX_STATS(x) (&x->u.rx_frame.stats)
+#define IL_RX_DATA(x) (IL_RX_HDR(x)->payload)
+
+/******************************************************************************
+ *
+ * Functions implemented in iwl3945-base.c which are forward declared here
+ * for use by iwl-*.c
+ *
+ *****************************************************************************/
+int il3945_calc_db_from_ratio(int sig_ratio);
+void il3945_rx_replenish(void *data);
+void il3945_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq);
+unsigned int il3945_fill_beacon_frame(struct il_priv *il,
+                                     struct ieee80211_hdr *hdr, int left);
+int il3945_dump_nic_event_log(struct il_priv *il, bool full_log, char **buf,
+                             bool display);
+void il3945_dump_nic_error_log(struct il_priv *il);
+
+/******************************************************************************
+ *
+ * Functions implemented in iwl-[34]*.c which are forward declared here
+ * for use by iwl3945-base.c
+ *
+ * NOTE:  The implementation of these functions are hardware specific
+ * which is why they are in the hardware specific files (vs. iwl-base.c)
+ *
+ * Naming convention --
+ * il3945_         <-- Its part of iwlwifi (should be changed to il3945_)
+ * il3945_hw_      <-- Hardware specific (implemented in iwl-XXXX.c by all HW)
+ * iwlXXXX_     <-- Hardware specific (implemented in iwl-XXXX.c for XXXX)
+ * il3945_bg_      <-- Called from work queue context
+ * il3945_mac_     <-- mac80211 callback
+ *
+ ****************************************************************************/
+void il3945_hw_handler_setup(struct il_priv *il);
+void il3945_hw_setup_deferred_work(struct il_priv *il);
+void il3945_hw_cancel_deferred_work(struct il_priv *il);
+int il3945_hw_rxq_stop(struct il_priv *il);
+int il3945_hw_set_hw_params(struct il_priv *il);
+int il3945_hw_nic_init(struct il_priv *il);
+int il3945_hw_nic_stop_master(struct il_priv *il);
+void il3945_hw_txq_ctx_free(struct il_priv *il);
+void il3945_hw_txq_ctx_stop(struct il_priv *il);
+int il3945_hw_nic_reset(struct il_priv *il);
+int il3945_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
+                                   dma_addr_t addr, u16 len, u8 reset, u8 pad);
+void il3945_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq);
+int il3945_hw_get_temperature(struct il_priv *il);
+int il3945_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq);
+unsigned int il3945_hw_get_beacon_cmd(struct il_priv *il,
+                                     struct il3945_frame *frame, u8 rate);
+void il3945_hw_build_tx_cmd_rate(struct il_priv *il, struct il_device_cmd *cmd,
+                                struct ieee80211_tx_info *info,
+                                struct ieee80211_hdr *hdr, int sta_id);
+int il3945_hw_reg_send_txpower(struct il_priv *il);
+int il3945_hw_reg_set_txpower(struct il_priv *il, s8 power);
+void il3945_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb);
+void il3945_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb);
+void il3945_disable_events(struct il_priv *il);
+int il4965_get_temperature(const struct il_priv *il);
+void il3945_post_associate(struct il_priv *il);
+void il3945_config_ap(struct il_priv *il);
+
+int il3945_commit_rxon(struct il_priv *il);
+
+/**
+ * il3945_hw_find_station - Find station id for a given BSSID
+ * @bssid: MAC address of station ID to find
+ *
+ * NOTE:  This should not be hardware specific but the code has
+ * not yet been merged into a single common layer for managing the
+ * station tables.
+ */
+u8 il3945_hw_find_station(struct il_priv *il, const u8 *bssid);
+
+__le32 il3945_get_antenna_flags(const struct il_priv *il);
+int il3945_init_hw_rate_table(struct il_priv *il);
+void il3945_reg_txpower_periodic(struct il_priv *il);
+int il3945_txpower_set_from_eeprom(struct il_priv *il);
+
+int il3945_rs_next_rate(struct il_priv *il, int rate);
+
+/* scanning */
+int il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif);
+void il3945_post_scan(struct il_priv *il);
+
+/* rates */
+extern const struct il3945_rate_info il3945_rates[RATE_COUNT_3945];
+
+/* RSSI to dBm */
+#define IL39_RSSI_OFFSET       95
+
+/*
+ * EEPROM related constants, enums, and structures.
+ */
+#define EEPROM_SKU_CAP_OP_MODE_MRC                      (1 << 7)
+
+/*
+ * Mapping of a Tx power level, at factory calibration temperature,
+ *   to a radio/DSP gain table idx.
+ * One for each of 5 "sample" power levels in each band.
+ * v_det is measured at the factory, using the 3945's built-in power amplifier
+ *   (PA) output voltage detector.  This same detector is used during Tx of
+ *   long packets in normal operation to provide feedback as to proper output
+ *   level.
+ * Data copied from EEPROM.
+ * DO NOT ALTER THIS STRUCTURE!!!
+ */
+struct il3945_eeprom_txpower_sample {
+       u8 gain_idx;            /* idx into power (gain) setup table ... */
+       s8 power;               /* ... for this pwr level for this chnl group */
+       u16 v_det;              /* PA output voltage */
+} __packed;
+
+/*
+ * Mappings of Tx power levels -> nominal radio/DSP gain table idxes.
+ * One for each channel group (a.k.a. "band") (1 for BG, 4 for A).
+ * Tx power setup code interpolates between the 5 "sample" power levels
+ *    to determine the nominal setup for a requested power level.
+ * Data copied from EEPROM.
+ * DO NOT ALTER THIS STRUCTURE!!!
+ */
+struct il3945_eeprom_txpower_group {
+       struct il3945_eeprom_txpower_sample samples[5]; /* 5 power levels */
+       s32 a, b, c, d, e;      /* coefficients for voltage->power
+                                * formula (signed) */
+       s32 Fa, Fb, Fc, Fd, Fe; /* these modify coeffs based on
+                                * frequency (signed) */
+       s8 saturation_power;    /* highest power possible by h/w in this
+                                * band */
+       u8 group_channel;       /* "representative" channel # in this band */
+       s16 temperature;        /* h/w temperature at factory calib this band
+                                * (signed) */
+} __packed;
+
+/*
+ * Temperature-based Tx-power compensation data, not band-specific.
+ * These coefficients are use to modify a/b/c/d/e coeffs based on
+ *   difference between current temperature and factory calib temperature.
+ * Data copied from EEPROM.
+ */
+struct il3945_eeprom_temperature_corr {
+       u32 Ta;
+       u32 Tb;
+       u32 Tc;
+       u32 Td;
+       u32 Te;
+} __packed;
+
+/*
+ * EEPROM map
+ */
+struct il3945_eeprom {
+       u8 reserved0[16];
+       u16 device_id;          /* abs.ofs: 16 */
+       u8 reserved1[2];
+       u16 pmc;                /* abs.ofs: 20 */
+       u8 reserved2[20];
+       u8 mac_address[6];      /* abs.ofs: 42 */
+       u8 reserved3[58];
+       u16 board_revision;     /* abs.ofs: 106 */
+       u8 reserved4[11];
+       u8 board_pba_number[9]; /* abs.ofs: 119 */
+       u8 reserved5[8];
+       u16 version;            /* abs.ofs: 136 */
+       u8 sku_cap;             /* abs.ofs: 138 */
+       u8 leds_mode;           /* abs.ofs: 139 */
+       u16 oem_mode;
+       u16 wowlan_mode;        /* abs.ofs: 142 */
+       u16 leds_time_interval; /* abs.ofs: 144 */
+       u8 leds_off_time;       /* abs.ofs: 146 */
+       u8 leds_on_time;        /* abs.ofs: 147 */
+       u8 almgor_m_version;    /* abs.ofs: 148 */
+       u8 antenna_switch_type; /* abs.ofs: 149 */
+       u8 reserved6[42];
+       u8 sku_id[4];           /* abs.ofs: 192 */
+
+/*
+ * Per-channel regulatory data.
+ *
+ * Each channel that *might* be supported by 3945 has a fixed location
+ * in EEPROM containing EEPROM_CHANNEL_* usage flags (LSB) and max regulatory
+ * txpower (MSB).
+ *
+ * Entries immediately below are for 20 MHz channel width.
+ *
+ * 2.4 GHz channels 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
+ */
+       u16 band_1_count;       /* abs.ofs: 196 */
+       struct il_eeprom_channel band_1_channels[14];   /* abs.ofs: 198 */
+
+/*
+ * 4.9 GHz channels 183, 184, 185, 187, 188, 189, 192, 196,
+ * 5.0 GHz channels 7, 8, 11, 12, 16
+ * (4915-5080MHz) (none of these is ever supported)
+ */
+       u16 band_2_count;       /* abs.ofs: 226 */
+       struct il_eeprom_channel band_2_channels[13];   /* abs.ofs: 228 */
+
+/*
+ * 5.2 GHz channels 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
+ * (5170-5320MHz)
+ */
+       u16 band_3_count;       /* abs.ofs: 254 */
+       struct il_eeprom_channel band_3_channels[12];   /* abs.ofs: 256 */
+
+/*
+ * 5.5 GHz channels 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
+ * (5500-5700MHz)
+ */
+       u16 band_4_count;       /* abs.ofs: 280 */
+       struct il_eeprom_channel band_4_channels[11];   /* abs.ofs: 282 */
+
+/*
+ * 5.7 GHz channels 145, 149, 153, 157, 161, 165
+ * (5725-5825MHz)
+ */
+       u16 band_5_count;       /* abs.ofs: 304 */
+       struct il_eeprom_channel band_5_channels[6];    /* abs.ofs: 306 */
+
+       u8 reserved9[194];
+
+/*
+ * 3945 Txpower calibration data.
+ */
+#define IL_NUM_TX_CALIB_GROUPS 5
+       struct il3945_eeprom_txpower_group groups[IL_NUM_TX_CALIB_GROUPS];
+/* abs.ofs: 512 */
+       struct il3945_eeprom_temperature_corr corrections;      /* abs.ofs: 832 */
+       u8 reserved16[172];     /* fill out to full 1024 byte block */
+} __packed;
+
+#define IL3945_EEPROM_IMG_SIZE 1024
+
+/* End of EEPROM */
+
+#define PCI_CFG_REV_ID_BIT_BASIC_SKU                (0x40)     /* bit 6    */
+#define PCI_CFG_REV_ID_BIT_RTP                      (0x80)     /* bit 7    */
+
+/* 4 DATA + 1 CMD. There are 2 HCCA queues that are not used. */
+#define IL39_NUM_QUEUES        5
+#define IL39_CMD_QUEUE_NUM     4
+
+#define IL_DEFAULT_TX_RETRY  15
+
+/*********************************************/
+
+#define RFD_SIZE                              4
+#define NUM_TFD_CHUNKS                        4
+
+#define TFD_CTL_COUNT_SET(n)       (n << 24)
+#define TFD_CTL_COUNT_GET(ctl)     ((ctl >> 24) & 7)
+#define TFD_CTL_PAD_SET(n)         (n << 28)
+#define TFD_CTL_PAD_GET(ctl)       (ctl >> 28)
+
+/* Sizes and addresses for instruction and data memory (SRAM) in
+ * 3945's embedded processor.  Driver access is via HBUS_TARG_MEM_* regs. */
+#define IL39_RTC_INST_LOWER_BOUND              (0x000000)
+#define IL39_RTC_INST_UPPER_BOUND              (0x014000)
+
+#define IL39_RTC_DATA_LOWER_BOUND              (0x800000)
+#define IL39_RTC_DATA_UPPER_BOUND              (0x808000)
+
+#define IL39_RTC_INST_SIZE (IL39_RTC_INST_UPPER_BOUND - \
+                               IL39_RTC_INST_LOWER_BOUND)
+#define IL39_RTC_DATA_SIZE (IL39_RTC_DATA_UPPER_BOUND - \
+                               IL39_RTC_DATA_LOWER_BOUND)
+
+#define IL39_MAX_INST_SIZE IL39_RTC_INST_SIZE
+#define IL39_MAX_DATA_SIZE IL39_RTC_DATA_SIZE
+
+/* Size of uCode instruction memory in bootstrap state machine */
+#define IL39_MAX_BSM_SIZE IL39_RTC_INST_SIZE
+
+static inline int
+il3945_hw_valid_rtc_data_addr(u32 addr)
+{
+       return (addr >= IL39_RTC_DATA_LOWER_BOUND &&
+               addr < IL39_RTC_DATA_UPPER_BOUND);
+}
+
+/* Base physical address of il3945_shared is provided to FH39_TSSR_CBB_BASE
+ * and &il3945_shared.rx_read_ptr[0] is provided to FH39_RCSR_RPTR_ADDR(0) */
+struct il3945_shared {
+       __le32 tx_base_ptr[8];
+} __packed;
+
+/************************************/
+/* iwl3945 Flow Handler Definitions */
+/************************************/
+
+/**
+ * This I/O area is directly read/writable by driver (e.g. Linux uses writel())
+ * Addresses are offsets from device's PCI hardware base address.
+ */
+#define FH39_MEM_LOWER_BOUND                   (0x0800)
+#define FH39_MEM_UPPER_BOUND                   (0x1000)
+
+#define FH39_CBCC_TBL          (FH39_MEM_LOWER_BOUND + 0x140)
+#define FH39_TFDB_TBL          (FH39_MEM_LOWER_BOUND + 0x180)
+#define FH39_RCSR_TBL          (FH39_MEM_LOWER_BOUND + 0x400)
+#define FH39_RSSR_TBL          (FH39_MEM_LOWER_BOUND + 0x4c0)
+#define FH39_TCSR_TBL          (FH39_MEM_LOWER_BOUND + 0x500)
+#define FH39_TSSR_TBL          (FH39_MEM_LOWER_BOUND + 0x680)
+
+/* TFDB (Transmit Frame Buffer Descriptor) */
+#define FH39_TFDB(_ch, buf)                    (FH39_TFDB_TBL + \
+                                                ((_ch) * 2 + (buf)) * 0x28)
+#define FH39_TFDB_CHNL_BUF_CTRL_REG(_ch)       (FH39_TFDB_TBL + 0x50 * (_ch))
+
+/* CBCC channel is [0,2] */
+#define FH39_CBCC(_ch)         (FH39_CBCC_TBL + (_ch) * 0x8)
+#define FH39_CBCC_CTRL(_ch)    (FH39_CBCC(_ch) + 0x00)
+#define FH39_CBCC_BASE(_ch)    (FH39_CBCC(_ch) + 0x04)
+
+/* RCSR channel is [0,2] */
+#define FH39_RCSR(_ch)                 (FH39_RCSR_TBL + (_ch) * 0x40)
+#define FH39_RCSR_CONFIG(_ch)          (FH39_RCSR(_ch) + 0x00)
+#define FH39_RCSR_RBD_BASE(_ch)                (FH39_RCSR(_ch) + 0x04)
+#define FH39_RCSR_WPTR(_ch)            (FH39_RCSR(_ch) + 0x20)
+#define FH39_RCSR_RPTR_ADDR(_ch)       (FH39_RCSR(_ch) + 0x24)
+
+#define FH39_RSCSR_CHNL0_WPTR          (FH39_RCSR_WPTR(0))
+
+/* RSSR */
+#define FH39_RSSR_CTRL                 (FH39_RSSR_TBL + 0x000)
+#define FH39_RSSR_STATUS               (FH39_RSSR_TBL + 0x004)
+
+/* TCSR */
+#define FH39_TCSR(_ch)                 (FH39_TCSR_TBL + (_ch) * 0x20)
+#define FH39_TCSR_CONFIG(_ch)          (FH39_TCSR(_ch) + 0x00)
+#define FH39_TCSR_CREDIT(_ch)          (FH39_TCSR(_ch) + 0x04)
+#define FH39_TCSR_BUFF_STTS(_ch)       (FH39_TCSR(_ch) + 0x08)
+
+/* TSSR */
+#define FH39_TSSR_CBB_BASE        (FH39_TSSR_TBL + 0x000)
+#define FH39_TSSR_MSG_CONFIG      (FH39_TSSR_TBL + 0x008)
+#define FH39_TSSR_TX_STATUS       (FH39_TSSR_TBL + 0x010)
+
+/* DBM */
+
+#define FH39_SRVC_CHNL                            (6)
+
+#define FH39_RCSR_RX_CONFIG_REG_POS_RBDC_SIZE     (20)
+#define FH39_RCSR_RX_CONFIG_REG_POS_IRQ_RBTH      (4)
+
+#define FH39_RCSR_RX_CONFIG_REG_BIT_WR_STTS_EN    (0x08000000)
+
+#define FH39_RCSR_RX_CONFIG_REG_VAL_DMA_CHNL_EN_ENABLE        (0x80000000)
+
+#define FH39_RCSR_RX_CONFIG_REG_VAL_RDRBD_EN_ENABLE           (0x20000000)
+
+#define FH39_RCSR_RX_CONFIG_REG_VAL_MAX_FRAG_SIZE_128          (0x01000000)
+
+#define FH39_RCSR_RX_CONFIG_REG_VAL_IRQ_DEST_INT_HOST          (0x00001000)
+
+#define FH39_RCSR_RX_CONFIG_REG_VAL_MSG_MODE_FH                        (0x00000000)
+
+#define FH39_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_TXF               (0x00000000)
+#define FH39_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_DRIVER            (0x00000001)
+
+#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_DISABLE_VAL     (0x00000000)
+#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL      (0x00000008)
+
+#define FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_IFTFD            (0x00200000)
+
+#define FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_NOINT             (0x00000000)
+
+#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_PAUSE             (0x00000000)
+#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE            (0x80000000)
+
+#define FH39_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_VALID           (0x00004000)
+
+#define FH39_TCSR_CHNL_TX_BUF_STS_REG_BIT_TFDB_WPTR            (0x00000001)
+
+#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TXPD_ON       (0xFF000000)
+#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_TXPD_ON       (0x00FF0000)
+
+#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_MAX_FRAG_SIZE_128B     (0x00000400)
+
+#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TFD_ON                (0x00000100)
+#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_CBB_ON                (0x00000080)
+
+#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RSP_WAIT_TH      (0x00000020)
+#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_RSP_WAIT_TH            (0x00000005)
+
+#define FH39_TSSR_TX_STATUS_REG_BIT_BUFS_EMPTY(_ch)    (BIT(_ch) << 24)
+#define FH39_TSSR_TX_STATUS_REG_BIT_NO_PEND_REQ(_ch)   (BIT(_ch) << 16)
+
+#define FH39_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(_ch) \
+       (FH39_TSSR_TX_STATUS_REG_BIT_BUFS_EMPTY(_ch) | \
+        FH39_TSSR_TX_STATUS_REG_BIT_NO_PEND_REQ(_ch))
+
+#define FH39_RSSR_CHNL0_RX_STATUS_CHNL_IDLE                    (0x01000000)
+
+struct il3945_tfd_tb {
+       __le32 addr;
+       __le32 len;
+} __packed;
+
+struct il3945_tfd {
+       __le32 control_flags;
+       struct il3945_tfd_tb tbs[4];
+       u8 __pad[28];
+} __packed;
+
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+extern const struct il_debugfs_ops il3945_debugfs_ops;
+#endif
+
+#endif
diff --git a/drivers/net/wireless/intel/iwlegacy/4965-calib.c b/drivers/net/wireless/intel/iwlegacy/4965-calib.c
new file mode 100644 (file)
index 0000000..e78bdef
--- /dev/null
@@ -0,0 +1,934 @@
+/******************************************************************************
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *  * Neither the name Intel Corporation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+
+#include <linux/slab.h>
+#include <net/mac80211.h>
+
+#include "common.h"
+#include "4965.h"
+
+/*****************************************************************************
+ * INIT calibrations framework
+ *****************************************************************************/
+
+struct stats_general_data {
+       u32 beacon_silence_rssi_a;
+       u32 beacon_silence_rssi_b;
+       u32 beacon_silence_rssi_c;
+       u32 beacon_energy_a;
+       u32 beacon_energy_b;
+       u32 beacon_energy_c;
+};
+
+/*****************************************************************************
+ * RUNTIME calibrations framework
+ *****************************************************************************/
+
+/* "false alarms" are signals that our DSP tries to lock onto,
+ *   but then determines that they are either noise, or transmissions
+ *   from a distant wireless network (also "noise", really) that get
+ *   "stepped on" by stronger transmissions within our own network.
+ * This algorithm attempts to set a sensitivity level that is high
+ *   enough to receive all of our own network traffic, but not so
+ *   high that our DSP gets too busy trying to lock onto non-network
+ *   activity/noise. */
+static int
+il4965_sens_energy_cck(struct il_priv *il, u32 norm_fa, u32 rx_enable_time,
+                      struct stats_general_data *rx_info)
+{
+       u32 max_nrg_cck = 0;
+       int i = 0;
+       u8 max_silence_rssi = 0;
+       u32 silence_ref = 0;
+       u8 silence_rssi_a = 0;
+       u8 silence_rssi_b = 0;
+       u8 silence_rssi_c = 0;
+       u32 val;
+
+       /* "false_alarms" values below are cross-multiplications to assess the
+        *   numbers of false alarms within the measured period of actual Rx
+        *   (Rx is off when we're txing), vs the min/max expected false alarms
+        *   (some should be expected if rx is sensitive enough) in a
+        *   hypothetical listening period of 200 time units (TU), 204.8 msec:
+        *
+        * MIN_FA/fixed-time < false_alarms/actual-rx-time < MAX_FA/beacon-time
+        *
+        * */
+       u32 false_alarms = norm_fa * 200 * 1024;
+       u32 max_false_alarms = MAX_FA_CCK * rx_enable_time;
+       u32 min_false_alarms = MIN_FA_CCK * rx_enable_time;
+       struct il_sensitivity_data *data = NULL;
+       const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
+
+       data = &(il->sensitivity_data);
+
+       data->nrg_auto_corr_silence_diff = 0;
+
+       /* Find max silence rssi among all 3 receivers.
+        * This is background noise, which may include transmissions from other
+        *    networks, measured during silence before our network's beacon */
+       silence_rssi_a =
+           (u8) ((rx_info->beacon_silence_rssi_a & ALL_BAND_FILTER) >> 8);
+       silence_rssi_b =
+           (u8) ((rx_info->beacon_silence_rssi_b & ALL_BAND_FILTER) >> 8);
+       silence_rssi_c =
+           (u8) ((rx_info->beacon_silence_rssi_c & ALL_BAND_FILTER) >> 8);
+
+       val = max(silence_rssi_b, silence_rssi_c);
+       max_silence_rssi = max(silence_rssi_a, (u8) val);
+
+       /* Store silence rssi in 20-beacon history table */
+       data->nrg_silence_rssi[data->nrg_silence_idx] = max_silence_rssi;
+       data->nrg_silence_idx++;
+       if (data->nrg_silence_idx >= NRG_NUM_PREV_STAT_L)
+               data->nrg_silence_idx = 0;
+
+       /* Find max silence rssi across 20 beacon history */
+       for (i = 0; i < NRG_NUM_PREV_STAT_L; i++) {
+               val = data->nrg_silence_rssi[i];
+               silence_ref = max(silence_ref, val);
+       }
+       D_CALIB("silence a %u, b %u, c %u, 20-bcn max %u\n", silence_rssi_a,
+               silence_rssi_b, silence_rssi_c, silence_ref);
+
+       /* Find max rx energy (min value!) among all 3 receivers,
+        *   measured during beacon frame.
+        * Save it in 10-beacon history table. */
+       i = data->nrg_energy_idx;
+       val = min(rx_info->beacon_energy_b, rx_info->beacon_energy_c);
+       data->nrg_value[i] = min(rx_info->beacon_energy_a, val);
+
+       data->nrg_energy_idx++;
+       if (data->nrg_energy_idx >= 10)
+               data->nrg_energy_idx = 0;
+
+       /* Find min rx energy (max value) across 10 beacon history.
+        * This is the minimum signal level that we want to receive well.
+        * Add backoff (margin so we don't miss slightly lower energy frames).
+        * This establishes an upper bound (min value) for energy threshold. */
+       max_nrg_cck = data->nrg_value[0];
+       for (i = 1; i < 10; i++)
+               max_nrg_cck = (u32) max(max_nrg_cck, (data->nrg_value[i]));
+       max_nrg_cck += 6;
+
+       D_CALIB("rx energy a %u, b %u, c %u, 10-bcn max/min %u\n",
+               rx_info->beacon_energy_a, rx_info->beacon_energy_b,
+               rx_info->beacon_energy_c, max_nrg_cck - 6);
+
+       /* Count number of consecutive beacons with fewer-than-desired
+        *   false alarms. */
+       if (false_alarms < min_false_alarms)
+               data->num_in_cck_no_fa++;
+       else
+               data->num_in_cck_no_fa = 0;
+       D_CALIB("consecutive bcns with few false alarms = %u\n",
+               data->num_in_cck_no_fa);
+
+       /* If we got too many false alarms this time, reduce sensitivity */
+       if (false_alarms > max_false_alarms &&
+           data->auto_corr_cck > AUTO_CORR_MAX_TH_CCK) {
+               D_CALIB("norm FA %u > max FA %u\n", false_alarms,
+                       max_false_alarms);
+               D_CALIB("... reducing sensitivity\n");
+               data->nrg_curr_state = IL_FA_TOO_MANY;
+               /* Store for "fewer than desired" on later beacon */
+               data->nrg_silence_ref = silence_ref;
+
+               /* increase energy threshold (reduce nrg value)
+                *   to decrease sensitivity */
+               data->nrg_th_cck = data->nrg_th_cck - NRG_STEP_CCK;
+               /* Else if we got fewer than desired, increase sensitivity */
+       } else if (false_alarms < min_false_alarms) {
+               data->nrg_curr_state = IL_FA_TOO_FEW;
+
+               /* Compare silence level with silence level for most recent
+                *   healthy number or too many false alarms */
+               data->nrg_auto_corr_silence_diff =
+                   (s32) data->nrg_silence_ref - (s32) silence_ref;
+
+               D_CALIB("norm FA %u < min FA %u, silence diff %d\n",
+                       false_alarms, min_false_alarms,
+                       data->nrg_auto_corr_silence_diff);
+
+               /* Increase value to increase sensitivity, but only if:
+                * 1a) previous beacon did *not* have *too many* false alarms
+                * 1b) AND there's a significant difference in Rx levels
+                *      from a previous beacon with too many, or healthy # FAs
+                * OR 2) We've seen a lot of beacons (100) with too few
+                *       false alarms */
+               if (data->nrg_prev_state != IL_FA_TOO_MANY &&
+                   (data->nrg_auto_corr_silence_diff > NRG_DIFF ||
+                    data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA)) {
+
+                       D_CALIB("... increasing sensitivity\n");
+                       /* Increase nrg value to increase sensitivity */
+                       val = data->nrg_th_cck + NRG_STEP_CCK;
+                       data->nrg_th_cck = min((u32) ranges->min_nrg_cck, val);
+               } else {
+                       D_CALIB("... but not changing sensitivity\n");
+               }
+
+               /* Else we got a healthy number of false alarms, keep status quo */
+       } else {
+               D_CALIB(" FA in safe zone\n");
+               data->nrg_curr_state = IL_FA_GOOD_RANGE;
+
+               /* Store for use in "fewer than desired" with later beacon */
+               data->nrg_silence_ref = silence_ref;
+
+               /* If previous beacon had too many false alarms,
+                *   give it some extra margin by reducing sensitivity again
+                *   (but don't go below measured energy of desired Rx) */
+               if (IL_FA_TOO_MANY == data->nrg_prev_state) {
+                       D_CALIB("... increasing margin\n");
+                       if (data->nrg_th_cck > (max_nrg_cck + NRG_MARGIN))
+                               data->nrg_th_cck -= NRG_MARGIN;
+                       else
+                               data->nrg_th_cck = max_nrg_cck;
+               }
+       }
+
+       /* Make sure the energy threshold does not go above the measured
+        * energy of the desired Rx signals (reduced by backoff margin),
+        * or else we might start missing Rx frames.
+        * Lower value is higher energy, so we use max()!
+        */
+       data->nrg_th_cck = max(max_nrg_cck, data->nrg_th_cck);
+       D_CALIB("new nrg_th_cck %u\n", data->nrg_th_cck);
+
+       data->nrg_prev_state = data->nrg_curr_state;
+
+       /* Auto-correlation CCK algorithm */
+       if (false_alarms > min_false_alarms) {
+
+               /* increase auto_corr values to decrease sensitivity
+                * so the DSP won't be disturbed by the noise
+                */
+               if (data->auto_corr_cck < AUTO_CORR_MAX_TH_CCK)
+                       data->auto_corr_cck = AUTO_CORR_MAX_TH_CCK + 1;
+               else {
+                       val = data->auto_corr_cck + AUTO_CORR_STEP_CCK;
+                       data->auto_corr_cck =
+                           min((u32) ranges->auto_corr_max_cck, val);
+               }
+               val = data->auto_corr_cck_mrc + AUTO_CORR_STEP_CCK;
+               data->auto_corr_cck_mrc =
+                   min((u32) ranges->auto_corr_max_cck_mrc, val);
+       } else if (false_alarms < min_false_alarms &&
+                  (data->nrg_auto_corr_silence_diff > NRG_DIFF ||
+                   data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA)) {
+
+               /* Decrease auto_corr values to increase sensitivity */
+               val = data->auto_corr_cck - AUTO_CORR_STEP_CCK;
+               data->auto_corr_cck = max((u32) ranges->auto_corr_min_cck, val);
+               val = data->auto_corr_cck_mrc - AUTO_CORR_STEP_CCK;
+               data->auto_corr_cck_mrc =
+                   max((u32) ranges->auto_corr_min_cck_mrc, val);
+       }
+
+       return 0;
+}
+
+static int
+il4965_sens_auto_corr_ofdm(struct il_priv *il, u32 norm_fa, u32 rx_enable_time)
+{
+       u32 val;
+       u32 false_alarms = norm_fa * 200 * 1024;
+       u32 max_false_alarms = MAX_FA_OFDM * rx_enable_time;
+       u32 min_false_alarms = MIN_FA_OFDM * rx_enable_time;
+       struct il_sensitivity_data *data = NULL;
+       const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
+
+       data = &(il->sensitivity_data);
+
+       /* If we got too many false alarms this time, reduce sensitivity */
+       if (false_alarms > max_false_alarms) {
+
+               D_CALIB("norm FA %u > max FA %u)\n", false_alarms,
+                       max_false_alarms);
+
+               val = data->auto_corr_ofdm + AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm =
+                   min((u32) ranges->auto_corr_max_ofdm, val);
+
+               val = data->auto_corr_ofdm_mrc + AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm_mrc =
+                   min((u32) ranges->auto_corr_max_ofdm_mrc, val);
+
+               val = data->auto_corr_ofdm_x1 + AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm_x1 =
+                   min((u32) ranges->auto_corr_max_ofdm_x1, val);
+
+               val = data->auto_corr_ofdm_mrc_x1 + AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm_mrc_x1 =
+                   min((u32) ranges->auto_corr_max_ofdm_mrc_x1, val);
+       }
+
+       /* Else if we got fewer than desired, increase sensitivity */
+       else if (false_alarms < min_false_alarms) {
+
+               D_CALIB("norm FA %u < min FA %u\n", false_alarms,
+                       min_false_alarms);
+
+               val = data->auto_corr_ofdm - AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm =
+                   max((u32) ranges->auto_corr_min_ofdm, val);
+
+               val = data->auto_corr_ofdm_mrc - AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm_mrc =
+                   max((u32) ranges->auto_corr_min_ofdm_mrc, val);
+
+               val = data->auto_corr_ofdm_x1 - AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm_x1 =
+                   max((u32) ranges->auto_corr_min_ofdm_x1, val);
+
+               val = data->auto_corr_ofdm_mrc_x1 - AUTO_CORR_STEP_OFDM;
+               data->auto_corr_ofdm_mrc_x1 =
+                   max((u32) ranges->auto_corr_min_ofdm_mrc_x1, val);
+       } else {
+               D_CALIB("min FA %u < norm FA %u < max FA %u OK\n",
+                       min_false_alarms, false_alarms, max_false_alarms);
+       }
+       return 0;
+}
+
+static void
+il4965_prepare_legacy_sensitivity_tbl(struct il_priv *il,
+                                     struct il_sensitivity_data *data,
+                                     __le16 *tbl)
+{
+       tbl[HD_AUTO_CORR32_X4_TH_ADD_MIN_IDX] =
+           cpu_to_le16((u16) data->auto_corr_ofdm);
+       tbl[HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_IDX] =
+           cpu_to_le16((u16) data->auto_corr_ofdm_mrc);
+       tbl[HD_AUTO_CORR32_X1_TH_ADD_MIN_IDX] =
+           cpu_to_le16((u16) data->auto_corr_ofdm_x1);
+       tbl[HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_IDX] =
+           cpu_to_le16((u16) data->auto_corr_ofdm_mrc_x1);
+
+       tbl[HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX] =
+           cpu_to_le16((u16) data->auto_corr_cck);
+       tbl[HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX] =
+           cpu_to_le16((u16) data->auto_corr_cck_mrc);
+
+       tbl[HD_MIN_ENERGY_CCK_DET_IDX] = cpu_to_le16((u16) data->nrg_th_cck);
+       tbl[HD_MIN_ENERGY_OFDM_DET_IDX] = cpu_to_le16((u16) data->nrg_th_ofdm);
+
+       tbl[HD_BARKER_CORR_TH_ADD_MIN_IDX] =
+           cpu_to_le16(data->barker_corr_th_min);
+       tbl[HD_BARKER_CORR_TH_ADD_MIN_MRC_IDX] =
+           cpu_to_le16(data->barker_corr_th_min_mrc);
+       tbl[HD_OFDM_ENERGY_TH_IN_IDX] = cpu_to_le16(data->nrg_th_cca);
+
+       D_CALIB("ofdm: ac %u mrc %u x1 %u mrc_x1 %u thresh %u\n",
+               data->auto_corr_ofdm, data->auto_corr_ofdm_mrc,
+               data->auto_corr_ofdm_x1, data->auto_corr_ofdm_mrc_x1,
+               data->nrg_th_ofdm);
+
+       D_CALIB("cck: ac %u mrc %u thresh %u\n", data->auto_corr_cck,
+               data->auto_corr_cck_mrc, data->nrg_th_cck);
+}
+
+/* Prepare a C_SENSITIVITY, send to uCode if values have changed */
+static int
+il4965_sensitivity_write(struct il_priv *il)
+{
+       struct il_sensitivity_cmd cmd;
+       struct il_sensitivity_data *data = NULL;
+       struct il_host_cmd cmd_out = {
+               .id = C_SENSITIVITY,
+               .len = sizeof(struct il_sensitivity_cmd),
+               .flags = CMD_ASYNC,
+               .data = &cmd,
+       };
+
+       data = &(il->sensitivity_data);
+
+       memset(&cmd, 0, sizeof(cmd));
+
+       il4965_prepare_legacy_sensitivity_tbl(il, data, &cmd.table[0]);
+
+       /* Update uCode's "work" table, and copy it to DSP */
+       cmd.control = C_SENSITIVITY_CONTROL_WORK_TBL;
+
+       /* Don't send command to uCode if nothing has changed */
+       if (!memcmp
+           (&cmd.table[0], &(il->sensitivity_tbl[0]),
+            sizeof(u16) * HD_TBL_SIZE)) {
+               D_CALIB("No change in C_SENSITIVITY\n");
+               return 0;
+       }
+
+       /* Copy table for comparison next time */
+       memcpy(&(il->sensitivity_tbl[0]), &(cmd.table[0]),
+              sizeof(u16) * HD_TBL_SIZE);
+
+       return il_send_cmd(il, &cmd_out);
+}
+
+void
+il4965_init_sensitivity(struct il_priv *il)
+{
+       int ret = 0;
+       int i;
+       struct il_sensitivity_data *data = NULL;
+       const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
+
+       if (il->disable_sens_cal)
+               return;
+
+       D_CALIB("Start il4965_init_sensitivity\n");
+
+       /* Clear driver's sensitivity algo data */
+       data = &(il->sensitivity_data);
+
+       if (ranges == NULL)
+               return;
+
+       memset(data, 0, sizeof(struct il_sensitivity_data));
+
+       data->num_in_cck_no_fa = 0;
+       data->nrg_curr_state = IL_FA_TOO_MANY;
+       data->nrg_prev_state = IL_FA_TOO_MANY;
+       data->nrg_silence_ref = 0;
+       data->nrg_silence_idx = 0;
+       data->nrg_energy_idx = 0;
+
+       for (i = 0; i < 10; i++)
+               data->nrg_value[i] = 0;
+
+       for (i = 0; i < NRG_NUM_PREV_STAT_L; i++)
+               data->nrg_silence_rssi[i] = 0;
+
+       data->auto_corr_ofdm = ranges->auto_corr_min_ofdm;
+       data->auto_corr_ofdm_mrc = ranges->auto_corr_min_ofdm_mrc;
+       data->auto_corr_ofdm_x1 = ranges->auto_corr_min_ofdm_x1;
+       data->auto_corr_ofdm_mrc_x1 = ranges->auto_corr_min_ofdm_mrc_x1;
+       data->auto_corr_cck = AUTO_CORR_CCK_MIN_VAL_DEF;
+       data->auto_corr_cck_mrc = ranges->auto_corr_min_cck_mrc;
+       data->nrg_th_cck = ranges->nrg_th_cck;
+       data->nrg_th_ofdm = ranges->nrg_th_ofdm;
+       data->barker_corr_th_min = ranges->barker_corr_th_min;
+       data->barker_corr_th_min_mrc = ranges->barker_corr_th_min_mrc;
+       data->nrg_th_cca = ranges->nrg_th_cca;
+
+       data->last_bad_plcp_cnt_ofdm = 0;
+       data->last_fa_cnt_ofdm = 0;
+       data->last_bad_plcp_cnt_cck = 0;
+       data->last_fa_cnt_cck = 0;
+
+       ret |= il4965_sensitivity_write(il);
+       D_CALIB("<<return 0x%X\n", ret);
+}
+
+void
+il4965_sensitivity_calibration(struct il_priv *il, void *resp)
+{
+       u32 rx_enable_time;
+       u32 fa_cck;
+       u32 fa_ofdm;
+       u32 bad_plcp_cck;
+       u32 bad_plcp_ofdm;
+       u32 norm_fa_ofdm;
+       u32 norm_fa_cck;
+       struct il_sensitivity_data *data = NULL;
+       struct stats_rx_non_phy *rx_info;
+       struct stats_rx_phy *ofdm, *cck;
+       unsigned long flags;
+       struct stats_general_data statis;
+
+       if (il->disable_sens_cal)
+               return;
+
+       data = &(il->sensitivity_data);
+
+       if (!il_is_any_associated(il)) {
+               D_CALIB("<< - not associated\n");
+               return;
+       }
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       rx_info = &(((struct il_notif_stats *)resp)->rx.general);
+       ofdm = &(((struct il_notif_stats *)resp)->rx.ofdm);
+       cck = &(((struct il_notif_stats *)resp)->rx.cck);
+
+       if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
+               D_CALIB("<< invalid data.\n");
+               spin_unlock_irqrestore(&il->lock, flags);
+               return;
+       }
+
+       /* Extract Statistics: */
+       rx_enable_time = le32_to_cpu(rx_info->channel_load);
+       fa_cck = le32_to_cpu(cck->false_alarm_cnt);
+       fa_ofdm = le32_to_cpu(ofdm->false_alarm_cnt);
+       bad_plcp_cck = le32_to_cpu(cck->plcp_err);
+       bad_plcp_ofdm = le32_to_cpu(ofdm->plcp_err);
+
+       statis.beacon_silence_rssi_a =
+           le32_to_cpu(rx_info->beacon_silence_rssi_a);
+       statis.beacon_silence_rssi_b =
+           le32_to_cpu(rx_info->beacon_silence_rssi_b);
+       statis.beacon_silence_rssi_c =
+           le32_to_cpu(rx_info->beacon_silence_rssi_c);
+       statis.beacon_energy_a = le32_to_cpu(rx_info->beacon_energy_a);
+       statis.beacon_energy_b = le32_to_cpu(rx_info->beacon_energy_b);
+       statis.beacon_energy_c = le32_to_cpu(rx_info->beacon_energy_c);
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       D_CALIB("rx_enable_time = %u usecs\n", rx_enable_time);
+
+       if (!rx_enable_time) {
+               D_CALIB("<< RX Enable Time == 0!\n");
+               return;
+       }
+
+       /* These stats increase monotonically, and do not reset
+        *   at each beacon.  Calculate difference from last value, or just
+        *   use the new stats value if it has reset or wrapped around. */
+       if (data->last_bad_plcp_cnt_cck > bad_plcp_cck)
+               data->last_bad_plcp_cnt_cck = bad_plcp_cck;
+       else {
+               bad_plcp_cck -= data->last_bad_plcp_cnt_cck;
+               data->last_bad_plcp_cnt_cck += bad_plcp_cck;
+       }
+
+       if (data->last_bad_plcp_cnt_ofdm > bad_plcp_ofdm)
+               data->last_bad_plcp_cnt_ofdm = bad_plcp_ofdm;
+       else {
+               bad_plcp_ofdm -= data->last_bad_plcp_cnt_ofdm;
+               data->last_bad_plcp_cnt_ofdm += bad_plcp_ofdm;
+       }
+
+       if (data->last_fa_cnt_ofdm > fa_ofdm)
+               data->last_fa_cnt_ofdm = fa_ofdm;
+       else {
+               fa_ofdm -= data->last_fa_cnt_ofdm;
+               data->last_fa_cnt_ofdm += fa_ofdm;
+       }
+
+       if (data->last_fa_cnt_cck > fa_cck)
+               data->last_fa_cnt_cck = fa_cck;
+       else {
+               fa_cck -= data->last_fa_cnt_cck;
+               data->last_fa_cnt_cck += fa_cck;
+       }
+
+       /* Total aborted signal locks */
+       norm_fa_ofdm = fa_ofdm + bad_plcp_ofdm;
+       norm_fa_cck = fa_cck + bad_plcp_cck;
+
+       D_CALIB("cck: fa %u badp %u  ofdm: fa %u badp %u\n", fa_cck,
+               bad_plcp_cck, fa_ofdm, bad_plcp_ofdm);
+
+       il4965_sens_auto_corr_ofdm(il, norm_fa_ofdm, rx_enable_time);
+       il4965_sens_energy_cck(il, norm_fa_cck, rx_enable_time, &statis);
+
+       il4965_sensitivity_write(il);
+}
+
+static inline u8
+il4965_find_first_chain(u8 mask)
+{
+       if (mask & ANT_A)
+               return CHAIN_A;
+       if (mask & ANT_B)
+               return CHAIN_B;
+       return CHAIN_C;
+}
+
+/**
+ * Run disconnected antenna algorithm to find out which antennas are
+ * disconnected.
+ */
+static void
+il4965_find_disconn_antenna(struct il_priv *il, u32 * average_sig,
+                           struct il_chain_noise_data *data)
+{
+       u32 active_chains = 0;
+       u32 max_average_sig;
+       u16 max_average_sig_antenna_i;
+       u8 num_tx_chains;
+       u8 first_chain;
+       u16 i = 0;
+
+       average_sig[0] =
+           data->chain_signal_a /
+           il->cfg->chain_noise_num_beacons;
+       average_sig[1] =
+           data->chain_signal_b /
+           il->cfg->chain_noise_num_beacons;
+       average_sig[2] =
+           data->chain_signal_c /
+           il->cfg->chain_noise_num_beacons;
+
+       if (average_sig[0] >= average_sig[1]) {
+               max_average_sig = average_sig[0];
+               max_average_sig_antenna_i = 0;
+               active_chains = (1 << max_average_sig_antenna_i);
+       } else {
+               max_average_sig = average_sig[1];
+               max_average_sig_antenna_i = 1;
+               active_chains = (1 << max_average_sig_antenna_i);
+       }
+
+       if (average_sig[2] >= max_average_sig) {
+               max_average_sig = average_sig[2];
+               max_average_sig_antenna_i = 2;
+               active_chains = (1 << max_average_sig_antenna_i);
+       }
+
+       D_CALIB("average_sig: a %d b %d c %d\n", average_sig[0], average_sig[1],
+               average_sig[2]);
+       D_CALIB("max_average_sig = %d, antenna %d\n", max_average_sig,
+               max_average_sig_antenna_i);
+
+       /* Compare signal strengths for all 3 receivers. */
+       for (i = 0; i < NUM_RX_CHAINS; i++) {
+               if (i != max_average_sig_antenna_i) {
+                       s32 rssi_delta = (max_average_sig - average_sig[i]);
+
+                       /* If signal is very weak, compared with
+                        * strongest, mark it as disconnected. */
+                       if (rssi_delta > MAXIMUM_ALLOWED_PATHLOSS)
+                               data->disconn_array[i] = 1;
+                       else
+                               active_chains |= (1 << i);
+                       D_CALIB("i = %d  rssiDelta = %d  "
+                               "disconn_array[i] = %d\n", i, rssi_delta,
+                               data->disconn_array[i]);
+               }
+       }
+
+       /*
+        * The above algorithm sometimes fails when the ucode
+        * reports 0 for all chains. It's not clear why that
+        * happens to start with, but it is then causing trouble
+        * because this can make us enable more chains than the
+        * hardware really has.
+        *
+        * To be safe, simply mask out any chains that we know
+        * are not on the device.
+        */
+       active_chains &= il->hw_params.valid_rx_ant;
+
+       num_tx_chains = 0;
+       for (i = 0; i < NUM_RX_CHAINS; i++) {
+               /* loops on all the bits of
+                * il->hw_setting.valid_tx_ant */
+               u8 ant_msk = (1 << i);
+               if (!(il->hw_params.valid_tx_ant & ant_msk))
+                       continue;
+
+               num_tx_chains++;
+               if (data->disconn_array[i] == 0)
+                       /* there is a Tx antenna connected */
+                       break;
+               if (num_tx_chains == il->hw_params.tx_chains_num &&
+                   data->disconn_array[i]) {
+                       /*
+                        * If all chains are disconnected
+                        * connect the first valid tx chain
+                        */
+                       first_chain =
+                           il4965_find_first_chain(il->cfg->valid_tx_ant);
+                       data->disconn_array[first_chain] = 0;
+                       active_chains |= BIT(first_chain);
+                       D_CALIB("All Tx chains are disconnected"
+                               "- declare %d as connected\n", first_chain);
+                       break;
+               }
+       }
+
+       if (active_chains != il->hw_params.valid_rx_ant &&
+           active_chains != il->chain_noise_data.active_chains)
+               D_CALIB("Detected that not all antennas are connected! "
+                       "Connected: %#x, valid: %#x.\n", active_chains,
+                       il->hw_params.valid_rx_ant);
+
+       /* Save for use within RXON, TX, SCAN commands, etc. */
+       data->active_chains = active_chains;
+       D_CALIB("active_chains (bitwise) = 0x%x\n", active_chains);
+}
+
+static void
+il4965_gain_computation(struct il_priv *il, u32 * average_noise,
+                       u16 min_average_noise_antenna_i, u32 min_average_noise,
+                       u8 default_chain)
+{
+       int i, ret;
+       struct il_chain_noise_data *data = &il->chain_noise_data;
+
+       data->delta_gain_code[min_average_noise_antenna_i] = 0;
+
+       for (i = default_chain; i < NUM_RX_CHAINS; i++) {
+               s32 delta_g = 0;
+
+               if (!data->disconn_array[i] &&
+                   data->delta_gain_code[i] ==
+                   CHAIN_NOISE_DELTA_GAIN_INIT_VAL) {
+                       delta_g = average_noise[i] - min_average_noise;
+                       data->delta_gain_code[i] = (u8) ((delta_g * 10) / 15);
+                       data->delta_gain_code[i] =
+                           min(data->delta_gain_code[i],
+                               (u8) CHAIN_NOISE_MAX_DELTA_GAIN_CODE);
+
+                       data->delta_gain_code[i] =
+                           (data->delta_gain_code[i] | (1 << 2));
+               } else {
+                       data->delta_gain_code[i] = 0;
+               }
+       }
+       D_CALIB("delta_gain_codes: a %d b %d c %d\n", data->delta_gain_code[0],
+               data->delta_gain_code[1], data->delta_gain_code[2]);
+
+       /* Differential gain gets sent to uCode only once */
+       if (!data->radio_write) {
+               struct il_calib_diff_gain_cmd cmd;
+               data->radio_write = 1;
+
+               memset(&cmd, 0, sizeof(cmd));
+               cmd.hdr.op_code = IL_PHY_CALIBRATE_DIFF_GAIN_CMD;
+               cmd.diff_gain_a = data->delta_gain_code[0];
+               cmd.diff_gain_b = data->delta_gain_code[1];
+               cmd.diff_gain_c = data->delta_gain_code[2];
+               ret = il_send_cmd_pdu(il, C_PHY_CALIBRATION, sizeof(cmd), &cmd);
+               if (ret)
+                       D_CALIB("fail sending cmd " "C_PHY_CALIBRATION\n");
+
+               /* TODO we might want recalculate
+                * rx_chain in rxon cmd */
+
+               /* Mark so we run this algo only once! */
+               data->state = IL_CHAIN_NOISE_CALIBRATED;
+       }
+}
+
+/*
+ * Accumulate 16 beacons of signal and noise stats for each of
+ *   3 receivers/antennas/rx-chains, then figure out:
+ * 1)  Which antennas are connected.
+ * 2)  Differential rx gain settings to balance the 3 receivers.
+ */
+void
+il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
+{
+       struct il_chain_noise_data *data = NULL;
+
+       u32 chain_noise_a;
+       u32 chain_noise_b;
+       u32 chain_noise_c;
+       u32 chain_sig_a;
+       u32 chain_sig_b;
+       u32 chain_sig_c;
+       u32 average_sig[NUM_RX_CHAINS] = { INITIALIZATION_VALUE };
+       u32 average_noise[NUM_RX_CHAINS] = { INITIALIZATION_VALUE };
+       u32 min_average_noise = MIN_AVERAGE_NOISE_MAX_VALUE;
+       u16 min_average_noise_antenna_i = INITIALIZATION_VALUE;
+       u16 i = 0;
+       u16 rxon_chnum = INITIALIZATION_VALUE;
+       u16 stat_chnum = INITIALIZATION_VALUE;
+       u8 rxon_band24;
+       u8 stat_band24;
+       unsigned long flags;
+       struct stats_rx_non_phy *rx_info;
+
+       if (il->disable_chain_noise_cal)
+               return;
+
+       data = &(il->chain_noise_data);
+
+       /*
+        * Accumulate just the first "chain_noise_num_beacons" after
+        * the first association, then we're done forever.
+        */
+       if (data->state != IL_CHAIN_NOISE_ACCUMULATE) {
+               if (data->state == IL_CHAIN_NOISE_ALIVE)
+                       D_CALIB("Wait for noise calib reset\n");
+               return;
+       }
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       rx_info = &(((struct il_notif_stats *)stat_resp)->rx.general);
+
+       if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
+               D_CALIB(" << Interference data unavailable\n");
+               spin_unlock_irqrestore(&il->lock, flags);
+               return;
+       }
+
+       rxon_band24 = !!(il->staging.flags & RXON_FLG_BAND_24G_MSK);
+       rxon_chnum = le16_to_cpu(il->staging.channel);
+
+       stat_band24 =
+           !!(((struct il_notif_stats *)stat_resp)->
+              flag & STATS_REPLY_FLG_BAND_24G_MSK);
+       stat_chnum =
+           le32_to_cpu(((struct il_notif_stats *)stat_resp)->flag) >> 16;
+
+       /* Make sure we accumulate data for just the associated channel
+        *   (even if scanning). */
+       if (rxon_chnum != stat_chnum || rxon_band24 != stat_band24) {
+               D_CALIB("Stats not from chan=%d, band24=%d\n", rxon_chnum,
+                       rxon_band24);
+               spin_unlock_irqrestore(&il->lock, flags);
+               return;
+       }
+
+       /*
+        *  Accumulate beacon stats values across
+        * "chain_noise_num_beacons"
+        */
+       chain_noise_a =
+           le32_to_cpu(rx_info->beacon_silence_rssi_a) & IN_BAND_FILTER;
+       chain_noise_b =
+           le32_to_cpu(rx_info->beacon_silence_rssi_b) & IN_BAND_FILTER;
+       chain_noise_c =
+           le32_to_cpu(rx_info->beacon_silence_rssi_c) & IN_BAND_FILTER;
+
+       chain_sig_a = le32_to_cpu(rx_info->beacon_rssi_a) & IN_BAND_FILTER;
+       chain_sig_b = le32_to_cpu(rx_info->beacon_rssi_b) & IN_BAND_FILTER;
+       chain_sig_c = le32_to_cpu(rx_info->beacon_rssi_c) & IN_BAND_FILTER;
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       data->beacon_count++;
+
+       data->chain_noise_a = (chain_noise_a + data->chain_noise_a);
+       data->chain_noise_b = (chain_noise_b + data->chain_noise_b);
+       data->chain_noise_c = (chain_noise_c + data->chain_noise_c);
+
+       data->chain_signal_a = (chain_sig_a + data->chain_signal_a);
+       data->chain_signal_b = (chain_sig_b + data->chain_signal_b);
+       data->chain_signal_c = (chain_sig_c + data->chain_signal_c);
+
+       D_CALIB("chan=%d, band24=%d, beacon=%d\n", rxon_chnum, rxon_band24,
+               data->beacon_count);
+       D_CALIB("chain_sig: a %d b %d c %d\n", chain_sig_a, chain_sig_b,
+               chain_sig_c);
+       D_CALIB("chain_noise: a %d b %d c %d\n", chain_noise_a, chain_noise_b,
+               chain_noise_c);
+
+       /* If this is the "chain_noise_num_beacons", determine:
+        * 1)  Disconnected antennas (using signal strengths)
+        * 2)  Differential gain (using silence noise) to balance receivers */
+       if (data->beacon_count != il->cfg->chain_noise_num_beacons)
+               return;
+
+       /* Analyze signal for disconnected antenna */
+       il4965_find_disconn_antenna(il, average_sig, data);
+
+       /* Analyze noise for rx balance */
+       average_noise[0] =
+           data->chain_noise_a / il->cfg->chain_noise_num_beacons;
+       average_noise[1] =
+           data->chain_noise_b / il->cfg->chain_noise_num_beacons;
+       average_noise[2] =
+           data->chain_noise_c / il->cfg->chain_noise_num_beacons;
+
+       for (i = 0; i < NUM_RX_CHAINS; i++) {
+               if (!data->disconn_array[i] &&
+                   average_noise[i] <= min_average_noise) {
+                       /* This means that chain i is active and has
+                        * lower noise values so far: */
+                       min_average_noise = average_noise[i];
+                       min_average_noise_antenna_i = i;
+               }
+       }
+
+       D_CALIB("average_noise: a %d b %d c %d\n", average_noise[0],
+               average_noise[1], average_noise[2]);
+
+       D_CALIB("min_average_noise = %d, antenna %d\n", min_average_noise,
+               min_average_noise_antenna_i);
+
+       il4965_gain_computation(il, average_noise, min_average_noise_antenna_i,
+                               min_average_noise,
+                               il4965_find_first_chain(il->cfg->valid_rx_ant));
+
+       /* Some power changes may have been made during the calibration.
+        * Update and commit the RXON
+        */
+       if (il->ops->update_chain_flags)
+               il->ops->update_chain_flags(il);
+
+       data->state = IL_CHAIN_NOISE_DONE;
+       il_power_update_mode(il, false);
+}
+
+void
+il4965_reset_run_time_calib(struct il_priv *il)
+{
+       int i;
+       memset(&(il->sensitivity_data), 0, sizeof(struct il_sensitivity_data));
+       memset(&(il->chain_noise_data), 0, sizeof(struct il_chain_noise_data));
+       for (i = 0; i < NUM_RX_CHAINS; i++)
+               il->chain_noise_data.delta_gain_code[i] =
+                   CHAIN_NOISE_DELTA_GAIN_INIT_VAL;
+
+       /* Ask for stats now, the uCode will send notification
+        * periodically after association */
+       il_send_stats_request(il, CMD_ASYNC, true);
+}
diff --git a/drivers/net/wireless/intel/iwlegacy/4965-debug.c b/drivers/net/wireless/intel/iwlegacy/4965-debug.c
new file mode 100644 (file)
index 0000000..e0597bf
--- /dev/null
@@ -0,0 +1,752 @@
+/******************************************************************************
+*
+* GPL LICENSE SUMMARY
+*
+* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of version 2 of the GNU General Public License as
+* published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+* USA
+*
+* The full GNU General Public License is included in this distribution
+* in the file called LICENSE.GPL.
+*
+* Contact Information:
+*  Intel Linux Wireless <ilw@linux.intel.com>
+* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+*****************************************************************************/
+#include "common.h"
+#include "4965.h"
+
+static const char *fmt_value = "  %-30s %10u\n";
+static const char *fmt_table = "  %-30s %10u  %10u  %10u  %10u\n";
+static const char *fmt_header =
+    "%-32s    current  cumulative       delta         max\n";
+
+static int
+il4965_stats_flag(struct il_priv *il, char *buf, int bufsz)
+{
+       int p = 0;
+       u32 flag;
+
+       flag = le32_to_cpu(il->_4965.stats.flag);
+
+       p += scnprintf(buf + p, bufsz - p, "Statistics Flag(0x%X):\n", flag);
+       if (flag & UCODE_STATS_CLEAR_MSK)
+               p += scnprintf(buf + p, bufsz - p,
+                              "\tStatistics have been cleared\n");
+       p += scnprintf(buf + p, bufsz - p, "\tOperational Frequency: %s\n",
+                      (flag & UCODE_STATS_FREQUENCY_MSK) ? "2.4 GHz" :
+                      "5.2 GHz");
+       p += scnprintf(buf + p, bufsz - p, "\tTGj Narrow Band: %s\n",
+                      (flag & UCODE_STATS_NARROW_BAND_MSK) ? "enabled" :
+                      "disabled");
+
+       return p;
+}
+
+static ssize_t
+il4965_ucode_rx_stats_read(struct file *file, char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char *buf;
+       int bufsz =
+           sizeof(struct stats_rx_phy) * 40 +
+           sizeof(struct stats_rx_non_phy) * 40 +
+           sizeof(struct stats_rx_ht_phy) * 40 + 400;
+       ssize_t ret;
+       struct stats_rx_phy *ofdm, *accum_ofdm, *delta_ofdm, *max_ofdm;
+       struct stats_rx_phy *cck, *accum_cck, *delta_cck, *max_cck;
+       struct stats_rx_non_phy *general, *accum_general;
+       struct stats_rx_non_phy *delta_general, *max_general;
+       struct stats_rx_ht_phy *ht, *accum_ht, *delta_ht, *max_ht;
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       /*
+        * the statistic information display here is based on
+        * the last stats notification from uCode
+        * might not reflect the current uCode activity
+        */
+       ofdm = &il->_4965.stats.rx.ofdm;
+       cck = &il->_4965.stats.rx.cck;
+       general = &il->_4965.stats.rx.general;
+       ht = &il->_4965.stats.rx.ofdm_ht;
+       accum_ofdm = &il->_4965.accum_stats.rx.ofdm;
+       accum_cck = &il->_4965.accum_stats.rx.cck;
+       accum_general = &il->_4965.accum_stats.rx.general;
+       accum_ht = &il->_4965.accum_stats.rx.ofdm_ht;
+       delta_ofdm = &il->_4965.delta_stats.rx.ofdm;
+       delta_cck = &il->_4965.delta_stats.rx.cck;
+       delta_general = &il->_4965.delta_stats.rx.general;
+       delta_ht = &il->_4965.delta_stats.rx.ofdm_ht;
+       max_ofdm = &il->_4965.max_delta.rx.ofdm;
+       max_cck = &il->_4965.max_delta.rx.cck;
+       max_general = &il->_4965.max_delta.rx.general;
+       max_ht = &il->_4965.max_delta.rx.ofdm_ht;
+
+       pos += il4965_stats_flag(il, buf, bufsz);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_header,
+                     "Statistics_Rx - OFDM:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "ina_cnt:",
+                     le32_to_cpu(ofdm->ina_cnt), accum_ofdm->ina_cnt,
+                     delta_ofdm->ina_cnt, max_ofdm->ina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_cnt:",
+                     le32_to_cpu(ofdm->fina_cnt), accum_ofdm->fina_cnt,
+                     delta_ofdm->fina_cnt, max_ofdm->fina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "plcp_err:",
+                     le32_to_cpu(ofdm->plcp_err), accum_ofdm->plcp_err,
+                     delta_ofdm->plcp_err, max_ofdm->plcp_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_err:",
+                     le32_to_cpu(ofdm->crc32_err), accum_ofdm->crc32_err,
+                     delta_ofdm->crc32_err, max_ofdm->crc32_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "overrun_err:",
+                     le32_to_cpu(ofdm->overrun_err), accum_ofdm->overrun_err,
+                     delta_ofdm->overrun_err, max_ofdm->overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "early_overrun_err:",
+                     le32_to_cpu(ofdm->early_overrun_err),
+                     accum_ofdm->early_overrun_err,
+                     delta_ofdm->early_overrun_err,
+                     max_ofdm->early_overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_good:",
+                     le32_to_cpu(ofdm->crc32_good), accum_ofdm->crc32_good,
+                     delta_ofdm->crc32_good, max_ofdm->crc32_good);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "false_alarm_cnt:",
+                     le32_to_cpu(ofdm->false_alarm_cnt),
+                     accum_ofdm->false_alarm_cnt, delta_ofdm->false_alarm_cnt,
+                     max_ofdm->false_alarm_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_sync_err_cnt:",
+                     le32_to_cpu(ofdm->fina_sync_err_cnt),
+                     accum_ofdm->fina_sync_err_cnt,
+                     delta_ofdm->fina_sync_err_cnt,
+                     max_ofdm->fina_sync_err_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sfd_timeout:",
+                     le32_to_cpu(ofdm->sfd_timeout), accum_ofdm->sfd_timeout,
+                     delta_ofdm->sfd_timeout, max_ofdm->sfd_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_timeout:",
+                     le32_to_cpu(ofdm->fina_timeout), accum_ofdm->fina_timeout,
+                     delta_ofdm->fina_timeout, max_ofdm->fina_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "unresponded_rts:",
+                     le32_to_cpu(ofdm->unresponded_rts),
+                     accum_ofdm->unresponded_rts, delta_ofdm->unresponded_rts,
+                     max_ofdm->unresponded_rts);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "rxe_frame_lmt_ovrun:",
+                     le32_to_cpu(ofdm->rxe_frame_limit_overrun),
+                     accum_ofdm->rxe_frame_limit_overrun,
+                     delta_ofdm->rxe_frame_limit_overrun,
+                     max_ofdm->rxe_frame_limit_overrun);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ack_cnt:",
+                     le32_to_cpu(ofdm->sent_ack_cnt), accum_ofdm->sent_ack_cnt,
+                     delta_ofdm->sent_ack_cnt, max_ofdm->sent_ack_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_cts_cnt:",
+                     le32_to_cpu(ofdm->sent_cts_cnt), accum_ofdm->sent_cts_cnt,
+                     delta_ofdm->sent_cts_cnt, max_ofdm->sent_cts_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ba_rsp_cnt:",
+                     le32_to_cpu(ofdm->sent_ba_rsp_cnt),
+                     accum_ofdm->sent_ba_rsp_cnt, delta_ofdm->sent_ba_rsp_cnt,
+                     max_ofdm->sent_ba_rsp_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "dsp_self_kill:",
+                     le32_to_cpu(ofdm->dsp_self_kill),
+                     accum_ofdm->dsp_self_kill, delta_ofdm->dsp_self_kill,
+                     max_ofdm->dsp_self_kill);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "mh_format_err:",
+                     le32_to_cpu(ofdm->mh_format_err),
+                     accum_ofdm->mh_format_err, delta_ofdm->mh_format_err,
+                     max_ofdm->mh_format_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "re_acq_main_rssi_sum:",
+                     le32_to_cpu(ofdm->re_acq_main_rssi_sum),
+                     accum_ofdm->re_acq_main_rssi_sum,
+                     delta_ofdm->re_acq_main_rssi_sum,
+                     max_ofdm->re_acq_main_rssi_sum);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_header,
+                     "Statistics_Rx - CCK:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "ina_cnt:",
+                     le32_to_cpu(cck->ina_cnt), accum_cck->ina_cnt,
+                     delta_cck->ina_cnt, max_cck->ina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_cnt:",
+                     le32_to_cpu(cck->fina_cnt), accum_cck->fina_cnt,
+                     delta_cck->fina_cnt, max_cck->fina_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "plcp_err:",
+                     le32_to_cpu(cck->plcp_err), accum_cck->plcp_err,
+                     delta_cck->plcp_err, max_cck->plcp_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_err:",
+                     le32_to_cpu(cck->crc32_err), accum_cck->crc32_err,
+                     delta_cck->crc32_err, max_cck->crc32_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "overrun_err:",
+                     le32_to_cpu(cck->overrun_err), accum_cck->overrun_err,
+                     delta_cck->overrun_err, max_cck->overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "early_overrun_err:",
+                     le32_to_cpu(cck->early_overrun_err),
+                     accum_cck->early_overrun_err,
+                     delta_cck->early_overrun_err, max_cck->early_overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_good:",
+                     le32_to_cpu(cck->crc32_good), accum_cck->crc32_good,
+                     delta_cck->crc32_good, max_cck->crc32_good);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "false_alarm_cnt:",
+                     le32_to_cpu(cck->false_alarm_cnt),
+                     accum_cck->false_alarm_cnt, delta_cck->false_alarm_cnt,
+                     max_cck->false_alarm_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_sync_err_cnt:",
+                     le32_to_cpu(cck->fina_sync_err_cnt),
+                     accum_cck->fina_sync_err_cnt,
+                     delta_cck->fina_sync_err_cnt, max_cck->fina_sync_err_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sfd_timeout:",
+                     le32_to_cpu(cck->sfd_timeout), accum_cck->sfd_timeout,
+                     delta_cck->sfd_timeout, max_cck->sfd_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_timeout:",
+                     le32_to_cpu(cck->fina_timeout), accum_cck->fina_timeout,
+                     delta_cck->fina_timeout, max_cck->fina_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "unresponded_rts:",
+                     le32_to_cpu(cck->unresponded_rts),
+                     accum_cck->unresponded_rts, delta_cck->unresponded_rts,
+                     max_cck->unresponded_rts);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "rxe_frame_lmt_ovrun:",
+                     le32_to_cpu(cck->rxe_frame_limit_overrun),
+                     accum_cck->rxe_frame_limit_overrun,
+                     delta_cck->rxe_frame_limit_overrun,
+                     max_cck->rxe_frame_limit_overrun);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ack_cnt:",
+                     le32_to_cpu(cck->sent_ack_cnt), accum_cck->sent_ack_cnt,
+                     delta_cck->sent_ack_cnt, max_cck->sent_ack_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_cts_cnt:",
+                     le32_to_cpu(cck->sent_cts_cnt), accum_cck->sent_cts_cnt,
+                     delta_cck->sent_cts_cnt, max_cck->sent_cts_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ba_rsp_cnt:",
+                     le32_to_cpu(cck->sent_ba_rsp_cnt),
+                     accum_cck->sent_ba_rsp_cnt, delta_cck->sent_ba_rsp_cnt,
+                     max_cck->sent_ba_rsp_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "dsp_self_kill:",
+                     le32_to_cpu(cck->dsp_self_kill), accum_cck->dsp_self_kill,
+                     delta_cck->dsp_self_kill, max_cck->dsp_self_kill);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "mh_format_err:",
+                     le32_to_cpu(cck->mh_format_err), accum_cck->mh_format_err,
+                     delta_cck->mh_format_err, max_cck->mh_format_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "re_acq_main_rssi_sum:",
+                     le32_to_cpu(cck->re_acq_main_rssi_sum),
+                     accum_cck->re_acq_main_rssi_sum,
+                     delta_cck->re_acq_main_rssi_sum,
+                     max_cck->re_acq_main_rssi_sum);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_header,
+                     "Statistics_Rx - GENERAL:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "bogus_cts:",
+                     le32_to_cpu(general->bogus_cts), accum_general->bogus_cts,
+                     delta_general->bogus_cts, max_general->bogus_cts);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "bogus_ack:",
+                     le32_to_cpu(general->bogus_ack), accum_general->bogus_ack,
+                     delta_general->bogus_ack, max_general->bogus_ack);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "non_bssid_frames:",
+                     le32_to_cpu(general->non_bssid_frames),
+                     accum_general->non_bssid_frames,
+                     delta_general->non_bssid_frames,
+                     max_general->non_bssid_frames);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "filtered_frames:",
+                     le32_to_cpu(general->filtered_frames),
+                     accum_general->filtered_frames,
+                     delta_general->filtered_frames,
+                     max_general->filtered_frames);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "non_channel_beacons:",
+                     le32_to_cpu(general->non_channel_beacons),
+                     accum_general->non_channel_beacons,
+                     delta_general->non_channel_beacons,
+                     max_general->non_channel_beacons);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "channel_beacons:",
+                     le32_to_cpu(general->channel_beacons),
+                     accum_general->channel_beacons,
+                     delta_general->channel_beacons,
+                     max_general->channel_beacons);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "num_missed_bcon:",
+                     le32_to_cpu(general->num_missed_bcon),
+                     accum_general->num_missed_bcon,
+                     delta_general->num_missed_bcon,
+                     max_general->num_missed_bcon);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "adc_rx_saturation_time:",
+                     le32_to_cpu(general->adc_rx_saturation_time),
+                     accum_general->adc_rx_saturation_time,
+                     delta_general->adc_rx_saturation_time,
+                     max_general->adc_rx_saturation_time);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "ina_detect_search_tm:",
+                     le32_to_cpu(general->ina_detection_search_time),
+                     accum_general->ina_detection_search_time,
+                     delta_general->ina_detection_search_time,
+                     max_general->ina_detection_search_time);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "beacon_silence_rssi_a:",
+                     le32_to_cpu(general->beacon_silence_rssi_a),
+                     accum_general->beacon_silence_rssi_a,
+                     delta_general->beacon_silence_rssi_a,
+                     max_general->beacon_silence_rssi_a);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "beacon_silence_rssi_b:",
+                     le32_to_cpu(general->beacon_silence_rssi_b),
+                     accum_general->beacon_silence_rssi_b,
+                     delta_general->beacon_silence_rssi_b,
+                     max_general->beacon_silence_rssi_b);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "beacon_silence_rssi_c:",
+                     le32_to_cpu(general->beacon_silence_rssi_c),
+                     accum_general->beacon_silence_rssi_c,
+                     delta_general->beacon_silence_rssi_c,
+                     max_general->beacon_silence_rssi_c);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "interference_data_flag:",
+                     le32_to_cpu(general->interference_data_flag),
+                     accum_general->interference_data_flag,
+                     delta_general->interference_data_flag,
+                     max_general->interference_data_flag);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "channel_load:",
+                     le32_to_cpu(general->channel_load),
+                     accum_general->channel_load, delta_general->channel_load,
+                     max_general->channel_load);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "dsp_false_alarms:",
+                     le32_to_cpu(general->dsp_false_alarms),
+                     accum_general->dsp_false_alarms,
+                     delta_general->dsp_false_alarms,
+                     max_general->dsp_false_alarms);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_rssi_a:",
+                     le32_to_cpu(general->beacon_rssi_a),
+                     accum_general->beacon_rssi_a,
+                     delta_general->beacon_rssi_a, max_general->beacon_rssi_a);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_rssi_b:",
+                     le32_to_cpu(general->beacon_rssi_b),
+                     accum_general->beacon_rssi_b,
+                     delta_general->beacon_rssi_b, max_general->beacon_rssi_b);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_rssi_c:",
+                     le32_to_cpu(general->beacon_rssi_c),
+                     accum_general->beacon_rssi_c,
+                     delta_general->beacon_rssi_c, max_general->beacon_rssi_c);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_energy_a:",
+                     le32_to_cpu(general->beacon_energy_a),
+                     accum_general->beacon_energy_a,
+                     delta_general->beacon_energy_a,
+                     max_general->beacon_energy_a);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_energy_b:",
+                     le32_to_cpu(general->beacon_energy_b),
+                     accum_general->beacon_energy_b,
+                     delta_general->beacon_energy_b,
+                     max_general->beacon_energy_b);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_energy_c:",
+                     le32_to_cpu(general->beacon_energy_c),
+                     accum_general->beacon_energy_c,
+                     delta_general->beacon_energy_c,
+                     max_general->beacon_energy_c);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_header,
+                     "Statistics_Rx - OFDM_HT:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "plcp_err:",
+                     le32_to_cpu(ht->plcp_err), accum_ht->plcp_err,
+                     delta_ht->plcp_err, max_ht->plcp_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "overrun_err:",
+                     le32_to_cpu(ht->overrun_err), accum_ht->overrun_err,
+                     delta_ht->overrun_err, max_ht->overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "early_overrun_err:",
+                     le32_to_cpu(ht->early_overrun_err),
+                     accum_ht->early_overrun_err, delta_ht->early_overrun_err,
+                     max_ht->early_overrun_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_good:",
+                     le32_to_cpu(ht->crc32_good), accum_ht->crc32_good,
+                     delta_ht->crc32_good, max_ht->crc32_good);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_err:",
+                     le32_to_cpu(ht->crc32_err), accum_ht->crc32_err,
+                     delta_ht->crc32_err, max_ht->crc32_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "mh_format_err:",
+                     le32_to_cpu(ht->mh_format_err), accum_ht->mh_format_err,
+                     delta_ht->mh_format_err, max_ht->mh_format_err);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg_crc32_good:",
+                     le32_to_cpu(ht->agg_crc32_good), accum_ht->agg_crc32_good,
+                     delta_ht->agg_crc32_good, max_ht->agg_crc32_good);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg_mpdu_cnt:",
+                     le32_to_cpu(ht->agg_mpdu_cnt), accum_ht->agg_mpdu_cnt,
+                     delta_ht->agg_mpdu_cnt, max_ht->agg_mpdu_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg_cnt:",
+                     le32_to_cpu(ht->agg_cnt), accum_ht->agg_cnt,
+                     delta_ht->agg_cnt, max_ht->agg_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "unsupport_mcs:",
+                     le32_to_cpu(ht->unsupport_mcs), accum_ht->unsupport_mcs,
+                     delta_ht->unsupport_mcs, max_ht->unsupport_mcs);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il4965_ucode_tx_stats_read(struct file *file, char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char *buf;
+       int bufsz = (sizeof(struct stats_tx) * 48) + 250;
+       ssize_t ret;
+       struct stats_tx *tx, *accum_tx, *delta_tx, *max_tx;
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       /* the statistic information display here is based on
+        * the last stats notification from uCode
+        * might not reflect the current uCode activity
+        */
+       tx = &il->_4965.stats.tx;
+       accum_tx = &il->_4965.accum_stats.tx;
+       delta_tx = &il->_4965.delta_stats.tx;
+       max_tx = &il->_4965.max_delta.tx;
+
+       pos += il4965_stats_flag(il, buf, bufsz);
+       pos += scnprintf(buf + pos, bufsz - pos, fmt_header, "Statistics_Tx:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "preamble:",
+                     le32_to_cpu(tx->preamble_cnt), accum_tx->preamble_cnt,
+                     delta_tx->preamble_cnt, max_tx->preamble_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "rx_detected_cnt:",
+                     le32_to_cpu(tx->rx_detected_cnt),
+                     accum_tx->rx_detected_cnt, delta_tx->rx_detected_cnt,
+                     max_tx->rx_detected_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "bt_prio_defer_cnt:",
+                     le32_to_cpu(tx->bt_prio_defer_cnt),
+                     accum_tx->bt_prio_defer_cnt, delta_tx->bt_prio_defer_cnt,
+                     max_tx->bt_prio_defer_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "bt_prio_kill_cnt:",
+                     le32_to_cpu(tx->bt_prio_kill_cnt),
+                     accum_tx->bt_prio_kill_cnt, delta_tx->bt_prio_kill_cnt,
+                     max_tx->bt_prio_kill_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "few_bytes_cnt:",
+                     le32_to_cpu(tx->few_bytes_cnt), accum_tx->few_bytes_cnt,
+                     delta_tx->few_bytes_cnt, max_tx->few_bytes_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "cts_timeout:",
+                     le32_to_cpu(tx->cts_timeout), accum_tx->cts_timeout,
+                     delta_tx->cts_timeout, max_tx->cts_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "ack_timeout:",
+                     le32_to_cpu(tx->ack_timeout), accum_tx->ack_timeout,
+                     delta_tx->ack_timeout, max_tx->ack_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "expected_ack_cnt:",
+                     le32_to_cpu(tx->expected_ack_cnt),
+                     accum_tx->expected_ack_cnt, delta_tx->expected_ack_cnt,
+                     max_tx->expected_ack_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "actual_ack_cnt:",
+                     le32_to_cpu(tx->actual_ack_cnt), accum_tx->actual_ack_cnt,
+                     delta_tx->actual_ack_cnt, max_tx->actual_ack_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "dump_msdu_cnt:",
+                     le32_to_cpu(tx->dump_msdu_cnt), accum_tx->dump_msdu_cnt,
+                     delta_tx->dump_msdu_cnt, max_tx->dump_msdu_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "abort_nxt_frame_mismatch:",
+                     le32_to_cpu(tx->burst_abort_next_frame_mismatch_cnt),
+                     accum_tx->burst_abort_next_frame_mismatch_cnt,
+                     delta_tx->burst_abort_next_frame_mismatch_cnt,
+                     max_tx->burst_abort_next_frame_mismatch_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "abort_missing_nxt_frame:",
+                     le32_to_cpu(tx->burst_abort_missing_next_frame_cnt),
+                     accum_tx->burst_abort_missing_next_frame_cnt,
+                     delta_tx->burst_abort_missing_next_frame_cnt,
+                     max_tx->burst_abort_missing_next_frame_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "cts_timeout_collision:",
+                     le32_to_cpu(tx->cts_timeout_collision),
+                     accum_tx->cts_timeout_collision,
+                     delta_tx->cts_timeout_collision,
+                     max_tx->cts_timeout_collision);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "ack_ba_timeout_collision:",
+                     le32_to_cpu(tx->ack_or_ba_timeout_collision),
+                     accum_tx->ack_or_ba_timeout_collision,
+                     delta_tx->ack_or_ba_timeout_collision,
+                     max_tx->ack_or_ba_timeout_collision);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg ba_timeout:",
+                     le32_to_cpu(tx->agg.ba_timeout), accum_tx->agg.ba_timeout,
+                     delta_tx->agg.ba_timeout, max_tx->agg.ba_timeout);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "agg ba_resched_frames:",
+                     le32_to_cpu(tx->agg.ba_reschedule_frames),
+                     accum_tx->agg.ba_reschedule_frames,
+                     delta_tx->agg.ba_reschedule_frames,
+                     max_tx->agg.ba_reschedule_frames);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "agg scd_query_agg_frame:",
+                     le32_to_cpu(tx->agg.scd_query_agg_frame_cnt),
+                     accum_tx->agg.scd_query_agg_frame_cnt,
+                     delta_tx->agg.scd_query_agg_frame_cnt,
+                     max_tx->agg.scd_query_agg_frame_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "agg scd_query_no_agg:",
+                     le32_to_cpu(tx->agg.scd_query_no_agg),
+                     accum_tx->agg.scd_query_no_agg,
+                     delta_tx->agg.scd_query_no_agg,
+                     max_tx->agg.scd_query_no_agg);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg scd_query_agg:",
+                     le32_to_cpu(tx->agg.scd_query_agg),
+                     accum_tx->agg.scd_query_agg, delta_tx->agg.scd_query_agg,
+                     max_tx->agg.scd_query_agg);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "agg scd_query_mismatch:",
+                     le32_to_cpu(tx->agg.scd_query_mismatch),
+                     accum_tx->agg.scd_query_mismatch,
+                     delta_tx->agg.scd_query_mismatch,
+                     max_tx->agg.scd_query_mismatch);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg frame_not_ready:",
+                     le32_to_cpu(tx->agg.frame_not_ready),
+                     accum_tx->agg.frame_not_ready,
+                     delta_tx->agg.frame_not_ready,
+                     max_tx->agg.frame_not_ready);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg underrun:",
+                     le32_to_cpu(tx->agg.underrun), accum_tx->agg.underrun,
+                     delta_tx->agg.underrun, max_tx->agg.underrun);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg bt_prio_kill:",
+                     le32_to_cpu(tx->agg.bt_prio_kill),
+                     accum_tx->agg.bt_prio_kill, delta_tx->agg.bt_prio_kill,
+                     max_tx->agg.bt_prio_kill);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg rx_ba_rsp_cnt:",
+                     le32_to_cpu(tx->agg.rx_ba_rsp_cnt),
+                     accum_tx->agg.rx_ba_rsp_cnt, delta_tx->agg.rx_ba_rsp_cnt,
+                     max_tx->agg.rx_ba_rsp_cnt);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il4965_ucode_general_stats_read(struct file *file, char __user *user_buf,
+                               size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char *buf;
+       int bufsz = sizeof(struct stats_general) * 10 + 300;
+       ssize_t ret;
+       struct stats_general_common *general, *accum_general;
+       struct stats_general_common *delta_general, *max_general;
+       struct stats_dbg *dbg, *accum_dbg, *delta_dbg, *max_dbg;
+       struct stats_div *div, *accum_div, *delta_div, *max_div;
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       /* the statistic information display here is based on
+        * the last stats notification from uCode
+        * might not reflect the current uCode activity
+        */
+       general = &il->_4965.stats.general.common;
+       dbg = &il->_4965.stats.general.common.dbg;
+       div = &il->_4965.stats.general.common.div;
+       accum_general = &il->_4965.accum_stats.general.common;
+       accum_dbg = &il->_4965.accum_stats.general.common.dbg;
+       accum_div = &il->_4965.accum_stats.general.common.div;
+       delta_general = &il->_4965.delta_stats.general.common;
+       max_general = &il->_4965.max_delta.general.common;
+       delta_dbg = &il->_4965.delta_stats.general.common.dbg;
+       max_dbg = &il->_4965.max_delta.general.common.dbg;
+       delta_div = &il->_4965.delta_stats.general.common.div;
+       max_div = &il->_4965.max_delta.general.common.div;
+
+       pos += il4965_stats_flag(il, buf, bufsz);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_header,
+                     "Statistics_General:");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_value, "temperature:",
+                     le32_to_cpu(general->temperature));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_value, "ttl_timestamp:",
+                     le32_to_cpu(general->ttl_timestamp));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "burst_check:",
+                     le32_to_cpu(dbg->burst_check), accum_dbg->burst_check,
+                     delta_dbg->burst_check, max_dbg->burst_check);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "burst_count:",
+                     le32_to_cpu(dbg->burst_count), accum_dbg->burst_count,
+                     delta_dbg->burst_count, max_dbg->burst_count);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table,
+                     "wait_for_silence_timeout_count:",
+                     le32_to_cpu(dbg->wait_for_silence_timeout_cnt),
+                     accum_dbg->wait_for_silence_timeout_cnt,
+                     delta_dbg->wait_for_silence_timeout_cnt,
+                     max_dbg->wait_for_silence_timeout_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "sleep_time:",
+                     le32_to_cpu(general->sleep_time),
+                     accum_general->sleep_time, delta_general->sleep_time,
+                     max_general->sleep_time);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "slots_out:",
+                     le32_to_cpu(general->slots_out), accum_general->slots_out,
+                     delta_general->slots_out, max_general->slots_out);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "slots_idle:",
+                     le32_to_cpu(general->slots_idle),
+                     accum_general->slots_idle, delta_general->slots_idle,
+                     max_general->slots_idle);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "tx_on_a:",
+                     le32_to_cpu(div->tx_on_a), accum_div->tx_on_a,
+                     delta_div->tx_on_a, max_div->tx_on_a);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "tx_on_b:",
+                     le32_to_cpu(div->tx_on_b), accum_div->tx_on_b,
+                     delta_div->tx_on_b, max_div->tx_on_b);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "exec_time:",
+                     le32_to_cpu(div->exec_time), accum_div->exec_time,
+                     delta_div->exec_time, max_div->exec_time);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "probe_time:",
+                     le32_to_cpu(div->probe_time), accum_div->probe_time,
+                     delta_div->probe_time, max_div->probe_time);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "rx_enable_counter:",
+                     le32_to_cpu(general->rx_enable_counter),
+                     accum_general->rx_enable_counter,
+                     delta_general->rx_enable_counter,
+                     max_general->rx_enable_counter);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, fmt_table, "num_of_sos_states:",
+                     le32_to_cpu(general->num_of_sos_states),
+                     accum_general->num_of_sos_states,
+                     delta_general->num_of_sos_states,
+                     max_general->num_of_sos_states);
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+const struct il_debugfs_ops il4965_debugfs_ops = {
+       .rx_stats_read = il4965_ucode_rx_stats_read,
+       .tx_stats_read = il4965_ucode_tx_stats_read,
+       .general_stats_read = il4965_ucode_general_stats_read,
+};
diff --git a/drivers/net/wireless/intel/iwlegacy/4965-mac.c b/drivers/net/wireless/intel/iwlegacy/4965-mac.c
new file mode 100644 (file)
index 0000000..6656215
--- /dev/null
@@ -0,0 +1,6868 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
+ *
+ * Portions of this file are derived from the ipw3945 project, as well
+ * as portions of the ieee80211 subsystem header files.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/pci-aspm.h>
+#include <linux/slab.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+#include <linux/firmware.h>
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+
+#include <net/mac80211.h>
+
+#include <asm/div64.h>
+
+#define DRV_NAME        "iwl4965"
+
+#include "common.h"
+#include "4965.h"
+
+/******************************************************************************
+ *
+ * module boiler plate
+ *
+ ******************************************************************************/
+
+/*
+ * module name, copyright, version, etc.
+ */
+#define DRV_DESCRIPTION        "Intel(R) Wireless WiFi 4965 driver for Linux"
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+#define VD "d"
+#else
+#define VD
+#endif
+
+#define DRV_VERSION     IWLWIFI_VERSION VD
+
+MODULE_DESCRIPTION(DRV_DESCRIPTION);
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("iwl4965");
+
+void
+il4965_check_abort_status(struct il_priv *il, u8 frame_count, u32 status)
+{
+       if (frame_count == 1 && status == TX_STATUS_FAIL_RFKILL_FLUSH) {
+               IL_ERR("Tx flush command to flush out all frames\n");
+               if (!test_bit(S_EXIT_PENDING, &il->status))
+                       queue_work(il->workqueue, &il->tx_flush);
+       }
+}
+
+/*
+ * EEPROM
+ */
+struct il_mod_params il4965_mod_params = {
+       .restart_fw = 1,
+       /* the rest are 0 by default */
+};
+
+void
+il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
+{
+       unsigned long flags;
+       int i;
+       spin_lock_irqsave(&rxq->lock, flags);
+       INIT_LIST_HEAD(&rxq->rx_free);
+       INIT_LIST_HEAD(&rxq->rx_used);
+       /* Fill the rx_used queue with _all_ of the Rx buffers */
+       for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
+               /* In the reset function, these buffers may have been allocated
+                * to an SKB, so we need to unmap and free potential storage */
+               if (rxq->pool[i].page != NULL) {
+                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
+                                      PAGE_SIZE << il->hw_params.rx_page_order,
+                                      PCI_DMA_FROMDEVICE);
+                       __il_free_pages(il, rxq->pool[i].page);
+                       rxq->pool[i].page = NULL;
+               }
+               list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
+       }
+
+       for (i = 0; i < RX_QUEUE_SIZE; i++)
+               rxq->queue[i] = NULL;
+
+       /* Set us so that we have processed and used all buffers, but have
+        * not restocked the Rx queue with fresh buffers */
+       rxq->read = rxq->write = 0;
+       rxq->write_actual = 0;
+       rxq->free_count = 0;
+       spin_unlock_irqrestore(&rxq->lock, flags);
+}
+
+int
+il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
+{
+       u32 rb_size;
+       const u32 rfdnlog = RX_QUEUE_SIZE_LOG;  /* 256 RBDs */
+       u32 rb_timeout = 0;
+
+       if (il->cfg->mod_params->amsdu_size_8K)
+               rb_size = FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_8K;
+       else
+               rb_size = FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_4K;
+
+       /* Stop Rx DMA */
+       il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG, 0);
+
+       /* Reset driver's Rx queue write idx */
+       il_wr(il, FH49_RSCSR_CHNL0_RBDCB_WPTR_REG, 0);
+
+       /* Tell device where to find RBD circular buffer in DRAM */
+       il_wr(il, FH49_RSCSR_CHNL0_RBDCB_BASE_REG, (u32) (rxq->bd_dma >> 8));
+
+       /* Tell device where in DRAM to update its Rx status */
+       il_wr(il, FH49_RSCSR_CHNL0_STTS_WPTR_REG, rxq->rb_stts_dma >> 4);
+
+       /* Enable Rx DMA
+        * Direct rx interrupts to hosts
+        * Rx buffer size 4 or 8k
+        * RB timeout 0x10
+        * 256 RBDs
+        */
+       il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG,
+             FH49_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL |
+             FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL |
+             FH49_RCSR_CHNL0_RX_CONFIG_SINGLE_FRAME_MSK |
+             rb_size |
+             (rb_timeout << FH49_RCSR_RX_CONFIG_REG_IRQ_RBTH_POS) |
+             (rfdnlog << FH49_RCSR_RX_CONFIG_RBDCB_SIZE_POS));
+
+       /* Set interrupt coalescing timer to default (2048 usecs) */
+       il_write8(il, CSR_INT_COALESCING, IL_HOST_INT_TIMEOUT_DEF);
+
+       return 0;
+}
+
+static void
+il4965_set_pwr_vmain(struct il_priv *il)
+{
+/*
+ * (for documentation purposes)
+ * to set power to V_AUX, do:
+
+               if (pci_pme_capable(il->pci_dev, PCI_D3cold))
+                       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
+                                              APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
+                                              ~APMG_PS_CTRL_MSK_PWR_SRC);
+ */
+
+       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
+                             APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
+                             ~APMG_PS_CTRL_MSK_PWR_SRC);
+}
+
+int
+il4965_hw_nic_init(struct il_priv *il)
+{
+       unsigned long flags;
+       struct il_rx_queue *rxq = &il->rxq;
+       int ret;
+
+       spin_lock_irqsave(&il->lock, flags);
+       il_apm_init(il);
+       /* Set interrupt coalescing calibration timer to default (512 usecs) */
+       il_write8(il, CSR_INT_COALESCING, IL_HOST_INT_CALIB_TIMEOUT_DEF);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       il4965_set_pwr_vmain(il);
+       il4965_nic_config(il);
+
+       /* Allocate the RX queue, or reset if it is already allocated */
+       if (!rxq->bd) {
+               ret = il_rx_queue_alloc(il);
+               if (ret) {
+                       IL_ERR("Unable to initialize Rx queue\n");
+                       return -ENOMEM;
+               }
+       } else
+               il4965_rx_queue_reset(il, rxq);
+
+       il4965_rx_replenish(il);
+
+       il4965_rx_init(il, rxq);
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       rxq->need_update = 1;
+       il_rx_queue_update_write_ptr(il, rxq);
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       /* Allocate or reset and init all Tx and Command queues */
+       if (!il->txq) {
+               ret = il4965_txq_ctx_alloc(il);
+               if (ret)
+                       return ret;
+       } else
+               il4965_txq_ctx_reset(il);
+
+       set_bit(S_INIT, &il->status);
+
+       return 0;
+}
+
+/**
+ * il4965_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
+ */
+static inline __le32
+il4965_dma_addr2rbd_ptr(struct il_priv *il, dma_addr_t dma_addr)
+{
+       return cpu_to_le32((u32) (dma_addr >> 8));
+}
+
+/**
+ * il4965_rx_queue_restock - refill RX queue from pre-allocated pool
+ *
+ * If there are slots in the RX queue that need to be restocked,
+ * and we have free pre-allocated buffers, fill the ranks as much
+ * as we can, pulling from rx_free.
+ *
+ * This moves the 'write' idx forward to catch up with 'processed', and
+ * also updates the memory address in the firmware to reference the new
+ * target buffer.
+ */
+void
+il4965_rx_queue_restock(struct il_priv *il)
+{
+       struct il_rx_queue *rxq = &il->rxq;
+       struct list_head *element;
+       struct il_rx_buf *rxb;
+       unsigned long flags;
+
+       spin_lock_irqsave(&rxq->lock, flags);
+       while (il_rx_queue_space(rxq) > 0 && rxq->free_count) {
+               /* The overwritten rxb must be a used one */
+               rxb = rxq->queue[rxq->write];
+               BUG_ON(rxb && rxb->page);
+
+               /* Get next free Rx buffer, remove from free list */
+               element = rxq->rx_free.next;
+               rxb = list_entry(element, struct il_rx_buf, list);
+               list_del(element);
+
+               /* Point to Rx buffer via next RBD in circular buffer */
+               rxq->bd[rxq->write] =
+                   il4965_dma_addr2rbd_ptr(il, rxb->page_dma);
+               rxq->queue[rxq->write] = rxb;
+               rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
+               rxq->free_count--;
+       }
+       spin_unlock_irqrestore(&rxq->lock, flags);
+       /* If the pre-allocated buffer pool is dropping low, schedule to
+        * refill it */
+       if (rxq->free_count <= RX_LOW_WATERMARK)
+               queue_work(il->workqueue, &il->rx_replenish);
+
+       /* If we've added more space for the firmware to place data, tell it.
+        * Increment device's write pointer in multiples of 8. */
+       if (rxq->write_actual != (rxq->write & ~0x7)) {
+               spin_lock_irqsave(&rxq->lock, flags);
+               rxq->need_update = 1;
+               spin_unlock_irqrestore(&rxq->lock, flags);
+               il_rx_queue_update_write_ptr(il, rxq);
+       }
+}
+
+/**
+ * il4965_rx_replenish - Move all used packet from rx_used to rx_free
+ *
+ * When moving to rx_free an SKB is allocated for the slot.
+ *
+ * Also restock the Rx queue via il_rx_queue_restock.
+ * This is called as a scheduled work item (except for during initialization)
+ */
+static void
+il4965_rx_allocate(struct il_priv *il, gfp_t priority)
+{
+       struct il_rx_queue *rxq = &il->rxq;
+       struct list_head *element;
+       struct il_rx_buf *rxb;
+       struct page *page;
+       dma_addr_t page_dma;
+       unsigned long flags;
+       gfp_t gfp_mask = priority;
+
+       while (1) {
+               spin_lock_irqsave(&rxq->lock, flags);
+               if (list_empty(&rxq->rx_used)) {
+                       spin_unlock_irqrestore(&rxq->lock, flags);
+                       return;
+               }
+               spin_unlock_irqrestore(&rxq->lock, flags);
+
+               if (rxq->free_count > RX_LOW_WATERMARK)
+                       gfp_mask |= __GFP_NOWARN;
+
+               if (il->hw_params.rx_page_order > 0)
+                       gfp_mask |= __GFP_COMP;
+
+               /* Alloc a new receive buffer */
+               page = alloc_pages(gfp_mask, il->hw_params.rx_page_order);
+               if (!page) {
+                       if (net_ratelimit())
+                               D_INFO("alloc_pages failed, " "order: %d\n",
+                                      il->hw_params.rx_page_order);
+
+                       if (rxq->free_count <= RX_LOW_WATERMARK &&
+                           net_ratelimit())
+                               IL_ERR("Failed to alloc_pages with %s. "
+                                      "Only %u free buffers remaining.\n",
+                                      priority ==
+                                      GFP_ATOMIC ? "GFP_ATOMIC" : "GFP_KERNEL",
+                                      rxq->free_count);
+                       /* We don't reschedule replenish work here -- we will
+                        * call the restock method and if it still needs
+                        * more buffers it will schedule replenish */
+                       return;
+               }
+
+               /* Get physical address of the RB */
+               page_dma =
+                   pci_map_page(il->pci_dev, page, 0,
+                                PAGE_SIZE << il->hw_params.rx_page_order,
+                                PCI_DMA_FROMDEVICE);
+               if (unlikely(pci_dma_mapping_error(il->pci_dev, page_dma))) {
+                       __free_pages(page, il->hw_params.rx_page_order);
+                       break;
+               }
+
+               spin_lock_irqsave(&rxq->lock, flags);
+
+               if (list_empty(&rxq->rx_used)) {
+                       spin_unlock_irqrestore(&rxq->lock, flags);
+                       pci_unmap_page(il->pci_dev, page_dma,
+                                      PAGE_SIZE << il->hw_params.rx_page_order,
+                                      PCI_DMA_FROMDEVICE);
+                       __free_pages(page, il->hw_params.rx_page_order);
+                       return;
+               }
+
+               element = rxq->rx_used.next;
+               rxb = list_entry(element, struct il_rx_buf, list);
+               list_del(element);
+
+               BUG_ON(rxb->page);
+
+               rxb->page = page;
+               rxb->page_dma = page_dma;
+               list_add_tail(&rxb->list, &rxq->rx_free);
+               rxq->free_count++;
+               il->alloc_rxb_page++;
+
+               spin_unlock_irqrestore(&rxq->lock, flags);
+       }
+}
+
+void
+il4965_rx_replenish(struct il_priv *il)
+{
+       unsigned long flags;
+
+       il4965_rx_allocate(il, GFP_KERNEL);
+
+       spin_lock_irqsave(&il->lock, flags);
+       il4965_rx_queue_restock(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+}
+
+void
+il4965_rx_replenish_now(struct il_priv *il)
+{
+       il4965_rx_allocate(il, GFP_ATOMIC);
+
+       il4965_rx_queue_restock(il);
+}
+
+/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
+ * If an SKB has been detached, the POOL needs to have its SKB set to NULL
+ * This free routine walks the list of POOL entries and if SKB is set to
+ * non NULL it is unmapped and freed
+ */
+void
+il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
+{
+       int i;
+       for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
+               if (rxq->pool[i].page != NULL) {
+                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
+                                      PAGE_SIZE << il->hw_params.rx_page_order,
+                                      PCI_DMA_FROMDEVICE);
+                       __il_free_pages(il, rxq->pool[i].page);
+                       rxq->pool[i].page = NULL;
+               }
+       }
+
+       dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
+                         rxq->bd_dma);
+       dma_free_coherent(&il->pci_dev->dev, sizeof(struct il_rb_status),
+                         rxq->rb_stts, rxq->rb_stts_dma);
+       rxq->bd = NULL;
+       rxq->rb_stts = NULL;
+}
+
+int
+il4965_rxq_stop(struct il_priv *il)
+{
+       int ret;
+
+       _il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG, 0);
+       ret = _il_poll_bit(il, FH49_MEM_RSSR_RX_STATUS_REG,
+                          FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
+                          FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
+                          1000);
+       if (ret < 0)
+               IL_ERR("Can't stop Rx DMA.\n");
+
+       return 0;
+}
+
+int
+il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
+{
+       int idx = 0;
+       int band_offset = 0;
+
+       /* HT rate format: mac80211 wants an MCS number, which is just LSB */
+       if (rate_n_flags & RATE_MCS_HT_MSK) {
+               idx = (rate_n_flags & 0xff);
+               return idx;
+               /* Legacy rate format, search for match in table */
+       } else {
+               if (band == IEEE80211_BAND_5GHZ)
+                       band_offset = IL_FIRST_OFDM_RATE;
+               for (idx = band_offset; idx < RATE_COUNT_LEGACY; idx++)
+                       if (il_rates[idx].plcp == (rate_n_flags & 0xFF))
+                               return idx - band_offset;
+       }
+
+       return -1;
+}
+
+static int
+il4965_calc_rssi(struct il_priv *il, struct il_rx_phy_res *rx_resp)
+{
+       /* data from PHY/DSP regarding signal strength, etc.,
+        *   contents are always there, not configurable by host.  */
+       struct il4965_rx_non_cfg_phy *ncphy =
+           (struct il4965_rx_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
+       u32 agc =
+           (le16_to_cpu(ncphy->agc_info) & IL49_AGC_DB_MASK) >>
+           IL49_AGC_DB_POS;
+
+       u32 valid_antennae =
+           (le16_to_cpu(rx_resp->phy_flags) & IL49_RX_PHY_FLAGS_ANTENNAE_MASK)
+           >> IL49_RX_PHY_FLAGS_ANTENNAE_OFFSET;
+       u8 max_rssi = 0;
+       u32 i;
+
+       /* Find max rssi among 3 possible receivers.
+        * These values are measured by the digital signal processor (DSP).
+        * They should stay fairly constant even as the signal strength varies,
+        *   if the radio's automatic gain control (AGC) is working right.
+        * AGC value (see below) will provide the "interesting" info. */
+       for (i = 0; i < 3; i++)
+               if (valid_antennae & (1 << i))
+                       max_rssi = max(ncphy->rssi_info[i << 1], max_rssi);
+
+       D_STATS("Rssi In A %d B %d C %d Max %d AGC dB %d\n",
+               ncphy->rssi_info[0], ncphy->rssi_info[2], ncphy->rssi_info[4],
+               max_rssi, agc);
+
+       /* dBm = max_rssi dB - agc dB - constant.
+        * Higher AGC (higher radio gain) means lower signal. */
+       return max_rssi - agc - IL4965_RSSI_OFFSET;
+}
+
+static u32
+il4965_translate_rx_status(struct il_priv *il, u32 decrypt_in)
+{
+       u32 decrypt_out = 0;
+
+       if ((decrypt_in & RX_RES_STATUS_STATION_FOUND) ==
+           RX_RES_STATUS_STATION_FOUND)
+               decrypt_out |=
+                   (RX_RES_STATUS_STATION_FOUND |
+                    RX_RES_STATUS_NO_STATION_INFO_MISMATCH);
+
+       decrypt_out |= (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK);
+
+       /* packet was not encrypted */
+       if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
+           RX_RES_STATUS_SEC_TYPE_NONE)
+               return decrypt_out;
+
+       /* packet was encrypted with unknown alg */
+       if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
+           RX_RES_STATUS_SEC_TYPE_ERR)
+               return decrypt_out;
+
+       /* decryption was not done in HW */
+       if ((decrypt_in & RX_MPDU_RES_STATUS_DEC_DONE_MSK) !=
+           RX_MPDU_RES_STATUS_DEC_DONE_MSK)
+               return decrypt_out;
+
+       switch (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) {
+
+       case RX_RES_STATUS_SEC_TYPE_CCMP:
+               /* alg is CCM: check MIC only */
+               if (!(decrypt_in & RX_MPDU_RES_STATUS_MIC_OK))
+                       /* Bad MIC */
+                       decrypt_out |= RX_RES_STATUS_BAD_ICV_MIC;
+               else
+                       decrypt_out |= RX_RES_STATUS_DECRYPT_OK;
+
+               break;
+
+       case RX_RES_STATUS_SEC_TYPE_TKIP:
+               if (!(decrypt_in & RX_MPDU_RES_STATUS_TTAK_OK)) {
+                       /* Bad TTAK */
+                       decrypt_out |= RX_RES_STATUS_BAD_KEY_TTAK;
+                       break;
+               }
+               /* fall through if TTAK OK */
+       default:
+               if (!(decrypt_in & RX_MPDU_RES_STATUS_ICV_OK))
+                       decrypt_out |= RX_RES_STATUS_BAD_ICV_MIC;
+               else
+                       decrypt_out |= RX_RES_STATUS_DECRYPT_OK;
+               break;
+       }
+
+       D_RX("decrypt_in:0x%x  decrypt_out = 0x%x\n", decrypt_in, decrypt_out);
+
+       return decrypt_out;
+}
+
+#define SMALL_PACKET_SIZE 256
+
+static void
+il4965_pass_packet_to_mac80211(struct il_priv *il, struct ieee80211_hdr *hdr,
+                              u32 len, u32 ampdu_status, struct il_rx_buf *rxb,
+                              struct ieee80211_rx_status *stats)
+{
+       struct sk_buff *skb;
+       __le16 fc = hdr->frame_control;
+
+       /* We only process data packets if the interface is open */
+       if (unlikely(!il->is_open)) {
+               D_DROP("Dropping packet while interface is not open.\n");
+               return;
+       }
+
+       if (unlikely(test_bit(IL_STOP_REASON_PASSIVE, &il->stop_reason))) {
+               il_wake_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
+               D_INFO("Woke queues - frame received on passive channel\n");
+       }
+
+       /* In case of HW accelerated crypto and bad decryption, drop */
+       if (!il->cfg->mod_params->sw_crypto &&
+           il_set_decrypted_flag(il, hdr, ampdu_status, stats))
+               return;
+
+       skb = dev_alloc_skb(SMALL_PACKET_SIZE);
+       if (!skb) {
+               IL_ERR("dev_alloc_skb failed\n");
+               return;
+       }
+
+       if (len <= SMALL_PACKET_SIZE) {
+               memcpy(skb_put(skb, len), hdr, len);
+       } else {
+               skb_add_rx_frag(skb, 0, rxb->page, (void *)hdr - rxb_addr(rxb),
+                               len, PAGE_SIZE << il->hw_params.rx_page_order);
+               il->alloc_rxb_page--;
+               rxb->page = NULL;
+       }
+
+       il_update_stats(il, false, fc, len);
+       memcpy(IEEE80211_SKB_RXCB(skb), stats, sizeof(*stats));
+
+       ieee80211_rx(il->hw, skb);
+}
+
+/* Called for N_RX (legacy ABG frames), or
+ * N_RX_MPDU (HT high-throughput N frames). */
+static void
+il4965_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct ieee80211_hdr *header;
+       struct ieee80211_rx_status rx_status = {};
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_rx_phy_res *phy_res;
+       __le32 rx_pkt_status;
+       struct il_rx_mpdu_res_start *amsdu;
+       u32 len;
+       u32 ampdu_status;
+       u32 rate_n_flags;
+
+       /**
+        * N_RX and N_RX_MPDU are handled differently.
+        *      N_RX: physical layer info is in this buffer
+        *      N_RX_MPDU: physical layer info was sent in separate
+        *              command and cached in il->last_phy_res
+        *
+        * Here we set up local variables depending on which command is
+        * received.
+        */
+       if (pkt->hdr.cmd == N_RX) {
+               phy_res = (struct il_rx_phy_res *)pkt->u.raw;
+               header =
+                   (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*phy_res) +
+                                            phy_res->cfg_phy_cnt);
+
+               len = le16_to_cpu(phy_res->byte_count);
+               rx_pkt_status =
+                   *(__le32 *) (pkt->u.raw + sizeof(*phy_res) +
+                                phy_res->cfg_phy_cnt + len);
+               ampdu_status = le32_to_cpu(rx_pkt_status);
+       } else {
+               if (!il->_4965.last_phy_res_valid) {
+                       IL_ERR("MPDU frame without cached PHY data\n");
+                       return;
+               }
+               phy_res = &il->_4965.last_phy_res;
+               amsdu = (struct il_rx_mpdu_res_start *)pkt->u.raw;
+               header = (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*amsdu));
+               len = le16_to_cpu(amsdu->byte_count);
+               rx_pkt_status = *(__le32 *) (pkt->u.raw + sizeof(*amsdu) + len);
+               ampdu_status =
+                   il4965_translate_rx_status(il, le32_to_cpu(rx_pkt_status));
+       }
+
+       if ((unlikely(phy_res->cfg_phy_cnt > 20))) {
+               D_DROP("dsp size out of range [0,20]: %d\n",
+                      phy_res->cfg_phy_cnt);
+               return;
+       }
+
+       if (!(rx_pkt_status & RX_RES_STATUS_NO_CRC32_ERROR) ||
+           !(rx_pkt_status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
+               D_RX("Bad CRC or FIFO: 0x%08X.\n", le32_to_cpu(rx_pkt_status));
+               return;
+       }
+
+       /* This will be used in several places later */
+       rate_n_flags = le32_to_cpu(phy_res->rate_n_flags);
+
+       /* rx_status carries information about the packet to mac80211 */
+       rx_status.mactime = le64_to_cpu(phy_res->timestamp);
+       rx_status.band =
+           (phy_res->
+            phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
+           IEEE80211_BAND_5GHZ;
+       rx_status.freq =
+           ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
+                                          rx_status.band);
+       rx_status.rate_idx =
+           il4965_hwrate_to_mac80211_idx(rate_n_flags, rx_status.band);
+       rx_status.flag = 0;
+
+       /* TSF isn't reliable. In order to allow smooth user experience,
+        * this W/A doesn't propagate it to the mac80211 */
+       /*rx_status.flag |= RX_FLAG_MACTIME_START; */
+
+       il->ucode_beacon_time = le32_to_cpu(phy_res->beacon_time_stamp);
+
+       /* Find max signal strength (dBm) among 3 antenna/receiver chains */
+       rx_status.signal = il4965_calc_rssi(il, phy_res);
+
+       D_STATS("Rssi %d, TSF %llu\n", rx_status.signal,
+               (unsigned long long)rx_status.mactime);
+
+       /*
+        * "antenna number"
+        *
+        * It seems that the antenna field in the phy flags value
+        * is actually a bit field. This is undefined by radiotap,
+        * it wants an actual antenna number but I always get "7"
+        * for most legacy frames I receive indicating that the
+        * same frame was received on all three RX chains.
+        *
+        * I think this field should be removed in favor of a
+        * new 802.11n radiotap field "RX chains" that is defined
+        * as a bitmask.
+        */
+       rx_status.antenna =
+           (le16_to_cpu(phy_res->phy_flags) & RX_RES_PHY_FLAGS_ANTENNA_MSK) >>
+           RX_RES_PHY_FLAGS_ANTENNA_POS;
+
+       /* set the preamble flag if appropriate */
+       if (phy_res->phy_flags & RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK)
+               rx_status.flag |= RX_FLAG_SHORTPRE;
+
+       /* Set up the HT phy flags */
+       if (rate_n_flags & RATE_MCS_HT_MSK)
+               rx_status.flag |= RX_FLAG_HT;
+       if (rate_n_flags & RATE_MCS_HT40_MSK)
+               rx_status.flag |= RX_FLAG_40MHZ;
+       if (rate_n_flags & RATE_MCS_SGI_MSK)
+               rx_status.flag |= RX_FLAG_SHORT_GI;
+
+       if (phy_res->phy_flags & RX_RES_PHY_FLAGS_AGG_MSK) {
+               /* We know which subframes of an A-MPDU belong
+                * together since we get a single PHY response
+                * from the firmware for all of them.
+                */
+
+               rx_status.flag |= RX_FLAG_AMPDU_DETAILS;
+               rx_status.ampdu_reference = il->_4965.ampdu_ref;
+       }
+
+       il4965_pass_packet_to_mac80211(il, header, len, ampdu_status, rxb,
+                                      &rx_status);
+}
+
+/* Cache phy data (Rx signal strength, etc) for HT frame (N_RX_PHY).
+ * This will be used later in il_hdl_rx() for N_RX_MPDU. */
+static void
+il4965_hdl_rx_phy(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       il->_4965.last_phy_res_valid = true;
+       il->_4965.ampdu_ref++;
+       memcpy(&il->_4965.last_phy_res, pkt->u.raw,
+              sizeof(struct il_rx_phy_res));
+}
+
+static int
+il4965_get_channels_for_scan(struct il_priv *il, struct ieee80211_vif *vif,
+                            enum ieee80211_band band, u8 is_active,
+                            u8 n_probes, struct il_scan_channel *scan_ch)
+{
+       struct ieee80211_channel *chan;
+       const struct ieee80211_supported_band *sband;
+       const struct il_channel_info *ch_info;
+       u16 passive_dwell = 0;
+       u16 active_dwell = 0;
+       int added, i;
+       u16 channel;
+
+       sband = il_get_hw_mode(il, band);
+       if (!sband)
+               return 0;
+
+       active_dwell = il_get_active_dwell_time(il, band, n_probes);
+       passive_dwell = il_get_passive_dwell_time(il, band, vif);
+
+       if (passive_dwell <= active_dwell)
+               passive_dwell = active_dwell + 1;
+
+       for (i = 0, added = 0; i < il->scan_request->n_channels; i++) {
+               chan = il->scan_request->channels[i];
+
+               if (chan->band != band)
+                       continue;
+
+               channel = chan->hw_value;
+               scan_ch->channel = cpu_to_le16(channel);
+
+               ch_info = il_get_channel_info(il, band, channel);
+               if (!il_is_channel_valid(ch_info)) {
+                       D_SCAN("Channel %d is INVALID for this band.\n",
+                              channel);
+                       continue;
+               }
+
+               if (!is_active || il_is_channel_passive(ch_info) ||
+                   (chan->flags & IEEE80211_CHAN_NO_IR))
+                       scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE;
+               else
+                       scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE;
+
+               if (n_probes)
+                       scan_ch->type |= IL_SCAN_PROBE_MASK(n_probes);
+
+               scan_ch->active_dwell = cpu_to_le16(active_dwell);
+               scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
+
+               /* Set txpower levels to defaults */
+               scan_ch->dsp_atten = 110;
+
+               /* NOTE: if we were doing 6Mb OFDM for scans we'd use
+                * power level:
+                * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
+                */
+               if (band == IEEE80211_BAND_5GHZ)
+                       scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3;
+               else
+                       scan_ch->tx_gain = ((1 << 5) | (5 << 3));
+
+               D_SCAN("Scanning ch=%d prob=0x%X [%s %d]\n", channel,
+                      le32_to_cpu(scan_ch->type),
+                      (scan_ch->
+                       type & SCAN_CHANNEL_TYPE_ACTIVE) ? "ACTIVE" : "PASSIVE",
+                      (scan_ch->
+                       type & SCAN_CHANNEL_TYPE_ACTIVE) ? active_dwell :
+                      passive_dwell);
+
+               scan_ch++;
+               added++;
+       }
+
+       D_SCAN("total channels to scan %d\n", added);
+       return added;
+}
+
+static void
+il4965_toggle_tx_ant(struct il_priv *il, u8 *ant, u8 valid)
+{
+       int i;
+       u8 ind = *ant;
+
+       for (i = 0; i < RATE_ANT_NUM - 1; i++) {
+               ind = (ind + 1) < RATE_ANT_NUM ? ind + 1 : 0;
+               if (valid & BIT(ind)) {
+                       *ant = ind;
+                       return;
+               }
+       }
+}
+
+int
+il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
+{
+       struct il_host_cmd cmd = {
+               .id = C_SCAN,
+               .len = sizeof(struct il_scan_cmd),
+               .flags = CMD_SIZE_HUGE,
+       };
+       struct il_scan_cmd *scan;
+       u32 rate_flags = 0;
+       u16 cmd_len;
+       u16 rx_chain = 0;
+       enum ieee80211_band band;
+       u8 n_probes = 0;
+       u8 rx_ant = il->hw_params.valid_rx_ant;
+       u8 rate;
+       bool is_active = false;
+       int chan_mod;
+       u8 active_chains;
+       u8 scan_tx_antennas = il->hw_params.valid_tx_ant;
+       int ret;
+
+       lockdep_assert_held(&il->mutex);
+
+       if (!il->scan_cmd) {
+               il->scan_cmd =
+                   kmalloc(sizeof(struct il_scan_cmd) + IL_MAX_SCAN_SIZE,
+                           GFP_KERNEL);
+               if (!il->scan_cmd) {
+                       D_SCAN("fail to allocate memory for scan\n");
+                       return -ENOMEM;
+               }
+       }
+       scan = il->scan_cmd;
+       memset(scan, 0, sizeof(struct il_scan_cmd) + IL_MAX_SCAN_SIZE);
+
+       scan->quiet_plcp_th = IL_PLCP_QUIET_THRESH;
+       scan->quiet_time = IL_ACTIVE_QUIET_TIME;
+
+       if (il_is_any_associated(il)) {
+               u16 interval;
+               u32 extra;
+               u32 suspend_time = 100;
+               u32 scan_suspend_time = 100;
+
+               D_INFO("Scanning while associated...\n");
+               interval = vif->bss_conf.beacon_int;
+
+               scan->suspend_time = 0;
+               scan->max_out_time = cpu_to_le32(200 * 1024);
+               if (!interval)
+                       interval = suspend_time;
+
+               extra = (suspend_time / interval) << 22;
+               scan_suspend_time =
+                   (extra | ((suspend_time % interval) * 1024));
+               scan->suspend_time = cpu_to_le32(scan_suspend_time);
+               D_SCAN("suspend_time 0x%X beacon interval %d\n",
+                      scan_suspend_time, interval);
+       }
+
+       if (il->scan_request->n_ssids) {
+               int i, p = 0;
+               D_SCAN("Kicking off active scan\n");
+               for (i = 0; i < il->scan_request->n_ssids; i++) {
+                       /* always does wildcard anyway */
+                       if (!il->scan_request->ssids[i].ssid_len)
+                               continue;
+                       scan->direct_scan[p].id = WLAN_EID_SSID;
+                       scan->direct_scan[p].len =
+                           il->scan_request->ssids[i].ssid_len;
+                       memcpy(scan->direct_scan[p].ssid,
+                              il->scan_request->ssids[i].ssid,
+                              il->scan_request->ssids[i].ssid_len);
+                       n_probes++;
+                       p++;
+               }
+               is_active = true;
+       } else
+               D_SCAN("Start passive scan.\n");
+
+       scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
+       scan->tx_cmd.sta_id = il->hw_params.bcast_id;
+       scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
+
+       switch (il->scan_band) {
+       case IEEE80211_BAND_2GHZ:
+               scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
+               chan_mod =
+                   le32_to_cpu(il->active.flags & RXON_FLG_CHANNEL_MODE_MSK) >>
+                   RXON_FLG_CHANNEL_MODE_POS;
+               if (chan_mod == CHANNEL_MODE_PURE_40) {
+                       rate = RATE_6M_PLCP;
+               } else {
+                       rate = RATE_1M_PLCP;
+                       rate_flags = RATE_MCS_CCK_MSK;
+               }
+               break;
+       case IEEE80211_BAND_5GHZ:
+               rate = RATE_6M_PLCP;
+               break;
+       default:
+               IL_WARN("Invalid scan band\n");
+               return -EIO;
+       }
+
+       /*
+        * If active scanning is requested but a certain channel is
+        * marked passive, we can do active scanning if we detect
+        * transmissions.
+        *
+        * There is an issue with some firmware versions that triggers
+        * a sysassert on a "good CRC threshold" of zero (== disabled),
+        * on a radar channel even though this means that we should NOT
+        * send probes.
+        *
+        * The "good CRC threshold" is the number of frames that we
+        * need to receive during our dwell time on a channel before
+        * sending out probes -- setting this to a huge value will
+        * mean we never reach it, but at the same time work around
+        * the aforementioned issue. Thus use IL_GOOD_CRC_TH_NEVER
+        * here instead of IL_GOOD_CRC_TH_DISABLED.
+        */
+       scan->good_CRC_th =
+           is_active ? IL_GOOD_CRC_TH_DEFAULT : IL_GOOD_CRC_TH_NEVER;
+
+       band = il->scan_band;
+
+       if (il->cfg->scan_rx_antennas[band])
+               rx_ant = il->cfg->scan_rx_antennas[band];
+
+       il4965_toggle_tx_ant(il, &il->scan_tx_ant[band], scan_tx_antennas);
+       rate_flags |= BIT(il->scan_tx_ant[band]) << RATE_MCS_ANT_POS;
+       scan->tx_cmd.rate_n_flags = cpu_to_le32(rate | rate_flags);
+
+       /* In power save mode use one chain, otherwise use all chains */
+       if (test_bit(S_POWER_PMI, &il->status)) {
+               /* rx_ant has been set to all valid chains previously */
+               active_chains =
+                   rx_ant & ((u8) (il->chain_noise_data.active_chains));
+               if (!active_chains)
+                       active_chains = rx_ant;
+
+               D_SCAN("chain_noise_data.active_chains: %u\n",
+                      il->chain_noise_data.active_chains);
+
+               rx_ant = il4965_first_antenna(active_chains);
+       }
+
+       /* MIMO is not used here, but value is required */
+       rx_chain |= il->hw_params.valid_rx_ant << RXON_RX_CHAIN_VALID_POS;
+       rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS;
+       rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS;
+       rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS;
+       scan->rx_chain = cpu_to_le16(rx_chain);
+
+       cmd_len =
+           il_fill_probe_req(il, (struct ieee80211_mgmt *)scan->data,
+                             vif->addr, il->scan_request->ie,
+                             il->scan_request->ie_len,
+                             IL_MAX_SCAN_SIZE - sizeof(*scan));
+       scan->tx_cmd.len = cpu_to_le16(cmd_len);
+
+       scan->filter_flags |=
+           (RXON_FILTER_ACCEPT_GRP_MSK | RXON_FILTER_BCON_AWARE_MSK);
+
+       scan->channel_count =
+           il4965_get_channels_for_scan(il, vif, band, is_active, n_probes,
+                                        (void *)&scan->data[cmd_len]);
+       if (scan->channel_count == 0) {
+               D_SCAN("channel count %d\n", scan->channel_count);
+               return -EIO;
+       }
+
+       cmd.len +=
+           le16_to_cpu(scan->tx_cmd.len) +
+           scan->channel_count * sizeof(struct il_scan_channel);
+       cmd.data = scan;
+       scan->len = cpu_to_le16(cmd.len);
+
+       set_bit(S_SCAN_HW, &il->status);
+
+       ret = il_send_cmd_sync(il, &cmd);
+       if (ret)
+               clear_bit(S_SCAN_HW, &il->status);
+
+       return ret;
+}
+
+int
+il4965_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
+                          bool add)
+{
+       struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
+
+       if (add)
+               return il4965_add_bssid_station(il, vif->bss_conf.bssid,
+                                               &vif_priv->ibss_bssid_sta_id);
+       return il_remove_station(il, vif_priv->ibss_bssid_sta_id,
+                                vif->bss_conf.bssid);
+}
+
+void
+il4965_free_tfds_in_queue(struct il_priv *il, int sta_id, int tid, int freed)
+{
+       lockdep_assert_held(&il->sta_lock);
+
+       if (il->stations[sta_id].tid[tid].tfds_in_queue >= freed)
+               il->stations[sta_id].tid[tid].tfds_in_queue -= freed;
+       else {
+               D_TX("free more than tfds_in_queue (%u:%d)\n",
+                    il->stations[sta_id].tid[tid].tfds_in_queue, freed);
+               il->stations[sta_id].tid[tid].tfds_in_queue = 0;
+       }
+}
+
+#define IL_TX_QUEUE_MSK        0xfffff
+
+static bool
+il4965_is_single_rx_stream(struct il_priv *il)
+{
+       return il->current_ht_config.smps == IEEE80211_SMPS_STATIC ||
+           il->current_ht_config.single_chain_sufficient;
+}
+
+#define IL_NUM_RX_CHAINS_MULTIPLE      3
+#define IL_NUM_RX_CHAINS_SINGLE        2
+#define IL_NUM_IDLE_CHAINS_DUAL        2
+#define IL_NUM_IDLE_CHAINS_SINGLE      1
+
+/*
+ * Determine how many receiver/antenna chains to use.
+ *
+ * More provides better reception via diversity.  Fewer saves power
+ * at the expense of throughput, but only when not in powersave to
+ * start with.
+ *
+ * MIMO (dual stream) requires at least 2, but works better with 3.
+ * This does not determine *which* chains to use, just how many.
+ */
+static int
+il4965_get_active_rx_chain_count(struct il_priv *il)
+{
+       /* # of Rx chains to use when expecting MIMO. */
+       if (il4965_is_single_rx_stream(il))
+               return IL_NUM_RX_CHAINS_SINGLE;
+       else
+               return IL_NUM_RX_CHAINS_MULTIPLE;
+}
+
+/*
+ * When we are in power saving mode, unless device support spatial
+ * multiplexing power save, use the active count for rx chain count.
+ */
+static int
+il4965_get_idle_rx_chain_count(struct il_priv *il, int active_cnt)
+{
+       /* # Rx chains when idling, depending on SMPS mode */
+       switch (il->current_ht_config.smps) {
+       case IEEE80211_SMPS_STATIC:
+       case IEEE80211_SMPS_DYNAMIC:
+               return IL_NUM_IDLE_CHAINS_SINGLE;
+       case IEEE80211_SMPS_OFF:
+               return active_cnt;
+       default:
+               WARN(1, "invalid SMPS mode %d", il->current_ht_config.smps);
+               return active_cnt;
+       }
+}
+
+/* up to 4 chains */
+static u8
+il4965_count_chain_bitmap(u32 chain_bitmap)
+{
+       u8 res;
+       res = (chain_bitmap & BIT(0)) >> 0;
+       res += (chain_bitmap & BIT(1)) >> 1;
+       res += (chain_bitmap & BIT(2)) >> 2;
+       res += (chain_bitmap & BIT(3)) >> 3;
+       return res;
+}
+
+/**
+ * il4965_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
+ *
+ * Selects how many and which Rx receivers/antennas/chains to use.
+ * This should not be used for scan command ... it puts data in wrong place.
+ */
+void
+il4965_set_rxon_chain(struct il_priv *il)
+{
+       bool is_single = il4965_is_single_rx_stream(il);
+       bool is_cam = !test_bit(S_POWER_PMI, &il->status);
+       u8 idle_rx_cnt, active_rx_cnt, valid_rx_cnt;
+       u32 active_chains;
+       u16 rx_chain;
+
+       /* Tell uCode which antennas are actually connected.
+        * Before first association, we assume all antennas are connected.
+        * Just after first association, il4965_chain_noise_calibration()
+        *    checks which antennas actually *are* connected. */
+       if (il->chain_noise_data.active_chains)
+               active_chains = il->chain_noise_data.active_chains;
+       else
+               active_chains = il->hw_params.valid_rx_ant;
+
+       rx_chain = active_chains << RXON_RX_CHAIN_VALID_POS;
+
+       /* How many receivers should we use? */
+       active_rx_cnt = il4965_get_active_rx_chain_count(il);
+       idle_rx_cnt = il4965_get_idle_rx_chain_count(il, active_rx_cnt);
+
+       /* correct rx chain count according hw settings
+        * and chain noise calibration
+        */
+       valid_rx_cnt = il4965_count_chain_bitmap(active_chains);
+       if (valid_rx_cnt < active_rx_cnt)
+               active_rx_cnt = valid_rx_cnt;
+
+       if (valid_rx_cnt < idle_rx_cnt)
+               idle_rx_cnt = valid_rx_cnt;
+
+       rx_chain |= active_rx_cnt << RXON_RX_CHAIN_MIMO_CNT_POS;
+       rx_chain |= idle_rx_cnt << RXON_RX_CHAIN_CNT_POS;
+
+       il->staging.rx_chain = cpu_to_le16(rx_chain);
+
+       if (!is_single && active_rx_cnt >= IL_NUM_RX_CHAINS_SINGLE && is_cam)
+               il->staging.rx_chain |= RXON_RX_CHAIN_MIMO_FORCE_MSK;
+       else
+               il->staging.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
+
+       D_ASSOC("rx_chain=0x%X active=%d idle=%d\n", il->staging.rx_chain,
+               active_rx_cnt, idle_rx_cnt);
+
+       WARN_ON(active_rx_cnt == 0 || idle_rx_cnt == 0 ||
+               active_rx_cnt < idle_rx_cnt);
+}
+
+static const char *
+il4965_get_fh_string(int cmd)
+{
+       switch (cmd) {
+               IL_CMD(FH49_RSCSR_CHNL0_STTS_WPTR_REG);
+               IL_CMD(FH49_RSCSR_CHNL0_RBDCB_BASE_REG);
+               IL_CMD(FH49_RSCSR_CHNL0_WPTR);
+               IL_CMD(FH49_MEM_RCSR_CHNL0_CONFIG_REG);
+               IL_CMD(FH49_MEM_RSSR_SHARED_CTRL_REG);
+               IL_CMD(FH49_MEM_RSSR_RX_STATUS_REG);
+               IL_CMD(FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
+               IL_CMD(FH49_TSSR_TX_STATUS_REG);
+               IL_CMD(FH49_TSSR_TX_ERROR_REG);
+       default:
+               return "UNKNOWN";
+       }
+}
+
+int
+il4965_dump_fh(struct il_priv *il, char **buf, bool display)
+{
+       int i;
+#ifdef CONFIG_IWLEGACY_DEBUG
+       int pos = 0;
+       size_t bufsz = 0;
+#endif
+       static const u32 fh_tbl[] = {
+               FH49_RSCSR_CHNL0_STTS_WPTR_REG,
+               FH49_RSCSR_CHNL0_RBDCB_BASE_REG,
+               FH49_RSCSR_CHNL0_WPTR,
+               FH49_MEM_RCSR_CHNL0_CONFIG_REG,
+               FH49_MEM_RSSR_SHARED_CTRL_REG,
+               FH49_MEM_RSSR_RX_STATUS_REG,
+               FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV,
+               FH49_TSSR_TX_STATUS_REG,
+               FH49_TSSR_TX_ERROR_REG
+       };
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (display) {
+               bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
+               *buf = kmalloc(bufsz, GFP_KERNEL);
+               if (!*buf)
+                       return -ENOMEM;
+               pos +=
+                   scnprintf(*buf + pos, bufsz - pos, "FH register values:\n");
+               for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
+                       pos +=
+                           scnprintf(*buf + pos, bufsz - pos,
+                                     "  %34s: 0X%08x\n",
+                                     il4965_get_fh_string(fh_tbl[i]),
+                                     il_rd(il, fh_tbl[i]));
+               }
+               return pos;
+       }
+#endif
+       IL_ERR("FH register values:\n");
+       for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
+               IL_ERR("  %34s: 0X%08x\n", il4965_get_fh_string(fh_tbl[i]),
+                      il_rd(il, fh_tbl[i]));
+       }
+       return 0;
+}
+
+static void
+il4965_hdl_missed_beacon(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_missed_beacon_notif *missed_beacon;
+
+       missed_beacon = &pkt->u.missed_beacon;
+       if (le32_to_cpu(missed_beacon->consecutive_missed_beacons) >
+           il->missed_beacon_threshold) {
+               D_CALIB("missed bcn cnsq %d totl %d rcd %d expctd %d\n",
+                       le32_to_cpu(missed_beacon->consecutive_missed_beacons),
+                       le32_to_cpu(missed_beacon->total_missed_becons),
+                       le32_to_cpu(missed_beacon->num_recvd_beacons),
+                       le32_to_cpu(missed_beacon->num_expected_beacons));
+               if (!test_bit(S_SCANNING, &il->status))
+                       il4965_init_sensitivity(il);
+       }
+}
+
+/* Calculate noise level, based on measurements during network silence just
+ *   before arriving beacon.  This measurement can be done only if we know
+ *   exactly when to expect beacons, therefore only when we're associated. */
+static void
+il4965_rx_calc_noise(struct il_priv *il)
+{
+       struct stats_rx_non_phy *rx_info;
+       int num_active_rx = 0;
+       int total_silence = 0;
+       int bcn_silence_a, bcn_silence_b, bcn_silence_c;
+       int last_rx_noise;
+
+       rx_info = &(il->_4965.stats.rx.general);
+       bcn_silence_a =
+           le32_to_cpu(rx_info->beacon_silence_rssi_a) & IN_BAND_FILTER;
+       bcn_silence_b =
+           le32_to_cpu(rx_info->beacon_silence_rssi_b) & IN_BAND_FILTER;
+       bcn_silence_c =
+           le32_to_cpu(rx_info->beacon_silence_rssi_c) & IN_BAND_FILTER;
+
+       if (bcn_silence_a) {
+               total_silence += bcn_silence_a;
+               num_active_rx++;
+       }
+       if (bcn_silence_b) {
+               total_silence += bcn_silence_b;
+               num_active_rx++;
+       }
+       if (bcn_silence_c) {
+               total_silence += bcn_silence_c;
+               num_active_rx++;
+       }
+
+       /* Average among active antennas */
+       if (num_active_rx)
+               last_rx_noise = (total_silence / num_active_rx) - 107;
+       else
+               last_rx_noise = IL_NOISE_MEAS_NOT_AVAILABLE;
+
+       D_CALIB("inband silence a %u, b %u, c %u, dBm %d\n", bcn_silence_a,
+               bcn_silence_b, bcn_silence_c, last_rx_noise);
+}
+
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+/*
+ *  based on the assumption of all stats counter are in DWORD
+ *  FIXME: This function is for debugging, do not deal with
+ *  the case of counters roll-over.
+ */
+static void
+il4965_accumulative_stats(struct il_priv *il, __le32 * stats)
+{
+       int i, size;
+       __le32 *prev_stats;
+       u32 *accum_stats;
+       u32 *delta, *max_delta;
+       struct stats_general_common *general, *accum_general;
+       struct stats_tx *tx, *accum_tx;
+
+       prev_stats = (__le32 *) &il->_4965.stats;
+       accum_stats = (u32 *) &il->_4965.accum_stats;
+       size = sizeof(struct il_notif_stats);
+       general = &il->_4965.stats.general.common;
+       accum_general = &il->_4965.accum_stats.general.common;
+       tx = &il->_4965.stats.tx;
+       accum_tx = &il->_4965.accum_stats.tx;
+       delta = (u32 *) &il->_4965.delta_stats;
+       max_delta = (u32 *) &il->_4965.max_delta;
+
+       for (i = sizeof(__le32); i < size;
+            i +=
+            sizeof(__le32), stats++, prev_stats++, delta++, max_delta++,
+            accum_stats++) {
+               if (le32_to_cpu(*stats) > le32_to_cpu(*prev_stats)) {
+                       *delta =
+                           (le32_to_cpu(*stats) - le32_to_cpu(*prev_stats));
+                       *accum_stats += *delta;
+                       if (*delta > *max_delta)
+                               *max_delta = *delta;
+               }
+       }
+
+       /* reset accumulative stats for "no-counter" type stats */
+       accum_general->temperature = general->temperature;
+       accum_general->ttl_timestamp = general->ttl_timestamp;
+}
+#endif
+
+static void
+il4965_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       const int recalib_seconds = 60;
+       bool change;
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+
+       D_RX("Statistics notification received (%d vs %d).\n",
+            (int)sizeof(struct il_notif_stats),
+            le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK);
+
+       change =
+           ((il->_4965.stats.general.common.temperature !=
+             pkt->u.stats.general.common.temperature) ||
+            ((il->_4965.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK) !=
+             (pkt->u.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK)));
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       il4965_accumulative_stats(il, (__le32 *) &pkt->u.stats);
+#endif
+
+       /* TODO: reading some of stats is unneeded */
+       memcpy(&il->_4965.stats, &pkt->u.stats, sizeof(il->_4965.stats));
+
+       set_bit(S_STATS, &il->status);
+
+       /*
+        * Reschedule the stats timer to occur in recalib_seconds to ensure
+        * we get a thermal update even if the uCode doesn't give us one
+        */
+       mod_timer(&il->stats_periodic,
+                 jiffies + msecs_to_jiffies(recalib_seconds * 1000));
+
+       if (unlikely(!test_bit(S_SCANNING, &il->status)) &&
+           (pkt->hdr.cmd == N_STATS)) {
+               il4965_rx_calc_noise(il);
+               queue_work(il->workqueue, &il->run_time_calib_work);
+       }
+
+       if (change)
+               il4965_temperature_calib(il);
+}
+
+static void
+il4965_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+
+       if (le32_to_cpu(pkt->u.stats.flag) & UCODE_STATS_CLEAR_MSK) {
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+               memset(&il->_4965.accum_stats, 0,
+                      sizeof(struct il_notif_stats));
+               memset(&il->_4965.delta_stats, 0,
+                      sizeof(struct il_notif_stats));
+               memset(&il->_4965.max_delta, 0, sizeof(struct il_notif_stats));
+#endif
+               D_RX("Statistics have been cleared\n");
+       }
+       il4965_hdl_stats(il, rxb);
+}
+
+
+/*
+ * mac80211 queues, ACs, hardware queues, FIFOs.
+ *
+ * Cf. http://wireless.kernel.org/en/developers/Documentation/mac80211/queues
+ *
+ * Mac80211 uses the following numbers, which we get as from it
+ * by way of skb_get_queue_mapping(skb):
+ *
+ *     VO      0
+ *     VI      1
+ *     BE      2
+ *     BK      3
+ *
+ *
+ * Regular (not A-MPDU) frames are put into hardware queues corresponding
+ * to the FIFOs, see comments in iwl-prph.h. Aggregated frames get their
+ * own queue per aggregation session (RA/TID combination), such queues are
+ * set up to map into FIFOs too, for which we need an AC->FIFO mapping. In
+ * order to map frames to the right queue, we also need an AC->hw queue
+ * mapping. This is implemented here.
+ *
+ * Due to the way hw queues are set up (by the hw specific modules like
+ * 4965.c), the AC->hw queue mapping is the identity
+ * mapping.
+ */
+
+static const u8 tid_to_ac[] = {
+       IEEE80211_AC_BE,
+       IEEE80211_AC_BK,
+       IEEE80211_AC_BK,
+       IEEE80211_AC_BE,
+       IEEE80211_AC_VI,
+       IEEE80211_AC_VI,
+       IEEE80211_AC_VO,
+       IEEE80211_AC_VO
+};
+
+static inline int
+il4965_get_ac_from_tid(u16 tid)
+{
+       if (likely(tid < ARRAY_SIZE(tid_to_ac)))
+               return tid_to_ac[tid];
+
+       /* no support for TIDs 8-15 yet */
+       return -EINVAL;
+}
+
+static inline int
+il4965_get_fifo_from_tid(u16 tid)
+{
+       const u8 ac_to_fifo[] = {
+               IL_TX_FIFO_VO,
+               IL_TX_FIFO_VI,
+               IL_TX_FIFO_BE,
+               IL_TX_FIFO_BK,
+       };
+
+       if (likely(tid < ARRAY_SIZE(tid_to_ac)))
+               return ac_to_fifo[tid_to_ac[tid]];
+
+       /* no support for TIDs 8-15 yet */
+       return -EINVAL;
+}
+
+/*
+ * handle build C_TX command notification.
+ */
+static void
+il4965_tx_cmd_build_basic(struct il_priv *il, struct sk_buff *skb,
+                         struct il_tx_cmd *tx_cmd,
+                         struct ieee80211_tx_info *info,
+                         struct ieee80211_hdr *hdr, u8 std_id)
+{
+       __le16 fc = hdr->frame_control;
+       __le32 tx_flags = tx_cmd->tx_flags;
+
+       tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
+       if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
+               tx_flags |= TX_CMD_FLG_ACK_MSK;
+               if (ieee80211_is_mgmt(fc))
+                       tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
+               if (ieee80211_is_probe_resp(fc) &&
+                   !(le16_to_cpu(hdr->seq_ctrl) & 0xf))
+                       tx_flags |= TX_CMD_FLG_TSF_MSK;
+       } else {
+               tx_flags &= (~TX_CMD_FLG_ACK_MSK);
+               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
+       }
+
+       if (ieee80211_is_back_req(fc))
+               tx_flags |= TX_CMD_FLG_ACK_MSK | TX_CMD_FLG_IMM_BA_RSP_MASK;
+
+       tx_cmd->sta_id = std_id;
+       if (ieee80211_has_morefrags(fc))
+               tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;
+
+       if (ieee80211_is_data_qos(fc)) {
+               u8 *qc = ieee80211_get_qos_ctl(hdr);
+               tx_cmd->tid_tspec = qc[0] & 0xf;
+               tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
+       } else {
+               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
+       }
+
+       il_tx_cmd_protection(il, info, fc, &tx_flags);
+
+       tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
+       if (ieee80211_is_mgmt(fc)) {
+               if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
+                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
+               else
+                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
+       } else {
+               tx_cmd->timeout.pm_frame_timeout = 0;
+       }
+
+       tx_cmd->driver_txop = 0;
+       tx_cmd->tx_flags = tx_flags;
+       tx_cmd->next_frame_len = 0;
+}
+
+static void
+il4965_tx_cmd_build_rate(struct il_priv *il,
+                        struct il_tx_cmd *tx_cmd,
+                        struct ieee80211_tx_info *info,
+                        struct ieee80211_sta *sta,
+                        __le16 fc)
+{
+       const u8 rts_retry_limit = 60;
+       u32 rate_flags;
+       int rate_idx;
+       u8 data_retry_limit;
+       u8 rate_plcp;
+
+       /* Set retry limit on DATA packets and Probe Responses */
+       if (ieee80211_is_probe_resp(fc))
+               data_retry_limit = 3;
+       else
+               data_retry_limit = IL4965_DEFAULT_TX_RETRY;
+       tx_cmd->data_retry_limit = data_retry_limit;
+       /* Set retry limit on RTS packets */
+       tx_cmd->rts_retry_limit = min(data_retry_limit, rts_retry_limit);
+
+       /* DATA packets will use the uCode station table for rate/antenna
+        * selection */
+       if (ieee80211_is_data(fc)) {
+               tx_cmd->initial_rate_idx = 0;
+               tx_cmd->tx_flags |= TX_CMD_FLG_STA_RATE_MSK;
+               return;
+       }
+
+       /**
+        * If the current TX rate stored in mac80211 has the MCS bit set, it's
+        * not really a TX rate.  Thus, we use the lowest supported rate for
+        * this band.  Also use the lowest supported rate if the stored rate
+        * idx is invalid.
+        */
+       rate_idx = info->control.rates[0].idx;
+       if ((info->control.rates[0].flags & IEEE80211_TX_RC_MCS) || rate_idx < 0
+           || rate_idx > RATE_COUNT_LEGACY)
+               rate_idx = rate_lowest_index(&il->bands[info->band], sta);
+       /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
+       if (info->band == IEEE80211_BAND_5GHZ)
+               rate_idx += IL_FIRST_OFDM_RATE;
+       /* Get PLCP rate for tx_cmd->rate_n_flags */
+       rate_plcp = il_rates[rate_idx].plcp;
+       /* Zero out flags for this packet */
+       rate_flags = 0;
+
+       /* Set CCK flag as needed */
+       if (rate_idx >= IL_FIRST_CCK_RATE && rate_idx <= IL_LAST_CCK_RATE)
+               rate_flags |= RATE_MCS_CCK_MSK;
+
+       /* Set up antennas */
+       il4965_toggle_tx_ant(il, &il->mgmt_tx_ant, il->hw_params.valid_tx_ant);
+       rate_flags |= BIT(il->mgmt_tx_ant) << RATE_MCS_ANT_POS;
+
+       /* Set the rate in the TX cmd */
+       tx_cmd->rate_n_flags = cpu_to_le32(rate_plcp | rate_flags);
+}
+
+static void
+il4965_tx_cmd_build_hwcrypto(struct il_priv *il, struct ieee80211_tx_info *info,
+                            struct il_tx_cmd *tx_cmd, struct sk_buff *skb_frag,
+                            int sta_id)
+{
+       struct ieee80211_key_conf *keyconf = info->control.hw_key;
+
+       switch (keyconf->cipher) {
+       case WLAN_CIPHER_SUITE_CCMP:
+               tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
+               memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
+               if (info->flags & IEEE80211_TX_CTL_AMPDU)
+                       tx_cmd->tx_flags |= TX_CMD_FLG_AGG_CCMP_MSK;
+               D_TX("tx_cmd with AES hwcrypto\n");
+               break;
+
+       case WLAN_CIPHER_SUITE_TKIP:
+               tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
+               ieee80211_get_tkip_p2k(keyconf, skb_frag, tx_cmd->key);
+               D_TX("tx_cmd with tkip hwcrypto\n");
+               break;
+
+       case WLAN_CIPHER_SUITE_WEP104:
+               tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
+               /* fall through */
+       case WLAN_CIPHER_SUITE_WEP40:
+               tx_cmd->sec_ctl |=
+                   (TX_CMD_SEC_WEP | (keyconf->keyidx & TX_CMD_SEC_MSK) <<
+                    TX_CMD_SEC_SHIFT);
+
+               memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
+
+               D_TX("Configuring packet for WEP encryption " "with key %d\n",
+                    keyconf->keyidx);
+               break;
+
+       default:
+               IL_ERR("Unknown encode cipher %x\n", keyconf->cipher);
+               break;
+       }
+}
+
+/*
+ * start C_TX command process
+ */
+int
+il4965_tx_skb(struct il_priv *il,
+             struct ieee80211_sta *sta,
+             struct sk_buff *skb)
+{
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+       struct il_station_priv *sta_priv = NULL;
+       struct il_tx_queue *txq;
+       struct il_queue *q;
+       struct il_device_cmd *out_cmd;
+       struct il_cmd_meta *out_meta;
+       struct il_tx_cmd *tx_cmd;
+       int txq_id;
+       dma_addr_t phys_addr;
+       dma_addr_t txcmd_phys;
+       dma_addr_t scratch_phys;
+       u16 len, firstlen, secondlen;
+       u16 seq_number = 0;
+       __le16 fc;
+       u8 hdr_len;
+       u8 sta_id;
+       u8 wait_write_ptr = 0;
+       u8 tid = 0;
+       u8 *qc = NULL;
+       unsigned long flags;
+       bool is_agg = false;
+
+       spin_lock_irqsave(&il->lock, flags);
+       if (il_is_rfkill(il)) {
+               D_DROP("Dropping - RF KILL\n");
+               goto drop_unlock;
+       }
+
+       fc = hdr->frame_control;
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (ieee80211_is_auth(fc))
+               D_TX("Sending AUTH frame\n");
+       else if (ieee80211_is_assoc_req(fc))
+               D_TX("Sending ASSOC frame\n");
+       else if (ieee80211_is_reassoc_req(fc))
+               D_TX("Sending REASSOC frame\n");
+#endif
+
+       hdr_len = ieee80211_hdrlen(fc);
+
+       /* For management frames use broadcast id to do not break aggregation */
+       if (!ieee80211_is_data(fc))
+               sta_id = il->hw_params.bcast_id;
+       else {
+               /* Find idx into station table for destination station */
+               sta_id = il_sta_id_or_broadcast(il, sta);
+
+               if (sta_id == IL_INVALID_STATION) {
+                       D_DROP("Dropping - INVALID STATION: %pM\n", hdr->addr1);
+                       goto drop_unlock;
+               }
+       }
+
+       D_TX("station Id %d\n", sta_id);
+
+       if (sta)
+               sta_priv = (void *)sta->drv_priv;
+
+       if (sta_priv && sta_priv->asleep &&
+           (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)) {
+               /*
+                * This sends an asynchronous command to the device,
+                * but we can rely on it being processed before the
+                * next frame is processed -- and the next frame to
+                * this station is the one that will consume this
+                * counter.
+                * For now set the counter to just 1 since we do not
+                * support uAPSD yet.
+                */
+               il4965_sta_modify_sleep_tx_count(il, sta_id, 1);
+       }
+
+       /* FIXME: remove me ? */
+       WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM);
+
+       /* Access category (AC) is also the queue number */
+       txq_id = skb_get_queue_mapping(skb);
+
+       /* irqs already disabled/saved above when locking il->lock */
+       spin_lock(&il->sta_lock);
+
+       if (ieee80211_is_data_qos(fc)) {
+               qc = ieee80211_get_qos_ctl(hdr);
+               tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
+               if (WARN_ON_ONCE(tid >= MAX_TID_COUNT)) {
+                       spin_unlock(&il->sta_lock);
+                       goto drop_unlock;
+               }
+               seq_number = il->stations[sta_id].tid[tid].seq_number;
+               seq_number &= IEEE80211_SCTL_SEQ;
+               hdr->seq_ctrl =
+                   hdr->seq_ctrl & cpu_to_le16(IEEE80211_SCTL_FRAG);
+               hdr->seq_ctrl |= cpu_to_le16(seq_number);
+               seq_number += 0x10;
+               /* aggregation is on for this <sta,tid> */
+               if (info->flags & IEEE80211_TX_CTL_AMPDU &&
+                   il->stations[sta_id].tid[tid].agg.state == IL_AGG_ON) {
+                       txq_id = il->stations[sta_id].tid[tid].agg.txq_id;
+                       is_agg = true;
+               }
+       }
+
+       txq = &il->txq[txq_id];
+       q = &txq->q;
+
+       if (unlikely(il_queue_space(q) < q->high_mark)) {
+               spin_unlock(&il->sta_lock);
+               goto drop_unlock;
+       }
+
+       if (ieee80211_is_data_qos(fc)) {
+               il->stations[sta_id].tid[tid].tfds_in_queue++;
+               if (!ieee80211_has_morefrags(fc))
+                       il->stations[sta_id].tid[tid].seq_number = seq_number;
+       }
+
+       spin_unlock(&il->sta_lock);
+
+       txq->skbs[q->write_ptr] = skb;
+
+       /* Set up first empty entry in queue's array of Tx/cmd buffers */
+       out_cmd = txq->cmd[q->write_ptr];
+       out_meta = &txq->meta[q->write_ptr];
+       tx_cmd = &out_cmd->cmd.tx;
+       memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
+       memset(tx_cmd, 0, sizeof(struct il_tx_cmd));
+
+       /*
+        * Set up the Tx-command (not MAC!) header.
+        * Store the chosen Tx queue and TFD idx within the sequence field;
+        * after Tx, uCode's Tx response will return this value so driver can
+        * locate the frame within the tx queue and do post-tx processing.
+        */
+       out_cmd->hdr.cmd = C_TX;
+       out_cmd->hdr.sequence =
+           cpu_to_le16((u16)
+                       (QUEUE_TO_SEQ(txq_id) | IDX_TO_SEQ(q->write_ptr)));
+
+       /* Copy MAC header from skb into command buffer */
+       memcpy(tx_cmd->hdr, hdr, hdr_len);
+
+       /* Total # bytes to be transmitted */
+       tx_cmd->len = cpu_to_le16((u16) skb->len);
+
+       if (info->control.hw_key)
+               il4965_tx_cmd_build_hwcrypto(il, info, tx_cmd, skb, sta_id);
+
+       /* TODO need this for burst mode later on */
+       il4965_tx_cmd_build_basic(il, skb, tx_cmd, info, hdr, sta_id);
+
+       il4965_tx_cmd_build_rate(il, tx_cmd, info, sta, fc);
+
+       /*
+        * Use the first empty entry in this queue's command buffer array
+        * to contain the Tx command and MAC header concatenated together
+        * (payload data will be in another buffer).
+        * Size of this varies, due to varying MAC header length.
+        * If end is not dword aligned, we'll have 2 extra bytes at the end
+        * of the MAC header (device reads on dword boundaries).
+        * We'll tell device about this padding later.
+        */
+       len = sizeof(struct il_tx_cmd) + sizeof(struct il_cmd_header) + hdr_len;
+       firstlen = (len + 3) & ~3;
+
+       /* Tell NIC about any 2-byte padding after MAC header */
+       if (firstlen != len)
+               tx_cmd->tx_flags |= TX_CMD_FLG_MH_PAD_MSK;
+
+       /* Physical address of this Tx command's header (not MAC header!),
+        * within command buffer array. */
+       txcmd_phys =
+           pci_map_single(il->pci_dev, &out_cmd->hdr, firstlen,
+                          PCI_DMA_BIDIRECTIONAL);
+       if (unlikely(pci_dma_mapping_error(il->pci_dev, txcmd_phys)))
+               goto drop_unlock;
+
+       /* Set up TFD's 2nd entry to point directly to remainder of skb,
+        * if any (802.11 null frames have no payload). */
+       secondlen = skb->len - hdr_len;
+       if (secondlen > 0) {
+               phys_addr =
+                   pci_map_single(il->pci_dev, skb->data + hdr_len, secondlen,
+                                  PCI_DMA_TODEVICE);
+               if (unlikely(pci_dma_mapping_error(il->pci_dev, phys_addr)))
+                       goto drop_unlock;
+       }
+
+       /* Add buffer containing Tx command and MAC(!) header to TFD's
+        * first entry */
+       il->ops->txq_attach_buf_to_tfd(il, txq, txcmd_phys, firstlen, 1, 0);
+       dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
+       dma_unmap_len_set(out_meta, len, firstlen);
+       if (secondlen)
+               il->ops->txq_attach_buf_to_tfd(il, txq, phys_addr, secondlen,
+                                              0, 0);
+
+       if (!ieee80211_has_morefrags(hdr->frame_control)) {
+               txq->need_update = 1;
+       } else {
+               wait_write_ptr = 1;
+               txq->need_update = 0;
+       }
+
+       scratch_phys =
+           txcmd_phys + sizeof(struct il_cmd_header) +
+           offsetof(struct il_tx_cmd, scratch);
+
+       /* take back ownership of DMA buffer to enable update */
+       pci_dma_sync_single_for_cpu(il->pci_dev, txcmd_phys, firstlen,
+                                   PCI_DMA_BIDIRECTIONAL);
+       tx_cmd->dram_lsb_ptr = cpu_to_le32(scratch_phys);
+       tx_cmd->dram_msb_ptr = il_get_dma_hi_addr(scratch_phys);
+
+       il_update_stats(il, true, fc, skb->len);
+
+       D_TX("sequence nr = 0X%x\n", le16_to_cpu(out_cmd->hdr.sequence));
+       D_TX("tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
+       il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd, sizeof(*tx_cmd));
+       il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd->hdr, hdr_len);
+
+       /* Set up entry for this TFD in Tx byte-count array */
+       if (info->flags & IEEE80211_TX_CTL_AMPDU)
+               il->ops->txq_update_byte_cnt_tbl(il, txq, le16_to_cpu(tx_cmd->len));
+
+       pci_dma_sync_single_for_device(il->pci_dev, txcmd_phys, firstlen,
+                                      PCI_DMA_BIDIRECTIONAL);
+
+       /* Tell device the write idx *just past* this latest filled TFD */
+       q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
+       il_txq_update_write_ptr(il, txq);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       /*
+        * At this point the frame is "transmitted" successfully
+        * and we will get a TX status notification eventually,
+        * regardless of the value of ret. "ret" only indicates
+        * whether or not we should update the write pointer.
+        */
+
+       /*
+        * Avoid atomic ops if it isn't an associated client.
+        * Also, if this is a packet for aggregation, don't
+        * increase the counter because the ucode will stop
+        * aggregation queues when their respective station
+        * goes to sleep.
+        */
+       if (sta_priv && sta_priv->client && !is_agg)
+               atomic_inc(&sta_priv->pending_frames);
+
+       if (il_queue_space(q) < q->high_mark && il->mac80211_registered) {
+               if (wait_write_ptr) {
+                       spin_lock_irqsave(&il->lock, flags);
+                       txq->need_update = 1;
+                       il_txq_update_write_ptr(il, txq);
+                       spin_unlock_irqrestore(&il->lock, flags);
+               } else {
+                       il_stop_queue(il, txq);
+               }
+       }
+
+       return 0;
+
+drop_unlock:
+       spin_unlock_irqrestore(&il->lock, flags);
+       return -1;
+}
+
+static inline int
+il4965_alloc_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr, size_t size)
+{
+       ptr->addr = dma_alloc_coherent(&il->pci_dev->dev, size, &ptr->dma,
+                                      GFP_KERNEL);
+       if (!ptr->addr)
+               return -ENOMEM;
+       ptr->size = size;
+       return 0;
+}
+
+static inline void
+il4965_free_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr)
+{
+       if (unlikely(!ptr->addr))
+               return;
+
+       dma_free_coherent(&il->pci_dev->dev, ptr->size, ptr->addr, ptr->dma);
+       memset(ptr, 0, sizeof(*ptr));
+}
+
+/**
+ * il4965_hw_txq_ctx_free - Free TXQ Context
+ *
+ * Destroy all TX DMA queues and structures
+ */
+void
+il4965_hw_txq_ctx_free(struct il_priv *il)
+{
+       int txq_id;
+
+       /* Tx queues */
+       if (il->txq) {
+               for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
+                       if (txq_id == il->cmd_queue)
+                               il_cmd_queue_free(il);
+                       else
+                               il_tx_queue_free(il, txq_id);
+       }
+       il4965_free_dma_ptr(il, &il->kw);
+
+       il4965_free_dma_ptr(il, &il->scd_bc_tbls);
+
+       /* free tx queue structure */
+       il_free_txq_mem(il);
+}
+
+/**
+ * il4965_txq_ctx_alloc - allocate TX queue context
+ * Allocate all Tx DMA structures and initialize them
+ *
+ * @param il
+ * @return error code
+ */
+int
+il4965_txq_ctx_alloc(struct il_priv *il)
+{
+       int ret, txq_id;
+       unsigned long flags;
+
+       /* Free all tx/cmd queues and keep-warm buffer */
+       il4965_hw_txq_ctx_free(il);
+
+       ret =
+           il4965_alloc_dma_ptr(il, &il->scd_bc_tbls,
+                                il->hw_params.scd_bc_tbls_size);
+       if (ret) {
+               IL_ERR("Scheduler BC Table allocation failed\n");
+               goto error_bc_tbls;
+       }
+       /* Alloc keep-warm buffer */
+       ret = il4965_alloc_dma_ptr(il, &il->kw, IL_KW_SIZE);
+       if (ret) {
+               IL_ERR("Keep Warm allocation failed\n");
+               goto error_kw;
+       }
+
+       /* allocate tx queue structure */
+       ret = il_alloc_txq_mem(il);
+       if (ret)
+               goto error;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Turn off all Tx DMA fifos */
+       il4965_txq_set_sched(il, 0);
+
+       /* Tell NIC where to find the "keep warm" buffer */
+       il_wr(il, FH49_KW_MEM_ADDR_REG, il->kw.dma >> 4);
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       /* Alloc and init all Tx queues, including the command queue (#4/#9) */
+       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
+               ret = il_tx_queue_init(il, txq_id);
+               if (ret) {
+                       IL_ERR("Tx %d queue init failed\n", txq_id);
+                       goto error;
+               }
+       }
+
+       return ret;
+
+error:
+       il4965_hw_txq_ctx_free(il);
+       il4965_free_dma_ptr(il, &il->kw);
+error_kw:
+       il4965_free_dma_ptr(il, &il->scd_bc_tbls);
+error_bc_tbls:
+       return ret;
+}
+
+void
+il4965_txq_ctx_reset(struct il_priv *il)
+{
+       int txq_id;
+       unsigned long flags;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Turn off all Tx DMA fifos */
+       il4965_txq_set_sched(il, 0);
+       /* Tell NIC where to find the "keep warm" buffer */
+       il_wr(il, FH49_KW_MEM_ADDR_REG, il->kw.dma >> 4);
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       /* Alloc and init all Tx queues, including the command queue (#4) */
+       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
+               il_tx_queue_reset(il, txq_id);
+}
+
+static void
+il4965_txq_ctx_unmap(struct il_priv *il)
+{
+       int txq_id;
+
+       if (!il->txq)
+               return;
+
+       /* Unmap DMA from host system and free skb's */
+       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
+               if (txq_id == il->cmd_queue)
+                       il_cmd_queue_unmap(il);
+               else
+                       il_tx_queue_unmap(il, txq_id);
+}
+
+/**
+ * il4965_txq_ctx_stop - Stop all Tx DMA channels
+ */
+void
+il4965_txq_ctx_stop(struct il_priv *il)
+{
+       int ch, ret;
+
+       _il_wr_prph(il, IL49_SCD_TXFACT, 0);
+
+       /* Stop each Tx DMA channel, and wait for it to be idle */
+       for (ch = 0; ch < il->hw_params.dma_chnl_num; ch++) {
+               _il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
+               ret =
+                   _il_poll_bit(il, FH49_TSSR_TX_STATUS_REG,
+                                FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
+                                FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
+                                1000);
+               if (ret < 0)
+                       IL_ERR("Timeout stopping DMA channel %d [0x%08x]",
+                              ch, _il_rd(il, FH49_TSSR_TX_STATUS_REG));
+       }
+}
+
+/*
+ * Find first available (lowest unused) Tx Queue, mark it "active".
+ * Called only when finding queue for aggregation.
+ * Should never return anything < 7, because they should already
+ * be in use as EDCA AC (0-3), Command (4), reserved (5, 6)
+ */
+static int
+il4965_txq_ctx_activate_free(struct il_priv *il)
+{
+       int txq_id;
+
+       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
+               if (!test_and_set_bit(txq_id, &il->txq_ctx_active_msk))
+                       return txq_id;
+       return -1;
+}
+
+/**
+ * il4965_tx_queue_stop_scheduler - Stop queue, but keep configuration
+ */
+static void
+il4965_tx_queue_stop_scheduler(struct il_priv *il, u16 txq_id)
+{
+       /* Simply stop the queue, but don't change any configuration;
+        * the SCD_ACT_EN bit is the write-enable mask for the ACTIVE bit. */
+       il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
+                  (0 << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
+                  (1 << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN));
+}
+
+/**
+ * il4965_tx_queue_set_q2ratid - Map unique receiver/tid combination to a queue
+ */
+static int
+il4965_tx_queue_set_q2ratid(struct il_priv *il, u16 ra_tid, u16 txq_id)
+{
+       u32 tbl_dw_addr;
+       u32 tbl_dw;
+       u16 scd_q2ratid;
+
+       scd_q2ratid = ra_tid & IL_SCD_QUEUE_RA_TID_MAP_RATID_MSK;
+
+       tbl_dw_addr =
+           il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id);
+
+       tbl_dw = il_read_targ_mem(il, tbl_dw_addr);
+
+       if (txq_id & 0x1)
+               tbl_dw = (scd_q2ratid << 16) | (tbl_dw & 0x0000FFFF);
+       else
+               tbl_dw = scd_q2ratid | (tbl_dw & 0xFFFF0000);
+
+       il_write_targ_mem(il, tbl_dw_addr, tbl_dw);
+
+       return 0;
+}
+
+/**
+ * il4965_tx_queue_agg_enable - Set up & enable aggregation for selected queue
+ *
+ * NOTE:  txq_id must be greater than IL49_FIRST_AMPDU_QUEUE,
+ *        i.e. it must be one of the higher queues used for aggregation
+ */
+static int
+il4965_txq_agg_enable(struct il_priv *il, int txq_id, int tx_fifo, int sta_id,
+                     int tid, u16 ssn_idx)
+{
+       unsigned long flags;
+       u16 ra_tid;
+       int ret;
+
+       if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
+           (IL49_FIRST_AMPDU_QUEUE +
+            il->cfg->num_of_ampdu_queues <= txq_id)) {
+               IL_WARN("queue number out of range: %d, must be %d to %d\n",
+                       txq_id, IL49_FIRST_AMPDU_QUEUE,
+                       IL49_FIRST_AMPDU_QUEUE +
+                       il->cfg->num_of_ampdu_queues - 1);
+               return -EINVAL;
+       }
+
+       ra_tid = BUILD_RAxTID(sta_id, tid);
+
+       /* Modify device's station table to Tx this TID */
+       ret = il4965_sta_tx_modify_enable_tid(il, sta_id, tid);
+       if (ret)
+               return ret;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Stop this Tx queue before configuring it */
+       il4965_tx_queue_stop_scheduler(il, txq_id);
+
+       /* Map receiver-address / traffic-ID to this queue */
+       il4965_tx_queue_set_q2ratid(il, ra_tid, txq_id);
+
+       /* Set this queue as a chain-building queue */
+       il_set_bits_prph(il, IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
+
+       /* Place first TFD at idx corresponding to start sequence number.
+        * Assumes that ssn_idx is valid (!= 0xFFF) */
+       il->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
+       il->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
+       il4965_set_wr_ptrs(il, txq_id, ssn_idx);
+
+       /* Set up Tx win size and frame limit for this queue */
+       il_write_targ_mem(il,
+                         il->scd_base_addr +
+                         IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id),
+                         (SCD_WIN_SIZE << IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS)
+                         & IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
+
+       il_write_targ_mem(il,
+                         il->scd_base_addr +
+                         IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32),
+                         (SCD_FRAME_LIMIT <<
+                          IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
+                         IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
+
+       il_set_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
+
+       /* Set up Status area in SRAM, map to Tx DMA/FIFO, activate the queue */
+       il4965_tx_queue_set_status(il, &il->txq[txq_id], tx_fifo, 1);
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       return 0;
+}
+
+int
+il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
+                   struct ieee80211_sta *sta, u16 tid, u16 * ssn)
+{
+       int sta_id;
+       int tx_fifo;
+       int txq_id;
+       int ret;
+       unsigned long flags;
+       struct il_tid_data *tid_data;
+
+       /* FIXME: warning if tx fifo not found ? */
+       tx_fifo = il4965_get_fifo_from_tid(tid);
+       if (unlikely(tx_fifo < 0))
+               return tx_fifo;
+
+       D_HT("%s on ra = %pM tid = %d\n", __func__, sta->addr, tid);
+
+       sta_id = il_sta_id(sta);
+       if (sta_id == IL_INVALID_STATION) {
+               IL_ERR("Start AGG on invalid station\n");
+               return -ENXIO;
+       }
+       if (unlikely(tid >= MAX_TID_COUNT))
+               return -EINVAL;
+
+       if (il->stations[sta_id].tid[tid].agg.state != IL_AGG_OFF) {
+               IL_ERR("Start AGG when state is not IL_AGG_OFF !\n");
+               return -ENXIO;
+       }
+
+       txq_id = il4965_txq_ctx_activate_free(il);
+       if (txq_id == -1) {
+               IL_ERR("No free aggregation queue available\n");
+               return -ENXIO;
+       }
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       tid_data = &il->stations[sta_id].tid[tid];
+       *ssn = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
+       tid_data->agg.txq_id = txq_id;
+       il_set_swq_id(&il->txq[txq_id], il4965_get_ac_from_tid(tid), txq_id);
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       ret = il4965_txq_agg_enable(il, txq_id, tx_fifo, sta_id, tid, *ssn);
+       if (ret)
+               return ret;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       tid_data = &il->stations[sta_id].tid[tid];
+       if (tid_data->tfds_in_queue == 0) {
+               D_HT("HW queue is empty\n");
+               tid_data->agg.state = IL_AGG_ON;
+               ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
+       } else {
+               D_HT("HW queue is NOT empty: %d packets in HW queue\n",
+                    tid_data->tfds_in_queue);
+               tid_data->agg.state = IL_EMPTYING_HW_QUEUE_ADDBA;
+       }
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+       return ret;
+}
+
+/**
+ * txq_id must be greater than IL49_FIRST_AMPDU_QUEUE
+ * il->lock must be held by the caller
+ */
+static int
+il4965_txq_agg_disable(struct il_priv *il, u16 txq_id, u16 ssn_idx, u8 tx_fifo)
+{
+       if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
+           (IL49_FIRST_AMPDU_QUEUE +
+            il->cfg->num_of_ampdu_queues <= txq_id)) {
+               IL_WARN("queue number out of range: %d, must be %d to %d\n",
+                       txq_id, IL49_FIRST_AMPDU_QUEUE,
+                       IL49_FIRST_AMPDU_QUEUE +
+                       il->cfg->num_of_ampdu_queues - 1);
+               return -EINVAL;
+       }
+
+       il4965_tx_queue_stop_scheduler(il, txq_id);
+
+       il_clear_bits_prph(il, IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
+
+       il->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
+       il->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
+       /* supposes that ssn_idx is valid (!= 0xFFF) */
+       il4965_set_wr_ptrs(il, txq_id, ssn_idx);
+
+       il_clear_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
+       il_txq_ctx_deactivate(il, txq_id);
+       il4965_tx_queue_set_status(il, &il->txq[txq_id], tx_fifo, 0);
+
+       return 0;
+}
+
+int
+il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
+                  struct ieee80211_sta *sta, u16 tid)
+{
+       int tx_fifo_id, txq_id, sta_id, ssn;
+       struct il_tid_data *tid_data;
+       int write_ptr, read_ptr;
+       unsigned long flags;
+
+       /* FIXME: warning if tx_fifo_id not found ? */
+       tx_fifo_id = il4965_get_fifo_from_tid(tid);
+       if (unlikely(tx_fifo_id < 0))
+               return tx_fifo_id;
+
+       sta_id = il_sta_id(sta);
+
+       if (sta_id == IL_INVALID_STATION) {
+               IL_ERR("Invalid station for AGG tid %d\n", tid);
+               return -ENXIO;
+       }
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+
+       tid_data = &il->stations[sta_id].tid[tid];
+       ssn = (tid_data->seq_number & IEEE80211_SCTL_SEQ) >> 4;
+       txq_id = tid_data->agg.txq_id;
+
+       switch (il->stations[sta_id].tid[tid].agg.state) {
+       case IL_EMPTYING_HW_QUEUE_ADDBA:
+               /*
+                * This can happen if the peer stops aggregation
+                * again before we've had a chance to drain the
+                * queue we selected previously, i.e. before the
+                * session was really started completely.
+                */
+               D_HT("AGG stop before setup done\n");
+               goto turn_off;
+       case IL_AGG_ON:
+               break;
+       default:
+               IL_WARN("Stopping AGG while state not ON or starting\n");
+       }
+
+       write_ptr = il->txq[txq_id].q.write_ptr;
+       read_ptr = il->txq[txq_id].q.read_ptr;
+
+       /* The queue is not empty */
+       if (write_ptr != read_ptr) {
+               D_HT("Stopping a non empty AGG HW QUEUE\n");
+               il->stations[sta_id].tid[tid].agg.state =
+                   IL_EMPTYING_HW_QUEUE_DELBA;
+               spin_unlock_irqrestore(&il->sta_lock, flags);
+               return 0;
+       }
+
+       D_HT("HW queue is empty\n");
+turn_off:
+       il->stations[sta_id].tid[tid].agg.state = IL_AGG_OFF;
+
+       /* do not restore/save irqs */
+       spin_unlock(&il->sta_lock);
+       spin_lock(&il->lock);
+
+       /*
+        * the only reason this call can fail is queue number out of range,
+        * which can happen if uCode is reloaded and all the station
+        * information are lost. if it is outside the range, there is no need
+        * to deactivate the uCode queue, just return "success" to allow
+        *  mac80211 to clean up it own data.
+        */
+       il4965_txq_agg_disable(il, txq_id, ssn, tx_fifo_id);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
+
+       return 0;
+}
+
+int
+il4965_txq_check_empty(struct il_priv *il, int sta_id, u8 tid, int txq_id)
+{
+       struct il_queue *q = &il->txq[txq_id].q;
+       u8 *addr = il->stations[sta_id].sta.sta.addr;
+       struct il_tid_data *tid_data = &il->stations[sta_id].tid[tid];
+
+       lockdep_assert_held(&il->sta_lock);
+
+       switch (il->stations[sta_id].tid[tid].agg.state) {
+       case IL_EMPTYING_HW_QUEUE_DELBA:
+               /* We are reclaiming the last packet of the */
+               /* aggregated HW queue */
+               if (txq_id == tid_data->agg.txq_id &&
+                   q->read_ptr == q->write_ptr) {
+                       u16 ssn = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
+                       int tx_fifo = il4965_get_fifo_from_tid(tid);
+                       D_HT("HW queue empty: continue DELBA flow\n");
+                       il4965_txq_agg_disable(il, txq_id, ssn, tx_fifo);
+                       tid_data->agg.state = IL_AGG_OFF;
+                       ieee80211_stop_tx_ba_cb_irqsafe(il->vif, addr, tid);
+               }
+               break;
+       case IL_EMPTYING_HW_QUEUE_ADDBA:
+               /* We are reclaiming the last packet of the queue */
+               if (tid_data->tfds_in_queue == 0) {
+                       D_HT("HW queue empty: continue ADDBA flow\n");
+                       tid_data->agg.state = IL_AGG_ON;
+                       ieee80211_start_tx_ba_cb_irqsafe(il->vif, addr, tid);
+               }
+               break;
+       }
+
+       return 0;
+}
+
+static void
+il4965_non_agg_tx_status(struct il_priv *il, const u8 *addr1)
+{
+       struct ieee80211_sta *sta;
+       struct il_station_priv *sta_priv;
+
+       rcu_read_lock();
+       sta = ieee80211_find_sta(il->vif, addr1);
+       if (sta) {
+               sta_priv = (void *)sta->drv_priv;
+               /* avoid atomic ops if this isn't a client */
+               if (sta_priv->client &&
+                   atomic_dec_return(&sta_priv->pending_frames) == 0)
+                       ieee80211_sta_block_awake(il->hw, sta, false);
+       }
+       rcu_read_unlock();
+}
+
+static void
+il4965_tx_status(struct il_priv *il, struct sk_buff *skb, bool is_agg)
+{
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+
+       if (!is_agg)
+               il4965_non_agg_tx_status(il, hdr->addr1);
+
+       ieee80211_tx_status_irqsafe(il->hw, skb);
+}
+
+int
+il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
+{
+       struct il_tx_queue *txq = &il->txq[txq_id];
+       struct il_queue *q = &txq->q;
+       int nfreed = 0;
+       struct ieee80211_hdr *hdr;
+       struct sk_buff *skb;
+
+       if (idx >= q->n_bd || il_queue_used(q, idx) == 0) {
+               IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
+                      "is out of range [0-%d] %d %d.\n", txq_id, idx, q->n_bd,
+                      q->write_ptr, q->read_ptr);
+               return 0;
+       }
+
+       for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
+            q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
+
+               skb = txq->skbs[txq->q.read_ptr];
+
+               if (WARN_ON_ONCE(skb == NULL))
+                       continue;
+
+               hdr = (struct ieee80211_hdr *) skb->data;
+               if (ieee80211_is_data_qos(hdr->frame_control))
+                       nfreed++;
+
+               il4965_tx_status(il, skb, txq_id >= IL4965_FIRST_AMPDU_QUEUE);
+
+               txq->skbs[txq->q.read_ptr] = NULL;
+               il->ops->txq_free_tfd(il, txq);
+       }
+       return nfreed;
+}
+
+/**
+ * il4965_tx_status_reply_compressed_ba - Update tx status from block-ack
+ *
+ * Go through block-ack's bitmap of ACK'd frames, update driver's record of
+ * ACK vs. not.  This gets sent to mac80211, then to rate scaling algo.
+ */
+static int
+il4965_tx_status_reply_compressed_ba(struct il_priv *il, struct il_ht_agg *agg,
+                                    struct il_compressed_ba_resp *ba_resp)
+{
+       int i, sh, ack;
+       u16 seq_ctl = le16_to_cpu(ba_resp->seq_ctl);
+       u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);
+       int successes = 0;
+       struct ieee80211_tx_info *info;
+       u64 bitmap, sent_bitmap;
+
+       if (unlikely(!agg->wait_for_ba)) {
+               if (unlikely(ba_resp->bitmap))
+                       IL_ERR("Received BA when not expected\n");
+               return -EINVAL;
+       }
+
+       /* Mark that the expected block-ack response arrived */
+       agg->wait_for_ba = 0;
+       D_TX_REPLY("BA %d %d\n", agg->start_idx, ba_resp->seq_ctl);
+
+       /* Calculate shift to align block-ack bits with our Tx win bits */
+       sh = agg->start_idx - SEQ_TO_IDX(seq_ctl >> 4);
+       if (sh < 0)             /* tbw something is wrong with indices */
+               sh += 0x100;
+
+       if (agg->frame_count > (64 - sh)) {
+               D_TX_REPLY("more frames than bitmap size");
+               return -1;
+       }
+
+       /* don't use 64-bit values for now */
+       bitmap = le64_to_cpu(ba_resp->bitmap) >> sh;
+
+       /* check for success or failure according to the
+        * transmitted bitmap and block-ack bitmap */
+       sent_bitmap = bitmap & agg->bitmap;
+
+       /* For each frame attempted in aggregation,
+        * update driver's record of tx frame's status. */
+       i = 0;
+       while (sent_bitmap) {
+               ack = sent_bitmap & 1ULL;
+               successes += ack;
+               D_TX_REPLY("%s ON i=%d idx=%d raw=%d\n", ack ? "ACK" : "NACK",
+                          i, (agg->start_idx + i) & 0xff, agg->start_idx + i);
+               sent_bitmap >>= 1;
+               ++i;
+       }
+
+       D_TX_REPLY("Bitmap %llx\n", (unsigned long long)bitmap);
+
+       info = IEEE80211_SKB_CB(il->txq[scd_flow].skbs[agg->start_idx]);
+       memset(&info->status, 0, sizeof(info->status));
+       info->flags |= IEEE80211_TX_STAT_ACK;
+       info->flags |= IEEE80211_TX_STAT_AMPDU;
+       info->status.ampdu_ack_len = successes;
+       info->status.ampdu_len = agg->frame_count;
+       il4965_hwrate_to_tx_control(il, agg->rate_n_flags, info);
+
+       return 0;
+}
+
+static inline bool
+il4965_is_tx_success(u32 status)
+{
+       status &= TX_STATUS_MSK;
+       return (status == TX_STATUS_SUCCESS || status == TX_STATUS_DIRECT_DONE);
+}
+
+static u8
+il4965_find_station(struct il_priv *il, const u8 *addr)
+{
+       int i;
+       int start = 0;
+       int ret = IL_INVALID_STATION;
+       unsigned long flags;
+
+       if (il->iw_mode == NL80211_IFTYPE_ADHOC)
+               start = IL_STA_ID;
+
+       if (is_broadcast_ether_addr(addr))
+               return il->hw_params.bcast_id;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       for (i = start; i < il->hw_params.max_stations; i++)
+               if (il->stations[i].used &&
+                   ether_addr_equal(il->stations[i].sta.sta.addr, addr)) {
+                       ret = i;
+                       goto out;
+               }
+
+       D_ASSOC("can not find STA %pM total %d\n", addr, il->num_stations);
+
+out:
+       /*
+        * It may be possible that more commands interacting with stations
+        * arrive before we completed processing the adding of
+        * station
+        */
+       if (ret != IL_INVALID_STATION &&
+           (!(il->stations[ret].used & IL_STA_UCODE_ACTIVE) ||
+            ((il->stations[ret].used & IL_STA_UCODE_ACTIVE) &&
+             (il->stations[ret].used & IL_STA_UCODE_INPROGRESS)))) {
+               IL_ERR("Requested station info for sta %d before ready.\n",
+                      ret);
+               ret = IL_INVALID_STATION;
+       }
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+       return ret;
+}
+
+static int
+il4965_get_ra_sta_id(struct il_priv *il, struct ieee80211_hdr *hdr)
+{
+       if (il->iw_mode == NL80211_IFTYPE_STATION)
+               return IL_AP_ID;
+       else {
+               u8 *da = ieee80211_get_DA(hdr);
+
+               return il4965_find_station(il, da);
+       }
+}
+
+static inline u32
+il4965_get_scd_ssn(struct il4965_tx_resp *tx_resp)
+{
+       return le32_to_cpup(&tx_resp->u.status +
+                           tx_resp->frame_count) & IEEE80211_MAX_SN;
+}
+
+static inline u32
+il4965_tx_status_to_mac80211(u32 status)
+{
+       status &= TX_STATUS_MSK;
+
+       switch (status) {
+       case TX_STATUS_SUCCESS:
+       case TX_STATUS_DIRECT_DONE:
+               return IEEE80211_TX_STAT_ACK;
+       case TX_STATUS_FAIL_DEST_PS:
+               return IEEE80211_TX_STAT_TX_FILTERED;
+       default:
+               return 0;
+       }
+}
+
+/**
+ * il4965_tx_status_reply_tx - Handle Tx response for frames in aggregation queue
+ */
+static int
+il4965_tx_status_reply_tx(struct il_priv *il, struct il_ht_agg *agg,
+                         struct il4965_tx_resp *tx_resp, int txq_id,
+                         u16 start_idx)
+{
+       u16 status;
+       struct agg_tx_status *frame_status = tx_resp->u.agg_status;
+       struct ieee80211_tx_info *info = NULL;
+       struct ieee80211_hdr *hdr = NULL;
+       u32 rate_n_flags = le32_to_cpu(tx_resp->rate_n_flags);
+       int i, sh, idx;
+       u16 seq;
+       if (agg->wait_for_ba)
+               D_TX_REPLY("got tx response w/o block-ack\n");
+
+       agg->frame_count = tx_resp->frame_count;
+       agg->start_idx = start_idx;
+       agg->rate_n_flags = rate_n_flags;
+       agg->bitmap = 0;
+
+       /* num frames attempted by Tx command */
+       if (agg->frame_count == 1) {
+               /* Only one frame was attempted; no block-ack will arrive */
+               status = le16_to_cpu(frame_status[0].status);
+               idx = start_idx;
+
+               D_TX_REPLY("FrameCnt = %d, StartIdx=%d idx=%d\n",
+                          agg->frame_count, agg->start_idx, idx);
+
+               info = IEEE80211_SKB_CB(il->txq[txq_id].skbs[idx]);
+               info->status.rates[0].count = tx_resp->failure_frame + 1;
+               info->flags &= ~IEEE80211_TX_CTL_AMPDU;
+               info->flags |= il4965_tx_status_to_mac80211(status);
+               il4965_hwrate_to_tx_control(il, rate_n_flags, info);
+
+               D_TX_REPLY("1 Frame 0x%x failure :%d\n", status & 0xff,
+                          tx_resp->failure_frame);
+               D_TX_REPLY("Rate Info rate_n_flags=%x\n", rate_n_flags);
+
+               agg->wait_for_ba = 0;
+       } else {
+               /* Two or more frames were attempted; expect block-ack */
+               u64 bitmap = 0;
+               int start = agg->start_idx;
+               struct sk_buff *skb;
+
+               /* Construct bit-map of pending frames within Tx win */
+               for (i = 0; i < agg->frame_count; i++) {
+                       u16 sc;
+                       status = le16_to_cpu(frame_status[i].status);
+                       seq = le16_to_cpu(frame_status[i].sequence);
+                       idx = SEQ_TO_IDX(seq);
+                       txq_id = SEQ_TO_QUEUE(seq);
+
+                       if (status &
+                           (AGG_TX_STATE_FEW_BYTES_MSK |
+                            AGG_TX_STATE_ABORT_MSK))
+                               continue;
+
+                       D_TX_REPLY("FrameCnt = %d, txq_id=%d idx=%d\n",
+                                  agg->frame_count, txq_id, idx);
+
+                       skb = il->txq[txq_id].skbs[idx];
+                       if (WARN_ON_ONCE(skb == NULL))
+                               return -1;
+                       hdr = (struct ieee80211_hdr *) skb->data;
+
+                       sc = le16_to_cpu(hdr->seq_ctrl);
+                       if (idx != (IEEE80211_SEQ_TO_SN(sc) & 0xff)) {
+                               IL_ERR("BUG_ON idx doesn't match seq control"
+                                      " idx=%d, seq_idx=%d, seq=%d\n", idx,
+                                      IEEE80211_SEQ_TO_SN(sc), hdr->seq_ctrl);
+                               return -1;
+                       }
+
+                       D_TX_REPLY("AGG Frame i=%d idx %d seq=%d\n", i, idx,
+                                  IEEE80211_SEQ_TO_SN(sc));
+
+                       sh = idx - start;
+                       if (sh > 64) {
+                               sh = (start - idx) + 0xff;
+                               bitmap = bitmap << sh;
+                               sh = 0;
+                               start = idx;
+                       } else if (sh < -64)
+                               sh = 0xff - (start - idx);
+                       else if (sh < 0) {
+                               sh = start - idx;
+                               start = idx;
+                               bitmap = bitmap << sh;
+                               sh = 0;
+                       }
+                       bitmap |= 1ULL << sh;
+                       D_TX_REPLY("start=%d bitmap=0x%llx\n", start,
+                                  (unsigned long long)bitmap);
+               }
+
+               agg->bitmap = bitmap;
+               agg->start_idx = start;
+               D_TX_REPLY("Frames %d start_idx=%d bitmap=0x%llx\n",
+                          agg->frame_count, agg->start_idx,
+                          (unsigned long long)agg->bitmap);
+
+               if (bitmap)
+                       agg->wait_for_ba = 1;
+       }
+       return 0;
+}
+
+/**
+ * il4965_hdl_tx - Handle standard (non-aggregation) Tx response
+ */
+static void
+il4965_hdl_tx(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       u16 sequence = le16_to_cpu(pkt->hdr.sequence);
+       int txq_id = SEQ_TO_QUEUE(sequence);
+       int idx = SEQ_TO_IDX(sequence);
+       struct il_tx_queue *txq = &il->txq[txq_id];
+       struct sk_buff *skb;
+       struct ieee80211_hdr *hdr;
+       struct ieee80211_tx_info *info;
+       struct il4965_tx_resp *tx_resp = (void *)&pkt->u.raw[0];
+       u32 status = le32_to_cpu(tx_resp->u.status);
+       int uninitialized_var(tid);
+       int sta_id;
+       int freed;
+       u8 *qc = NULL;
+       unsigned long flags;
+
+       if (idx >= txq->q.n_bd || il_queue_used(&txq->q, idx) == 0) {
+               IL_ERR("Read idx for DMA queue txq_id (%d) idx %d "
+                      "is out of range [0-%d] %d %d\n", txq_id, idx,
+                      txq->q.n_bd, txq->q.write_ptr, txq->q.read_ptr);
+               return;
+       }
+
+       txq->time_stamp = jiffies;
+
+       skb = txq->skbs[txq->q.read_ptr];
+       info = IEEE80211_SKB_CB(skb);
+       memset(&info->status, 0, sizeof(info->status));
+
+       hdr = (struct ieee80211_hdr *) skb->data;
+       if (ieee80211_is_data_qos(hdr->frame_control)) {
+               qc = ieee80211_get_qos_ctl(hdr);
+               tid = qc[0] & 0xf;
+       }
+
+       sta_id = il4965_get_ra_sta_id(il, hdr);
+       if (txq->sched_retry && unlikely(sta_id == IL_INVALID_STATION)) {
+               IL_ERR("Station not known\n");
+               return;
+       }
+
+       /*
+        * Firmware will not transmit frame on passive channel, if it not yet
+        * received some valid frame on that channel. When this error happen
+        * we have to wait until firmware will unblock itself i.e. when we
+        * note received beacon or other frame. We unblock queues in
+        * il4965_pass_packet_to_mac80211 or in il_mac_bss_info_changed.
+        */
+       if (unlikely((status & TX_STATUS_MSK) == TX_STATUS_FAIL_PASSIVE_NO_RX) &&
+           il->iw_mode == NL80211_IFTYPE_STATION) {
+               il_stop_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
+               D_INFO("Stopped queues - RX waiting on passive channel\n");
+       }
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       if (txq->sched_retry) {
+               const u32 scd_ssn = il4965_get_scd_ssn(tx_resp);
+               struct il_ht_agg *agg = NULL;
+               WARN_ON(!qc);
+
+               agg = &il->stations[sta_id].tid[tid].agg;
+
+               il4965_tx_status_reply_tx(il, agg, tx_resp, txq_id, idx);
+
+               /* check if BAR is needed */
+               if (tx_resp->frame_count == 1 &&
+                   !il4965_is_tx_success(status))
+                       info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
+
+               if (txq->q.read_ptr != (scd_ssn & 0xff)) {
+                       idx = il_queue_dec_wrap(scd_ssn & 0xff, txq->q.n_bd);
+                       D_TX_REPLY("Retry scheduler reclaim scd_ssn "
+                                  "%d idx %d\n", scd_ssn, idx);
+                       freed = il4965_tx_queue_reclaim(il, txq_id, idx);
+                       if (qc)
+                               il4965_free_tfds_in_queue(il, sta_id, tid,
+                                                         freed);
+
+                       if (il->mac80211_registered &&
+                           il_queue_space(&txq->q) > txq->q.low_mark &&
+                           agg->state != IL_EMPTYING_HW_QUEUE_DELBA)
+                               il_wake_queue(il, txq);
+               }
+       } else {
+               info->status.rates[0].count = tx_resp->failure_frame + 1;
+               info->flags |= il4965_tx_status_to_mac80211(status);
+               il4965_hwrate_to_tx_control(il,
+                                           le32_to_cpu(tx_resp->rate_n_flags),
+                                           info);
+
+               D_TX_REPLY("TXQ %d status %s (0x%08x) "
+                          "rate_n_flags 0x%x retries %d\n", txq_id,
+                          il4965_get_tx_fail_reason(status), status,
+                          le32_to_cpu(tx_resp->rate_n_flags),
+                          tx_resp->failure_frame);
+
+               freed = il4965_tx_queue_reclaim(il, txq_id, idx);
+               if (qc && likely(sta_id != IL_INVALID_STATION))
+                       il4965_free_tfds_in_queue(il, sta_id, tid, freed);
+               else if (sta_id == IL_INVALID_STATION)
+                       D_TX_REPLY("Station not known\n");
+
+               if (il->mac80211_registered &&
+                   il_queue_space(&txq->q) > txq->q.low_mark)
+                       il_wake_queue(il, txq);
+       }
+       if (qc && likely(sta_id != IL_INVALID_STATION))
+               il4965_txq_check_empty(il, sta_id, tid, txq_id);
+
+       il4965_check_abort_status(il, tx_resp->frame_count, status);
+
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+}
+
+/**
+ * translate ucode response to mac80211 tx status control values
+ */
+void
+il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
+                           struct ieee80211_tx_info *info)
+{
+       struct ieee80211_tx_rate *r = &info->status.rates[0];
+
+       info->status.antenna =
+           ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
+       if (rate_n_flags & RATE_MCS_HT_MSK)
+               r->flags |= IEEE80211_TX_RC_MCS;
+       if (rate_n_flags & RATE_MCS_GF_MSK)
+               r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
+       if (rate_n_flags & RATE_MCS_HT40_MSK)
+               r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
+       if (rate_n_flags & RATE_MCS_DUP_MSK)
+               r->flags |= IEEE80211_TX_RC_DUP_DATA;
+       if (rate_n_flags & RATE_MCS_SGI_MSK)
+               r->flags |= IEEE80211_TX_RC_SHORT_GI;
+       r->idx = il4965_hwrate_to_mac80211_idx(rate_n_flags, info->band);
+}
+
+/**
+ * il4965_hdl_compressed_ba - Handler for N_COMPRESSED_BA
+ *
+ * Handles block-acknowledge notification from device, which reports success
+ * of frames sent via aggregation.
+ */
+static void
+il4965_hdl_compressed_ba(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_compressed_ba_resp *ba_resp = &pkt->u.compressed_ba;
+       struct il_tx_queue *txq = NULL;
+       struct il_ht_agg *agg;
+       int idx;
+       int sta_id;
+       int tid;
+       unsigned long flags;
+
+       /* "flow" corresponds to Tx queue */
+       u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);
+
+       /* "ssn" is start of block-ack Tx win, corresponds to idx
+        * (in Tx queue's circular buffer) of first TFD/frame in win */
+       u16 ba_resp_scd_ssn = le16_to_cpu(ba_resp->scd_ssn);
+
+       if (scd_flow >= il->hw_params.max_txq_num) {
+               IL_ERR("BUG_ON scd_flow is bigger than number of queues\n");
+               return;
+       }
+
+       txq = &il->txq[scd_flow];
+       sta_id = ba_resp->sta_id;
+       tid = ba_resp->tid;
+       agg = &il->stations[sta_id].tid[tid].agg;
+       if (unlikely(agg->txq_id != scd_flow)) {
+               /*
+                * FIXME: this is a uCode bug which need to be addressed,
+                * log the information and return for now!
+                * since it is possible happen very often and in order
+                * not to fill the syslog, don't enable the logging by default
+                */
+               D_TX_REPLY("BA scd_flow %d does not match txq_id %d\n",
+                          scd_flow, agg->txq_id);
+               return;
+       }
+
+       /* Find idx just before block-ack win */
+       idx = il_queue_dec_wrap(ba_resp_scd_ssn & 0xff, txq->q.n_bd);
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+
+       D_TX_REPLY("N_COMPRESSED_BA [%d] Received from %pM, " "sta_id = %d\n",
+                  agg->wait_for_ba, (u8 *) &ba_resp->sta_addr_lo32,
+                  ba_resp->sta_id);
+       D_TX_REPLY("TID = %d, SeqCtl = %d, bitmap = 0x%llx," "scd_flow = "
+                  "%d, scd_ssn = %d\n", ba_resp->tid, ba_resp->seq_ctl,
+                  (unsigned long long)le64_to_cpu(ba_resp->bitmap),
+                  ba_resp->scd_flow, ba_resp->scd_ssn);
+       D_TX_REPLY("DAT start_idx = %d, bitmap = 0x%llx\n", agg->start_idx,
+                  (unsigned long long)agg->bitmap);
+
+       /* Update driver's record of ACK vs. not for each frame in win */
+       il4965_tx_status_reply_compressed_ba(il, agg, ba_resp);
+
+       /* Release all TFDs before the SSN, i.e. all TFDs in front of
+        * block-ack win (we assume that they've been successfully
+        * transmitted ... if not, it's too late anyway). */
+       if (txq->q.read_ptr != (ba_resp_scd_ssn & 0xff)) {
+               /* calculate mac80211 ampdu sw queue to wake */
+               int freed = il4965_tx_queue_reclaim(il, scd_flow, idx);
+               il4965_free_tfds_in_queue(il, sta_id, tid, freed);
+
+               if (il_queue_space(&txq->q) > txq->q.low_mark &&
+                   il->mac80211_registered &&
+                   agg->state != IL_EMPTYING_HW_QUEUE_DELBA)
+                       il_wake_queue(il, txq);
+
+               il4965_txq_check_empty(il, sta_id, tid, scd_flow);
+       }
+
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+}
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+const char *
+il4965_get_tx_fail_reason(u32 status)
+{
+#define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
+#define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
+
+       switch (status & TX_STATUS_MSK) {
+       case TX_STATUS_SUCCESS:
+               return "SUCCESS";
+               TX_STATUS_POSTPONE(DELAY);
+               TX_STATUS_POSTPONE(FEW_BYTES);
+               TX_STATUS_POSTPONE(QUIET_PERIOD);
+               TX_STATUS_POSTPONE(CALC_TTAK);
+               TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
+               TX_STATUS_FAIL(SHORT_LIMIT);
+               TX_STATUS_FAIL(LONG_LIMIT);
+               TX_STATUS_FAIL(FIFO_UNDERRUN);
+               TX_STATUS_FAIL(DRAIN_FLOW);
+               TX_STATUS_FAIL(RFKILL_FLUSH);
+               TX_STATUS_FAIL(LIFE_EXPIRE);
+               TX_STATUS_FAIL(DEST_PS);
+               TX_STATUS_FAIL(HOST_ABORTED);
+               TX_STATUS_FAIL(BT_RETRY);
+               TX_STATUS_FAIL(STA_INVALID);
+               TX_STATUS_FAIL(FRAG_DROPPED);
+               TX_STATUS_FAIL(TID_DISABLE);
+               TX_STATUS_FAIL(FIFO_FLUSHED);
+               TX_STATUS_FAIL(INSUFFICIENT_CF_POLL);
+               TX_STATUS_FAIL(PASSIVE_NO_RX);
+               TX_STATUS_FAIL(NO_BEACON_ON_RADAR);
+       }
+
+       return "UNKNOWN";
+
+#undef TX_STATUS_FAIL
+#undef TX_STATUS_POSTPONE
+}
+#endif /* CONFIG_IWLEGACY_DEBUG */
+
+static struct il_link_quality_cmd *
+il4965_sta_alloc_lq(struct il_priv *il, u8 sta_id)
+{
+       int i, r;
+       struct il_link_quality_cmd *link_cmd;
+       u32 rate_flags = 0;
+       __le32 rate_n_flags;
+
+       link_cmd = kzalloc(sizeof(struct il_link_quality_cmd), GFP_KERNEL);
+       if (!link_cmd) {
+               IL_ERR("Unable to allocate memory for LQ cmd.\n");
+               return NULL;
+       }
+       /* Set up the rate scaling to start at selected rate, fall back
+        * all the way down to 1M in IEEE order, and then spin on 1M */
+       if (il->band == IEEE80211_BAND_5GHZ)
+               r = RATE_6M_IDX;
+       else
+               r = RATE_1M_IDX;
+
+       if (r >= IL_FIRST_CCK_RATE && r <= IL_LAST_CCK_RATE)
+               rate_flags |= RATE_MCS_CCK_MSK;
+
+       rate_flags |=
+           il4965_first_antenna(il->hw_params.
+                                valid_tx_ant) << RATE_MCS_ANT_POS;
+       rate_n_flags = cpu_to_le32(il_rates[r].plcp | rate_flags);
+       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
+               link_cmd->rs_table[i].rate_n_flags = rate_n_flags;
+
+       link_cmd->general_params.single_stream_ant_msk =
+           il4965_first_antenna(il->hw_params.valid_tx_ant);
+
+       link_cmd->general_params.dual_stream_ant_msk =
+           il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
+                                                              valid_tx_ant);
+       if (!link_cmd->general_params.dual_stream_ant_msk) {
+               link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
+       } else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
+               link_cmd->general_params.dual_stream_ant_msk =
+                   il->hw_params.valid_tx_ant;
+       }
+
+       link_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
+       link_cmd->agg_params.agg_time_limit =
+           cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
+
+       link_cmd->sta_id = sta_id;
+
+       return link_cmd;
+}
+
+/*
+ * il4965_add_bssid_station - Add the special IBSS BSSID station
+ *
+ * Function sleeps.
+ */
+int
+il4965_add_bssid_station(struct il_priv *il, const u8 *addr, u8 *sta_id_r)
+{
+       int ret;
+       u8 sta_id;
+       struct il_link_quality_cmd *link_cmd;
+       unsigned long flags;
+
+       if (sta_id_r)
+               *sta_id_r = IL_INVALID_STATION;
+
+       ret = il_add_station_common(il, addr, 0, NULL, &sta_id);
+       if (ret) {
+               IL_ERR("Unable to add station %pM\n", addr);
+               return ret;
+       }
+
+       if (sta_id_r)
+               *sta_id_r = sta_id;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].used |= IL_STA_LOCAL;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       /* Set up default rate scaling table in device's station table */
+       link_cmd = il4965_sta_alloc_lq(il, sta_id);
+       if (!link_cmd) {
+               IL_ERR("Unable to initialize rate scaling for station %pM.\n",
+                      addr);
+               return -ENOMEM;
+       }
+
+       ret = il_send_lq_cmd(il, link_cmd, CMD_SYNC, true);
+       if (ret)
+               IL_ERR("Link quality command failed (%d)\n", ret);
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].lq = link_cmd;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return 0;
+}
+
+static int
+il4965_static_wepkey_cmd(struct il_priv *il, bool send_if_empty)
+{
+       int i;
+       u8 buff[sizeof(struct il_wep_cmd) +
+               sizeof(struct il_wep_key) * WEP_KEYS_MAX];
+       struct il_wep_cmd *wep_cmd = (struct il_wep_cmd *)buff;
+       size_t cmd_size = sizeof(struct il_wep_cmd);
+       struct il_host_cmd cmd = {
+               .id = C_WEPKEY,
+               .data = wep_cmd,
+               .flags = CMD_SYNC,
+       };
+       bool not_empty = false;
+
+       might_sleep();
+
+       memset(wep_cmd, 0,
+              cmd_size + (sizeof(struct il_wep_key) * WEP_KEYS_MAX));
+
+       for (i = 0; i < WEP_KEYS_MAX; i++) {
+               u8 key_size = il->_4965.wep_keys[i].key_size;
+
+               wep_cmd->key[i].key_idx = i;
+               if (key_size) {
+                       wep_cmd->key[i].key_offset = i;
+                       not_empty = true;
+               } else
+                       wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
+
+               wep_cmd->key[i].key_size = key_size;
+               memcpy(&wep_cmd->key[i].key[3], il->_4965.wep_keys[i].key, key_size);
+       }
+
+       wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
+       wep_cmd->num_keys = WEP_KEYS_MAX;
+
+       cmd_size += sizeof(struct il_wep_key) * WEP_KEYS_MAX;
+       cmd.len = cmd_size;
+
+       if (not_empty || send_if_empty)
+               return il_send_cmd(il, &cmd);
+       else
+               return 0;
+}
+
+int
+il4965_restore_default_wep_keys(struct il_priv *il)
+{
+       lockdep_assert_held(&il->mutex);
+
+       return il4965_static_wepkey_cmd(il, false);
+}
+
+int
+il4965_remove_default_wep_key(struct il_priv *il,
+                             struct ieee80211_key_conf *keyconf)
+{
+       int ret;
+       int idx = keyconf->keyidx;
+
+       lockdep_assert_held(&il->mutex);
+
+       D_WEP("Removing default WEP key: idx=%d\n", idx);
+
+       memset(&il->_4965.wep_keys[idx], 0, sizeof(struct il_wep_key));
+       if (il_is_rfkill(il)) {
+               D_WEP("Not sending C_WEPKEY command due to RFKILL.\n");
+               /* but keys in device are clear anyway so return success */
+               return 0;
+       }
+       ret = il4965_static_wepkey_cmd(il, 1);
+       D_WEP("Remove default WEP key: idx=%d ret=%d\n", idx, ret);
+
+       return ret;
+}
+
+int
+il4965_set_default_wep_key(struct il_priv *il,
+                          struct ieee80211_key_conf *keyconf)
+{
+       int ret;
+       int len = keyconf->keylen;
+       int idx = keyconf->keyidx;
+
+       lockdep_assert_held(&il->mutex);
+
+       if (len != WEP_KEY_LEN_128 && len != WEP_KEY_LEN_64) {
+               D_WEP("Bad WEP key length %d\n", keyconf->keylen);
+               return -EINVAL;
+       }
+
+       keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
+       keyconf->hw_key_idx = HW_KEY_DEFAULT;
+       il->stations[IL_AP_ID].keyinfo.cipher = keyconf->cipher;
+
+       il->_4965.wep_keys[idx].key_size = len;
+       memcpy(&il->_4965.wep_keys[idx].key, &keyconf->key, len);
+
+       ret = il4965_static_wepkey_cmd(il, false);
+
+       D_WEP("Set default WEP key: len=%d idx=%d ret=%d\n", len, idx, ret);
+       return ret;
+}
+
+static int
+il4965_set_wep_dynamic_key_info(struct il_priv *il,
+                               struct ieee80211_key_conf *keyconf, u8 sta_id)
+{
+       unsigned long flags;
+       __le16 key_flags = 0;
+       struct il_addsta_cmd sta_cmd;
+
+       lockdep_assert_held(&il->mutex);
+
+       keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
+
+       key_flags |= (STA_KEY_FLG_WEP | STA_KEY_FLG_MAP_KEY_MSK);
+       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
+       key_flags &= ~STA_KEY_FLG_INVALID;
+
+       if (keyconf->keylen == WEP_KEY_LEN_128)
+               key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;
+
+       if (sta_id == il->hw_params.bcast_id)
+               key_flags |= STA_KEY_MULTICAST_MSK;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+
+       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
+       il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
+       il->stations[sta_id].keyinfo.keyidx = keyconf->keyidx;
+
+       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
+
+       memcpy(&il->stations[sta_id].sta.key.key[3], keyconf->key,
+              keyconf->keylen);
+
+       if ((il->stations[sta_id].sta.key.
+            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
+               il->stations[sta_id].sta.key.key_offset =
+                   il_get_free_ucode_key_idx(il);
+       /* else, we are overriding an existing key => no need to allocated room
+        * in uCode. */
+
+       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
+            "no space for a new key");
+
+       il->stations[sta_id].sta.key.key_flags = key_flags;
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+}
+
+static int
+il4965_set_ccmp_dynamic_key_info(struct il_priv *il,
+                                struct ieee80211_key_conf *keyconf, u8 sta_id)
+{
+       unsigned long flags;
+       __le16 key_flags = 0;
+       struct il_addsta_cmd sta_cmd;
+
+       lockdep_assert_held(&il->mutex);
+
+       key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
+       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
+       key_flags &= ~STA_KEY_FLG_INVALID;
+
+       if (sta_id == il->hw_params.bcast_id)
+               key_flags |= STA_KEY_MULTICAST_MSK;
+
+       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
+       il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
+
+       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
+
+       memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
+
+       if ((il->stations[sta_id].sta.key.
+            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
+               il->stations[sta_id].sta.key.key_offset =
+                   il_get_free_ucode_key_idx(il);
+       /* else, we are overriding an existing key => no need to allocated room
+        * in uCode. */
+
+       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
+            "no space for a new key");
+
+       il->stations[sta_id].sta.key.key_flags = key_flags;
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+}
+
+static int
+il4965_set_tkip_dynamic_key_info(struct il_priv *il,
+                                struct ieee80211_key_conf *keyconf, u8 sta_id)
+{
+       unsigned long flags;
+       int ret = 0;
+       __le16 key_flags = 0;
+
+       key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
+       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
+       key_flags &= ~STA_KEY_FLG_INVALID;
+
+       if (sta_id == il->hw_params.bcast_id)
+               key_flags |= STA_KEY_MULTICAST_MSK;
+
+       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
+       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+
+       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
+       il->stations[sta_id].keyinfo.keylen = 16;
+
+       if ((il->stations[sta_id].sta.key.
+            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
+               il->stations[sta_id].sta.key.key_offset =
+                   il_get_free_ucode_key_idx(il);
+       /* else, we are overriding an existing key => no need to allocated room
+        * in uCode. */
+
+       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
+            "no space for a new key");
+
+       il->stations[sta_id].sta.key.key_flags = key_flags;
+
+       /* This copy is acutally not needed: we get the key with each TX */
+       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, 16);
+
+       memcpy(il->stations[sta_id].sta.key.key, keyconf->key, 16);
+
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return ret;
+}
+
+void
+il4965_update_tkip_key(struct il_priv *il, struct ieee80211_key_conf *keyconf,
+                      struct ieee80211_sta *sta, u32 iv32, u16 *phase1key)
+{
+       u8 sta_id;
+       unsigned long flags;
+       int i;
+
+       if (il_scan_cancel(il)) {
+               /* cancel scan failed, just live w/ bad key and rely
+                  briefly on SW decryption */
+               return;
+       }
+
+       sta_id = il_sta_id_or_broadcast(il, sta);
+       if (sta_id == IL_INVALID_STATION)
+               return;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+
+       il->stations[sta_id].sta.key.tkip_rx_tsc_byte2 = (u8) iv32;
+
+       for (i = 0; i < 5; i++)
+               il->stations[sta_id].sta.key.tkip_rx_ttak[i] =
+                   cpu_to_le16(phase1key[i]);
+
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+
+       il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
+
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+}
+
+int
+il4965_remove_dynamic_key(struct il_priv *il,
+                         struct ieee80211_key_conf *keyconf, u8 sta_id)
+{
+       unsigned long flags;
+       u16 key_flags;
+       u8 keyidx;
+       struct il_addsta_cmd sta_cmd;
+
+       lockdep_assert_held(&il->mutex);
+
+       il->_4965.key_mapping_keys--;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       key_flags = le16_to_cpu(il->stations[sta_id].sta.key.key_flags);
+       keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;
+
+       D_WEP("Remove dynamic key: idx=%d sta=%d\n", keyconf->keyidx, sta_id);
+
+       if (keyconf->keyidx != keyidx) {
+               /* We need to remove a key with idx different that the one
+                * in the uCode. This means that the key we need to remove has
+                * been replaced by another one with different idx.
+                * Don't do anything and return ok
+                */
+               spin_unlock_irqrestore(&il->sta_lock, flags);
+               return 0;
+       }
+
+       if (il->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_INVALID) {
+               IL_WARN("Removing wrong key %d 0x%x\n", keyconf->keyidx,
+                       key_flags);
+               spin_unlock_irqrestore(&il->sta_lock, flags);
+               return 0;
+       }
+
+       if (!test_and_clear_bit
+           (il->stations[sta_id].sta.key.key_offset, &il->ucode_key_table))
+               IL_ERR("idx %d not used in uCode key table.\n",
+                      il->stations[sta_id].sta.key.key_offset);
+       memset(&il->stations[sta_id].keyinfo, 0, sizeof(struct il_hw_key));
+       memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
+       il->stations[sta_id].sta.key.key_flags =
+           STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
+       il->stations[sta_id].sta.key.key_offset = keyconf->hw_key_idx;
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+
+       if (il_is_rfkill(il)) {
+               D_WEP
+                   ("Not sending C_ADD_STA command because RFKILL enabled.\n");
+               spin_unlock_irqrestore(&il->sta_lock, flags);
+               return 0;
+       }
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+}
+
+int
+il4965_set_dynamic_key(struct il_priv *il, struct ieee80211_key_conf *keyconf,
+                      u8 sta_id)
+{
+       int ret;
+
+       lockdep_assert_held(&il->mutex);
+
+       il->_4965.key_mapping_keys++;
+       keyconf->hw_key_idx = HW_KEY_DYNAMIC;
+
+       switch (keyconf->cipher) {
+       case WLAN_CIPHER_SUITE_CCMP:
+               ret =
+                   il4965_set_ccmp_dynamic_key_info(il, keyconf, sta_id);
+               break;
+       case WLAN_CIPHER_SUITE_TKIP:
+               ret =
+                   il4965_set_tkip_dynamic_key_info(il, keyconf, sta_id);
+               break;
+       case WLAN_CIPHER_SUITE_WEP40:
+       case WLAN_CIPHER_SUITE_WEP104:
+               ret = il4965_set_wep_dynamic_key_info(il, keyconf, sta_id);
+               break;
+       default:
+               IL_ERR("Unknown alg: %s cipher = %x\n", __func__,
+                      keyconf->cipher);
+               ret = -EINVAL;
+       }
+
+       D_WEP("Set dynamic key: cipher=%x len=%d idx=%d sta=%d ret=%d\n",
+             keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
+
+       return ret;
+}
+
+/**
+ * il4965_alloc_bcast_station - add broadcast station into driver's station table.
+ *
+ * This adds the broadcast station into the driver's station table
+ * and marks it driver active, so that it will be restored to the
+ * device at the next best time.
+ */
+int
+il4965_alloc_bcast_station(struct il_priv *il)
+{
+       struct il_link_quality_cmd *link_cmd;
+       unsigned long flags;
+       u8 sta_id;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       sta_id = il_prep_station(il, il_bcast_addr, false, NULL);
+       if (sta_id == IL_INVALID_STATION) {
+               IL_ERR("Unable to prepare broadcast station\n");
+               spin_unlock_irqrestore(&il->sta_lock, flags);
+
+               return -EINVAL;
+       }
+
+       il->stations[sta_id].used |= IL_STA_DRIVER_ACTIVE;
+       il->stations[sta_id].used |= IL_STA_BCAST;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       link_cmd = il4965_sta_alloc_lq(il, sta_id);
+       if (!link_cmd) {
+               IL_ERR
+                   ("Unable to initialize rate scaling for bcast station.\n");
+               return -ENOMEM;
+       }
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].lq = link_cmd;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return 0;
+}
+
+/**
+ * il4965_update_bcast_station - update broadcast station's LQ command
+ *
+ * Only used by iwl4965. Placed here to have all bcast station management
+ * code together.
+ */
+static int
+il4965_update_bcast_station(struct il_priv *il)
+{
+       unsigned long flags;
+       struct il_link_quality_cmd *link_cmd;
+       u8 sta_id = il->hw_params.bcast_id;
+
+       link_cmd = il4965_sta_alloc_lq(il, sta_id);
+       if (!link_cmd) {
+               IL_ERR("Unable to initialize rate scaling for bcast sta.\n");
+               return -ENOMEM;
+       }
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       if (il->stations[sta_id].lq)
+               kfree(il->stations[sta_id].lq);
+       else
+               D_INFO("Bcast sta rate scaling has not been initialized.\n");
+       il->stations[sta_id].lq = link_cmd;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return 0;
+}
+
+int
+il4965_update_bcast_stations(struct il_priv *il)
+{
+       return il4965_update_bcast_station(il);
+}
+
+/**
+ * il4965_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
+ */
+int
+il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid)
+{
+       unsigned long flags;
+       struct il_addsta_cmd sta_cmd;
+
+       lockdep_assert_held(&il->mutex);
+
+       /* Remove "disable" flag, to enable Tx for this TID */
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
+       il->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+}
+
+int
+il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta, int tid,
+                       u16 ssn)
+{
+       unsigned long flags;
+       int sta_id;
+       struct il_addsta_cmd sta_cmd;
+
+       lockdep_assert_held(&il->mutex);
+
+       sta_id = il_sta_id(sta);
+       if (sta_id == IL_INVALID_STATION)
+               return -ENXIO;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].sta.station_flags_msk = 0;
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
+       il->stations[sta_id].sta.add_immediate_ba_tid = (u8) tid;
+       il->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+}
+
+int
+il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta, int tid)
+{
+       unsigned long flags;
+       int sta_id;
+       struct il_addsta_cmd sta_cmd;
+
+       lockdep_assert_held(&il->mutex);
+
+       sta_id = il_sta_id(sta);
+       if (sta_id == IL_INVALID_STATION) {
+               IL_ERR("Invalid station for AGG tid %d\n", tid);
+               return -ENXIO;
+       }
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].sta.station_flags_msk = 0;
+       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
+       il->stations[sta_id].sta.remove_immediate_ba_tid = (u8) tid;
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+}
+
+void
+il4965_sta_modify_sleep_tx_count(struct il_priv *il, int sta_id, int cnt)
+{
+       unsigned long flags;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       il->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
+       il->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
+       il->stations[sta_id].sta.sta.modify_mask =
+           STA_MODIFY_SLEEP_TX_COUNT_MSK;
+       il->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
+       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
+       il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+}
+
+void
+il4965_update_chain_flags(struct il_priv *il)
+{
+       if (il->ops->set_rxon_chain) {
+               il->ops->set_rxon_chain(il);
+               if (il->active.rx_chain != il->staging.rx_chain)
+                       il_commit_rxon(il);
+       }
+}
+
+static void
+il4965_clear_free_frames(struct il_priv *il)
+{
+       struct list_head *element;
+
+       D_INFO("%d frames on pre-allocated heap on clear.\n", il->frames_count);
+
+       while (!list_empty(&il->free_frames)) {
+               element = il->free_frames.next;
+               list_del(element);
+               kfree(list_entry(element, struct il_frame, list));
+               il->frames_count--;
+       }
+
+       if (il->frames_count) {
+               IL_WARN("%d frames still in use.  Did we lose one?\n",
+                       il->frames_count);
+               il->frames_count = 0;
+       }
+}
+
+static struct il_frame *
+il4965_get_free_frame(struct il_priv *il)
+{
+       struct il_frame *frame;
+       struct list_head *element;
+       if (list_empty(&il->free_frames)) {
+               frame = kzalloc(sizeof(*frame), GFP_KERNEL);
+               if (!frame) {
+                       IL_ERR("Could not allocate frame!\n");
+                       return NULL;
+               }
+
+               il->frames_count++;
+               return frame;
+       }
+
+       element = il->free_frames.next;
+       list_del(element);
+       return list_entry(element, struct il_frame, list);
+}
+
+static void
+il4965_free_frame(struct il_priv *il, struct il_frame *frame)
+{
+       memset(frame, 0, sizeof(*frame));
+       list_add(&frame->list, &il->free_frames);
+}
+
+static u32
+il4965_fill_beacon_frame(struct il_priv *il, struct ieee80211_hdr *hdr,
+                        int left)
+{
+       lockdep_assert_held(&il->mutex);
+
+       if (!il->beacon_skb)
+               return 0;
+
+       if (il->beacon_skb->len > left)
+               return 0;
+
+       memcpy(hdr, il->beacon_skb->data, il->beacon_skb->len);
+
+       return il->beacon_skb->len;
+}
+
+/* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
+static void
+il4965_set_beacon_tim(struct il_priv *il,
+                     struct il_tx_beacon_cmd *tx_beacon_cmd, u8 * beacon,
+                     u32 frame_size)
+{
+       u16 tim_idx;
+       struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
+
+       /*
+        * The idx is relative to frame start but we start looking at the
+        * variable-length part of the beacon.
+        */
+       tim_idx = mgmt->u.beacon.variable - beacon;
+
+       /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
+       while ((tim_idx < (frame_size - 2)) &&
+              (beacon[tim_idx] != WLAN_EID_TIM))
+               tim_idx += beacon[tim_idx + 1] + 2;
+
+       /* If TIM field was found, set variables */
+       if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
+               tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
+               tx_beacon_cmd->tim_size = beacon[tim_idx + 1];
+       } else
+               IL_WARN("Unable to find TIM Element in beacon\n");
+}
+
+static unsigned int
+il4965_hw_get_beacon_cmd(struct il_priv *il, struct il_frame *frame)
+{
+       struct il_tx_beacon_cmd *tx_beacon_cmd;
+       u32 frame_size;
+       u32 rate_flags;
+       u32 rate;
+       /*
+        * We have to set up the TX command, the TX Beacon command, and the
+        * beacon contents.
+        */
+
+       lockdep_assert_held(&il->mutex);
+
+       if (!il->beacon_enabled) {
+               IL_ERR("Trying to build beacon without beaconing enabled\n");
+               return 0;
+       }
+
+       /* Initialize memory */
+       tx_beacon_cmd = &frame->u.beacon;
+       memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
+
+       /* Set up TX beacon contents */
+       frame_size =
+           il4965_fill_beacon_frame(il, tx_beacon_cmd->frame,
+                                    sizeof(frame->u) - sizeof(*tx_beacon_cmd));
+       if (WARN_ON_ONCE(frame_size > MAX_MPDU_SIZE))
+               return 0;
+       if (!frame_size)
+               return 0;
+
+       /* Set up TX command fields */
+       tx_beacon_cmd->tx.len = cpu_to_le16((u16) frame_size);
+       tx_beacon_cmd->tx.sta_id = il->hw_params.bcast_id;
+       tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
+       tx_beacon_cmd->tx.tx_flags =
+           TX_CMD_FLG_SEQ_CTL_MSK | TX_CMD_FLG_TSF_MSK |
+           TX_CMD_FLG_STA_RATE_MSK;
+
+       /* Set up TX beacon command fields */
+       il4965_set_beacon_tim(il, tx_beacon_cmd, (u8 *) tx_beacon_cmd->frame,
+                             frame_size);
+
+       /* Set up packet rate and flags */
+       rate = il_get_lowest_plcp(il);
+       il4965_toggle_tx_ant(il, &il->mgmt_tx_ant, il->hw_params.valid_tx_ant);
+       rate_flags = BIT(il->mgmt_tx_ant) << RATE_MCS_ANT_POS;
+       if ((rate >= IL_FIRST_CCK_RATE) && (rate <= IL_LAST_CCK_RATE))
+               rate_flags |= RATE_MCS_CCK_MSK;
+       tx_beacon_cmd->tx.rate_n_flags = cpu_to_le32(rate | rate_flags);
+
+       return sizeof(*tx_beacon_cmd) + frame_size;
+}
+
+int
+il4965_send_beacon_cmd(struct il_priv *il)
+{
+       struct il_frame *frame;
+       unsigned int frame_size;
+       int rc;
+
+       frame = il4965_get_free_frame(il);
+       if (!frame) {
+               IL_ERR("Could not obtain free frame buffer for beacon "
+                      "command.\n");
+               return -ENOMEM;
+       }
+
+       frame_size = il4965_hw_get_beacon_cmd(il, frame);
+       if (!frame_size) {
+               IL_ERR("Error configuring the beacon command\n");
+               il4965_free_frame(il, frame);
+               return -EINVAL;
+       }
+
+       rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size, &frame->u.cmd[0]);
+
+       il4965_free_frame(il, frame);
+
+       return rc;
+}
+
+static inline dma_addr_t
+il4965_tfd_tb_get_addr(struct il_tfd *tfd, u8 idx)
+{
+       struct il_tfd_tb *tb = &tfd->tbs[idx];
+
+       dma_addr_t addr = get_unaligned_le32(&tb->lo);
+       if (sizeof(dma_addr_t) > sizeof(u32))
+               addr |=
+                   ((dma_addr_t) (le16_to_cpu(tb->hi_n_len) & 0xF) << 16) <<
+                   16;
+
+       return addr;
+}
+
+static inline u16
+il4965_tfd_tb_get_len(struct il_tfd *tfd, u8 idx)
+{
+       struct il_tfd_tb *tb = &tfd->tbs[idx];
+
+       return le16_to_cpu(tb->hi_n_len) >> 4;
+}
+
+static inline void
+il4965_tfd_set_tb(struct il_tfd *tfd, u8 idx, dma_addr_t addr, u16 len)
+{
+       struct il_tfd_tb *tb = &tfd->tbs[idx];
+       u16 hi_n_len = len << 4;
+
+       put_unaligned_le32(addr, &tb->lo);
+       if (sizeof(dma_addr_t) > sizeof(u32))
+               hi_n_len |= ((addr >> 16) >> 16) & 0xF;
+
+       tb->hi_n_len = cpu_to_le16(hi_n_len);
+
+       tfd->num_tbs = idx + 1;
+}
+
+static inline u8
+il4965_tfd_get_num_tbs(struct il_tfd *tfd)
+{
+       return tfd->num_tbs & 0x1f;
+}
+
+/**
+ * il4965_hw_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
+ * @il - driver ilate data
+ * @txq - tx queue
+ *
+ * Does NOT advance any TFD circular buffer read/write idxes
+ * Does NOT free the TFD itself (which is within circular buffer)
+ */
+void
+il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
+{
+       struct il_tfd *tfd_tmp = (struct il_tfd *)txq->tfds;
+       struct il_tfd *tfd;
+       struct pci_dev *dev = il->pci_dev;
+       int idx = txq->q.read_ptr;
+       int i;
+       int num_tbs;
+
+       tfd = &tfd_tmp[idx];
+
+       /* Sanity check on number of chunks */
+       num_tbs = il4965_tfd_get_num_tbs(tfd);
+
+       if (num_tbs >= IL_NUM_OF_TBS) {
+               IL_ERR("Too many chunks: %i\n", num_tbs);
+               /* @todo issue fatal error, it is quite serious situation */
+               return;
+       }
+
+       /* Unmap tx_cmd */
+       if (num_tbs)
+               pci_unmap_single(dev, dma_unmap_addr(&txq->meta[idx], mapping),
+                                dma_unmap_len(&txq->meta[idx], len),
+                                PCI_DMA_BIDIRECTIONAL);
+
+       /* Unmap chunks, if any. */
+       for (i = 1; i < num_tbs; i++)
+               pci_unmap_single(dev, il4965_tfd_tb_get_addr(tfd, i),
+                                il4965_tfd_tb_get_len(tfd, i),
+                                PCI_DMA_TODEVICE);
+
+       /* free SKB */
+       if (txq->skbs) {
+               struct sk_buff *skb = txq->skbs[txq->q.read_ptr];
+
+               /* can be called from irqs-disabled context */
+               if (skb) {
+                       dev_kfree_skb_any(skb);
+                       txq->skbs[txq->q.read_ptr] = NULL;
+               }
+       }
+}
+
+int
+il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
+                               dma_addr_t addr, u16 len, u8 reset, u8 pad)
+{
+       struct il_queue *q;
+       struct il_tfd *tfd, *tfd_tmp;
+       u32 num_tbs;
+
+       q = &txq->q;
+       tfd_tmp = (struct il_tfd *)txq->tfds;
+       tfd = &tfd_tmp[q->write_ptr];
+
+       if (reset)
+               memset(tfd, 0, sizeof(*tfd));
+
+       num_tbs = il4965_tfd_get_num_tbs(tfd);
+
+       /* Each TFD can point to a maximum 20 Tx buffers */
+       if (num_tbs >= IL_NUM_OF_TBS) {
+               IL_ERR("Error can not send more than %d chunks\n",
+                      IL_NUM_OF_TBS);
+               return -EINVAL;
+       }
+
+       BUG_ON(addr & ~DMA_BIT_MASK(36));
+       if (unlikely(addr & ~IL_TX_DMA_MASK))
+               IL_ERR("Unaligned address = %llx\n", (unsigned long long)addr);
+
+       il4965_tfd_set_tb(tfd, num_tbs, addr, len);
+
+       return 0;
+}
+
+/*
+ * Tell nic where to find circular buffer of Tx Frame Descriptors for
+ * given Tx queue, and enable the DMA channel used for that queue.
+ *
+ * 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
+ * channels supported in hardware.
+ */
+int
+il4965_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq)
+{
+       int txq_id = txq->q.id;
+
+       /* Circular buffer (TFD queue in DRAM) physical base address */
+       il_wr(il, FH49_MEM_CBBC_QUEUE(txq_id), txq->q.dma_addr >> 8);
+
+       return 0;
+}
+
+/******************************************************************************
+ *
+ * Generic RX handler implementations
+ *
+ ******************************************************************************/
+static void
+il4965_hdl_alive(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_alive_resp *palive;
+       struct delayed_work *pwork;
+
+       palive = &pkt->u.alive_frame;
+
+       D_INFO("Alive ucode status 0x%08X revision " "0x%01X 0x%01X\n",
+              palive->is_valid, palive->ver_type, palive->ver_subtype);
+
+       if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
+               D_INFO("Initialization Alive received.\n");
+               memcpy(&il->card_alive_init, &pkt->u.alive_frame,
+                      sizeof(struct il_init_alive_resp));
+               pwork = &il->init_alive_start;
+       } else {
+               D_INFO("Runtime Alive received.\n");
+               memcpy(&il->card_alive, &pkt->u.alive_frame,
+                      sizeof(struct il_alive_resp));
+               pwork = &il->alive_start;
+       }
+
+       /* We delay the ALIVE response by 5ms to
+        * give the HW RF Kill time to activate... */
+       if (palive->is_valid == UCODE_VALID_OK)
+               queue_delayed_work(il->workqueue, pwork, msecs_to_jiffies(5));
+       else
+               IL_WARN("uCode did not respond OK.\n");
+}
+
+/**
+ * il4965_bg_stats_periodic - Timer callback to queue stats
+ *
+ * This callback is provided in order to send a stats request.
+ *
+ * This timer function is continually reset to execute within
+ * 60 seconds since the last N_STATS was received.  We need to
+ * ensure we receive the stats in order to update the temperature
+ * used for calibrating the TXPOWER.
+ */
+static void
+il4965_bg_stats_periodic(unsigned long data)
+{
+       struct il_priv *il = (struct il_priv *)data;
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       /* dont send host command if rf-kill is on */
+       if (!il_is_ready_rf(il))
+               return;
+
+       il_send_stats_request(il, CMD_ASYNC, false);
+}
+
+static void
+il4965_hdl_beacon(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il4965_beacon_notif *beacon =
+           (struct il4965_beacon_notif *)pkt->u.raw;
+#ifdef CONFIG_IWLEGACY_DEBUG
+       u8 rate = il4965_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
+
+       D_RX("beacon status %x retries %d iss %d tsf:0x%.8x%.8x rate %d\n",
+            le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
+            beacon->beacon_notify_hdr.failure_frame,
+            le32_to_cpu(beacon->ibss_mgr_status),
+            le32_to_cpu(beacon->high_tsf), le32_to_cpu(beacon->low_tsf), rate);
+#endif
+       il->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
+}
+
+static void
+il4965_perform_ct_kill_task(struct il_priv *il)
+{
+       unsigned long flags;
+
+       D_POWER("Stop all queues\n");
+
+       if (il->mac80211_registered)
+               ieee80211_stop_queues(il->hw);
+
+       _il_wr(il, CSR_UCODE_DRV_GP1_SET,
+              CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
+       _il_rd(il, CSR_UCODE_DRV_GP1);
+
+       spin_lock_irqsave(&il->reg_lock, flags);
+       if (likely(_il_grab_nic_access(il)))
+               _il_release_nic_access(il);
+       spin_unlock_irqrestore(&il->reg_lock, flags);
+}
+
+/* Handle notification from uCode that card's power state is changing
+ * due to software, hardware, or critical temperature RFKILL */
+static void
+il4965_hdl_card_state(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
+       unsigned long status = il->status;
+
+       D_RF_KILL("Card state received: HW:%s SW:%s CT:%s\n",
+                 (flags & HW_CARD_DISABLED) ? "Kill" : "On",
+                 (flags & SW_CARD_DISABLED) ? "Kill" : "On",
+                 (flags & CT_CARD_DISABLED) ? "Reached" : "Not reached");
+
+       if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED | CT_CARD_DISABLED)) {
+
+               _il_wr(il, CSR_UCODE_DRV_GP1_SET,
+                      CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+
+               il_wr(il, HBUS_TARG_MBX_C, HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
+
+               if (!(flags & RXON_CARD_DISABLED)) {
+                       _il_wr(il, CSR_UCODE_DRV_GP1_CLR,
+                              CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+                       il_wr(il, HBUS_TARG_MBX_C,
+                             HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
+               }
+       }
+
+       if (flags & CT_CARD_DISABLED)
+               il4965_perform_ct_kill_task(il);
+
+       if (flags & HW_CARD_DISABLED)
+               set_bit(S_RFKILL, &il->status);
+       else
+               clear_bit(S_RFKILL, &il->status);
+
+       if (!(flags & RXON_CARD_DISABLED))
+               il_scan_cancel(il);
+
+       if ((test_bit(S_RFKILL, &status) !=
+            test_bit(S_RFKILL, &il->status)))
+               wiphy_rfkill_set_hw_state(il->hw->wiphy,
+                                         test_bit(S_RFKILL, &il->status));
+       else
+               wake_up(&il->wait_command_queue);
+}
+
+/**
+ * il4965_setup_handlers - Initialize Rx handler callbacks
+ *
+ * Setup the RX handlers for each of the reply types sent from the uCode
+ * to the host.
+ *
+ * This function chains into the hardware specific files for them to setup
+ * any hardware specific handlers as well.
+ */
+static void
+il4965_setup_handlers(struct il_priv *il)
+{
+       il->handlers[N_ALIVE] = il4965_hdl_alive;
+       il->handlers[N_ERROR] = il_hdl_error;
+       il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;
+       il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;
+       il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;
+       il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;
+       il->handlers[N_BEACON] = il4965_hdl_beacon;
+
+       /*
+        * The same handler is used for both the REPLY to a discrete
+        * stats request from the host as well as for the periodic
+        * stats notifications (after received beacons) from the uCode.
+        */
+       il->handlers[C_STATS] = il4965_hdl_c_stats;
+       il->handlers[N_STATS] = il4965_hdl_stats;
+
+       il_setup_rx_scan_handlers(il);
+
+       /* status change handler */
+       il->handlers[N_CARD_STATE] = il4965_hdl_card_state;
+
+       il->handlers[N_MISSED_BEACONS] = il4965_hdl_missed_beacon;
+       /* Rx handlers */
+       il->handlers[N_RX_PHY] = il4965_hdl_rx_phy;
+       il->handlers[N_RX_MPDU] = il4965_hdl_rx;
+       il->handlers[N_RX] = il4965_hdl_rx;
+       /* block ack */
+       il->handlers[N_COMPRESSED_BA] = il4965_hdl_compressed_ba;
+       /* Tx response */
+       il->handlers[C_TX] = il4965_hdl_tx;
+}
+
+/**
+ * il4965_rx_handle - Main entry function for receiving responses from uCode
+ *
+ * Uses the il->handlers callback function array to invoke
+ * the appropriate handlers, including command responses,
+ * frame-received notifications, and other notifications.
+ */
+void
+il4965_rx_handle(struct il_priv *il)
+{
+       struct il_rx_buf *rxb;
+       struct il_rx_pkt *pkt;
+       struct il_rx_queue *rxq = &il->rxq;
+       u32 r, i;
+       int reclaim;
+       unsigned long flags;
+       u8 fill_rx = 0;
+       u32 count = 8;
+       int total_empty;
+
+       /* uCode's read idx (stored in shared DRAM) indicates the last Rx
+        * buffer that the driver may process (last buffer filled by ucode). */
+       r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
+       i = rxq->read;
+
+       /* Rx interrupt, but nothing sent from uCode */
+       if (i == r)
+               D_RX("r = %d, i = %d\n", r, i);
+
+       /* calculate total frames need to be restock after handling RX */
+       total_empty = r - rxq->write_actual;
+       if (total_empty < 0)
+               total_empty += RX_QUEUE_SIZE;
+
+       if (total_empty > (RX_QUEUE_SIZE / 2))
+               fill_rx = 1;
+
+       while (i != r) {
+               int len;
+
+               rxb = rxq->queue[i];
+
+               /* If an RXB doesn't have a Rx queue slot associated with it,
+                * then a bug has been introduced in the queue refilling
+                * routines -- catch it here */
+               BUG_ON(rxb == NULL);
+
+               rxq->queue[i] = NULL;
+
+               pci_unmap_page(il->pci_dev, rxb->page_dma,
+                              PAGE_SIZE << il->hw_params.rx_page_order,
+                              PCI_DMA_FROMDEVICE);
+               pkt = rxb_addr(rxb);
+
+               len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
+               len += sizeof(u32);     /* account for status word */
+
+               reclaim = il_need_reclaim(il, pkt);
+
+               /* Based on type of command response or notification,
+                *   handle those that need handling via function in
+                *   handlers table.  See il4965_setup_handlers() */
+               if (il->handlers[pkt->hdr.cmd]) {
+                       D_RX("r = %d, i = %d, %s, 0x%02x\n", r, i,
+                            il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
+                       il->isr_stats.handlers[pkt->hdr.cmd]++;
+                       il->handlers[pkt->hdr.cmd] (il, rxb);
+               } else {
+                       /* No handling needed */
+                       D_RX("r %d i %d No handler needed for %s, 0x%02x\n", r,
+                            i, il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
+               }
+
+               /*
+                * XXX: After here, we should always check rxb->page
+                * against NULL before touching it or its virtual
+                * memory (pkt). Because some handler might have
+                * already taken or freed the pages.
+                */
+
+               if (reclaim) {
+                       /* Invoke any callbacks, transfer the buffer to caller,
+                        * and fire off the (possibly) blocking il_send_cmd()
+                        * as we reclaim the driver command queue */
+                       if (rxb->page)
+                               il_tx_cmd_complete(il, rxb);
+                       else
+                               IL_WARN("Claim null rxb?\n");
+               }
+
+               /* Reuse the page if possible. For notification packets and
+                * SKBs that fail to Rx correctly, add them back into the
+                * rx_free list for reuse later. */
+               spin_lock_irqsave(&rxq->lock, flags);
+               if (rxb->page != NULL) {
+                       rxb->page_dma =
+                           pci_map_page(il->pci_dev, rxb->page, 0,
+                                        PAGE_SIZE << il->hw_params.
+                                        rx_page_order, PCI_DMA_FROMDEVICE);
+
+                       if (unlikely(pci_dma_mapping_error(il->pci_dev,
+                                                          rxb->page_dma))) {
+                               __il_free_pages(il, rxb->page);
+                               rxb->page = NULL;
+                               list_add_tail(&rxb->list, &rxq->rx_used);
+                       } else {
+                               list_add_tail(&rxb->list, &rxq->rx_free);
+                               rxq->free_count++;
+                       }
+               } else
+                       list_add_tail(&rxb->list, &rxq->rx_used);
+
+               spin_unlock_irqrestore(&rxq->lock, flags);
+
+               i = (i + 1) & RX_QUEUE_MASK;
+               /* If there are a lot of unused frames,
+                * restock the Rx queue so ucode wont assert. */
+               if (fill_rx) {
+                       count++;
+                       if (count >= 8) {
+                               rxq->read = i;
+                               il4965_rx_replenish_now(il);
+                               count = 0;
+                       }
+               }
+       }
+
+       /* Backtrack one entry */
+       rxq->read = i;
+       if (fill_rx)
+               il4965_rx_replenish_now(il);
+       else
+               il4965_rx_queue_restock(il);
+}
+
+/* call this function to flush any scheduled tasklet */
+static inline void
+il4965_synchronize_irq(struct il_priv *il)
+{
+       /* wait to make sure we flush pending tasklet */
+       synchronize_irq(il->pci_dev->irq);
+       tasklet_kill(&il->irq_tasklet);
+}
+
+static void
+il4965_irq_tasklet(struct il_priv *il)
+{
+       u32 inta, handled = 0;
+       u32 inta_fh;
+       unsigned long flags;
+       u32 i;
+#ifdef CONFIG_IWLEGACY_DEBUG
+       u32 inta_mask;
+#endif
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Ack/clear/reset pending uCode interrupts.
+        * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
+        *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
+       inta = _il_rd(il, CSR_INT);
+       _il_wr(il, CSR_INT, inta);
+
+       /* Ack/clear/reset pending flow-handler (DMA) interrupts.
+        * Any new interrupts that happen after this, either while we're
+        * in this tasklet, or later, will show up in next ISR/tasklet. */
+       inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
+       _il_wr(il, CSR_FH_INT_STATUS, inta_fh);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (il_get_debug_level(il) & IL_DL_ISR) {
+               /* just for debug */
+               inta_mask = _il_rd(il, CSR_INT_MASK);
+               D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta,
+                     inta_mask, inta_fh);
+       }
+#endif
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       /* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
+        * atomic, make sure that inta covers all the interrupts that
+        * we've discovered, even if FH interrupt came in just after
+        * reading CSR_INT. */
+       if (inta_fh & CSR49_FH_INT_RX_MASK)
+               inta |= CSR_INT_BIT_FH_RX;
+       if (inta_fh & CSR49_FH_INT_TX_MASK)
+               inta |= CSR_INT_BIT_FH_TX;
+
+       /* Now service all interrupt bits discovered above. */
+       if (inta & CSR_INT_BIT_HW_ERR) {
+               IL_ERR("Hardware error detected.  Restarting.\n");
+
+               /* Tell the device to stop sending interrupts */
+               il_disable_interrupts(il);
+
+               il->isr_stats.hw++;
+               il_irq_handle_error(il);
+
+               handled |= CSR_INT_BIT_HW_ERR;
+
+               return;
+       }
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (il_get_debug_level(il) & (IL_DL_ISR)) {
+               /* NIC fires this, but we don't use it, redundant with WAKEUP */
+               if (inta & CSR_INT_BIT_SCD) {
+                       D_ISR("Scheduler finished to transmit "
+                             "the frame/frames.\n");
+                       il->isr_stats.sch++;
+               }
+
+               /* Alive notification via Rx interrupt will do the real work */
+               if (inta & CSR_INT_BIT_ALIVE) {
+                       D_ISR("Alive interrupt\n");
+                       il->isr_stats.alive++;
+               }
+       }
+#endif
+       /* Safely ignore these bits for debug checks below */
+       inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
+
+       /* HW RF KILL switch toggled */
+       if (inta & CSR_INT_BIT_RF_KILL) {
+               int hw_rf_kill = 0;
+
+               if (!(_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
+                       hw_rf_kill = 1;
+
+               IL_WARN("RF_KILL bit toggled to %s.\n",
+                       hw_rf_kill ? "disable radio" : "enable radio");
+
+               il->isr_stats.rfkill++;
+
+               /* driver only loads ucode once setting the interface up.
+                * the driver allows loading the ucode even if the radio
+                * is killed. Hence update the killswitch state here. The
+                * rfkill handler will care about restarting if needed.
+                */
+               if (hw_rf_kill) {
+                       set_bit(S_RFKILL, &il->status);
+               } else {
+                       clear_bit(S_RFKILL, &il->status);
+                       il_force_reset(il, true);
+               }
+               wiphy_rfkill_set_hw_state(il->hw->wiphy, hw_rf_kill);
+
+               handled |= CSR_INT_BIT_RF_KILL;
+       }
+
+       /* Chip got too hot and stopped itself */
+       if (inta & CSR_INT_BIT_CT_KILL) {
+               IL_ERR("Microcode CT kill error detected.\n");
+               il->isr_stats.ctkill++;
+               handled |= CSR_INT_BIT_CT_KILL;
+       }
+
+       /* Error detected by uCode */
+       if (inta & CSR_INT_BIT_SW_ERR) {
+               IL_ERR("Microcode SW error detected. " " Restarting 0x%X.\n",
+                      inta);
+               il->isr_stats.sw++;
+               il_irq_handle_error(il);
+               handled |= CSR_INT_BIT_SW_ERR;
+       }
+
+       /*
+        * uCode wakes up after power-down sleep.
+        * Tell device about any new tx or host commands enqueued,
+        * and about any Rx buffers made available while asleep.
+        */
+       if (inta & CSR_INT_BIT_WAKEUP) {
+               D_ISR("Wakeup interrupt\n");
+               il_rx_queue_update_write_ptr(il, &il->rxq);
+               for (i = 0; i < il->hw_params.max_txq_num; i++)
+                       il_txq_update_write_ptr(il, &il->txq[i]);
+               il->isr_stats.wakeup++;
+               handled |= CSR_INT_BIT_WAKEUP;
+       }
+
+       /* All uCode command responses, including Tx command responses,
+        * Rx "responses" (frame-received notification), and other
+        * notifications from uCode come through here*/
+       if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
+               il4965_rx_handle(il);
+               il->isr_stats.rx++;
+               handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
+       }
+
+       /* This "Tx" DMA channel is used only for loading uCode */
+       if (inta & CSR_INT_BIT_FH_TX) {
+               D_ISR("uCode load interrupt\n");
+               il->isr_stats.tx++;
+               handled |= CSR_INT_BIT_FH_TX;
+               /* Wake up uCode load routine, now that load is complete */
+               il->ucode_write_complete = 1;
+               wake_up(&il->wait_command_queue);
+       }
+
+       if (inta & ~handled) {
+               IL_ERR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
+               il->isr_stats.unhandled++;
+       }
+
+       if (inta & ~(il->inta_mask)) {
+               IL_WARN("Disabled INTA bits 0x%08x were pending\n",
+                       inta & ~il->inta_mask);
+               IL_WARN("   with FH49_INT = 0x%08x\n", inta_fh);
+       }
+
+       /* Re-enable all interrupts */
+       /* only Re-enable if disabled by irq */
+       if (test_bit(S_INT_ENABLED, &il->status))
+               il_enable_interrupts(il);
+       /* Re-enable RF_KILL if it occurred */
+       else if (handled & CSR_INT_BIT_RF_KILL)
+               il_enable_rfkill_int(il);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (il_get_debug_level(il) & (IL_DL_ISR)) {
+               inta = _il_rd(il, CSR_INT);
+               inta_mask = _il_rd(il, CSR_INT_MASK);
+               inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
+               D_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
+                     "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
+       }
+#endif
+}
+
+/*****************************************************************************
+ *
+ * sysfs attributes
+ *
+ *****************************************************************************/
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+
+/*
+ * The following adds a new attribute to the sysfs representation
+ * of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
+ * used for controlling the debug level.
+ *
+ * See the level definitions in iwl for details.
+ *
+ * The debug_level being managed using sysfs below is a per device debug
+ * level that is used instead of the global debug level if it (the per
+ * device debug level) is set.
+ */
+static ssize_t
+il4965_show_debug_level(struct device *d, struct device_attribute *attr,
+                       char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       return sprintf(buf, "0x%08X\n", il_get_debug_level(il));
+}
+
+static ssize_t
+il4965_store_debug_level(struct device *d, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       unsigned long val;
+       int ret;
+
+       ret = kstrtoul(buf, 0, &val);
+       if (ret)
+               IL_ERR("%s is not in hex or decimal form.\n", buf);
+       else
+               il->debug_level = val;
+
+       return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO, il4965_show_debug_level,
+                  il4965_store_debug_level);
+
+#endif /* CONFIG_IWLEGACY_DEBUG */
+
+static ssize_t
+il4965_show_temperature(struct device *d, struct device_attribute *attr,
+                       char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+
+       if (!il_is_alive(il))
+               return -EAGAIN;
+
+       return sprintf(buf, "%d\n", il->temperature);
+}
+
+static DEVICE_ATTR(temperature, S_IRUGO, il4965_show_temperature, NULL);
+
+static ssize_t
+il4965_show_tx_power(struct device *d, struct device_attribute *attr, char *buf)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+
+       if (!il_is_ready_rf(il))
+               return sprintf(buf, "off\n");
+       else
+               return sprintf(buf, "%d\n", il->tx_power_user_lmt);
+}
+
+static ssize_t
+il4965_store_tx_power(struct device *d, struct device_attribute *attr,
+                     const char *buf, size_t count)
+{
+       struct il_priv *il = dev_get_drvdata(d);
+       unsigned long val;
+       int ret;
+
+       ret = kstrtoul(buf, 10, &val);
+       if (ret)
+               IL_INFO("%s is not in decimal form.\n", buf);
+       else {
+               ret = il_set_tx_power(il, val, false);
+               if (ret)
+                       IL_ERR("failed setting tx power (0x%08x).\n", ret);
+               else
+                       ret = count;
+       }
+       return ret;
+}
+
+static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, il4965_show_tx_power,
+                  il4965_store_tx_power);
+
+static struct attribute *il_sysfs_entries[] = {
+       &dev_attr_temperature.attr,
+       &dev_attr_tx_power.attr,
+#ifdef CONFIG_IWLEGACY_DEBUG
+       &dev_attr_debug_level.attr,
+#endif
+       NULL
+};
+
+static struct attribute_group il_attribute_group = {
+       .name = NULL,           /* put in device directory */
+       .attrs = il_sysfs_entries,
+};
+
+/******************************************************************************
+ *
+ * uCode download functions
+ *
+ ******************************************************************************/
+
+static void
+il4965_dealloc_ucode_pci(struct il_priv *il)
+{
+       il_free_fw_desc(il->pci_dev, &il->ucode_code);
+       il_free_fw_desc(il->pci_dev, &il->ucode_data);
+       il_free_fw_desc(il->pci_dev, &il->ucode_data_backup);
+       il_free_fw_desc(il->pci_dev, &il->ucode_init);
+       il_free_fw_desc(il->pci_dev, &il->ucode_init_data);
+       il_free_fw_desc(il->pci_dev, &il->ucode_boot);
+}
+
+static void
+il4965_nic_start(struct il_priv *il)
+{
+       /* Remove all resets to allow NIC to operate */
+       _il_wr(il, CSR_RESET, 0);
+}
+
+static void il4965_ucode_callback(const struct firmware *ucode_raw,
+                                 void *context);
+static int il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length);
+
+static int __must_check
+il4965_request_firmware(struct il_priv *il, bool first)
+{
+       const char *name_pre = il->cfg->fw_name_pre;
+       char tag[8];
+
+       if (first) {
+               il->fw_idx = il->cfg->ucode_api_max;
+               sprintf(tag, "%d", il->fw_idx);
+       } else {
+               il->fw_idx--;
+               sprintf(tag, "%d", il->fw_idx);
+       }
+
+       if (il->fw_idx < il->cfg->ucode_api_min) {
+               IL_ERR("no suitable firmware found!\n");
+               return -ENOENT;
+       }
+
+       sprintf(il->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
+
+       D_INFO("attempting to load firmware '%s'\n", il->firmware_name);
+
+       return request_firmware_nowait(THIS_MODULE, 1, il->firmware_name,
+                                      &il->pci_dev->dev, GFP_KERNEL, il,
+                                      il4965_ucode_callback);
+}
+
+struct il4965_firmware_pieces {
+       const void *inst, *data, *init, *init_data, *boot;
+       size_t inst_size, data_size, init_size, init_data_size, boot_size;
+};
+
+static int
+il4965_load_firmware(struct il_priv *il, const struct firmware *ucode_raw,
+                    struct il4965_firmware_pieces *pieces)
+{
+       struct il_ucode_header *ucode = (void *)ucode_raw->data;
+       u32 api_ver, hdr_size;
+       const u8 *src;
+
+       il->ucode_ver = le32_to_cpu(ucode->ver);
+       api_ver = IL_UCODE_API(il->ucode_ver);
+
+       switch (api_ver) {
+       default:
+       case 0:
+       case 1:
+       case 2:
+               hdr_size = 24;
+               if (ucode_raw->size < hdr_size) {
+                       IL_ERR("File size too small!\n");
+                       return -EINVAL;
+               }
+               pieces->inst_size = le32_to_cpu(ucode->v1.inst_size);
+               pieces->data_size = le32_to_cpu(ucode->v1.data_size);
+               pieces->init_size = le32_to_cpu(ucode->v1.init_size);
+               pieces->init_data_size = le32_to_cpu(ucode->v1.init_data_size);
+               pieces->boot_size = le32_to_cpu(ucode->v1.boot_size);
+               src = ucode->v1.data;
+               break;
+       }
+
+       /* Verify size of file vs. image size info in file's header */
+       if (ucode_raw->size !=
+           hdr_size + pieces->inst_size + pieces->data_size +
+           pieces->init_size + pieces->init_data_size + pieces->boot_size) {
+
+               IL_ERR("uCode file size %d does not match expected size\n",
+                      (int)ucode_raw->size);
+               return -EINVAL;
+       }
+
+       pieces->inst = src;
+       src += pieces->inst_size;
+       pieces->data = src;
+       src += pieces->data_size;
+       pieces->init = src;
+       src += pieces->init_size;
+       pieces->init_data = src;
+       src += pieces->init_data_size;
+       pieces->boot = src;
+       src += pieces->boot_size;
+
+       return 0;
+}
+
+/**
+ * il4965_ucode_callback - callback when firmware was loaded
+ *
+ * If loaded successfully, copies the firmware into buffers
+ * for the card to fetch (via DMA).
+ */
+static void
+il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
+{
+       struct il_priv *il = context;
+       struct il_ucode_header *ucode;
+       int err;
+       struct il4965_firmware_pieces pieces;
+       const unsigned int api_max = il->cfg->ucode_api_max;
+       const unsigned int api_min = il->cfg->ucode_api_min;
+       u32 api_ver;
+
+       u32 max_probe_length = 200;
+       u32 standard_phy_calibration_size =
+           IL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
+
+       memset(&pieces, 0, sizeof(pieces));
+
+       if (!ucode_raw) {
+               if (il->fw_idx <= il->cfg->ucode_api_max)
+                       IL_ERR("request for firmware file '%s' failed.\n",
+                              il->firmware_name);
+               goto try_again;
+       }
+
+       D_INFO("Loaded firmware file '%s' (%zd bytes).\n", il->firmware_name,
+              ucode_raw->size);
+
+       /* Make sure that we got at least the API version number */
+       if (ucode_raw->size < 4) {
+               IL_ERR("File size way too small!\n");
+               goto try_again;
+       }
+
+       /* Data from ucode file:  header followed by uCode images */
+       ucode = (struct il_ucode_header *)ucode_raw->data;
+
+       err = il4965_load_firmware(il, ucode_raw, &pieces);
+
+       if (err)
+               goto try_again;
+
+       api_ver = IL_UCODE_API(il->ucode_ver);
+
+       /*
+        * api_ver should match the api version forming part of the
+        * firmware filename ... but we don't check for that and only rely
+        * on the API version read from firmware header from here on forward
+        */
+       if (api_ver < api_min || api_ver > api_max) {
+               IL_ERR("Driver unable to support your firmware API. "
+                      "Driver supports v%u, firmware is v%u.\n", api_max,
+                      api_ver);
+               goto try_again;
+       }
+
+       if (api_ver != api_max)
+               IL_ERR("Firmware has old API version. Expected v%u, "
+                      "got v%u. New firmware can be obtained "
+                      "from http://www.intellinuxwireless.org.\n", api_max,
+                      api_ver);
+
+       IL_INFO("loaded firmware version %u.%u.%u.%u\n",
+               IL_UCODE_MAJOR(il->ucode_ver), IL_UCODE_MINOR(il->ucode_ver),
+               IL_UCODE_API(il->ucode_ver), IL_UCODE_SERIAL(il->ucode_ver));
+
+       snprintf(il->hw->wiphy->fw_version, sizeof(il->hw->wiphy->fw_version),
+                "%u.%u.%u.%u", IL_UCODE_MAJOR(il->ucode_ver),
+                IL_UCODE_MINOR(il->ucode_ver), IL_UCODE_API(il->ucode_ver),
+                IL_UCODE_SERIAL(il->ucode_ver));
+
+       /*
+        * For any of the failures below (before allocating pci memory)
+        * we will try to load a version with a smaller API -- maybe the
+        * user just got a corrupted version of the latest API.
+        */
+
+       D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver);
+       D_INFO("f/w package hdr runtime inst size = %Zd\n", pieces.inst_size);
+       D_INFO("f/w package hdr runtime data size = %Zd\n", pieces.data_size);
+       D_INFO("f/w package hdr init inst size = %Zd\n", pieces.init_size);
+       D_INFO("f/w package hdr init data size = %Zd\n", pieces.init_data_size);
+       D_INFO("f/w package hdr boot inst size = %Zd\n", pieces.boot_size);
+
+       /* Verify that uCode images will fit in card's SRAM */
+       if (pieces.inst_size > il->hw_params.max_inst_size) {
+               IL_ERR("uCode instr len %Zd too large to fit in\n",
+                      pieces.inst_size);
+               goto try_again;
+       }
+
+       if (pieces.data_size > il->hw_params.max_data_size) {
+               IL_ERR("uCode data len %Zd too large to fit in\n",
+                      pieces.data_size);
+               goto try_again;
+       }
+
+       if (pieces.init_size > il->hw_params.max_inst_size) {
+               IL_ERR("uCode init instr len %Zd too large to fit in\n",
+                      pieces.init_size);
+               goto try_again;
+       }
+
+       if (pieces.init_data_size > il->hw_params.max_data_size) {
+               IL_ERR("uCode init data len %Zd too large to fit in\n",
+                      pieces.init_data_size);
+               goto try_again;
+       }
+
+       if (pieces.boot_size > il->hw_params.max_bsm_size) {
+               IL_ERR("uCode boot instr len %Zd too large to fit in\n",
+                      pieces.boot_size);
+               goto try_again;
+       }
+
+       /* Allocate ucode buffers for card's bus-master loading ... */
+
+       /* Runtime instructions and 2 copies of data:
+        * 1) unmodified from disk
+        * 2) backup cache for save/restore during power-downs */
+       il->ucode_code.len = pieces.inst_size;
+       il_alloc_fw_desc(il->pci_dev, &il->ucode_code);
+
+       il->ucode_data.len = pieces.data_size;
+       il_alloc_fw_desc(il->pci_dev, &il->ucode_data);
+
+       il->ucode_data_backup.len = pieces.data_size;
+       il_alloc_fw_desc(il->pci_dev, &il->ucode_data_backup);
+
+       if (!il->ucode_code.v_addr || !il->ucode_data.v_addr ||
+           !il->ucode_data_backup.v_addr)
+               goto err_pci_alloc;
+
+       /* Initialization instructions and data */
+       if (pieces.init_size && pieces.init_data_size) {
+               il->ucode_init.len = pieces.init_size;
+               il_alloc_fw_desc(il->pci_dev, &il->ucode_init);
+
+               il->ucode_init_data.len = pieces.init_data_size;
+               il_alloc_fw_desc(il->pci_dev, &il->ucode_init_data);
+
+               if (!il->ucode_init.v_addr || !il->ucode_init_data.v_addr)
+                       goto err_pci_alloc;
+       }
+
+       /* Bootstrap (instructions only, no data) */
+       if (pieces.boot_size) {
+               il->ucode_boot.len = pieces.boot_size;
+               il_alloc_fw_desc(il->pci_dev, &il->ucode_boot);
+
+               if (!il->ucode_boot.v_addr)
+                       goto err_pci_alloc;
+       }
+
+       /* Now that we can no longer fail, copy information */
+
+       il->sta_key_max_num = STA_KEY_MAX_NUM;
+
+       /* Copy images into buffers for card's bus-master reads ... */
+
+       /* Runtime instructions (first block of data in file) */
+       D_INFO("Copying (but not loading) uCode instr len %Zd\n",
+              pieces.inst_size);
+       memcpy(il->ucode_code.v_addr, pieces.inst, pieces.inst_size);
+
+       D_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
+              il->ucode_code.v_addr, (u32) il->ucode_code.p_addr);
+
+       /*
+        * Runtime data
+        * NOTE:  Copy into backup buffer will be done in il_up()
+        */
+       D_INFO("Copying (but not loading) uCode data len %Zd\n",
+              pieces.data_size);
+       memcpy(il->ucode_data.v_addr, pieces.data, pieces.data_size);
+       memcpy(il->ucode_data_backup.v_addr, pieces.data, pieces.data_size);
+
+       /* Initialization instructions */
+       if (pieces.init_size) {
+               D_INFO("Copying (but not loading) init instr len %Zd\n",
+                      pieces.init_size);
+               memcpy(il->ucode_init.v_addr, pieces.init, pieces.init_size);
+       }
+
+       /* Initialization data */
+       if (pieces.init_data_size) {
+               D_INFO("Copying (but not loading) init data len %Zd\n",
+                      pieces.init_data_size);
+               memcpy(il->ucode_init_data.v_addr, pieces.init_data,
+                      pieces.init_data_size);
+       }
+
+       /* Bootstrap instructions */
+       D_INFO("Copying (but not loading) boot instr len %Zd\n",
+              pieces.boot_size);
+       memcpy(il->ucode_boot.v_addr, pieces.boot, pieces.boot_size);
+
+       /*
+        * figure out the offset of chain noise reset and gain commands
+        * base on the size of standard phy calibration commands table size
+        */
+       il->_4965.phy_calib_chain_noise_reset_cmd =
+           standard_phy_calibration_size;
+       il->_4965.phy_calib_chain_noise_gain_cmd =
+           standard_phy_calibration_size + 1;
+
+       /**************************************************
+        * This is still part of probe() in a sense...
+        *
+        * 9. Setup and register with mac80211 and debugfs
+        **************************************************/
+       err = il4965_mac_setup_register(il, max_probe_length);
+       if (err)
+               goto out_unbind;
+
+       err = il_dbgfs_register(il, DRV_NAME);
+       if (err)
+               IL_ERR("failed to create debugfs files. Ignoring error: %d\n",
+                      err);
+
+       err = sysfs_create_group(&il->pci_dev->dev.kobj, &il_attribute_group);
+       if (err) {
+               IL_ERR("failed to create sysfs device attributes\n");
+               goto out_unbind;
+       }
+
+       /* We have our copies now, allow OS release its copies */
+       release_firmware(ucode_raw);
+       complete(&il->_4965.firmware_loading_complete);
+       return;
+
+try_again:
+       /* try next, if any */
+       if (il4965_request_firmware(il, false))
+               goto out_unbind;
+       release_firmware(ucode_raw);
+       return;
+
+err_pci_alloc:
+       IL_ERR("failed to allocate pci memory\n");
+       il4965_dealloc_ucode_pci(il);
+out_unbind:
+       complete(&il->_4965.firmware_loading_complete);
+       device_release_driver(&il->pci_dev->dev);
+       release_firmware(ucode_raw);
+}
+
+static const char *const desc_lookup_text[] = {
+       "OK",
+       "FAIL",
+       "BAD_PARAM",
+       "BAD_CHECKSUM",
+       "NMI_INTERRUPT_WDG",
+       "SYSASSERT",
+       "FATAL_ERROR",
+       "BAD_COMMAND",
+       "HW_ERROR_TUNE_LOCK",
+       "HW_ERROR_TEMPERATURE",
+       "ILLEGAL_CHAN_FREQ",
+       "VCC_NOT_STBL",
+       "FH49_ERROR",
+       "NMI_INTERRUPT_HOST",
+       "NMI_INTERRUPT_ACTION_PT",
+       "NMI_INTERRUPT_UNKNOWN",
+       "UCODE_VERSION_MISMATCH",
+       "HW_ERROR_ABS_LOCK",
+       "HW_ERROR_CAL_LOCK_FAIL",
+       "NMI_INTERRUPT_INST_ACTION_PT",
+       "NMI_INTERRUPT_DATA_ACTION_PT",
+       "NMI_TRM_HW_ER",
+       "NMI_INTERRUPT_TRM",
+       "NMI_INTERRUPT_BREAK_POINT",
+       "DEBUG_0",
+       "DEBUG_1",
+       "DEBUG_2",
+       "DEBUG_3",
+};
+
+static struct {
+       char *name;
+       u8 num;
+} advanced_lookup[] = {
+       {
+       "NMI_INTERRUPT_WDG", 0x34}, {
+       "SYSASSERT", 0x35}, {
+       "UCODE_VERSION_MISMATCH", 0x37}, {
+       "BAD_COMMAND", 0x38}, {
+       "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C}, {
+       "FATAL_ERROR", 0x3D}, {
+       "NMI_TRM_HW_ERR", 0x46}, {
+       "NMI_INTERRUPT_TRM", 0x4C}, {
+       "NMI_INTERRUPT_BREAK_POINT", 0x54}, {
+       "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C}, {
+       "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64}, {
+       "NMI_INTERRUPT_HOST", 0x66}, {
+       "NMI_INTERRUPT_ACTION_PT", 0x7C}, {
+       "NMI_INTERRUPT_UNKNOWN", 0x84}, {
+       "NMI_INTERRUPT_INST_ACTION_PT", 0x86}, {
+"ADVANCED_SYSASSERT", 0},};
+
+static const char *
+il4965_desc_lookup(u32 num)
+{
+       int i;
+       int max = ARRAY_SIZE(desc_lookup_text);
+
+       if (num < max)
+               return desc_lookup_text[num];
+
+       max = ARRAY_SIZE(advanced_lookup) - 1;
+       for (i = 0; i < max; i++) {
+               if (advanced_lookup[i].num == num)
+                       break;
+       }
+       return advanced_lookup[i].name;
+}
+
+#define ERROR_START_OFFSET  (1 * sizeof(u32))
+#define ERROR_ELEM_SIZE     (7 * sizeof(u32))
+
+void
+il4965_dump_nic_error_log(struct il_priv *il)
+{
+       u32 data2, line;
+       u32 desc, time, count, base, data1;
+       u32 blink1, blink2, ilink1, ilink2;
+       u32 pc, hcmd;
+
+       if (il->ucode_type == UCODE_INIT)
+               base = le32_to_cpu(il->card_alive_init.error_event_table_ptr);
+       else
+               base = le32_to_cpu(il->card_alive.error_event_table_ptr);
+
+       if (!il->ops->is_valid_rtc_data_addr(base)) {
+               IL_ERR("Not valid error log pointer 0x%08X for %s uCode\n",
+                      base, (il->ucode_type == UCODE_INIT) ? "Init" : "RT");
+               return;
+       }
+
+       count = il_read_targ_mem(il, base);
+
+       if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
+               IL_ERR("Start IWL Error Log Dump:\n");
+               IL_ERR("Status: 0x%08lX, count: %d\n", il->status, count);
+       }
+
+       desc = il_read_targ_mem(il, base + 1 * sizeof(u32));
+       il->isr_stats.err_code = desc;
+       pc = il_read_targ_mem(il, base + 2 * sizeof(u32));
+       blink1 = il_read_targ_mem(il, base + 3 * sizeof(u32));
+       blink2 = il_read_targ_mem(il, base + 4 * sizeof(u32));
+       ilink1 = il_read_targ_mem(il, base + 5 * sizeof(u32));
+       ilink2 = il_read_targ_mem(il, base + 6 * sizeof(u32));
+       data1 = il_read_targ_mem(il, base + 7 * sizeof(u32));
+       data2 = il_read_targ_mem(il, base + 8 * sizeof(u32));
+       line = il_read_targ_mem(il, base + 9 * sizeof(u32));
+       time = il_read_targ_mem(il, base + 11 * sizeof(u32));
+       hcmd = il_read_targ_mem(il, base + 22 * sizeof(u32));
+
+       IL_ERR("Desc                                  Time       "
+              "data1      data2      line\n");
+       IL_ERR("%-28s (0x%04X) %010u 0x%08X 0x%08X %u\n",
+              il4965_desc_lookup(desc), desc, time, data1, data2, line);
+       IL_ERR("pc      blink1  blink2  ilink1  ilink2  hcmd\n");
+       IL_ERR("0x%05X 0x%05X 0x%05X 0x%05X 0x%05X 0x%05X\n", pc, blink1,
+              blink2, ilink1, ilink2, hcmd);
+}
+
+static void
+il4965_rf_kill_ct_config(struct il_priv *il)
+{
+       struct il_ct_kill_config cmd;
+       unsigned long flags;
+       int ret = 0;
+
+       spin_lock_irqsave(&il->lock, flags);
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR,
+              CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       cmd.critical_temperature_R =
+           cpu_to_le32(il->hw_params.ct_kill_threshold);
+
+       ret = il_send_cmd_pdu(il, C_CT_KILL_CONFIG, sizeof(cmd), &cmd);
+       if (ret)
+               IL_ERR("C_CT_KILL_CONFIG failed\n");
+       else
+               D_INFO("C_CT_KILL_CONFIG " "succeeded, "
+                      "critical temperature is %d\n",
+                      il->hw_params.ct_kill_threshold);
+}
+
+static const s8 default_queue_to_tx_fifo[] = {
+       IL_TX_FIFO_VO,
+       IL_TX_FIFO_VI,
+       IL_TX_FIFO_BE,
+       IL_TX_FIFO_BK,
+       IL49_CMD_FIFO_NUM,
+       IL_TX_FIFO_UNUSED,
+       IL_TX_FIFO_UNUSED,
+};
+
+#define IL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo))))
+
+static int
+il4965_alive_notify(struct il_priv *il)
+{
+       u32 a;
+       unsigned long flags;
+       int i, chan;
+       u32 reg_val;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Clear 4965's internal Tx Scheduler data base */
+       il->scd_base_addr = il_rd_prph(il, IL49_SCD_SRAM_BASE_ADDR);
+       a = il->scd_base_addr + IL49_SCD_CONTEXT_DATA_OFFSET;
+       for (; a < il->scd_base_addr + IL49_SCD_TX_STTS_BITMAP_OFFSET; a += 4)
+               il_write_targ_mem(il, a, 0);
+       for (; a < il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET; a += 4)
+               il_write_targ_mem(il, a, 0);
+       for (;
+            a <
+            il->scd_base_addr +
+            IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(il->hw_params.max_txq_num);
+            a += 4)
+               il_write_targ_mem(il, a, 0);
+
+       /* Tel 4965 where to find Tx byte count tables */
+       il_wr_prph(il, IL49_SCD_DRAM_BASE_ADDR, il->scd_bc_tbls.dma >> 10);
+
+       /* Enable DMA channel */
+       for (chan = 0; chan < FH49_TCSR_CHNL_NUM; chan++)
+               il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(chan),
+                     FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |
+                     FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE);
+
+       /* Update FH chicken bits */
+       reg_val = il_rd(il, FH49_TX_CHICKEN_BITS_REG);
+       il_wr(il, FH49_TX_CHICKEN_BITS_REG,
+             reg_val | FH49_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN);
+
+       /* Disable chain mode for all queues */
+       il_wr_prph(il, IL49_SCD_QUEUECHAIN_SEL, 0);
+
+       /* Initialize each Tx queue (including the command queue) */
+       for (i = 0; i < il->hw_params.max_txq_num; i++) {
+
+               /* TFD circular buffer read/write idxes */
+               il_wr_prph(il, IL49_SCD_QUEUE_RDPTR(i), 0);
+               il_wr(il, HBUS_TARG_WRPTR, 0 | (i << 8));
+
+               /* Max Tx Window size for Scheduler-ACK mode */
+               il_write_targ_mem(il,
+                                 il->scd_base_addr +
+                                 IL49_SCD_CONTEXT_QUEUE_OFFSET(i),
+                                 (SCD_WIN_SIZE <<
+                                  IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) &
+                                 IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
+
+               /* Frame limit */
+               il_write_targ_mem(il,
+                                 il->scd_base_addr +
+                                 IL49_SCD_CONTEXT_QUEUE_OFFSET(i) +
+                                 sizeof(u32),
+                                 (SCD_FRAME_LIMIT <<
+                                  IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
+                                 IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
+
+       }
+       il_wr_prph(il, IL49_SCD_INTERRUPT_MASK,
+                  (1 << il->hw_params.max_txq_num) - 1);
+
+       /* Activate all Tx DMA/FIFO channels */
+       il4965_txq_set_sched(il, IL_MASK(0, 6));
+
+       il4965_set_wr_ptrs(il, IL_DEFAULT_CMD_QUEUE_NUM, 0);
+
+       /* make sure all queue are not stopped */
+       memset(&il->queue_stopped[0], 0, sizeof(il->queue_stopped));
+       for (i = 0; i < 4; i++)
+               atomic_set(&il->queue_stop_count[i], 0);
+
+       /* reset to 0 to enable all the queue first */
+       il->txq_ctx_active_msk = 0;
+       /* Map each Tx/cmd queue to its corresponding fifo */
+       BUILD_BUG_ON(ARRAY_SIZE(default_queue_to_tx_fifo) != 7);
+
+       for (i = 0; i < ARRAY_SIZE(default_queue_to_tx_fifo); i++) {
+               int ac = default_queue_to_tx_fifo[i];
+
+               il_txq_ctx_activate(il, i);
+
+               if (ac == IL_TX_FIFO_UNUSED)
+                       continue;
+
+               il4965_tx_queue_set_status(il, &il->txq[i], ac, 0);
+       }
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       return 0;
+}
+
+/**
+ * il4965_alive_start - called after N_ALIVE notification received
+ *                   from protocol/runtime uCode (initialization uCode's
+ *                   Alive gets handled by il_init_alive_start()).
+ */
+static void
+il4965_alive_start(struct il_priv *il)
+{
+       int ret = 0;
+
+       D_INFO("Runtime Alive received.\n");
+
+       if (il->card_alive.is_valid != UCODE_VALID_OK) {
+               /* We had an error bringing up the hardware, so take it
+                * all the way back down so we can try again */
+               D_INFO("Alive failed.\n");
+               goto restart;
+       }
+
+       /* Initialize uCode has loaded Runtime uCode ... verify inst image.
+        * This is a paranoid check, because we would not have gotten the
+        * "runtime" alive if code weren't properly loaded.  */
+       if (il4965_verify_ucode(il)) {
+               /* Runtime instruction load was bad;
+                * take it all the way back down so we can try again */
+               D_INFO("Bad runtime uCode load.\n");
+               goto restart;
+       }
+
+       ret = il4965_alive_notify(il);
+       if (ret) {
+               IL_WARN("Could not complete ALIVE transition [ntf]: %d\n", ret);
+               goto restart;
+       }
+
+       /* After the ALIVE response, we can send host commands to the uCode */
+       set_bit(S_ALIVE, &il->status);
+
+       /* Enable watchdog to monitor the driver tx queues */
+       il_setup_watchdog(il);
+
+       if (il_is_rfkill(il))
+               return;
+
+       ieee80211_wake_queues(il->hw);
+
+       il->active_rate = RATES_MASK;
+
+       il_power_update_mode(il, true);
+       D_INFO("Updated power mode\n");
+
+       if (il_is_associated(il)) {
+               struct il_rxon_cmd *active_rxon =
+                   (struct il_rxon_cmd *)&il->active;
+               /* apply any changes in staging */
+               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
+               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+       } else {
+               /* Initialize our rx_config data */
+               il_connection_init_rx_config(il);
+
+               if (il->ops->set_rxon_chain)
+                       il->ops->set_rxon_chain(il);
+       }
+
+       /* Configure bluetooth coexistence if enabled */
+       il_send_bt_config(il);
+
+       il4965_reset_run_time_calib(il);
+
+       set_bit(S_READY, &il->status);
+
+       /* Configure the adapter for unassociated operation */
+       il_commit_rxon(il);
+
+       /* At this point, the NIC is initialized and operational */
+       il4965_rf_kill_ct_config(il);
+
+       D_INFO("ALIVE processing complete.\n");
+       wake_up(&il->wait_command_queue);
+
+       return;
+
+restart:
+       queue_work(il->workqueue, &il->restart);
+}
+
+static void il4965_cancel_deferred_work(struct il_priv *il);
+
+static void
+__il4965_down(struct il_priv *il)
+{
+       unsigned long flags;
+       int exit_pending;
+
+       D_INFO(DRV_NAME " is going down\n");
+
+       il_scan_cancel_timeout(il, 200);
+
+       exit_pending = test_and_set_bit(S_EXIT_PENDING, &il->status);
+
+       /* Stop TX queues watchdog. We need to have S_EXIT_PENDING bit set
+        * to prevent rearm timer */
+       del_timer_sync(&il->watchdog);
+
+       il_clear_ucode_stations(il);
+
+       /* FIXME: race conditions ? */
+       spin_lock_irq(&il->sta_lock);
+       /*
+        * Remove all key information that is not stored as part
+        * of station information since mac80211 may not have had
+        * a chance to remove all the keys. When device is
+        * reconfigured by mac80211 after an error all keys will
+        * be reconfigured.
+        */
+       memset(il->_4965.wep_keys, 0, sizeof(il->_4965.wep_keys));
+       il->_4965.key_mapping_keys = 0;
+       spin_unlock_irq(&il->sta_lock);
+
+       il_dealloc_bcast_stations(il);
+       il_clear_driver_stations(il);
+
+       /* Unblock any waiting calls */
+       wake_up_all(&il->wait_command_queue);
+
+       /* Wipe out the EXIT_PENDING status bit if we are not actually
+        * exiting the module */
+       if (!exit_pending)
+               clear_bit(S_EXIT_PENDING, &il->status);
+
+       /* stop and reset the on-board processor */
+       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
+
+       /* tell the device to stop sending interrupts */
+       spin_lock_irqsave(&il->lock, flags);
+       il_disable_interrupts(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+       il4965_synchronize_irq(il);
+
+       if (il->mac80211_registered)
+               ieee80211_stop_queues(il->hw);
+
+       /* If we have not previously called il_init() then
+        * clear all bits but the RF Kill bit and return */
+       if (!il_is_init(il)) {
+               il->status =
+                   test_bit(S_RFKILL, &il->status) << S_RFKILL |
+                   test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
+                   test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
+               goto exit;
+       }
+
+       /* ...otherwise clear out all the status bits but the RF Kill
+        * bit and continue taking the NIC down. */
+       il->status &=
+           test_bit(S_RFKILL, &il->status) << S_RFKILL |
+           test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
+           test_bit(S_FW_ERROR, &il->status) << S_FW_ERROR |
+           test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
+
+       /*
+        * We disabled and synchronized interrupt, and priv->mutex is taken, so
+        * here is the only thread which will program device registers, but
+        * still have lockdep assertions, so we are taking reg_lock.
+        */
+       spin_lock_irq(&il->reg_lock);
+       /* FIXME: il_grab_nic_access if rfkill is off ? */
+
+       il4965_txq_ctx_stop(il);
+       il4965_rxq_stop(il);
+       /* Power-down device's busmaster DMA clocks */
+       _il_wr_prph(il, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
+       udelay(5);
+       /* Make sure (redundant) we've released our request to stay awake */
+       _il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+       /* Stop the device, and put it in low power state */
+       _il_apm_stop(il);
+
+       spin_unlock_irq(&il->reg_lock);
+
+       il4965_txq_ctx_unmap(il);
+exit:
+       memset(&il->card_alive, 0, sizeof(struct il_alive_resp));
+
+       dev_kfree_skb(il->beacon_skb);
+       il->beacon_skb = NULL;
+
+       /* clear out any free frames */
+       il4965_clear_free_frames(il);
+}
+
+static void
+il4965_down(struct il_priv *il)
+{
+       mutex_lock(&il->mutex);
+       __il4965_down(il);
+       mutex_unlock(&il->mutex);
+
+       il4965_cancel_deferred_work(il);
+}
+
+
+static void
+il4965_set_hw_ready(struct il_priv *il)
+{
+       int ret;
+
+       il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                  CSR_HW_IF_CONFIG_REG_BIT_NIC_READY);
+
+       /* See if we got it */
+       ret = _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
+                          CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
+                          100);
+       if (ret >= 0)
+               il->hw_ready = true;
+
+       D_INFO("hardware %s ready\n", (il->hw_ready) ? "" : "not");
+}
+
+static void
+il4965_prepare_card_hw(struct il_priv *il)
+{
+       int ret;
+
+       il->hw_ready = false;
+
+       il4965_set_hw_ready(il);
+       if (il->hw_ready)
+               return;
+
+       /* If HW is not ready, prepare the conditions to check again */
+       il_set_bit(il, CSR_HW_IF_CONFIG_REG, CSR_HW_IF_CONFIG_REG_PREPARE);
+
+       ret =
+           _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
+                        ~CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE,
+                        CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE, 150000);
+
+       /* HW should be ready by now, check again. */
+       if (ret != -ETIMEDOUT)
+               il4965_set_hw_ready(il);
+}
+
+#define MAX_HW_RESTARTS 5
+
+static int
+__il4965_up(struct il_priv *il)
+{
+       int i;
+       int ret;
+
+       if (test_bit(S_EXIT_PENDING, &il->status)) {
+               IL_WARN("Exit pending; will not bring the NIC up\n");
+               return -EIO;
+       }
+
+       if (!il->ucode_data_backup.v_addr || !il->ucode_data.v_addr) {
+               IL_ERR("ucode not available for device bringup\n");
+               return -EIO;
+       }
+
+       ret = il4965_alloc_bcast_station(il);
+       if (ret) {
+               il_dealloc_bcast_stations(il);
+               return ret;
+       }
+
+       il4965_prepare_card_hw(il);
+       if (!il->hw_ready) {
+               IL_ERR("HW not ready\n");
+               return -EIO;
+       }
+
+       /* If platform's RF_KILL switch is NOT set to KILL */
+       if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
+               clear_bit(S_RFKILL, &il->status);
+       else {
+               set_bit(S_RFKILL, &il->status);
+               wiphy_rfkill_set_hw_state(il->hw->wiphy, true);
+
+               il_enable_rfkill_int(il);
+               IL_WARN("Radio disabled by HW RF Kill switch\n");
+               return 0;
+       }
+
+       _il_wr(il, CSR_INT, 0xFFFFFFFF);
+
+       /* must be initialised before il_hw_nic_init */
+       il->cmd_queue = IL_DEFAULT_CMD_QUEUE_NUM;
+
+       ret = il4965_hw_nic_init(il);
+       if (ret) {
+               IL_ERR("Unable to init nic\n");
+               return ret;
+       }
+
+       /* make sure rfkill handshake bits are cleared */
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
+
+       /* clear (again), then enable host interrupts */
+       _il_wr(il, CSR_INT, 0xFFFFFFFF);
+       il_enable_interrupts(il);
+
+       /* really make sure rfkill handshake bits are cleared */
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
+
+       /* Copy original ucode data image from disk into backup cache.
+        * This will be used to initialize the on-board processor's
+        * data SRAM for a clean start when the runtime program first loads. */
+       memcpy(il->ucode_data_backup.v_addr, il->ucode_data.v_addr,
+              il->ucode_data.len);
+
+       for (i = 0; i < MAX_HW_RESTARTS; i++) {
+
+               /* load bootstrap state machine,
+                * load bootstrap program into processor's memory,
+                * prepare to load the "initialize" uCode */
+               ret = il->ops->load_ucode(il);
+
+               if (ret) {
+                       IL_ERR("Unable to set up bootstrap uCode: %d\n", ret);
+                       continue;
+               }
+
+               /* start card; "initialize" will load runtime ucode */
+               il4965_nic_start(il);
+
+               D_INFO(DRV_NAME " is coming up\n");
+
+               return 0;
+       }
+
+       set_bit(S_EXIT_PENDING, &il->status);
+       __il4965_down(il);
+       clear_bit(S_EXIT_PENDING, &il->status);
+
+       /* tried to restart and config the device for as long as our
+        * patience could withstand */
+       IL_ERR("Unable to initialize device after %d attempts.\n", i);
+       return -EIO;
+}
+
+/*****************************************************************************
+ *
+ * Workqueue callbacks
+ *
+ *****************************************************************************/
+
+static void
+il4965_bg_init_alive_start(struct work_struct *data)
+{
+       struct il_priv *il =
+           container_of(data, struct il_priv, init_alive_start.work);
+
+       mutex_lock(&il->mutex);
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               goto out;
+
+       il->ops->init_alive_start(il);
+out:
+       mutex_unlock(&il->mutex);
+}
+
+static void
+il4965_bg_alive_start(struct work_struct *data)
+{
+       struct il_priv *il =
+           container_of(data, struct il_priv, alive_start.work);
+
+       mutex_lock(&il->mutex);
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               goto out;
+
+       il4965_alive_start(il);
+out:
+       mutex_unlock(&il->mutex);
+}
+
+static void
+il4965_bg_run_time_calib_work(struct work_struct *work)
+{
+       struct il_priv *il = container_of(work, struct il_priv,
+                                         run_time_calib_work);
+
+       mutex_lock(&il->mutex);
+
+       if (test_bit(S_EXIT_PENDING, &il->status) ||
+           test_bit(S_SCANNING, &il->status)) {
+               mutex_unlock(&il->mutex);
+               return;
+       }
+
+       if (il->start_calib) {
+               il4965_chain_noise_calibration(il, (void *)&il->_4965.stats);
+               il4965_sensitivity_calibration(il, (void *)&il->_4965.stats);
+       }
+
+       mutex_unlock(&il->mutex);
+}
+
+static void
+il4965_bg_restart(struct work_struct *data)
+{
+       struct il_priv *il = container_of(data, struct il_priv, restart);
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
+               mutex_lock(&il->mutex);
+               il->is_open = 0;
+
+               __il4965_down(il);
+
+               mutex_unlock(&il->mutex);
+               il4965_cancel_deferred_work(il);
+               ieee80211_restart_hw(il->hw);
+       } else {
+               il4965_down(il);
+
+               mutex_lock(&il->mutex);
+               if (test_bit(S_EXIT_PENDING, &il->status)) {
+                       mutex_unlock(&il->mutex);
+                       return;
+               }
+
+               __il4965_up(il);
+               mutex_unlock(&il->mutex);
+       }
+}
+
+static void
+il4965_bg_rx_replenish(struct work_struct *data)
+{
+       struct il_priv *il = container_of(data, struct il_priv, rx_replenish);
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       mutex_lock(&il->mutex);
+       il4965_rx_replenish(il);
+       mutex_unlock(&il->mutex);
+}
+
+/*****************************************************************************
+ *
+ * mac80211 entry point functions
+ *
+ *****************************************************************************/
+
+#define UCODE_READY_TIMEOUT    (4 * HZ)
+
+/*
+ * Not a mac80211 entry point function, but it fits in with all the
+ * other mac80211 functions grouped here.
+ */
+static int
+il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length)
+{
+       int ret;
+       struct ieee80211_hw *hw = il->hw;
+
+       hw->rate_control_algorithm = "iwl-4965-rs";
+
+       /* Tell mac80211 our characteristics */
+       ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
+       ieee80211_hw_set(hw, SUPPORTS_PS);
+       ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
+       ieee80211_hw_set(hw, SPECTRUM_MGMT);
+       ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
+       ieee80211_hw_set(hw, SIGNAL_DBM);
+       ieee80211_hw_set(hw, AMPDU_AGGREGATION);
+       if (il->cfg->sku & IL_SKU_N)
+               hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS |
+                                      NL80211_FEATURE_STATIC_SMPS;
+
+       hw->sta_data_size = sizeof(struct il_station_priv);
+       hw->vif_data_size = sizeof(struct il_vif_priv);
+
+       hw->wiphy->interface_modes =
+           BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
+
+       hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
+       hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
+                                      REGULATORY_DISABLE_BEACON_HINTS;
+
+       /*
+        * For now, disable PS by default because it affects
+        * RX performance significantly.
+        */
+       hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
+
+       hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
+       /* we create the 802.11 header and a zero-length SSID element */
+       hw->wiphy->max_scan_ie_len = max_probe_length - 24 - 2;
+
+       /* Default value; 4 EDCA QOS priorities */
+       hw->queues = 4;
+
+       hw->max_listen_interval = IL_CONN_MAX_LISTEN_INTERVAL;
+
+       if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
+               il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
+                   &il->bands[IEEE80211_BAND_2GHZ];
+       if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
+               il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
+                   &il->bands[IEEE80211_BAND_5GHZ];
+
+       il_leds_init(il);
+
+       ret = ieee80211_register_hw(il->hw);
+       if (ret) {
+               IL_ERR("Failed to register hw (error %d)\n", ret);
+               return ret;
+       }
+       il->mac80211_registered = 1;
+
+       return 0;
+}
+
+int
+il4965_mac_start(struct ieee80211_hw *hw)
+{
+       struct il_priv *il = hw->priv;
+       int ret;
+
+       D_MAC80211("enter\n");
+
+       /* we should be verifying the device is ready to be opened */
+       mutex_lock(&il->mutex);
+       ret = __il4965_up(il);
+       mutex_unlock(&il->mutex);
+
+       if (ret)
+               return ret;
+
+       if (il_is_rfkill(il))
+               goto out;
+
+       D_INFO("Start UP work done.\n");
+
+       /* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
+        * mac80211 will not be run successfully. */
+       ret = wait_event_timeout(il->wait_command_queue,
+                                test_bit(S_READY, &il->status),
+                                UCODE_READY_TIMEOUT);
+       if (!ret) {
+               if (!test_bit(S_READY, &il->status)) {
+                       IL_ERR("START_ALIVE timeout after %dms.\n",
+                               jiffies_to_msecs(UCODE_READY_TIMEOUT));
+                       return -ETIMEDOUT;
+               }
+       }
+
+       il4965_led_enable(il);
+
+out:
+       il->is_open = 1;
+       D_MAC80211("leave\n");
+       return 0;
+}
+
+void
+il4965_mac_stop(struct ieee80211_hw *hw)
+{
+       struct il_priv *il = hw->priv;
+
+       D_MAC80211("enter\n");
+
+       if (!il->is_open)
+               return;
+
+       il->is_open = 0;
+
+       il4965_down(il);
+
+       flush_workqueue(il->workqueue);
+
+       /* User space software may expect getting rfkill changes
+        * even if interface is down */
+       _il_wr(il, CSR_INT, 0xFFFFFFFF);
+       il_enable_rfkill_int(il);
+
+       D_MAC80211("leave\n");
+}
+
+void
+il4965_mac_tx(struct ieee80211_hw *hw,
+             struct ieee80211_tx_control *control,
+             struct sk_buff *skb)
+{
+       struct il_priv *il = hw->priv;
+
+       D_MACDUMP("enter\n");
+
+       D_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
+            ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
+
+       if (il4965_tx_skb(il, control->sta, skb))
+               dev_kfree_skb_any(skb);
+
+       D_MACDUMP("leave\n");
+}
+
+void
+il4965_mac_update_tkip_key(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                          struct ieee80211_key_conf *keyconf,
+                          struct ieee80211_sta *sta, u32 iv32, u16 * phase1key)
+{
+       struct il_priv *il = hw->priv;
+
+       D_MAC80211("enter\n");
+
+       il4965_update_tkip_key(il, keyconf, sta, iv32, phase1key);
+
+       D_MAC80211("leave\n");
+}
+
+int
+il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
+                  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
+                  struct ieee80211_key_conf *key)
+{
+       struct il_priv *il = hw->priv;
+       int ret;
+       u8 sta_id;
+       bool is_default_wep_key = false;
+
+       D_MAC80211("enter\n");
+
+       if (il->cfg->mod_params->sw_crypto) {
+               D_MAC80211("leave - hwcrypto disabled\n");
+               return -EOPNOTSUPP;
+       }
+
+       /*
+        * To support IBSS RSN, don't program group keys in IBSS, the
+        * hardware will then not attempt to decrypt the frames.
+        */
+       if (vif->type == NL80211_IFTYPE_ADHOC &&
+           !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
+               D_MAC80211("leave - ad-hoc group key\n");
+               return -EOPNOTSUPP;
+       }
+
+       sta_id = il_sta_id_or_broadcast(il, sta);
+       if (sta_id == IL_INVALID_STATION)
+               return -EINVAL;
+
+       mutex_lock(&il->mutex);
+       il_scan_cancel_timeout(il, 100);
+
+       /*
+        * If we are getting WEP group key and we didn't receive any key mapping
+        * so far, we are in legacy wep mode (group key only), otherwise we are
+        * in 1X mode.
+        * In legacy wep mode, we use another host command to the uCode.
+        */
+       if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
+            key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
+               if (cmd == SET_KEY)
+                       is_default_wep_key = !il->_4965.key_mapping_keys;
+               else
+                       is_default_wep_key =
+                           (key->hw_key_idx == HW_KEY_DEFAULT);
+       }
+
+       switch (cmd) {
+       case SET_KEY:
+               if (is_default_wep_key)
+                       ret = il4965_set_default_wep_key(il, key);
+               else
+                       ret = il4965_set_dynamic_key(il, key, sta_id);
+
+               D_MAC80211("enable hwcrypto key\n");
+               break;
+       case DISABLE_KEY:
+               if (is_default_wep_key)
+                       ret = il4965_remove_default_wep_key(il, key);
+               else
+                       ret = il4965_remove_dynamic_key(il, key, sta_id);
+
+               D_MAC80211("disable hwcrypto key\n");
+               break;
+       default:
+               ret = -EINVAL;
+       }
+
+       mutex_unlock(&il->mutex);
+       D_MAC80211("leave\n");
+
+       return ret;
+}
+
+int
+il4965_mac_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                       enum ieee80211_ampdu_mlme_action action,
+                       struct ieee80211_sta *sta, u16 tid, u16 * ssn,
+                       u8 buf_size, bool amsdu)
+{
+       struct il_priv *il = hw->priv;
+       int ret = -EINVAL;
+
+       D_HT("A-MPDU action on addr %pM tid %d\n", sta->addr, tid);
+
+       if (!(il->cfg->sku & IL_SKU_N))
+               return -EACCES;
+
+       mutex_lock(&il->mutex);
+
+       switch (action) {
+       case IEEE80211_AMPDU_RX_START:
+               D_HT("start Rx\n");
+               ret = il4965_sta_rx_agg_start(il, sta, tid, *ssn);
+               break;
+       case IEEE80211_AMPDU_RX_STOP:
+               D_HT("stop Rx\n");
+               ret = il4965_sta_rx_agg_stop(il, sta, tid);
+               if (test_bit(S_EXIT_PENDING, &il->status))
+                       ret = 0;
+               break;
+       case IEEE80211_AMPDU_TX_START:
+               D_HT("start Tx\n");
+               ret = il4965_tx_agg_start(il, vif, sta, tid, ssn);
+               break;
+       case IEEE80211_AMPDU_TX_STOP_CONT:
+       case IEEE80211_AMPDU_TX_STOP_FLUSH:
+       case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
+               D_HT("stop Tx\n");
+               ret = il4965_tx_agg_stop(il, vif, sta, tid);
+               if (test_bit(S_EXIT_PENDING, &il->status))
+                       ret = 0;
+               break;
+       case IEEE80211_AMPDU_TX_OPERATIONAL:
+               ret = 0;
+               break;
+       }
+       mutex_unlock(&il->mutex);
+
+       return ret;
+}
+
+int
+il4965_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                  struct ieee80211_sta *sta)
+{
+       struct il_priv *il = hw->priv;
+       struct il_station_priv *sta_priv = (void *)sta->drv_priv;
+       bool is_ap = vif->type == NL80211_IFTYPE_STATION;
+       int ret;
+       u8 sta_id;
+
+       D_INFO("received request to add station %pM\n", sta->addr);
+       mutex_lock(&il->mutex);
+       D_INFO("proceeding to add station %pM\n", sta->addr);
+       sta_priv->common.sta_id = IL_INVALID_STATION;
+
+       atomic_set(&sta_priv->pending_frames, 0);
+
+       ret =
+           il_add_station_common(il, sta->addr, is_ap, sta, &sta_id);
+       if (ret) {
+               IL_ERR("Unable to add station %pM (%d)\n", sta->addr, ret);
+               /* Should we return success if return code is EEXIST ? */
+               mutex_unlock(&il->mutex);
+               return ret;
+       }
+
+       sta_priv->common.sta_id = sta_id;
+
+       /* Initialize rate scaling */
+       D_INFO("Initializing rate scaling for station %pM\n", sta->addr);
+       il4965_rs_rate_init(il, sta, sta_id);
+       mutex_unlock(&il->mutex);
+
+       return 0;
+}
+
+void
+il4965_mac_channel_switch(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                         struct ieee80211_channel_switch *ch_switch)
+{
+       struct il_priv *il = hw->priv;
+       const struct il_channel_info *ch_info;
+       struct ieee80211_conf *conf = &hw->conf;
+       struct ieee80211_channel *channel = ch_switch->chandef.chan;
+       struct il_ht_config *ht_conf = &il->current_ht_config;
+       u16 ch;
+
+       D_MAC80211("enter\n");
+
+       mutex_lock(&il->mutex);
+
+       if (il_is_rfkill(il))
+               goto out;
+
+       if (test_bit(S_EXIT_PENDING, &il->status) ||
+           test_bit(S_SCANNING, &il->status) ||
+           test_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
+               goto out;
+
+       if (!il_is_associated(il))
+               goto out;
+
+       if (!il->ops->set_channel_switch)
+               goto out;
+
+       ch = channel->hw_value;
+       if (le16_to_cpu(il->active.channel) == ch)
+               goto out;
+
+       ch_info = il_get_channel_info(il, channel->band, ch);
+       if (!il_is_channel_valid(ch_info)) {
+               D_MAC80211("invalid channel\n");
+               goto out;
+       }
+
+       spin_lock_irq(&il->lock);
+
+       il->current_ht_config.smps = conf->smps_mode;
+
+       /* Configure HT40 channels */
+       switch (cfg80211_get_chandef_type(&ch_switch->chandef)) {
+       case NL80211_CHAN_NO_HT:
+       case NL80211_CHAN_HT20:
+               il->ht.is_40mhz = false;
+               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
+               break;
+       case NL80211_CHAN_HT40MINUS:
+               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+               il->ht.is_40mhz = true;
+               break;
+       case NL80211_CHAN_HT40PLUS:
+               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
+               il->ht.is_40mhz = true;
+               break;
+       }
+
+       if ((le16_to_cpu(il->staging.channel) != ch))
+               il->staging.flags = 0;
+
+       il_set_rxon_channel(il, channel);
+       il_set_rxon_ht(il, ht_conf);
+       il_set_flags_for_band(il, channel->band, il->vif);
+
+       spin_unlock_irq(&il->lock);
+
+       il_set_rate(il);
+       /*
+        * at this point, staging_rxon has the
+        * configuration for channel switch
+        */
+       set_bit(S_CHANNEL_SWITCH_PENDING, &il->status);
+       il->switch_channel = cpu_to_le16(ch);
+       if (il->ops->set_channel_switch(il, ch_switch)) {
+               clear_bit(S_CHANNEL_SWITCH_PENDING, &il->status);
+               il->switch_channel = 0;
+               ieee80211_chswitch_done(il->vif, false);
+       }
+
+out:
+       mutex_unlock(&il->mutex);
+       D_MAC80211("leave\n");
+}
+
+void
+il4965_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
+                       unsigned int *total_flags, u64 multicast)
+{
+       struct il_priv *il = hw->priv;
+       __le32 filter_or = 0, filter_nand = 0;
+
+#define CHK(test, flag)        do { \
+       if (*total_flags & (test))              \
+               filter_or |= (flag);            \
+       else                                    \
+               filter_nand |= (flag);          \
+       } while (0)
+
+       D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n", changed_flags,
+                  *total_flags);
+
+       CHK(FIF_OTHER_BSS, RXON_FILTER_PROMISC_MSK);
+       /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
+       CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
+       CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
+
+#undef CHK
+
+       mutex_lock(&il->mutex);
+
+       il->staging.filter_flags &= ~filter_nand;
+       il->staging.filter_flags |= filter_or;
+
+       /*
+        * Not committing directly because hardware can perform a scan,
+        * but we'll eventually commit the filter flags change anyway.
+        */
+
+       mutex_unlock(&il->mutex);
+
+       /*
+        * Receiving all multicast frames is always enabled by the
+        * default flags setup in il_connection_init_rx_config()
+        * since we currently do not support programming multicast
+        * filters into the device.
+        */
+       *total_flags &=
+           FIF_OTHER_BSS | FIF_ALLMULTI |
+           FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
+}
+
+/*****************************************************************************
+ *
+ * driver setup and teardown
+ *
+ *****************************************************************************/
+
+static void
+il4965_bg_txpower_work(struct work_struct *work)
+{
+       struct il_priv *il = container_of(work, struct il_priv,
+                                         txpower_work);
+
+       mutex_lock(&il->mutex);
+
+       /* If a scan happened to start before we got here
+        * then just return; the stats notification will
+        * kick off another scheduled work to compensate for
+        * any temperature delta we missed here. */
+       if (test_bit(S_EXIT_PENDING, &il->status) ||
+           test_bit(S_SCANNING, &il->status))
+               goto out;
+
+       /* Regardless of if we are associated, we must reconfigure the
+        * TX power since frames can be sent on non-radar channels while
+        * not associated */
+       il->ops->send_tx_power(il);
+
+       /* Update last_temperature to keep is_calib_needed from running
+        * when it isn't needed... */
+       il->last_temperature = il->temperature;
+out:
+       mutex_unlock(&il->mutex);
+}
+
+static void
+il4965_setup_deferred_work(struct il_priv *il)
+{
+       il->workqueue = create_singlethread_workqueue(DRV_NAME);
+
+       init_waitqueue_head(&il->wait_command_queue);
+
+       INIT_WORK(&il->restart, il4965_bg_restart);
+       INIT_WORK(&il->rx_replenish, il4965_bg_rx_replenish);
+       INIT_WORK(&il->run_time_calib_work, il4965_bg_run_time_calib_work);
+       INIT_DELAYED_WORK(&il->init_alive_start, il4965_bg_init_alive_start);
+       INIT_DELAYED_WORK(&il->alive_start, il4965_bg_alive_start);
+
+       il_setup_scan_deferred_work(il);
+
+       INIT_WORK(&il->txpower_work, il4965_bg_txpower_work);
+
+       setup_timer(&il->stats_periodic, il4965_bg_stats_periodic,
+                   (unsigned long)il);
+
+       setup_timer(&il->watchdog, il_bg_watchdog, (unsigned long)il);
+
+       tasklet_init(&il->irq_tasklet,
+                    (void (*)(unsigned long))il4965_irq_tasklet,
+                    (unsigned long)il);
+}
+
+static void
+il4965_cancel_deferred_work(struct il_priv *il)
+{
+       cancel_work_sync(&il->txpower_work);
+       cancel_delayed_work_sync(&il->init_alive_start);
+       cancel_delayed_work(&il->alive_start);
+       cancel_work_sync(&il->run_time_calib_work);
+
+       il_cancel_scan_deferred_work(il);
+
+       del_timer_sync(&il->stats_periodic);
+}
+
+static void
+il4965_init_hw_rates(struct il_priv *il, struct ieee80211_rate *rates)
+{
+       int i;
+
+       for (i = 0; i < RATE_COUNT_LEGACY; i++) {
+               rates[i].bitrate = il_rates[i].ieee * 5;
+               rates[i].hw_value = i;  /* Rate scaling will work on idxes */
+               rates[i].hw_value_short = i;
+               rates[i].flags = 0;
+               if ((i >= IL_FIRST_CCK_RATE) && (i <= IL_LAST_CCK_RATE)) {
+                       /*
+                        * If CCK != 1M then set short preamble rate flag.
+                        */
+                       rates[i].flags |=
+                           (il_rates[i].plcp ==
+                            RATE_1M_PLCP) ? 0 : IEEE80211_RATE_SHORT_PREAMBLE;
+               }
+       }
+}
+
+/*
+ * Acquire il->lock before calling this function !
+ */
+void
+il4965_set_wr_ptrs(struct il_priv *il, int txq_id, u32 idx)
+{
+       il_wr(il, HBUS_TARG_WRPTR, (idx & 0xff) | (txq_id << 8));
+       il_wr_prph(il, IL49_SCD_QUEUE_RDPTR(txq_id), idx);
+}
+
+void
+il4965_tx_queue_set_status(struct il_priv *il, struct il_tx_queue *txq,
+                          int tx_fifo_id, int scd_retry)
+{
+       int txq_id = txq->q.id;
+
+       /* Find out whether to activate Tx queue */
+       int active = test_bit(txq_id, &il->txq_ctx_active_msk) ? 1 : 0;
+
+       /* Set up and activate */
+       il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
+                  (active << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
+                  (tx_fifo_id << IL49_SCD_QUEUE_STTS_REG_POS_TXF) |
+                  (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_WSL) |
+                  (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACK) |
+                  IL49_SCD_QUEUE_STTS_REG_MSK);
+
+       txq->sched_retry = scd_retry;
+
+       D_INFO("%s %s Queue %d on AC %d\n", active ? "Activate" : "Deactivate",
+              scd_retry ? "BA" : "AC", txq_id, tx_fifo_id);
+}
+
+static const struct ieee80211_ops il4965_mac_ops = {
+       .tx = il4965_mac_tx,
+       .start = il4965_mac_start,
+       .stop = il4965_mac_stop,
+       .add_interface = il_mac_add_interface,
+       .remove_interface = il_mac_remove_interface,
+       .change_interface = il_mac_change_interface,
+       .config = il_mac_config,
+       .configure_filter = il4965_configure_filter,
+       .set_key = il4965_mac_set_key,
+       .update_tkip_key = il4965_mac_update_tkip_key,
+       .conf_tx = il_mac_conf_tx,
+       .reset_tsf = il_mac_reset_tsf,
+       .bss_info_changed = il_mac_bss_info_changed,
+       .ampdu_action = il4965_mac_ampdu_action,
+       .hw_scan = il_mac_hw_scan,
+       .sta_add = il4965_mac_sta_add,
+       .sta_remove = il_mac_sta_remove,
+       .channel_switch = il4965_mac_channel_switch,
+       .tx_last_beacon = il_mac_tx_last_beacon,
+       .flush = il_mac_flush,
+};
+
+static int
+il4965_init_drv(struct il_priv *il)
+{
+       int ret;
+
+       spin_lock_init(&il->sta_lock);
+       spin_lock_init(&il->hcmd_lock);
+
+       INIT_LIST_HEAD(&il->free_frames);
+
+       mutex_init(&il->mutex);
+
+       il->ieee_channels = NULL;
+       il->ieee_rates = NULL;
+       il->band = IEEE80211_BAND_2GHZ;
+
+       il->iw_mode = NL80211_IFTYPE_STATION;
+       il->current_ht_config.smps = IEEE80211_SMPS_STATIC;
+       il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
+
+       /* initialize force reset */
+       il->force_reset.reset_duration = IL_DELAY_NEXT_FORCE_FW_RELOAD;
+
+       /* Choose which receivers/antennas to use */
+       if (il->ops->set_rxon_chain)
+               il->ops->set_rxon_chain(il);
+
+       il_init_scan_params(il);
+
+       ret = il_init_channel_map(il);
+       if (ret) {
+               IL_ERR("initializing regulatory failed: %d\n", ret);
+               goto err;
+       }
+
+       ret = il_init_geos(il);
+       if (ret) {
+               IL_ERR("initializing geos failed: %d\n", ret);
+               goto err_free_channel_map;
+       }
+       il4965_init_hw_rates(il, il->ieee_rates);
+
+       return 0;
+
+err_free_channel_map:
+       il_free_channel_map(il);
+err:
+       return ret;
+}
+
+static void
+il4965_uninit_drv(struct il_priv *il)
+{
+       il_free_geos(il);
+       il_free_channel_map(il);
+       kfree(il->scan_cmd);
+}
+
+static void
+il4965_hw_detect(struct il_priv *il)
+{
+       il->hw_rev = _il_rd(il, CSR_HW_REV);
+       il->hw_wa_rev = _il_rd(il, CSR_HW_REV_WA_REG);
+       il->rev_id = il->pci_dev->revision;
+       D_INFO("HW Revision ID = 0x%X\n", il->rev_id);
+}
+
+static struct il_sensitivity_ranges il4965_sensitivity = {
+       .min_nrg_cck = 97,
+       .max_nrg_cck = 0,       /* not used, set to 0 */
+
+       .auto_corr_min_ofdm = 85,
+       .auto_corr_min_ofdm_mrc = 170,
+       .auto_corr_min_ofdm_x1 = 105,
+       .auto_corr_min_ofdm_mrc_x1 = 220,
+
+       .auto_corr_max_ofdm = 120,
+       .auto_corr_max_ofdm_mrc = 210,
+       .auto_corr_max_ofdm_x1 = 140,
+       .auto_corr_max_ofdm_mrc_x1 = 270,
+
+       .auto_corr_min_cck = 125,
+       .auto_corr_max_cck = 200,
+       .auto_corr_min_cck_mrc = 200,
+       .auto_corr_max_cck_mrc = 400,
+
+       .nrg_th_cck = 100,
+       .nrg_th_ofdm = 100,
+
+       .barker_corr_th_min = 190,
+       .barker_corr_th_min_mrc = 390,
+       .nrg_th_cca = 62,
+};
+
+static void
+il4965_set_hw_params(struct il_priv *il)
+{
+       il->hw_params.bcast_id = IL4965_BROADCAST_ID;
+       il->hw_params.max_rxq_size = RX_QUEUE_SIZE;
+       il->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
+       if (il->cfg->mod_params->amsdu_size_8K)
+               il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_8K);
+       else
+               il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_4K);
+
+       il->hw_params.max_beacon_itrvl = IL_MAX_UCODE_BEACON_INTERVAL;
+
+       if (il->cfg->mod_params->disable_11n)
+               il->cfg->sku &= ~IL_SKU_N;
+
+       if (il->cfg->mod_params->num_of_queues >= IL_MIN_NUM_QUEUES &&
+           il->cfg->mod_params->num_of_queues <= IL49_NUM_QUEUES)
+               il->cfg->num_of_queues =
+                   il->cfg->mod_params->num_of_queues;
+
+       il->hw_params.max_txq_num = il->cfg->num_of_queues;
+       il->hw_params.dma_chnl_num = FH49_TCSR_CHNL_NUM;
+       il->hw_params.scd_bc_tbls_size =
+           il->cfg->num_of_queues *
+           sizeof(struct il4965_scd_bc_tbl);
+
+       il->hw_params.tfd_size = sizeof(struct il_tfd);
+       il->hw_params.max_stations = IL4965_STATION_COUNT;
+       il->hw_params.max_data_size = IL49_RTC_DATA_SIZE;
+       il->hw_params.max_inst_size = IL49_RTC_INST_SIZE;
+       il->hw_params.max_bsm_size = BSM_SRAM_SIZE;
+       il->hw_params.ht40_channel = BIT(IEEE80211_BAND_5GHZ);
+
+       il->hw_params.rx_wrt_ptr_reg = FH49_RSCSR_CHNL0_WPTR;
+
+       il->hw_params.tx_chains_num = il4965_num_of_ant(il->cfg->valid_tx_ant);
+       il->hw_params.rx_chains_num = il4965_num_of_ant(il->cfg->valid_rx_ant);
+       il->hw_params.valid_tx_ant = il->cfg->valid_tx_ant;
+       il->hw_params.valid_rx_ant = il->cfg->valid_rx_ant;
+
+       il->hw_params.ct_kill_threshold =
+          CELSIUS_TO_KELVIN(CT_KILL_THRESHOLD_LEGACY);
+
+       il->hw_params.sens = &il4965_sensitivity;
+       il->hw_params.beacon_time_tsf_bits = IL4965_EXT_BEACON_TIME_POS;
+}
+
+static int
+il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+       int err = 0;
+       struct il_priv *il;
+       struct ieee80211_hw *hw;
+       struct il_cfg *cfg = (struct il_cfg *)(ent->driver_data);
+       unsigned long flags;
+       u16 pci_cmd;
+
+       /************************
+        * 1. Allocating HW data
+        ************************/
+
+       hw = ieee80211_alloc_hw(sizeof(struct il_priv), &il4965_mac_ops);
+       if (!hw) {
+               err = -ENOMEM;
+               goto out;
+       }
+       il = hw->priv;
+       il->hw = hw;
+       SET_IEEE80211_DEV(hw, &pdev->dev);
+
+       D_INFO("*** LOAD DRIVER ***\n");
+       il->cfg = cfg;
+       il->ops = &il4965_ops;
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       il->debugfs_ops = &il4965_debugfs_ops;
+#endif
+       il->pci_dev = pdev;
+       il->inta_mask = CSR_INI_SET_MASK;
+
+       /**************************
+        * 2. Initializing PCI bus
+        **************************/
+       pci_disable_link_state(pdev,
+                              PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
+                              PCIE_LINK_STATE_CLKPM);
+
+       if (pci_enable_device(pdev)) {
+               err = -ENODEV;
+               goto out_ieee80211_free_hw;
+       }
+
+       pci_set_master(pdev);
+
+       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
+       if (!err)
+               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
+       if (err) {
+               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               if (!err)
+                       err =
+                           pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+               /* both attempts failed: */
+               if (err) {
+                       IL_WARN("No suitable DMA available.\n");
+                       goto out_pci_disable_device;
+               }
+       }
+
+       err = pci_request_regions(pdev, DRV_NAME);
+       if (err)
+               goto out_pci_disable_device;
+
+       pci_set_drvdata(pdev, il);
+
+       /***********************
+        * 3. Read REV register
+        ***********************/
+       il->hw_base = pci_ioremap_bar(pdev, 0);
+       if (!il->hw_base) {
+               err = -ENODEV;
+               goto out_pci_release_regions;
+       }
+
+       D_INFO("pci_resource_len = 0x%08llx\n",
+              (unsigned long long)pci_resource_len(pdev, 0));
+       D_INFO("pci_resource_base = %p\n", il->hw_base);
+
+       /* these spin locks will be used in apm_ops.init and EEPROM access
+        * we should init now
+        */
+       spin_lock_init(&il->reg_lock);
+       spin_lock_init(&il->lock);
+
+       /*
+        * stop and reset the on-board processor just in case it is in a
+        * strange state ... like being left stranded by a primary kernel
+        * and this is now the kdump kernel trying to start up
+        */
+       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
+
+       il4965_hw_detect(il);
+       IL_INFO("Detected %s, REV=0x%X\n", il->cfg->name, il->hw_rev);
+
+       /* We disable the RETRY_TIMEOUT register (0x41) to keep
+        * PCI Tx retries from interfering with C3 CPU state */
+       pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
+
+       il4965_prepare_card_hw(il);
+       if (!il->hw_ready) {
+               IL_WARN("Failed, HW not ready\n");
+               err = -EIO;
+               goto out_iounmap;
+       }
+
+       /*****************
+        * 4. Read EEPROM
+        *****************/
+       /* Read the EEPROM */
+       err = il_eeprom_init(il);
+       if (err) {
+               IL_ERR("Unable to init EEPROM\n");
+               goto out_iounmap;
+       }
+       err = il4965_eeprom_check_version(il);
+       if (err)
+               goto out_free_eeprom;
+
+       /* extract MAC Address */
+       il4965_eeprom_get_mac(il, il->addresses[0].addr);
+       D_INFO("MAC address: %pM\n", il->addresses[0].addr);
+       il->hw->wiphy->addresses = il->addresses;
+       il->hw->wiphy->n_addresses = 1;
+
+       /************************
+        * 5. Setup HW constants
+        ************************/
+       il4965_set_hw_params(il);
+
+       /*******************
+        * 6. Setup il
+        *******************/
+
+       err = il4965_init_drv(il);
+       if (err)
+               goto out_free_eeprom;
+       /* At this point both hw and il are initialized. */
+
+       /********************
+        * 7. Setup services
+        ********************/
+       spin_lock_irqsave(&il->lock, flags);
+       il_disable_interrupts(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       pci_enable_msi(il->pci_dev);
+
+       err = request_irq(il->pci_dev->irq, il_isr, IRQF_SHARED, DRV_NAME, il);
+       if (err) {
+               IL_ERR("Error allocating IRQ %d\n", il->pci_dev->irq);
+               goto out_disable_msi;
+       }
+
+       il4965_setup_deferred_work(il);
+       il4965_setup_handlers(il);
+
+       /*********************************************
+        * 8. Enable interrupts and read RFKILL state
+        *********************************************/
+
+       /* enable rfkill interrupt: hw bug w/a */
+       pci_read_config_word(il->pci_dev, PCI_COMMAND, &pci_cmd);
+       if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
+               pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
+               pci_write_config_word(il->pci_dev, PCI_COMMAND, pci_cmd);
+       }
+
+       il_enable_rfkill_int(il);
+
+       /* If platform's RF_KILL switch is NOT set to KILL */
+       if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
+               clear_bit(S_RFKILL, &il->status);
+       else
+               set_bit(S_RFKILL, &il->status);
+
+       wiphy_rfkill_set_hw_state(il->hw->wiphy,
+                                 test_bit(S_RFKILL, &il->status));
+
+       il_power_initialize(il);
+
+       init_completion(&il->_4965.firmware_loading_complete);
+
+       err = il4965_request_firmware(il, true);
+       if (err)
+               goto out_destroy_workqueue;
+
+       return 0;
+
+out_destroy_workqueue:
+       destroy_workqueue(il->workqueue);
+       il->workqueue = NULL;
+       free_irq(il->pci_dev->irq, il);
+out_disable_msi:
+       pci_disable_msi(il->pci_dev);
+       il4965_uninit_drv(il);
+out_free_eeprom:
+       il_eeprom_free(il);
+out_iounmap:
+       iounmap(il->hw_base);
+out_pci_release_regions:
+       pci_release_regions(pdev);
+out_pci_disable_device:
+       pci_disable_device(pdev);
+out_ieee80211_free_hw:
+       ieee80211_free_hw(il->hw);
+out:
+       return err;
+}
+
+static void
+il4965_pci_remove(struct pci_dev *pdev)
+{
+       struct il_priv *il = pci_get_drvdata(pdev);
+       unsigned long flags;
+
+       if (!il)
+               return;
+
+       wait_for_completion(&il->_4965.firmware_loading_complete);
+
+       D_INFO("*** UNLOAD DRIVER ***\n");
+
+       il_dbgfs_unregister(il);
+       sysfs_remove_group(&pdev->dev.kobj, &il_attribute_group);
+
+       /* ieee80211_unregister_hw call wil cause il_mac_stop to
+        * to be called and il4965_down since we are removing the device
+        * we need to set S_EXIT_PENDING bit.
+        */
+       set_bit(S_EXIT_PENDING, &il->status);
+
+       il_leds_exit(il);
+
+       if (il->mac80211_registered) {
+               ieee80211_unregister_hw(il->hw);
+               il->mac80211_registered = 0;
+       } else {
+               il4965_down(il);
+       }
+
+       /*
+        * Make sure device is reset to low power before unloading driver.
+        * This may be redundant with il4965_down(), but there are paths to
+        * run il4965_down() without calling apm_ops.stop(), and there are
+        * paths to avoid running il4965_down() at all before leaving driver.
+        * This (inexpensive) call *makes sure* device is reset.
+        */
+       il_apm_stop(il);
+
+       /* make sure we flush any pending irq or
+        * tasklet for the driver
+        */
+       spin_lock_irqsave(&il->lock, flags);
+       il_disable_interrupts(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       il4965_synchronize_irq(il);
+
+       il4965_dealloc_ucode_pci(il);
+
+       if (il->rxq.bd)
+               il4965_rx_queue_free(il, &il->rxq);
+       il4965_hw_txq_ctx_free(il);
+
+       il_eeprom_free(il);
+
+       /*netif_stop_queue(dev); */
+       flush_workqueue(il->workqueue);
+
+       /* ieee80211_unregister_hw calls il_mac_stop, which flushes
+        * il->workqueue... so we can't take down the workqueue
+        * until now... */
+       destroy_workqueue(il->workqueue);
+       il->workqueue = NULL;
+
+       free_irq(il->pci_dev->irq, il);
+       pci_disable_msi(il->pci_dev);
+       iounmap(il->hw_base);
+       pci_release_regions(pdev);
+       pci_disable_device(pdev);
+
+       il4965_uninit_drv(il);
+
+       dev_kfree_skb(il->beacon_skb);
+
+       ieee80211_free_hw(il->hw);
+}
+
+/*
+ * Activate/Deactivate Tx DMA/FIFO channels according tx fifos mask
+ * must be called under il->lock and mac access
+ */
+void
+il4965_txq_set_sched(struct il_priv *il, u32 mask)
+{
+       il_wr_prph(il, IL49_SCD_TXFACT, mask);
+}
+
+/*****************************************************************************
+ *
+ * driver and module entry point
+ *
+ *****************************************************************************/
+
+/* Hardware specific file defines the PCI IDs table for that hardware module */
+static const struct pci_device_id il4965_hw_card_ids[] = {
+       {IL_PCI_DEVICE(0x4229, PCI_ANY_ID, il4965_cfg)},
+       {IL_PCI_DEVICE(0x4230, PCI_ANY_ID, il4965_cfg)},
+       {0}
+};
+MODULE_DEVICE_TABLE(pci, il4965_hw_card_ids);
+
+static struct pci_driver il4965_driver = {
+       .name = DRV_NAME,
+       .id_table = il4965_hw_card_ids,
+       .probe = il4965_pci_probe,
+       .remove = il4965_pci_remove,
+       .driver.pm = IL_LEGACY_PM_OPS,
+};
+
+static int __init
+il4965_init(void)
+{
+
+       int ret;
+       pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
+       pr_info(DRV_COPYRIGHT "\n");
+
+       ret = il4965_rate_control_register();
+       if (ret) {
+               pr_err("Unable to register rate control algorithm: %d\n", ret);
+               return ret;
+       }
+
+       ret = pci_register_driver(&il4965_driver);
+       if (ret) {
+               pr_err("Unable to initialize PCI module\n");
+               goto error_register;
+       }
+
+       return ret;
+
+error_register:
+       il4965_rate_control_unregister();
+       return ret;
+}
+
+static void __exit
+il4965_exit(void)
+{
+       pci_unregister_driver(&il4965_driver);
+       il4965_rate_control_unregister();
+}
+
+module_exit(il4965_exit);
+module_init(il4965_init);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+module_param_named(debug, il_debug_level, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "debug output mask");
+#endif
+
+module_param_named(swcrypto, il4965_mod_params.sw_crypto, int, S_IRUGO);
+MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
+module_param_named(queues_num, il4965_mod_params.num_of_queues, int, S_IRUGO);
+MODULE_PARM_DESC(queues_num, "number of hw queues.");
+module_param_named(11n_disable, il4965_mod_params.disable_11n, int, S_IRUGO);
+MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
+module_param_named(amsdu_size_8K, il4965_mod_params.amsdu_size_8K, int,
+                  S_IRUGO);
+MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size (default 0 [disabled])");
+module_param_named(fw_restart, il4965_mod_params.restart_fw, int, S_IRUGO);
+MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
diff --git a/drivers/net/wireless/intel/iwlegacy/4965-rs.c b/drivers/net/wireless/intel/iwlegacy/4965-rs.c
new file mode 100644 (file)
index 0000000..bac60b2
--- /dev/null
@@ -0,0 +1,2835 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+#include <linux/kernel.h>
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+#include <net/mac80211.h>
+
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/delay.h>
+
+#include <linux/workqueue.h>
+
+#include "common.h"
+#include "4965.h"
+
+#define IL4965_RS_NAME "iwl-4965-rs"
+
+#define NUM_TRY_BEFORE_ANT_TOGGLE 1
+#define IL_NUMBER_TRY      1
+#define IL_HT_NUMBER_TRY   3
+
+#define RATE_MAX_WINDOW                62      /* # tx in history win */
+#define RATE_MIN_FAILURE_TH            6       /* min failures to calc tpt */
+#define RATE_MIN_SUCCESS_TH            8       /* min successes to calc tpt */
+
+/* max allowed rate miss before sync LQ cmd */
+#define IL_MISSED_RATE_MAX             15
+/* max time to accum history 2 seconds */
+#define RATE_SCALE_FLUSH_INTVL   (3*HZ)
+
+static u8 rs_ht_to_legacy[] = {
+       RATE_6M_IDX, RATE_6M_IDX,
+       RATE_6M_IDX, RATE_6M_IDX,
+       RATE_6M_IDX,
+       RATE_6M_IDX, RATE_9M_IDX,
+       RATE_12M_IDX, RATE_18M_IDX,
+       RATE_24M_IDX, RATE_36M_IDX,
+       RATE_48M_IDX, RATE_54M_IDX
+};
+
+static const u8 ant_toggle_lookup[] = {
+       /*ANT_NONE -> */ ANT_NONE,
+       /*ANT_A    -> */ ANT_B,
+       /*ANT_B    -> */ ANT_C,
+       /*ANT_AB   -> */ ANT_BC,
+       /*ANT_C    -> */ ANT_A,
+       /*ANT_AC   -> */ ANT_AB,
+       /*ANT_BC   -> */ ANT_AC,
+       /*ANT_ABC  -> */ ANT_ABC,
+};
+
+#define IL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np)    \
+       [RATE_##r##M_IDX] = { RATE_##r##M_PLCP,      \
+                                   RATE_SISO_##s##M_PLCP, \
+                                   RATE_MIMO2_##s##M_PLCP,\
+                                   RATE_##r##M_IEEE,      \
+                                   RATE_##ip##M_IDX,    \
+                                   RATE_##in##M_IDX,    \
+                                   RATE_##rp##M_IDX,    \
+                                   RATE_##rn##M_IDX,    \
+                                   RATE_##pp##M_IDX,    \
+                                   RATE_##np##M_IDX }
+
+/*
+ * Parameter order:
+ *   rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
+ *
+ * If there isn't a valid next or previous rate then INV is used which
+ * maps to RATE_INVALID
+ *
+ */
+const struct il_rate_info il_rates[RATE_COUNT] = {
+       IL_DECLARE_RATE_INFO(1, INV, INV, 2, INV, 2, INV, 2),   /*  1mbps */
+       IL_DECLARE_RATE_INFO(2, INV, 1, 5, 1, 5, 1, 5),         /*  2mbps */
+       IL_DECLARE_RATE_INFO(5, INV, 2, 6, 2, 11, 2, 11),       /*5.5mbps */
+       IL_DECLARE_RATE_INFO(11, INV, 9, 12, 9, 12, 5, 18),     /* 11mbps */
+       IL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11),         /*  6mbps */
+       IL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11),        /*  9mbps */
+       IL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18),   /* 12mbps */
+       IL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24),   /* 18mbps */
+       IL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36),   /* 24mbps */
+       IL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48),   /* 36mbps */
+       IL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54),   /* 48mbps */
+       IL_DECLARE_RATE_INFO(54, 54, 48, INV, 48, INV, 48, INV),/* 54mbps */
+       IL_DECLARE_RATE_INFO(60, 60, 48, INV, 48, INV, 48, INV),/* 60mbps */
+};
+
+static int
+il4965_hwrate_to_plcp_idx(u32 rate_n_flags)
+{
+       int idx = 0;
+
+       /* HT rate format */
+       if (rate_n_flags & RATE_MCS_HT_MSK) {
+               idx = (rate_n_flags & 0xff);
+
+               if (idx >= RATE_MIMO2_6M_PLCP)
+                       idx = idx - RATE_MIMO2_6M_PLCP;
+
+               idx += IL_FIRST_OFDM_RATE;
+               /* skip 9M not supported in ht */
+               if (idx >= RATE_9M_IDX)
+                       idx += 1;
+               if (idx >= IL_FIRST_OFDM_RATE && idx <= IL_LAST_OFDM_RATE)
+                       return idx;
+
+               /* legacy rate format, search for match in table */
+       } else {
+               for (idx = 0; idx < ARRAY_SIZE(il_rates); idx++)
+                       if (il_rates[idx].plcp == (rate_n_flags & 0xFF))
+                               return idx;
+       }
+
+       return -1;
+}
+
+static void il4965_rs_rate_scale_perform(struct il_priv *il,
+                                        struct sk_buff *skb,
+                                        struct ieee80211_sta *sta,
+                                        struct il_lq_sta *lq_sta);
+static void il4965_rs_fill_link_cmd(struct il_priv *il,
+                                   struct il_lq_sta *lq_sta, u32 rate_n_flags);
+static void il4965_rs_stay_in_table(struct il_lq_sta *lq_sta,
+                                   bool force_search);
+
+#ifdef CONFIG_MAC80211_DEBUGFS
+static void il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta,
+                                   u32 *rate_n_flags, int idx);
+#else
+static void
+il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta, u32 * rate_n_flags, int idx)
+{
+}
+#endif
+
+/**
+ * The following tables contain the expected throughput metrics for all rates
+ *
+ *     1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 60 MBits
+ *
+ * where invalid entries are zeros.
+ *
+ * CCK rates are only valid in legacy table and will only be used in G
+ * (2.4 GHz) band.
+ */
+
+static s32 expected_tpt_legacy[RATE_COUNT] = {
+       7, 13, 35, 58, 40, 57, 72, 98, 121, 154, 177, 186, 0
+};
+
+static s32 expected_tpt_siso20MHz[4][RATE_COUNT] = {
+       {0, 0, 0, 0, 42, 0, 76, 102, 124, 158, 183, 193, 202},  /* Norm */
+       {0, 0, 0, 0, 46, 0, 82, 110, 132, 167, 192, 202, 210},  /* SGI */
+       {0, 0, 0, 0, 48, 0, 93, 135, 176, 251, 319, 351, 381},  /* AGG */
+       {0, 0, 0, 0, 53, 0, 102, 149, 193, 275, 348, 381, 413}, /* AGG+SGI */
+};
+
+static s32 expected_tpt_siso40MHz[4][RATE_COUNT] = {
+       {0, 0, 0, 0, 77, 0, 127, 160, 184, 220, 242, 250, 257}, /* Norm */
+       {0, 0, 0, 0, 83, 0, 135, 169, 193, 229, 250, 257, 264}, /* SGI */
+       {0, 0, 0, 0, 96, 0, 182, 259, 328, 451, 553, 598, 640}, /* AGG */
+       {0, 0, 0, 0, 106, 0, 199, 282, 357, 487, 593, 640, 683},        /* AGG+SGI */
+};
+
+static s32 expected_tpt_mimo2_20MHz[4][RATE_COUNT] = {
+       {0, 0, 0, 0, 74, 0, 123, 155, 179, 213, 235, 243, 250}, /* Norm */
+       {0, 0, 0, 0, 81, 0, 131, 164, 187, 221, 242, 250, 256}, /* SGI */
+       {0, 0, 0, 0, 92, 0, 175, 250, 317, 436, 534, 578, 619}, /* AGG */
+       {0, 0, 0, 0, 102, 0, 192, 273, 344, 470, 573, 619, 660},        /* AGG+SGI */
+};
+
+static s32 expected_tpt_mimo2_40MHz[4][RATE_COUNT] = {
+       {0, 0, 0, 0, 123, 0, 182, 214, 235, 264, 279, 285, 289},        /* Norm */
+       {0, 0, 0, 0, 131, 0, 191, 222, 242, 270, 284, 289, 293},        /* SGI */
+       {0, 0, 0, 0, 180, 0, 327, 446, 545, 708, 828, 878, 922},        /* AGG */
+       {0, 0, 0, 0, 197, 0, 355, 481, 584, 752, 872, 922, 966},        /* AGG+SGI */
+};
+
+/* mbps, mcs */
+static const struct il_rate_mcs_info il_rate_mcs[RATE_COUNT] = {
+       {"1", "BPSK DSSS"},
+       {"2", "QPSK DSSS"},
+       {"5.5", "BPSK CCK"},
+       {"11", "QPSK CCK"},
+       {"6", "BPSK 1/2"},
+       {"9", "BPSK 1/2"},
+       {"12", "QPSK 1/2"},
+       {"18", "QPSK 3/4"},
+       {"24", "16QAM 1/2"},
+       {"36", "16QAM 3/4"},
+       {"48", "64QAM 2/3"},
+       {"54", "64QAM 3/4"},
+       {"60", "64QAM 5/6"},
+};
+
+#define MCS_IDX_PER_STREAM     (8)
+
+static inline u8
+il4965_rs_extract_rate(u32 rate_n_flags)
+{
+       return (u8) (rate_n_flags & 0xFF);
+}
+
+static void
+il4965_rs_rate_scale_clear_win(struct il_rate_scale_data *win)
+{
+       win->data = 0;
+       win->success_counter = 0;
+       win->success_ratio = IL_INVALID_VALUE;
+       win->counter = 0;
+       win->average_tpt = IL_INVALID_VALUE;
+       win->stamp = 0;
+}
+
+static inline u8
+il4965_rs_is_valid_ant(u8 valid_antenna, u8 ant_type)
+{
+       return (ant_type & valid_antenna) == ant_type;
+}
+
+/*
+ *     removes the old data from the stats. All data that is older than
+ *     TID_MAX_TIME_DIFF, will be deleted.
+ */
+static void
+il4965_rs_tl_rm_old_stats(struct il_traffic_load *tl, u32 curr_time)
+{
+       /* The oldest age we want to keep */
+       u32 oldest_time = curr_time - TID_MAX_TIME_DIFF;
+
+       while (tl->queue_count && tl->time_stamp < oldest_time) {
+               tl->total -= tl->packet_count[tl->head];
+               tl->packet_count[tl->head] = 0;
+               tl->time_stamp += TID_QUEUE_CELL_SPACING;
+               tl->queue_count--;
+               tl->head++;
+               if (tl->head >= TID_QUEUE_MAX_SIZE)
+                       tl->head = 0;
+       }
+}
+
+/*
+ *     increment traffic load value for tid and also remove
+ *     any old values if passed the certain time period
+ */
+static u8
+il4965_rs_tl_add_packet(struct il_lq_sta *lq_data, struct ieee80211_hdr *hdr)
+{
+       u32 curr_time = jiffies_to_msecs(jiffies);
+       u32 time_diff;
+       s32 idx;
+       struct il_traffic_load *tl = NULL;
+       u8 tid;
+
+       if (ieee80211_is_data_qos(hdr->frame_control)) {
+               u8 *qc = ieee80211_get_qos_ctl(hdr);
+               tid = qc[0] & 0xf;
+       } else
+               return MAX_TID_COUNT;
+
+       if (unlikely(tid >= TID_MAX_LOAD_COUNT))
+               return MAX_TID_COUNT;
+
+       tl = &lq_data->load[tid];
+
+       curr_time -= curr_time % TID_ROUND_VALUE;
+
+       /* Happens only for the first packet. Initialize the data */
+       if (!(tl->queue_count)) {
+               tl->total = 1;
+               tl->time_stamp = curr_time;
+               tl->queue_count = 1;
+               tl->head = 0;
+               tl->packet_count[0] = 1;
+               return MAX_TID_COUNT;
+       }
+
+       time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
+       idx = time_diff / TID_QUEUE_CELL_SPACING;
+
+       /* The history is too long: remove data that is older than */
+       /* TID_MAX_TIME_DIFF */
+       if (idx >= TID_QUEUE_MAX_SIZE)
+               il4965_rs_tl_rm_old_stats(tl, curr_time);
+
+       idx = (tl->head + idx) % TID_QUEUE_MAX_SIZE;
+       tl->packet_count[idx] = tl->packet_count[idx] + 1;
+       tl->total = tl->total + 1;
+
+       if ((idx + 1) > tl->queue_count)
+               tl->queue_count = idx + 1;
+
+       return tid;
+}
+
+/*
+       get the traffic load value for tid
+*/
+static u32
+il4965_rs_tl_get_load(struct il_lq_sta *lq_data, u8 tid)
+{
+       u32 curr_time = jiffies_to_msecs(jiffies);
+       u32 time_diff;
+       s32 idx;
+       struct il_traffic_load *tl = NULL;
+
+       if (tid >= TID_MAX_LOAD_COUNT)
+               return 0;
+
+       tl = &(lq_data->load[tid]);
+
+       curr_time -= curr_time % TID_ROUND_VALUE;
+
+       if (!(tl->queue_count))
+               return 0;
+
+       time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
+       idx = time_diff / TID_QUEUE_CELL_SPACING;
+
+       /* The history is too long: remove data that is older than */
+       /* TID_MAX_TIME_DIFF */
+       if (idx >= TID_QUEUE_MAX_SIZE)
+               il4965_rs_tl_rm_old_stats(tl, curr_time);
+
+       return tl->total;
+}
+
+static int
+il4965_rs_tl_turn_on_agg_for_tid(struct il_priv *il, struct il_lq_sta *lq_data,
+                                u8 tid, struct ieee80211_sta *sta)
+{
+       int ret = -EAGAIN;
+       u32 load;
+
+       load = il4965_rs_tl_get_load(lq_data, tid);
+
+       if (load > IL_AGG_LOAD_THRESHOLD) {
+               D_HT("Starting Tx agg: STA: %pM tid: %d\n", sta->addr, tid);
+               ret = ieee80211_start_tx_ba_session(sta, tid, 5000);
+               if (ret == -EAGAIN) {
+                       /*
+                        * driver and mac80211 is out of sync
+                        * this might be cause by reloading firmware
+                        * stop the tx ba session here
+                        */
+                       IL_ERR("Fail start Tx agg on tid: %d\n", tid);
+                       ieee80211_stop_tx_ba_session(sta, tid);
+               }
+       } else
+               D_HT("Aggregation not enabled for tid %d because load = %u\n",
+                    tid, load);
+
+       return ret;
+}
+
+static void
+il4965_rs_tl_turn_on_agg(struct il_priv *il, u8 tid, struct il_lq_sta *lq_data,
+                        struct ieee80211_sta *sta)
+{
+       if (tid < TID_MAX_LOAD_COUNT)
+               il4965_rs_tl_turn_on_agg_for_tid(il, lq_data, tid, sta);
+       else
+               IL_ERR("tid exceeds max load count: %d/%d\n", tid,
+                      TID_MAX_LOAD_COUNT);
+}
+
+static inline int
+il4965_get_il4965_num_of_ant_from_rate(u32 rate_n_flags)
+{
+       return !!(rate_n_flags & RATE_MCS_ANT_A_MSK) +
+           !!(rate_n_flags & RATE_MCS_ANT_B_MSK) +
+           !!(rate_n_flags & RATE_MCS_ANT_C_MSK);
+}
+
+/*
+ * Static function to get the expected throughput from an il_scale_tbl_info
+ * that wraps a NULL pointer check
+ */
+static s32
+il4965_get_expected_tpt(struct il_scale_tbl_info *tbl, int rs_idx)
+{
+       if (tbl->expected_tpt)
+               return tbl->expected_tpt[rs_idx];
+       return 0;
+}
+
+/**
+ * il4965_rs_collect_tx_data - Update the success/failure sliding win
+ *
+ * We keep a sliding win of the last 62 packets transmitted
+ * at this rate.  win->data contains the bitmask of successful
+ * packets.
+ */
+static int
+il4965_rs_collect_tx_data(struct il_scale_tbl_info *tbl, int scale_idx,
+                         int attempts, int successes)
+{
+       struct il_rate_scale_data *win = NULL;
+       static const u64 mask = (((u64) 1) << (RATE_MAX_WINDOW - 1));
+       s32 fail_count, tpt;
+
+       if (scale_idx < 0 || scale_idx >= RATE_COUNT)
+               return -EINVAL;
+
+       /* Select win for current tx bit rate */
+       win = &(tbl->win[scale_idx]);
+
+       /* Get expected throughput */
+       tpt = il4965_get_expected_tpt(tbl, scale_idx);
+
+       /*
+        * Keep track of only the latest 62 tx frame attempts in this rate's
+        * history win; anything older isn't really relevant any more.
+        * If we have filled up the sliding win, 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 (attempts > 0) {
+               if (win->counter >= RATE_MAX_WINDOW) {
+
+                       /* remove earliest */
+                       win->counter = RATE_MAX_WINDOW - 1;
+
+                       if (win->data & mask) {
+                               win->data &= ~mask;
+                               win->success_counter--;
+                       }
+               }
+
+               /* Increment frames-attempted counter */
+               win->counter++;
+
+               /* Shift bitmap by one frame to throw away oldest history */
+               win->data <<= 1;
+
+               /* Mark the most recent #successes attempts as successful */
+               if (successes > 0) {
+                       win->success_counter++;
+                       win->data |= 0x1;
+                       successes--;
+               }
+
+               attempts--;
+       }
+
+       /* Calculate current success ratio, avoid divide-by-0! */
+       if (win->counter > 0)
+               win->success_ratio =
+                   128 * (100 * win->success_counter) / win->counter;
+       else
+               win->success_ratio = IL_INVALID_VALUE;
+
+       fail_count = win->counter - win->success_counter;
+
+       /* Calculate average throughput, if we have enough history. */
+       if (fail_count >= RATE_MIN_FAILURE_TH ||
+           win->success_counter >= RATE_MIN_SUCCESS_TH)
+               win->average_tpt = (win->success_ratio * tpt + 64) / 128;
+       else
+               win->average_tpt = IL_INVALID_VALUE;
+
+       /* Tag this win as having been updated */
+       win->stamp = jiffies;
+
+       return 0;
+}
+
+/*
+ * Fill uCode API rate_n_flags field, based on "search" or "active" table.
+ */
+static u32
+il4965_rate_n_flags_from_tbl(struct il_priv *il, struct il_scale_tbl_info *tbl,
+                            int idx, u8 use_green)
+{
+       u32 rate_n_flags = 0;
+
+       if (is_legacy(tbl->lq_type)) {
+               rate_n_flags = il_rates[idx].plcp;
+               if (idx >= IL_FIRST_CCK_RATE && idx <= IL_LAST_CCK_RATE)
+                       rate_n_flags |= RATE_MCS_CCK_MSK;
+
+       } else if (is_Ht(tbl->lq_type)) {
+               if (idx > IL_LAST_OFDM_RATE) {
+                       IL_ERR("Invalid HT rate idx %d\n", idx);
+                       idx = IL_LAST_OFDM_RATE;
+               }
+               rate_n_flags = RATE_MCS_HT_MSK;
+
+               if (is_siso(tbl->lq_type))
+                       rate_n_flags |= il_rates[idx].plcp_siso;
+               else
+                       rate_n_flags |= il_rates[idx].plcp_mimo2;
+       } else {
+               IL_ERR("Invalid tbl->lq_type %d\n", tbl->lq_type);
+       }
+
+       rate_n_flags |=
+           ((tbl->ant_type << RATE_MCS_ANT_POS) & RATE_MCS_ANT_ABC_MSK);
+
+       if (is_Ht(tbl->lq_type)) {
+               if (tbl->is_ht40) {
+                       if (tbl->is_dup)
+                               rate_n_flags |= RATE_MCS_DUP_MSK;
+                       else
+                               rate_n_flags |= RATE_MCS_HT40_MSK;
+               }
+               if (tbl->is_SGI)
+                       rate_n_flags |= RATE_MCS_SGI_MSK;
+
+               if (use_green) {
+                       rate_n_flags |= RATE_MCS_GF_MSK;
+                       if (is_siso(tbl->lq_type) && tbl->is_SGI) {
+                               rate_n_flags &= ~RATE_MCS_SGI_MSK;
+                               IL_ERR("GF was set with SGI:SISO\n");
+                       }
+               }
+       }
+       return rate_n_flags;
+}
+
+/*
+ * Interpret uCode API's rate_n_flags format,
+ * fill "search" or "active" tx mode table.
+ */
+static int
+il4965_rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
+                               enum ieee80211_band band,
+                               struct il_scale_tbl_info *tbl, int *rate_idx)
+{
+       u32 ant_msk = (rate_n_flags & RATE_MCS_ANT_ABC_MSK);
+       u8 il4965_num_of_ant =
+           il4965_get_il4965_num_of_ant_from_rate(rate_n_flags);
+       u8 mcs;
+
+       memset(tbl, 0, sizeof(struct il_scale_tbl_info));
+       *rate_idx = il4965_hwrate_to_plcp_idx(rate_n_flags);
+
+       if (*rate_idx == RATE_INVALID) {
+               *rate_idx = -1;
+               return -EINVAL;
+       }
+       tbl->is_SGI = 0;        /* default legacy setup */
+       tbl->is_ht40 = 0;
+       tbl->is_dup = 0;
+       tbl->ant_type = (ant_msk >> RATE_MCS_ANT_POS);
+       tbl->lq_type = LQ_NONE;
+       tbl->max_search = IL_MAX_SEARCH;
+
+       /* legacy rate format */
+       if (!(rate_n_flags & RATE_MCS_HT_MSK)) {
+               if (il4965_num_of_ant == 1) {
+                       if (band == IEEE80211_BAND_5GHZ)
+                               tbl->lq_type = LQ_A;
+                       else
+                               tbl->lq_type = LQ_G;
+               }
+               /* HT rate format */
+       } else {
+               if (rate_n_flags & RATE_MCS_SGI_MSK)
+                       tbl->is_SGI = 1;
+
+               if ((rate_n_flags & RATE_MCS_HT40_MSK) ||
+                   (rate_n_flags & RATE_MCS_DUP_MSK))
+                       tbl->is_ht40 = 1;
+
+               if (rate_n_flags & RATE_MCS_DUP_MSK)
+                       tbl->is_dup = 1;
+
+               mcs = il4965_rs_extract_rate(rate_n_flags);
+
+               /* SISO */
+               if (mcs <= RATE_SISO_60M_PLCP) {
+                       if (il4965_num_of_ant == 1)
+                               tbl->lq_type = LQ_SISO; /*else NONE */
+                       /* MIMO2 */
+               } else {
+                       if (il4965_num_of_ant == 2)
+                               tbl->lq_type = LQ_MIMO2;
+               }
+       }
+       return 0;
+}
+
+/* switch to another antenna/antennas and return 1 */
+/* if no other valid antenna found, return 0 */
+static int
+il4965_rs_toggle_antenna(u32 valid_ant, u32 *rate_n_flags,
+                        struct il_scale_tbl_info *tbl)
+{
+       u8 new_ant_type;
+
+       if (!tbl->ant_type || tbl->ant_type > ANT_ABC)
+               return 0;
+
+       if (!il4965_rs_is_valid_ant(valid_ant, tbl->ant_type))
+               return 0;
+
+       new_ant_type = ant_toggle_lookup[tbl->ant_type];
+
+       while (new_ant_type != tbl->ant_type &&
+              !il4965_rs_is_valid_ant(valid_ant, new_ant_type))
+               new_ant_type = ant_toggle_lookup[new_ant_type];
+
+       if (new_ant_type == tbl->ant_type)
+               return 0;
+
+       tbl->ant_type = new_ant_type;
+       *rate_n_flags &= ~RATE_MCS_ANT_ABC_MSK;
+       *rate_n_flags |= new_ant_type << RATE_MCS_ANT_POS;
+       return 1;
+}
+
+/**
+ * Green-field mode is valid if the station supports it and
+ * there are no non-GF stations present in the BSS.
+ */
+static bool
+il4965_rs_use_green(struct il_priv *il, struct ieee80211_sta *sta)
+{
+       return (sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD) &&
+              !il->ht.non_gf_sta_present;
+}
+
+/**
+ * il4965_rs_get_supported_rates - get the available rates
+ *
+ * if management frame or broadcast frame only return
+ * basic available rates.
+ *
+ */
+static u16
+il4965_rs_get_supported_rates(struct il_lq_sta *lq_sta,
+                             struct ieee80211_hdr *hdr,
+                             enum il_table_type rate_type)
+{
+       if (is_legacy(rate_type)) {
+               return lq_sta->active_legacy_rate;
+       } else {
+               if (is_siso(rate_type))
+                       return lq_sta->active_siso_rate;
+               else
+                       return lq_sta->active_mimo2_rate;
+       }
+}
+
+static u16
+il4965_rs_get_adjacent_rate(struct il_priv *il, u8 idx, u16 rate_mask,
+                           int rate_type)
+{
+       u8 high = RATE_INVALID;
+       u8 low = RATE_INVALID;
+
+       /* 802.11A or ht walks to the next literal adjacent rate in
+        * the rate table */
+       if (is_a_band(rate_type) || !is_legacy(rate_type)) {
+               int i;
+               u32 mask;
+
+               /* Find the previous rate that is in the rate mask */
+               i = idx - 1;
+               for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
+                       if (rate_mask & mask) {
+                               low = i;
+                               break;
+                       }
+               }
+
+               /* Find the next rate that is in the rate mask */
+               i = idx + 1;
+               for (mask = (1 << i); i < RATE_COUNT; i++, mask <<= 1) {
+                       if (rate_mask & mask) {
+                               high = i;
+                               break;
+                       }
+               }
+
+               return (high << 8) | low;
+       }
+
+       low = idx;
+       while (low != RATE_INVALID) {
+               low = il_rates[low].prev_rs;
+               if (low == RATE_INVALID)
+                       break;
+               if (rate_mask & (1 << low))
+                       break;
+               D_RATE("Skipping masked lower rate: %d\n", low);
+       }
+
+       high = idx;
+       while (high != RATE_INVALID) {
+               high = il_rates[high].next_rs;
+               if (high == RATE_INVALID)
+                       break;
+               if (rate_mask & (1 << high))
+                       break;
+               D_RATE("Skipping masked higher rate: %d\n", high);
+       }
+
+       return (high << 8) | low;
+}
+
+static u32
+il4965_rs_get_lower_rate(struct il_lq_sta *lq_sta,
+                        struct il_scale_tbl_info *tbl, u8 scale_idx,
+                        u8 ht_possible)
+{
+       s32 low;
+       u16 rate_mask;
+       u16 high_low;
+       u8 switch_to_legacy = 0;
+       u8 is_green = lq_sta->is_green;
+       struct il_priv *il = lq_sta->drv;
+
+       /* check if we need to switch from HT to legacy rates.
+        * assumption is that mandatory rates (1Mbps or 6Mbps)
+        * are always supported (spec demand) */
+       if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_idx)) {
+               switch_to_legacy = 1;
+               scale_idx = rs_ht_to_legacy[scale_idx];
+               if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                       tbl->lq_type = LQ_A;
+               else
+                       tbl->lq_type = LQ_G;
+
+               if (il4965_num_of_ant(tbl->ant_type) > 1)
+                       tbl->ant_type =
+                           il4965_first_antenna(il->hw_params.valid_tx_ant);
+
+               tbl->is_ht40 = 0;
+               tbl->is_SGI = 0;
+               tbl->max_search = IL_MAX_SEARCH;
+       }
+
+       rate_mask = il4965_rs_get_supported_rates(lq_sta, NULL, tbl->lq_type);
+
+       /* Mask with station rate restriction */
+       if (is_legacy(tbl->lq_type)) {
+               /* supp_rates has no CCK bits in A mode */
+               if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                       rate_mask =
+                           (u16) (rate_mask &
+                                  (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
+               else
+                       rate_mask = (u16) (rate_mask & lq_sta->supp_rates);
+       }
+
+       /* If we switched from HT to legacy, check current rate */
+       if (switch_to_legacy && (rate_mask & (1 << scale_idx))) {
+               low = scale_idx;
+               goto out;
+       }
+
+       high_low =
+           il4965_rs_get_adjacent_rate(lq_sta->drv, scale_idx, rate_mask,
+                                       tbl->lq_type);
+       low = high_low & 0xff;
+
+       if (low == RATE_INVALID)
+               low = scale_idx;
+
+out:
+       return il4965_rate_n_flags_from_tbl(lq_sta->drv, tbl, low, is_green);
+}
+
+/*
+ * Simple function to compare two rate scale table types
+ */
+static bool
+il4965_table_type_matches(struct il_scale_tbl_info *a,
+                         struct il_scale_tbl_info *b)
+{
+       return (a->lq_type == b->lq_type && a->ant_type == b->ant_type &&
+               a->is_SGI == b->is_SGI);
+}
+
+/*
+ * mac80211 sends us Tx status
+ */
+static void
+il4965_rs_tx_status(void *il_r, struct ieee80211_supported_band *sband,
+                   struct ieee80211_sta *sta, void *il_sta,
+                   struct sk_buff *skb)
+{
+       int legacy_success;
+       int retries;
+       int rs_idx, mac_idx, i;
+       struct il_lq_sta *lq_sta = il_sta;
+       struct il_link_quality_cmd *table;
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+       struct il_priv *il = (struct il_priv *)il_r;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+       enum mac80211_rate_control_flags mac_flags;
+       u32 tx_rate;
+       struct il_scale_tbl_info tbl_type;
+       struct il_scale_tbl_info *curr_tbl, *other_tbl, *tmp_tbl;
+
+       D_RATE("get frame ack response, update rate scale win\n");
+
+       /* Treat uninitialized rate scaling data same as non-existing. */
+       if (!lq_sta) {
+               D_RATE("Station rate scaling not created yet.\n");
+               return;
+       } else if (!lq_sta->drv) {
+               D_RATE("Rate scaling not initialized yet.\n");
+               return;
+       }
+
+       if (!ieee80211_is_data(hdr->frame_control) ||
+           (info->flags & IEEE80211_TX_CTL_NO_ACK))
+               return;
+
+       /* This packet was aggregated but doesn't carry status info */
+       if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
+           !(info->flags & IEEE80211_TX_STAT_AMPDU))
+               return;
+
+       /*
+        * Ignore this Tx frame response if its initial rate doesn't match
+        * that of latest Link Quality command.  There may be stragglers
+        * from a previous Link Quality command, but we're no longer interested
+        * in those; they're either from the "active" mode while we're trying
+        * to check "search" mode, or a prior "search" mode after we've moved
+        * to a new "search" mode (which might become the new "active" mode).
+        */
+       table = &lq_sta->lq;
+       tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
+       il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type, &rs_idx);
+       if (il->band == IEEE80211_BAND_5GHZ)
+               rs_idx -= IL_FIRST_OFDM_RATE;
+       mac_flags = info->status.rates[0].flags;
+       mac_idx = info->status.rates[0].idx;
+       /* For HT packets, map MCS to PLCP */
+       if (mac_flags & IEEE80211_TX_RC_MCS) {
+               mac_idx &= RATE_MCS_CODE_MSK;   /* Remove # of streams */
+               if (mac_idx >= (RATE_9M_IDX - IL_FIRST_OFDM_RATE))
+                       mac_idx++;
+               /*
+                * mac80211 HT idx is always zero-idxed; we need to move
+                * HT OFDM rates after CCK rates in 2.4 GHz band
+                */
+               if (il->band == IEEE80211_BAND_2GHZ)
+                       mac_idx += IL_FIRST_OFDM_RATE;
+       }
+       /* Here we actually compare this rate to the latest LQ command */
+       if (mac_idx < 0 ||
+           tbl_type.is_SGI != !!(mac_flags & IEEE80211_TX_RC_SHORT_GI) ||
+           tbl_type.is_ht40 != !!(mac_flags & IEEE80211_TX_RC_40_MHZ_WIDTH) ||
+           tbl_type.is_dup != !!(mac_flags & IEEE80211_TX_RC_DUP_DATA) ||
+           tbl_type.ant_type != info->status.antenna ||
+           !!(tx_rate & RATE_MCS_HT_MSK) != !!(mac_flags & IEEE80211_TX_RC_MCS)
+           || !!(tx_rate & RATE_MCS_GF_MSK) !=
+           !!(mac_flags & IEEE80211_TX_RC_GREEN_FIELD) || rs_idx != mac_idx) {
+               D_RATE("initial rate %d does not match %d (0x%x)\n", mac_idx,
+                      rs_idx, tx_rate);
+               /*
+                * Since rates mis-match, the last LQ command may have failed.
+                * After IL_MISSED_RATE_MAX mis-matches, resync the uCode with
+                * ... driver.
+                */
+               lq_sta->missed_rate_counter++;
+               if (lq_sta->missed_rate_counter > IL_MISSED_RATE_MAX) {
+                       lq_sta->missed_rate_counter = 0;
+                       il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
+               }
+               /* Regardless, ignore this status info for outdated rate */
+               return;
+       } else
+               /* Rate did match, so reset the missed_rate_counter */
+               lq_sta->missed_rate_counter = 0;
+
+       /* Figure out if rate scale algorithm is in active or search table */
+       if (il4965_table_type_matches
+           (&tbl_type, &(lq_sta->lq_info[lq_sta->active_tbl]))) {
+               curr_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+               other_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
+       } else
+           if (il4965_table_type_matches
+               (&tbl_type, &lq_sta->lq_info[1 - lq_sta->active_tbl])) {
+               curr_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
+               other_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+       } else {
+               D_RATE("Neither active nor search matches tx rate\n");
+               tmp_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+               D_RATE("active- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
+                      tmp_tbl->ant_type, tmp_tbl->is_SGI);
+               tmp_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
+               D_RATE("search- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
+                      tmp_tbl->ant_type, tmp_tbl->is_SGI);
+               D_RATE("actual- lq:%x, ant:%x, SGI:%d\n", tbl_type.lq_type,
+                      tbl_type.ant_type, tbl_type.is_SGI);
+               /*
+                * no matching table found, let's by-pass the data collection
+                * and continue to perform rate scale to find the rate table
+                */
+               il4965_rs_stay_in_table(lq_sta, true);
+               goto done;
+       }
+
+       /*
+        * Updating the frame history depends on whether packets were
+        * aggregated.
+        *
+        * For aggregation, all packets were transmitted at the same rate, the
+        * first idx into rate scale table.
+        */
+       if (info->flags & IEEE80211_TX_STAT_AMPDU) {
+               tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
+               il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type,
+                                               &rs_idx);
+               il4965_rs_collect_tx_data(curr_tbl, rs_idx,
+                                         info->status.ampdu_len,
+                                         info->status.ampdu_ack_len);
+
+               /* Update success/fail counts if not searching for new mode */
+               if (lq_sta->stay_in_tbl) {
+                       lq_sta->total_success += info->status.ampdu_ack_len;
+                       lq_sta->total_failed +=
+                           (info->status.ampdu_len -
+                            info->status.ampdu_ack_len);
+               }
+       } else {
+               /*
+                * For legacy, update frame history with for each Tx retry.
+                */
+               retries = info->status.rates[0].count - 1;
+               /* HW doesn't send more than 15 retries */
+               retries = min(retries, 15);
+
+               /* The last transmission may have been successful */
+               legacy_success = !!(info->flags & IEEE80211_TX_STAT_ACK);
+               /* Collect data for each rate used during failed TX attempts */
+               for (i = 0; i <= retries; ++i) {
+                       tx_rate = le32_to_cpu(table->rs_table[i].rate_n_flags);
+                       il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band,
+                                                       &tbl_type, &rs_idx);
+                       /*
+                        * Only collect stats if retried rate is in the same RS
+                        * table as active/search.
+                        */
+                       if (il4965_table_type_matches(&tbl_type, curr_tbl))
+                               tmp_tbl = curr_tbl;
+                       else if (il4965_table_type_matches
+                                (&tbl_type, other_tbl))
+                               tmp_tbl = other_tbl;
+                       else
+                               continue;
+                       il4965_rs_collect_tx_data(tmp_tbl, rs_idx, 1,
+                                                 i <
+                                                 retries ? 0 : legacy_success);
+               }
+
+               /* Update success/fail counts if not searching for new mode */
+               if (lq_sta->stay_in_tbl) {
+                       lq_sta->total_success += legacy_success;
+                       lq_sta->total_failed += retries + (1 - legacy_success);
+               }
+       }
+       /* The last TX rate is cached in lq_sta; it's set in if/else above */
+       lq_sta->last_rate_n_flags = tx_rate;
+done:
+       /* See if there's a better rate or modulation mode to try. */
+       if (sta->supp_rates[sband->band])
+               il4965_rs_rate_scale_perform(il, skb, sta, lq_sta);
+}
+
+/*
+ * Begin a period of staying with a selected modulation mode.
+ * Set "stay_in_tbl" flag to prevent any mode switches.
+ * Set frame tx success limits according to legacy vs. high-throughput,
+ * and reset overall (spanning all rates) tx success history stats.
+ * These control how long we stay using same modulation mode before
+ * searching for a new mode.
+ */
+static void
+il4965_rs_set_stay_in_table(struct il_priv *il, u8 is_legacy,
+                           struct il_lq_sta *lq_sta)
+{
+       D_RATE("we are staying in the same table\n");
+       lq_sta->stay_in_tbl = 1;        /* only place this gets set */
+       if (is_legacy) {
+               lq_sta->table_count_limit = IL_LEGACY_TBL_COUNT;
+               lq_sta->max_failure_limit = IL_LEGACY_FAILURE_LIMIT;
+               lq_sta->max_success_limit = IL_LEGACY_SUCCESS_LIMIT;
+       } else {
+               lq_sta->table_count_limit = IL_NONE_LEGACY_TBL_COUNT;
+               lq_sta->max_failure_limit = IL_NONE_LEGACY_FAILURE_LIMIT;
+               lq_sta->max_success_limit = IL_NONE_LEGACY_SUCCESS_LIMIT;
+       }
+       lq_sta->table_count = 0;
+       lq_sta->total_failed = 0;
+       lq_sta->total_success = 0;
+       lq_sta->flush_timer = jiffies;
+       lq_sta->action_counter = 0;
+}
+
+/*
+ * Find correct throughput table for given mode of modulation
+ */
+static void
+il4965_rs_set_expected_tpt_table(struct il_lq_sta *lq_sta,
+                                struct il_scale_tbl_info *tbl)
+{
+       /* Used to choose among HT tables */
+       s32(*ht_tbl_pointer)[RATE_COUNT];
+
+       /* Check for invalid LQ type */
+       if (WARN_ON_ONCE(!is_legacy(tbl->lq_type) && !is_Ht(tbl->lq_type))) {
+               tbl->expected_tpt = expected_tpt_legacy;
+               return;
+       }
+
+       /* Legacy rates have only one table */
+       if (is_legacy(tbl->lq_type)) {
+               tbl->expected_tpt = expected_tpt_legacy;
+               return;
+       }
+
+       /* Choose among many HT tables depending on number of streams
+        * (SISO/MIMO2), channel width (20/40), SGI, and aggregation
+        * status */
+       if (is_siso(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
+               ht_tbl_pointer = expected_tpt_siso20MHz;
+       else if (is_siso(tbl->lq_type))
+               ht_tbl_pointer = expected_tpt_siso40MHz;
+       else if (is_mimo2(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
+               ht_tbl_pointer = expected_tpt_mimo2_20MHz;
+       else                    /* if (is_mimo2(tbl->lq_type)) <-- must be true */
+               ht_tbl_pointer = expected_tpt_mimo2_40MHz;
+
+       if (!tbl->is_SGI && !lq_sta->is_agg)    /* Normal */
+               tbl->expected_tpt = ht_tbl_pointer[0];
+       else if (tbl->is_SGI && !lq_sta->is_agg)        /* SGI */
+               tbl->expected_tpt = ht_tbl_pointer[1];
+       else if (!tbl->is_SGI && lq_sta->is_agg)        /* AGG */
+               tbl->expected_tpt = ht_tbl_pointer[2];
+       else                    /* AGG+SGI */
+               tbl->expected_tpt = ht_tbl_pointer[3];
+}
+
+/*
+ * Find starting rate for new "search" high-throughput mode of modulation.
+ * Goal is to find lowest expected rate (under perfect conditions) that is
+ * above the current measured throughput of "active" mode, to give new mode
+ * a fair chance to prove itself without too many challenges.
+ *
+ * This gets called when transitioning to more aggressive modulation
+ * (i.e. legacy to SISO or MIMO, or SISO to MIMO), as well as less aggressive
+ * (i.e. MIMO to SISO).  When moving to MIMO, bit rate will typically need
+ * to decrease to match "active" throughput.  When moving from MIMO to SISO,
+ * bit rate will typically need to increase, but not if performance was bad.
+ */
+static s32
+il4965_rs_get_best_rate(struct il_priv *il, struct il_lq_sta *lq_sta,
+                       struct il_scale_tbl_info *tbl,  /* "search" */
+                       u16 rate_mask, s8 idx)
+{
+       /* "active" values */
+       struct il_scale_tbl_info *active_tbl =
+           &(lq_sta->lq_info[lq_sta->active_tbl]);
+       s32 active_sr = active_tbl->win[idx].success_ratio;
+       s32 active_tpt = active_tbl->expected_tpt[idx];
+
+       /* expected "search" throughput */
+       s32 *tpt_tbl = tbl->expected_tpt;
+
+       s32 new_rate, high, low, start_hi;
+       u16 high_low;
+       s8 rate = idx;
+
+       new_rate = high = low = start_hi = RATE_INVALID;
+
+       for (;;) {
+               high_low =
+                   il4965_rs_get_adjacent_rate(il, rate, rate_mask,
+                                               tbl->lq_type);
+
+               low = high_low & 0xff;
+               high = (high_low >> 8) & 0xff;
+
+               /*
+                * Lower the "search" bit rate, to give new "search" mode
+                * approximately the same throughput as "active" if:
+                *
+                * 1) "Active" mode has been working modestly well (but not
+                *    great), and expected "search" throughput (under perfect
+                *    conditions) at candidate rate is above the actual
+                *    measured "active" throughput (but less than expected
+                *    "active" throughput under perfect conditions).
+                * OR
+                * 2) "Active" mode has been working perfectly or very well
+                *    and expected "search" throughput (under perfect
+                *    conditions) at candidate rate is above expected
+                *    "active" throughput (under perfect conditions).
+                */
+               if ((100 * tpt_tbl[rate] > lq_sta->last_tpt &&
+                    (active_sr > RATE_DECREASE_TH && active_sr <= RATE_HIGH_TH
+                     && tpt_tbl[rate] <= active_tpt)) ||
+                   (active_sr >= RATE_SCALE_SWITCH &&
+                    tpt_tbl[rate] > active_tpt)) {
+
+                       /* (2nd or later pass)
+                        * If we've already tried to raise the rate, and are
+                        * now trying to lower it, use the higher rate. */
+                       if (start_hi != RATE_INVALID) {
+                               new_rate = start_hi;
+                               break;
+                       }
+
+                       new_rate = rate;
+
+                       /* Loop again with lower rate */
+                       if (low != RATE_INVALID)
+                               rate = low;
+
+                       /* Lower rate not available, use the original */
+                       else
+                               break;
+
+                       /* Else try to raise the "search" rate to match "active" */
+               } else {
+                       /* (2nd or later pass)
+                        * If we've already tried to lower the rate, and are
+                        * now trying to raise it, use the lower rate. */
+                       if (new_rate != RATE_INVALID)
+                               break;
+
+                       /* Loop again with higher rate */
+                       else if (high != RATE_INVALID) {
+                               start_hi = high;
+                               rate = high;
+
+                               /* Higher rate not available, use the original */
+                       } else {
+                               new_rate = rate;
+                               break;
+                       }
+               }
+       }
+
+       return new_rate;
+}
+
+/*
+ * Set up search table for MIMO2
+ */
+static int
+il4965_rs_switch_to_mimo2(struct il_priv *il, struct il_lq_sta *lq_sta,
+                         struct ieee80211_conf *conf,
+                         struct ieee80211_sta *sta,
+                         struct il_scale_tbl_info *tbl, int idx)
+{
+       u16 rate_mask;
+       s32 rate;
+       s8 is_green = lq_sta->is_green;
+
+       if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
+               return -1;
+
+       if (sta->smps_mode == IEEE80211_SMPS_STATIC)
+               return -1;
+
+       /* Need both Tx chains/antennas to support MIMO */
+       if (il->hw_params.tx_chains_num < 2)
+               return -1;
+
+       D_RATE("LQ: try to switch to MIMO2\n");
+
+       tbl->lq_type = LQ_MIMO2;
+       tbl->is_dup = lq_sta->is_dup;
+       tbl->action = 0;
+       tbl->max_search = IL_MAX_SEARCH;
+       rate_mask = lq_sta->active_mimo2_rate;
+
+       if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
+               tbl->is_ht40 = 1;
+       else
+               tbl->is_ht40 = 0;
+
+       il4965_rs_set_expected_tpt_table(lq_sta, tbl);
+
+       rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
+
+       D_RATE("LQ: MIMO2 best rate %d mask %X\n", rate, rate_mask);
+       if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
+               D_RATE("Can't switch with idx %d rate mask %x\n", rate,
+                      rate_mask);
+               return -1;
+       }
+       tbl->current_rate =
+           il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
+
+       D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
+              is_green);
+       return 0;
+}
+
+/*
+ * Set up search table for SISO
+ */
+static int
+il4965_rs_switch_to_siso(struct il_priv *il, struct il_lq_sta *lq_sta,
+                        struct ieee80211_conf *conf, struct ieee80211_sta *sta,
+                        struct il_scale_tbl_info *tbl, int idx)
+{
+       u16 rate_mask;
+       u8 is_green = lq_sta->is_green;
+       s32 rate;
+
+       if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
+               return -1;
+
+       D_RATE("LQ: try to switch to SISO\n");
+
+       tbl->is_dup = lq_sta->is_dup;
+       tbl->lq_type = LQ_SISO;
+       tbl->action = 0;
+       tbl->max_search = IL_MAX_SEARCH;
+       rate_mask = lq_sta->active_siso_rate;
+
+       if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
+               tbl->is_ht40 = 1;
+       else
+               tbl->is_ht40 = 0;
+
+       if (is_green)
+               tbl->is_SGI = 0;        /*11n spec: no SGI in SISO+Greenfield */
+
+       il4965_rs_set_expected_tpt_table(lq_sta, tbl);
+       rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
+
+       D_RATE("LQ: get best rate %d mask %X\n", rate, rate_mask);
+       if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
+               D_RATE("can not switch with idx %d rate mask %x\n", rate,
+                      rate_mask);
+               return -1;
+       }
+       tbl->current_rate =
+           il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
+       D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
+              is_green);
+       return 0;
+}
+
+/*
+ * Try to switch to new modulation mode from legacy
+ */
+static int
+il4965_rs_move_legacy_other(struct il_priv *il, struct il_lq_sta *lq_sta,
+                           struct ieee80211_conf *conf,
+                           struct ieee80211_sta *sta, int idx)
+{
+       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+       struct il_scale_tbl_info *search_tbl =
+           &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
+       struct il_rate_scale_data *win = &(tbl->win[idx]);
+       u32 sz =
+           (sizeof(struct il_scale_tbl_info) -
+            (sizeof(struct il_rate_scale_data) * RATE_COUNT));
+       u8 start_action;
+       u8 valid_tx_ant = il->hw_params.valid_tx_ant;
+       u8 tx_chains_num = il->hw_params.tx_chains_num;
+       int ret = 0;
+       u8 update_search_tbl_counter = 0;
+
+       tbl->action = IL_LEGACY_SWITCH_SISO;
+
+       start_action = tbl->action;
+       for (;;) {
+               lq_sta->action_counter++;
+               switch (tbl->action) {
+               case IL_LEGACY_SWITCH_ANTENNA1:
+               case IL_LEGACY_SWITCH_ANTENNA2:
+                       D_RATE("LQ: Legacy toggle Antenna\n");
+
+                       if ((tbl->action == IL_LEGACY_SWITCH_ANTENNA1 &&
+                            tx_chains_num <= 1) ||
+                           (tbl->action == IL_LEGACY_SWITCH_ANTENNA2 &&
+                            tx_chains_num <= 2))
+                               break;
+
+                       /* Don't change antenna if success has been great */
+                       if (win->success_ratio >= IL_RS_GOOD_RATIO)
+                               break;
+
+                       /* Set up search table to try other antenna */
+                       memcpy(search_tbl, tbl, sz);
+
+                       if (il4965_rs_toggle_antenna
+                           (valid_tx_ant, &search_tbl->current_rate,
+                            search_tbl)) {
+                               update_search_tbl_counter = 1;
+                               il4965_rs_set_expected_tpt_table(lq_sta,
+                                                                search_tbl);
+                               goto out;
+                       }
+                       break;
+               case IL_LEGACY_SWITCH_SISO:
+                       D_RATE("LQ: Legacy switch to SISO\n");
+
+                       /* Set up search table to try SISO */
+                       memcpy(search_tbl, tbl, sz);
+                       search_tbl->is_SGI = 0;
+                       ret =
+                           il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
+                                                    search_tbl, idx);
+                       if (!ret) {
+                               lq_sta->action_counter = 0;
+                               goto out;
+                       }
+
+                       break;
+               case IL_LEGACY_SWITCH_MIMO2_AB:
+               case IL_LEGACY_SWITCH_MIMO2_AC:
+               case IL_LEGACY_SWITCH_MIMO2_BC:
+                       D_RATE("LQ: Legacy switch to MIMO2\n");
+
+                       /* Set up search table to try MIMO */
+                       memcpy(search_tbl, tbl, sz);
+                       search_tbl->is_SGI = 0;
+
+                       if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AB)
+                               search_tbl->ant_type = ANT_AB;
+                       else if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AC)
+                               search_tbl->ant_type = ANT_AC;
+                       else
+                               search_tbl->ant_type = ANT_BC;
+
+                       if (!il4965_rs_is_valid_ant
+                           (valid_tx_ant, search_tbl->ant_type))
+                               break;
+
+                       ret =
+                           il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
+                                                     search_tbl, idx);
+                       if (!ret) {
+                               lq_sta->action_counter = 0;
+                               goto out;
+                       }
+                       break;
+               }
+               tbl->action++;
+               if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
+                       tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
+
+               if (tbl->action == start_action)
+                       break;
+
+       }
+       search_tbl->lq_type = LQ_NONE;
+       return 0;
+
+out:
+       lq_sta->search_better_tbl = 1;
+       tbl->action++;
+       if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
+               tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
+       if (update_search_tbl_counter)
+               search_tbl->action = tbl->action;
+       return 0;
+
+}
+
+/*
+ * Try to switch to new modulation mode from SISO
+ */
+static int
+il4965_rs_move_siso_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
+                            struct ieee80211_conf *conf,
+                            struct ieee80211_sta *sta, int idx)
+{
+       u8 is_green = lq_sta->is_green;
+       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+       struct il_scale_tbl_info *search_tbl =
+           &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
+       struct il_rate_scale_data *win = &(tbl->win[idx]);
+       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
+       u32 sz =
+           (sizeof(struct il_scale_tbl_info) -
+            (sizeof(struct il_rate_scale_data) * RATE_COUNT));
+       u8 start_action;
+       u8 valid_tx_ant = il->hw_params.valid_tx_ant;
+       u8 tx_chains_num = il->hw_params.tx_chains_num;
+       u8 update_search_tbl_counter = 0;
+       int ret;
+
+       start_action = tbl->action;
+
+       for (;;) {
+               lq_sta->action_counter++;
+               switch (tbl->action) {
+               case IL_SISO_SWITCH_ANTENNA1:
+               case IL_SISO_SWITCH_ANTENNA2:
+                       D_RATE("LQ: SISO toggle Antenna\n");
+                       if ((tbl->action == IL_SISO_SWITCH_ANTENNA1 &&
+                            tx_chains_num <= 1) ||
+                           (tbl->action == IL_SISO_SWITCH_ANTENNA2 &&
+                            tx_chains_num <= 2))
+                               break;
+
+                       if (win->success_ratio >= IL_RS_GOOD_RATIO)
+                               break;
+
+                       memcpy(search_tbl, tbl, sz);
+                       if (il4965_rs_toggle_antenna
+                           (valid_tx_ant, &search_tbl->current_rate,
+                            search_tbl)) {
+                               update_search_tbl_counter = 1;
+                               goto out;
+                       }
+                       break;
+               case IL_SISO_SWITCH_MIMO2_AB:
+               case IL_SISO_SWITCH_MIMO2_AC:
+               case IL_SISO_SWITCH_MIMO2_BC:
+                       D_RATE("LQ: SISO switch to MIMO2\n");
+                       memcpy(search_tbl, tbl, sz);
+                       search_tbl->is_SGI = 0;
+
+                       if (tbl->action == IL_SISO_SWITCH_MIMO2_AB)
+                               search_tbl->ant_type = ANT_AB;
+                       else if (tbl->action == IL_SISO_SWITCH_MIMO2_AC)
+                               search_tbl->ant_type = ANT_AC;
+                       else
+                               search_tbl->ant_type = ANT_BC;
+
+                       if (!il4965_rs_is_valid_ant
+                           (valid_tx_ant, search_tbl->ant_type))
+                               break;
+
+                       ret =
+                           il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
+                                                     search_tbl, idx);
+                       if (!ret)
+                               goto out;
+                       break;
+               case IL_SISO_SWITCH_GI:
+                       if (!tbl->is_ht40 &&
+                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
+                               break;
+                       if (tbl->is_ht40 &&
+                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
+                               break;
+
+                       D_RATE("LQ: SISO toggle SGI/NGI\n");
+
+                       memcpy(search_tbl, tbl, sz);
+                       if (is_green) {
+                               if (!tbl->is_SGI)
+                                       break;
+                               else
+                                       IL_ERR("SGI was set in GF+SISO\n");
+                       }
+                       search_tbl->is_SGI = !tbl->is_SGI;
+                       il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
+                       if (tbl->is_SGI) {
+                               s32 tpt = lq_sta->last_tpt / 100;
+                               if (tpt >= search_tbl->expected_tpt[idx])
+                                       break;
+                       }
+                       search_tbl->current_rate =
+                           il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
+                                                        is_green);
+                       update_search_tbl_counter = 1;
+                       goto out;
+               }
+               tbl->action++;
+               if (tbl->action > IL_SISO_SWITCH_GI)
+                       tbl->action = IL_SISO_SWITCH_ANTENNA1;
+
+               if (tbl->action == start_action)
+                       break;
+       }
+       search_tbl->lq_type = LQ_NONE;
+       return 0;
+
+out:
+       lq_sta->search_better_tbl = 1;
+       tbl->action++;
+       if (tbl->action > IL_SISO_SWITCH_GI)
+               tbl->action = IL_SISO_SWITCH_ANTENNA1;
+       if (update_search_tbl_counter)
+               search_tbl->action = tbl->action;
+
+       return 0;
+}
+
+/*
+ * Try to switch to new modulation mode from MIMO2
+ */
+static int
+il4965_rs_move_mimo2_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
+                             struct ieee80211_conf *conf,
+                             struct ieee80211_sta *sta, int idx)
+{
+       s8 is_green = lq_sta->is_green;
+       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+       struct il_scale_tbl_info *search_tbl =
+           &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
+       struct il_rate_scale_data *win = &(tbl->win[idx]);
+       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
+       u32 sz =
+           (sizeof(struct il_scale_tbl_info) -
+            (sizeof(struct il_rate_scale_data) * RATE_COUNT));
+       u8 start_action;
+       u8 valid_tx_ant = il->hw_params.valid_tx_ant;
+       u8 tx_chains_num = il->hw_params.tx_chains_num;
+       u8 update_search_tbl_counter = 0;
+       int ret;
+
+       start_action = tbl->action;
+       for (;;) {
+               lq_sta->action_counter++;
+               switch (tbl->action) {
+               case IL_MIMO2_SWITCH_ANTENNA1:
+               case IL_MIMO2_SWITCH_ANTENNA2:
+                       D_RATE("LQ: MIMO2 toggle Antennas\n");
+
+                       if (tx_chains_num <= 2)
+                               break;
+
+                       if (win->success_ratio >= IL_RS_GOOD_RATIO)
+                               break;
+
+                       memcpy(search_tbl, tbl, sz);
+                       if (il4965_rs_toggle_antenna
+                           (valid_tx_ant, &search_tbl->current_rate,
+                            search_tbl)) {
+                               update_search_tbl_counter = 1;
+                               goto out;
+                       }
+                       break;
+               case IL_MIMO2_SWITCH_SISO_A:
+               case IL_MIMO2_SWITCH_SISO_B:
+               case IL_MIMO2_SWITCH_SISO_C:
+                       D_RATE("LQ: MIMO2 switch to SISO\n");
+
+                       /* Set up new search table for SISO */
+                       memcpy(search_tbl, tbl, sz);
+
+                       if (tbl->action == IL_MIMO2_SWITCH_SISO_A)
+                               search_tbl->ant_type = ANT_A;
+                       else if (tbl->action == IL_MIMO2_SWITCH_SISO_B)
+                               search_tbl->ant_type = ANT_B;
+                       else
+                               search_tbl->ant_type = ANT_C;
+
+                       if (!il4965_rs_is_valid_ant
+                           (valid_tx_ant, search_tbl->ant_type))
+                               break;
+
+                       ret =
+                           il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
+                                                    search_tbl, idx);
+                       if (!ret)
+                               goto out;
+
+                       break;
+
+               case IL_MIMO2_SWITCH_GI:
+                       if (!tbl->is_ht40 &&
+                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
+                               break;
+                       if (tbl->is_ht40 &&
+                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
+                               break;
+
+                       D_RATE("LQ: MIMO2 toggle SGI/NGI\n");
+
+                       /* Set up new search table for MIMO2 */
+                       memcpy(search_tbl, tbl, sz);
+                       search_tbl->is_SGI = !tbl->is_SGI;
+                       il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
+                       /*
+                        * If active table already uses the fastest possible
+                        * modulation (dual stream with short guard interval),
+                        * and it's working well, there's no need to look
+                        * for a better type of modulation!
+                        */
+                       if (tbl->is_SGI) {
+                               s32 tpt = lq_sta->last_tpt / 100;
+                               if (tpt >= search_tbl->expected_tpt[idx])
+                                       break;
+                       }
+                       search_tbl->current_rate =
+                           il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
+                                                        is_green);
+                       update_search_tbl_counter = 1;
+                       goto out;
+
+               }
+               tbl->action++;
+               if (tbl->action > IL_MIMO2_SWITCH_GI)
+                       tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
+
+               if (tbl->action == start_action)
+                       break;
+       }
+       search_tbl->lq_type = LQ_NONE;
+       return 0;
+out:
+       lq_sta->search_better_tbl = 1;
+       tbl->action++;
+       if (tbl->action > IL_MIMO2_SWITCH_GI)
+               tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
+       if (update_search_tbl_counter)
+               search_tbl->action = tbl->action;
+
+       return 0;
+
+}
+
+/*
+ * Check whether we should continue using same modulation mode, or
+ * begin search for a new mode, based on:
+ * 1) # tx successes or failures while using this mode
+ * 2) # times calling this function
+ * 3) elapsed time in this mode (not used, for now)
+ */
+static void
+il4965_rs_stay_in_table(struct il_lq_sta *lq_sta, bool force_search)
+{
+       struct il_scale_tbl_info *tbl;
+       int i;
+       int active_tbl;
+       int flush_interval_passed = 0;
+       struct il_priv *il;
+
+       il = lq_sta->drv;
+       active_tbl = lq_sta->active_tbl;
+
+       tbl = &(lq_sta->lq_info[active_tbl]);
+
+       /* If we've been disallowing search, see if we should now allow it */
+       if (lq_sta->stay_in_tbl) {
+
+               /* Elapsed time using current modulation mode */
+               if (lq_sta->flush_timer)
+                       flush_interval_passed =
+                           time_after(jiffies,
+                                      (unsigned long)(lq_sta->flush_timer +
+                                                      RATE_SCALE_FLUSH_INTVL));
+
+               /*
+                * Check if we should allow search for new modulation mode.
+                * If many frames have failed or succeeded, or we've used
+                * this same modulation for a long time, allow search, and
+                * reset history stats that keep track of whether we should
+                * allow a new search.  Also (below) reset all bitmaps and
+                * stats in active history.
+                */
+               if (force_search ||
+                   lq_sta->total_failed > lq_sta->max_failure_limit ||
+                   lq_sta->total_success > lq_sta->max_success_limit ||
+                   (!lq_sta->search_better_tbl && lq_sta->flush_timer &&
+                    flush_interval_passed)) {
+                       D_RATE("LQ: stay is expired %d %d %d\n",
+                              lq_sta->total_failed, lq_sta->total_success,
+                              flush_interval_passed);
+
+                       /* Allow search for new mode */
+                       lq_sta->stay_in_tbl = 0;        /* only place reset */
+                       lq_sta->total_failed = 0;
+                       lq_sta->total_success = 0;
+                       lq_sta->flush_timer = 0;
+
+                       /*
+                        * Else if we've used this modulation mode enough repetitions
+                        * (regardless of elapsed time or success/failure), reset
+                        * history bitmaps and rate-specific stats for all rates in
+                        * active table.
+                        */
+               } else {
+                       lq_sta->table_count++;
+                       if (lq_sta->table_count >= lq_sta->table_count_limit) {
+                               lq_sta->table_count = 0;
+
+                               D_RATE("LQ: stay in table clear win\n");
+                               for (i = 0; i < RATE_COUNT; i++)
+                                       il4965_rs_rate_scale_clear_win(&
+                                                                      (tbl->
+                                                                       win
+                                                                       [i]));
+                       }
+               }
+
+               /* If transitioning to allow "search", reset all history
+                * bitmaps and stats in active table (this will become the new
+                * "search" table). */
+               if (!lq_sta->stay_in_tbl) {
+                       for (i = 0; i < RATE_COUNT; i++)
+                               il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
+               }
+       }
+}
+
+/*
+ * setup rate table in uCode
+ */
+static void
+il4965_rs_update_rate_tbl(struct il_priv *il, struct il_lq_sta *lq_sta,
+                         struct il_scale_tbl_info *tbl, int idx, u8 is_green)
+{
+       u32 rate;
+
+       /* Update uCode's rate table. */
+       rate = il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
+       il4965_rs_fill_link_cmd(il, lq_sta, rate);
+       il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
+}
+
+/*
+ * Do rate scaling and search for new modulation mode.
+ */
+static void
+il4965_rs_rate_scale_perform(struct il_priv *il, struct sk_buff *skb,
+                            struct ieee80211_sta *sta,
+                            struct il_lq_sta *lq_sta)
+{
+       struct ieee80211_hw *hw = il->hw;
+       struct ieee80211_conf *conf = &hw->conf;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+       int low = RATE_INVALID;
+       int high = RATE_INVALID;
+       int idx;
+       int i;
+       struct il_rate_scale_data *win = NULL;
+       int current_tpt = IL_INVALID_VALUE;
+       int low_tpt = IL_INVALID_VALUE;
+       int high_tpt = IL_INVALID_VALUE;
+       u32 fail_count;
+       s8 scale_action = 0;
+       u16 rate_mask;
+       u8 update_lq = 0;
+       struct il_scale_tbl_info *tbl, *tbl1;
+       u16 rate_scale_idx_msk = 0;
+       u8 is_green = 0;
+       u8 active_tbl = 0;
+       u8 done_search = 0;
+       u16 high_low;
+       s32 sr;
+       u8 tid = MAX_TID_COUNT;
+       struct il_tid_data *tid_data;
+
+       D_RATE("rate scale calculate new rate for skb\n");
+
+       /* Send management frames and NO_ACK data using lowest rate. */
+       /* TODO: this could probably be improved.. */
+       if (!ieee80211_is_data(hdr->frame_control) ||
+           (info->flags & IEEE80211_TX_CTL_NO_ACK))
+               return;
+
+       lq_sta->supp_rates = sta->supp_rates[lq_sta->band];
+
+       tid = il4965_rs_tl_add_packet(lq_sta, hdr);
+       if (tid != MAX_TID_COUNT && (lq_sta->tx_agg_tid_en & (1 << tid))) {
+               tid_data = &il->stations[lq_sta->lq.sta_id].tid[tid];
+               if (tid_data->agg.state == IL_AGG_OFF)
+                       lq_sta->is_agg = 0;
+               else
+                       lq_sta->is_agg = 1;
+       } else
+               lq_sta->is_agg = 0;
+
+       /*
+        * Select rate-scale / modulation-mode table to work with in
+        * the rest of this function:  "search" if searching for better
+        * modulation mode, or "active" if doing rate scaling within a mode.
+        */
+       if (!lq_sta->search_better_tbl)
+               active_tbl = lq_sta->active_tbl;
+       else
+               active_tbl = 1 - lq_sta->active_tbl;
+
+       tbl = &(lq_sta->lq_info[active_tbl]);
+       if (is_legacy(tbl->lq_type))
+               lq_sta->is_green = 0;
+       else
+               lq_sta->is_green = il4965_rs_use_green(il, sta);
+       is_green = lq_sta->is_green;
+
+       /* current tx rate */
+       idx = lq_sta->last_txrate_idx;
+
+       D_RATE("Rate scale idx %d for type %d\n", idx, tbl->lq_type);
+
+       /* rates available for this association, and for modulation mode */
+       rate_mask = il4965_rs_get_supported_rates(lq_sta, hdr, tbl->lq_type);
+
+       D_RATE("mask 0x%04X\n", rate_mask);
+
+       /* mask with station rate restriction */
+       if (is_legacy(tbl->lq_type)) {
+               if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                       /* supp_rates has no CCK bits in A mode */
+                       rate_scale_idx_msk =
+                           (u16) (rate_mask &
+                                  (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
+               else
+                       rate_scale_idx_msk =
+                           (u16) (rate_mask & lq_sta->supp_rates);
+
+       } else
+               rate_scale_idx_msk = rate_mask;
+
+       if (!rate_scale_idx_msk)
+               rate_scale_idx_msk = rate_mask;
+
+       if (!((1 << idx) & rate_scale_idx_msk)) {
+               IL_ERR("Current Rate is not valid\n");
+               if (lq_sta->search_better_tbl) {
+                       /* revert to active table if search table is not valid */
+                       tbl->lq_type = LQ_NONE;
+                       lq_sta->search_better_tbl = 0;
+                       tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+                       /* get "active" rate info */
+                       idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
+                       il4965_rs_update_rate_tbl(il, lq_sta, tbl, idx,
+                                                     is_green);
+               }
+               return;
+       }
+
+       /* Get expected throughput table and history win for current rate */
+       if (!tbl->expected_tpt) {
+               IL_ERR("tbl->expected_tpt is NULL\n");
+               return;
+       }
+
+       /* force user max rate if set by user */
+       if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < idx) {
+               idx = lq_sta->max_rate_idx;
+               update_lq = 1;
+               win = &(tbl->win[idx]);
+               goto lq_update;
+       }
+
+       win = &(tbl->win[idx]);
+
+       /*
+        * If there is not enough history to calculate actual average
+        * throughput, keep analyzing results of more tx frames, without
+        * changing rate or mode (bypass most of the rest of this function).
+        * Set up new rate table in uCode only if old rate is not supported
+        * in current association (use new rate found above).
+        */
+       fail_count = win->counter - win->success_counter;
+       if (fail_count < RATE_MIN_FAILURE_TH &&
+           win->success_counter < RATE_MIN_SUCCESS_TH) {
+               D_RATE("LQ: still below TH. succ=%d total=%d " "for idx %d\n",
+                      win->success_counter, win->counter, idx);
+
+               /* Can't calculate this yet; not enough history */
+               win->average_tpt = IL_INVALID_VALUE;
+
+               /* Should we stay with this modulation mode,
+                * or search for a new one? */
+               il4965_rs_stay_in_table(lq_sta, false);
+
+               goto out;
+       }
+       /* Else we have enough samples; calculate estimate of
+        * actual average throughput */
+       if (win->average_tpt !=
+           ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128)) {
+               IL_ERR("expected_tpt should have been calculated by now\n");
+               win->average_tpt =
+                   ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128);
+       }
+
+       /* If we are searching for better modulation mode, check success. */
+       if (lq_sta->search_better_tbl) {
+               /* If good success, continue using the "search" mode;
+                * no need to send new link quality command, since we're
+                * continuing to use the setup that we've been trying. */
+               if (win->average_tpt > lq_sta->last_tpt) {
+
+                       D_RATE("LQ: SWITCHING TO NEW TBL "
+                              "suc=%d cur-tpt=%d old-tpt=%d\n",
+                              win->success_ratio, win->average_tpt,
+                              lq_sta->last_tpt);
+
+                       if (!is_legacy(tbl->lq_type))
+                               lq_sta->enable_counter = 1;
+
+                       /* Swap tables; "search" becomes "active" */
+                       lq_sta->active_tbl = active_tbl;
+                       current_tpt = win->average_tpt;
+
+                       /* Else poor success; go back to mode in "active" table */
+               } else {
+
+                       D_RATE("LQ: GOING BACK TO THE OLD TBL "
+                              "suc=%d cur-tpt=%d old-tpt=%d\n",
+                              win->success_ratio, win->average_tpt,
+                              lq_sta->last_tpt);
+
+                       /* Nullify "search" table */
+                       tbl->lq_type = LQ_NONE;
+
+                       /* Revert to "active" table */
+                       active_tbl = lq_sta->active_tbl;
+                       tbl = &(lq_sta->lq_info[active_tbl]);
+
+                       /* Revert to "active" rate and throughput info */
+                       idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
+                       current_tpt = lq_sta->last_tpt;
+
+                       /* Need to set up a new rate table in uCode */
+                       update_lq = 1;
+               }
+
+               /* Either way, we've made a decision; modulation mode
+                * search is done, allow rate adjustment next time. */
+               lq_sta->search_better_tbl = 0;
+               done_search = 1;        /* Don't switch modes below! */
+               goto lq_update;
+       }
+
+       /* (Else) not in search of better modulation mode, try for better
+        * starting rate, while staying in this mode. */
+       high_low =
+           il4965_rs_get_adjacent_rate(il, idx, rate_scale_idx_msk,
+                                       tbl->lq_type);
+       low = high_low & 0xff;
+       high = (high_low >> 8) & 0xff;
+
+       /* If user set max rate, dont allow higher than user constrain */
+       if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < high)
+               high = RATE_INVALID;
+
+       sr = win->success_ratio;
+
+       /* Collect measured throughputs for current and adjacent rates */
+       current_tpt = win->average_tpt;
+       if (low != RATE_INVALID)
+               low_tpt = tbl->win[low].average_tpt;
+       if (high != RATE_INVALID)
+               high_tpt = tbl->win[high].average_tpt;
+
+       scale_action = 0;
+
+       /* Too many failures, decrease rate */
+       if (sr <= RATE_DECREASE_TH || current_tpt == 0) {
+               D_RATE("decrease rate because of low success_ratio\n");
+               scale_action = -1;
+
+               /* No throughput measured yet for adjacent rates; try increase. */
+       } else if (low_tpt == IL_INVALID_VALUE && high_tpt == IL_INVALID_VALUE) {
+
+               if (high != RATE_INVALID && sr >= RATE_INCREASE_TH)
+                       scale_action = 1;
+               else if (low != RATE_INVALID)
+                       scale_action = 0;
+       }
+
+       /* 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 != IL_INVALID_VALUE && high_tpt != IL_INVALID_VALUE &&
+                low_tpt < current_tpt && high_tpt < current_tpt)
+               scale_action = 0;
+
+       /* At least one adjacent rate's throughput is measured,
+        * and may have better performance. */
+       else {
+               /* Higher adjacent rate's throughput is measured */
+               if (high_tpt != IL_INVALID_VALUE) {
+                       /* Higher rate has better throughput */
+                       if (high_tpt > current_tpt && sr >= RATE_INCREASE_TH)
+                               scale_action = 1;
+                       else
+                               scale_action = 0;
+
+                       /* Lower adjacent rate's throughput is measured */
+               } else if (low_tpt != IL_INVALID_VALUE) {
+                       /* Lower rate has better throughput */
+                       if (low_tpt > current_tpt) {
+                               D_RATE("decrease rate because of low tpt\n");
+                               scale_action = -1;
+                       } else if (sr >= RATE_INCREASE_TH) {
+                               scale_action = 1;
+                       }
+               }
+       }
+
+       /* 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 != RATE_INVALID &&
+           (sr > RATE_HIGH_TH || current_tpt > 100 * tbl->expected_tpt[low]))
+               scale_action = 0;
+
+       switch (scale_action) {
+       case -1:
+               /* Decrease starting rate, update uCode's rate table */
+               if (low != RATE_INVALID) {
+                       update_lq = 1;
+                       idx = low;
+               }
+
+               break;
+       case 1:
+               /* Increase starting rate, update uCode's rate table */
+               if (high != RATE_INVALID) {
+                       update_lq = 1;
+                       idx = high;
+               }
+
+               break;
+       case 0:
+               /* No change */
+       default:
+               break;
+       }
+
+       D_RATE("choose rate scale idx %d action %d low %d " "high %d type %d\n",
+              idx, scale_action, low, high, tbl->lq_type);
+
+lq_update:
+       /* Replace uCode's rate table for the destination station. */
+       if (update_lq)
+               il4965_rs_update_rate_tbl(il, lq_sta, tbl, idx, is_green);
+
+       /* Should we stay with this modulation mode,
+        * or search for a new one? */
+       il4965_rs_stay_in_table(lq_sta, false);
+
+       /*
+        * Search for new modulation mode if we're:
+        * 1)  Not changing rates right now
+        * 2)  Not just finishing up a search
+        * 3)  Allowing a new search
+        */
+       if (!update_lq && !done_search && !lq_sta->stay_in_tbl && win->counter) {
+               /* Save current throughput to compare with "search" throughput */
+               lq_sta->last_tpt = current_tpt;
+
+               /* Select a new "search" modulation mode to try.
+                * If one is found, set up the new "search" table. */
+               if (is_legacy(tbl->lq_type))
+                       il4965_rs_move_legacy_other(il, lq_sta, conf, sta, idx);
+               else if (is_siso(tbl->lq_type))
+                       il4965_rs_move_siso_to_other(il, lq_sta, conf, sta,
+                                                    idx);
+               else            /* (is_mimo2(tbl->lq_type)) */
+                       il4965_rs_move_mimo2_to_other(il, lq_sta, conf, sta,
+                                                     idx);
+
+               /* If new "search" mode was selected, set up in uCode table */
+               if (lq_sta->search_better_tbl) {
+                       /* Access the "search" table, clear its history. */
+                       tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
+                       for (i = 0; i < RATE_COUNT; i++)
+                               il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
+
+                       /* Use new "search" start rate */
+                       idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
+
+                       D_RATE("Switch current  mcs: %X idx: %d\n",
+                              tbl->current_rate, idx);
+                       il4965_rs_fill_link_cmd(il, lq_sta, tbl->current_rate);
+                       il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
+               } else
+                       done_search = 1;
+       }
+
+       if (done_search && !lq_sta->stay_in_tbl) {
+               /* If the "active" (non-search) mode was legacy,
+                * and we've tried switching antennas,
+                * but we haven't been able to try HT modes (not available),
+                * stay with best antenna legacy modulation for a while
+                * before next round of mode comparisons. */
+               tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
+               if (is_legacy(tbl1->lq_type) && !conf_is_ht(conf) &&
+                   lq_sta->action_counter > tbl1->max_search) {
+                       D_RATE("LQ: STAY in legacy table\n");
+                       il4965_rs_set_stay_in_table(il, 1, lq_sta);
+               }
+
+               /* If we're in an HT mode, and all 3 mode switch actions
+                * have been tried and compared, stay in this best modulation
+                * mode for a while before next round of mode comparisons. */
+               if (lq_sta->enable_counter &&
+                   lq_sta->action_counter >= tbl1->max_search) {
+                       if (lq_sta->last_tpt > IL_AGG_TPT_THREHOLD &&
+                           (lq_sta->tx_agg_tid_en & (1 << tid)) &&
+                           tid != MAX_TID_COUNT) {
+                               tid_data =
+                                   &il->stations[lq_sta->lq.sta_id].tid[tid];
+                               if (tid_data->agg.state == IL_AGG_OFF) {
+                                       D_RATE("try to aggregate tid %d\n",
+                                              tid);
+                                       il4965_rs_tl_turn_on_agg(il, tid,
+                                                                lq_sta, sta);
+                               }
+                       }
+                       il4965_rs_set_stay_in_table(il, 0, lq_sta);
+               }
+       }
+
+out:
+       tbl->current_rate =
+           il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
+       i = idx;
+       lq_sta->last_txrate_idx = i;
+}
+
+/**
+ * il4965_rs_initialize_lq - Initialize a station's hardware rate table
+ *
+ * The uCode's station table contains a table of fallback rates
+ * for automatic fallback during transmission.
+ *
+ * NOTE: This sets up a default set of values.  These will be replaced later
+ *       if the driver's iwl-4965-rs rate scaling algorithm is used, instead of
+ *       rc80211_simple.
+ *
+ * NOTE: Run C_ADD_STA command to set up station table entry, before
+ *       calling this function (which runs C_TX_LINK_QUALITY_CMD,
+ *       which requires station table entry to exist).
+ */
+static void
+il4965_rs_initialize_lq(struct il_priv *il, struct ieee80211_conf *conf,
+                       struct ieee80211_sta *sta, struct il_lq_sta *lq_sta)
+{
+       struct il_scale_tbl_info *tbl;
+       int rate_idx;
+       int i;
+       u32 rate;
+       u8 use_green;
+       u8 active_tbl = 0;
+       u8 valid_tx_ant;
+       struct il_station_priv *sta_priv;
+
+       if (!sta || !lq_sta)
+               return;
+
+       use_green = il4965_rs_use_green(il, sta);
+       sta_priv = (void *)sta->drv_priv;
+
+       i = lq_sta->last_txrate_idx;
+
+       valid_tx_ant = il->hw_params.valid_tx_ant;
+
+       if (!lq_sta->search_better_tbl)
+               active_tbl = lq_sta->active_tbl;
+       else
+               active_tbl = 1 - lq_sta->active_tbl;
+
+       tbl = &(lq_sta->lq_info[active_tbl]);
+
+       if (i < 0 || i >= RATE_COUNT)
+               i = 0;
+
+       rate = il_rates[i].plcp;
+       tbl->ant_type = il4965_first_antenna(valid_tx_ant);
+       rate |= tbl->ant_type << RATE_MCS_ANT_POS;
+
+       if (i >= IL_FIRST_CCK_RATE && i <= IL_LAST_CCK_RATE)
+               rate |= RATE_MCS_CCK_MSK;
+
+       il4965_rs_get_tbl_info_from_mcs(rate, il->band, tbl, &rate_idx);
+       if (!il4965_rs_is_valid_ant(valid_tx_ant, tbl->ant_type))
+               il4965_rs_toggle_antenna(valid_tx_ant, &rate, tbl);
+
+       rate = il4965_rate_n_flags_from_tbl(il, tbl, rate_idx, use_green);
+       tbl->current_rate = rate;
+       il4965_rs_set_expected_tpt_table(lq_sta, tbl);
+       il4965_rs_fill_link_cmd(NULL, lq_sta, rate);
+       il->stations[lq_sta->lq.sta_id].lq = &lq_sta->lq;
+       il_send_lq_cmd(il, &lq_sta->lq, CMD_SYNC, true);
+}
+
+static void
+il4965_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
+                  struct ieee80211_tx_rate_control *txrc)
+{
+
+       struct sk_buff *skb = txrc->skb;
+       struct ieee80211_supported_band *sband = txrc->sband;
+       struct il_priv *il __maybe_unused = (struct il_priv *)il_r;
+       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+       struct il_lq_sta *lq_sta = il_sta;
+       int rate_idx;
+
+       D_RATE("rate scale calculate new rate for skb\n");
+
+       /* Get max rate if user set max rate */
+       if (lq_sta) {
+               lq_sta->max_rate_idx = txrc->max_rate_idx;
+               if (sband->band == IEEE80211_BAND_5GHZ &&
+                   lq_sta->max_rate_idx != -1)
+                       lq_sta->max_rate_idx += IL_FIRST_OFDM_RATE;
+               if (lq_sta->max_rate_idx < 0 ||
+                   lq_sta->max_rate_idx >= RATE_COUNT)
+                       lq_sta->max_rate_idx = -1;
+       }
+
+       /* Treat uninitialized rate scaling data same as non-existing. */
+       if (lq_sta && !lq_sta->drv) {
+               D_RATE("Rate scaling not initialized yet.\n");
+               il_sta = NULL;
+       }
+
+       /* Send management frames and NO_ACK data using lowest rate. */
+       if (rate_control_send_low(sta, il_sta, txrc))
+               return;
+
+       if (!lq_sta)
+               return;
+
+       rate_idx = lq_sta->last_txrate_idx;
+
+       if (lq_sta->last_rate_n_flags & RATE_MCS_HT_MSK) {
+               rate_idx -= IL_FIRST_OFDM_RATE;
+               /* 6M and 9M shared same MCS idx */
+               rate_idx = (rate_idx > 0) ? (rate_idx - 1) : 0;
+               if (il4965_rs_extract_rate(lq_sta->last_rate_n_flags) >=
+                   RATE_MIMO2_6M_PLCP)
+                       rate_idx = rate_idx + MCS_IDX_PER_STREAM;
+               info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
+               if (lq_sta->last_rate_n_flags & RATE_MCS_SGI_MSK)
+                       info->control.rates[0].flags |=
+                           IEEE80211_TX_RC_SHORT_GI;
+               if (lq_sta->last_rate_n_flags & RATE_MCS_DUP_MSK)
+                       info->control.rates[0].flags |=
+                           IEEE80211_TX_RC_DUP_DATA;
+               if (lq_sta->last_rate_n_flags & RATE_MCS_HT40_MSK)
+                       info->control.rates[0].flags |=
+                           IEEE80211_TX_RC_40_MHZ_WIDTH;
+               if (lq_sta->last_rate_n_flags & RATE_MCS_GF_MSK)
+                       info->control.rates[0].flags |=
+                           IEEE80211_TX_RC_GREEN_FIELD;
+       } else {
+               /* Check for invalid rates */
+               if (rate_idx < 0 || rate_idx >= RATE_COUNT_LEGACY ||
+                   (sband->band == IEEE80211_BAND_5GHZ &&
+                    rate_idx < IL_FIRST_OFDM_RATE))
+                       rate_idx = rate_lowest_index(sband, sta);
+               /* On valid 5 GHz rate, adjust idx */
+               else if (sband->band == IEEE80211_BAND_5GHZ)
+                       rate_idx -= IL_FIRST_OFDM_RATE;
+               info->control.rates[0].flags = 0;
+       }
+       info->control.rates[0].idx = rate_idx;
+       info->control.rates[0].count = 1;
+}
+
+static void *
+il4965_rs_alloc_sta(void *il_rate, struct ieee80211_sta *sta, gfp_t gfp)
+{
+       struct il_station_priv *sta_priv =
+           (struct il_station_priv *)sta->drv_priv;
+       struct il_priv *il;
+
+       il = (struct il_priv *)il_rate;
+       D_RATE("create station rate scale win\n");
+
+       return &sta_priv->lq_sta;
+}
+
+/*
+ * Called after adding a new station to initialize rate scaling
+ */
+void
+il4965_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
+{
+       int i, j;
+       struct ieee80211_hw *hw = il->hw;
+       struct ieee80211_conf *conf = &il->hw->conf;
+       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
+       struct il_station_priv *sta_priv;
+       struct il_lq_sta *lq_sta;
+       struct ieee80211_supported_band *sband;
+
+       sta_priv = (struct il_station_priv *)sta->drv_priv;
+       lq_sta = &sta_priv->lq_sta;
+       sband = hw->wiphy->bands[conf->chandef.chan->band];
+
+       lq_sta->lq.sta_id = sta_id;
+
+       for (j = 0; j < LQ_SIZE; j++)
+               for (i = 0; i < RATE_COUNT; i++)
+                       il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
+                                                      win[i]);
+
+       lq_sta->flush_timer = 0;
+       lq_sta->supp_rates = sta->supp_rates[sband->band];
+       for (j = 0; j < LQ_SIZE; j++)
+               for (i = 0; i < RATE_COUNT; i++)
+                       il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
+                                                      win[i]);
+
+       D_RATE("LQ:" "*** rate scale station global init for station %d ***\n",
+              sta_id);
+       /* TODO: what is a good starting rate for STA? About middle? Maybe not
+        * the lowest or the highest rate.. Could consider using RSSI from
+        * previous packets? Need to have IEEE 802.1X auth succeed immediately
+        * after assoc.. */
+
+       lq_sta->is_dup = 0;
+       lq_sta->max_rate_idx = -1;
+       lq_sta->missed_rate_counter = IL_MISSED_RATE_MAX;
+       lq_sta->is_green = il4965_rs_use_green(il, sta);
+       lq_sta->active_legacy_rate = il->active_rate & ~(0x1000);
+       lq_sta->band = il->band;
+       /*
+        * active_siso_rate mask includes 9 MBits (bit 5), and CCK (bits 0-3),
+        * supp_rates[] does not; shift to convert format, force 9 MBits off.
+        */
+       lq_sta->active_siso_rate = ht_cap->mcs.rx_mask[0] << 1;
+       lq_sta->active_siso_rate |= ht_cap->mcs.rx_mask[0] & 0x1;
+       lq_sta->active_siso_rate &= ~((u16) 0x2);
+       lq_sta->active_siso_rate <<= IL_FIRST_OFDM_RATE;
+
+       /* Same here */
+       lq_sta->active_mimo2_rate = ht_cap->mcs.rx_mask[1] << 1;
+       lq_sta->active_mimo2_rate |= ht_cap->mcs.rx_mask[1] & 0x1;
+       lq_sta->active_mimo2_rate &= ~((u16) 0x2);
+       lq_sta->active_mimo2_rate <<= IL_FIRST_OFDM_RATE;
+
+       /* These values will be overridden later */
+       lq_sta->lq.general_params.single_stream_ant_msk =
+           il4965_first_antenna(il->hw_params.valid_tx_ant);
+       lq_sta->lq.general_params.dual_stream_ant_msk =
+           il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
+                                                              valid_tx_ant);
+       if (!lq_sta->lq.general_params.dual_stream_ant_msk) {
+               lq_sta->lq.general_params.dual_stream_ant_msk = ANT_AB;
+       } else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
+               lq_sta->lq.general_params.dual_stream_ant_msk =
+                   il->hw_params.valid_tx_ant;
+       }
+
+       /* as default allow aggregation for all tids */
+       lq_sta->tx_agg_tid_en = IL_AGG_ALL_TID;
+       lq_sta->drv = il;
+
+       /* Set last_txrate_idx to lowest rate */
+       lq_sta->last_txrate_idx = rate_lowest_index(sband, sta);
+       if (sband->band == IEEE80211_BAND_5GHZ)
+               lq_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
+       lq_sta->is_agg = 0;
+
+#ifdef CONFIG_MAC80211_DEBUGFS
+       lq_sta->dbg_fixed_rate = 0;
+#endif
+
+       il4965_rs_initialize_lq(il, conf, sta, lq_sta);
+}
+
+static void
+il4965_rs_fill_link_cmd(struct il_priv *il, struct il_lq_sta *lq_sta,
+                       u32 new_rate)
+{
+       struct il_scale_tbl_info tbl_type;
+       int idx = 0;
+       int rate_idx;
+       int repeat_rate = 0;
+       u8 ant_toggle_cnt = 0;
+       u8 use_ht_possible = 1;
+       u8 valid_tx_ant = 0;
+       struct il_link_quality_cmd *lq_cmd = &lq_sta->lq;
+
+       /* Override starting rate (idx 0) if needed for debug purposes */
+       il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
+
+       /* Interpret new_rate (rate_n_flags) */
+       il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band, &tbl_type,
+                                       &rate_idx);
+
+       /* How many times should we repeat the initial rate? */
+       if (is_legacy(tbl_type.lq_type)) {
+               ant_toggle_cnt = 1;
+               repeat_rate = IL_NUMBER_TRY;
+       } else {
+               repeat_rate = IL_HT_NUMBER_TRY;
+       }
+
+       lq_cmd->general_params.mimo_delimiter =
+           is_mimo(tbl_type.lq_type) ? 1 : 0;
+
+       /* Fill 1st table entry (idx 0) */
+       lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
+
+       if (il4965_num_of_ant(tbl_type.ant_type) == 1) {
+               lq_cmd->general_params.single_stream_ant_msk =
+                   tbl_type.ant_type;
+       } else if (il4965_num_of_ant(tbl_type.ant_type) == 2) {
+               lq_cmd->general_params.dual_stream_ant_msk = tbl_type.ant_type;
+       }
+       /* otherwise we don't modify the existing value */
+       idx++;
+       repeat_rate--;
+       if (il)
+               valid_tx_ant = il->hw_params.valid_tx_ant;
+
+       /* Fill rest of rate table */
+       while (idx < LINK_QUAL_MAX_RETRY_NUM) {
+               /* Repeat initial/next rate.
+                * For legacy IL_NUMBER_TRY == 1, this loop will not execute.
+                * For HT IL_HT_NUMBER_TRY == 3, this executes twice. */
+               while (repeat_rate > 0 && idx < LINK_QUAL_MAX_RETRY_NUM) {
+                       if (is_legacy(tbl_type.lq_type)) {
+                               if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
+                                       ant_toggle_cnt++;
+                               else if (il &&
+                                        il4965_rs_toggle_antenna(valid_tx_ant,
+                                                                 &new_rate,
+                                                                 &tbl_type))
+                                       ant_toggle_cnt = 1;
+                       }
+
+                       /* Override next rate if needed for debug purposes */
+                       il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
+
+                       /* Fill next table entry */
+                       lq_cmd->rs_table[idx].rate_n_flags =
+                           cpu_to_le32(new_rate);
+                       repeat_rate--;
+                       idx++;
+               }
+
+               il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band,
+                                               &tbl_type, &rate_idx);
+
+               /* Indicate to uCode which entries might be MIMO.
+                * If initial rate was MIMO, this will finally end up
+                * as (IL_HT_NUMBER_TRY * 2), after 2nd pass, otherwise 0. */
+               if (is_mimo(tbl_type.lq_type))
+                       lq_cmd->general_params.mimo_delimiter = idx;
+
+               /* Get next rate */
+               new_rate =
+                   il4965_rs_get_lower_rate(lq_sta, &tbl_type, rate_idx,
+                                            use_ht_possible);
+
+               /* How many times should we repeat the next rate? */
+               if (is_legacy(tbl_type.lq_type)) {
+                       if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
+                               ant_toggle_cnt++;
+                       else if (il &&
+                                il4965_rs_toggle_antenna(valid_tx_ant,
+                                                         &new_rate, &tbl_type))
+                               ant_toggle_cnt = 1;
+
+                       repeat_rate = IL_NUMBER_TRY;
+               } else {
+                       repeat_rate = IL_HT_NUMBER_TRY;
+               }
+
+               /* Don't allow HT rates after next pass.
+                * il4965_rs_get_lower_rate() will change type to LQ_A or LQ_G. */
+               use_ht_possible = 0;
+
+               /* Override next rate if needed for debug purposes */
+               il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
+
+               /* Fill next table entry */
+               lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
+
+               idx++;
+               repeat_rate--;
+       }
+
+       lq_cmd->agg_params.agg_frame_cnt_limit = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
+       lq_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
+
+       lq_cmd->agg_params.agg_time_limit =
+           cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
+}
+
+static void *
+il4965_rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
+{
+       return hw->priv;
+}
+
+/* rate scale requires free function to be implemented */
+static void
+il4965_rs_free(void *il_rate)
+{
+       return;
+}
+
+static void
+il4965_rs_free_sta(void *il_r, struct ieee80211_sta *sta, void *il_sta)
+{
+       struct il_priv *il __maybe_unused = il_r;
+
+       D_RATE("enter\n");
+       D_RATE("leave\n");
+}
+
+#ifdef CONFIG_MAC80211_DEBUGFS
+
+static void
+il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta, u32 * rate_n_flags, int idx)
+{
+       struct il_priv *il;
+       u8 valid_tx_ant;
+       u8 ant_sel_tx;
+
+       il = lq_sta->drv;
+       valid_tx_ant = il->hw_params.valid_tx_ant;
+       if (lq_sta->dbg_fixed_rate) {
+               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;
+                       D_RATE("Fixed rate ON\n");
+               } else {
+                       lq_sta->dbg_fixed_rate = 0;
+                       IL_ERR
+                           ("Invalid antenna selection 0x%X, Valid is 0x%X\n",
+                            ant_sel_tx, valid_tx_ant);
+                       D_RATE("Fixed rate OFF\n");
+               }
+       } else {
+               D_RATE("Fixed rate OFF\n");
+       }
+}
+
+static ssize_t
+il4965_rs_sta_dbgfs_scale_table_write(struct file *file,
+                                     const char __user *user_buf,
+                                     size_t count, loff_t *ppos)
+{
+       struct il_lq_sta *lq_sta = file->private_data;
+       struct il_priv *il;
+       char buf[64];
+       size_t buf_size;
+       u32 parsed_rate;
+
+       il = lq_sta->drv;
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+
+       if (sscanf(buf, "%x", &parsed_rate) == 1)
+               lq_sta->dbg_fixed_rate = parsed_rate;
+       else
+               lq_sta->dbg_fixed_rate = 0;
+
+       lq_sta->active_legacy_rate = 0x0FFF;    /* 1 - 54 MBits, includes CCK */
+       lq_sta->active_siso_rate = 0x1FD0;      /* 6 - 60 MBits, no 9, no CCK */
+       lq_sta->active_mimo2_rate = 0x1FD0;     /* 6 - 60 MBits, no 9, no CCK */
+
+       D_RATE("sta_id %d rate 0x%X\n", lq_sta->lq.sta_id,
+              lq_sta->dbg_fixed_rate);
+
+       if (lq_sta->dbg_fixed_rate) {
+               il4965_rs_fill_link_cmd(NULL, lq_sta, lq_sta->dbg_fixed_rate);
+               il_send_lq_cmd(lq_sta->drv, &lq_sta->lq, CMD_ASYNC, false);
+       }
+
+       return count;
+}
+
+static ssize_t
+il4965_rs_sta_dbgfs_scale_table_read(struct file *file, char __user *user_buf,
+                                    size_t count, loff_t *ppos)
+{
+       char *buff;
+       int desc = 0;
+       int i = 0;
+       int idx = 0;
+       ssize_t ret;
+
+       struct il_lq_sta *lq_sta = file->private_data;
+       struct il_priv *il;
+       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
+
+       il = lq_sta->drv;
+       buff = kmalloc(1024, GFP_KERNEL);
+       if (!buff)
+               return -ENOMEM;
+
+       desc += sprintf(buff + desc, "sta_id %d\n", lq_sta->lq.sta_id);
+       desc +=
+           sprintf(buff + desc, "failed=%d success=%d rate=0%X\n",
+                   lq_sta->total_failed, lq_sta->total_success,
+                   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",
+                   (il->hw_params.valid_tx_ant & ANT_A) ? "ANT_A," : "",
+                   (il->hw_params.valid_tx_ant & ANT_B) ? "ANT_B," : "",
+                   (il->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" : "MIMO2");
+               desc +=
+                   sprintf(buff + desc, " %s",
+                           (tbl->is_ht40) ? "40MHz" : "20MHz");
+               desc +=
+                   sprintf(buff + desc, " %s %s %s\n",
+                           (tbl->is_SGI) ? "SGI" : "",
+                           (lq_sta->is_green) ? "GF enabled" : "",
+                           (lq_sta->is_agg) ? "AGG on" : "");
+       }
+       desc +=
+           sprintf(buff + desc, "last tx rate=0x%X\n",
+                   lq_sta->last_rate_n_flags);
+       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,
+                   lq_sta->lq.general_params.mimo_delimiter,
+                   lq_sta->lq.general_params.single_stream_ant_msk,
+                   lq_sta->lq.general_params.dual_stream_ant_msk);
+
+       desc +=
+           sprintf(buff + desc,
+                   "agg:"
+                   "time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
+                   le16_to_cpu(lq_sta->lq.agg_params.agg_time_limit),
+                   lq_sta->lq.agg_params.agg_dis_start_th,
+                   lq_sta->lq.agg_params.agg_frame_cnt_limit);
+
+       desc +=
+           sprintf(buff + desc,
+                   "Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
+                   lq_sta->lq.general_params.start_rate_idx[0],
+                   lq_sta->lq.general_params.start_rate_idx[1],
+                   lq_sta->lq.general_params.start_rate_idx[2],
+                   lq_sta->lq.general_params.start_rate_idx[3]);
+
+       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
+               idx =
+                   il4965_hwrate_to_plcp_idx(le32_to_cpu
+                                             (lq_sta->lq.rs_table[i].
+                                              rate_n_flags));
+               if (is_legacy(tbl->lq_type)) {
+                       desc +=
+                           sprintf(buff + desc, " rate[%d] 0x%X %smbps\n", i,
+                                   le32_to_cpu(lq_sta->lq.rs_table[i].
+                                               rate_n_flags),
+                                   il_rate_mcs[idx].mbps);
+               } else {
+                       desc +=
+                           sprintf(buff + desc, " rate[%d] 0x%X %smbps (%s)\n",
+                                   i,
+                                   le32_to_cpu(lq_sta->lq.rs_table[i].
+                                               rate_n_flags),
+                                   il_rate_mcs[idx].mbps,
+                                   il_rate_mcs[idx].mcs);
+               }
+       }
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
+       kfree(buff);
+       return ret;
+}
+
+static const struct file_operations rs_sta_dbgfs_scale_table_ops = {
+       .write = il4965_rs_sta_dbgfs_scale_table_write,
+       .read = il4965_rs_sta_dbgfs_scale_table_read,
+       .open = simple_open,
+       .llseek = default_llseek,
+};
+
+static ssize_t
+il4965_rs_sta_dbgfs_stats_table_read(struct file *file, char __user *user_buf,
+                                    size_t count, loff_t *ppos)
+{
+       char *buff;
+       int desc = 0;
+       int i, j;
+       ssize_t ret;
+
+       struct il_lq_sta *lq_sta = file->private_data;
+
+       buff = kmalloc(1024, GFP_KERNEL);
+       if (!buff)
+               return -ENOMEM;
+
+       for (i = 0; i < LQ_SIZE; i++) {
+               desc +=
+                   sprintf(buff + desc,
+                           "%s type=%d SGI=%d HT40=%d DUP=%d GF=%d\n"
+                           "rate=0x%X\n", lq_sta->active_tbl == i ? "*" : "x",
+                           lq_sta->lq_info[i].lq_type,
+                           lq_sta->lq_info[i].is_SGI,
+                           lq_sta->lq_info[i].is_ht40,
+                           lq_sta->lq_info[i].is_dup, lq_sta->is_green,
+                           lq_sta->lq_info[i].current_rate);
+               for (j = 0; j < RATE_COUNT; j++) {
+                       desc +=
+                           sprintf(buff + desc,
+                                   "counter=%d success=%d %%=%d\n",
+                                   lq_sta->lq_info[i].win[j].counter,
+                                   lq_sta->lq_info[i].win[j].success_counter,
+                                   lq_sta->lq_info[i].win[j].success_ratio);
+               }
+       }
+       ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
+       kfree(buff);
+       return ret;
+}
+
+static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
+       .read = il4965_rs_sta_dbgfs_stats_table_read,
+       .open = simple_open,
+       .llseek = default_llseek,
+};
+
+static ssize_t
+il4965_rs_sta_dbgfs_rate_scale_data_read(struct file *file,
+                                        char __user *user_buf, size_t count,
+                                        loff_t *ppos)
+{
+       char buff[120];
+       int desc = 0;
+       struct il_lq_sta *lq_sta = file->private_data;
+       struct il_scale_tbl_info *tbl = &lq_sta->lq_info[lq_sta->active_tbl];
+
+       if (is_Ht(tbl->lq_type))
+               desc +=
+                   sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
+                           tbl->expected_tpt[lq_sta->last_txrate_idx]);
+       else
+               desc +=
+                   sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
+                           il_rates[lq_sta->last_txrate_idx].ieee >> 1);
+
+       return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
+}
+
+static const struct file_operations rs_sta_dbgfs_rate_scale_data_ops = {
+       .read = il4965_rs_sta_dbgfs_rate_scale_data_read,
+       .open = simple_open,
+       .llseek = default_llseek,
+};
+
+static void
+il4965_rs_add_debugfs(void *il, void *il_sta, struct dentry *dir)
+{
+       struct il_lq_sta *lq_sta = il_sta;
+       lq_sta->rs_sta_dbgfs_scale_table_file =
+           debugfs_create_file("rate_scale_table", S_IRUSR | S_IWUSR, dir,
+                               lq_sta, &rs_sta_dbgfs_scale_table_ops);
+       lq_sta->rs_sta_dbgfs_stats_table_file =
+           debugfs_create_file("rate_stats_table", S_IRUSR, dir, lq_sta,
+                               &rs_sta_dbgfs_stats_table_ops);
+       lq_sta->rs_sta_dbgfs_rate_scale_data_file =
+           debugfs_create_file("rate_scale_data", S_IRUSR, dir, lq_sta,
+                               &rs_sta_dbgfs_rate_scale_data_ops);
+       lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file =
+           debugfs_create_u8("tx_agg_tid_enable", S_IRUSR | S_IWUSR, dir,
+                             &lq_sta->tx_agg_tid_en);
+
+}
+
+static void
+il4965_rs_remove_debugfs(void *il, void *il_sta)
+{
+       struct il_lq_sta *lq_sta = il_sta;
+       debugfs_remove(lq_sta->rs_sta_dbgfs_scale_table_file);
+       debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
+       debugfs_remove(lq_sta->rs_sta_dbgfs_rate_scale_data_file);
+       debugfs_remove(lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file);
+}
+#endif
+
+/*
+ * Initialization of rate scaling information is done by driver after
+ * the station is added. Since mac80211 calls this function before a
+ * station is added we ignore it.
+ */
+static void
+il4965_rs_rate_init_stub(void *il_r, struct ieee80211_supported_band *sband,
+                        struct cfg80211_chan_def *chandef,
+                        struct ieee80211_sta *sta, void *il_sta)
+{
+}
+
+static const struct rate_control_ops rs_4965_ops = {
+       .name = IL4965_RS_NAME,
+       .tx_status = il4965_rs_tx_status,
+       .get_rate = il4965_rs_get_rate,
+       .rate_init = il4965_rs_rate_init_stub,
+       .alloc = il4965_rs_alloc,
+       .free = il4965_rs_free,
+       .alloc_sta = il4965_rs_alloc_sta,
+       .free_sta = il4965_rs_free_sta,
+#ifdef CONFIG_MAC80211_DEBUGFS
+       .add_sta_debugfs = il4965_rs_add_debugfs,
+       .remove_sta_debugfs = il4965_rs_remove_debugfs,
+#endif
+};
+
+int
+il4965_rate_control_register(void)
+{
+       return ieee80211_rate_control_register(&rs_4965_ops);
+}
+
+void
+il4965_rate_control_unregister(void)
+{
+       ieee80211_rate_control_unregister(&rs_4965_ops);
+}
diff --git a/drivers/net/wireless/intel/iwlegacy/4965.c b/drivers/net/wireless/intel/iwlegacy/4965.c
new file mode 100644 (file)
index 0000000..fe47db9
--- /dev/null
@@ -0,0 +1,1950 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+#include <net/mac80211.h>
+#include <linux/etherdevice.h>
+#include <asm/unaligned.h>
+
+#include "common.h"
+#include "4965.h"
+
+/**
+ * il_verify_inst_sparse - verify runtime uCode image in card vs. host,
+ *   using sample data 100 bytes apart.  If these sample points are good,
+ *   it's a pretty good bet that everything between them is good, too.
+ */
+static int
+il4965_verify_inst_sparse(struct il_priv *il, __le32 * image, u32 len)
+{
+       u32 val;
+       int ret = 0;
+       u32 errcnt = 0;
+       u32 i;
+
+       D_INFO("ucode inst image size is %u\n", len);
+
+       for (i = 0; i < len; i += 100, image += 100 / sizeof(u32)) {
+               /* read data comes through single port, auto-incr addr */
+               /* NOTE: Use the debugless read so we don't flood kernel log
+                * if IL_DL_IO is set */
+               il_wr(il, HBUS_TARG_MEM_RADDR, i + IL4965_RTC_INST_LOWER_BOUND);
+               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
+               if (val != le32_to_cpu(*image)) {
+                       ret = -EIO;
+                       errcnt++;
+                       if (errcnt >= 3)
+                               break;
+               }
+       }
+
+       return ret;
+}
+
+/**
+ * il4965_verify_inst_full - verify runtime uCode image in card vs. host,
+ *     looking at all data.
+ */
+static int
+il4965_verify_inst_full(struct il_priv *il, __le32 * image, u32 len)
+{
+       u32 val;
+       u32 save_len = len;
+       int ret = 0;
+       u32 errcnt;
+
+       D_INFO("ucode inst image size is %u\n", len);
+
+       il_wr(il, HBUS_TARG_MEM_RADDR, IL4965_RTC_INST_LOWER_BOUND);
+
+       errcnt = 0;
+       for (; len > 0; len -= sizeof(u32), image++) {
+               /* read data comes through single port, auto-incr addr */
+               /* NOTE: Use the debugless read so we don't flood kernel log
+                * if IL_DL_IO is set */
+               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
+               if (val != le32_to_cpu(*image)) {
+                       IL_ERR("uCode INST section is invalid at "
+                              "offset 0x%x, is 0x%x, s/b 0x%x\n",
+                              save_len - len, val, le32_to_cpu(*image));
+                       ret = -EIO;
+                       errcnt++;
+                       if (errcnt >= 20)
+                               break;
+               }
+       }
+
+       if (!errcnt)
+               D_INFO("ucode image in INSTRUCTION memory is good\n");
+
+       return ret;
+}
+
+/**
+ * il4965_verify_ucode - determine which instruction image is in SRAM,
+ *    and verify its contents
+ */
+int
+il4965_verify_ucode(struct il_priv *il)
+{
+       __le32 *image;
+       u32 len;
+       int ret;
+
+       /* Try bootstrap */
+       image = (__le32 *) il->ucode_boot.v_addr;
+       len = il->ucode_boot.len;
+       ret = il4965_verify_inst_sparse(il, image, len);
+       if (!ret) {
+               D_INFO("Bootstrap uCode is good in inst SRAM\n");
+               return 0;
+       }
+
+       /* Try initialize */
+       image = (__le32 *) il->ucode_init.v_addr;
+       len = il->ucode_init.len;
+       ret = il4965_verify_inst_sparse(il, image, len);
+       if (!ret) {
+               D_INFO("Initialize uCode is good in inst SRAM\n");
+               return 0;
+       }
+
+       /* Try runtime/protocol */
+       image = (__le32 *) il->ucode_code.v_addr;
+       len = il->ucode_code.len;
+       ret = il4965_verify_inst_sparse(il, image, len);
+       if (!ret) {
+               D_INFO("Runtime uCode is good in inst SRAM\n");
+               return 0;
+       }
+
+       IL_ERR("NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");
+
+       /* Since nothing seems to match, show first several data entries in
+        * instruction SRAM, so maybe visual inspection will give a clue.
+        * Selection of bootstrap image (vs. other images) is arbitrary. */
+       image = (__le32 *) il->ucode_boot.v_addr;
+       len = il->ucode_boot.len;
+       ret = il4965_verify_inst_full(il, image, len);
+
+       return ret;
+}
+
+/******************************************************************************
+ *
+ * EEPROM related functions
+ *
+******************************************************************************/
+
+/*
+ * The device's EEPROM semaphore prevents conflicts between driver and uCode
+ * when accessing the EEPROM; each access is a series of pulses to/from the
+ * EEPROM chip, not a single event, so even reads could conflict if they
+ * weren't arbitrated by the semaphore.
+ */
+int
+il4965_eeprom_acquire_semaphore(struct il_priv *il)
+{
+       u16 count;
+       int ret;
+
+       for (count = 0; count < EEPROM_SEM_RETRY_LIMIT; count++) {
+               /* Request semaphore */
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
+
+               /* See if we got it */
+               ret =
+                   _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
+                                CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
+                                CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
+                                EEPROM_SEM_TIMEOUT);
+               if (ret >= 0)
+                       return ret;
+       }
+
+       return ret;
+}
+
+void
+il4965_eeprom_release_semaphore(struct il_priv *il)
+{
+       il_clear_bit(il, CSR_HW_IF_CONFIG_REG,
+                    CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
+
+}
+
+int
+il4965_eeprom_check_version(struct il_priv *il)
+{
+       u16 eeprom_ver;
+       u16 calib_ver;
+
+       eeprom_ver = il_eeprom_query16(il, EEPROM_VERSION);
+       calib_ver = il_eeprom_query16(il, EEPROM_4965_CALIB_VERSION_OFFSET);
+
+       if (eeprom_ver < il->cfg->eeprom_ver ||
+           calib_ver < il->cfg->eeprom_calib_ver)
+               goto err;
+
+       IL_INFO("device EEPROM VER=0x%x, CALIB=0x%x\n", eeprom_ver, calib_ver);
+
+       return 0;
+err:
+       IL_ERR("Unsupported (too old) EEPROM VER=0x%x < 0x%x "
+              "CALIB=0x%x < 0x%x\n", eeprom_ver, il->cfg->eeprom_ver,
+              calib_ver, il->cfg->eeprom_calib_ver);
+       return -EINVAL;
+
+}
+
+void
+il4965_eeprom_get_mac(const struct il_priv *il, u8 * mac)
+{
+       const u8 *addr = il_eeprom_query_addr(il,
+                                             EEPROM_MAC_ADDRESS);
+       memcpy(mac, addr, ETH_ALEN);
+}
+
+/* Send led command */
+static int
+il4965_send_led_cmd(struct il_priv *il, struct il_led_cmd *led_cmd)
+{
+       struct il_host_cmd cmd = {
+               .id = C_LEDS,
+               .len = sizeof(struct il_led_cmd),
+               .data = led_cmd,
+               .flags = CMD_ASYNC,
+               .callback = NULL,
+       };
+       u32 reg;
+
+       reg = _il_rd(il, CSR_LED_REG);
+       if (reg != (reg & CSR_LED_BSM_CTRL_MSK))
+               _il_wr(il, CSR_LED_REG, reg & CSR_LED_BSM_CTRL_MSK);
+
+       return il_send_cmd(il, &cmd);
+}
+
+/* Set led register off */
+void
+il4965_led_enable(struct il_priv *il)
+{
+       _il_wr(il, CSR_LED_REG, CSR_LED_REG_TRUN_ON);
+}
+
+static int il4965_send_tx_power(struct il_priv *il);
+static int il4965_hw_get_temperature(struct il_priv *il);
+
+/* Highest firmware API version supported */
+#define IL4965_UCODE_API_MAX 2
+
+/* Lowest firmware API version supported */
+#define IL4965_UCODE_API_MIN 2
+
+#define IL4965_FW_PRE "iwlwifi-4965-"
+#define _IL4965_MODULE_FIRMWARE(api) IL4965_FW_PRE #api ".ucode"
+#define IL4965_MODULE_FIRMWARE(api) _IL4965_MODULE_FIRMWARE(api)
+
+/* check contents of special bootstrap uCode SRAM */
+static int
+il4965_verify_bsm(struct il_priv *il)
+{
+       __le32 *image = il->ucode_boot.v_addr;
+       u32 len = il->ucode_boot.len;
+       u32 reg;
+       u32 val;
+
+       D_INFO("Begin verify bsm\n");
+
+       /* verify BSM SRAM contents */
+       val = il_rd_prph(il, BSM_WR_DWCOUNT_REG);
+       for (reg = BSM_SRAM_LOWER_BOUND; reg < BSM_SRAM_LOWER_BOUND + len;
+            reg += sizeof(u32), image++) {
+               val = il_rd_prph(il, reg);
+               if (val != le32_to_cpu(*image)) {
+                       IL_ERR("BSM uCode verification failed at "
+                              "addr 0x%08X+%u (of %u), is 0x%x, s/b 0x%x\n",
+                              BSM_SRAM_LOWER_BOUND, reg - BSM_SRAM_LOWER_BOUND,
+                              len, val, le32_to_cpu(*image));
+                       return -EIO;
+               }
+       }
+
+       D_INFO("BSM bootstrap uCode image OK\n");
+
+       return 0;
+}
+
+/**
+ * il4965_load_bsm - Load bootstrap instructions
+ *
+ * BSM operation:
+ *
+ * The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
+ * in special SRAM that does not power down during RFKILL.  When powering back
+ * up after power-saving sleeps (or during initial uCode load), the BSM loads
+ * the bootstrap program into the on-board processor, and starts it.
+ *
+ * The bootstrap program loads (via DMA) instructions and data for a new
+ * program from host DRAM locations indicated by the host driver in the
+ * BSM_DRAM_* registers.  Once the new program is loaded, it starts
+ * automatically.
+ *
+ * When initializing the NIC, the host driver points the BSM to the
+ * "initialize" uCode image.  This uCode sets up some internal data, then
+ * notifies host via "initialize alive" that it is complete.
+ *
+ * The host then replaces the BSM_DRAM_* pointer values to point to the
+ * normal runtime uCode instructions and a backup uCode data cache buffer
+ * (filled initially with starting data values for the on-board processor),
+ * then triggers the "initialize" uCode to load and launch the runtime uCode,
+ * which begins normal operation.
+ *
+ * When doing a power-save shutdown, runtime uCode saves data SRAM into
+ * the backup data cache in DRAM before SRAM is powered down.
+ *
+ * When powering back up, the BSM loads the bootstrap program.  This reloads
+ * the runtime uCode instructions and the backup data cache into SRAM,
+ * and re-launches the runtime uCode from where it left off.
+ */
+static int
+il4965_load_bsm(struct il_priv *il)
+{
+       __le32 *image = il->ucode_boot.v_addr;
+       u32 len = il->ucode_boot.len;
+       dma_addr_t pinst;
+       dma_addr_t pdata;
+       u32 inst_len;
+       u32 data_len;
+       int i;
+       u32 done;
+       u32 reg_offset;
+       int ret;
+
+       D_INFO("Begin load bsm\n");
+
+       il->ucode_type = UCODE_RT;
+
+       /* make sure bootstrap program is no larger than BSM's SRAM size */
+       if (len > IL49_MAX_BSM_SIZE)
+               return -EINVAL;
+
+       /* Tell bootstrap uCode where to find the "Initialize" uCode
+        *   in host DRAM ... host DRAM physical address bits 35:4 for 4965.
+        * NOTE:  il_init_alive_start() will replace these values,
+        *        after the "initialize" uCode has run, to point to
+        *        runtime/protocol instructions and backup data cache.
+        */
+       pinst = il->ucode_init.p_addr >> 4;
+       pdata = il->ucode_init_data.p_addr >> 4;
+       inst_len = il->ucode_init.len;
+       data_len = il->ucode_init_data.len;
+
+       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
+       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
+       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
+       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
+
+       /* Fill BSM memory with bootstrap instructions */
+       for (reg_offset = BSM_SRAM_LOWER_BOUND;
+            reg_offset < BSM_SRAM_LOWER_BOUND + len;
+            reg_offset += sizeof(u32), image++)
+               _il_wr_prph(il, reg_offset, le32_to_cpu(*image));
+
+       ret = il4965_verify_bsm(il);
+       if (ret)
+               return ret;
+
+       /* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
+       il_wr_prph(il, BSM_WR_MEM_SRC_REG, 0x0);
+       il_wr_prph(il, BSM_WR_MEM_DST_REG, IL49_RTC_INST_LOWER_BOUND);
+       il_wr_prph(il, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
+
+       /* Load bootstrap code into instruction SRAM now,
+        *   to prepare to load "initialize" uCode */
+       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START);
+
+       /* Wait for load of bootstrap uCode to finish */
+       for (i = 0; i < 100; i++) {
+               done = il_rd_prph(il, BSM_WR_CTRL_REG);
+               if (!(done & BSM_WR_CTRL_REG_BIT_START))
+                       break;
+               udelay(10);
+       }
+       if (i < 100)
+               D_INFO("BSM write complete, poll %d iterations\n", i);
+       else {
+               IL_ERR("BSM write did not complete!\n");
+               return -EIO;
+       }
+
+       /* Enable future boot loads whenever power management unit triggers it
+        *   (e.g. when powering back up after power-save shutdown) */
+       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START_EN);
+
+       return 0;
+}
+
+/**
+ * il4965_set_ucode_ptrs - Set uCode address location
+ *
+ * Tell initialization uCode where to find runtime uCode.
+ *
+ * BSM registers initially contain pointers to initialization uCode.
+ * We need to replace them to load runtime uCode inst and data,
+ * and to save runtime data when powering down.
+ */
+static int
+il4965_set_ucode_ptrs(struct il_priv *il)
+{
+       dma_addr_t pinst;
+       dma_addr_t pdata;
+       int ret = 0;
+
+       /* bits 35:4 for 4965 */
+       pinst = il->ucode_code.p_addr >> 4;
+       pdata = il->ucode_data_backup.p_addr >> 4;
+
+       /* Tell bootstrap uCode where to find image to load */
+       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
+       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
+       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, il->ucode_data.len);
+
+       /* Inst byte count must be last to set up, bit 31 signals uCode
+        *   that all new ptr/size info is in place */
+       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG,
+                  il->ucode_code.len | BSM_DRAM_INST_LOAD);
+       D_INFO("Runtime uCode pointers are set.\n");
+
+       return ret;
+}
+
+/**
+ * il4965_init_alive_start - Called after N_ALIVE notification received
+ *
+ * Called after N_ALIVE notification received from "initialize" uCode.
+ *
+ * The 4965 "initialize" ALIVE reply contains calibration data for:
+ *   Voltage, temperature, and MIMO tx gain correction, now stored in il
+ *   (3945 does not contain this data).
+ *
+ * Tell "initialize" uCode to go ahead and load the runtime uCode.
+*/
+static void
+il4965_init_alive_start(struct il_priv *il)
+{
+       /* Bootstrap uCode has loaded initialize uCode ... verify inst image.
+        * This is a paranoid check, because we would not have gotten the
+        * "initialize" alive if code weren't properly loaded.  */
+       if (il4965_verify_ucode(il)) {
+               /* Runtime instruction load was bad;
+                * take it all the way back down so we can try again */
+               D_INFO("Bad \"initialize\" uCode load.\n");
+               goto restart;
+       }
+
+       /* Calculate temperature */
+       il->temperature = il4965_hw_get_temperature(il);
+
+       /* Send pointers to protocol/runtime uCode image ... init code will
+        * load and launch runtime uCode, which will send us another "Alive"
+        * notification. */
+       D_INFO("Initialization Alive received.\n");
+       if (il4965_set_ucode_ptrs(il)) {
+               /* Runtime instruction load won't happen;
+                * take it all the way back down so we can try again */
+               D_INFO("Couldn't set up uCode pointers.\n");
+               goto restart;
+       }
+       return;
+
+restart:
+       queue_work(il->workqueue, &il->restart);
+}
+
+static bool
+iw4965_is_ht40_channel(__le32 rxon_flags)
+{
+       int chan_mod =
+           le32_to_cpu(rxon_flags & RXON_FLG_CHANNEL_MODE_MSK) >>
+           RXON_FLG_CHANNEL_MODE_POS;
+       return (chan_mod == CHANNEL_MODE_PURE_40 ||
+               chan_mod == CHANNEL_MODE_MIXED);
+}
+
+void
+il4965_nic_config(struct il_priv *il)
+{
+       unsigned long flags;
+       u16 radio_cfg;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       radio_cfg = il_eeprom_query16(il, EEPROM_RADIO_CONFIG);
+
+       /* write radio config values to register */
+       if (EEPROM_RF_CFG_TYPE_MSK(radio_cfg) == EEPROM_4965_RF_CFG_TYPE_MAX)
+               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                          EEPROM_RF_CFG_TYPE_MSK(radio_cfg) |
+                          EEPROM_RF_CFG_STEP_MSK(radio_cfg) |
+                          EEPROM_RF_CFG_DASH_MSK(radio_cfg));
+
+       /* set CSR_HW_CONFIG_REG for uCode use */
+       il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                  CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
+                  CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);
+
+       il->calib_info =
+           (struct il_eeprom_calib_info *)
+           il_eeprom_query_addr(il, EEPROM_4965_CALIB_TXPOWER_OFFSET);
+
+       spin_unlock_irqrestore(&il->lock, flags);
+}
+
+/* Reset differential Rx gains in NIC to prepare for chain noise calibration.
+ * Called after every association, but this runs only once!
+ *  ... once chain noise is calibrated the first time, it's good forever.  */
+static void
+il4965_chain_noise_reset(struct il_priv *il)
+{
+       struct il_chain_noise_data *data = &(il->chain_noise_data);
+
+       if (data->state == IL_CHAIN_NOISE_ALIVE && il_is_any_associated(il)) {
+               struct il_calib_diff_gain_cmd cmd;
+
+               /* clear data for chain noise calibration algorithm */
+               data->chain_noise_a = 0;
+               data->chain_noise_b = 0;
+               data->chain_noise_c = 0;
+               data->chain_signal_a = 0;
+               data->chain_signal_b = 0;
+               data->chain_signal_c = 0;
+               data->beacon_count = 0;
+
+               memset(&cmd, 0, sizeof(cmd));
+               cmd.hdr.op_code = IL_PHY_CALIBRATE_DIFF_GAIN_CMD;
+               cmd.diff_gain_a = 0;
+               cmd.diff_gain_b = 0;
+               cmd.diff_gain_c = 0;
+               if (il_send_cmd_pdu(il, C_PHY_CALIBRATION, sizeof(cmd), &cmd))
+                       IL_ERR("Could not send C_PHY_CALIBRATION\n");
+               data->state = IL_CHAIN_NOISE_ACCUMULATE;
+               D_CALIB("Run chain_noise_calibrate\n");
+       }
+}
+
+static s32
+il4965_math_div_round(s32 num, s32 denom, s32 * res)
+{
+       s32 sign = 1;
+
+       if (num < 0) {
+               sign = -sign;
+               num = -num;
+       }
+       if (denom < 0) {
+               sign = -sign;
+               denom = -denom;
+       }
+       *res = 1;
+       *res = ((num * 2 + denom) / (denom * 2)) * sign;
+
+       return 1;
+}
+
+/**
+ * il4965_get_voltage_compensation - Power supply voltage comp for txpower
+ *
+ * Determines power supply voltage compensation for txpower calculations.
+ * Returns number of 1/2-dB steps to subtract from gain table idx,
+ * to compensate for difference between power supply voltage during
+ * factory measurements, vs. current power supply voltage.
+ *
+ * Voltage indication is higher for lower voltage.
+ * Lower voltage requires more gain (lower gain table idx).
+ */
+static s32
+il4965_get_voltage_compensation(s32 eeprom_voltage, s32 current_voltage)
+{
+       s32 comp = 0;
+
+       if (TX_POWER_IL_ILLEGAL_VOLTAGE == eeprom_voltage ||
+           TX_POWER_IL_ILLEGAL_VOLTAGE == current_voltage)
+               return 0;
+
+       il4965_math_div_round(current_voltage - eeprom_voltage,
+                             TX_POWER_IL_VOLTAGE_CODES_PER_03V, &comp);
+
+       if (current_voltage > eeprom_voltage)
+               comp *= 2;
+       if ((comp < -2) || (comp > 2))
+               comp = 0;
+
+       return comp;
+}
+
+static s32
+il4965_get_tx_atten_grp(u16 channel)
+{
+       if (channel >= CALIB_IL_TX_ATTEN_GR5_FCH &&
+           channel <= CALIB_IL_TX_ATTEN_GR5_LCH)
+               return CALIB_CH_GROUP_5;
+
+       if (channel >= CALIB_IL_TX_ATTEN_GR1_FCH &&
+           channel <= CALIB_IL_TX_ATTEN_GR1_LCH)
+               return CALIB_CH_GROUP_1;
+
+       if (channel >= CALIB_IL_TX_ATTEN_GR2_FCH &&
+           channel <= CALIB_IL_TX_ATTEN_GR2_LCH)
+               return CALIB_CH_GROUP_2;
+
+       if (channel >= CALIB_IL_TX_ATTEN_GR3_FCH &&
+           channel <= CALIB_IL_TX_ATTEN_GR3_LCH)
+               return CALIB_CH_GROUP_3;
+
+       if (channel >= CALIB_IL_TX_ATTEN_GR4_FCH &&
+           channel <= CALIB_IL_TX_ATTEN_GR4_LCH)
+               return CALIB_CH_GROUP_4;
+
+       return -EINVAL;
+}
+
+static u32
+il4965_get_sub_band(const struct il_priv *il, u32 channel)
+{
+       s32 b = -1;
+
+       for (b = 0; b < EEPROM_TX_POWER_BANDS; b++) {
+               if (il->calib_info->band_info[b].ch_from == 0)
+                       continue;
+
+               if (channel >= il->calib_info->band_info[b].ch_from &&
+                   channel <= il->calib_info->band_info[b].ch_to)
+                       break;
+       }
+
+       return b;
+}
+
+static s32
+il4965_interpolate_value(s32 x, s32 x1, s32 y1, s32 x2, s32 y2)
+{
+       s32 val;
+
+       if (x2 == x1)
+               return y1;
+       else {
+               il4965_math_div_round((x2 - x) * (y1 - y2), (x2 - x1), &val);
+               return val + y2;
+       }
+}
+
+/**
+ * il4965_interpolate_chan - Interpolate factory measurements for one channel
+ *
+ * Interpolates factory measurements from the two sample channels within a
+ * sub-band, to apply to channel of interest.  Interpolation is proportional to
+ * differences in channel frequencies, which is proportional to differences
+ * in channel number.
+ */
+static int
+il4965_interpolate_chan(struct il_priv *il, u32 channel,
+                       struct il_eeprom_calib_ch_info *chan_info)
+{
+       s32 s = -1;
+       u32 c;
+       u32 m;
+       const struct il_eeprom_calib_measure *m1;
+       const struct il_eeprom_calib_measure *m2;
+       struct il_eeprom_calib_measure *omeas;
+       u32 ch_i1;
+       u32 ch_i2;
+
+       s = il4965_get_sub_band(il, channel);
+       if (s >= EEPROM_TX_POWER_BANDS) {
+               IL_ERR("Tx Power can not find channel %d\n", channel);
+               return -1;
+       }
+
+       ch_i1 = il->calib_info->band_info[s].ch1.ch_num;
+       ch_i2 = il->calib_info->band_info[s].ch2.ch_num;
+       chan_info->ch_num = (u8) channel;
+
+       D_TXPOWER("channel %d subband %d factory cal ch %d & %d\n", channel, s,
+                 ch_i1, ch_i2);
+
+       for (c = 0; c < EEPROM_TX_POWER_TX_CHAINS; c++) {
+               for (m = 0; m < EEPROM_TX_POWER_MEASUREMENTS; m++) {
+                       m1 = &(il->calib_info->band_info[s].ch1.
+                              measurements[c][m]);
+                       m2 = &(il->calib_info->band_info[s].ch2.
+                              measurements[c][m]);
+                       omeas = &(chan_info->measurements[c][m]);
+
+                       omeas->actual_pow =
+                           (u8) il4965_interpolate_value(channel, ch_i1,
+                                                         m1->actual_pow, ch_i2,
+                                                         m2->actual_pow);
+                       omeas->gain_idx =
+                           (u8) il4965_interpolate_value(channel, ch_i1,
+                                                         m1->gain_idx, ch_i2,
+                                                         m2->gain_idx);
+                       omeas->temperature =
+                           (u8) il4965_interpolate_value(channel, ch_i1,
+                                                         m1->temperature,
+                                                         ch_i2,
+                                                         m2->temperature);
+                       omeas->pa_det =
+                           (s8) il4965_interpolate_value(channel, ch_i1,
+                                                         m1->pa_det, ch_i2,
+                                                         m2->pa_det);
+
+                       D_TXPOWER("chain %d meas %d AP1=%d AP2=%d AP=%d\n", c,
+                                 m, m1->actual_pow, m2->actual_pow,
+                                 omeas->actual_pow);
+                       D_TXPOWER("chain %d meas %d NI1=%d NI2=%d NI=%d\n", c,
+                                 m, m1->gain_idx, m2->gain_idx,
+                                 omeas->gain_idx);
+                       D_TXPOWER("chain %d meas %d PA1=%d PA2=%d PA=%d\n", c,
+                                 m, m1->pa_det, m2->pa_det, omeas->pa_det);
+                       D_TXPOWER("chain %d meas %d  T1=%d  T2=%d  T=%d\n", c,
+                                 m, m1->temperature, m2->temperature,
+                                 omeas->temperature);
+               }
+       }
+
+       return 0;
+}
+
+/* bit-rate-dependent table to prevent Tx distortion, in half-dB units,
+ * for OFDM 6, 12, 18, 24, 36, 48, 54, 60 MBit, and CCK all rates. */
+static s32 back_off_table[] = {
+       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 20 MHz */
+       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 20 MHz */
+       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 40 MHz */
+       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 40 MHz */
+       10                      /* CCK */
+};
+
+/* Thermal compensation values for txpower for various frequency ranges ...
+ *   ratios from 3:1 to 4.5:1 of degrees (Celsius) per half-dB gain adjust */
+static struct il4965_txpower_comp_entry {
+       s32 degrees_per_05db_a;
+       s32 degrees_per_05db_a_denom;
+} tx_power_cmp_tble[CALIB_CH_GROUP_MAX] = {
+       {
+       9, 2},                  /* group 0 5.2, ch  34-43 */
+       {
+       4, 1},                  /* group 1 5.2, ch  44-70 */
+       {
+       4, 1},                  /* group 2 5.2, ch  71-124 */
+       {
+       4, 1},                  /* group 3 5.2, ch 125-200 */
+       {
+       3, 1}                   /* group 4 2.4, ch   all */
+};
+
+static s32
+get_min_power_idx(s32 rate_power_idx, u32 band)
+{
+       if (!band) {
+               if ((rate_power_idx & 7) <= 4)
+                       return MIN_TX_GAIN_IDX_52GHZ_EXT;
+       }
+       return MIN_TX_GAIN_IDX;
+}
+
+struct gain_entry {
+       u8 dsp;
+       u8 radio;
+};
+
+static const struct gain_entry gain_table[2][108] = {
+       /* 5.2GHz power gain idx table */
+       {
+        {123, 0x3F},           /* highest txpower */
+        {117, 0x3F},
+        {110, 0x3F},
+        {104, 0x3F},
+        {98, 0x3F},
+        {110, 0x3E},
+        {104, 0x3E},
+        {98, 0x3E},
+        {110, 0x3D},
+        {104, 0x3D},
+        {98, 0x3D},
+        {110, 0x3C},
+        {104, 0x3C},
+        {98, 0x3C},
+        {110, 0x3B},
+        {104, 0x3B},
+        {98, 0x3B},
+        {110, 0x3A},
+        {104, 0x3A},
+        {98, 0x3A},
+        {110, 0x39},
+        {104, 0x39},
+        {98, 0x39},
+        {110, 0x38},
+        {104, 0x38},
+        {98, 0x38},
+        {110, 0x37},
+        {104, 0x37},
+        {98, 0x37},
+        {110, 0x36},
+        {104, 0x36},
+        {98, 0x36},
+        {110, 0x35},
+        {104, 0x35},
+        {98, 0x35},
+        {110, 0x34},
+        {104, 0x34},
+        {98, 0x34},
+        {110, 0x33},
+        {104, 0x33},
+        {98, 0x33},
+        {110, 0x32},
+        {104, 0x32},
+        {98, 0x32},
+        {110, 0x31},
+        {104, 0x31},
+        {98, 0x31},
+        {110, 0x30},
+        {104, 0x30},
+        {98, 0x30},
+        {110, 0x25},
+        {104, 0x25},
+        {98, 0x25},
+        {110, 0x24},
+        {104, 0x24},
+        {98, 0x24},
+        {110, 0x23},
+        {104, 0x23},
+        {98, 0x23},
+        {110, 0x22},
+        {104, 0x18},
+        {98, 0x18},
+        {110, 0x17},
+        {104, 0x17},
+        {98, 0x17},
+        {110, 0x16},
+        {104, 0x16},
+        {98, 0x16},
+        {110, 0x15},
+        {104, 0x15},
+        {98, 0x15},
+        {110, 0x14},
+        {104, 0x14},
+        {98, 0x14},
+        {110, 0x13},
+        {104, 0x13},
+        {98, 0x13},
+        {110, 0x12},
+        {104, 0x08},
+        {98, 0x08},
+        {110, 0x07},
+        {104, 0x07},
+        {98, 0x07},
+        {110, 0x06},
+        {104, 0x06},
+        {98, 0x06},
+        {110, 0x05},
+        {104, 0x05},
+        {98, 0x05},
+        {110, 0x04},
+        {104, 0x04},
+        {98, 0x04},
+        {110, 0x03},
+        {104, 0x03},
+        {98, 0x03},
+        {110, 0x02},
+        {104, 0x02},
+        {98, 0x02},
+        {110, 0x01},
+        {104, 0x01},
+        {98, 0x01},
+        {110, 0x00},
+        {104, 0x00},
+        {98, 0x00},
+        {93, 0x00},
+        {88, 0x00},
+        {83, 0x00},
+        {78, 0x00},
+        },
+       /* 2.4GHz power gain idx table */
+       {
+        {110, 0x3f},           /* highest txpower */
+        {104, 0x3f},
+        {98, 0x3f},
+        {110, 0x3e},
+        {104, 0x3e},
+        {98, 0x3e},
+        {110, 0x3d},
+        {104, 0x3d},
+        {98, 0x3d},
+        {110, 0x3c},
+        {104, 0x3c},
+        {98, 0x3c},
+        {110, 0x3b},
+        {104, 0x3b},
+        {98, 0x3b},
+        {110, 0x3a},
+        {104, 0x3a},
+        {98, 0x3a},
+        {110, 0x39},
+        {104, 0x39},
+        {98, 0x39},
+        {110, 0x38},
+        {104, 0x38},
+        {98, 0x38},
+        {110, 0x37},
+        {104, 0x37},
+        {98, 0x37},
+        {110, 0x36},
+        {104, 0x36},
+        {98, 0x36},
+        {110, 0x35},
+        {104, 0x35},
+        {98, 0x35},
+        {110, 0x34},
+        {104, 0x34},
+        {98, 0x34},
+        {110, 0x33},
+        {104, 0x33},
+        {98, 0x33},
+        {110, 0x32},
+        {104, 0x32},
+        {98, 0x32},
+        {110, 0x31},
+        {104, 0x31},
+        {98, 0x31},
+        {110, 0x30},
+        {104, 0x30},
+        {98, 0x30},
+        {110, 0x6},
+        {104, 0x6},
+        {98, 0x6},
+        {110, 0x5},
+        {104, 0x5},
+        {98, 0x5},
+        {110, 0x4},
+        {104, 0x4},
+        {98, 0x4},
+        {110, 0x3},
+        {104, 0x3},
+        {98, 0x3},
+        {110, 0x2},
+        {104, 0x2},
+        {98, 0x2},
+        {110, 0x1},
+        {104, 0x1},
+        {98, 0x1},
+        {110, 0x0},
+        {104, 0x0},
+        {98, 0x0},
+        {97, 0},
+        {96, 0},
+        {95, 0},
+        {94, 0},
+        {93, 0},
+        {92, 0},
+        {91, 0},
+        {90, 0},
+        {89, 0},
+        {88, 0},
+        {87, 0},
+        {86, 0},
+        {85, 0},
+        {84, 0},
+        {83, 0},
+        {82, 0},
+        {81, 0},
+        {80, 0},
+        {79, 0},
+        {78, 0},
+        {77, 0},
+        {76, 0},
+        {75, 0},
+        {74, 0},
+        {73, 0},
+        {72, 0},
+        {71, 0},
+        {70, 0},
+        {69, 0},
+        {68, 0},
+        {67, 0},
+        {66, 0},
+        {65, 0},
+        {64, 0},
+        {63, 0},
+        {62, 0},
+        {61, 0},
+        {60, 0},
+        {59, 0},
+        }
+};
+
+static int
+il4965_fill_txpower_tbl(struct il_priv *il, u8 band, u16 channel, u8 is_ht40,
+                       u8 ctrl_chan_high,
+                       struct il4965_tx_power_db *tx_power_tbl)
+{
+       u8 saturation_power;
+       s32 target_power;
+       s32 user_target_power;
+       s32 power_limit;
+       s32 current_temp;
+       s32 reg_limit;
+       s32 current_regulatory;
+       s32 txatten_grp = CALIB_CH_GROUP_MAX;
+       int i;
+       int c;
+       const struct il_channel_info *ch_info = NULL;
+       struct il_eeprom_calib_ch_info ch_eeprom_info;
+       const struct il_eeprom_calib_measure *measurement;
+       s16 voltage;
+       s32 init_voltage;
+       s32 voltage_compensation;
+       s32 degrees_per_05db_num;
+       s32 degrees_per_05db_denom;
+       s32 factory_temp;
+       s32 temperature_comp[2];
+       s32 factory_gain_idx[2];
+       s32 factory_actual_pwr[2];
+       s32 power_idx;
+
+       /* tx_power_user_lmt is in dBm, convert to half-dBm (half-dB units
+        *   are used for idxing into txpower table) */
+       user_target_power = 2 * il->tx_power_user_lmt;
+
+       /* Get current (RXON) channel, band, width */
+       D_TXPOWER("chan %d band %d is_ht40 %d\n", channel, band, is_ht40);
+
+       ch_info = il_get_channel_info(il, il->band, channel);
+
+       if (!il_is_channel_valid(ch_info))
+               return -EINVAL;
+
+       /* get txatten group, used to select 1) thermal txpower adjustment
+        *   and 2) mimo txpower balance between Tx chains. */
+       txatten_grp = il4965_get_tx_atten_grp(channel);
+       if (txatten_grp < 0) {
+               IL_ERR("Can't find txatten group for channel %d.\n", channel);
+               return txatten_grp;
+       }
+
+       D_TXPOWER("channel %d belongs to txatten group %d\n", channel,
+                 txatten_grp);
+
+       if (is_ht40) {
+               if (ctrl_chan_high)
+                       channel -= 2;
+               else
+                       channel += 2;
+       }
+
+       /* hardware txpower limits ...
+        * saturation (clipping distortion) txpowers are in half-dBm */
+       if (band)
+               saturation_power = il->calib_info->saturation_power24;
+       else
+               saturation_power = il->calib_info->saturation_power52;
+
+       if (saturation_power < IL_TX_POWER_SATURATION_MIN ||
+           saturation_power > IL_TX_POWER_SATURATION_MAX) {
+               if (band)
+                       saturation_power = IL_TX_POWER_DEFAULT_SATURATION_24;
+               else
+                       saturation_power = IL_TX_POWER_DEFAULT_SATURATION_52;
+       }
+
+       /* regulatory txpower limits ... reg_limit values are in half-dBm,
+        *   max_power_avg values are in dBm, convert * 2 */
+       if (is_ht40)
+               reg_limit = ch_info->ht40_max_power_avg * 2;
+       else
+               reg_limit = ch_info->max_power_avg * 2;
+
+       if ((reg_limit < IL_TX_POWER_REGULATORY_MIN) ||
+           (reg_limit > IL_TX_POWER_REGULATORY_MAX)) {
+               if (band)
+                       reg_limit = IL_TX_POWER_DEFAULT_REGULATORY_24;
+               else
+                       reg_limit = IL_TX_POWER_DEFAULT_REGULATORY_52;
+       }
+
+       /* Interpolate txpower calibration values for this channel,
+        *   based on factory calibration tests on spaced channels. */
+       il4965_interpolate_chan(il, channel, &ch_eeprom_info);
+
+       /* calculate tx gain adjustment based on power supply voltage */
+       voltage = le16_to_cpu(il->calib_info->voltage);
+       init_voltage = (s32) le32_to_cpu(il->card_alive_init.voltage);
+       voltage_compensation =
+           il4965_get_voltage_compensation(voltage, init_voltage);
+
+       D_TXPOWER("curr volt %d eeprom volt %d volt comp %d\n", init_voltage,
+                 voltage, voltage_compensation);
+
+       /* get current temperature (Celsius) */
+       current_temp = max(il->temperature, IL_TX_POWER_TEMPERATURE_MIN);
+       current_temp = min(il->temperature, IL_TX_POWER_TEMPERATURE_MAX);
+       current_temp = KELVIN_TO_CELSIUS(current_temp);
+
+       /* select thermal txpower adjustment params, based on channel group
+        *   (same frequency group used for mimo txatten adjustment) */
+       degrees_per_05db_num =
+           tx_power_cmp_tble[txatten_grp].degrees_per_05db_a;
+       degrees_per_05db_denom =
+           tx_power_cmp_tble[txatten_grp].degrees_per_05db_a_denom;
+
+       /* get per-chain txpower values from factory measurements */
+       for (c = 0; c < 2; c++) {
+               measurement = &ch_eeprom_info.measurements[c][1];
+
+               /* txgain adjustment (in half-dB steps) based on difference
+                *   between factory and current temperature */
+               factory_temp = measurement->temperature;
+               il4965_math_div_round((current_temp -
+                                      factory_temp) * degrees_per_05db_denom,
+                                     degrees_per_05db_num,
+                                     &temperature_comp[c]);
+
+               factory_gain_idx[c] = measurement->gain_idx;
+               factory_actual_pwr[c] = measurement->actual_pow;
+
+               D_TXPOWER("chain = %d\n", c);
+               D_TXPOWER("fctry tmp %d, " "curr tmp %d, comp %d steps\n",
+                         factory_temp, current_temp, temperature_comp[c]);
+
+               D_TXPOWER("fctry idx %d, fctry pwr %d\n", factory_gain_idx[c],
+                         factory_actual_pwr[c]);
+       }
+
+       /* for each of 33 bit-rates (including 1 for CCK) */
+       for (i = 0; i < POWER_TBL_NUM_ENTRIES; i++) {
+               u8 is_mimo_rate;
+               union il4965_tx_power_dual_stream tx_power;
+
+               /* for mimo, reduce each chain's txpower by half
+                * (3dB, 6 steps), so total output power is regulatory
+                * compliant. */
+               if (i & 0x8) {
+                       current_regulatory =
+                           reg_limit -
+                           IL_TX_POWER_MIMO_REGULATORY_COMPENSATION;
+                       is_mimo_rate = 1;
+               } else {
+                       current_regulatory = reg_limit;
+                       is_mimo_rate = 0;
+               }
+
+               /* find txpower limit, either hardware or regulatory */
+               power_limit = saturation_power - back_off_table[i];
+               if (power_limit > current_regulatory)
+                       power_limit = current_regulatory;
+
+               /* reduce user's txpower request if necessary
+                * for this rate on this channel */
+               target_power = user_target_power;
+               if (target_power > power_limit)
+                       target_power = power_limit;
+
+               D_TXPOWER("rate %d sat %d reg %d usr %d tgt %d\n", i,
+                         saturation_power - back_off_table[i],
+                         current_regulatory, user_target_power, target_power);
+
+               /* for each of 2 Tx chains (radio transmitters) */
+               for (c = 0; c < 2; c++) {
+                       s32 atten_value;
+
+                       if (is_mimo_rate)
+                               atten_value =
+                                   (s32) le32_to_cpu(il->card_alive_init.
+                                                     tx_atten[txatten_grp][c]);
+                       else
+                               atten_value = 0;
+
+                       /* calculate idx; higher idx means lower txpower */
+                       power_idx =
+                           (u8) (factory_gain_idx[c] -
+                                 (target_power - factory_actual_pwr[c]) -
+                                 temperature_comp[c] - voltage_compensation +
+                                 atten_value);
+
+/*                     D_TXPOWER("calculated txpower idx %d\n",
+                                               power_idx); */
+
+                       if (power_idx < get_min_power_idx(i, band))
+                               power_idx = get_min_power_idx(i, band);
+
+                       /* adjust 5 GHz idx to support negative idxes */
+                       if (!band)
+                               power_idx += 9;
+
+                       /* CCK, rate 32, reduce txpower for CCK */
+                       if (i == POWER_TBL_CCK_ENTRY)
+                               power_idx +=
+                                   IL_TX_POWER_CCK_COMPENSATION_C_STEP;
+
+                       /* stay within the table! */
+                       if (power_idx > 107) {
+                               IL_WARN("txpower idx %d > 107\n", power_idx);
+                               power_idx = 107;
+                       }
+                       if (power_idx < 0) {
+                               IL_WARN("txpower idx %d < 0\n", power_idx);
+                               power_idx = 0;
+                       }
+
+                       /* fill txpower command for this rate/chain */
+                       tx_power.s.radio_tx_gain[c] =
+                           gain_table[band][power_idx].radio;
+                       tx_power.s.dsp_predis_atten[c] =
+                           gain_table[band][power_idx].dsp;
+
+                       D_TXPOWER("chain %d mimo %d idx %d "
+                                 "gain 0x%02x dsp %d\n", c, atten_value,
+                                 power_idx, tx_power.s.radio_tx_gain[c],
+                                 tx_power.s.dsp_predis_atten[c]);
+               }               /* for each chain */
+
+               tx_power_tbl->power_tbl[i].dw = cpu_to_le32(tx_power.dw);
+
+       }                       /* for each rate */
+
+       return 0;
+}
+
+/**
+ * il4965_send_tx_power - Configure the TXPOWER level user limit
+ *
+ * Uses the active RXON for channel, band, and characteristics (ht40, high)
+ * The power limit is taken from il->tx_power_user_lmt.
+ */
+static int
+il4965_send_tx_power(struct il_priv *il)
+{
+       struct il4965_txpowertable_cmd cmd = { 0 };
+       int ret;
+       u8 band = 0;
+       bool is_ht40 = false;
+       u8 ctrl_chan_high = 0;
+
+       if (WARN_ONCE
+           (test_bit(S_SCAN_HW, &il->status),
+            "TX Power requested while scanning!\n"))
+               return -EAGAIN;
+
+       band = il->band == IEEE80211_BAND_2GHZ;
+
+       is_ht40 = iw4965_is_ht40_channel(il->active.flags);
+
+       if (is_ht40 && (il->active.flags & RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK))
+               ctrl_chan_high = 1;
+
+       cmd.band = band;
+       cmd.channel = il->active.channel;
+
+       ret =
+           il4965_fill_txpower_tbl(il, band, le16_to_cpu(il->active.channel),
+                                   is_ht40, ctrl_chan_high, &cmd.tx_power);
+       if (ret)
+               goto out;
+
+       ret = il_send_cmd_pdu(il, C_TX_PWR_TBL, sizeof(cmd), &cmd);
+
+out:
+       return ret;
+}
+
+static int
+il4965_send_rxon_assoc(struct il_priv *il)
+{
+       int ret = 0;
+       struct il4965_rxon_assoc_cmd rxon_assoc;
+       const struct il_rxon_cmd *rxon1 = &il->staging;
+       const struct il_rxon_cmd *rxon2 = &il->active;
+
+       if (rxon1->flags == rxon2->flags &&
+           rxon1->filter_flags == rxon2->filter_flags &&
+           rxon1->cck_basic_rates == rxon2->cck_basic_rates &&
+           rxon1->ofdm_ht_single_stream_basic_rates ==
+           rxon2->ofdm_ht_single_stream_basic_rates &&
+           rxon1->ofdm_ht_dual_stream_basic_rates ==
+           rxon2->ofdm_ht_dual_stream_basic_rates &&
+           rxon1->rx_chain == rxon2->rx_chain &&
+           rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates) {
+               D_INFO("Using current RXON_ASSOC.  Not resending.\n");
+               return 0;
+       }
+
+       rxon_assoc.flags = il->staging.flags;
+       rxon_assoc.filter_flags = il->staging.filter_flags;
+       rxon_assoc.ofdm_basic_rates = il->staging.ofdm_basic_rates;
+       rxon_assoc.cck_basic_rates = il->staging.cck_basic_rates;
+       rxon_assoc.reserved = 0;
+       rxon_assoc.ofdm_ht_single_stream_basic_rates =
+           il->staging.ofdm_ht_single_stream_basic_rates;
+       rxon_assoc.ofdm_ht_dual_stream_basic_rates =
+           il->staging.ofdm_ht_dual_stream_basic_rates;
+       rxon_assoc.rx_chain_select_flags = il->staging.rx_chain;
+
+       ret =
+           il_send_cmd_pdu_async(il, C_RXON_ASSOC, sizeof(rxon_assoc),
+                                 &rxon_assoc, NULL);
+
+       return ret;
+}
+
+static int
+il4965_commit_rxon(struct il_priv *il)
+{
+       /* cast away the const for active_rxon in this function */
+       struct il_rxon_cmd *active_rxon = (void *)&il->active;
+       int ret;
+       bool new_assoc = !!(il->staging.filter_flags & RXON_FILTER_ASSOC_MSK);
+
+       if (!il_is_alive(il))
+               return -EBUSY;
+
+       /* always get timestamp with Rx frame */
+       il->staging.flags |= RXON_FLG_TSF2HOST_MSK;
+
+       ret = il_check_rxon_cmd(il);
+       if (ret) {
+               IL_ERR("Invalid RXON configuration.  Not committing.\n");
+               return -EINVAL;
+       }
+
+       /*
+        * receive commit_rxon request
+        * abort any previous channel switch if still in process
+        */
+       if (test_bit(S_CHANNEL_SWITCH_PENDING, &il->status) &&
+           il->switch_channel != il->staging.channel) {
+               D_11H("abort channel switch on %d\n",
+                     le16_to_cpu(il->switch_channel));
+               il_chswitch_done(il, false);
+       }
+
+       /* If we don't need to send a full RXON, we can use
+        * il_rxon_assoc_cmd which is used to reconfigure filter
+        * and other flags for the current radio configuration. */
+       if (!il_full_rxon_required(il)) {
+               ret = il_send_rxon_assoc(il);
+               if (ret) {
+                       IL_ERR("Error setting RXON_ASSOC (%d)\n", ret);
+                       return ret;
+               }
+
+               memcpy(active_rxon, &il->staging, sizeof(*active_rxon));
+               il_print_rx_config_cmd(il);
+               /*
+                * We do not commit tx power settings while channel changing,
+                * do it now if tx power changed.
+                */
+               il_set_tx_power(il, il->tx_power_next, false);
+               return 0;
+       }
+
+       /* If we are currently associated and the new config requires
+        * 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 (il_is_associated(il) && new_assoc) {
+               D_INFO("Toggling associated bit on current RXON\n");
+               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+
+               ret =
+                   il_send_cmd_pdu(il, C_RXON,
+                                   sizeof(struct il_rxon_cmd), active_rxon);
+
+               /* If the mask clearing failed then we set
+                * active_rxon back to what it was previously */
+               if (ret) {
+                       active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
+                       IL_ERR("Error clearing ASSOC_MSK (%d)\n", ret);
+                       return ret;
+               }
+               il_clear_ucode_stations(il);
+               il_restore_stations(il);
+               ret = il4965_restore_default_wep_keys(il);
+               if (ret) {
+                       IL_ERR("Failed to restore WEP keys (%d)\n", ret);
+                       return ret;
+               }
+       }
+
+       D_INFO("Sending RXON\n" "* with%s RXON_FILTER_ASSOC_MSK\n"
+              "* channel = %d\n" "* bssid = %pM\n", (new_assoc ? "" : "out"),
+              le16_to_cpu(il->staging.channel), il->staging.bssid_addr);
+
+       il_set_rxon_hwcrypto(il, !il->cfg->mod_params->sw_crypto);
+
+       /* Apply the new configuration
+        * RXON unassoc clears the station table in uCode so restoration of
+        * stations is needed after it (the RXON command) completes
+        */
+       if (!new_assoc) {
+               ret =
+                   il_send_cmd_pdu(il, C_RXON,
+                                   sizeof(struct il_rxon_cmd), &il->staging);
+               if (ret) {
+                       IL_ERR("Error setting new RXON (%d)\n", ret);
+                       return ret;
+               }
+               D_INFO("Return from !new_assoc RXON.\n");
+               memcpy(active_rxon, &il->staging, sizeof(*active_rxon));
+               il_clear_ucode_stations(il);
+               il_restore_stations(il);
+               ret = il4965_restore_default_wep_keys(il);
+               if (ret) {
+                       IL_ERR("Failed to restore WEP keys (%d)\n", ret);
+                       return ret;
+               }
+       }
+       if (new_assoc) {
+               il->start_calib = 0;
+               /* Apply the new configuration
+                * RXON assoc doesn't clear the station table in uCode,
+                */
+               ret =
+                   il_send_cmd_pdu(il, C_RXON,
+                                   sizeof(struct il_rxon_cmd), &il->staging);
+               if (ret) {
+                       IL_ERR("Error setting new RXON (%d)\n", ret);
+                       return ret;
+               }
+               memcpy(active_rxon, &il->staging, sizeof(*active_rxon));
+       }
+       il_print_rx_config_cmd(il);
+
+       il4965_init_sensitivity(il);
+
+       /* If we issue a new RXON command which required a tune then we must
+        * send a new TXPOWER command or we won't be able to Tx any frames */
+       ret = il_set_tx_power(il, il->tx_power_next, true);
+       if (ret) {
+               IL_ERR("Error sending TX power (%d)\n", ret);
+               return ret;
+       }
+
+       return 0;
+}
+
+static int
+il4965_hw_channel_switch(struct il_priv *il,
+                        struct ieee80211_channel_switch *ch_switch)
+{
+       int rc;
+       u8 band = 0;
+       bool is_ht40 = false;
+       u8 ctrl_chan_high = 0;
+       struct il4965_channel_switch_cmd cmd;
+       const struct il_channel_info *ch_info;
+       u32 switch_time_in_usec, ucode_switch_time;
+       u16 ch;
+       u32 tsf_low;
+       u8 switch_count;
+       u16 beacon_interval = le16_to_cpu(il->timing.beacon_interval);
+       struct ieee80211_vif *vif = il->vif;
+       band = (il->band == IEEE80211_BAND_2GHZ);
+
+       if (WARN_ON_ONCE(vif == NULL))
+               return -EIO;
+
+       is_ht40 = iw4965_is_ht40_channel(il->staging.flags);
+
+       if (is_ht40 && (il->staging.flags & RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK))
+               ctrl_chan_high = 1;
+
+       cmd.band = band;
+       cmd.expect_beacon = 0;
+       ch = ch_switch->chandef.chan->hw_value;
+       cmd.channel = cpu_to_le16(ch);
+       cmd.rxon_flags = il->staging.flags;
+       cmd.rxon_filter_flags = il->staging.filter_flags;
+       switch_count = ch_switch->count;
+       tsf_low = ch_switch->timestamp & 0x0ffffffff;
+       /*
+        * calculate the ucode channel switch time
+        * adding TSF as one of the factor for when to switch
+        */
+       if (il->ucode_beacon_time > tsf_low && beacon_interval) {
+               if (switch_count >
+                   ((il->ucode_beacon_time - tsf_low) / beacon_interval)) {
+                       switch_count -=
+                           (il->ucode_beacon_time - tsf_low) / beacon_interval;
+               } else
+                       switch_count = 0;
+       }
+       if (switch_count <= 1)
+               cmd.switch_time = cpu_to_le32(il->ucode_beacon_time);
+       else {
+               switch_time_in_usec =
+                   vif->bss_conf.beacon_int * switch_count * TIME_UNIT;
+               ucode_switch_time =
+                   il_usecs_to_beacons(il, switch_time_in_usec,
+                                       beacon_interval);
+               cmd.switch_time =
+                   il_add_beacon_time(il, il->ucode_beacon_time,
+                                      ucode_switch_time, beacon_interval);
+       }
+       D_11H("uCode time for the switch is 0x%x\n", cmd.switch_time);
+       ch_info = il_get_channel_info(il, il->band, ch);
+       if (ch_info)
+               cmd.expect_beacon = il_is_channel_radar(ch_info);
+       else {
+               IL_ERR("invalid channel switch from %u to %u\n",
+                      il->active.channel, ch);
+               return -EFAULT;
+       }
+
+       rc = il4965_fill_txpower_tbl(il, band, ch, is_ht40, ctrl_chan_high,
+                                    &cmd.tx_power);
+       if (rc) {
+               D_11H("error:%d  fill txpower_tbl\n", rc);
+               return rc;
+       }
+
+       return il_send_cmd_pdu(il, C_CHANNEL_SWITCH, sizeof(cmd), &cmd);
+}
+
+/**
+ * il4965_txq_update_byte_cnt_tbl - Set up entry in Tx byte-count array
+ */
+static void
+il4965_txq_update_byte_cnt_tbl(struct il_priv *il, struct il_tx_queue *txq,
+                              u16 byte_cnt)
+{
+       struct il4965_scd_bc_tbl *scd_bc_tbl = il->scd_bc_tbls.addr;
+       int txq_id = txq->q.id;
+       int write_ptr = txq->q.write_ptr;
+       int len = byte_cnt + IL_TX_CRC_SIZE + IL_TX_DELIMITER_SIZE;
+       __le16 bc_ent;
+
+       WARN_ON(len > 0xFFF || write_ptr >= TFD_QUEUE_SIZE_MAX);
+
+       bc_ent = cpu_to_le16(len & 0xFFF);
+       /* Set up byte count within first 256 entries */
+       scd_bc_tbl[txq_id].tfd_offset[write_ptr] = bc_ent;
+
+       /* If within first 64 entries, duplicate at end */
+       if (write_ptr < TFD_QUEUE_SIZE_BC_DUP)
+               scd_bc_tbl[txq_id].tfd_offset[TFD_QUEUE_SIZE_MAX + write_ptr] =
+                   bc_ent;
+}
+
+/**
+ * il4965_hw_get_temperature - return the calibrated temperature (in Kelvin)
+ * @stats: Provides the temperature reading from the uCode
+ *
+ * A return of <0 indicates bogus data in the stats
+ */
+static int
+il4965_hw_get_temperature(struct il_priv *il)
+{
+       s32 temperature;
+       s32 vt;
+       s32 R1, R2, R3;
+       u32 R4;
+
+       if (test_bit(S_TEMPERATURE, &il->status) &&
+           (il->_4965.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK)) {
+               D_TEMP("Running HT40 temperature calibration\n");
+               R1 = (s32) le32_to_cpu(il->card_alive_init.therm_r1[1]);
+               R2 = (s32) le32_to_cpu(il->card_alive_init.therm_r2[1]);
+               R3 = (s32) le32_to_cpu(il->card_alive_init.therm_r3[1]);
+               R4 = le32_to_cpu(il->card_alive_init.therm_r4[1]);
+       } else {
+               D_TEMP("Running temperature calibration\n");
+               R1 = (s32) le32_to_cpu(il->card_alive_init.therm_r1[0]);
+               R2 = (s32) le32_to_cpu(il->card_alive_init.therm_r2[0]);
+               R3 = (s32) le32_to_cpu(il->card_alive_init.therm_r3[0]);
+               R4 = le32_to_cpu(il->card_alive_init.therm_r4[0]);
+       }
+
+       /*
+        * Temperature is only 23 bits, so sign extend out to 32.
+        *
+        * NOTE If we haven't received a stats notification yet
+        * with an updated temperature, use R4 provided to us in the
+        * "initialize" ALIVE response.
+        */
+       if (!test_bit(S_TEMPERATURE, &il->status))
+               vt = sign_extend32(R4, 23);
+       else
+               vt = sign_extend32(le32_to_cpu
+                                  (il->_4965.stats.general.common.temperature),
+                                  23);
+
+       D_TEMP("Calib values R[1-3]: %d %d %d R4: %d\n", R1, R2, R3, vt);
+
+       if (R3 == R1) {
+               IL_ERR("Calibration conflict R1 == R3\n");
+               return -1;
+       }
+
+       /* Calculate temperature in degrees Kelvin, adjust by 97%.
+        * Add offset to center the adjustment around 0 degrees Centigrade. */
+       temperature = TEMPERATURE_CALIB_A_VAL * (vt - R2);
+       temperature /= (R3 - R1);
+       temperature =
+           (temperature * 97) / 100 + TEMPERATURE_CALIB_KELVIN_OFFSET;
+
+       D_TEMP("Calibrated temperature: %dK, %dC\n", temperature,
+              KELVIN_TO_CELSIUS(temperature));
+
+       return temperature;
+}
+
+/* Adjust Txpower only if temperature variance is greater than threshold. */
+#define IL_TEMPERATURE_THRESHOLD   3
+
+/**
+ * il4965_is_temp_calib_needed - determines if new calibration is needed
+ *
+ * If the temperature changed has changed sufficiently, then a recalibration
+ * is needed.
+ *
+ * Assumes caller will replace il->last_temperature once calibration
+ * executed.
+ */
+static int
+il4965_is_temp_calib_needed(struct il_priv *il)
+{
+       int temp_diff;
+
+       if (!test_bit(S_STATS, &il->status)) {
+               D_TEMP("Temperature not updated -- no stats.\n");
+               return 0;
+       }
+
+       temp_diff = il->temperature - il->last_temperature;
+
+       /* get absolute value */
+       if (temp_diff < 0) {
+               D_POWER("Getting cooler, delta %d\n", temp_diff);
+               temp_diff = -temp_diff;
+       } else if (temp_diff == 0)
+               D_POWER("Temperature unchanged\n");
+       else
+               D_POWER("Getting warmer, delta %d\n", temp_diff);
+
+       if (temp_diff < IL_TEMPERATURE_THRESHOLD) {
+               D_POWER(" => thermal txpower calib not needed\n");
+               return 0;
+       }
+
+       D_POWER(" => thermal txpower calib needed\n");
+
+       return 1;
+}
+
+void
+il4965_temperature_calib(struct il_priv *il)
+{
+       s32 temp;
+
+       temp = il4965_hw_get_temperature(il);
+       if (IL_TX_POWER_TEMPERATURE_OUT_OF_RANGE(temp))
+               return;
+
+       if (il->temperature != temp) {
+               if (il->temperature)
+                       D_TEMP("Temperature changed " "from %dC to %dC\n",
+                              KELVIN_TO_CELSIUS(il->temperature),
+                              KELVIN_TO_CELSIUS(temp));
+               else
+                       D_TEMP("Temperature " "initialized to %dC\n",
+                              KELVIN_TO_CELSIUS(temp));
+       }
+
+       il->temperature = temp;
+       set_bit(S_TEMPERATURE, &il->status);
+
+       if (!il->disable_tx_power_cal &&
+           unlikely(!test_bit(S_SCANNING, &il->status)) &&
+           il4965_is_temp_calib_needed(il))
+               queue_work(il->workqueue, &il->txpower_work);
+}
+
+static u16
+il4965_get_hcmd_size(u8 cmd_id, u16 len)
+{
+       switch (cmd_id) {
+       case C_RXON:
+               return (u16) sizeof(struct il4965_rxon_cmd);
+       default:
+               return len;
+       }
+}
+
+static u16
+il4965_build_addsta_hcmd(const struct il_addsta_cmd *cmd, u8 * data)
+{
+       struct il4965_addsta_cmd *addsta = (struct il4965_addsta_cmd *)data;
+       addsta->mode = cmd->mode;
+       memcpy(&addsta->sta, &cmd->sta, sizeof(struct sta_id_modify));
+       memcpy(&addsta->key, &cmd->key, sizeof(struct il4965_keyinfo));
+       addsta->station_flags = cmd->station_flags;
+       addsta->station_flags_msk = cmd->station_flags_msk;
+       addsta->tid_disable_tx = cmd->tid_disable_tx;
+       addsta->add_immediate_ba_tid = cmd->add_immediate_ba_tid;
+       addsta->remove_immediate_ba_tid = cmd->remove_immediate_ba_tid;
+       addsta->add_immediate_ba_ssn = cmd->add_immediate_ba_ssn;
+       addsta->sleep_tx_count = cmd->sleep_tx_count;
+       addsta->reserved1 = cpu_to_le16(0);
+       addsta->reserved2 = cpu_to_le16(0);
+
+       return (u16) sizeof(struct il4965_addsta_cmd);
+}
+
+static void
+il4965_post_scan(struct il_priv *il)
+{
+       /*
+        * Since setting the RXON may have been deferred while
+        * performing the scan, fire one off if needed
+        */
+       if (memcmp(&il->staging, &il->active, sizeof(il->staging)))
+               il_commit_rxon(il);
+}
+
+static void
+il4965_post_associate(struct il_priv *il)
+{
+       struct ieee80211_vif *vif = il->vif;
+       int ret = 0;
+
+       if (!vif || !il->is_open)
+               return;
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       il_scan_cancel_timeout(il, 200);
+
+       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+       il_commit_rxon(il);
+
+       ret = il_send_rxon_timing(il);
+       if (ret)
+               IL_WARN("RXON timing - " "Attempting to continue.\n");
+
+       il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
+
+       il_set_rxon_ht(il, &il->current_ht_config);
+
+       if (il->ops->set_rxon_chain)
+               il->ops->set_rxon_chain(il);
+
+       il->staging.assoc_id = cpu_to_le16(vif->bss_conf.aid);
+
+       D_ASSOC("assoc id %d beacon interval %d\n", vif->bss_conf.aid,
+               vif->bss_conf.beacon_int);
+
+       if (vif->bss_conf.use_short_preamble)
+               il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+       else
+               il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+
+       if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
+               if (vif->bss_conf.use_short_slot)
+                       il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
+               else
+                       il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
+       }
+
+       il_commit_rxon(il);
+
+       D_ASSOC("Associated as %d to: %pM\n", vif->bss_conf.aid,
+               il->active.bssid_addr);
+
+       switch (vif->type) {
+       case NL80211_IFTYPE_STATION:
+               break;
+       case NL80211_IFTYPE_ADHOC:
+               il4965_send_beacon_cmd(il);
+               break;
+       default:
+               IL_ERR("%s Should not be called in %d mode\n", __func__,
+                      vif->type);
+               break;
+       }
+
+       /* the chain noise calibration will enabled PM upon completion
+        * If chain noise has already been run, then we need to enable
+        * power management here */
+       if (il->chain_noise_data.state == IL_CHAIN_NOISE_DONE)
+               il_power_update_mode(il, false);
+
+       /* Enable Rx differential gain and sensitivity calibrations */
+       il4965_chain_noise_reset(il);
+       il->start_calib = 1;
+}
+
+static void
+il4965_config_ap(struct il_priv *il)
+{
+       struct ieee80211_vif *vif = il->vif;
+       int ret = 0;
+
+       lockdep_assert_held(&il->mutex);
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       /* The following should be done only at AP bring up */
+       if (!il_is_associated(il)) {
+
+               /* RXON - unassoc (to set timing command) */
+               il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+               il_commit_rxon(il);
+
+               /* RXON Timing */
+               ret = il_send_rxon_timing(il);
+               if (ret)
+                       IL_WARN("RXON timing failed - "
+                               "Attempting to continue.\n");
+
+               /* AP has all antennas */
+               il->chain_noise_data.active_chains = il->hw_params.valid_rx_ant;
+               il_set_rxon_ht(il, &il->current_ht_config);
+               if (il->ops->set_rxon_chain)
+                       il->ops->set_rxon_chain(il);
+
+               il->staging.assoc_id = 0;
+
+               if (vif->bss_conf.use_short_preamble)
+                       il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+               else
+                       il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+
+               if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
+                       if (vif->bss_conf.use_short_slot)
+                               il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
+                       else
+                               il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
+               }
+               /* need to send beacon cmd before committing assoc RXON! */
+               il4965_send_beacon_cmd(il);
+               /* restore RXON assoc */
+               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
+               il_commit_rxon(il);
+       }
+       il4965_send_beacon_cmd(il);
+}
+
+const struct il_ops il4965_ops = {
+       .txq_update_byte_cnt_tbl = il4965_txq_update_byte_cnt_tbl,
+       .txq_attach_buf_to_tfd = il4965_hw_txq_attach_buf_to_tfd,
+       .txq_free_tfd = il4965_hw_txq_free_tfd,
+       .txq_init = il4965_hw_tx_queue_init,
+       .is_valid_rtc_data_addr = il4965_hw_valid_rtc_data_addr,
+       .init_alive_start = il4965_init_alive_start,
+       .load_ucode = il4965_load_bsm,
+       .dump_nic_error_log = il4965_dump_nic_error_log,
+       .dump_fh = il4965_dump_fh,
+       .set_channel_switch = il4965_hw_channel_switch,
+       .apm_init = il_apm_init,
+       .send_tx_power = il4965_send_tx_power,
+       .update_chain_flags = il4965_update_chain_flags,
+       .eeprom_acquire_semaphore = il4965_eeprom_acquire_semaphore,
+       .eeprom_release_semaphore = il4965_eeprom_release_semaphore,
+
+       .rxon_assoc = il4965_send_rxon_assoc,
+       .commit_rxon = il4965_commit_rxon,
+       .set_rxon_chain = il4965_set_rxon_chain,
+
+       .get_hcmd_size = il4965_get_hcmd_size,
+       .build_addsta_hcmd = il4965_build_addsta_hcmd,
+       .request_scan = il4965_request_scan,
+       .post_scan = il4965_post_scan,
+
+       .post_associate = il4965_post_associate,
+       .config_ap = il4965_config_ap,
+       .manage_ibss_station = il4965_manage_ibss_station,
+       .update_bcast_stations = il4965_update_bcast_stations,
+
+       .send_led_cmd = il4965_send_led_cmd,
+};
+
+struct il_cfg il4965_cfg = {
+       .name = "Intel(R) Wireless WiFi Link 4965AGN",
+       .fw_name_pre = IL4965_FW_PRE,
+       .ucode_api_max = IL4965_UCODE_API_MAX,
+       .ucode_api_min = IL4965_UCODE_API_MIN,
+       .sku = IL_SKU_A | IL_SKU_G | IL_SKU_N,
+       .valid_tx_ant = ANT_AB,
+       .valid_rx_ant = ANT_ABC,
+       .eeprom_ver = EEPROM_4965_EEPROM_VERSION,
+       .eeprom_calib_ver = EEPROM_4965_TX_POWER_VERSION,
+       .mod_params = &il4965_mod_params,
+       .led_mode = IL_LED_BLINK,
+       /*
+        * Force use of chains B and C for scan RX on 5 GHz band
+        * because the device has off-channel reception on chain A.
+        */
+       .scan_rx_antennas[IEEE80211_BAND_5GHZ] = ANT_BC,
+
+       .eeprom_size = IL4965_EEPROM_IMG_SIZE,
+       .num_of_queues = IL49_NUM_QUEUES,
+       .num_of_ampdu_queues = IL49_NUM_AMPDU_QUEUES,
+       .pll_cfg_val = 0,
+       .set_l0s = true,
+       .use_bsm = true,
+       .led_compensation = 61,
+       .chain_noise_num_beacons = IL4965_CAL_NUM_BEACONS,
+       .wd_timeout = IL_DEF_WD_TIMEOUT,
+       .temperature_kelvin = true,
+       .ucode_tracing = true,
+       .sensitivity_calib_by_driver = true,
+       .chain_noise_calib_by_driver = true,
+
+       .regulatory_bands = {
+               EEPROM_REGULATORY_BAND_1_CHANNELS,
+               EEPROM_REGULATORY_BAND_2_CHANNELS,
+               EEPROM_REGULATORY_BAND_3_CHANNELS,
+               EEPROM_REGULATORY_BAND_4_CHANNELS,
+               EEPROM_REGULATORY_BAND_5_CHANNELS,
+               EEPROM_4965_REGULATORY_BAND_24_HT40_CHANNELS,
+               EEPROM_4965_REGULATORY_BAND_52_HT40_CHANNELS
+       },
+
+};
+
+/* Module firmware */
+MODULE_FIRMWARE(IL4965_MODULE_FIRMWARE(IL4965_UCODE_API_MAX));
diff --git a/drivers/net/wireless/intel/iwlegacy/4965.h b/drivers/net/wireless/intel/iwlegacy/4965.h
new file mode 100644 (file)
index 0000000..8ab8706
--- /dev/null
@@ -0,0 +1,1285 @@
+/******************************************************************************
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#ifndef __il_4965_h__
+#define __il_4965_h__
+
+struct il_rx_queue;
+struct il_rx_buf;
+struct il_rx_pkt;
+struct il_tx_queue;
+struct il_rxon_context;
+
+/* configuration for the _4965 devices */
+extern struct il_cfg il4965_cfg;
+extern const struct il_ops il4965_ops;
+
+extern struct il_mod_params il4965_mod_params;
+
+/* tx queue */
+void il4965_free_tfds_in_queue(struct il_priv *il, int sta_id, int tid,
+                              int freed);
+
+/* RXON */
+void il4965_set_rxon_chain(struct il_priv *il);
+
+/* uCode */
+int il4965_verify_ucode(struct il_priv *il);
+
+/* lib */
+void il4965_check_abort_status(struct il_priv *il, u8 frame_count, u32 status);
+
+void il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq);
+int il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq);
+int il4965_hw_nic_init(struct il_priv *il);
+int il4965_dump_fh(struct il_priv *il, char **buf, bool display);
+
+void il4965_nic_config(struct il_priv *il);
+
+/* rx */
+void il4965_rx_queue_restock(struct il_priv *il);
+void il4965_rx_replenish(struct il_priv *il);
+void il4965_rx_replenish_now(struct il_priv *il);
+void il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq);
+int il4965_rxq_stop(struct il_priv *il);
+int il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band);
+void il4965_rx_handle(struct il_priv *il);
+
+/* tx */
+void il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq);
+int il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
+                                   dma_addr_t addr, u16 len, u8 reset, u8 pad);
+int il4965_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq);
+void il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
+                                struct ieee80211_tx_info *info);
+int il4965_tx_skb(struct il_priv *il,
+                 struct ieee80211_sta *sta,
+                 struct sk_buff *skb);
+int il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
+                       struct ieee80211_sta *sta, u16 tid, u16 * ssn);
+int il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
+                      struct ieee80211_sta *sta, u16 tid);
+int il4965_txq_check_empty(struct il_priv *il, int sta_id, u8 tid, int txq_id);
+int il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx);
+void il4965_hw_txq_ctx_free(struct il_priv *il);
+int il4965_txq_ctx_alloc(struct il_priv *il);
+void il4965_txq_ctx_reset(struct il_priv *il);
+void il4965_txq_ctx_stop(struct il_priv *il);
+void il4965_txq_set_sched(struct il_priv *il, u32 mask);
+
+/*
+ * Acquire il->lock before calling this function !
+ */
+void il4965_set_wr_ptrs(struct il_priv *il, int txq_id, u32 idx);
+/**
+ * il4965_tx_queue_set_status - (optionally) start Tx/Cmd queue
+ * @tx_fifo_id: Tx DMA/FIFO channel (range 0-7) that the queue will feed
+ * @scd_retry: (1) Indicates queue will be used in aggregation mode
+ *
+ * NOTE:  Acquire il->lock before calling this function !
+ */
+void il4965_tx_queue_set_status(struct il_priv *il, struct il_tx_queue *txq,
+                               int tx_fifo_id, int scd_retry);
+
+/* scan */
+int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif);
+
+/* station mgmt */
+int il4965_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
+                              bool add);
+
+/* hcmd */
+int il4965_send_beacon_cmd(struct il_priv *il);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+const char *il4965_get_tx_fail_reason(u32 status);
+#else
+static inline const char *
+il4965_get_tx_fail_reason(u32 status)
+{
+       return "";
+}
+#endif
+
+/* station management */
+int il4965_alloc_bcast_station(struct il_priv *il);
+int il4965_add_bssid_station(struct il_priv *il, const u8 *addr, u8 *sta_id_r);
+int il4965_remove_default_wep_key(struct il_priv *il,
+                                 struct ieee80211_key_conf *key);
+int il4965_set_default_wep_key(struct il_priv *il,
+                              struct ieee80211_key_conf *key);
+int il4965_restore_default_wep_keys(struct il_priv *il);
+int il4965_set_dynamic_key(struct il_priv *il,
+                          struct ieee80211_key_conf *key, u8 sta_id);
+int il4965_remove_dynamic_key(struct il_priv *il,
+                             struct ieee80211_key_conf *key, u8 sta_id);
+void il4965_update_tkip_key(struct il_priv *il,
+                           struct ieee80211_key_conf *keyconf,
+                           struct ieee80211_sta *sta, u32 iv32,
+                           u16 *phase1key);
+int il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid);
+int il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta,
+                           int tid, u16 ssn);
+int il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta,
+                          int tid);
+void il4965_sta_modify_sleep_tx_count(struct il_priv *il, int sta_id, int cnt);
+int il4965_update_bcast_stations(struct il_priv *il);
+
+/* rate */
+static inline u8
+il4965_hw_get_rate(__le32 rate_n_flags)
+{
+       return le32_to_cpu(rate_n_flags) & 0xFF;
+}
+
+/* eeprom */
+void il4965_eeprom_get_mac(const struct il_priv *il, u8 * mac);
+int il4965_eeprom_acquire_semaphore(struct il_priv *il);
+void il4965_eeprom_release_semaphore(struct il_priv *il);
+int il4965_eeprom_check_version(struct il_priv *il);
+
+/* mac80211 handlers (for 4965) */
+void il4965_mac_tx(struct ieee80211_hw *hw,
+                  struct ieee80211_tx_control *control,
+                  struct sk_buff *skb);
+int il4965_mac_start(struct ieee80211_hw *hw);
+void il4965_mac_stop(struct ieee80211_hw *hw);
+void il4965_configure_filter(struct ieee80211_hw *hw,
+                            unsigned int changed_flags,
+                            unsigned int *total_flags, u64 multicast);
+int il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
+                      struct ieee80211_vif *vif, struct ieee80211_sta *sta,
+                      struct ieee80211_key_conf *key);
+void il4965_mac_update_tkip_key(struct ieee80211_hw *hw,
+                               struct ieee80211_vif *vif,
+                               struct ieee80211_key_conf *keyconf,
+                               struct ieee80211_sta *sta, u32 iv32,
+                               u16 *phase1key);
+int il4965_mac_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                           enum ieee80211_ampdu_mlme_action action,
+                           struct ieee80211_sta *sta, u16 tid, u16 * ssn,
+                           u8 buf_size, bool amsdu);
+int il4965_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                      struct ieee80211_sta *sta);
+void
+il4965_mac_channel_switch(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                         struct ieee80211_channel_switch *ch_switch);
+
+void il4965_led_enable(struct il_priv *il);
+
+/* EEPROM */
+#define IL4965_EEPROM_IMG_SIZE                 1024
+
+/*
+ * uCode queue management definitions ...
+ * The first queue used for block-ack aggregation is #7 (4965 only).
+ * All block-ack aggregation queues should map to Tx DMA/FIFO channel 7.
+ */
+#define IL49_FIRST_AMPDU_QUEUE 7
+
+/* Sizes and addresses for instruction and data memory (SRAM) in
+ * 4965's embedded processor.  Driver access is via HBUS_TARG_MEM_* regs. */
+#define IL49_RTC_INST_LOWER_BOUND              (0x000000)
+#define IL49_RTC_INST_UPPER_BOUND              (0x018000)
+
+#define IL49_RTC_DATA_LOWER_BOUND              (0x800000)
+#define IL49_RTC_DATA_UPPER_BOUND              (0x80A000)
+
+#define IL49_RTC_INST_SIZE  (IL49_RTC_INST_UPPER_BOUND - \
+                               IL49_RTC_INST_LOWER_BOUND)
+#define IL49_RTC_DATA_SIZE  (IL49_RTC_DATA_UPPER_BOUND - \
+                               IL49_RTC_DATA_LOWER_BOUND)
+
+#define IL49_MAX_INST_SIZE IL49_RTC_INST_SIZE
+#define IL49_MAX_DATA_SIZE IL49_RTC_DATA_SIZE
+
+/* Size of uCode instruction memory in bootstrap state machine */
+#define IL49_MAX_BSM_SIZE BSM_SRAM_SIZE
+
+static inline int
+il4965_hw_valid_rtc_data_addr(u32 addr)
+{
+       return (addr >= IL49_RTC_DATA_LOWER_BOUND &&
+               addr < IL49_RTC_DATA_UPPER_BOUND);
+}
+
+/********************* START TEMPERATURE *************************************/
+
+/**
+ * 4965 temperature calculation.
+ *
+ * The driver must calculate the device temperature before calculating
+ * a txpower setting (amplifier gain is temperature dependent).  The
+ * calculation uses 4 measurements, 3 of which (R1, R2, R3) are calibration
+ * values used for the life of the driver, and one of which (R4) is the
+ * real-time temperature indicator.
+ *
+ * uCode provides all 4 values to the driver via the "initialize alive"
+ * notification (see struct il4965_init_alive_resp).  After the runtime uCode
+ * image loads, uCode updates the R4 value via stats notifications
+ * (see N_STATS), which occur after each received beacon
+ * when associated, or can be requested via C_STATS.
+ *
+ * NOTE:  uCode provides the R4 value as a 23-bit signed value.  Driver
+ *        must sign-extend to 32 bits before applying formula below.
+ *
+ * Formula:
+ *
+ * degrees Kelvin = ((97 * 259 * (R4 - R2) / (R3 - R1)) / 100) + 8
+ *
+ * NOTE:  The basic formula is 259 * (R4-R2) / (R3-R1).  The 97/100 is
+ * an additional correction, which should be centered around 0 degrees
+ * Celsius (273 degrees Kelvin).  The 8 (3 percent of 273) compensates for
+ * centering the 97/100 correction around 0 degrees K.
+ *
+ * Add 273 to Kelvin value to find degrees Celsius, for comparing current
+ * temperature with factory-measured temperatures when calculating txpower
+ * settings.
+ */
+#define TEMPERATURE_CALIB_KELVIN_OFFSET 8
+#define TEMPERATURE_CALIB_A_VAL 259
+
+/* Limit range of calculated temperature to be between these Kelvin values */
+#define IL_TX_POWER_TEMPERATURE_MIN  (263)
+#define IL_TX_POWER_TEMPERATURE_MAX  (410)
+
+#define IL_TX_POWER_TEMPERATURE_OUT_OF_RANGE(t) \
+       ((t) < IL_TX_POWER_TEMPERATURE_MIN || \
+        (t) > IL_TX_POWER_TEMPERATURE_MAX)
+
+void il4965_temperature_calib(struct il_priv *il);
+/********************* END TEMPERATURE ***************************************/
+
+/********************* START TXPOWER *****************************************/
+
+/**
+ * 4965 txpower calculations rely on information from three sources:
+ *
+ *     1) EEPROM
+ *     2) "initialize" alive notification
+ *     3) stats notifications
+ *
+ * EEPROM data consists of:
+ *
+ * 1)  Regulatory information (max txpower and channel usage flags) is provided
+ *     separately for each channel that can possibly supported by 4965.
+ *     40 MHz wide (.11n HT40) channels are listed separately from 20 MHz
+ *     (legacy) channels.
+ *
+ *     See struct il4965_eeprom_channel for format, and struct il4965_eeprom
+ *     for locations in EEPROM.
+ *
+ * 2)  Factory txpower calibration information is provided separately for
+ *     sub-bands of contiguous channels.  2.4GHz has just one sub-band,
+ *     but 5 GHz has several sub-bands.
+ *
+ *     In addition, per-band (2.4 and 5 Ghz) saturation txpowers are provided.
+ *
+ *     See struct il4965_eeprom_calib_info (and the tree of structures
+ *     contained within it) for format, and struct il4965_eeprom for
+ *     locations in EEPROM.
+ *
+ * "Initialization alive" notification (see struct il4965_init_alive_resp)
+ * consists of:
+ *
+ * 1)  Temperature calculation parameters.
+ *
+ * 2)  Power supply voltage measurement.
+ *
+ * 3)  Tx gain compensation to balance 2 transmitters for MIMO use.
+ *
+ * Statistics notifications deliver:
+ *
+ * 1)  Current values for temperature param R4.
+ */
+
+/**
+ * To calculate a txpower setting for a given desired target txpower, channel,
+ * modulation bit rate, and transmitter chain (4965 has 2 transmitters to
+ * support MIMO and transmit diversity), driver must do the following:
+ *
+ * 1)  Compare desired txpower vs. (EEPROM) regulatory limit for this channel.
+ *     Do not exceed regulatory limit; reduce target txpower if necessary.
+ *
+ *     If setting up txpowers for MIMO rates (rate idxes 8-15, 24-31),
+ *     2 transmitters will be used simultaneously; driver must reduce the
+ *     regulatory limit by 3 dB (half-power) for each transmitter, so the
+ *     combined total output of the 2 transmitters is within regulatory limits.
+ *
+ *
+ * 2)  Compare target txpower vs. (EEPROM) saturation txpower *reduced by
+ *     backoff for this bit rate*.  Do not exceed (saturation - backoff[rate]);
+ *     reduce target txpower if necessary.
+ *
+ *     Backoff values below are in 1/2 dB units (equivalent to steps in
+ *     txpower gain tables):
+ *
+ *     OFDM 6 - 36 MBit:  10 steps (5 dB)
+ *     OFDM 48 MBit:      15 steps (7.5 dB)
+ *     OFDM 54 MBit:      17 steps (8.5 dB)
+ *     OFDM 60 MBit:      20 steps (10 dB)
+ *     CCK all rates:     10 steps (5 dB)
+ *
+ *     Backoff values apply to saturation txpower on a per-transmitter basis;
+ *     when using MIMO (2 transmitters), each transmitter uses the same
+ *     saturation level provided in EEPROM, and the same backoff values;
+ *     no reduction (such as with regulatory txpower limits) is required.
+ *
+ *     Saturation and Backoff values apply equally to 20 Mhz (legacy) channel
+ *     widths and 40 Mhz (.11n HT40) channel widths; there is no separate
+ *     factory measurement for ht40 channels.
+ *
+ *     The result of this step is the final target txpower.  The rest of
+ *     the steps figure out the proper settings for the device to achieve
+ *     that target txpower.
+ *
+ *
+ * 3)  Determine (EEPROM) calibration sub band for the target channel, by
+ *     comparing against first and last channels in each sub band
+ *     (see struct il4965_eeprom_calib_subband_info).
+ *
+ *
+ * 4)  Linearly interpolate (EEPROM) factory calibration measurement sets,
+ *     referencing the 2 factory-measured (sample) channels within the sub band.
+ *
+ *     Interpolation is based on difference between target channel's frequency
+ *     and the sample channels' frequencies.  Since channel numbers are based
+ *     on frequency (5 MHz between each channel number), this is equivalent
+ *     to interpolating based on channel number differences.
+ *
+ *     Note that the sample channels may or may not be the channels at the
+ *     edges of the sub band.  The target channel may be "outside" of the
+ *     span of the sampled channels.
+ *
+ *     Driver may choose the pair (for 2 Tx chains) of measurements (see
+ *     struct il4965_eeprom_calib_ch_info) for which the actual measured
+ *     txpower comes closest to the desired txpower.  Usually, though,
+ *     the middle set of measurements is closest to the regulatory limits,
+ *     and is therefore a good choice for all txpower calculations (this
+ *     assumes that high accuracy is needed for maximizing legal txpower,
+ *     while lower txpower configurations do not need as much accuracy).
+ *
+ *     Driver should interpolate both members of the chosen measurement pair,
+ *     i.e. for both Tx chains (radio transmitters), unless the driver knows
+ *     that only one of the chains will be used (e.g. only one tx antenna
+ *     connected, but this should be unusual).  The rate scaling algorithm
+ *     switches antennas to find best performance, so both Tx chains will
+ *     be used (although only one at a time) even for non-MIMO transmissions.
+ *
+ *     Driver should interpolate factory values for temperature, gain table
+ *     idx, and actual power.  The power amplifier detector values are
+ *     not used by the driver.
+ *
+ *     Sanity check:  If the target channel happens to be one of the sample
+ *     channels, the results should agree with the sample channel's
+ *     measurements!
+ *
+ *
+ * 5)  Find difference between desired txpower and (interpolated)
+ *     factory-measured txpower.  Using (interpolated) factory gain table idx
+ *     (shown elsewhere) as a starting point, adjust this idx lower to
+ *     increase txpower, or higher to decrease txpower, until the target
+ *     txpower is reached.  Each step in the gain table is 1/2 dB.
+ *
+ *     For example, if factory measured txpower is 16 dBm, and target txpower
+ *     is 13 dBm, add 6 steps to the factory gain idx to reduce txpower
+ *     by 3 dB.
+ *
+ *
+ * 6)  Find difference between current device temperature and (interpolated)
+ *     factory-measured temperature for sub-band.  Factory values are in
+ *     degrees Celsius.  To calculate current temperature, see comments for
+ *     "4965 temperature calculation".
+ *
+ *     If current temperature is higher than factory temperature, driver must
+ *     increase gain (lower gain table idx), and vice verse.
+ *
+ *     Temperature affects gain differently for different channels:
+ *
+ *     2.4 GHz all channels:  3.5 degrees per half-dB step
+ *     5 GHz channels 34-43:  4.5 degrees per half-dB step
+ *     5 GHz channels >= 44:  4.0 degrees per half-dB step
+ *
+ *     NOTE:  Temperature can increase rapidly when transmitting, especially
+ *            with heavy traffic at high txpowers.  Driver should update
+ *            temperature calculations often under these conditions to
+ *            maintain strong txpower in the face of rising temperature.
+ *
+ *
+ * 7)  Find difference between current power supply voltage indicator
+ *     (from "initialize alive") and factory-measured power supply voltage
+ *     indicator (EEPROM).
+ *
+ *     If the current voltage is higher (indicator is lower) than factory
+ *     voltage, gain should be reduced (gain table idx increased) by:
+ *
+ *     (eeprom - current) / 7
+ *
+ *     If the current voltage is lower (indicator is higher) than factory
+ *     voltage, gain should be increased (gain table idx decreased) by:
+ *
+ *     2 * (current - eeprom) / 7
+ *
+ *     If number of idx steps in either direction turns out to be > 2,
+ *     something is wrong ... just use 0.
+ *
+ *     NOTE:  Voltage compensation is independent of band/channel.
+ *
+ *     NOTE:  "Initialize" uCode measures current voltage, which is assumed
+ *            to be constant after this initial measurement.  Voltage
+ *            compensation for txpower (number of steps in gain table)
+ *            may be calculated once and used until the next uCode bootload.
+ *
+ *
+ * 8)  If setting up txpowers for MIMO rates (rate idxes 8-15, 24-31),
+ *     adjust txpower for each transmitter chain, so txpower is balanced
+ *     between the two chains.  There are 5 pairs of tx_atten[group][chain]
+ *     values in "initialize alive", one pair for each of 5 channel ranges:
+ *
+ *     Group 0:  5 GHz channel 34-43
+ *     Group 1:  5 GHz channel 44-70
+ *     Group 2:  5 GHz channel 71-124
+ *     Group 3:  5 GHz channel 125-200
+ *     Group 4:  2.4 GHz all channels
+ *
+ *     Add the tx_atten[group][chain] value to the idx for the target chain.
+ *     The values are signed, but are in pairs of 0 and a non-negative number,
+ *     so as to reduce gain (if necessary) of the "hotter" channel.  This
+ *     avoids any need to double-check for regulatory compliance after
+ *     this step.
+ *
+ *
+ * 9)  If setting up for a CCK rate, lower the gain by adding a CCK compensation
+ *     value to the idx:
+ *
+ *     Hardware rev B:  9 steps (4.5 dB)
+ *     Hardware rev C:  5 steps (2.5 dB)
+ *
+ *     Hardware rev for 4965 can be determined by reading CSR_HW_REV_WA_REG,
+ *     bits [3:2], 1 = B, 2 = C.
+ *
+ *     NOTE:  This compensation is in addition to any saturation backoff that
+ *            might have been applied in an earlier step.
+ *
+ *
+ * 10) Select the gain table, based on band (2.4 vs 5 GHz).
+ *
+ *     Limit the adjusted idx to stay within the table!
+ *
+ *
+ * 11) Read gain table entries for DSP and radio gain, place into appropriate
+ *     location(s) in command (struct il4965_txpowertable_cmd).
+ */
+
+/**
+ * When MIMO is used (2 transmitters operating simultaneously), driver should
+ * limit each transmitter to deliver a max of 3 dB below the regulatory limit
+ * for the device.  That is, use half power for each transmitter, so total
+ * txpower is within regulatory limits.
+ *
+ * The value "6" represents number of steps in gain table to reduce power 3 dB.
+ * Each step is 1/2 dB.
+ */
+#define IL_TX_POWER_MIMO_REGULATORY_COMPENSATION (6)
+
+/**
+ * CCK gain compensation.
+ *
+ * When calculating txpowers for CCK, after making sure that the target power
+ * is within regulatory and saturation limits, driver must additionally
+ * back off gain by adding these values to the gain table idx.
+ *
+ * Hardware rev for 4965 can be determined by reading CSR_HW_REV_WA_REG,
+ * bits [3:2], 1 = B, 2 = C.
+ */
+#define IL_TX_POWER_CCK_COMPENSATION_B_STEP (9)
+#define IL_TX_POWER_CCK_COMPENSATION_C_STEP (5)
+
+/*
+ * 4965 power supply voltage compensation for txpower
+ */
+#define TX_POWER_IL_VOLTAGE_CODES_PER_03V   (7)
+
+/**
+ * Gain tables.
+ *
+ * The following tables contain pair of values for setting txpower, i.e.
+ * gain settings for the output of the device's digital signal processor (DSP),
+ * and for the analog gain structure of the transmitter.
+ *
+ * Each entry in the gain tables represents a step of 1/2 dB.  Note that these
+ * are *relative* steps, not indications of absolute output power.  Output
+ * power varies with temperature, voltage, and channel frequency, and also
+ * requires consideration of average power (to satisfy regulatory constraints),
+ * and peak power (to avoid distortion of the output signal).
+ *
+ * Each entry contains two values:
+ * 1)  DSP gain (or sometimes called DSP attenuation).  This is a fine-grained
+ *     linear value that multiplies the output of the digital signal processor,
+ *     before being sent to the analog radio.
+ * 2)  Radio gain.  This sets the analog gain of the radio Tx path.
+ *     It is a coarser setting, and behaves in a logarithmic (dB) fashion.
+ *
+ * EEPROM contains factory calibration data for txpower.  This maps actual
+ * measured txpower levels to gain settings in the "well known" tables
+ * below ("well-known" means here that both factory calibration *and* the
+ * driver work with the same table).
+ *
+ * There are separate tables for 2.4 GHz and 5 GHz bands.  The 5 GHz table
+ * has an extension (into negative idxes), in case the driver needs to
+ * boost power setting for high device temperatures (higher than would be
+ * present during factory calibration).  A 5 Ghz EEPROM idx of "40"
+ * corresponds to the 49th entry in the table used by the driver.
+ */
+#define MIN_TX_GAIN_IDX                (0)     /* highest gain, lowest idx, 2.4 */
+#define MIN_TX_GAIN_IDX_52GHZ_EXT      (-9)    /* highest gain, lowest idx, 5 */
+
+/**
+ * 2.4 GHz gain table
+ *
+ * Index    Dsp gain   Radio gain
+ *   0        110         0x3f      (highest gain)
+ *   1        104         0x3f
+ *   2         98         0x3f
+ *   3        110         0x3e
+ *   4        104         0x3e
+ *   5         98         0x3e
+ *   6        110         0x3d
+ *   7        104         0x3d
+ *   8         98         0x3d
+ *   9        110         0x3c
+ *  10        104         0x3c
+ *  11         98         0x3c
+ *  12        110         0x3b
+ *  13        104         0x3b
+ *  14         98         0x3b
+ *  15        110         0x3a
+ *  16        104         0x3a
+ *  17         98         0x3a
+ *  18        110         0x39
+ *  19        104         0x39
+ *  20         98         0x39
+ *  21        110         0x38
+ *  22        104         0x38
+ *  23         98         0x38
+ *  24        110         0x37
+ *  25        104         0x37
+ *  26         98         0x37
+ *  27        110         0x36
+ *  28        104         0x36
+ *  29         98         0x36
+ *  30        110         0x35
+ *  31        104         0x35
+ *  32         98         0x35
+ *  33        110         0x34
+ *  34        104         0x34
+ *  35         98         0x34
+ *  36        110         0x33
+ *  37        104         0x33
+ *  38         98         0x33
+ *  39        110         0x32
+ *  40        104         0x32
+ *  41         98         0x32
+ *  42        110         0x31
+ *  43        104         0x31
+ *  44         98         0x31
+ *  45        110         0x30
+ *  46        104         0x30
+ *  47         98         0x30
+ *  48        110          0x6
+ *  49        104          0x6
+ *  50         98          0x6
+ *  51        110          0x5
+ *  52        104          0x5
+ *  53         98          0x5
+ *  54        110          0x4
+ *  55        104          0x4
+ *  56         98          0x4
+ *  57        110          0x3
+ *  58        104          0x3
+ *  59         98          0x3
+ *  60        110          0x2
+ *  61        104          0x2
+ *  62         98          0x2
+ *  63        110          0x1
+ *  64        104          0x1
+ *  65         98          0x1
+ *  66        110          0x0
+ *  67        104          0x0
+ *  68         98          0x0
+ *  69         97            0
+ *  70         96            0
+ *  71         95            0
+ *  72         94            0
+ *  73         93            0
+ *  74         92            0
+ *  75         91            0
+ *  76         90            0
+ *  77         89            0
+ *  78         88            0
+ *  79         87            0
+ *  80         86            0
+ *  81         85            0
+ *  82         84            0
+ *  83         83            0
+ *  84         82            0
+ *  85         81            0
+ *  86         80            0
+ *  87         79            0
+ *  88         78            0
+ *  89         77            0
+ *  90         76            0
+ *  91         75            0
+ *  92         74            0
+ *  93         73            0
+ *  94         72            0
+ *  95         71            0
+ *  96         70            0
+ *  97         69            0
+ *  98         68            0
+ */
+
+/**
+ * 5 GHz gain table
+ *
+ * Index    Dsp gain   Radio gain
+ *  -9               123         0x3F      (highest gain)
+ *  -8               117         0x3F
+ *  -7        110         0x3F
+ *  -6        104         0x3F
+ *  -5         98         0x3F
+ *  -4        110         0x3E
+ *  -3        104         0x3E
+ *  -2         98         0x3E
+ *  -1        110         0x3D
+ *   0        104         0x3D
+ *   1         98         0x3D
+ *   2        110         0x3C
+ *   3        104         0x3C
+ *   4         98         0x3C
+ *   5        110         0x3B
+ *   6        104         0x3B
+ *   7         98         0x3B
+ *   8        110         0x3A
+ *   9        104         0x3A
+ *  10         98         0x3A
+ *  11        110         0x39
+ *  12        104         0x39
+ *  13         98         0x39
+ *  14        110         0x38
+ *  15        104         0x38
+ *  16         98         0x38
+ *  17        110         0x37
+ *  18        104         0x37
+ *  19         98         0x37
+ *  20        110         0x36
+ *  21        104         0x36
+ *  22         98         0x36
+ *  23        110         0x35
+ *  24        104         0x35
+ *  25         98         0x35
+ *  26        110         0x34
+ *  27        104         0x34
+ *  28         98         0x34
+ *  29        110         0x33
+ *  30        104         0x33
+ *  31         98         0x33
+ *  32        110         0x32
+ *  33        104         0x32
+ *  34         98         0x32
+ *  35        110         0x31
+ *  36        104         0x31
+ *  37         98         0x31
+ *  38        110         0x30
+ *  39        104         0x30
+ *  40         98         0x30
+ *  41        110         0x25
+ *  42        104         0x25
+ *  43         98         0x25
+ *  44        110         0x24
+ *  45        104         0x24
+ *  46         98         0x24
+ *  47        110         0x23
+ *  48        104         0x23
+ *  49         98         0x23
+ *  50        110         0x22
+ *  51        104         0x18
+ *  52         98         0x18
+ *  53        110         0x17
+ *  54        104         0x17
+ *  55         98         0x17
+ *  56        110         0x16
+ *  57        104         0x16
+ *  58         98         0x16
+ *  59        110         0x15
+ *  60        104         0x15
+ *  61         98         0x15
+ *  62        110         0x14
+ *  63        104         0x14
+ *  64         98         0x14
+ *  65        110         0x13
+ *  66        104         0x13
+ *  67         98         0x13
+ *  68        110         0x12
+ *  69        104         0x08
+ *  70         98         0x08
+ *  71        110         0x07
+ *  72        104         0x07
+ *  73         98         0x07
+ *  74        110         0x06
+ *  75        104         0x06
+ *  76         98         0x06
+ *  77        110         0x05
+ *  78        104         0x05
+ *  79         98         0x05
+ *  80        110         0x04
+ *  81        104         0x04
+ *  82         98         0x04
+ *  83        110         0x03
+ *  84        104         0x03
+ *  85         98         0x03
+ *  86        110         0x02
+ *  87        104         0x02
+ *  88         98         0x02
+ *  89        110         0x01
+ *  90        104         0x01
+ *  91         98         0x01
+ *  92        110         0x00
+ *  93        104         0x00
+ *  94         98         0x00
+ *  95         93         0x00
+ *  96         88         0x00
+ *  97         83         0x00
+ *  98         78         0x00
+ */
+
+/**
+ * Sanity checks and default values for EEPROM regulatory levels.
+ * If EEPROM values fall outside MIN/MAX range, use default values.
+ *
+ * Regulatory limits refer to the maximum average txpower allowed by
+ * regulatory agencies in the geographies in which the device is meant
+ * to be operated.  These limits are SKU-specific (i.e. geography-specific),
+ * and channel-specific; each channel has an individual regulatory limit
+ * listed in the EEPROM.
+ *
+ * Units are in half-dBm (i.e. "34" means 17 dBm).
+ */
+#define IL_TX_POWER_DEFAULT_REGULATORY_24   (34)
+#define IL_TX_POWER_DEFAULT_REGULATORY_52   (34)
+#define IL_TX_POWER_REGULATORY_MIN          (0)
+#define IL_TX_POWER_REGULATORY_MAX          (34)
+
+/**
+ * Sanity checks and default values for EEPROM saturation levels.
+ * If EEPROM values fall outside MIN/MAX range, use default values.
+ *
+ * Saturation is the highest level that the output power amplifier can produce
+ * without significant clipping distortion.  This is a "peak" power level.
+ * Different types of modulation (i.e. various "rates", and OFDM vs. CCK)
+ * require differing amounts of backoff, relative to their average power output,
+ * in order to avoid clipping distortion.
+ *
+ * Driver must make sure that it is violating neither the saturation limit,
+ * nor the regulatory limit, when calculating Tx power settings for various
+ * rates.
+ *
+ * Units are in half-dBm (i.e. "38" means 19 dBm).
+ */
+#define IL_TX_POWER_DEFAULT_SATURATION_24   (38)
+#define IL_TX_POWER_DEFAULT_SATURATION_52   (38)
+#define IL_TX_POWER_SATURATION_MIN          (20)
+#define IL_TX_POWER_SATURATION_MAX          (50)
+
+/**
+ * Channel groups used for Tx Attenuation calibration (MIMO tx channel balance)
+ * and thermal Txpower calibration.
+ *
+ * When calculating txpower, driver must compensate for current device
+ * temperature; higher temperature requires higher gain.  Driver must calculate
+ * current temperature (see "4965 temperature calculation"), then compare vs.
+ * factory calibration temperature in EEPROM; if current temperature is higher
+ * than factory temperature, driver must *increase* gain by proportions shown
+ * in table below.  If current temperature is lower than factory, driver must
+ * *decrease* gain.
+ *
+ * Different frequency ranges require different compensation, as shown below.
+ */
+/* Group 0, 5.2 GHz ch 34-43:  4.5 degrees per 1/2 dB. */
+#define CALIB_IL_TX_ATTEN_GR1_FCH 34
+#define CALIB_IL_TX_ATTEN_GR1_LCH 43
+
+/* Group 1, 5.3 GHz ch 44-70:  4.0 degrees per 1/2 dB. */
+#define CALIB_IL_TX_ATTEN_GR2_FCH 44
+#define CALIB_IL_TX_ATTEN_GR2_LCH 70
+
+/* Group 2, 5.5 GHz ch 71-124:  4.0 degrees per 1/2 dB. */
+#define CALIB_IL_TX_ATTEN_GR3_FCH 71
+#define CALIB_IL_TX_ATTEN_GR3_LCH 124
+
+/* Group 3, 5.7 GHz ch 125-200:  4.0 degrees per 1/2 dB. */
+#define CALIB_IL_TX_ATTEN_GR4_FCH 125
+#define CALIB_IL_TX_ATTEN_GR4_LCH 200
+
+/* Group 4, 2.4 GHz all channels:  3.5 degrees per 1/2 dB. */
+#define CALIB_IL_TX_ATTEN_GR5_FCH 1
+#define CALIB_IL_TX_ATTEN_GR5_LCH 20
+
+enum {
+       CALIB_CH_GROUP_1 = 0,
+       CALIB_CH_GROUP_2 = 1,
+       CALIB_CH_GROUP_3 = 2,
+       CALIB_CH_GROUP_4 = 3,
+       CALIB_CH_GROUP_5 = 4,
+       CALIB_CH_GROUP_MAX
+};
+
+/********************* END TXPOWER *****************************************/
+
+/**
+ * Tx/Rx Queues
+ *
+ * Most communication between driver and 4965 is via queues of data buffers.
+ * For example, all commands that the driver issues to device's embedded
+ * controller (uCode) are via the command queue (one of the Tx queues).  All
+ * uCode command responses/replies/notifications, including Rx frames, are
+ * conveyed from uCode to driver via the Rx queue.
+ *
+ * Most support for these queues, including handshake support, resides in
+ * structures in host DRAM, shared between the driver and the device.  When
+ * allocating this memory, the driver must make sure that data written by
+ * the host CPU updates DRAM immediately (and does not get "stuck" in CPU's
+ * cache memory), so DRAM and cache are consistent, and the device can
+ * immediately see changes made by the driver.
+ *
+ * 4965 supports up to 16 DRAM-based Tx queues, and services these queues via
+ * up to 7 DMA channels (FIFOs).  Each Tx queue is supported by a circular array
+ * in DRAM containing 256 Transmit Frame Descriptors (TFDs).
+ */
+#define IL49_NUM_FIFOS 7
+#define IL49_CMD_FIFO_NUM      4
+#define IL49_NUM_QUEUES        16
+#define IL49_NUM_AMPDU_QUEUES  8
+
+/**
+ * struct il4965_schedq_bc_tbl
+ *
+ * Byte Count table
+ *
+ * Each Tx queue uses a byte-count table containing 320 entries:
+ * one 16-bit entry for each of 256 TFDs, plus an additional 64 entries that
+ * duplicate the first 64 entries (to avoid wrap-around within a Tx win;
+ * max Tx win is 64 TFDs).
+ *
+ * When driver sets up a new TFD, it must also enter the total byte count
+ * of the frame to be transmitted into the corresponding entry in the byte
+ * count table for the chosen Tx queue.  If the TFD idx is 0-63, the driver
+ * must duplicate the byte count entry in corresponding idx 256-319.
+ *
+ * padding puts each byte count table on a 1024-byte boundary;
+ * 4965 assumes tables are separated by 1024 bytes.
+ */
+struct il4965_scd_bc_tbl {
+       __le16 tfd_offset[TFD_QUEUE_BC_SIZE];
+       u8 pad[1024 - (TFD_QUEUE_BC_SIZE) * sizeof(__le16)];
+} __packed;
+
+#define IL4965_RTC_INST_LOWER_BOUND            (0x000000)
+
+/* RSSI to dBm */
+#define IL4965_RSSI_OFFSET     44
+
+/* PCI registers */
+#define PCI_CFG_RETRY_TIMEOUT  0x041
+
+#define IL4965_DEFAULT_TX_RETRY  15
+
+/* EEPROM */
+#define IL4965_FIRST_AMPDU_QUEUE       10
+
+/* Calibration */
+void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp);
+void il4965_sensitivity_calibration(struct il_priv *il, void *resp);
+void il4965_init_sensitivity(struct il_priv *il);
+void il4965_reset_run_time_calib(struct il_priv *il);
+
+/* Debug */
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+extern const struct il_debugfs_ops il4965_debugfs_ops;
+#endif
+
+/****************************/
+/* Flow Handler Definitions */
+/****************************/
+
+/**
+ * This I/O area is directly read/writable by driver (e.g. Linux uses writel())
+ * Addresses are offsets from device's PCI hardware base address.
+ */
+#define FH49_MEM_LOWER_BOUND                   (0x1000)
+#define FH49_MEM_UPPER_BOUND                   (0x2000)
+
+/**
+ * Keep-Warm (KW) buffer base address.
+ *
+ * Driver must allocate a 4KByte buffer that is used by 4965 for keeping the
+ * host DRAM powered on (via dummy accesses to DRAM) to maintain low-latency
+ * DRAM access when 4965 is Txing or Rxing.  The dummy accesses prevent host
+ * from going into a power-savings mode that would cause higher DRAM latency,
+ * and possible data over/under-runs, before all Tx/Rx is complete.
+ *
+ * Driver loads FH49_KW_MEM_ADDR_REG with the physical address (bits 35:4)
+ * of the buffer, which must be 4K aligned.  Once this is set up, the 4965
+ * automatically invokes keep-warm accesses when normal accesses might not
+ * be sufficient to maintain fast DRAM response.
+ *
+ * Bit fields:
+ *  31-0:  Keep-warm buffer physical base address [35:4], must be 4K aligned
+ */
+#define FH49_KW_MEM_ADDR_REG                (FH49_MEM_LOWER_BOUND + 0x97C)
+
+/**
+ * TFD Circular Buffers Base (CBBC) addresses
+ *
+ * 4965 has 16 base pointer registers, one for each of 16 host-DRAM-resident
+ * circular buffers (CBs/queues) containing Transmit Frame Descriptors (TFDs)
+ * (see struct il_tfd_frame).  These 16 pointer registers are offset by 0x04
+ * bytes from one another.  Each TFD circular buffer in DRAM must be 256-byte
+ * aligned (address bits 0-7 must be 0).
+ *
+ * Bit fields in each pointer register:
+ *  27-0: TFD CB physical base address [35:8], must be 256-byte aligned
+ */
+#define FH49_MEM_CBBC_LOWER_BOUND          (FH49_MEM_LOWER_BOUND + 0x9D0)
+#define FH49_MEM_CBBC_UPPER_BOUND          (FH49_MEM_LOWER_BOUND + 0xA10)
+
+/* Find TFD CB base pointer for given queue (range 0-15). */
+#define FH49_MEM_CBBC_QUEUE(x)  (FH49_MEM_CBBC_LOWER_BOUND + (x) * 0x4)
+
+/**
+ * Rx SRAM Control and Status Registers (RSCSR)
+ *
+ * These registers provide handshake between driver and 4965 for the Rx queue
+ * (this queue handles *all* command responses, notifications, Rx data, etc.
+ * sent from 4965 uCode to host driver).  Unlike Tx, there is only one Rx
+ * queue, and only one Rx DMA/FIFO channel.  Also unlike Tx, which can
+ * concatenate up to 20 DRAM buffers to form a Tx frame, each Receive Buffer
+ * Descriptor (RBD) points to only one Rx Buffer (RB); there is a 1:1
+ * mapping between RBDs and RBs.
+ *
+ * Driver must allocate host DRAM memory for the following, and set the
+ * physical address of each into 4965 registers:
+ *
+ * 1)  Receive Buffer Descriptor (RBD) circular buffer (CB), typically with 256
+ *     entries (although any power of 2, up to 4096, is selectable by driver).
+ *     Each entry (1 dword) points to a receive buffer (RB) of consistent size
+ *     (typically 4K, although 8K or 16K are also selectable by driver).
+ *     Driver sets up RB size and number of RBDs in the CB via Rx config
+ *     register FH49_MEM_RCSR_CHNL0_CONFIG_REG.
+ *
+ *     Bit fields within one RBD:
+ *     27-0:  Receive Buffer physical address bits [35:8], 256-byte aligned
+ *
+ *     Driver sets physical address [35:8] of base of RBD circular buffer
+ *     into FH49_RSCSR_CHNL0_RBDCB_BASE_REG [27:0].
+ *
+ * 2)  Rx status buffer, 8 bytes, in which 4965 indicates which Rx Buffers
+ *     (RBs) have been filled, via a "write pointer", actually the idx of
+ *     the RB's corresponding RBD within the circular buffer.  Driver sets
+ *     physical address [35:4] into FH49_RSCSR_CHNL0_STTS_WPTR_REG [31:0].
+ *
+ *     Bit fields in lower dword of Rx status buffer (upper dword not used
+ *     by driver; see struct il4965_shared, val0):
+ *     31-12:  Not used by driver
+ *     11- 0:  Index of last filled Rx buffer descriptor
+ *             (4965 writes, driver reads this value)
+ *
+ * As the driver prepares Receive Buffers (RBs) for 4965 to fill, driver must
+ * enter pointers to these RBs into contiguous RBD circular buffer entries,
+ * and update the 4965's "write" idx register,
+ * FH49_RSCSR_CHNL0_RBDCB_WPTR_REG.
+ *
+ * This "write" idx corresponds to the *next* RBD that the driver will make
+ * available, i.e. one RBD past the tail of the ready-to-fill RBDs within
+ * the circular buffer.  This value should initially be 0 (before preparing any
+ * RBs), should be 8 after preparing the first 8 RBs (for example), and must
+ * wrap back to 0 at the end of the circular buffer (but don't wrap before
+ * "read" idx has advanced past 1!  See below).
+ * NOTE:  4965 EXPECTS THE WRITE IDX TO BE INCREMENTED IN MULTIPLES OF 8.
+ *
+ * As the 4965 fills RBs (referenced from contiguous RBDs within the circular
+ * buffer), it updates the Rx status buffer in host DRAM, 2) described above,
+ * to tell the driver the idx of the latest filled RBD.  The driver must
+ * read this "read" idx from DRAM after receiving an Rx interrupt from 4965.
+ *
+ * The driver must also internally keep track of a third idx, which is the
+ * next RBD to process.  When receiving an Rx interrupt, driver should process
+ * all filled but unprocessed RBs up to, but not including, the RB
+ * corresponding to the "read" idx.  For example, if "read" idx becomes "1",
+ * driver may process the RB pointed to by RBD 0.  Depending on volume of
+ * traffic, there may be many RBs to process.
+ *
+ * If read idx == write idx, 4965 thinks there is no room to put new data.
+ * Due to this, the maximum number of filled RBs is 255, instead of 256.  To
+ * be safe, make sure that there is a gap of at least 2 RBDs between "write"
+ * and "read" idxes; that is, make sure that there are no more than 254
+ * buffers waiting to be filled.
+ */
+#define FH49_MEM_RSCSR_LOWER_BOUND     (FH49_MEM_LOWER_BOUND + 0xBC0)
+#define FH49_MEM_RSCSR_UPPER_BOUND     (FH49_MEM_LOWER_BOUND + 0xC00)
+#define FH49_MEM_RSCSR_CHNL0           (FH49_MEM_RSCSR_LOWER_BOUND)
+
+/**
+ * Physical base address of 8-byte Rx Status buffer.
+ * Bit fields:
+ *  31-0: Rx status buffer physical base address [35:4], must 16-byte aligned.
+ */
+#define FH49_RSCSR_CHNL0_STTS_WPTR_REG (FH49_MEM_RSCSR_CHNL0)
+
+/**
+ * Physical base address of Rx Buffer Descriptor Circular Buffer.
+ * Bit fields:
+ *  27-0:  RBD CD physical base address [35:8], must be 256-byte aligned.
+ */
+#define FH49_RSCSR_CHNL0_RBDCB_BASE_REG        (FH49_MEM_RSCSR_CHNL0 + 0x004)
+
+/**
+ * Rx write pointer (idx, really!).
+ * Bit fields:
+ *  11-0:  Index of driver's most recent prepared-to-be-filled RBD, + 1.
+ *         NOTE:  For 256-entry circular buffer, use only bits [7:0].
+ */
+#define FH49_RSCSR_CHNL0_RBDCB_WPTR_REG        (FH49_MEM_RSCSR_CHNL0 + 0x008)
+#define FH49_RSCSR_CHNL0_WPTR        (FH49_RSCSR_CHNL0_RBDCB_WPTR_REG)
+
+/**
+ * Rx Config/Status Registers (RCSR)
+ * Rx Config Reg for channel 0 (only channel used)
+ *
+ * Driver must initialize FH49_MEM_RCSR_CHNL0_CONFIG_REG as follows for
+ * normal operation (see bit fields).
+ *
+ * Clearing FH49_MEM_RCSR_CHNL0_CONFIG_REG to 0 turns off Rx DMA.
+ * Driver should poll FH49_MEM_RSSR_RX_STATUS_REG      for
+ * FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE (bit 24) before continuing.
+ *
+ * Bit fields:
+ * 31-30: Rx DMA channel enable: '00' off/pause, '01' pause at end of frame,
+ *        '10' operate normally
+ * 29-24: reserved
+ * 23-20: # RBDs in circular buffer = 2^value; use "8" for 256 RBDs (normal),
+ *        min "5" for 32 RBDs, max "12" for 4096 RBDs.
+ * 19-18: reserved
+ * 17-16: size of each receive buffer; '00' 4K (normal), '01' 8K,
+ *        '10' 12K, '11' 16K.
+ * 15-14: reserved
+ * 13-12: IRQ destination; '00' none, '01' host driver (normal operation)
+ * 11- 4: timeout for closing Rx buffer and interrupting host (units 32 usec)
+ *        typical value 0x10 (about 1/2 msec)
+ *  3- 0: reserved
+ */
+#define FH49_MEM_RCSR_LOWER_BOUND      (FH49_MEM_LOWER_BOUND + 0xC00)
+#define FH49_MEM_RCSR_UPPER_BOUND      (FH49_MEM_LOWER_BOUND + 0xCC0)
+#define FH49_MEM_RCSR_CHNL0            (FH49_MEM_RCSR_LOWER_BOUND)
+
+#define FH49_MEM_RCSR_CHNL0_CONFIG_REG (FH49_MEM_RCSR_CHNL0)
+
+#define FH49_RCSR_CHNL0_RX_CONFIG_RB_TIMEOUT_MSK (0x00000FF0)  /* bits 4-11 */
+#define FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_MSK   (0x00001000)  /* bits 12 */
+#define FH49_RCSR_CHNL0_RX_CONFIG_SINGLE_FRAME_MSK (0x00008000)        /* bit 15 */
+#define FH49_RCSR_CHNL0_RX_CONFIG_RB_SIZE_MSK   (0x00030000)   /* bits 16-17 */
+#define FH49_RCSR_CHNL0_RX_CONFIG_RBDBC_SIZE_MSK (0x00F00000)  /* bits 20-23 */
+#define FH49_RCSR_CHNL0_RX_CONFIG_DMA_CHNL_EN_MSK (0xC0000000) /* bits 30-31 */
+
+#define FH49_RCSR_RX_CONFIG_RBDCB_SIZE_POS     (20)
+#define FH49_RCSR_RX_CONFIG_REG_IRQ_RBTH_POS   (4)
+#define RX_RB_TIMEOUT  (0x10)
+
+#define FH49_RCSR_RX_CONFIG_CHNL_EN_PAUSE_VAL         (0x00000000)
+#define FH49_RCSR_RX_CONFIG_CHNL_EN_PAUSE_EOF_VAL     (0x40000000)
+#define FH49_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL        (0x80000000)
+
+#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_4K    (0x00000000)
+#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_8K    (0x00010000)
+#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_12K   (0x00020000)
+#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_16K   (0x00030000)
+
+#define FH49_RCSR_CHNL0_RX_IGNORE_RXF_EMPTY              (0x00000004)
+#define FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_NO_INT_VAL    (0x00000000)
+#define FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL  (0x00001000)
+
+/**
+ * Rx Shared Status Registers (RSSR)
+ *
+ * After stopping Rx DMA channel (writing 0 to
+ * FH49_MEM_RCSR_CHNL0_CONFIG_REG), driver must poll
+ * FH49_MEM_RSSR_RX_STATUS_REG until Rx channel is idle.
+ *
+ * Bit fields:
+ *  24:  1 = Channel 0 is idle
+ *
+ * FH49_MEM_RSSR_SHARED_CTRL_REG and FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV
+ * contain default values that should not be altered by the driver.
+ */
+#define FH49_MEM_RSSR_LOWER_BOUND           (FH49_MEM_LOWER_BOUND + 0xC40)
+#define FH49_MEM_RSSR_UPPER_BOUND           (FH49_MEM_LOWER_BOUND + 0xD00)
+
+#define FH49_MEM_RSSR_SHARED_CTRL_REG       (FH49_MEM_RSSR_LOWER_BOUND)
+#define FH49_MEM_RSSR_RX_STATUS_REG    (FH49_MEM_RSSR_LOWER_BOUND + 0x004)
+#define FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV\
+                                       (FH49_MEM_RSSR_LOWER_BOUND + 0x008)
+
+#define FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE    (0x01000000)
+
+#define FH49_MEM_TFDIB_REG1_ADDR_BITSHIFT      28
+
+/* TFDB  Area - TFDs buffer table */
+#define FH49_MEM_TFDIB_DRAM_ADDR_LSB_MSK      (0xFFFFFFFF)
+#define FH49_TFDIB_LOWER_BOUND       (FH49_MEM_LOWER_BOUND + 0x900)
+#define FH49_TFDIB_UPPER_BOUND       (FH49_MEM_LOWER_BOUND + 0x958)
+#define FH49_TFDIB_CTRL0_REG(_chnl)  (FH49_TFDIB_LOWER_BOUND + 0x8 * (_chnl))
+#define FH49_TFDIB_CTRL1_REG(_chnl)  (FH49_TFDIB_LOWER_BOUND + 0x8 * (_chnl) + 0x4)
+
+/**
+ * Transmit DMA Channel Control/Status Registers (TCSR)
+ *
+ * 4965 has one configuration register for each of 8 Tx DMA/FIFO channels
+ * supported in hardware (don't confuse these with the 16 Tx queues in DRAM,
+ * which feed the DMA/FIFO channels); config regs are separated by 0x20 bytes.
+ *
+ * To use a Tx DMA channel, driver must initialize its
+ * FH49_TCSR_CHNL_TX_CONFIG_REG(chnl) with:
+ *
+ * FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |
+ * FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL
+ *
+ * All other bits should be 0.
+ *
+ * Bit fields:
+ * 31-30: Tx DMA channel enable: '00' off/pause, '01' pause at end of frame,
+ *        '10' operate normally
+ * 29- 4: Reserved, set to "0"
+ *     3: Enable internal DMA requests (1, normal operation), disable (0)
+ *  2- 0: Reserved, set to "0"
+ */
+#define FH49_TCSR_LOWER_BOUND  (FH49_MEM_LOWER_BOUND + 0xD00)
+#define FH49_TCSR_UPPER_BOUND  (FH49_MEM_LOWER_BOUND + 0xE60)
+
+/* Find Control/Status reg for given Tx DMA/FIFO channel */
+#define FH49_TCSR_CHNL_NUM                            (7)
+#define FH50_TCSR_CHNL_NUM                            (8)
+
+/* TCSR: tx_config register values */
+#define FH49_TCSR_CHNL_TX_CONFIG_REG(_chnl)    \
+               (FH49_TCSR_LOWER_BOUND + 0x20 * (_chnl))
+#define FH49_TCSR_CHNL_TX_CREDIT_REG(_chnl)    \
+               (FH49_TCSR_LOWER_BOUND + 0x20 * (_chnl) + 0x4)
+#define FH49_TCSR_CHNL_TX_BUF_STS_REG(_chnl)   \
+               (FH49_TCSR_LOWER_BOUND + 0x20 * (_chnl) + 0x8)
+
+#define FH49_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_TXF               (0x00000000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_DRV               (0x00000001)
+
+#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_DISABLE (0x00000000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE  (0x00000008)
+
+#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_NOINT    (0x00000000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_ENDTFD   (0x00100000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_IFTFD    (0x00200000)
+
+#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_NOINT     (0x00000000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_ENDTFD    (0x00400000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_IFTFD     (0x00800000)
+
+#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_PAUSE     (0x00000000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_PAUSE_EOF (0x40000000)
+#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE    (0x80000000)
+
+#define FH49_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_EMPTY   (0x00000000)
+#define FH49_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_WAIT    (0x00002000)
+#define FH49_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_VALID   (0x00000003)
+
+#define FH49_TCSR_CHNL_TX_BUF_STS_REG_POS_TB_NUM               (20)
+#define FH49_TCSR_CHNL_TX_BUF_STS_REG_POS_TB_IDX               (12)
+
+/**
+ * Tx Shared Status Registers (TSSR)
+ *
+ * After stopping Tx DMA channel (writing 0 to
+ * FH49_TCSR_CHNL_TX_CONFIG_REG(chnl)), driver must poll
+ * FH49_TSSR_TX_STATUS_REG until selected Tx channel is idle
+ * (channel's buffers empty | no pending requests).
+ *
+ * Bit fields:
+ * 31-24:  1 = Channel buffers empty (channel 7:0)
+ * 23-16:  1 = No pending requests (channel 7:0)
+ */
+#define FH49_TSSR_LOWER_BOUND          (FH49_MEM_LOWER_BOUND + 0xEA0)
+#define FH49_TSSR_UPPER_BOUND          (FH49_MEM_LOWER_BOUND + 0xEC0)
+
+#define FH49_TSSR_TX_STATUS_REG                (FH49_TSSR_LOWER_BOUND + 0x010)
+
+/**
+ * Bit fields for TSSR(Tx Shared Status & Control) error status register:
+ * 31:  Indicates an address error when accessed to internal memory
+ *     uCode/driver must write "1" in order to clear this flag
+ * 30:  Indicates that Host did not send the expected number of dwords to FH
+ *     uCode/driver must write "1" in order to clear this flag
+ * 16-9:Each status bit is for one channel. Indicates that an (Error) ActDMA
+ *     command was received from the scheduler while the TRB was already full
+ *     with previous command
+ *     uCode/driver must write "1" in order to clear this flag
+ * 7-0: Each status bit indicates a channel's TxCredit error. When an error
+ *     bit is set, it indicates that the FH has received a full indication
+ *     from the RTC TxFIFO and the current value of the TxCredit counter was
+ *     not equal to zero. This mean that the credit mechanism was not
+ *     synchronized to the TxFIFO status
+ *     uCode/driver must write "1" in order to clear this flag
+ */
+#define FH49_TSSR_TX_ERROR_REG         (FH49_TSSR_LOWER_BOUND + 0x018)
+
+#define FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(_chnl) ((1 << (_chnl)) << 16)
+
+/* Tx service channels */
+#define FH49_SRVC_CHNL         (9)
+#define FH49_SRVC_LOWER_BOUND  (FH49_MEM_LOWER_BOUND + 0x9C8)
+#define FH49_SRVC_UPPER_BOUND  (FH49_MEM_LOWER_BOUND + 0x9D0)
+#define FH49_SRVC_CHNL_SRAM_ADDR_REG(_chnl) \
+               (FH49_SRVC_LOWER_BOUND + ((_chnl) - 9) * 0x4)
+
+#define FH49_TX_CHICKEN_BITS_REG       (FH49_MEM_LOWER_BOUND + 0xE98)
+/* Instruct FH to increment the retry count of a packet when
+ * it is brought from the memory to TX-FIFO
+ */
+#define FH49_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN (0x00000002)
+
+/* Keep Warm Size */
+#define IL_KW_SIZE 0x1000      /* 4k */
+
+#endif /* __il_4965_h__ */
diff --git a/drivers/net/wireless/intel/iwlegacy/Kconfig b/drivers/net/wireless/intel/iwlegacy/Kconfig
new file mode 100644 (file)
index 0000000..fb91972
--- /dev/null
@@ -0,0 +1,100 @@
+config IWLEGACY
+       tristate
+       select FW_LOADER
+       select NEW_LEDS
+       select LEDS_CLASS
+       select LEDS_TRIGGERS
+       select MAC80211_LEDS
+
+config IWL4965
+       tristate "Intel Wireless WiFi 4965AGN (iwl4965)"
+       depends on PCI && MAC80211
+       select IWLEGACY
+       ---help---
+         This option enables support for
+
+         Select to build the driver supporting the:
+
+         Intel Wireless WiFi Link 4965AGN
+
+         This driver uses the kernel's mac80211 subsystem.
+
+         In order to use this driver, you will need a microcode (uCode)
+         image for it. You can obtain the microcode from:
+
+                 <http://intellinuxwireless.org/>.
+
+         The microcode is typically installed in /lib/firmware. You can
+         look in the hotplug script /etc/hotplug/firmware.agent to
+         determine which directory FIRMWARE_DIR is set to when the script
+         runs.
+
+         If you want to compile the driver as a module ( = code which can be
+         inserted in and removed from the running kernel whenever you want),
+         say M here and read <file:Documentation/kbuild/modules.txt>.  The
+         module will be called iwl4965.
+
+config IWL3945
+       tristate "Intel PRO/Wireless 3945ABG/BG Network Connection (iwl3945)"
+       depends on PCI && MAC80211
+       select IWLEGACY
+       ---help---
+         Select to build the driver supporting the:
+
+         Intel PRO/Wireless 3945ABG/BG Network Connection
+
+         This driver uses the kernel's mac80211 subsystem.
+
+         In order to use this driver, you will need a microcode (uCode)
+         image for it. You can obtain the microcode from:
+
+                 <http://intellinuxwireless.org/>.
+
+         The microcode is typically installed in /lib/firmware. You can
+         look in the hotplug script /etc/hotplug/firmware.agent to
+         determine which directory FIRMWARE_DIR is set to when the script
+         runs.
+
+         If you want to compile the driver as a module ( = code which can be
+         inserted in and removed from the running kernel whenever you want),
+         say M here and read <file:Documentation/kbuild/modules.txt>.  The
+         module will be called iwl3945.
+
+menu "iwl3945 / iwl4965 Debugging Options"
+       depends on IWLEGACY
+
+config IWLEGACY_DEBUG
+       bool "Enable full debugging output in iwlegacy (iwl 3945/4965) drivers"
+       depends on IWLEGACY
+       ---help---
+         This option will enable debug tracing output for the iwlegacy
+         drivers.
+
+         This will result in the kernel module being ~100k larger.  You can
+         control which debug output is sent to the kernel log by setting the
+         value in
+
+               /sys/class/net/wlan0/device/debug_level
+
+         This entry will only exist if this option is enabled.
+
+         To set a value, simply echo an 8-byte hex value to the same file:
+
+                 % echo 0x43fff > /sys/class/net/wlan0/device/debug_level
+
+         You can find the list of debug mask values in:
+                 drivers/net/wireless/iwlegacy/common.h
+
+         If this is your first time using this driver, you should say Y here
+         as the debug information can assist others in helping you resolve
+         any problems you may encounter.
+
+config IWLEGACY_DEBUGFS
+        bool "iwlegacy (iwl 3945/4965) debugfs support"
+        depends on IWLEGACY && MAC80211_DEBUGFS
+        ---help---
+         Enable creation of debugfs files for the iwlegacy drivers. This
+         is a low-impact option that allows getting insight into the
+         driver's state at runtime.
+
+endmenu
diff --git a/drivers/net/wireless/intel/iwlegacy/Makefile b/drivers/net/wireless/intel/iwlegacy/Makefile
new file mode 100644 (file)
index 0000000..c985a01
--- /dev/null
@@ -0,0 +1,17 @@
+obj-$(CONFIG_IWLEGACY) += iwlegacy.o
+iwlegacy-objs          := common.o
+iwlegacy-$(CONFIG_IWLEGACY_DEBUGFS) += debug.o
+
+iwlegacy-objs += $(iwlegacy-m)
+
+# 4965
+obj-$(CONFIG_IWL4965)  += iwl4965.o
+iwl4965-objs           := 4965.o 4965-mac.o 4965-rs.o 4965-calib.o
+iwl4965-$(CONFIG_IWLEGACY_DEBUGFS) += 4965-debug.o
+
+# 3945
+obj-$(CONFIG_IWL3945)  += iwl3945.o
+iwl3945-objs           := 3945-mac.o 3945.o 3945-rs.o
+iwl3945-$(CONFIG_IWLEGACY_DEBUGFS) += 3945-debug.o
+
+ccflags-y += -D__CHECK_ENDIAN__
diff --git a/drivers/net/wireless/intel/iwlegacy/commands.h b/drivers/net/wireless/intel/iwlegacy/commands.h
new file mode 100644 (file)
index 0000000..dd74413
--- /dev/null
@@ -0,0 +1,3370 @@
+/******************************************************************************
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *  * Neither the name Intel Corporation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *****************************************************************************/
+
+#ifndef __il_commands_h__
+#define __il_commands_h__
+
+#include <linux/ieee80211.h>
+
+struct il_priv;
+
+/* uCode version contains 4 values: Major/Minor/API/Serial */
+#define IL_UCODE_MAJOR(ver)    (((ver) & 0xFF000000) >> 24)
+#define IL_UCODE_MINOR(ver)    (((ver) & 0x00FF0000) >> 16)
+#define IL_UCODE_API(ver)      (((ver) & 0x0000FF00) >> 8)
+#define IL_UCODE_SERIAL(ver)   ((ver) & 0x000000FF)
+
+/* Tx rates */
+#define IL_CCK_RATES   4
+#define IL_OFDM_RATES  8
+#define IL_MAX_RATES   (IL_CCK_RATES + IL_OFDM_RATES)
+
+enum {
+       N_ALIVE = 0x1,
+       N_ERROR = 0x2,
+
+       /* RXON and QOS commands */
+       C_RXON = 0x10,
+       C_RXON_ASSOC = 0x11,
+       C_QOS_PARAM = 0x13,
+       C_RXON_TIMING = 0x14,
+
+       /* Multi-Station support */
+       C_ADD_STA = 0x18,
+       C_REM_STA = 0x19,
+
+       /* Security */
+       C_WEPKEY = 0x20,
+
+       /* RX, TX, LEDs */
+       N_3945_RX = 0x1b,       /* 3945 only */
+       C_TX = 0x1c,
+       C_RATE_SCALE = 0x47,    /* 3945 only */
+       C_LEDS = 0x48,
+       C_TX_LINK_QUALITY_CMD = 0x4e,   /* for 4965 */
+
+       /* 802.11h related */
+       C_CHANNEL_SWITCH = 0x72,
+       N_CHANNEL_SWITCH = 0x73,
+       C_SPECTRUM_MEASUREMENT = 0x74,
+       N_SPECTRUM_MEASUREMENT = 0x75,
+
+       /* Power Management */
+       C_POWER_TBL = 0x77,
+       N_PM_SLEEP = 0x7A,
+       N_PM_DEBUG_STATS = 0x7B,
+
+       /* Scan commands and notifications */
+       C_SCAN = 0x80,
+       C_SCAN_ABORT = 0x81,
+       N_SCAN_START = 0x82,
+       N_SCAN_RESULTS = 0x83,
+       N_SCAN_COMPLETE = 0x84,
+
+       /* IBSS/AP commands */
+       N_BEACON = 0x90,
+       C_TX_BEACON = 0x91,
+
+       /* Miscellaneous commands */
+       C_TX_PWR_TBL = 0x97,
+
+       /* Bluetooth device coexistence config command */
+       C_BT_CONFIG = 0x9b,
+
+       /* Statistics */
+       C_STATS = 0x9c,
+       N_STATS = 0x9d,
+
+       /* RF-KILL commands and notifications */
+       N_CARD_STATE = 0xa1,
+
+       /* Missed beacons notification */
+       N_MISSED_BEACONS = 0xa2,
+
+       C_CT_KILL_CONFIG = 0xa4,
+       C_SENSITIVITY = 0xa8,
+       C_PHY_CALIBRATION = 0xb0,
+       N_RX_PHY = 0xc0,
+       N_RX_MPDU = 0xc1,
+       N_RX = 0xc3,
+       N_COMPRESSED_BA = 0xc5,
+
+       IL_CN_MAX = 0xff
+};
+
+/******************************************************************************
+ * (0)
+ * Commonly used structures and definitions:
+ * Command header, rate_n_flags, txpower
+ *
+ *****************************************************************************/
+
+/* il_cmd_header flags value */
+#define IL_CMD_FAILED_MSK 0x40
+
+#define SEQ_TO_QUEUE(s)        (((s) >> 8) & 0x1f)
+#define QUEUE_TO_SEQ(q)        (((q) & 0x1f) << 8)
+#define SEQ_TO_IDX(s)  ((s) & 0xff)
+#define IDX_TO_SEQ(i)  ((i) & 0xff)
+#define SEQ_HUGE_FRAME cpu_to_le16(0x4000)
+#define SEQ_RX_FRAME   cpu_to_le16(0x8000)
+
+/**
+ * struct il_cmd_header
+ *
+ * This header format appears in the beginning of each command sent from the
+ * driver, and each response/notification received from uCode.
+ */
+struct il_cmd_header {
+       u8 cmd;                 /* Command ID:  C_RXON, etc. */
+       u8 flags;               /* 0:5 reserved, 6 abort, 7 internal */
+       /*
+        * The driver sets up the sequence number to values of its choosing.
+        * uCode does not use this value, but passes it back to the driver
+        * when sending the response to each driver-originated command, so
+        * the driver can match the response to the command.  Since the values
+        * don't get used by uCode, the driver may set up an arbitrary format.
+        *
+        * There is one exception:  uCode sets bit 15 when it originates
+        * the response/notification, i.e. when the response/notification
+        * is not a direct response to a command sent by the driver.  For
+        * example, uCode issues N_3945_RX when it sends a received frame
+        * to the driver; it is not a direct response to any driver command.
+        *
+        * The Linux driver uses the following format:
+        *
+        *  0:7         tfd idx - position within TX queue
+        *  8:12        TX queue id
+        *  13          reserved
+        *  14          huge - driver sets this to indicate command is in the
+        *              'huge' storage at the end of the command buffers
+        *  15          unsolicited RX or uCode-originated notification
+        */
+       __le16 sequence;
+
+       /* command or response/notification data follows immediately */
+       u8 data[0];
+} __packed;
+
+/**
+ * struct il3945_tx_power
+ *
+ * Used in C_TX_PWR_TBL, C_SCAN, C_CHANNEL_SWITCH
+ *
+ * Each entry contains two values:
+ * 1)  DSP gain (or sometimes called DSP attenuation).  This is a fine-grained
+ *     linear value that multiplies the output of the digital signal processor,
+ *     before being sent to the analog radio.
+ * 2)  Radio gain.  This sets the analog gain of the radio Tx path.
+ *     It is a coarser setting, and behaves in a logarithmic (dB) fashion.
+ *
+ * Driver obtains values from struct il3945_tx_power power_gain_table[][].
+ */
+struct il3945_tx_power {
+       u8 tx_gain;             /* gain for analog radio */
+       u8 dsp_atten;           /* gain for DSP */
+} __packed;
+
+/**
+ * struct il3945_power_per_rate
+ *
+ * Used in C_TX_PWR_TBL, C_CHANNEL_SWITCH
+ */
+struct il3945_power_per_rate {
+       u8 rate;                /* plcp */
+       struct il3945_tx_power tpc;
+       u8 reserved;
+} __packed;
+
+/**
+ * iwl4965 rate_n_flags bit fields
+ *
+ * rate_n_flags format is used in following iwl4965 commands:
+ *  N_RX (response only)
+ *  N_RX_MPDU (response only)
+ *  C_TX (both command and response)
+ *  C_TX_LINK_QUALITY_CMD
+ *
+ * High-throughput (HT) rate format for bits 7:0 (bit 8 must be "1"):
+ *  2-0:  0)   6 Mbps
+ *        1)  12 Mbps
+ *        2)  18 Mbps
+ *        3)  24 Mbps
+ *        4)  36 Mbps
+ *        5)  48 Mbps
+ *        6)  54 Mbps
+ *        7)  60 Mbps
+ *
+ *  4-3:  0)  Single stream (SISO)
+ *        1)  Dual stream (MIMO)
+ *        2)  Triple stream (MIMO)
+ *
+ *    5:  Value of 0x20 in bits 7:0 indicates 6 Mbps HT40 duplicate data
+ *
+ * Legacy OFDM rate format for bits 7:0 (bit 8 must be "0", bit 9 "0"):
+ *  3-0:  0xD)   6 Mbps
+ *        0xF)   9 Mbps
+ *        0x5)  12 Mbps
+ *        0x7)  18 Mbps
+ *        0x9)  24 Mbps
+ *        0xB)  36 Mbps
+ *        0x1)  48 Mbps
+ *        0x3)  54 Mbps
+ *
+ * Legacy CCK rate format for bits 7:0 (bit 8 must be "0", bit 9 "1"):
+ *  6-0:   10)  1 Mbps
+ *         20)  2 Mbps
+ *         55)  5.5 Mbps
+ *        110)  11 Mbps
+ */
+#define RATE_MCS_CODE_MSK 0x7
+#define RATE_MCS_SPATIAL_POS 3
+#define RATE_MCS_SPATIAL_MSK 0x18
+#define RATE_MCS_HT_DUP_POS 5
+#define RATE_MCS_HT_DUP_MSK 0x20
+
+/* Bit 8: (1) HT format, (0) legacy format in bits 7:0 */
+#define RATE_MCS_FLAGS_POS 8
+#define RATE_MCS_HT_POS 8
+#define RATE_MCS_HT_MSK 0x100
+
+/* Bit 9: (1) CCK, (0) OFDM.  HT (bit 8) must be "0" for this bit to be valid */
+#define RATE_MCS_CCK_POS 9
+#define RATE_MCS_CCK_MSK 0x200
+
+/* Bit 10: (1) Use Green Field preamble */
+#define RATE_MCS_GF_POS 10
+#define RATE_MCS_GF_MSK 0x400
+
+/* Bit 11: (1) Use 40Mhz HT40 chnl width, (0) use 20 MHz legacy chnl width */
+#define RATE_MCS_HT40_POS 11
+#define RATE_MCS_HT40_MSK 0x800
+
+/* Bit 12: (1) Duplicate data on both 20MHz chnls. HT40 (bit 11) must be set. */
+#define RATE_MCS_DUP_POS 12
+#define RATE_MCS_DUP_MSK 0x1000
+
+/* Bit 13: (1) Short guard interval (0.4 usec), (0) normal GI (0.8 usec) */
+#define RATE_MCS_SGI_POS 13
+#define RATE_MCS_SGI_MSK 0x2000
+
+/**
+ * rate_n_flags Tx antenna masks
+ * 4965 has 2 transmitters
+ * bit14:16
+ */
+#define RATE_MCS_ANT_POS       14
+#define RATE_MCS_ANT_A_MSK     0x04000
+#define RATE_MCS_ANT_B_MSK     0x08000
+#define RATE_MCS_ANT_C_MSK     0x10000
+#define RATE_MCS_ANT_AB_MSK    (RATE_MCS_ANT_A_MSK | RATE_MCS_ANT_B_MSK)
+#define RATE_MCS_ANT_ABC_MSK   (RATE_MCS_ANT_AB_MSK | RATE_MCS_ANT_C_MSK)
+#define RATE_ANT_NUM 3
+
+#define POWER_TBL_NUM_ENTRIES                  33
+#define POWER_TBL_NUM_HT_OFDM_ENTRIES          32
+#define POWER_TBL_CCK_ENTRY                    32
+
+#define IL_PWR_NUM_HT_OFDM_ENTRIES             24
+#define IL_PWR_CCK_ENTRIES                     2
+
+/**
+ * union il4965_tx_power_dual_stream
+ *
+ * Host format used for C_TX_PWR_TBL, C_CHANNEL_SWITCH
+ * Use __le32 version (struct tx_power_dual_stream) when building command.
+ *
+ * Driver provides radio gain and DSP attenuation settings to device in pairs,
+ * one value for each transmitter chain.  The first value is for transmitter A,
+ * second for transmitter B.
+ *
+ * For SISO bit rates, both values in a pair should be identical.
+ * For MIMO rates, one value may be different from the other,
+ * in order to balance the Tx output between the two transmitters.
+ *
+ * See more details in doc for TXPOWER in 4965.h.
+ */
+union il4965_tx_power_dual_stream {
+       struct {
+               u8 radio_tx_gain[2];
+               u8 dsp_predis_atten[2];
+       } s;
+       u32 dw;
+};
+
+/**
+ * struct tx_power_dual_stream
+ *
+ * Table entries in C_TX_PWR_TBL, C_CHANNEL_SWITCH
+ *
+ * Same format as il_tx_power_dual_stream, but __le32
+ */
+struct tx_power_dual_stream {
+       __le32 dw;
+} __packed;
+
+/**
+ * struct il4965_tx_power_db
+ *
+ * Entire table within C_TX_PWR_TBL, C_CHANNEL_SWITCH
+ */
+struct il4965_tx_power_db {
+       struct tx_power_dual_stream power_tbl[POWER_TBL_NUM_ENTRIES];
+} __packed;
+
+/******************************************************************************
+ * (0a)
+ * Alive and Error Commands & Responses:
+ *
+ *****************************************************************************/
+
+#define UCODE_VALID_OK cpu_to_le32(0x1)
+#define INITIALIZE_SUBTYPE    (9)
+
+/*
+ * ("Initialize") N_ALIVE = 0x1 (response only, not a command)
+ *
+ * uCode issues this "initialize alive" notification once the initialization
+ * uCode image has completed its work, and is ready to load the runtime image.
+ * This is the *first* "alive" notification that the driver will receive after
+ * rebooting uCode; the "initialize" alive is indicated by subtype field == 9.
+ *
+ * See comments documenting "BSM" (bootstrap state machine).
+ *
+ * For 4965, this notification contains important calibration data for
+ * calculating txpower settings:
+ *
+ * 1)  Power supply voltage indication.  The voltage sensor outputs higher
+ *     values for lower voltage, and vice verse.
+ *
+ * 2)  Temperature measurement parameters, for each of two channel widths
+ *     (20 MHz and 40 MHz) supported by the radios.  Temperature sensing
+ *     is done via one of the receiver chains, and channel width influences
+ *     the results.
+ *
+ * 3)  Tx gain compensation to balance 4965's 2 Tx chains for MIMO operation,
+ *     for each of 5 frequency ranges.
+ */
+struct il_init_alive_resp {
+       u8 ucode_minor;
+       u8 ucode_major;
+       __le16 reserved1;
+       u8 sw_rev[8];
+       u8 ver_type;
+       u8 ver_subtype;         /* "9" for initialize alive */
+       __le16 reserved2;
+       __le32 log_event_table_ptr;
+       __le32 error_event_table_ptr;
+       __le32 timestamp;
+       __le32 is_valid;
+
+       /* calibration values from "initialize" uCode */
+       __le32 voltage;         /* signed, higher value is lower voltage */
+       __le32 therm_r1[2];     /* signed, 1st for normal, 2nd for HT40 */
+       __le32 therm_r2[2];     /* signed */
+       __le32 therm_r3[2];     /* signed */
+       __le32 therm_r4[2];     /* signed */
+       __le32 tx_atten[5][2];  /* signed MIMO gain comp, 5 freq groups,
+                                * 2 Tx chains */
+} __packed;
+
+/**
+ * N_ALIVE = 0x1 (response only, not a command)
+ *
+ * uCode issues this "alive" notification once the runtime image is ready
+ * to receive commands from the driver.  This is the *second* "alive"
+ * notification that the driver will receive after rebooting uCode;
+ * this "alive" is indicated by subtype field != 9.
+ *
+ * See comments documenting "BSM" (bootstrap state machine).
+ *
+ * This response includes two pointers to structures within the device's
+ * data SRAM (access via HBUS_TARG_MEM_* regs) that are useful for debugging:
+ *
+ * 1)  log_event_table_ptr indicates base of the event log.  This traces
+ *     a 256-entry history of uCode execution within a circular buffer.
+ *     Its header format is:
+ *
+ *     __le32 log_size;     log capacity (in number of entries)
+ *     __le32 type;         (1) timestamp with each entry, (0) no timestamp
+ *     __le32 wraps;        # times uCode has wrapped to top of circular buffer
+ *      __le32 write_idx;  next circular buffer entry that uCode would fill
+ *
+ *     The header is followed by the circular buffer of log entries.  Entries
+ *     with timestamps have the following format:
+ *
+ *     __le32 event_id;     range 0 - 1500
+ *     __le32 timestamp;    low 32 bits of TSF (of network, if associated)
+ *     __le32 data;         event_id-specific data value
+ *
+ *     Entries without timestamps contain only event_id and data.
+ *
+ *
+ * 2)  error_event_table_ptr indicates base of the error log.  This contains
+ *     information about any uCode error that occurs.  For 4965, the format
+ *     of the error log is:
+ *
+ *     __le32 valid;        (nonzero) valid, (0) log is empty
+ *     __le32 error_id;     type of error
+ *     __le32 pc;           program counter
+ *     __le32 blink1;       branch link
+ *     __le32 blink2;       branch link
+ *     __le32 ilink1;       interrupt link
+ *     __le32 ilink2;       interrupt link
+ *     __le32 data1;        error-specific data
+ *     __le32 data2;        error-specific data
+ *     __le32 line;         source code line of error
+ *     __le32 bcon_time;    beacon timer
+ *     __le32 tsf_low;      network timestamp function timer
+ *     __le32 tsf_hi;       network timestamp function timer
+ *     __le32 gp1;          GP1 timer register
+ *     __le32 gp2;          GP2 timer register
+ *     __le32 gp3;          GP3 timer register
+ *     __le32 ucode_ver;    uCode version
+ *     __le32 hw_ver;       HW Silicon version
+ *     __le32 brd_ver;      HW board version
+ *     __le32 log_pc;       log program counter
+ *     __le32 frame_ptr;    frame pointer
+ *     __le32 stack_ptr;    stack pointer
+ *     __le32 hcmd;         last host command
+ *     __le32 isr0;         isr status register LMPM_NIC_ISR0: rxtx_flag
+ *     __le32 isr1;         isr status register LMPM_NIC_ISR1: host_flag
+ *     __le32 isr2;         isr status register LMPM_NIC_ISR2: enc_flag
+ *     __le32 isr3;         isr status register LMPM_NIC_ISR3: time_flag
+ *     __le32 isr4;         isr status register LMPM_NIC_ISR4: wico interrupt
+ *     __le32 isr_pref;     isr status register LMPM_NIC_PREF_STAT
+ *     __le32 wait_event;   wait event() caller address
+ *     __le32 l2p_control;  L2pControlField
+ *     __le32 l2p_duration; L2pDurationField
+ *     __le32 l2p_mhvalid;  L2pMhValidBits
+ *     __le32 l2p_addr_match; L2pAddrMatchStat
+ *     __le32 lmpm_pmg_sel; indicate which clocks are turned on (LMPM_PMG_SEL)
+ *     __le32 u_timestamp;  indicate when the date and time of the compilation
+ *     __le32 reserved;
+ *
+ * The Linux driver can print both logs to the system log when a uCode error
+ * occurs.
+ */
+struct il_alive_resp {
+       u8 ucode_minor;
+       u8 ucode_major;
+       __le16 reserved1;
+       u8 sw_rev[8];
+       u8 ver_type;
+       u8 ver_subtype;         /* not "9" for runtime alive */
+       __le16 reserved2;
+       __le32 log_event_table_ptr;     /* SRAM address for event log */
+       __le32 error_event_table_ptr;   /* SRAM address for error log */
+       __le32 timestamp;
+       __le32 is_valid;
+} __packed;
+
+/*
+ * N_ERROR = 0x2 (response only, not a command)
+ */
+struct il_error_resp {
+       __le32 error_type;
+       u8 cmd_id;
+       u8 reserved1;
+       __le16 bad_cmd_seq_num;
+       __le32 error_info;
+       __le64 timestamp;
+} __packed;
+
+/******************************************************************************
+ * (1)
+ * RXON Commands & Responses:
+ *
+ *****************************************************************************/
+
+/*
+ * Rx config defines & structure
+ */
+/* rx_config device types  */
+enum {
+       RXON_DEV_TYPE_AP = 1,
+       RXON_DEV_TYPE_ESS = 3,
+       RXON_DEV_TYPE_IBSS = 4,
+       RXON_DEV_TYPE_SNIFFER = 6,
+};
+
+#define RXON_RX_CHAIN_DRIVER_FORCE_MSK         cpu_to_le16(0x1 << 0)
+#define RXON_RX_CHAIN_DRIVER_FORCE_POS         (0)
+#define RXON_RX_CHAIN_VALID_MSK                        cpu_to_le16(0x7 << 1)
+#define RXON_RX_CHAIN_VALID_POS                        (1)
+#define RXON_RX_CHAIN_FORCE_SEL_MSK            cpu_to_le16(0x7 << 4)
+#define RXON_RX_CHAIN_FORCE_SEL_POS            (4)
+#define RXON_RX_CHAIN_FORCE_MIMO_SEL_MSK       cpu_to_le16(0x7 << 7)
+#define RXON_RX_CHAIN_FORCE_MIMO_SEL_POS       (7)
+#define RXON_RX_CHAIN_CNT_MSK                  cpu_to_le16(0x3 << 10)
+#define RXON_RX_CHAIN_CNT_POS                  (10)
+#define RXON_RX_CHAIN_MIMO_CNT_MSK             cpu_to_le16(0x3 << 12)
+#define RXON_RX_CHAIN_MIMO_CNT_POS             (12)
+#define RXON_RX_CHAIN_MIMO_FORCE_MSK           cpu_to_le16(0x1 << 14)
+#define RXON_RX_CHAIN_MIMO_FORCE_POS           (14)
+
+/* rx_config flags */
+/* band & modulation selection */
+#define RXON_FLG_BAND_24G_MSK           cpu_to_le32(1 << 0)
+#define RXON_FLG_CCK_MSK                cpu_to_le32(1 << 1)
+/* auto detection enable */
+#define RXON_FLG_AUTO_DETECT_MSK        cpu_to_le32(1 << 2)
+/* TGg protection when tx */
+#define RXON_FLG_TGG_PROTECT_MSK        cpu_to_le32(1 << 3)
+/* cck short slot & preamble */
+#define RXON_FLG_SHORT_SLOT_MSK          cpu_to_le32(1 << 4)
+#define RXON_FLG_SHORT_PREAMBLE_MSK     cpu_to_le32(1 << 5)
+/* antenna selection */
+#define RXON_FLG_DIS_DIV_MSK            cpu_to_le32(1 << 7)
+#define RXON_FLG_ANT_SEL_MSK            cpu_to_le32(0x0f00)
+#define RXON_FLG_ANT_A_MSK              cpu_to_le32(1 << 8)
+#define RXON_FLG_ANT_B_MSK              cpu_to_le32(1 << 9)
+/* radar detection enable */
+#define RXON_FLG_RADAR_DETECT_MSK       cpu_to_le32(1 << 12)
+#define RXON_FLG_TGJ_NARROW_BAND_MSK    cpu_to_le32(1 << 13)
+/* rx response to host with 8-byte TSF
+* (according to ON_AIR deassertion) */
+#define RXON_FLG_TSF2HOST_MSK           cpu_to_le32(1 << 15)
+
+/* HT flags */
+#define RXON_FLG_CTRL_CHANNEL_LOC_POS          (22)
+#define RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK       cpu_to_le32(0x1 << 22)
+
+#define RXON_FLG_HT_OPERATING_MODE_POS         (23)
+
+#define RXON_FLG_HT_PROT_MSK                   cpu_to_le32(0x1 << 23)
+#define RXON_FLG_HT40_PROT_MSK                 cpu_to_le32(0x2 << 23)
+
+#define RXON_FLG_CHANNEL_MODE_POS              (25)
+#define RXON_FLG_CHANNEL_MODE_MSK              cpu_to_le32(0x3 << 25)
+
+/* channel mode */
+enum {
+       CHANNEL_MODE_LEGACY = 0,
+       CHANNEL_MODE_PURE_40 = 1,
+       CHANNEL_MODE_MIXED = 2,
+       CHANNEL_MODE_RESERVED = 3,
+};
+#define RXON_FLG_CHANNEL_MODE_LEGACY                   \
+       cpu_to_le32(CHANNEL_MODE_LEGACY << RXON_FLG_CHANNEL_MODE_POS)
+#define RXON_FLG_CHANNEL_MODE_PURE_40                  \
+       cpu_to_le32(CHANNEL_MODE_PURE_40 << RXON_FLG_CHANNEL_MODE_POS)
+#define RXON_FLG_CHANNEL_MODE_MIXED                    \
+       cpu_to_le32(CHANNEL_MODE_MIXED << RXON_FLG_CHANNEL_MODE_POS)
+
+/* CTS to self (if spec allows) flag */
+#define RXON_FLG_SELF_CTS_EN                   cpu_to_le32(0x1<<30)
+
+/* rx_config filter flags */
+/* accept all data frames */
+#define RXON_FILTER_PROMISC_MSK         cpu_to_le32(1 << 0)
+/* pass control & management to host */
+#define RXON_FILTER_CTL2HOST_MSK        cpu_to_le32(1 << 1)
+/* accept multi-cast */
+#define RXON_FILTER_ACCEPT_GRP_MSK      cpu_to_le32(1 << 2)
+/* don't decrypt uni-cast frames */
+#define RXON_FILTER_DIS_DECRYPT_MSK     cpu_to_le32(1 << 3)
+/* don't decrypt multi-cast frames */
+#define RXON_FILTER_DIS_GRP_DECRYPT_MSK cpu_to_le32(1 << 4)
+/* STA is associated */
+#define RXON_FILTER_ASSOC_MSK           cpu_to_le32(1 << 5)
+/* transfer to host non bssid beacons in associated state */
+#define RXON_FILTER_BCON_AWARE_MSK      cpu_to_le32(1 << 6)
+
+/**
+ * C_RXON = 0x10 (command, has simple generic response)
+ *
+ * RXON tunes the radio tuner to a service channel, and sets up a number
+ * of parameters that are used primarily for Rx, but also for Tx operations.
+ *
+ * NOTE:  When tuning to a new channel, driver must set the
+ *        RXON_FILTER_ASSOC_MSK to 0.  This will clear station-dependent
+ *        info within the device, including the station tables, tx retry
+ *        rate tables, and txpower tables.  Driver must build a new station
+ *        table and txpower table before transmitting anything on the RXON
+ *        channel.
+ *
+ * NOTE:  All RXONs wipe clean the internal txpower table.  Driver must
+ *        issue a new C_TX_PWR_TBL after each C_RXON (0x10),
+ *        regardless of whether RXON_FILTER_ASSOC_MSK is set.
+ */
+
+struct il3945_rxon_cmd {
+       u8 node_addr[6];
+       __le16 reserved1;
+       u8 bssid_addr[6];
+       __le16 reserved2;
+       u8 wlap_bssid_addr[6];
+       __le16 reserved3;
+       u8 dev_type;
+       u8 air_propagation;
+       __le16 reserved4;
+       u8 ofdm_basic_rates;
+       u8 cck_basic_rates;
+       __le16 assoc_id;
+       __le32 flags;
+       __le32 filter_flags;
+       __le16 channel;
+       __le16 reserved5;
+} __packed;
+
+struct il4965_rxon_cmd {
+       u8 node_addr[6];
+       __le16 reserved1;
+       u8 bssid_addr[6];
+       __le16 reserved2;
+       u8 wlap_bssid_addr[6];
+       __le16 reserved3;
+       u8 dev_type;
+       u8 air_propagation;
+       __le16 rx_chain;
+       u8 ofdm_basic_rates;
+       u8 cck_basic_rates;
+       __le16 assoc_id;
+       __le32 flags;
+       __le32 filter_flags;
+       __le16 channel;
+       u8 ofdm_ht_single_stream_basic_rates;
+       u8 ofdm_ht_dual_stream_basic_rates;
+} __packed;
+
+/* Create a common rxon cmd which will be typecast into the 3945 or 4965
+ * specific rxon cmd, depending on where it is called from.
+ */
+struct il_rxon_cmd {
+       u8 node_addr[6];
+       __le16 reserved1;
+       u8 bssid_addr[6];
+       __le16 reserved2;
+       u8 wlap_bssid_addr[6];
+       __le16 reserved3;
+       u8 dev_type;
+       u8 air_propagation;
+       __le16 rx_chain;
+       u8 ofdm_basic_rates;
+       u8 cck_basic_rates;
+       __le16 assoc_id;
+       __le32 flags;
+       __le32 filter_flags;
+       __le16 channel;
+       u8 ofdm_ht_single_stream_basic_rates;
+       u8 ofdm_ht_dual_stream_basic_rates;
+       u8 reserved4;
+       u8 reserved5;
+} __packed;
+
+/*
+ * C_RXON_ASSOC = 0x11 (command, has simple generic response)
+ */
+struct il3945_rxon_assoc_cmd {
+       __le32 flags;
+       __le32 filter_flags;
+       u8 ofdm_basic_rates;
+       u8 cck_basic_rates;
+       __le16 reserved;
+} __packed;
+
+struct il4965_rxon_assoc_cmd {
+       __le32 flags;
+       __le32 filter_flags;
+       u8 ofdm_basic_rates;
+       u8 cck_basic_rates;
+       u8 ofdm_ht_single_stream_basic_rates;
+       u8 ofdm_ht_dual_stream_basic_rates;
+       __le16 rx_chain_select_flags;
+       __le16 reserved;
+} __packed;
+
+#define IL_CONN_MAX_LISTEN_INTERVAL    10
+#define IL_MAX_UCODE_BEACON_INTERVAL   4       /* 4096 */
+#define IL39_MAX_UCODE_BEACON_INTERVAL 1       /* 1024 */
+
+/*
+ * C_RXON_TIMING = 0x14 (command, has simple generic response)
+ */
+struct il_rxon_time_cmd {
+       __le64 timestamp;
+       __le16 beacon_interval;
+       __le16 atim_win;
+       __le32 beacon_init_val;
+       __le16 listen_interval;
+       u8 dtim_period;
+       u8 delta_cp_bss_tbtts;
+} __packed;
+
+/*
+ * C_CHANNEL_SWITCH = 0x72 (command, has simple generic response)
+ */
+struct il3945_channel_switch_cmd {
+       u8 band;
+       u8 expect_beacon;
+       __le16 channel;
+       __le32 rxon_flags;
+       __le32 rxon_filter_flags;
+       __le32 switch_time;
+       struct il3945_power_per_rate power[IL_MAX_RATES];
+} __packed;
+
+struct il4965_channel_switch_cmd {
+       u8 band;
+       u8 expect_beacon;
+       __le16 channel;
+       __le32 rxon_flags;
+       __le32 rxon_filter_flags;
+       __le32 switch_time;
+       struct il4965_tx_power_db tx_power;
+} __packed;
+
+/*
+ * N_CHANNEL_SWITCH = 0x73 (notification only, not a command)
+ */
+struct il_csa_notification {
+       __le16 band;
+       __le16 channel;
+       __le32 status;          /* 0 - OK, 1 - fail */
+} __packed;
+
+/******************************************************************************
+ * (2)
+ * Quality-of-Service (QOS) Commands & Responses:
+ *
+ *****************************************************************************/
+
+/**
+ * struct il_ac_qos -- QOS timing params for C_QOS_PARAM
+ * One for each of 4 EDCA access categories in struct il_qosparam_cmd
+ *
+ * @cw_min: Contention win, start value in numbers of slots.
+ *          Should be a power-of-2, minus 1.  Device's default is 0x0f.
+ * @cw_max: Contention win, max value in numbers of slots.
+ *          Should be a power-of-2, minus 1.  Device's default is 0x3f.
+ * @aifsn:  Number of slots in Arbitration Interframe Space (before
+ *          performing random backoff timing prior to Tx).  Device default 1.
+ * @edca_txop:  Length of Tx opportunity, in uSecs.  Device default is 0.
+ *
+ * Device will automatically increase contention win by (2*CW) + 1 for each
+ * transmission retry.  Device uses cw_max as a bit mask, ANDed with new CW
+ * value, to cap the CW value.
+ */
+struct il_ac_qos {
+       __le16 cw_min;
+       __le16 cw_max;
+       u8 aifsn;
+       u8 reserved1;
+       __le16 edca_txop;
+} __packed;
+
+/* QoS flags defines */
+#define QOS_PARAM_FLG_UPDATE_EDCA_MSK  cpu_to_le32(0x01)
+#define QOS_PARAM_FLG_TGN_MSK          cpu_to_le32(0x02)
+#define QOS_PARAM_FLG_TXOP_TYPE_MSK    cpu_to_le32(0x10)
+
+/* Number of Access Categories (AC) (EDCA), queues 0..3 */
+#define AC_NUM                4
+
+/*
+ * C_QOS_PARAM = 0x13 (command, has simple generic response)
+ *
+ * This command sets up timings for each of the 4 prioritized EDCA Tx FIFOs
+ * 0: Background, 1: Best Effort, 2: Video, 3: Voice.
+ */
+struct il_qosparam_cmd {
+       __le32 qos_flags;
+       struct il_ac_qos ac[AC_NUM];
+} __packed;
+
+/******************************************************************************
+ * (3)
+ * Add/Modify Stations Commands & Responses:
+ *
+ *****************************************************************************/
+/*
+ * Multi station support
+ */
+
+/* Special, dedicated locations within device's station table */
+#define        IL_AP_ID                0
+#define        IL_STA_ID               2
+#define        IL3945_BROADCAST_ID     24
+#define IL3945_STATION_COUNT   25
+#define IL4965_BROADCAST_ID    31
+#define        IL4965_STATION_COUNT    32
+
+#define        IL_STATION_COUNT        32      /* MAX(3945,4965) */
+#define        IL_INVALID_STATION      255
+
+#define STA_FLG_TX_RATE_MSK            cpu_to_le32(1 << 2)
+#define STA_FLG_PWR_SAVE_MSK           cpu_to_le32(1 << 8)
+#define STA_FLG_RTS_MIMO_PROT_MSK      cpu_to_le32(1 << 17)
+#define STA_FLG_AGG_MPDU_8US_MSK       cpu_to_le32(1 << 18)
+#define STA_FLG_MAX_AGG_SIZE_POS       (19)
+#define STA_FLG_MAX_AGG_SIZE_MSK       cpu_to_le32(3 << 19)
+#define STA_FLG_HT40_EN_MSK            cpu_to_le32(1 << 21)
+#define STA_FLG_MIMO_DIS_MSK           cpu_to_le32(1 << 22)
+#define STA_FLG_AGG_MPDU_DENSITY_POS   (23)
+#define STA_FLG_AGG_MPDU_DENSITY_MSK   cpu_to_le32(7 << 23)
+
+/* Use in mode field.  1: modify existing entry, 0: add new station entry */
+#define STA_CONTROL_MODIFY_MSK         0x01
+
+/* key flags __le16*/
+#define STA_KEY_FLG_ENCRYPT_MSK        cpu_to_le16(0x0007)
+#define STA_KEY_FLG_NO_ENC     cpu_to_le16(0x0000)
+#define STA_KEY_FLG_WEP                cpu_to_le16(0x0001)
+#define STA_KEY_FLG_CCMP       cpu_to_le16(0x0002)
+#define STA_KEY_FLG_TKIP       cpu_to_le16(0x0003)
+
+#define STA_KEY_FLG_KEYID_POS  8
+#define STA_KEY_FLG_INVALID    cpu_to_le16(0x0800)
+/* wep key is either from global key (0) or from station info array (1) */
+#define STA_KEY_FLG_MAP_KEY_MSK        cpu_to_le16(0x0008)
+
+/* wep key in STA: 5-bytes (0) or 13-bytes (1) */
+#define STA_KEY_FLG_KEY_SIZE_MSK       cpu_to_le16(0x1000)
+#define STA_KEY_MULTICAST_MSK          cpu_to_le16(0x4000)
+#define STA_KEY_MAX_NUM                8
+
+/* Flags indicate whether to modify vs. don't change various station params */
+#define        STA_MODIFY_KEY_MASK             0x01
+#define        STA_MODIFY_TID_DISABLE_TX       0x02
+#define        STA_MODIFY_TX_RATE_MSK          0x04
+#define STA_MODIFY_ADDBA_TID_MSK       0x08
+#define STA_MODIFY_DELBA_TID_MSK       0x10
+#define STA_MODIFY_SLEEP_TX_COUNT_MSK  0x20
+
+/* Receiver address (actually, Rx station's idx into station table),
+ * combined with Traffic ID (QOS priority), in format used by Tx Scheduler */
+#define BUILD_RAxTID(sta_id, tid)      (((sta_id) << 4) + (tid))
+
+struct il4965_keyinfo {
+       __le16 key_flags;
+       u8 tkip_rx_tsc_byte2;   /* TSC[2] for key mix ph1 detection */
+       u8 reserved1;
+       __le16 tkip_rx_ttak[5]; /* 10-byte unicast TKIP TTAK */
+       u8 key_offset;
+       u8 reserved2;
+       u8 key[16];             /* 16-byte unicast decryption key */
+} __packed;
+
+/**
+ * struct sta_id_modify
+ * @addr[ETH_ALEN]: station's MAC address
+ * @sta_id: idx of station in uCode's station table
+ * @modify_mask: STA_MODIFY_*, 1: modify, 0: don't change
+ *
+ * Driver selects unused table idx when adding new station,
+ * or the idx to a pre-existing station entry when modifying that station.
+ * Some idxes have special purposes (IL_AP_ID, idx 0, is for AP).
+ *
+ * modify_mask flags select which parameters to modify vs. leave alone.
+ */
+struct sta_id_modify {
+       u8 addr[ETH_ALEN];
+       __le16 reserved1;
+       u8 sta_id;
+       u8 modify_mask;
+       __le16 reserved2;
+} __packed;
+
+/*
+ * C_ADD_STA = 0x18 (command)
+ *
+ * The device contains an internal table of per-station information,
+ * with info on security keys, aggregation parameters, and Tx rates for
+ * initial Tx attempt and any retries (4965 devices uses
+ * C_TX_LINK_QUALITY_CMD,
+ * 3945 uses C_RATE_SCALE to set up rate tables).
+ *
+ * C_ADD_STA sets up the table entry for one station, either creating
+ * a new entry, or modifying a pre-existing one.
+ *
+ * NOTE:  RXON command (without "associated" bit set) wipes the station table
+ *        clean.  Moving into RF_KILL state does this also.  Driver must set up
+ *        new station table before transmitting anything on the RXON channel
+ *        (except active scans or active measurements; those commands carry
+ *        their own txpower/rate setup data).
+ *
+ *        When getting started on a new channel, driver must set up the
+ *        IL_BROADCAST_ID entry (last entry in the table).  For a client
+ *        station in a BSS, once an AP is selected, driver sets up the AP STA
+ *        in the IL_AP_ID entry (1st entry in the table).  BROADCAST and AP
+ *        are all that are needed for a BSS client station.  If the device is
+ *        used as AP, or in an IBSS network, driver must set up station table
+ *        entries for all STAs in network, starting with idx IL_STA_ID.
+ */
+
+struct il3945_addsta_cmd {
+       u8 mode;                /* 1: modify existing, 0: add new station */
+       u8 reserved[3];
+       struct sta_id_modify sta;
+       struct il4965_keyinfo key;
+       __le32 station_flags;   /* STA_FLG_* */
+       __le32 station_flags_msk;       /* STA_FLG_* */
+
+       /* bit field to disable (1) or enable (0) Tx for Traffic ID (TID)
+        * corresponding to bit (e.g. bit 5 controls TID 5).
+        * Set modify_mask bit STA_MODIFY_TID_DISABLE_TX to use this field. */
+       __le16 tid_disable_tx;
+
+       __le16 rate_n_flags;
+
+       /* TID for which to add block-ack support.
+        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
+       u8 add_immediate_ba_tid;
+
+       /* TID for which to remove block-ack support.
+        * Set modify_mask bit STA_MODIFY_DELBA_TID_MSK to use this field. */
+       u8 remove_immediate_ba_tid;
+
+       /* Starting Sequence Number for added block-ack support.
+        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
+       __le16 add_immediate_ba_ssn;
+} __packed;
+
+struct il4965_addsta_cmd {
+       u8 mode;                /* 1: modify existing, 0: add new station */
+       u8 reserved[3];
+       struct sta_id_modify sta;
+       struct il4965_keyinfo key;
+       __le32 station_flags;   /* STA_FLG_* */
+       __le32 station_flags_msk;       /* STA_FLG_* */
+
+       /* bit field to disable (1) or enable (0) Tx for Traffic ID (TID)
+        * corresponding to bit (e.g. bit 5 controls TID 5).
+        * Set modify_mask bit STA_MODIFY_TID_DISABLE_TX to use this field. */
+       __le16 tid_disable_tx;
+
+       __le16 reserved1;
+
+       /* TID for which to add block-ack support.
+        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
+       u8 add_immediate_ba_tid;
+
+       /* TID for which to remove block-ack support.
+        * Set modify_mask bit STA_MODIFY_DELBA_TID_MSK to use this field. */
+       u8 remove_immediate_ba_tid;
+
+       /* Starting Sequence Number for added block-ack support.
+        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
+       __le16 add_immediate_ba_ssn;
+
+       /*
+        * Number of packets OK to transmit to station even though
+        * it is asleep -- used to synchronise PS-poll and u-APSD
+        * responses while ucode keeps track of STA sleep state.
+        */
+       __le16 sleep_tx_count;
+
+       __le16 reserved2;
+} __packed;
+
+/* Wrapper struct for 3945 and 4965 addsta_cmd structures */
+struct il_addsta_cmd {
+       u8 mode;                /* 1: modify existing, 0: add new station */
+       u8 reserved[3];
+       struct sta_id_modify sta;
+       struct il4965_keyinfo key;
+       __le32 station_flags;   /* STA_FLG_* */
+       __le32 station_flags_msk;       /* STA_FLG_* */
+
+       /* bit field to disable (1) or enable (0) Tx for Traffic ID (TID)
+        * corresponding to bit (e.g. bit 5 controls TID 5).
+        * Set modify_mask bit STA_MODIFY_TID_DISABLE_TX to use this field. */
+       __le16 tid_disable_tx;
+
+       __le16 rate_n_flags;    /* 3945 only */
+
+       /* TID for which to add block-ack support.
+        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
+       u8 add_immediate_ba_tid;
+
+       /* TID for which to remove block-ack support.
+        * Set modify_mask bit STA_MODIFY_DELBA_TID_MSK to use this field. */
+       u8 remove_immediate_ba_tid;
+
+       /* Starting Sequence Number for added block-ack support.
+        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
+       __le16 add_immediate_ba_ssn;
+
+       /*
+        * Number of packets OK to transmit to station even though
+        * it is asleep -- used to synchronise PS-poll and u-APSD
+        * responses while ucode keeps track of STA sleep state.
+        */
+       __le16 sleep_tx_count;
+
+       __le16 reserved2;
+} __packed;
+
+#define ADD_STA_SUCCESS_MSK            0x1
+#define ADD_STA_NO_ROOM_IN_TBL 0x2
+#define ADD_STA_NO_BLOCK_ACK_RESOURCE  0x4
+#define ADD_STA_MODIFY_NON_EXIST_STA   0x8
+/*
+ * C_ADD_STA = 0x18 (response)
+ */
+struct il_add_sta_resp {
+       u8 status;              /* ADD_STA_* */
+} __packed;
+
+#define REM_STA_SUCCESS_MSK              0x1
+/*
+ *  C_REM_STA = 0x19 (response)
+ */
+struct il_rem_sta_resp {
+       u8 status;
+} __packed;
+
+/*
+ *  C_REM_STA = 0x19 (command)
+ */
+struct il_rem_sta_cmd {
+       u8 num_sta;             /* number of removed stations */
+       u8 reserved[3];
+       u8 addr[ETH_ALEN];      /* MAC addr of the first station */
+       u8 reserved2[2];
+} __packed;
+
+#define IL_TX_FIFO_BK_MSK              cpu_to_le32(BIT(0))
+#define IL_TX_FIFO_BE_MSK              cpu_to_le32(BIT(1))
+#define IL_TX_FIFO_VI_MSK              cpu_to_le32(BIT(2))
+#define IL_TX_FIFO_VO_MSK              cpu_to_le32(BIT(3))
+#define IL_AGG_TX_QUEUE_MSK            cpu_to_le32(0xffc00)
+
+#define IL_DROP_SINGLE         0
+#define IL_DROP_SELECTED       1
+#define IL_DROP_ALL            2
+
+/*
+ * REPLY_WEP_KEY = 0x20
+ */
+struct il_wep_key {
+       u8 key_idx;
+       u8 key_offset;
+       u8 reserved1[2];
+       u8 key_size;
+       u8 reserved2[3];
+       u8 key[16];
+} __packed;
+
+struct il_wep_cmd {
+       u8 num_keys;
+       u8 global_key_type;
+       u8 flags;
+       u8 reserved;
+       struct il_wep_key key[0];
+} __packed;
+
+#define WEP_KEY_WEP_TYPE 1
+#define WEP_KEYS_MAX 4
+#define WEP_INVALID_OFFSET 0xff
+#define WEP_KEY_LEN_64 5
+#define WEP_KEY_LEN_128 13
+
+/******************************************************************************
+ * (4)
+ * Rx Responses:
+ *
+ *****************************************************************************/
+
+#define RX_RES_STATUS_NO_CRC32_ERROR   cpu_to_le32(1 << 0)
+#define RX_RES_STATUS_NO_RXE_OVERFLOW  cpu_to_le32(1 << 1)
+
+#define RX_RES_PHY_FLAGS_BAND_24_MSK   cpu_to_le16(1 << 0)
+#define RX_RES_PHY_FLAGS_MOD_CCK_MSK           cpu_to_le16(1 << 1)
+#define RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK    cpu_to_le16(1 << 2)
+#define RX_RES_PHY_FLAGS_NARROW_BAND_MSK       cpu_to_le16(1 << 3)
+#define RX_RES_PHY_FLAGS_ANTENNA_MSK           0x70
+#define RX_RES_PHY_FLAGS_ANTENNA_POS           4
+#define RX_RES_PHY_FLAGS_AGG_MSK       cpu_to_le16(1 << 7)
+
+#define RX_RES_STATUS_SEC_TYPE_MSK     (0x7 << 8)
+#define RX_RES_STATUS_SEC_TYPE_NONE    (0x0 << 8)
+#define RX_RES_STATUS_SEC_TYPE_WEP     (0x1 << 8)
+#define RX_RES_STATUS_SEC_TYPE_CCMP    (0x2 << 8)
+#define RX_RES_STATUS_SEC_TYPE_TKIP    (0x3 << 8)
+#define        RX_RES_STATUS_SEC_TYPE_ERR      (0x7 << 8)
+
+#define RX_RES_STATUS_STATION_FOUND    (1<<6)
+#define RX_RES_STATUS_NO_STATION_INFO_MISMATCH (1<<7)
+
+#define RX_RES_STATUS_DECRYPT_TYPE_MSK (0x3 << 11)
+#define RX_RES_STATUS_NOT_DECRYPT      (0x0 << 11)
+#define RX_RES_STATUS_DECRYPT_OK       (0x3 << 11)
+#define RX_RES_STATUS_BAD_ICV_MIC      (0x1 << 11)
+#define RX_RES_STATUS_BAD_KEY_TTAK     (0x2 << 11)
+
+#define RX_MPDU_RES_STATUS_ICV_OK      (0x20)
+#define RX_MPDU_RES_STATUS_MIC_OK      (0x40)
+#define RX_MPDU_RES_STATUS_TTAK_OK     (1 << 7)
+#define RX_MPDU_RES_STATUS_DEC_DONE_MSK        (0x800)
+
+struct il3945_rx_frame_stats {
+       u8 phy_count;
+       u8 id;
+       u8 rssi;
+       u8 agc;
+       __le16 sig_avg;
+       __le16 noise_diff;
+       u8 payload[0];
+} __packed;
+
+struct il3945_rx_frame_hdr {
+       __le16 channel;
+       __le16 phy_flags;
+       u8 reserved1;
+       u8 rate;
+       __le16 len;
+       u8 payload[0];
+} __packed;
+
+struct il3945_rx_frame_end {
+       __le32 status;
+       __le64 timestamp;
+       __le32 beacon_timestamp;
+} __packed;
+
+/*
+ * N_3945_RX = 0x1b (response only, not a command)
+ *
+ * NOTE:  DO NOT dereference from casts to this structure
+ * It is provided only for calculating minimum data set size.
+ * The actual offsets of the hdr and end are dynamic based on
+ * stats.phy_count
+ */
+struct il3945_rx_frame {
+       struct il3945_rx_frame_stats stats;
+       struct il3945_rx_frame_hdr hdr;
+       struct il3945_rx_frame_end end;
+} __packed;
+
+#define IL39_RX_FRAME_SIZE     (4 + sizeof(struct il3945_rx_frame))
+
+/* Fixed (non-configurable) rx data from phy */
+
+#define IL49_RX_RES_PHY_CNT 14
+#define IL49_RX_PHY_FLAGS_ANTENNAE_OFFSET      (4)
+#define IL49_RX_PHY_FLAGS_ANTENNAE_MASK        (0x70)
+#define IL49_AGC_DB_MASK                       (0x3f80)        /* MASK(7,13) */
+#define IL49_AGC_DB_POS                        (7)
+struct il4965_rx_non_cfg_phy {
+       __le16 ant_selection;   /* ant A bit 4, ant B bit 5, ant C bit 6 */
+       __le16 agc_info;        /* agc code 0:6, agc dB 7:13, reserved 14:15 */
+       u8 rssi_info[6];        /* we use even entries, 0/2/4 for A/B/C rssi */
+       u8 pad[0];
+} __packed;
+
+/*
+ * N_RX = 0xc3 (response only, not a command)
+ * Used only for legacy (non 11n) frames.
+ */
+struct il_rx_phy_res {
+       u8 non_cfg_phy_cnt;     /* non configurable DSP phy data byte count */
+       u8 cfg_phy_cnt;         /* configurable DSP phy data byte count */
+       u8 stat_id;             /* configurable DSP phy data set ID */
+       u8 reserved1;
+       __le64 timestamp;       /* TSF at on air rise */
+       __le32 beacon_time_stamp;       /* beacon at on-air rise */
+       __le16 phy_flags;       /* general phy flags: band, modulation, ... */
+       __le16 channel;         /* channel number */
+       u8 non_cfg_phy_buf[32]; /* for various implementations of non_cfg_phy */
+       __le32 rate_n_flags;    /* RATE_MCS_* */
+       __le16 byte_count;      /* frame's byte-count */
+       __le16 frame_time;      /* frame's time on the air */
+} __packed;
+
+struct il_rx_mpdu_res_start {
+       __le16 byte_count;
+       __le16 reserved;
+} __packed;
+
+/******************************************************************************
+ * (5)
+ * Tx Commands & Responses:
+ *
+ * Driver must place each C_TX command into one of the prioritized Tx
+ * queues in host DRAM, shared between driver and device (see comments for
+ * SCD registers and Tx/Rx Queues).  When the device's Tx scheduler and uCode
+ * are preparing to transmit, the device pulls the Tx command over the PCI
+ * bus via one of the device's Tx DMA channels, to fill an internal FIFO
+ * from which data will be transmitted.
+ *
+ * uCode handles all timing and protocol related to control frames
+ * (RTS/CTS/ACK), based on flags in the Tx command.  uCode and Tx scheduler
+ * handle reception of block-acks; uCode updates the host driver via
+ * N_COMPRESSED_BA.
+ *
+ * uCode handles retrying Tx when an ACK is expected but not received.
+ * This includes trying lower data rates than the one requested in the Tx
+ * command, as set up by the C_RATE_SCALE (for 3945) or
+ * C_TX_LINK_QUALITY_CMD (4965).
+ *
+ * Driver sets up transmit power for various rates via C_TX_PWR_TBL.
+ * This command must be executed after every RXON command, before Tx can occur.
+ *****************************************************************************/
+
+/* C_TX Tx flags field */
+
+/*
+ * 1: Use Request-To-Send protocol before this frame.
+ * Mutually exclusive vs. TX_CMD_FLG_CTS_MSK.
+ */
+#define TX_CMD_FLG_RTS_MSK cpu_to_le32(1 << 1)
+
+/*
+ * 1: Transmit Clear-To-Send to self before this frame.
+ * Driver should set this for AUTH/DEAUTH/ASSOC-REQ/REASSOC mgmnt frames.
+ * Mutually exclusive vs. TX_CMD_FLG_RTS_MSK.
+ */
+#define TX_CMD_FLG_CTS_MSK cpu_to_le32(1 << 2)
+
+/* 1: Expect ACK from receiving station
+ * 0: Don't expect ACK (MAC header's duration field s/b 0)
+ * Set this for unicast frames, but not broadcast/multicast. */
+#define TX_CMD_FLG_ACK_MSK cpu_to_le32(1 << 3)
+
+/* For 4965 devices:
+ * 1: Use rate scale table (see C_TX_LINK_QUALITY_CMD).
+ *    Tx command's initial_rate_idx indicates first rate to try;
+ *    uCode walks through table for additional Tx attempts.
+ * 0: Use Tx rate/MCS from Tx command's rate_n_flags field.
+ *    This rate will be used for all Tx attempts; it will not be scaled. */
+#define TX_CMD_FLG_STA_RATE_MSK cpu_to_le32(1 << 4)
+
+/* 1: Expect immediate block-ack.
+ * Set when Txing a block-ack request frame.  Also set TX_CMD_FLG_ACK_MSK. */
+#define TX_CMD_FLG_IMM_BA_RSP_MASK  cpu_to_le32(1 << 6)
+
+/*
+ * 1: Frame requires full Tx-Op protection.
+ * Set this if either RTS or CTS Tx Flag gets set.
+ */
+#define TX_CMD_FLG_FULL_TXOP_PROT_MSK cpu_to_le32(1 << 7)
+
+/* Tx antenna selection field; used only for 3945, reserved (0) for 4965 devices.
+ * Set field to "0" to allow 3945 uCode to select antenna (normal usage). */
+#define TX_CMD_FLG_ANT_SEL_MSK cpu_to_le32(0xf00)
+#define TX_CMD_FLG_ANT_A_MSK cpu_to_le32(1 << 8)
+#define TX_CMD_FLG_ANT_B_MSK cpu_to_le32(1 << 9)
+
+/* 1: uCode overrides sequence control field in MAC header.
+ * 0: Driver provides sequence control field in MAC header.
+ * Set this for management frames, non-QOS data frames, non-unicast frames,
+ * and also in Tx command embedded in C_SCAN for active scans. */
+#define TX_CMD_FLG_SEQ_CTL_MSK cpu_to_le32(1 << 13)
+
+/* 1: This frame is non-last MPDU; more fragments are coming.
+ * 0: Last fragment, or not using fragmentation. */
+#define TX_CMD_FLG_MORE_FRAG_MSK cpu_to_le32(1 << 14)
+
+/* 1: uCode calculates and inserts Timestamp Function (TSF) in outgoing frame.
+ * 0: No TSF required in outgoing frame.
+ * Set this for transmitting beacons and probe responses. */
+#define TX_CMD_FLG_TSF_MSK cpu_to_le32(1 << 16)
+
+/* 1: Driver inserted 2 bytes pad after the MAC header, for (required) dword
+ *    alignment of frame's payload data field.
+ * 0: No pad
+ * Set this for MAC headers with 26 or 30 bytes, i.e. those with QOS or ADDR4
+ * field (but not both).  Driver must align frame data (i.e. data following
+ * MAC header) to DWORD boundary. */
+#define TX_CMD_FLG_MH_PAD_MSK cpu_to_le32(1 << 20)
+
+/* accelerate aggregation support
+ * 0 - no CCMP encryption; 1 - CCMP encryption */
+#define TX_CMD_FLG_AGG_CCMP_MSK cpu_to_le32(1 << 22)
+
+/* HCCA-AP - disable duration overwriting. */
+#define TX_CMD_FLG_DUR_MSK cpu_to_le32(1 << 25)
+
+/*
+ * TX command security control
+ */
+#define TX_CMD_SEC_WEP         0x01
+#define TX_CMD_SEC_CCM         0x02
+#define TX_CMD_SEC_TKIP                0x03
+#define TX_CMD_SEC_MSK         0x03
+#define TX_CMD_SEC_SHIFT       6
+#define TX_CMD_SEC_KEY128      0x08
+
+/*
+ * C_TX = 0x1c (command)
+ */
+
+struct il3945_tx_cmd {
+       /*
+        * MPDU byte count:
+        * MAC header (24/26/30/32 bytes) + 2 bytes pad if 26/30 header size,
+        * + 8 byte IV for CCM or TKIP (not used for WEP)
+        * + Data payload
+        * + 8-byte MIC (not used for CCM/WEP)
+        * NOTE:  Does not include Tx command bytes, post-MAC pad bytes,
+        *        MIC (CCM) 8 bytes, ICV (WEP/TKIP/CKIP) 4 bytes, CRC 4 bytes.i
+        * Range: 14-2342 bytes.
+        */
+       __le16 len;
+
+       /*
+        * MPDU or MSDU byte count for next frame.
+        * Used for fragmentation and bursting, but not 11n aggregation.
+        * Same as "len", but for next frame.  Set to 0 if not applicable.
+        */
+       __le16 next_frame_len;
+
+       __le32 tx_flags;        /* TX_CMD_FLG_* */
+
+       u8 rate;
+
+       /* Index of recipient station in uCode's station table */
+       u8 sta_id;
+       u8 tid_tspec;
+       u8 sec_ctl;
+       u8 key[16];
+       union {
+               u8 byte[8];
+               __le16 word[4];
+               __le32 dw[2];
+       } tkip_mic;
+       __le32 next_frame_info;
+       union {
+               __le32 life_time;
+               __le32 attempt;
+       } stop_time;
+       u8 supp_rates[2];
+       u8 rts_retry_limit;     /*byte 50 */
+       u8 data_retry_limit;    /*byte 51 */
+       union {
+               __le16 pm_frame_timeout;
+               __le16 attempt_duration;
+       } timeout;
+
+       /*
+        * Duration of EDCA burst Tx Opportunity, in 32-usec units.
+        * Set this if txop time is not specified by HCCA protocol (e.g. by AP).
+        */
+       __le16 driver_txop;
+
+       /*
+        * MAC header goes here, followed by 2 bytes padding if MAC header
+        * length is 26 or 30 bytes, followed by payload data
+        */
+       u8 payload[0];
+       struct ieee80211_hdr hdr[0];
+} __packed;
+
+/*
+ * C_TX = 0x1c (response)
+ */
+struct il3945_tx_resp {
+       u8 failure_rts;
+       u8 failure_frame;
+       u8 bt_kill_count;
+       u8 rate;
+       __le32 wireless_media_time;
+       __le32 status;          /* TX status */
+} __packed;
+
+/*
+ * 4965 uCode updates these Tx attempt count values in host DRAM.
+ * Used for managing Tx retries when expecting block-acks.
+ * Driver should set these fields to 0.
+ */
+struct il_dram_scratch {
+       u8 try_cnt;             /* Tx attempts */
+       u8 bt_kill_cnt;         /* Tx attempts blocked by Bluetooth device */
+       __le16 reserved;
+} __packed;
+
+struct il_tx_cmd {
+       /*
+        * MPDU byte count:
+        * MAC header (24/26/30/32 bytes) + 2 bytes pad if 26/30 header size,
+        * + 8 byte IV for CCM or TKIP (not used for WEP)
+        * + Data payload
+        * + 8-byte MIC (not used for CCM/WEP)
+        * NOTE:  Does not include Tx command bytes, post-MAC pad bytes,
+        *        MIC (CCM) 8 bytes, ICV (WEP/TKIP/CKIP) 4 bytes, CRC 4 bytes.i
+        * Range: 14-2342 bytes.
+        */
+       __le16 len;
+
+       /*
+        * MPDU or MSDU byte count for next frame.
+        * Used for fragmentation and bursting, but not 11n aggregation.
+        * Same as "len", but for next frame.  Set to 0 if not applicable.
+        */
+       __le16 next_frame_len;
+
+       __le32 tx_flags;        /* TX_CMD_FLG_* */
+
+       /* uCode may modify this field of the Tx command (in host DRAM!).
+        * Driver must also set dram_lsb_ptr and dram_msb_ptr in this cmd. */
+       struct il_dram_scratch scratch;
+
+       /* Rate for *all* Tx attempts, if TX_CMD_FLG_STA_RATE_MSK is cleared. */
+       __le32 rate_n_flags;    /* RATE_MCS_* */
+
+       /* Index of destination station in uCode's station table */
+       u8 sta_id;
+
+       /* Type of security encryption:  CCM or TKIP */
+       u8 sec_ctl;             /* TX_CMD_SEC_* */
+
+       /*
+        * Index into rate table (see C_TX_LINK_QUALITY_CMD) for initial
+        * Tx attempt, if TX_CMD_FLG_STA_RATE_MSK is set.  Normally "0" for
+        * data frames, this field may be used to selectively reduce initial
+        * rate (via non-0 value) for special frames (e.g. management), while
+        * still supporting rate scaling for all frames.
+        */
+       u8 initial_rate_idx;
+       u8 reserved;
+       u8 key[16];
+       __le16 next_frame_flags;
+       __le16 reserved2;
+       union {
+               __le32 life_time;
+               __le32 attempt;
+       } stop_time;
+
+       /* Host DRAM physical address pointer to "scratch" in this command.
+        * Must be dword aligned.  "0" in dram_lsb_ptr disables usage. */
+       __le32 dram_lsb_ptr;
+       u8 dram_msb_ptr;
+
+       u8 rts_retry_limit;     /*byte 50 */
+       u8 data_retry_limit;    /*byte 51 */
+       u8 tid_tspec;
+       union {
+               __le16 pm_frame_timeout;
+               __le16 attempt_duration;
+       } timeout;
+
+       /*
+        * Duration of EDCA burst Tx Opportunity, in 32-usec units.
+        * Set this if txop time is not specified by HCCA protocol (e.g. by AP).
+        */
+       __le16 driver_txop;
+
+       /*
+        * MAC header goes here, followed by 2 bytes padding if MAC header
+        * length is 26 or 30 bytes, followed by payload data
+        */
+       u8 payload[0];
+       struct ieee80211_hdr hdr[0];
+} __packed;
+
+/* TX command response is sent after *3945* transmission attempts.
+ *
+ * NOTES:
+ *
+ * TX_STATUS_FAIL_NEXT_FRAG
+ *
+ * If the fragment flag in the MAC header for the frame being transmitted
+ * is set and there is insufficient time to transmit the next frame, the
+ * TX status will be returned with 'TX_STATUS_FAIL_NEXT_FRAG'.
+ *
+ * TX_STATUS_FIFO_UNDERRUN
+ *
+ * Indicates the host did not provide bytes to the FIFO fast enough while
+ * a TX was in progress.
+ *
+ * TX_STATUS_FAIL_MGMNT_ABORT
+ *
+ * This status is only possible if the ABORT ON MGMT RX parameter was
+ * set to true with the TX command.
+ *
+ * If the MSB of the status parameter is set then an abort sequence is
+ * required.  This sequence consists of the host activating the TX Abort
+ * control line, and then waiting for the TX Abort command response.  This
+ * indicates that a the device is no longer in a transmit state, and that the
+ * command FIFO has been cleared.  The host must then deactivate the TX Abort
+ * control line.  Receiving is still allowed in this case.
+ */
+enum {
+       TX_3945_STATUS_SUCCESS = 0x01,
+       TX_3945_STATUS_DIRECT_DONE = 0x02,
+       TX_3945_STATUS_FAIL_SHORT_LIMIT = 0x82,
+       TX_3945_STATUS_FAIL_LONG_LIMIT = 0x83,
+       TX_3945_STATUS_FAIL_FIFO_UNDERRUN = 0x84,
+       TX_3945_STATUS_FAIL_MGMNT_ABORT = 0x85,
+       TX_3945_STATUS_FAIL_NEXT_FRAG = 0x86,
+       TX_3945_STATUS_FAIL_LIFE_EXPIRE = 0x87,
+       TX_3945_STATUS_FAIL_DEST_PS = 0x88,
+       TX_3945_STATUS_FAIL_ABORTED = 0x89,
+       TX_3945_STATUS_FAIL_BT_RETRY = 0x8a,
+       TX_3945_STATUS_FAIL_STA_INVALID = 0x8b,
+       TX_3945_STATUS_FAIL_FRAG_DROPPED = 0x8c,
+       TX_3945_STATUS_FAIL_TID_DISABLE = 0x8d,
+       TX_3945_STATUS_FAIL_FRAME_FLUSHED = 0x8e,
+       TX_3945_STATUS_FAIL_INSUFFICIENT_CF_POLL = 0x8f,
+       TX_3945_STATUS_FAIL_TX_LOCKED = 0x90,
+       TX_3945_STATUS_FAIL_NO_BEACON_ON_RADAR = 0x91,
+};
+
+/*
+ * TX command response is sent after *4965* transmission attempts.
+ *
+ * both postpone and abort status are expected behavior from uCode. there is
+ * no special operation required from driver; except for RFKILL_FLUSH,
+ * which required tx flush host command to flush all the tx frames in queues
+ */
+enum {
+       TX_STATUS_SUCCESS = 0x01,
+       TX_STATUS_DIRECT_DONE = 0x02,
+       /* postpone TX */
+       TX_STATUS_POSTPONE_DELAY = 0x40,
+       TX_STATUS_POSTPONE_FEW_BYTES = 0x41,
+       TX_STATUS_POSTPONE_QUIET_PERIOD = 0x43,
+       TX_STATUS_POSTPONE_CALC_TTAK = 0x44,
+       /* abort TX */
+       TX_STATUS_FAIL_INTERNAL_CROSSED_RETRY = 0x81,
+       TX_STATUS_FAIL_SHORT_LIMIT = 0x82,
+       TX_STATUS_FAIL_LONG_LIMIT = 0x83,
+       TX_STATUS_FAIL_FIFO_UNDERRUN = 0x84,
+       TX_STATUS_FAIL_DRAIN_FLOW = 0x85,
+       TX_STATUS_FAIL_RFKILL_FLUSH = 0x86,
+       TX_STATUS_FAIL_LIFE_EXPIRE = 0x87,
+       TX_STATUS_FAIL_DEST_PS = 0x88,
+       TX_STATUS_FAIL_HOST_ABORTED = 0x89,
+       TX_STATUS_FAIL_BT_RETRY = 0x8a,
+       TX_STATUS_FAIL_STA_INVALID = 0x8b,
+       TX_STATUS_FAIL_FRAG_DROPPED = 0x8c,
+       TX_STATUS_FAIL_TID_DISABLE = 0x8d,
+       TX_STATUS_FAIL_FIFO_FLUSHED = 0x8e,
+       TX_STATUS_FAIL_INSUFFICIENT_CF_POLL = 0x8f,
+       TX_STATUS_FAIL_PASSIVE_NO_RX = 0x90,
+       TX_STATUS_FAIL_NO_BEACON_ON_RADAR = 0x91,
+};
+
+#define        TX_PACKET_MODE_REGULAR          0x0000
+#define        TX_PACKET_MODE_BURST_SEQ        0x0100
+#define        TX_PACKET_MODE_BURST_FIRST      0x0200
+
+enum {
+       TX_POWER_PA_NOT_ACTIVE = 0x0,
+};
+
+enum {
+       TX_STATUS_MSK = 0x000000ff,     /* bits 0:7 */
+       TX_STATUS_DELAY_MSK = 0x00000040,
+       TX_STATUS_ABORT_MSK = 0x00000080,
+       TX_PACKET_MODE_MSK = 0x0000ff00,        /* bits 8:15 */
+       TX_FIFO_NUMBER_MSK = 0x00070000,        /* bits 16:18 */
+       TX_RESERVED = 0x00780000,       /* bits 19:22 */
+       TX_POWER_PA_DETECT_MSK = 0x7f800000,    /* bits 23:30 */
+       TX_ABORT_REQUIRED_MSK = 0x80000000,     /* bits 31:31 */
+};
+
+/* *******************************
+ * TX aggregation status
+ ******************************* */
+
+enum {
+       AGG_TX_STATE_TRANSMITTED = 0x00,
+       AGG_TX_STATE_UNDERRUN_MSK = 0x01,
+       AGG_TX_STATE_FEW_BYTES_MSK = 0x04,
+       AGG_TX_STATE_ABORT_MSK = 0x08,
+       AGG_TX_STATE_LAST_SENT_TTL_MSK = 0x10,
+       AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK = 0x20,
+       AGG_TX_STATE_SCD_QUERY_MSK = 0x80,
+       AGG_TX_STATE_TEST_BAD_CRC32_MSK = 0x100,
+       AGG_TX_STATE_RESPONSE_MSK = 0x1ff,
+       AGG_TX_STATE_DUMP_TX_MSK = 0x200,
+       AGG_TX_STATE_DELAY_TX_MSK = 0x400
+};
+
+#define AGG_TX_STATUS_MSK      0x00000fff      /* bits 0:11 */
+#define AGG_TX_TRY_MSK         0x0000f000      /* bits 12:15 */
+
+#define AGG_TX_STATE_LAST_SENT_MSK  (AGG_TX_STATE_LAST_SENT_TTL_MSK | \
+                                    AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK)
+
+/* # tx attempts for first frame in aggregation */
+#define AGG_TX_STATE_TRY_CNT_POS 12
+#define AGG_TX_STATE_TRY_CNT_MSK 0xf000
+
+/* Command ID and sequence number of Tx command for this frame */
+#define AGG_TX_STATE_SEQ_NUM_POS 16
+#define AGG_TX_STATE_SEQ_NUM_MSK 0xffff0000
+
+/*
+ * C_TX = 0x1c (response)
+ *
+ * This response may be in one of two slightly different formats, indicated
+ * by the frame_count field:
+ *
+ * 1)  No aggregation (frame_count == 1).  This reports Tx results for
+ *     a single frame.  Multiple attempts, at various bit rates, may have
+ *     been made for this frame.
+ *
+ * 2)  Aggregation (frame_count > 1).  This reports Tx results for
+ *     2 or more frames that used block-acknowledge.  All frames were
+ *     transmitted at same rate.  Rate scaling may have been used if first
+ *     frame in this new agg block failed in previous agg block(s).
+ *
+ *     Note that, for aggregation, ACK (block-ack) status is not delivered here;
+ *     block-ack has not been received by the time the 4965 device records
+ *     this status.
+ *     This status relates to reasons the tx might have been blocked or aborted
+ *     within the sending station (this 4965 device), rather than whether it was
+ *     received successfully by the destination station.
+ */
+struct agg_tx_status {
+       __le16 status;
+       __le16 sequence;
+} __packed;
+
+struct il4965_tx_resp {
+       u8 frame_count;         /* 1 no aggregation, >1 aggregation */
+       u8 bt_kill_count;       /* # blocked by bluetooth (unused for agg) */
+       u8 failure_rts;         /* # failures due to unsuccessful RTS */
+       u8 failure_frame;       /* # failures due to no ACK (unused for agg) */
+
+       /* For non-agg:  Rate at which frame was successful.
+        * For agg:  Rate at which all frames were transmitted. */
+       __le32 rate_n_flags;    /* RATE_MCS_*  */
+
+       /* For non-agg:  RTS + CTS + frame tx attempts time + ACK.
+        * For agg:  RTS + CTS + aggregation tx time + block-ack time. */
+       __le16 wireless_media_time;     /* uSecs */
+
+       __le16 reserved;
+       __le32 pa_power1;       /* RF power amplifier measurement (not used) */
+       __le32 pa_power2;
+
+       /*
+        * For non-agg:  frame status TX_STATUS_*
+        * For agg:  status of 1st frame, AGG_TX_STATE_*; other frame status
+        *           fields follow this one, up to frame_count.
+        *           Bit fields:
+        *           11- 0:  AGG_TX_STATE_* status code
+        *           15-12:  Retry count for 1st frame in aggregation (retries
+        *                   occur if tx failed for this frame when it was a
+        *                   member of a previous aggregation block).  If rate
+        *                   scaling is used, retry count indicates the rate
+        *                   table entry used for all frames in the new agg.
+        *           31-16:  Sequence # for this frame's Tx cmd (not SSN!)
+        */
+       union {
+               __le32 status;
+               struct agg_tx_status agg_status[0];     /* for each agg frame */
+       } u;
+} __packed;
+
+/*
+ * N_COMPRESSED_BA = 0xc5 (response only, not a command)
+ *
+ * Reports Block-Acknowledge from recipient station
+ */
+struct il_compressed_ba_resp {
+       __le32 sta_addr_lo32;
+       __le16 sta_addr_hi16;
+       __le16 reserved;
+
+       /* Index of recipient (BA-sending) station in uCode's station table */
+       u8 sta_id;
+       u8 tid;
+       __le16 seq_ctl;
+       __le64 bitmap;
+       __le16 scd_flow;
+       __le16 scd_ssn;
+} __packed;
+
+/*
+ * C_TX_PWR_TBL = 0x97 (command, has simple generic response)
+ *
+ * See details under "TXPOWER" in 4965.h.
+ */
+
+struct il3945_txpowertable_cmd {
+       u8 band;                /* 0: 5 GHz, 1: 2.4 GHz */
+       u8 reserved;
+       __le16 channel;
+       struct il3945_power_per_rate power[IL_MAX_RATES];
+} __packed;
+
+struct il4965_txpowertable_cmd {
+       u8 band;                /* 0: 5 GHz, 1: 2.4 GHz */
+       u8 reserved;
+       __le16 channel;
+       struct il4965_tx_power_db tx_power;
+} __packed;
+
+/**
+ * struct il3945_rate_scaling_cmd - Rate Scaling Command & Response
+ *
+ * C_RATE_SCALE = 0x47 (command, has simple generic response)
+ *
+ * NOTE: The table of rates passed to the uCode via the
+ * RATE_SCALE command sets up the corresponding order of
+ * rates used for all related commands, including rate
+ * masks, etc.
+ *
+ * For example, if you set 9MB (PLCP 0x0f) as the first
+ * rate in the rate table, the bit mask for that rate
+ * when passed through ofdm_basic_rates on the C_RXON
+ * command would be bit 0 (1 << 0)
+ */
+struct il3945_rate_scaling_info {
+       __le16 rate_n_flags;
+       u8 try_cnt;
+       u8 next_rate_idx;
+} __packed;
+
+struct il3945_rate_scaling_cmd {
+       u8 table_id;
+       u8 reserved[3];
+       struct il3945_rate_scaling_info table[IL_MAX_RATES];
+} __packed;
+
+/*RS_NEW_API: only TLC_RTS remains and moved to bit 0 */
+#define  LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK   (1 << 0)
+
+/* # of EDCA prioritized tx fifos */
+#define  LINK_QUAL_AC_NUM AC_NUM
+
+/* # entries in rate scale table to support Tx retries */
+#define  LINK_QUAL_MAX_RETRY_NUM 16
+
+/* Tx antenna selection values */
+#define  LINK_QUAL_ANT_A_MSK (1 << 0)
+#define  LINK_QUAL_ANT_B_MSK (1 << 1)
+#define  LINK_QUAL_ANT_MSK   (LINK_QUAL_ANT_A_MSK|LINK_QUAL_ANT_B_MSK)
+
+/**
+ * struct il_link_qual_general_params
+ *
+ * Used in C_TX_LINK_QUALITY_CMD
+ */
+struct il_link_qual_general_params {
+       u8 flags;
+
+       /* No entries at or above this (driver chosen) idx contain MIMO */
+       u8 mimo_delimiter;
+
+       /* Best single antenna to use for single stream (legacy, SISO). */
+       u8 single_stream_ant_msk;       /* LINK_QUAL_ANT_* */
+
+       /* Best antennas to use for MIMO (unused for 4965, assumes both). */
+       u8 dual_stream_ant_msk; /* LINK_QUAL_ANT_* */
+
+       /*
+        * If driver needs to use different initial rates for different
+        * EDCA QOS access categories (as implemented by tx fifos 0-3),
+        * this table will set that up, by indicating the idxes in the
+        * rs_table[LINK_QUAL_MAX_RETRY_NUM] rate table at which to start.
+        * Otherwise, driver should set all entries to 0.
+        *
+        * Entry usage:
+        * 0 = Background, 1 = Best Effort (normal), 2 = Video, 3 = Voice
+        * TX FIFOs above 3 use same value (typically 0) as TX FIFO 3.
+        */
+       u8 start_rate_idx[LINK_QUAL_AC_NUM];
+} __packed;
+
+#define LINK_QUAL_AGG_TIME_LIMIT_DEF   (4000)  /* 4 milliseconds */
+#define LINK_QUAL_AGG_TIME_LIMIT_MAX   (8000)
+#define LINK_QUAL_AGG_TIME_LIMIT_MIN   (100)
+
+#define LINK_QUAL_AGG_DISABLE_START_DEF        (3)
+#define LINK_QUAL_AGG_DISABLE_START_MAX        (255)
+#define LINK_QUAL_AGG_DISABLE_START_MIN        (0)
+
+#define LINK_QUAL_AGG_FRAME_LIMIT_DEF  (31)
+#define LINK_QUAL_AGG_FRAME_LIMIT_MAX  (63)
+#define LINK_QUAL_AGG_FRAME_LIMIT_MIN  (0)
+
+/**
+ * struct il_link_qual_agg_params
+ *
+ * Used in C_TX_LINK_QUALITY_CMD
+ */
+struct il_link_qual_agg_params {
+
+       /*
+        *Maximum number of uSec in aggregation.
+        * default set to 4000 (4 milliseconds) if not configured in .cfg
+        */
+       __le16 agg_time_limit;
+
+       /*
+        * Number of Tx retries allowed for a frame, before that frame will
+        * no longer be considered for the start of an aggregation sequence
+        * (scheduler will then try to tx it as single frame).
+        * Driver should set this to 3.
+        */
+       u8 agg_dis_start_th;
+
+       /*
+        * Maximum number of frames in aggregation.
+        * 0 = no limit (default).  1 = no aggregation.
+        * Other values = max # frames in aggregation.
+        */
+       u8 agg_frame_cnt_limit;
+
+       __le32 reserved;
+} __packed;
+
+/*
+ * C_TX_LINK_QUALITY_CMD = 0x4e (command, has simple generic response)
+ *
+ * For 4965 devices only; 3945 uses C_RATE_SCALE.
+ *
+ * Each station in the 4965 device's internal station table has its own table
+ * of 16
+ * Tx rates and modulation modes (e.g. legacy/SISO/MIMO) for retrying Tx when
+ * an ACK is not received.  This command replaces the entire table for
+ * one station.
+ *
+ * NOTE:  Station must already be in 4965 device's station table.
+ *       Use C_ADD_STA.
+ *
+ * The rate scaling procedures described below work well.  Of course, other
+ * procedures are possible, and may work better for particular environments.
+ *
+ *
+ * FILLING THE RATE TBL
+ *
+ * Given a particular initial rate and mode, as determined by the rate
+ * scaling algorithm described below, the Linux driver uses the following
+ * formula to fill the rs_table[LINK_QUAL_MAX_RETRY_NUM] rate table in the
+ * Link Quality command:
+ *
+ *
+ * 1)  If using High-throughput (HT) (SISO or MIMO) initial rate:
+ *     a) Use this same initial rate for first 3 entries.
+ *     b) Find next lower available rate using same mode (SISO or MIMO),
+ *        use for next 3 entries.  If no lower rate available, switch to
+ *        legacy mode (no HT40 channel, no MIMO, no short guard interval).
+ *     c) If using MIMO, set command's mimo_delimiter to number of entries
+ *        using MIMO (3 or 6).
+ *     d) After trying 2 HT rates, switch to legacy mode (no HT40 channel,
+ *        no MIMO, no short guard interval), at the next lower bit rate
+ *        (e.g. if second HT bit rate was 54, try 48 legacy), and follow
+ *        legacy procedure for remaining table entries.
+ *
+ * 2)  If using legacy initial rate:
+ *     a) Use the initial rate for only one entry.
+ *     b) For each following entry, reduce the rate to next lower available
+ *        rate, until reaching the lowest available rate.
+ *     c) When reducing rate, also switch antenna selection.
+ *     d) Once lowest available rate is reached, repeat this rate until
+ *        rate table is filled (16 entries), switching antenna each entry.
+ *
+ *
+ * ACCUMULATING HISTORY
+ *
+ * The rate scaling algorithm for 4965 devices, as implemented in Linux driver,
+ * uses two sets of frame Tx success history:  One for the current/active
+ * modulation mode, and one for a speculative/search mode that is being
+ * attempted. If the speculative mode turns out to be more effective (i.e.
+ * actual transfer rate is better), then the driver continues to use the
+ * speculative mode as the new current active mode.
+ *
+ * Each history set contains, separately for each possible rate, data for a
+ * sliding win of the 62 most recent tx attempts at that rate.  The data
+ * includes a shifting bitmap of success(1)/failure(0), and sums of successful
+ * and attempted frames, from which the driver can additionally calculate a
+ * success ratio (success / attempted) and number of failures
+ * (attempted - success), and control the size of the win (attempted).
+ * The driver uses the bit map to remove successes from the success sum, as
+ * the oldest tx attempts fall out of the win.
+ *
+ * When the 4965 device makes multiple tx attempts for a given frame, each
+ * attempt might be at a different rate, and have different modulation
+ * characteristics (e.g. antenna, fat channel, short guard interval), as set
+ * up in the rate scaling table in the Link Quality command.  The driver must
+ * determine which rate table entry was used for each tx attempt, to determine
+ * which rate-specific history to update, and record only those attempts that
+ * match the modulation characteristics of the history set.
+ *
+ * When using block-ack (aggregation), all frames are transmitted at the same
+ * rate, since there is no per-attempt acknowledgment from the destination
+ * station.  The Tx response struct il_tx_resp indicates the Tx rate in
+ * rate_n_flags field.  After receiving a block-ack, the driver can update
+ * history for the entire block all at once.
+ *
+ *
+ * FINDING BEST STARTING RATE:
+ *
+ * When working with a selected initial modulation mode (see below), the
+ * driver attempts to find a best initial rate.  The initial rate is the
+ * first entry in the Link Quality command's rate table.
+ *
+ * 1)  Calculate actual throughput (success ratio * expected throughput, see
+ *     table below) for current initial rate.  Do this only if enough frames
+ *     have been attempted to make the value meaningful:  at least 6 failed
+ *     tx attempts, or at least 8 successes.  If not enough, don't try rate
+ *     scaling yet.
+ *
+ * 2)  Find available rates adjacent to current initial rate.  Available means:
+ *     a)  supported by hardware &&
+ *     b)  supported by association &&
+ *     c)  within any constraints selected by user
+ *
+ * 3)  Gather measured throughputs for adjacent rates.  These might not have
+ *     enough history to calculate a throughput.  That's okay, we might try
+ *     using one of them anyway!
+ *
+ * 4)  Try decreasing rate if, for current rate:
+ *     a)  success ratio is < 15% ||
+ *     b)  lower adjacent rate has better measured throughput ||
+ *     c)  higher adjacent rate has worse throughput, and lower is unmeasured
+ *
+ *     As a sanity check, if decrease was determined above, leave rate
+ *     unchanged if:
+ *     a)  lower rate unavailable
+ *     b)  success ratio at current rate > 85% (very good)
+ *     c)  current measured throughput is better than expected throughput
+ *         of lower rate (under perfect 100% tx conditions, see table below)
+ *
+ * 5)  Try increasing rate if, for current rate:
+ *     a)  success ratio is < 15% ||
+ *     b)  both adjacent rates' throughputs are unmeasured (try it!) ||
+ *     b)  higher adjacent rate has better measured throughput ||
+ *     c)  lower adjacent rate has worse throughput, and higher is unmeasured
+ *
+ *     As a sanity check, if increase was determined above, leave rate
+ *     unchanged if:
+ *     a)  success ratio at current rate < 70%.  This is not particularly
+ *         good performance; higher rate is sure to have poorer success.
+ *
+ * 6)  Re-evaluate the rate after each tx frame.  If working with block-
+ *     acknowledge, history and stats may be calculated for the entire
+ *     block (including prior history that fits within the history wins),
+ *     before re-evaluation.
+ *
+ * FINDING BEST STARTING MODULATION MODE:
+ *
+ * After working with a modulation mode for a "while" (and doing rate scaling),
+ * the driver searches for a new initial mode in an attempt to improve
+ * throughput.  The "while" is measured by numbers of attempted frames:
+ *
+ * For legacy mode, search for new mode after:
+ *   480 successful frames, or 160 failed frames
+ * For high-throughput modes (SISO or MIMO), search for new mode after:
+ *   4500 successful frames, or 400 failed frames
+ *
+ * Mode switch possibilities are (3 for each mode):
+ *
+ * For legacy:
+ *   Change antenna, try SISO (if HT association), try MIMO (if HT association)
+ * For SISO:
+ *   Change antenna, try MIMO, try shortened guard interval (SGI)
+ * For MIMO:
+ *   Try SISO antenna A, SISO antenna B, try shortened guard interval (SGI)
+ *
+ * When trying a new mode, use the same bit rate as the old/current mode when
+ * trying antenna switches and shortened guard interval.  When switching to
+ * SISO from MIMO or legacy, or to MIMO from SISO or legacy, use a rate
+ * for which the expected throughput (under perfect conditions) is about the
+ * same or slightly better than the actual measured throughput delivered by
+ * the old/current mode.
+ *
+ * Actual throughput can be estimated by multiplying the expected throughput
+ * by the success ratio (successful / attempted tx frames).  Frame size is
+ * not considered in this calculation; it assumes that frame size will average
+ * out to be fairly consistent over several samples.  The following are
+ * metric values for expected throughput assuming 100% success ratio.
+ * Only G band has support for CCK rates:
+ *
+ *           RATE:  1    2    5   11    6   9   12   18   24   36   48   54   60
+ *
+ *              G:  7   13   35   58   40  57   72   98  121  154  177  186  186
+ *              A:  0    0    0    0   40  57   72   98  121  154  177  186  186
+ *     SISO 20MHz:  0    0    0    0   42  42   76  102  124  159  183  193  202
+ * SGI SISO 20MHz:  0    0    0    0   46  46   82  110  132  168  192  202  211
+ *     MIMO 20MHz:  0    0    0    0   74  74  123  155  179  214  236  244  251
+ * SGI MIMO 20MHz:  0    0    0    0   81  81  131  164  188  222  243  251  257
+ *     SISO 40MHz:  0    0    0    0   77  77  127  160  184  220  242  250  257
+ * SGI SISO 40MHz:  0    0    0    0   83  83  135  169  193  229  250  257  264
+ *     MIMO 40MHz:  0    0    0    0  123 123  182  214  235  264  279  285  289
+ * SGI MIMO 40MHz:  0    0    0    0  131 131  191  222  242  270  284  289  293
+ *
+ * After the new mode has been tried for a short while (minimum of 6 failed
+ * frames or 8 successful frames), compare success ratio and actual throughput
+ * estimate of the new mode with the old.  If either is better with the new
+ * mode, continue to use the new mode.
+ *
+ * Continue comparing modes until all 3 possibilities have been tried.
+ * If moving from legacy to HT, try all 3 possibilities from the new HT
+ * mode.  After trying all 3, a best mode is found.  Continue to use this mode
+ * for the longer "while" described above (e.g. 480 successful frames for
+ * legacy), and then repeat the search process.
+ *
+ */
+struct il_link_quality_cmd {
+
+       /* Index of destination/recipient station in uCode's station table */
+       u8 sta_id;
+       u8 reserved1;
+       __le16 control;         /* not used */
+       struct il_link_qual_general_params general_params;
+       struct il_link_qual_agg_params agg_params;
+
+       /*
+        * Rate info; when using rate-scaling, Tx command's initial_rate_idx
+        * specifies 1st Tx rate attempted, via idx into this table.
+        * 4965 devices works its way through table when retrying Tx.
+        */
+       struct {
+               __le32 rate_n_flags;    /* RATE_MCS_*, RATE_* */
+       } rs_table[LINK_QUAL_MAX_RETRY_NUM];
+       __le32 reserved2;
+} __packed;
+
+/*
+ * BT configuration enable flags:
+ *   bit 0 - 1: BT channel announcement enabled
+ *           0: disable
+ *   bit 1 - 1: priority of BT device enabled
+ *           0: disable
+ */
+#define BT_COEX_DISABLE (0x0)
+#define BT_ENABLE_CHANNEL_ANNOUNCE BIT(0)
+#define BT_ENABLE_PRIORITY        BIT(1)
+
+#define BT_COEX_ENABLE  (BT_ENABLE_CHANNEL_ANNOUNCE | BT_ENABLE_PRIORITY)
+
+#define BT_LEAD_TIME_DEF (0x1E)
+
+#define BT_MAX_KILL_DEF (0x5)
+
+/*
+ * C_BT_CONFIG = 0x9b (command, has simple generic response)
+ *
+ * 3945 and 4965 devices support hardware handshake with Bluetooth device on
+ * same platform.  Bluetooth device alerts wireless device when it will Tx;
+ * wireless device can delay or kill its own Tx to accommodate.
+ */
+struct il_bt_cmd {
+       u8 flags;
+       u8 lead_time;
+       u8 max_kill;
+       u8 reserved;
+       __le32 kill_ack_mask;
+       __le32 kill_cts_mask;
+} __packed;
+
+/******************************************************************************
+ * (6)
+ * Spectrum Management (802.11h) Commands, Responses, Notifications:
+ *
+ *****************************************************************************/
+
+/*
+ * Spectrum Management
+ */
+#define MEASUREMENT_FILTER_FLAG (RXON_FILTER_PROMISC_MSK         | \
+                                RXON_FILTER_CTL2HOST_MSK        | \
+                                RXON_FILTER_ACCEPT_GRP_MSK      | \
+                                RXON_FILTER_DIS_DECRYPT_MSK     | \
+                                RXON_FILTER_DIS_GRP_DECRYPT_MSK | \
+                                RXON_FILTER_ASSOC_MSK           | \
+                                RXON_FILTER_BCON_AWARE_MSK)
+
+struct il_measure_channel {
+       __le32 duration;        /* measurement duration in extended beacon
+                                * format */
+       u8 channel;             /* channel to measure */
+       u8 type;                /* see enum il_measure_type */
+       __le16 reserved;
+} __packed;
+
+/*
+ * C_SPECTRUM_MEASUREMENT = 0x74 (command)
+ */
+struct il_spectrum_cmd {
+       __le16 len;             /* number of bytes starting from token */
+       u8 token;               /* token id */
+       u8 id;                  /* measurement id -- 0 or 1 */
+       u8 origin;              /* 0 = TGh, 1 = other, 2 = TGk */
+       u8 periodic;            /* 1 = periodic */
+       __le16 path_loss_timeout;
+       __le32 start_time;      /* start time in extended beacon format */
+       __le32 reserved2;
+       __le32 flags;           /* rxon flags */
+       __le32 filter_flags;    /* rxon filter flags */
+       __le16 channel_count;   /* minimum 1, maximum 10 */
+       __le16 reserved3;
+       struct il_measure_channel channels[10];
+} __packed;
+
+/*
+ * C_SPECTRUM_MEASUREMENT = 0x74 (response)
+ */
+struct il_spectrum_resp {
+       u8 token;
+       u8 id;                  /* id of the prior command replaced, or 0xff */
+       __le16 status;          /* 0 - command will be handled
+                                * 1 - cannot handle (conflicts with another
+                                *     measurement) */
+} __packed;
+
+enum il_measurement_state {
+       IL_MEASUREMENT_START = 0,
+       IL_MEASUREMENT_STOP = 1,
+};
+
+enum il_measurement_status {
+       IL_MEASUREMENT_OK = 0,
+       IL_MEASUREMENT_CONCURRENT = 1,
+       IL_MEASUREMENT_CSA_CONFLICT = 2,
+       IL_MEASUREMENT_TGH_CONFLICT = 3,
+       /* 4-5 reserved */
+       IL_MEASUREMENT_STOPPED = 6,
+       IL_MEASUREMENT_TIMEOUT = 7,
+       IL_MEASUREMENT_PERIODIC_FAILED = 8,
+};
+
+#define NUM_ELEMENTS_IN_HISTOGRAM 8
+
+struct il_measurement_histogram {
+       __le32 ofdm[NUM_ELEMENTS_IN_HISTOGRAM]; /* in 0.8usec counts */
+       __le32 cck[NUM_ELEMENTS_IN_HISTOGRAM];  /* in 1usec counts */
+} __packed;
+
+/* clear channel availability counters */
+struct il_measurement_cca_counters {
+       __le32 ofdm;
+       __le32 cck;
+} __packed;
+
+enum il_measure_type {
+       IL_MEASURE_BASIC = (1 << 0),
+       IL_MEASURE_CHANNEL_LOAD = (1 << 1),
+       IL_MEASURE_HISTOGRAM_RPI = (1 << 2),
+       IL_MEASURE_HISTOGRAM_NOISE = (1 << 3),
+       IL_MEASURE_FRAME = (1 << 4),
+       /* bits 5:6 are reserved */
+       IL_MEASURE_IDLE = (1 << 7),
+};
+
+/*
+ * N_SPECTRUM_MEASUREMENT = 0x75 (notification only, not a command)
+ */
+struct il_spectrum_notification {
+       u8 id;                  /* measurement id -- 0 or 1 */
+       u8 token;
+       u8 channel_idx;         /* idx in measurement channel list */
+       u8 state;               /* 0 - start, 1 - stop */
+       __le32 start_time;      /* lower 32-bits of TSF */
+       u8 band;                /* 0 - 5.2GHz, 1 - 2.4GHz */
+       u8 channel;
+       u8 type;                /* see enum il_measurement_type */
+       u8 reserved1;
+       /* NOTE:  cca_ofdm, cca_cck, basic_type, and histogram are only only
+        * valid if applicable for measurement type requested. */
+       __le32 cca_ofdm;        /* cca fraction time in 40Mhz clock periods */
+       __le32 cca_cck;         /* cca fraction time in 44Mhz clock periods */
+       __le32 cca_time;        /* channel load time in usecs */
+       u8 basic_type;          /* 0 - bss, 1 - ofdm preamble, 2 -
+                                * unidentified */
+       u8 reserved2[3];
+       struct il_measurement_histogram histogram;
+       __le32 stop_time;       /* lower 32-bits of TSF */
+       __le32 status;          /* see il_measurement_status */
+} __packed;
+
+/******************************************************************************
+ * (7)
+ * Power Management Commands, Responses, Notifications:
+ *
+ *****************************************************************************/
+
+/**
+ * struct il_powertable_cmd - Power Table Command
+ * @flags: See below:
+ *
+ * C_POWER_TBL = 0x77 (command, has simple generic response)
+ *
+ * PM allow:
+ *   bit 0 - '0' Driver not allow power management
+ *           '1' Driver allow PM (use rest of parameters)
+ *
+ * uCode send sleep notifications:
+ *   bit 1 - '0' Don't send sleep notification
+ *           '1' send sleep notification (SEND_PM_NOTIFICATION)
+ *
+ * Sleep over DTIM
+ *   bit 2 - '0' PM have to walk up every DTIM
+ *           '1' PM could sleep over DTIM till listen Interval.
+ *
+ * PCI power managed
+ *   bit 3 - '0' (PCI_CFG_LINK_CTRL & 0x1)
+ *           '1' !(PCI_CFG_LINK_CTRL & 0x1)
+ *
+ * Fast PD
+ *   bit 4 - '1' Put radio to sleep when receiving frame for others
+ *
+ * Force sleep Modes
+ *   bit 31/30- '00' use both mac/xtal sleeps
+ *              '01' force Mac sleep
+ *              '10' force xtal sleep
+ *              '11' Illegal set
+ *
+ * NOTE: if sleep_interval[SLEEP_INTRVL_TBL_SIZE-1] > DTIM period then
+ * ucode assume sleep over DTIM is allowed and we don't need to wake up
+ * for every DTIM.
+ */
+#define IL_POWER_VEC_SIZE 5
+
+#define IL_POWER_DRIVER_ALLOW_SLEEP_MSK                cpu_to_le16(BIT(0))
+#define IL_POWER_SLEEP_OVER_DTIM_MSK           cpu_to_le16(BIT(2))
+#define IL_POWER_PCI_PM_MSK                    cpu_to_le16(BIT(3))
+
+struct il3945_powertable_cmd {
+       __le16 flags;
+       u8 reserved[2];
+       __le32 rx_data_timeout;
+       __le32 tx_data_timeout;
+       __le32 sleep_interval[IL_POWER_VEC_SIZE];
+} __packed;
+
+struct il_powertable_cmd {
+       __le16 flags;
+       u8 keep_alive_seconds;  /* 3945 reserved */
+       u8 debug_flags;         /* 3945 reserved */
+       __le32 rx_data_timeout;
+       __le32 tx_data_timeout;
+       __le32 sleep_interval[IL_POWER_VEC_SIZE];
+       __le32 keep_alive_beacons;
+} __packed;
+
+/*
+ * N_PM_SLEEP = 0x7A (notification only, not a command)
+ * all devices identical.
+ */
+struct il_sleep_notification {
+       u8 pm_sleep_mode;
+       u8 pm_wakeup_src;
+       __le16 reserved;
+       __le32 sleep_time;
+       __le32 tsf_low;
+       __le32 bcon_timer;
+} __packed;
+
+/* Sleep states.  all devices identical. */
+enum {
+       IL_PM_NO_SLEEP = 0,
+       IL_PM_SLP_MAC = 1,
+       IL_PM_SLP_FULL_MAC_UNASSOCIATE = 2,
+       IL_PM_SLP_FULL_MAC_CARD_STATE = 3,
+       IL_PM_SLP_PHY = 4,
+       IL_PM_SLP_REPENT = 5,
+       IL_PM_WAKEUP_BY_TIMER = 6,
+       IL_PM_WAKEUP_BY_DRIVER = 7,
+       IL_PM_WAKEUP_BY_RFKILL = 8,
+       /* 3 reserved */
+       IL_PM_NUM_OF_MODES = 12,
+};
+
+/*
+ * N_CARD_STATE = 0xa1 (notification only, not a command)
+ */
+struct il_card_state_notif {
+       __le32 flags;
+} __packed;
+
+#define HW_CARD_DISABLED   0x01
+#define SW_CARD_DISABLED   0x02
+#define CT_CARD_DISABLED   0x04
+#define RXON_CARD_DISABLED 0x10
+
+struct il_ct_kill_config {
+       __le32 reserved;
+       __le32 critical_temperature_M;
+       __le32 critical_temperature_R;
+} __packed;
+
+/******************************************************************************
+ * (8)
+ * Scan Commands, Responses, Notifications:
+ *
+ *****************************************************************************/
+
+#define SCAN_CHANNEL_TYPE_PASSIVE cpu_to_le32(0)
+#define SCAN_CHANNEL_TYPE_ACTIVE  cpu_to_le32(1)
+
+/**
+ * struct il_scan_channel - entry in C_SCAN channel table
+ *
+ * One for each channel in the scan list.
+ * Each channel can independently select:
+ * 1)  SSID for directed active scans
+ * 2)  Txpower setting (for rate specified within Tx command)
+ * 3)  How long to stay on-channel (behavior may be modified by quiet_time,
+ *     quiet_plcp_th, good_CRC_th)
+ *
+ * To avoid uCode errors, make sure the following are true (see comments
+ * under struct il_scan_cmd about max_out_time and quiet_time):
+ * 1)  If using passive_dwell (i.e. passive_dwell != 0):
+ *     active_dwell <= passive_dwell (< max_out_time if max_out_time != 0)
+ * 2)  quiet_time <= active_dwell
+ * 3)  If restricting off-channel time (i.e. max_out_time !=0):
+ *     passive_dwell < max_out_time
+ *     active_dwell < max_out_time
+ */
+struct il3945_scan_channel {
+       /*
+        * type is defined as:
+        * 0:0 1 = active, 0 = passive
+        * 1:4 SSID direct bit map; if a bit is set, then corresponding
+        *     SSID IE is transmitted in probe request.
+        * 5:7 reserved
+        */
+       u8 type;
+       u8 channel;             /* band is selected by il3945_scan_cmd "flags" field */
+       struct il3945_tx_power tpc;
+       __le16 active_dwell;    /* in 1024-uSec TU (time units), typ 5-50 */
+       __le16 passive_dwell;   /* in 1024-uSec TU (time units), typ 20-500 */
+} __packed;
+
+/* set number of direct probes u8 type */
+#define IL39_SCAN_PROBE_MASK(n) ((BIT(n) | (BIT(n) - BIT(1))))
+
+struct il_scan_channel {
+       /*
+        * type is defined as:
+        * 0:0 1 = active, 0 = passive
+        * 1:20 SSID direct bit map; if a bit is set, then corresponding
+        *     SSID IE is transmitted in probe request.
+        * 21:31 reserved
+        */
+       __le32 type;
+       __le16 channel;         /* band is selected by il_scan_cmd "flags" field */
+       u8 tx_gain;             /* gain for analog radio */
+       u8 dsp_atten;           /* gain for DSP */
+       __le16 active_dwell;    /* in 1024-uSec TU (time units), typ 5-50 */
+       __le16 passive_dwell;   /* in 1024-uSec TU (time units), typ 20-500 */
+} __packed;
+
+/* set number of direct probes __le32 type */
+#define IL_SCAN_PROBE_MASK(n)  cpu_to_le32((BIT(n) | (BIT(n) - BIT(1))))
+
+/**
+ * struct il_ssid_ie - directed scan network information element
+ *
+ * Up to 20 of these may appear in C_SCAN (Note: Only 4 are in
+ * 3945 SCAN api), selected by "type" bit field in struct il_scan_channel;
+ * each channel may select different ssids from among the 20 (4) entries.
+ * SSID IEs get transmitted in reverse order of entry.
+ */
+struct il_ssid_ie {
+       u8 id;
+       u8 len;
+       u8 ssid[32];
+} __packed;
+
+#define PROBE_OPTION_MAX_3945          4
+#define PROBE_OPTION_MAX               20
+#define TX_CMD_LIFE_TIME_INFINITE      cpu_to_le32(0xFFFFFFFF)
+#define IL_GOOD_CRC_TH_DISABLED        0
+#define IL_GOOD_CRC_TH_DEFAULT         cpu_to_le16(1)
+#define IL_GOOD_CRC_TH_NEVER           cpu_to_le16(0xffff)
+#define IL_MAX_SCAN_SIZE 1024
+#define IL_MAX_CMD_SIZE 4096
+
+/*
+ * C_SCAN = 0x80 (command)
+ *
+ * The hardware scan command is very powerful; the driver can set it up to
+ * maintain (relatively) normal network traffic while doing a scan in the
+ * background.  The max_out_time and suspend_time control the ratio of how
+ * long the device stays on an associated network channel ("service channel")
+ * vs. how long it's away from the service channel, i.e. tuned to other channels
+ * for scanning.
+ *
+ * max_out_time is the max time off-channel (in usec), and suspend_time
+ * is how long (in "extended beacon" format) that the scan is "suspended"
+ * after returning to the service channel.  That is, suspend_time is the
+ * time that we stay on the service channel, doing normal work, between
+ * scan segments.  The driver may set these parameters differently to support
+ * scanning when associated vs. not associated, and light vs. heavy traffic
+ * loads when associated.
+ *
+ * After receiving this command, the device's scan engine does the following;
+ *
+ * 1)  Sends SCAN_START notification to driver
+ * 2)  Checks to see if it has time to do scan for one channel
+ * 3)  Sends NULL packet, with power-save (PS) bit set to 1,
+ *     to tell AP that we're going off-channel
+ * 4)  Tunes to first channel in scan list, does active or passive scan
+ * 5)  Sends SCAN_RESULT notification to driver
+ * 6)  Checks to see if it has time to do scan on *next* channel in list
+ * 7)  Repeats 4-6 until it no longer has time to scan the next channel
+ *     before max_out_time expires
+ * 8)  Returns to service channel
+ * 9)  Sends NULL packet with PS=0 to tell AP that we're back
+ * 10) Stays on service channel until suspend_time expires
+ * 11) Repeats entire process 2-10 until list is complete
+ * 12) Sends SCAN_COMPLETE notification
+ *
+ * For fast, efficient scans, the scan command also has support for staying on
+ * a channel for just a short time, if doing active scanning and getting no
+ * responses to the transmitted probe request.  This time is controlled by
+ * quiet_time, and the number of received packets below which a channel is
+ * considered "quiet" is controlled by quiet_plcp_threshold.
+ *
+ * For active scanning on channels that have regulatory restrictions against
+ * blindly transmitting, the scan can listen before transmitting, to make sure
+ * that there is already legitimate activity on the channel.  If enough
+ * packets are cleanly received on the channel (controlled by good_CRC_th,
+ * typical value 1), the scan engine starts transmitting probe requests.
+ *
+ * Driver must use separate scan commands for 2.4 vs. 5 GHz bands.
+ *
+ * To avoid uCode errors, see timing restrictions described under
+ * struct il_scan_channel.
+ */
+
+struct il3945_scan_cmd {
+       __le16 len;
+       u8 reserved0;
+       u8 channel_count;       /* # channels in channel list */
+       __le16 quiet_time;      /* dwell only this # millisecs on quiet channel
+                                * (only for active scan) */
+       __le16 quiet_plcp_th;   /* quiet chnl is < this # pkts (typ. 1) */
+       __le16 good_CRC_th;     /* passive -> active promotion threshold */
+       __le16 reserved1;
+       __le32 max_out_time;    /* max usec to be away from associated (service)
+                                * channel */
+       __le32 suspend_time;    /* pause scan this long (in "extended beacon
+                                * format") when returning to service channel:
+                                * 3945; 31:24 # beacons, 19:0 additional usec,
+                                * 4965; 31:22 # beacons, 21:0 additional usec.
+                                */
+       __le32 flags;           /* RXON_FLG_* */
+       __le32 filter_flags;    /* RXON_FILTER_* */
+
+       /* For active scans (set to all-0s for passive scans).
+        * Does not include payload.  Must specify Tx rate; no rate scaling. */
+       struct il3945_tx_cmd tx_cmd;
+
+       /* For directed active scans (set to all-0s otherwise) */
+       struct il_ssid_ie direct_scan[PROBE_OPTION_MAX_3945];
+
+       /*
+        * Probe request frame, followed by channel list.
+        *
+        * Size of probe request frame is specified by byte count in tx_cmd.
+        * Channel list follows immediately after probe request frame.
+        * Number of channels in list is specified by channel_count.
+        * Each channel in list is of type:
+        *
+        * struct il3945_scan_channel channels[0];
+        *
+        * NOTE:  Only one band of channels can be scanned per pass.  You
+        * must not mix 2.4GHz channels and 5.2GHz channels, and you must wait
+        * for one scan to complete (i.e. receive N_SCAN_COMPLETE)
+        * before requesting another scan.
+        */
+       u8 data[0];
+} __packed;
+
+struct il_scan_cmd {
+       __le16 len;
+       u8 reserved0;
+       u8 channel_count;       /* # channels in channel list */
+       __le16 quiet_time;      /* dwell only this # millisecs on quiet channel
+                                * (only for active scan) */
+       __le16 quiet_plcp_th;   /* quiet chnl is < this # pkts (typ. 1) */
+       __le16 good_CRC_th;     /* passive -> active promotion threshold */
+       __le16 rx_chain;        /* RXON_RX_CHAIN_* */
+       __le32 max_out_time;    /* max usec to be away from associated (service)
+                                * channel */
+       __le32 suspend_time;    /* pause scan this long (in "extended beacon
+                                * format") when returning to service chnl:
+                                * 3945; 31:24 # beacons, 19:0 additional usec,
+                                * 4965; 31:22 # beacons, 21:0 additional usec.
+                                */
+       __le32 flags;           /* RXON_FLG_* */
+       __le32 filter_flags;    /* RXON_FILTER_* */
+
+       /* For active scans (set to all-0s for passive scans).
+        * Does not include payload.  Must specify Tx rate; no rate scaling. */
+       struct il_tx_cmd tx_cmd;
+
+       /* For directed active scans (set to all-0s otherwise) */
+       struct il_ssid_ie direct_scan[PROBE_OPTION_MAX];
+
+       /*
+        * Probe request frame, followed by channel list.
+        *
+        * Size of probe request frame is specified by byte count in tx_cmd.
+        * Channel list follows immediately after probe request frame.
+        * Number of channels in list is specified by channel_count.
+        * Each channel in list is of type:
+        *
+        * struct il_scan_channel channels[0];
+        *
+        * NOTE:  Only one band of channels can be scanned per pass.  You
+        * must not mix 2.4GHz channels and 5.2GHz channels, and you must wait
+        * for one scan to complete (i.e. receive N_SCAN_COMPLETE)
+        * before requesting another scan.
+        */
+       u8 data[0];
+} __packed;
+
+/* Can abort will notify by complete notification with abort status. */
+#define CAN_ABORT_STATUS       cpu_to_le32(0x1)
+/* complete notification statuses */
+#define ABORT_STATUS            0x2
+
+/*
+ * C_SCAN = 0x80 (response)
+ */
+struct il_scanreq_notification {
+       __le32 status;          /* 1: okay, 2: cannot fulfill request */
+} __packed;
+
+/*
+ * N_SCAN_START = 0x82 (notification only, not a command)
+ */
+struct il_scanstart_notification {
+       __le32 tsf_low;
+       __le32 tsf_high;
+       __le32 beacon_timer;
+       u8 channel;
+       u8 band;
+       u8 reserved[2];
+       __le32 status;
+} __packed;
+
+#define  SCAN_OWNER_STATUS 0x1
+#define  MEASURE_OWNER_STATUS 0x2
+
+#define IL_PROBE_STATUS_OK             0
+#define IL_PROBE_STATUS_TX_FAILED      BIT(0)
+/* error statuses combined with TX_FAILED */
+#define IL_PROBE_STATUS_FAIL_TTL       BIT(1)
+#define IL_PROBE_STATUS_FAIL_BT        BIT(2)
+
+#define NUMBER_OF_STATS 1      /* first __le32 is good CRC */
+/*
+ * N_SCAN_RESULTS = 0x83 (notification only, not a command)
+ */
+struct il_scanresults_notification {
+       u8 channel;
+       u8 band;
+       u8 probe_status;
+       u8 num_probe_not_sent;  /* not enough time to send */
+       __le32 tsf_low;
+       __le32 tsf_high;
+       __le32 stats[NUMBER_OF_STATS];
+} __packed;
+
+/*
+ * N_SCAN_COMPLETE = 0x84 (notification only, not a command)
+ */
+struct il_scancomplete_notification {
+       u8 scanned_channels;
+       u8 status;
+       u8 last_channel;
+       __le32 tsf_low;
+       __le32 tsf_high;
+} __packed;
+
+/******************************************************************************
+ * (9)
+ * IBSS/AP Commands and Notifications:
+ *
+ *****************************************************************************/
+
+enum il_ibss_manager {
+       IL_NOT_IBSS_MANAGER = 0,
+       IL_IBSS_MANAGER = 1,
+};
+
+/*
+ * N_BEACON = 0x90 (notification only, not a command)
+ */
+
+struct il3945_beacon_notif {
+       struct il3945_tx_resp beacon_notify_hdr;
+       __le32 low_tsf;
+       __le32 high_tsf;
+       __le32 ibss_mgr_status;
+} __packed;
+
+struct il4965_beacon_notif {
+       struct il4965_tx_resp beacon_notify_hdr;
+       __le32 low_tsf;
+       __le32 high_tsf;
+       __le32 ibss_mgr_status;
+} __packed;
+
+/*
+ * C_TX_BEACON= 0x91 (command, has simple generic response)
+ */
+
+struct il3945_tx_beacon_cmd {
+       struct il3945_tx_cmd tx;
+       __le16 tim_idx;
+       u8 tim_size;
+       u8 reserved1;
+       struct ieee80211_hdr frame[0];  /* beacon frame */
+} __packed;
+
+struct il_tx_beacon_cmd {
+       struct il_tx_cmd tx;
+       __le16 tim_idx;
+       u8 tim_size;
+       u8 reserved1;
+       struct ieee80211_hdr frame[0];  /* beacon frame */
+} __packed;
+
+/******************************************************************************
+ * (10)
+ * Statistics Commands and Notifications:
+ *
+ *****************************************************************************/
+
+#define IL_TEMP_CONVERT 260
+
+#define SUP_RATE_11A_MAX_NUM_CHANNELS  8
+#define SUP_RATE_11B_MAX_NUM_CHANNELS  4
+#define SUP_RATE_11G_MAX_NUM_CHANNELS  12
+
+/* Used for passing to driver number of successes and failures per rate */
+struct rate_histogram {
+       union {
+               __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
+               __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
+               __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
+       } success;
+       union {
+               __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
+               __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
+               __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
+       } failed;
+} __packed;
+
+/* stats command response */
+
+struct iwl39_stats_rx_phy {
+       __le32 ina_cnt;
+       __le32 fina_cnt;
+       __le32 plcp_err;
+       __le32 crc32_err;
+       __le32 overrun_err;
+       __le32 early_overrun_err;
+       __le32 crc32_good;
+       __le32 false_alarm_cnt;
+       __le32 fina_sync_err_cnt;
+       __le32 sfd_timeout;
+       __le32 fina_timeout;
+       __le32 unresponded_rts;
+       __le32 rxe_frame_limit_overrun;
+       __le32 sent_ack_cnt;
+       __le32 sent_cts_cnt;
+} __packed;
+
+struct iwl39_stats_rx_non_phy {
+       __le32 bogus_cts;       /* CTS received when not expecting CTS */
+       __le32 bogus_ack;       /* ACK received when not expecting ACK */
+       __le32 non_bssid_frames;        /* number of frames with BSSID that
+                                        * doesn't belong to the STA BSSID */
+       __le32 filtered_frames; /* count frames that were dumped in the
+                                * filtering process */
+       __le32 non_channel_beacons;     /* beacons with our bss id but not on
+                                        * our serving channel */
+} __packed;
+
+struct iwl39_stats_rx {
+       struct iwl39_stats_rx_phy ofdm;
+       struct iwl39_stats_rx_phy cck;
+       struct iwl39_stats_rx_non_phy general;
+} __packed;
+
+struct iwl39_stats_tx {
+       __le32 preamble_cnt;
+       __le32 rx_detected_cnt;
+       __le32 bt_prio_defer_cnt;
+       __le32 bt_prio_kill_cnt;
+       __le32 few_bytes_cnt;
+       __le32 cts_timeout;
+       __le32 ack_timeout;
+       __le32 expected_ack_cnt;
+       __le32 actual_ack_cnt;
+} __packed;
+
+struct stats_dbg {
+       __le32 burst_check;
+       __le32 burst_count;
+       __le32 wait_for_silence_timeout_cnt;
+       __le32 reserved[3];
+} __packed;
+
+struct iwl39_stats_div {
+       __le32 tx_on_a;
+       __le32 tx_on_b;
+       __le32 exec_time;
+       __le32 probe_time;
+} __packed;
+
+struct iwl39_stats_general {
+       __le32 temperature;
+       struct stats_dbg dbg;
+       __le32 sleep_time;
+       __le32 slots_out;
+       __le32 slots_idle;
+       __le32 ttl_timestamp;
+       struct iwl39_stats_div div;
+} __packed;
+
+struct stats_rx_phy {
+       __le32 ina_cnt;
+       __le32 fina_cnt;
+       __le32 plcp_err;
+       __le32 crc32_err;
+       __le32 overrun_err;
+       __le32 early_overrun_err;
+       __le32 crc32_good;
+       __le32 false_alarm_cnt;
+       __le32 fina_sync_err_cnt;
+       __le32 sfd_timeout;
+       __le32 fina_timeout;
+       __le32 unresponded_rts;
+       __le32 rxe_frame_limit_overrun;
+       __le32 sent_ack_cnt;
+       __le32 sent_cts_cnt;
+       __le32 sent_ba_rsp_cnt;
+       __le32 dsp_self_kill;
+       __le32 mh_format_err;
+       __le32 re_acq_main_rssi_sum;
+       __le32 reserved3;
+} __packed;
+
+struct stats_rx_ht_phy {
+       __le32 plcp_err;
+       __le32 overrun_err;
+       __le32 early_overrun_err;
+       __le32 crc32_good;
+       __le32 crc32_err;
+       __le32 mh_format_err;
+       __le32 agg_crc32_good;
+       __le32 agg_mpdu_cnt;
+       __le32 agg_cnt;
+       __le32 unsupport_mcs;
+} __packed;
+
+#define INTERFERENCE_DATA_AVAILABLE      cpu_to_le32(1)
+
+struct stats_rx_non_phy {
+       __le32 bogus_cts;       /* CTS received when not expecting CTS */
+       __le32 bogus_ack;       /* ACK received when not expecting ACK */
+       __le32 non_bssid_frames;        /* number of frames with BSSID that
+                                        * doesn't belong to the STA BSSID */
+       __le32 filtered_frames; /* count frames that were dumped in the
+                                * filtering process */
+       __le32 non_channel_beacons;     /* beacons with our bss id but not on
+                                        * our serving channel */
+       __le32 channel_beacons; /* beacons with our bss id and in our
+                                * serving channel */
+       __le32 num_missed_bcon; /* number of missed beacons */
+       __le32 adc_rx_saturation_time;  /* count in 0.8us units the time the
+                                        * ADC was in saturation */
+       __le32 ina_detection_search_time;       /* total time (in 0.8us) searched
+                                                * for INA */
+       __le32 beacon_silence_rssi_a;   /* RSSI silence after beacon frame */
+       __le32 beacon_silence_rssi_b;   /* RSSI silence after beacon frame */
+       __le32 beacon_silence_rssi_c;   /* RSSI silence after beacon frame */
+       __le32 interference_data_flag;  /* flag for interference data
+                                        * availability. 1 when data is
+                                        * available. */
+       __le32 channel_load;    /* counts RX Enable time in uSec */
+       __le32 dsp_false_alarms;        /* DSP false alarm (both OFDM
+                                        * and CCK) counter */
+       __le32 beacon_rssi_a;
+       __le32 beacon_rssi_b;
+       __le32 beacon_rssi_c;
+       __le32 beacon_energy_a;
+       __le32 beacon_energy_b;
+       __le32 beacon_energy_c;
+} __packed;
+
+struct stats_rx {
+       struct stats_rx_phy ofdm;
+       struct stats_rx_phy cck;
+       struct stats_rx_non_phy general;
+       struct stats_rx_ht_phy ofdm_ht;
+} __packed;
+
+/**
+ * struct stats_tx_power - current tx power
+ *
+ * @ant_a: current tx power on chain a in 1/2 dB step
+ * @ant_b: current tx power on chain b in 1/2 dB step
+ * @ant_c: current tx power on chain c in 1/2 dB step
+ */
+struct stats_tx_power {
+       u8 ant_a;
+       u8 ant_b;
+       u8 ant_c;
+       u8 reserved;
+} __packed;
+
+struct stats_tx_non_phy_agg {
+       __le32 ba_timeout;
+       __le32 ba_reschedule_frames;
+       __le32 scd_query_agg_frame_cnt;
+       __le32 scd_query_no_agg;
+       __le32 scd_query_agg;
+       __le32 scd_query_mismatch;
+       __le32 frame_not_ready;
+       __le32 underrun;
+       __le32 bt_prio_kill;
+       __le32 rx_ba_rsp_cnt;
+} __packed;
+
+struct stats_tx {
+       __le32 preamble_cnt;
+       __le32 rx_detected_cnt;
+       __le32 bt_prio_defer_cnt;
+       __le32 bt_prio_kill_cnt;
+       __le32 few_bytes_cnt;
+       __le32 cts_timeout;
+       __le32 ack_timeout;
+       __le32 expected_ack_cnt;
+       __le32 actual_ack_cnt;
+       __le32 dump_msdu_cnt;
+       __le32 burst_abort_next_frame_mismatch_cnt;
+       __le32 burst_abort_missing_next_frame_cnt;
+       __le32 cts_timeout_collision;
+       __le32 ack_or_ba_timeout_collision;
+       struct stats_tx_non_phy_agg agg;
+
+       __le32 reserved1;
+} __packed;
+
+struct stats_div {
+       __le32 tx_on_a;
+       __le32 tx_on_b;
+       __le32 exec_time;
+       __le32 probe_time;
+       __le32 reserved1;
+       __le32 reserved2;
+} __packed;
+
+struct stats_general_common {
+       __le32 temperature;     /* radio temperature */
+       struct stats_dbg dbg;
+       __le32 sleep_time;
+       __le32 slots_out;
+       __le32 slots_idle;
+       __le32 ttl_timestamp;
+       struct stats_div div;
+       __le32 rx_enable_counter;
+       /*
+        * num_of_sos_states:
+        *  count the number of times we have to re-tune
+        *  in order to get out of bad PHY status
+        */
+       __le32 num_of_sos_states;
+} __packed;
+
+struct stats_general {
+       struct stats_general_common common;
+       __le32 reserved2;
+       __le32 reserved3;
+} __packed;
+
+#define UCODE_STATS_CLEAR_MSK          (0x1 << 0)
+#define UCODE_STATS_FREQUENCY_MSK              (0x1 << 1)
+#define UCODE_STATS_NARROW_BAND_MSK    (0x1 << 2)
+
+/*
+ * C_STATS = 0x9c,
+ * all devices identical.
+ *
+ * This command triggers an immediate response containing uCode stats.
+ * The response is in the same format as N_STATS 0x9d, below.
+ *
+ * If the CLEAR_STATS configuration flag is set, uCode will clear its
+ * internal copy of the stats (counters) after issuing the response.
+ * This flag does not affect N_STATSs after beacons (see below).
+ *
+ * If the DISABLE_NOTIF configuration flag is set, uCode will not issue
+ * N_STATSs after received beacons (see below).  This flag
+ * does not affect the response to the C_STATS 0x9c itself.
+ */
+#define IL_STATS_CONF_CLEAR_STATS cpu_to_le32(0x1)     /* see above */
+#define IL_STATS_CONF_DISABLE_NOTIF cpu_to_le32(0x2)   /* see above */
+struct il_stats_cmd {
+       __le32 configuration_flags;     /* IL_STATS_CONF_* */
+} __packed;
+
+/*
+ * N_STATS = 0x9d (notification only, not a command)
+ *
+ * By default, uCode issues this notification after receiving a beacon
+ * while associated.  To disable this behavior, set DISABLE_NOTIF flag in the
+ * C_STATS 0x9c, above.
+ *
+ * Statistics counters continue to increment beacon after beacon, but are
+ * cleared when changing channels or when driver issues C_STATS
+ * 0x9c with CLEAR_STATS bit set (see above).
+ *
+ * uCode also issues this notification during scans.  uCode clears stats
+ * appropriately so that each notification contains stats for only the
+ * one channel that has just been scanned.
+ */
+#define STATS_REPLY_FLG_BAND_24G_MSK         cpu_to_le32(0x2)
+#define STATS_REPLY_FLG_HT40_MODE_MSK        cpu_to_le32(0x8)
+
+struct il3945_notif_stats {
+       __le32 flag;
+       struct iwl39_stats_rx rx;
+       struct iwl39_stats_tx tx;
+       struct iwl39_stats_general general;
+} __packed;
+
+struct il_notif_stats {
+       __le32 flag;
+       struct stats_rx rx;
+       struct stats_tx tx;
+       struct stats_general general;
+} __packed;
+
+/*
+ * N_MISSED_BEACONS = 0xa2 (notification only, not a command)
+ *
+ * uCode send N_MISSED_BEACONS to driver when detect beacon missed
+ * in regardless of how many missed beacons, which mean when driver receive the
+ * notification, inside the command, it can find all the beacons information
+ * which include number of total missed beacons, number of consecutive missed
+ * beacons, number of beacons received and number of beacons expected to
+ * receive.
+ *
+ * If uCode detected consecutive_missed_beacons > 5, it will reset the radio
+ * in order to bring the radio/PHY back to working state; which has no relation
+ * to when driver will perform sensitivity calibration.
+ *
+ * Driver should set it own missed_beacon_threshold to decide when to perform
+ * sensitivity calibration based on number of consecutive missed beacons in
+ * order to improve overall performance, especially in noisy environment.
+ *
+ */
+
+#define IL_MISSED_BEACON_THRESHOLD_MIN (1)
+#define IL_MISSED_BEACON_THRESHOLD_DEF (5)
+#define IL_MISSED_BEACON_THRESHOLD_MAX IL_MISSED_BEACON_THRESHOLD_DEF
+
+struct il_missed_beacon_notif {
+       __le32 consecutive_missed_beacons;
+       __le32 total_missed_becons;
+       __le32 num_expected_beacons;
+       __le32 num_recvd_beacons;
+} __packed;
+
+/******************************************************************************
+ * (11)
+ * Rx Calibration Commands:
+ *
+ * With the uCode used for open source drivers, most Tx calibration (except
+ * for Tx Power) and most Rx calibration is done by uCode during the
+ * "initialize" phase of uCode boot.  Driver must calibrate only:
+ *
+ * 1)  Tx power (depends on temperature), described elsewhere
+ * 2)  Receiver gain balance (optimize MIMO, and detect disconnected antennas)
+ * 3)  Receiver sensitivity (to optimize signal detection)
+ *
+ *****************************************************************************/
+
+/**
+ * C_SENSITIVITY = 0xa8 (command, has simple generic response)
+ *
+ * This command sets up the Rx signal detector for a sensitivity level that
+ * is high enough to lock onto all signals within the associated network,
+ * but low enough to ignore signals that are below a certain threshold, so as
+ * not to have too many "false alarms".  False alarms are signals that the
+ * Rx DSP tries to lock onto, but then discards after determining that they
+ * are noise.
+ *
+ * The optimum number of false alarms is between 5 and 50 per 200 TUs
+ * (200 * 1024 uSecs, i.e. 204.8 milliseconds) of actual Rx time (i.e.
+ * time listening, not transmitting).  Driver must adjust sensitivity so that
+ * the ratio of actual false alarms to actual Rx time falls within this range.
+ *
+ * While associated, uCode delivers N_STATSs after each
+ * received beacon.  These provide information to the driver to analyze the
+ * sensitivity.  Don't analyze stats that come in from scanning, or any
+ * other non-associated-network source.  Pertinent stats include:
+ *
+ * From "general" stats (struct stats_rx_non_phy):
+ *
+ * (beacon_energy_[abc] & 0x0FF00) >> 8 (unsigned, higher value is lower level)
+ *   Measure of energy of desired signal.  Used for establishing a level
+ *   below which the device does not detect signals.
+ *
+ * (beacon_silence_rssi_[abc] & 0x0FF00) >> 8 (unsigned, units in dB)
+ *   Measure of background noise in silent period after beacon.
+ *
+ * channel_load
+ *   uSecs of actual Rx time during beacon period (varies according to
+ *   how much time was spent transmitting).
+ *
+ * From "cck" and "ofdm" stats (struct stats_rx_phy), separately:
+ *
+ * false_alarm_cnt
+ *   Signal locks abandoned early (before phy-level header).
+ *
+ * plcp_err
+ *   Signal locks abandoned late (during phy-level header).
+ *
+ * NOTE:  Both false_alarm_cnt and plcp_err increment monotonically from
+ *        beacon to beacon, i.e. each value is an accumulation of all errors
+ *        before and including the latest beacon.  Values will wrap around to 0
+ *        after counting up to 2^32 - 1.  Driver must differentiate vs.
+ *        previous beacon's values to determine # false alarms in the current
+ *        beacon period.
+ *
+ * Total number of false alarms = false_alarms + plcp_errs
+ *
+ * For OFDM, adjust the following table entries in struct il_sensitivity_cmd
+ * (notice that the start points for OFDM are at or close to settings for
+ * maximum sensitivity):
+ *
+ *                                             START  /  MIN  /  MAX
+ *   HD_AUTO_CORR32_X1_TH_ADD_MIN_IDX          90   /   85  /  120
+ *   HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_IDX     170   /  170  /  210
+ *   HD_AUTO_CORR32_X4_TH_ADD_MIN_IDX         105   /  105  /  140
+ *   HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_IDX     220   /  220  /  270
+ *
+ *   If actual rate of OFDM false alarms (+ plcp_errors) is too high
+ *   (greater than 50 for each 204.8 msecs listening), reduce sensitivity
+ *   by *adding* 1 to all 4 of the table entries above, up to the max for
+ *   each entry.  Conversely, if false alarm rate is too low (less than 5
+ *   for each 204.8 msecs listening), *subtract* 1 from each entry to
+ *   increase sensitivity.
+ *
+ * For CCK sensitivity, keep track of the following:
+ *
+ *   1).  20-beacon history of maximum background noise, indicated by
+ *        (beacon_silence_rssi_[abc] & 0x0FF00), units in dB, across the
+ *        3 receivers.  For any given beacon, the "silence reference" is
+ *        the maximum of last 60 samples (20 beacons * 3 receivers).
+ *
+ *   2).  10-beacon history of strongest signal level, as indicated
+ *        by (beacon_energy_[abc] & 0x0FF00) >> 8, across the 3 receivers,
+ *        i.e. the strength of the signal through the best receiver at the
+ *        moment.  These measurements are "upside down", with lower values
+ *        for stronger signals, so max energy will be *minimum* value.
+ *
+ *        Then for any given beacon, the driver must determine the *weakest*
+ *        of the strongest signals; this is the minimum level that needs to be
+ *        successfully detected, when using the best receiver at the moment.
+ *        "Max cck energy" is the maximum (higher value means lower energy!)
+ *        of the last 10 minima.  Once this is determined, driver must add
+ *        a little margin by adding "6" to it.
+ *
+ *   3).  Number of consecutive beacon periods with too few false alarms.
+ *        Reset this to 0 at the first beacon period that falls within the
+ *        "good" range (5 to 50 false alarms per 204.8 milliseconds rx).
+ *
+ * Then, adjust the following CCK table entries in struct il_sensitivity_cmd
+ * (notice that the start points for CCK are at maximum sensitivity):
+ *
+ *                                             START  /  MIN  /  MAX
+ *   HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX         125   /  125  /  200
+ *   HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX     200   /  200  /  400
+ *   HD_MIN_ENERGY_CCK_DET_IDX                100   /    0  /  100
+ *
+ *   If actual rate of CCK false alarms (+ plcp_errors) is too high
+ *   (greater than 50 for each 204.8 msecs listening), method for reducing
+ *   sensitivity is:
+ *
+ *   1)  *Add* 3 to value in HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX,
+ *       up to max 400.
+ *
+ *   2)  If current value in HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX is < 160,
+ *       sensitivity has been reduced a significant amount; bring it up to
+ *       a moderate 161.  Otherwise, *add* 3, up to max 200.
+ *
+ *   3)  a)  If current value in HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX is > 160,
+ *       sensitivity has been reduced only a moderate or small amount;
+ *       *subtract* 2 from value in HD_MIN_ENERGY_CCK_DET_IDX,
+ *       down to min 0.  Otherwise (if gain has been significantly reduced),
+ *       don't change the HD_MIN_ENERGY_CCK_DET_IDX value.
+ *
+ *       b)  Save a snapshot of the "silence reference".
+ *
+ *   If actual rate of CCK false alarms (+ plcp_errors) is too low
+ *   (less than 5 for each 204.8 msecs listening), method for increasing
+ *   sensitivity is used only if:
+ *
+ *   1a)  Previous beacon did not have too many false alarms
+ *   1b)  AND difference between previous "silence reference" and current
+ *        "silence reference" (prev - current) is 2 or more,
+ *   OR 2)  100 or more consecutive beacon periods have had rate of
+ *          less than 5 false alarms per 204.8 milliseconds rx time.
+ *
+ *   Method for increasing sensitivity:
+ *
+ *   1)  *Subtract* 3 from value in HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX,
+ *       down to min 125.
+ *
+ *   2)  *Subtract* 3 from value in HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX,
+ *       down to min 200.
+ *
+ *   3)  *Add* 2 to value in HD_MIN_ENERGY_CCK_DET_IDX, up to max 100.
+ *
+ *   If actual rate of CCK false alarms (+ plcp_errors) is within good range
+ *   (between 5 and 50 for each 204.8 msecs listening):
+ *
+ *   1)  Save a snapshot of the silence reference.
+ *
+ *   2)  If previous beacon had too many CCK false alarms (+ plcp_errors),
+ *       give some extra margin to energy threshold by *subtracting* 8
+ *       from value in HD_MIN_ENERGY_CCK_DET_IDX.
+ *
+ *   For all cases (too few, too many, good range), make sure that the CCK
+ *   detection threshold (energy) is below the energy level for robust
+ *   detection over the past 10 beacon periods, the "Max cck energy".
+ *   Lower values mean higher energy; this means making sure that the value
+ *   in HD_MIN_ENERGY_CCK_DET_IDX is at or *above* "Max cck energy".
+ *
+ */
+
+/*
+ * Table entries in C_SENSITIVITY (struct il_sensitivity_cmd)
+ */
+#define HD_TBL_SIZE  (11)      /* number of entries */
+#define HD_MIN_ENERGY_CCK_DET_IDX                 (0)  /* table idxes */
+#define HD_MIN_ENERGY_OFDM_DET_IDX                (1)
+#define HD_AUTO_CORR32_X1_TH_ADD_MIN_IDX          (2)
+#define HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_IDX      (3)
+#define HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX      (4)
+#define HD_AUTO_CORR32_X4_TH_ADD_MIN_IDX          (5)
+#define HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_IDX      (6)
+#define HD_BARKER_CORR_TH_ADD_MIN_IDX             (7)
+#define HD_BARKER_CORR_TH_ADD_MIN_MRC_IDX         (8)
+#define HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX          (9)
+#define HD_OFDM_ENERGY_TH_IN_IDX                  (10)
+
+/* Control field in struct il_sensitivity_cmd */
+#define C_SENSITIVITY_CONTROL_DEFAULT_TBL      cpu_to_le16(0)
+#define C_SENSITIVITY_CONTROL_WORK_TBL cpu_to_le16(1)
+
+/**
+ * struct il_sensitivity_cmd
+ * @control:  (1) updates working table, (0) updates default table
+ * @table:  energy threshold values, use HD_* as idx into table
+ *
+ * Always use "1" in "control" to update uCode's working table and DSP.
+ */
+struct il_sensitivity_cmd {
+       __le16 control;         /* always use "1" */
+       __le16 table[HD_TBL_SIZE];      /* use HD_* as idx */
+} __packed;
+
+/**
+ * C_PHY_CALIBRATION = 0xb0 (command, has simple generic response)
+ *
+ * This command sets the relative gains of 4965 device's 3 radio receiver chains.
+ *
+ * After the first association, driver should accumulate signal and noise
+ * stats from the N_STATSs that follow the first 20
+ * beacons from the associated network (don't collect stats that come
+ * in from scanning, or any other non-network source).
+ *
+ * DISCONNECTED ANTENNA:
+ *
+ * Driver should determine which antennas are actually connected, by comparing
+ * average beacon signal levels for the 3 Rx chains.  Accumulate (add) the
+ * following values over 20 beacons, one accumulator for each of the chains
+ * a/b/c, from struct stats_rx_non_phy:
+ *
+ * beacon_rssi_[abc] & 0x0FF (unsigned, units in dB)
+ *
+ * Find the strongest signal from among a/b/c.  Compare the other two to the
+ * strongest.  If any signal is more than 15 dB (times 20, unless you
+ * divide the accumulated values by 20) below the strongest, the driver
+ * considers that antenna to be disconnected, and should not try to use that
+ * antenna/chain for Rx or Tx.  If both A and B seem to be disconnected,
+ * driver should declare the stronger one as connected, and attempt to use it
+ * (A and B are the only 2 Tx chains!).
+ *
+ *
+ * RX BALANCE:
+ *
+ * Driver should balance the 3 receivers (but just the ones that are connected
+ * to antennas, see above) for gain, by comparing the average signal levels
+ * detected during the silence after each beacon (background noise).
+ * Accumulate (add) the following values over 20 beacons, one accumulator for
+ * each of the chains a/b/c, from struct stats_rx_non_phy:
+ *
+ * beacon_silence_rssi_[abc] & 0x0FF (unsigned, units in dB)
+ *
+ * Find the weakest background noise level from among a/b/c.  This Rx chain
+ * will be the reference, with 0 gain adjustment.  Attenuate other channels by
+ * finding noise difference:
+ *
+ * (accum_noise[i] - accum_noise[reference]) / 30
+ *
+ * The "30" adjusts the dB in the 20 accumulated samples to units of 1.5 dB.
+ * For use in diff_gain_[abc] fields of struct il_calibration_cmd, the
+ * driver should limit the difference results to a range of 0-3 (0-4.5 dB),
+ * and set bit 2 to indicate "reduce gain".  The value for the reference
+ * (weakest) chain should be "0".
+ *
+ * diff_gain_[abc] bit fields:
+ *   2: (1) reduce gain, (0) increase gain
+ * 1-0: amount of gain, units of 1.5 dB
+ */
+
+/* Phy calibration command for series */
+/* The default calibrate table size if not specified by firmware */
+#define IL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE     18
+enum {
+       IL_PHY_CALIBRATE_DIFF_GAIN_CMD = 7,
+       IL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE = 19,
+};
+
+#define IL_MAX_PHY_CALIBRATE_TBL_SIZE          (253)
+
+struct il_calib_hdr {
+       u8 op_code;
+       u8 first_group;
+       u8 groups_num;
+       u8 data_valid;
+} __packed;
+
+/* IL_PHY_CALIBRATE_DIFF_GAIN_CMD (7) */
+struct il_calib_diff_gain_cmd {
+       struct il_calib_hdr hdr;
+       s8 diff_gain_a;         /* see above */
+       s8 diff_gain_b;
+       s8 diff_gain_c;
+       u8 reserved1;
+} __packed;
+
+/******************************************************************************
+ * (12)
+ * Miscellaneous Commands:
+ *
+ *****************************************************************************/
+
+/*
+ * LEDs Command & Response
+ * C_LEDS = 0x48 (command, has simple generic response)
+ *
+ * For each of 3 possible LEDs (Activity/Link/Tech, selected by "id" field),
+ * this command turns it on or off, or sets up a periodic blinking cycle.
+ */
+struct il_led_cmd {
+       __le32 interval;        /* "interval" in uSec */
+       u8 id;                  /* 1: Activity, 2: Link, 3: Tech */
+       u8 off;                 /* # intervals off while blinking;
+                                * "0", with >0 "on" value, turns LED on */
+       u8 on;                  /* # intervals on while blinking;
+                                * "0", regardless of "off", turns LED off */
+       u8 reserved;
+} __packed;
+
+/******************************************************************************
+ * (13)
+ * Union of all expected notifications/responses:
+ *
+ *****************************************************************************/
+
+#define IL_RX_FRAME_SIZE_MSK   0x00003fff
+
+struct il_rx_pkt {
+       /*
+        * The first 4 bytes of the RX frame header contain both the RX frame
+        * size and some flags.
+        * Bit fields:
+        * 31:    flag flush RB request
+        * 30:    flag ignore TC (terminal counter) request
+        * 29:    flag fast IRQ request
+        * 28-14: Reserved
+        * 13-00: RX frame size
+        */
+       __le32 len_n_flags;
+       struct il_cmd_header hdr;
+       union {
+               struct il3945_rx_frame rx_frame;
+               struct il3945_tx_resp tx_resp;
+               struct il3945_beacon_notif beacon_status;
+
+               struct il_alive_resp alive_frame;
+               struct il_spectrum_notification spectrum_notif;
+               struct il_csa_notification csa_notif;
+               struct il_error_resp err_resp;
+               struct il_card_state_notif card_state_notif;
+               struct il_add_sta_resp add_sta;
+               struct il_rem_sta_resp rem_sta;
+               struct il_sleep_notification sleep_notif;
+               struct il_spectrum_resp spectrum;
+               struct il_notif_stats stats;
+               struct il_compressed_ba_resp compressed_ba;
+               struct il_missed_beacon_notif missed_beacon;
+               __le32 status;
+               u8 raw[0];
+       } u;
+} __packed;
+
+#endif /* __il_commands_h__ */
diff --git a/drivers/net/wireless/intel/iwlegacy/common.c b/drivers/net/wireless/intel/iwlegacy/common.c
new file mode 100644 (file)
index 0000000..8871145
--- /dev/null
@@ -0,0 +1,5586 @@
+/******************************************************************************
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/etherdevice.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/lockdep.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+#include <linux/skbuff.h>
+#include <net/mac80211.h>
+
+#include "common.h"
+
+int
+_il_poll_bit(struct il_priv *il, u32 addr, u32 bits, u32 mask, int timeout)
+{
+       const int interval = 10; /* microseconds */
+       int t = 0;
+
+       do {
+               if ((_il_rd(il, addr) & mask) == (bits & mask))
+                       return t;
+               udelay(interval);
+               t += interval;
+       } while (t < timeout);
+
+       return -ETIMEDOUT;
+}
+EXPORT_SYMBOL(_il_poll_bit);
+
+void
+il_set_bit(struct il_priv *p, u32 r, u32 m)
+{
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&p->reg_lock, reg_flags);
+       _il_set_bit(p, r, m);
+       spin_unlock_irqrestore(&p->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_set_bit);
+
+void
+il_clear_bit(struct il_priv *p, u32 r, u32 m)
+{
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&p->reg_lock, reg_flags);
+       _il_clear_bit(p, r, m);
+       spin_unlock_irqrestore(&p->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_clear_bit);
+
+bool
+_il_grab_nic_access(struct il_priv *il)
+{
+       int ret;
+       u32 val;
+
+       /* this bit wakes up the NIC */
+       _il_set_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+
+       /*
+        * These bits say the device is running, and should keep running for
+        * at least a short while (at least as long as MAC_ACCESS_REQ stays 1),
+        * but they do not indicate that embedded SRAM is restored yet;
+        * 3945 and 4965 have volatile SRAM, and must save/restore contents
+        * to/from host DRAM when sleeping/waking for power-saving.
+        * Each direction takes approximately 1/4 millisecond; with this
+        * overhead, it's a good idea to grab and hold MAC_ACCESS_REQUEST if a
+        * series of register accesses are expected (e.g. reading Event Log),
+        * to keep device from sleeping.
+        *
+        * CSR_UCODE_DRV_GP1 register bit MAC_SLEEP == 0 indicates that
+        * SRAM is okay/restored.  We don't check that here because this call
+        * is just for hardware register access; but GP1 MAC_SLEEP check is a
+        * good idea before accessing 3945/4965 SRAM (e.g. reading Event Log).
+        *
+        */
+       ret =
+           _il_poll_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN,
+                        (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
+                         CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 15000);
+       if (unlikely(ret < 0)) {
+               val = _il_rd(il, CSR_GP_CNTRL);
+               WARN_ONCE(1, "Timeout waiting for ucode processor access "
+                            "(CSR_GP_CNTRL 0x%08x)\n", val);
+               _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_FORCE_NMI);
+               return false;
+       }
+
+       return true;
+}
+EXPORT_SYMBOL_GPL(_il_grab_nic_access);
+
+int
+il_poll_bit(struct il_priv *il, u32 addr, u32 mask, int timeout)
+{
+       const int interval = 10; /* microseconds */
+       int t = 0;
+
+       do {
+               if ((il_rd(il, addr) & mask) == mask)
+                       return t;
+               udelay(interval);
+               t += interval;
+       } while (t < timeout);
+
+       return -ETIMEDOUT;
+}
+EXPORT_SYMBOL(il_poll_bit);
+
+u32
+il_rd_prph(struct il_priv *il, u32 reg)
+{
+       unsigned long reg_flags;
+       u32 val;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       _il_grab_nic_access(il);
+       val = _il_rd_prph(il, reg);
+       _il_release_nic_access(il);
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+       return val;
+}
+EXPORT_SYMBOL(il_rd_prph);
+
+void
+il_wr_prph(struct il_priv *il, u32 addr, u32 val)
+{
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       if (likely(_il_grab_nic_access(il))) {
+               _il_wr_prph(il, addr, val);
+               _il_release_nic_access(il);
+       }
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_wr_prph);
+
+u32
+il_read_targ_mem(struct il_priv *il, u32 addr)
+{
+       unsigned long reg_flags;
+       u32 value;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       _il_grab_nic_access(il);
+
+       _il_wr(il, HBUS_TARG_MEM_RADDR, addr);
+       value = _il_rd(il, HBUS_TARG_MEM_RDAT);
+
+       _il_release_nic_access(il);
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+       return value;
+}
+EXPORT_SYMBOL(il_read_targ_mem);
+
+void
+il_write_targ_mem(struct il_priv *il, u32 addr, u32 val)
+{
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       if (likely(_il_grab_nic_access(il))) {
+               _il_wr(il, HBUS_TARG_MEM_WADDR, addr);
+               _il_wr(il, HBUS_TARG_MEM_WDAT, val);
+               _il_release_nic_access(il);
+       }
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_write_targ_mem);
+
+const char *
+il_get_cmd_string(u8 cmd)
+{
+       switch (cmd) {
+               IL_CMD(N_ALIVE);
+               IL_CMD(N_ERROR);
+               IL_CMD(C_RXON);
+               IL_CMD(C_RXON_ASSOC);
+               IL_CMD(C_QOS_PARAM);
+               IL_CMD(C_RXON_TIMING);
+               IL_CMD(C_ADD_STA);
+               IL_CMD(C_REM_STA);
+               IL_CMD(C_WEPKEY);
+               IL_CMD(N_3945_RX);
+               IL_CMD(C_TX);
+               IL_CMD(C_RATE_SCALE);
+               IL_CMD(C_LEDS);
+               IL_CMD(C_TX_LINK_QUALITY_CMD);
+               IL_CMD(C_CHANNEL_SWITCH);
+               IL_CMD(N_CHANNEL_SWITCH);
+               IL_CMD(C_SPECTRUM_MEASUREMENT);
+               IL_CMD(N_SPECTRUM_MEASUREMENT);
+               IL_CMD(C_POWER_TBL);
+               IL_CMD(N_PM_SLEEP);
+               IL_CMD(N_PM_DEBUG_STATS);
+               IL_CMD(C_SCAN);
+               IL_CMD(C_SCAN_ABORT);
+               IL_CMD(N_SCAN_START);
+               IL_CMD(N_SCAN_RESULTS);
+               IL_CMD(N_SCAN_COMPLETE);
+               IL_CMD(N_BEACON);
+               IL_CMD(C_TX_BEACON);
+               IL_CMD(C_TX_PWR_TBL);
+               IL_CMD(C_BT_CONFIG);
+               IL_CMD(C_STATS);
+               IL_CMD(N_STATS);
+               IL_CMD(N_CARD_STATE);
+               IL_CMD(N_MISSED_BEACONS);
+               IL_CMD(C_CT_KILL_CONFIG);
+               IL_CMD(C_SENSITIVITY);
+               IL_CMD(C_PHY_CALIBRATION);
+               IL_CMD(N_RX_PHY);
+               IL_CMD(N_RX_MPDU);
+               IL_CMD(N_RX);
+               IL_CMD(N_COMPRESSED_BA);
+       default:
+               return "UNKNOWN";
+
+       }
+}
+EXPORT_SYMBOL(il_get_cmd_string);
+
+#define HOST_COMPLETE_TIMEOUT (HZ / 2)
+
+static void
+il_generic_cmd_callback(struct il_priv *il, struct il_device_cmd *cmd,
+                       struct il_rx_pkt *pkt)
+{
+       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
+               IL_ERR("Bad return from %s (0x%08X)\n",
+                      il_get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
+               return;
+       }
+#ifdef CONFIG_IWLEGACY_DEBUG
+       switch (cmd->hdr.cmd) {
+       case C_TX_LINK_QUALITY_CMD:
+       case C_SENSITIVITY:
+               D_HC_DUMP("back from %s (0x%08X)\n",
+                         il_get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
+               break;
+       default:
+               D_HC("back from %s (0x%08X)\n", il_get_cmd_string(cmd->hdr.cmd),
+                    pkt->hdr.flags);
+       }
+#endif
+}
+
+static int
+il_send_cmd_async(struct il_priv *il, struct il_host_cmd *cmd)
+{
+       int ret;
+
+       BUG_ON(!(cmd->flags & CMD_ASYNC));
+
+       /* An asynchronous command can not expect an SKB to be set. */
+       BUG_ON(cmd->flags & CMD_WANT_SKB);
+
+       /* Assign a generic callback if one is not provided */
+       if (!cmd->callback)
+               cmd->callback = il_generic_cmd_callback;
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return -EBUSY;
+
+       ret = il_enqueue_hcmd(il, cmd);
+       if (ret < 0) {
+               IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
+                      il_get_cmd_string(cmd->id), ret);
+               return ret;
+       }
+       return 0;
+}
+
+int
+il_send_cmd_sync(struct il_priv *il, struct il_host_cmd *cmd)
+{
+       int cmd_idx;
+       int ret;
+
+       lockdep_assert_held(&il->mutex);
+
+       BUG_ON(cmd->flags & CMD_ASYNC);
+
+       /* A synchronous command can not have a callback set. */
+       BUG_ON(cmd->callback);
+
+       D_INFO("Attempting to send sync command %s\n",
+              il_get_cmd_string(cmd->id));
+
+       set_bit(S_HCMD_ACTIVE, &il->status);
+       D_INFO("Setting HCMD_ACTIVE for command %s\n",
+              il_get_cmd_string(cmd->id));
+
+       cmd_idx = il_enqueue_hcmd(il, cmd);
+       if (cmd_idx < 0) {
+               ret = cmd_idx;
+               IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
+                      il_get_cmd_string(cmd->id), ret);
+               goto out;
+       }
+
+       ret = wait_event_timeout(il->wait_command_queue,
+                                !test_bit(S_HCMD_ACTIVE, &il->status),
+                                HOST_COMPLETE_TIMEOUT);
+       if (!ret) {
+               if (test_bit(S_HCMD_ACTIVE, &il->status)) {
+                       IL_ERR("Error sending %s: time out after %dms.\n",
+                              il_get_cmd_string(cmd->id),
+                              jiffies_to_msecs(HOST_COMPLETE_TIMEOUT));
+
+                       clear_bit(S_HCMD_ACTIVE, &il->status);
+                       D_INFO("Clearing HCMD_ACTIVE for command %s\n",
+                              il_get_cmd_string(cmd->id));
+                       ret = -ETIMEDOUT;
+                       goto cancel;
+               }
+       }
+
+       if (test_bit(S_RFKILL, &il->status)) {
+               IL_ERR("Command %s aborted: RF KILL Switch\n",
+                      il_get_cmd_string(cmd->id));
+               ret = -ECANCELED;
+               goto fail;
+       }
+       if (test_bit(S_FW_ERROR, &il->status)) {
+               IL_ERR("Command %s failed: FW Error\n",
+                      il_get_cmd_string(cmd->id));
+               ret = -EIO;
+               goto fail;
+       }
+       if ((cmd->flags & CMD_WANT_SKB) && !cmd->reply_page) {
+               IL_ERR("Error: Response NULL in '%s'\n",
+                      il_get_cmd_string(cmd->id));
+               ret = -EIO;
+               goto cancel;
+       }
+
+       ret = 0;
+       goto out;
+
+cancel:
+       if (cmd->flags & CMD_WANT_SKB) {
+               /*
+                * Cancel the CMD_WANT_SKB flag for the cmd in the
+                * TX cmd queue. Otherwise in case the cmd comes
+                * in later, it will possibly set an invalid
+                * address (cmd->meta.source).
+                */
+               il->txq[il->cmd_queue].meta[cmd_idx].flags &= ~CMD_WANT_SKB;
+       }
+fail:
+       if (cmd->reply_page) {
+               il_free_pages(il, cmd->reply_page);
+               cmd->reply_page = 0;
+       }
+out:
+       return ret;
+}
+EXPORT_SYMBOL(il_send_cmd_sync);
+
+int
+il_send_cmd(struct il_priv *il, struct il_host_cmd *cmd)
+{
+       if (cmd->flags & CMD_ASYNC)
+               return il_send_cmd_async(il, cmd);
+
+       return il_send_cmd_sync(il, cmd);
+}
+EXPORT_SYMBOL(il_send_cmd);
+
+int
+il_send_cmd_pdu(struct il_priv *il, u8 id, u16 len, const void *data)
+{
+       struct il_host_cmd cmd = {
+               .id = id,
+               .len = len,
+               .data = data,
+       };
+
+       return il_send_cmd_sync(il, &cmd);
+}
+EXPORT_SYMBOL(il_send_cmd_pdu);
+
+int
+il_send_cmd_pdu_async(struct il_priv *il, u8 id, u16 len, const void *data,
+                     void (*callback) (struct il_priv *il,
+                                       struct il_device_cmd *cmd,
+                                       struct il_rx_pkt *pkt))
+{
+       struct il_host_cmd cmd = {
+               .id = id,
+               .len = len,
+               .data = data,
+       };
+
+       cmd.flags |= CMD_ASYNC;
+       cmd.callback = callback;
+
+       return il_send_cmd_async(il, &cmd);
+}
+EXPORT_SYMBOL(il_send_cmd_pdu_async);
+
+/* default: IL_LED_BLINK(0) using blinking idx table */
+static int led_mode;
+module_param(led_mode, int, S_IRUGO);
+MODULE_PARM_DESC(led_mode,
+                "0=system default, " "1=On(RF On)/Off(RF Off), 2=blinking");
+
+/* Throughput          OFF time(ms)    ON time (ms)
+ *     >300                    25              25
+ *     >200 to 300             40              40
+ *     >100 to 200             55              55
+ *     >70 to 100              65              65
+ *     >50 to 70               75              75
+ *     >20 to 50               85              85
+ *     >10 to 20               95              95
+ *     >5 to 10                110             110
+ *     >1 to 5                 130             130
+ *     >0 to 1                 167             167
+ *     <=0                                     SOLID ON
+ */
+static const struct ieee80211_tpt_blink il_blink[] = {
+       {.throughput = 0,               .blink_time = 334},
+       {.throughput = 1 * 1024 - 1,    .blink_time = 260},
+       {.throughput = 5 * 1024 - 1,    .blink_time = 220},
+       {.throughput = 10 * 1024 - 1,   .blink_time = 190},
+       {.throughput = 20 * 1024 - 1,   .blink_time = 170},
+       {.throughput = 50 * 1024 - 1,   .blink_time = 150},
+       {.throughput = 70 * 1024 - 1,   .blink_time = 130},
+       {.throughput = 100 * 1024 - 1,  .blink_time = 110},
+       {.throughput = 200 * 1024 - 1,  .blink_time = 80},
+       {.throughput = 300 * 1024 - 1,  .blink_time = 50},
+};
+
+/*
+ * Adjust led blink rate to compensate on a MAC Clock difference on every HW
+ * Led blink rate analysis showed an average deviation of 0% on 3945,
+ * 5% on 4965 HW.
+ * Need to compensate on the led on/off time per HW according to the deviation
+ * to achieve the desired led frequency
+ * The calculation is: (100-averageDeviation)/100 * blinkTime
+ * For code efficiency the calculation will be:
+ *     compensation = (100 - averageDeviation) * 64 / 100
+ *     NewBlinkTime = (compensation * BlinkTime) / 64
+ */
+static inline u8
+il_blink_compensation(struct il_priv *il, u8 time, u16 compensation)
+{
+       if (!compensation) {
+               IL_ERR("undefined blink compensation: "
+                      "use pre-defined blinking time\n");
+               return time;
+       }
+
+       return (u8) ((time * compensation) >> 6);
+}
+
+/* Set led pattern command */
+static int
+il_led_cmd(struct il_priv *il, unsigned long on, unsigned long off)
+{
+       struct il_led_cmd led_cmd = {
+               .id = IL_LED_LINK,
+               .interval = IL_DEF_LED_INTRVL
+       };
+       int ret;
+
+       if (!test_bit(S_READY, &il->status))
+               return -EBUSY;
+
+       if (il->blink_on == on && il->blink_off == off)
+               return 0;
+
+       if (off == 0) {
+               /* led is SOLID_ON */
+               on = IL_LED_SOLID;
+       }
+
+       D_LED("Led blink time compensation=%u\n",
+             il->cfg->led_compensation);
+       led_cmd.on =
+           il_blink_compensation(il, on,
+                                 il->cfg->led_compensation);
+       led_cmd.off =
+           il_blink_compensation(il, off,
+                                 il->cfg->led_compensation);
+
+       ret = il->ops->send_led_cmd(il, &led_cmd);
+       if (!ret) {
+               il->blink_on = on;
+               il->blink_off = off;
+       }
+       return ret;
+}
+
+static void
+il_led_brightness_set(struct led_classdev *led_cdev,
+                     enum led_brightness brightness)
+{
+       struct il_priv *il = container_of(led_cdev, struct il_priv, led);
+       unsigned long on = 0;
+
+       if (brightness > 0)
+               on = IL_LED_SOLID;
+
+       il_led_cmd(il, on, 0);
+}
+
+static int
+il_led_blink_set(struct led_classdev *led_cdev, unsigned long *delay_on,
+                unsigned long *delay_off)
+{
+       struct il_priv *il = container_of(led_cdev, struct il_priv, led);
+
+       return il_led_cmd(il, *delay_on, *delay_off);
+}
+
+void
+il_leds_init(struct il_priv *il)
+{
+       int mode = led_mode;
+       int ret;
+
+       if (mode == IL_LED_DEFAULT)
+               mode = il->cfg->led_mode;
+
+       il->led.name =
+           kasprintf(GFP_KERNEL, "%s-led", wiphy_name(il->hw->wiphy));
+       il->led.brightness_set = il_led_brightness_set;
+       il->led.blink_set = il_led_blink_set;
+       il->led.max_brightness = 1;
+
+       switch (mode) {
+       case IL_LED_DEFAULT:
+               WARN_ON(1);
+               break;
+       case IL_LED_BLINK:
+               il->led.default_trigger =
+                   ieee80211_create_tpt_led_trigger(il->hw,
+                                                    IEEE80211_TPT_LEDTRIG_FL_CONNECTED,
+                                                    il_blink,
+                                                    ARRAY_SIZE(il_blink));
+               break;
+       case IL_LED_RF_STATE:
+               il->led.default_trigger = ieee80211_get_radio_led_name(il->hw);
+               break;
+       }
+
+       ret = led_classdev_register(&il->pci_dev->dev, &il->led);
+       if (ret) {
+               kfree(il->led.name);
+               return;
+       }
+
+       il->led_registered = true;
+}
+EXPORT_SYMBOL(il_leds_init);
+
+void
+il_leds_exit(struct il_priv *il)
+{
+       if (!il->led_registered)
+               return;
+
+       led_classdev_unregister(&il->led);
+       kfree(il->led.name);
+}
+EXPORT_SYMBOL(il_leds_exit);
+
+/************************** EEPROM BANDS ****************************
+ *
+ * The il_eeprom_band definitions below provide the mapping from the
+ * EEPROM contents to the specific channel number supported for each
+ * band.
+ *
+ * For example, il_priv->eeprom.band_3_channels[4] from the band_3
+ * definition below maps to physical channel 42 in the 5.2GHz spectrum.
+ * The specific geography and calibration information for that channel
+ * is contained in the eeprom map itself.
+ *
+ * During init, we copy the eeprom information and channel map
+ * information into il->channel_info_24/52 and il->channel_map_24/52
+ *
+ * channel_map_24/52 provides the idx in the channel_info array for a
+ * given channel.  We have to have two separate maps as there is channel
+ * overlap with the 2.4GHz and 5.2GHz spectrum as seen in band_1 and
+ * band_2
+ *
+ * A value of 0xff stored in the channel_map indicates that the channel
+ * is not supported by the hardware at all.
+ *
+ * A value of 0xfe in the channel_map indicates that the channel is not
+ * valid for Tx with the current hardware.  This means that
+ * while the system can tune and receive on a given channel, it may not
+ * be able to associate or transmit any frames on that
+ * channel.  There is no corresponding channel information for that
+ * entry.
+ *
+ *********************************************************************/
+
+/* 2.4 GHz */
+const u8 il_eeprom_band_1[14] = {
+       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
+};
+
+/* 5.2 GHz bands */
+static const u8 il_eeprom_band_2[] = { /* 4915-5080MHz */
+       183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
+};
+
+static const u8 il_eeprom_band_3[] = { /* 5170-5320MHz */
+       34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
+};
+
+static const u8 il_eeprom_band_4[] = { /* 5500-5700MHz */
+       100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
+};
+
+static const u8 il_eeprom_band_5[] = { /* 5725-5825MHz */
+       145, 149, 153, 157, 161, 165
+};
+
+static const u8 il_eeprom_band_6[] = { /* 2.4 ht40 channel */
+       1, 2, 3, 4, 5, 6, 7
+};
+
+static const u8 il_eeprom_band_7[] = { /* 5.2 ht40 channel */
+       36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157
+};
+
+/******************************************************************************
+ *
+ * EEPROM related functions
+ *
+******************************************************************************/
+
+static int
+il_eeprom_verify_signature(struct il_priv *il)
+{
+       u32 gp = _il_rd(il, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
+       int ret = 0;
+
+       D_EEPROM("EEPROM signature=0x%08x\n", gp);
+       switch (gp) {
+       case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K:
+       case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K:
+               break;
+       default:
+               IL_ERR("bad EEPROM signature," "EEPROM_GP=0x%08x\n", gp);
+               ret = -ENOENT;
+               break;
+       }
+       return ret;
+}
+
+const u8 *
+il_eeprom_query_addr(const struct il_priv *il, size_t offset)
+{
+       BUG_ON(offset >= il->cfg->eeprom_size);
+       return &il->eeprom[offset];
+}
+EXPORT_SYMBOL(il_eeprom_query_addr);
+
+u16
+il_eeprom_query16(const struct il_priv *il, size_t offset)
+{
+       if (!il->eeprom)
+               return 0;
+       return (u16) il->eeprom[offset] | ((u16) il->eeprom[offset + 1] << 8);
+}
+EXPORT_SYMBOL(il_eeprom_query16);
+
+/**
+ * il_eeprom_init - read EEPROM contents
+ *
+ * Load the EEPROM contents from adapter into il->eeprom
+ *
+ * NOTE:  This routine uses the non-debug IO access functions.
+ */
+int
+il_eeprom_init(struct il_priv *il)
+{
+       __le16 *e;
+       u32 gp = _il_rd(il, CSR_EEPROM_GP);
+       int sz;
+       int ret;
+       u16 addr;
+
+       /* allocate eeprom */
+       sz = il->cfg->eeprom_size;
+       D_EEPROM("NVM size = %d\n", sz);
+       il->eeprom = kzalloc(sz, GFP_KERNEL);
+       if (!il->eeprom) {
+               ret = -ENOMEM;
+               goto alloc_err;
+       }
+       e = (__le16 *) il->eeprom;
+
+       il->ops->apm_init(il);
+
+       ret = il_eeprom_verify_signature(il);
+       if (ret < 0) {
+               IL_ERR("EEPROM not found, EEPROM_GP=0x%08x\n", gp);
+               ret = -ENOENT;
+               goto err;
+       }
+
+       /* Make sure driver (instead of uCode) is allowed to read EEPROM */
+       ret = il->ops->eeprom_acquire_semaphore(il);
+       if (ret < 0) {
+               IL_ERR("Failed to acquire EEPROM semaphore.\n");
+               ret = -ENOENT;
+               goto err;
+       }
+
+       /* eeprom is an array of 16bit values */
+       for (addr = 0; addr < sz; addr += sizeof(u16)) {
+               u32 r;
+
+               _il_wr(il, CSR_EEPROM_REG,
+                      CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
+
+               ret =
+                   _il_poll_bit(il, CSR_EEPROM_REG,
+                                CSR_EEPROM_REG_READ_VALID_MSK,
+                                CSR_EEPROM_REG_READ_VALID_MSK,
+                                IL_EEPROM_ACCESS_TIMEOUT);
+               if (ret < 0) {
+                       IL_ERR("Time out reading EEPROM[%d]\n", addr);
+                       goto done;
+               }
+               r = _il_rd(il, CSR_EEPROM_REG);
+               e[addr / 2] = cpu_to_le16(r >> 16);
+       }
+
+       D_EEPROM("NVM Type: %s, version: 0x%x\n", "EEPROM",
+                il_eeprom_query16(il, EEPROM_VERSION));
+
+       ret = 0;
+done:
+       il->ops->eeprom_release_semaphore(il);
+
+err:
+       if (ret)
+               il_eeprom_free(il);
+       /* Reset chip to save power until we load uCode during "up". */
+       il_apm_stop(il);
+alloc_err:
+       return ret;
+}
+EXPORT_SYMBOL(il_eeprom_init);
+
+void
+il_eeprom_free(struct il_priv *il)
+{
+       kfree(il->eeprom);
+       il->eeprom = NULL;
+}
+EXPORT_SYMBOL(il_eeprom_free);
+
+static void
+il_init_band_reference(const struct il_priv *il, int eep_band,
+                      int *eeprom_ch_count,
+                      const struct il_eeprom_channel **eeprom_ch_info,
+                      const u8 **eeprom_ch_idx)
+{
+       u32 offset = il->cfg->regulatory_bands[eep_band - 1];
+
+       switch (eep_band) {
+       case 1:         /* 2.4GHz band */
+               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_1);
+               *eeprom_ch_info =
+                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
+                                                                    offset);
+               *eeprom_ch_idx = il_eeprom_band_1;
+               break;
+       case 2:         /* 4.9GHz band */
+               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_2);
+               *eeprom_ch_info =
+                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
+                                                                    offset);
+               *eeprom_ch_idx = il_eeprom_band_2;
+               break;
+       case 3:         /* 5.2GHz band */
+               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_3);
+               *eeprom_ch_info =
+                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
+                                                                    offset);
+               *eeprom_ch_idx = il_eeprom_band_3;
+               break;
+       case 4:         /* 5.5GHz band */
+               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_4);
+               *eeprom_ch_info =
+                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
+                                                                    offset);
+               *eeprom_ch_idx = il_eeprom_band_4;
+               break;
+       case 5:         /* 5.7GHz band */
+               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_5);
+               *eeprom_ch_info =
+                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
+                                                                    offset);
+               *eeprom_ch_idx = il_eeprom_band_5;
+               break;
+       case 6:         /* 2.4GHz ht40 channels */
+               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_6);
+               *eeprom_ch_info =
+                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
+                                                                    offset);
+               *eeprom_ch_idx = il_eeprom_band_6;
+               break;
+       case 7:         /* 5 GHz ht40 channels */
+               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_7);
+               *eeprom_ch_info =
+                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
+                                                                    offset);
+               *eeprom_ch_idx = il_eeprom_band_7;
+               break;
+       default:
+               BUG();
+       }
+}
+
+#define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
+                           ? # x " " : "")
+/**
+ * il_mod_ht40_chan_info - Copy ht40 channel info into driver's il.
+ *
+ * Does not set up a command, or touch hardware.
+ */
+static int
+il_mod_ht40_chan_info(struct il_priv *il, enum ieee80211_band band, u16 channel,
+                     const struct il_eeprom_channel *eeprom_ch,
+                     u8 clear_ht40_extension_channel)
+{
+       struct il_channel_info *ch_info;
+
+       ch_info =
+           (struct il_channel_info *)il_get_channel_info(il, band, channel);
+
+       if (!il_is_channel_valid(ch_info))
+               return -1;
+
+       D_EEPROM("HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
+                " Ad-Hoc %ssupported\n", ch_info->channel,
+                il_is_channel_a_band(ch_info) ? "5.2" : "2.4",
+                CHECK_AND_PRINT(IBSS), CHECK_AND_PRINT(ACTIVE),
+                CHECK_AND_PRINT(RADAR), CHECK_AND_PRINT(WIDE),
+                CHECK_AND_PRINT(DFS), eeprom_ch->flags,
+                eeprom_ch->max_power_avg,
+                ((eeprom_ch->flags & EEPROM_CHANNEL_IBSS) &&
+                 !(eeprom_ch->flags & EEPROM_CHANNEL_RADAR)) ? "" : "not ");
+
+       ch_info->ht40_eeprom = *eeprom_ch;
+       ch_info->ht40_max_power_avg = eeprom_ch->max_power_avg;
+       ch_info->ht40_flags = eeprom_ch->flags;
+       if (eeprom_ch->flags & EEPROM_CHANNEL_VALID)
+               ch_info->ht40_extension_channel &=
+                   ~clear_ht40_extension_channel;
+
+       return 0;
+}
+
+#define CHECK_AND_PRINT_I(x) ((eeprom_ch_info[ch].flags & EEPROM_CHANNEL_##x) \
+                           ? # x " " : "")
+
+/**
+ * il_init_channel_map - Set up driver's info for all possible channels
+ */
+int
+il_init_channel_map(struct il_priv *il)
+{
+       int eeprom_ch_count = 0;
+       const u8 *eeprom_ch_idx = NULL;
+       const struct il_eeprom_channel *eeprom_ch_info = NULL;
+       int band, ch;
+       struct il_channel_info *ch_info;
+
+       if (il->channel_count) {
+               D_EEPROM("Channel map already initialized.\n");
+               return 0;
+       }
+
+       D_EEPROM("Initializing regulatory info from EEPROM\n");
+
+       il->channel_count =
+           ARRAY_SIZE(il_eeprom_band_1) + ARRAY_SIZE(il_eeprom_band_2) +
+           ARRAY_SIZE(il_eeprom_band_3) + ARRAY_SIZE(il_eeprom_band_4) +
+           ARRAY_SIZE(il_eeprom_band_5);
+
+       D_EEPROM("Parsing data for %d channels.\n", il->channel_count);
+
+       il->channel_info =
+           kzalloc(sizeof(struct il_channel_info) * il->channel_count,
+                   GFP_KERNEL);
+       if (!il->channel_info) {
+               IL_ERR("Could not allocate channel_info\n");
+               il->channel_count = 0;
+               return -ENOMEM;
+       }
+
+       ch_info = il->channel_info;
+
+       /* Loop through the 5 EEPROM bands adding them in order to the
+        * channel map we maintain (that contains additional information than
+        * what just in the EEPROM) */
+       for (band = 1; band <= 5; band++) {
+
+               il_init_band_reference(il, band, &eeprom_ch_count,
+                                      &eeprom_ch_info, &eeprom_ch_idx);
+
+               /* Loop through each band adding each of the channels */
+               for (ch = 0; ch < eeprom_ch_count; ch++) {
+                       ch_info->channel = eeprom_ch_idx[ch];
+                       ch_info->band =
+                           (band ==
+                            1) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+
+                       /* permanently store EEPROM's channel regulatory flags
+                        *   and max power in channel info database. */
+                       ch_info->eeprom = eeprom_ch_info[ch];
+
+                       /* Copy the run-time flags so they are there even on
+                        * invalid channels */
+                       ch_info->flags = eeprom_ch_info[ch].flags;
+                       /* First write that ht40 is not enabled, and then enable
+                        * one by one */
+                       ch_info->ht40_extension_channel =
+                           IEEE80211_CHAN_NO_HT40;
+
+                       if (!(il_is_channel_valid(ch_info))) {
+                               D_EEPROM("Ch. %d Flags %x [%sGHz] - "
+                                        "No traffic\n", ch_info->channel,
+                                        ch_info->flags,
+                                        il_is_channel_a_band(ch_info) ? "5.2" :
+                                        "2.4");
+                               ch_info++;
+                               continue;
+                       }
+
+                       /* Initialize regulatory-based run-time data */
+                       ch_info->max_power_avg = ch_info->curr_txpow =
+                           eeprom_ch_info[ch].max_power_avg;
+                       ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
+                       ch_info->min_power = 0;
+
+                       D_EEPROM("Ch. %d [%sGHz] " "%s%s%s%s%s%s(0x%02x %ddBm):"
+                                " Ad-Hoc %ssupported\n", ch_info->channel,
+                                il_is_channel_a_band(ch_info) ? "5.2" : "2.4",
+                                CHECK_AND_PRINT_I(VALID),
+                                CHECK_AND_PRINT_I(IBSS),
+                                CHECK_AND_PRINT_I(ACTIVE),
+                                CHECK_AND_PRINT_I(RADAR),
+                                CHECK_AND_PRINT_I(WIDE),
+                                CHECK_AND_PRINT_I(DFS),
+                                eeprom_ch_info[ch].flags,
+                                eeprom_ch_info[ch].max_power_avg,
+                                ((eeprom_ch_info[ch].
+                                  flags & EEPROM_CHANNEL_IBSS) &&
+                                 !(eeprom_ch_info[ch].
+                                   flags & EEPROM_CHANNEL_RADAR)) ? "" :
+                                "not ");
+
+                       ch_info++;
+               }
+       }
+
+       /* Check if we do have HT40 channels */
+       if (il->cfg->regulatory_bands[5] == EEPROM_REGULATORY_BAND_NO_HT40 &&
+           il->cfg->regulatory_bands[6] == EEPROM_REGULATORY_BAND_NO_HT40)
+               return 0;
+
+       /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
+       for (band = 6; band <= 7; band++) {
+               enum ieee80211_band ieeeband;
+
+               il_init_band_reference(il, band, &eeprom_ch_count,
+                                      &eeprom_ch_info, &eeprom_ch_idx);
+
+               /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
+               ieeeband =
+                   (band == 6) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+
+               /* Loop through each band adding each of the channels */
+               for (ch = 0; ch < eeprom_ch_count; ch++) {
+                       /* Set up driver's info for lower half */
+                       il_mod_ht40_chan_info(il, ieeeband, eeprom_ch_idx[ch],
+                                             &eeprom_ch_info[ch],
+                                             IEEE80211_CHAN_NO_HT40PLUS);
+
+                       /* Set up driver's info for upper half */
+                       il_mod_ht40_chan_info(il, ieeeband,
+                                             eeprom_ch_idx[ch] + 4,
+                                             &eeprom_ch_info[ch],
+                                             IEEE80211_CHAN_NO_HT40MINUS);
+               }
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL(il_init_channel_map);
+
+/*
+ * il_free_channel_map - undo allocations in il_init_channel_map
+ */
+void
+il_free_channel_map(struct il_priv *il)
+{
+       kfree(il->channel_info);
+       il->channel_count = 0;
+}
+EXPORT_SYMBOL(il_free_channel_map);
+
+/**
+ * il_get_channel_info - Find driver's ilate channel info
+ *
+ * Based on band and channel number.
+ */
+const struct il_channel_info *
+il_get_channel_info(const struct il_priv *il, enum ieee80211_band band,
+                   u16 channel)
+{
+       int i;
+
+       switch (band) {
+       case IEEE80211_BAND_5GHZ:
+               for (i = 14; i < il->channel_count; i++) {
+                       if (il->channel_info[i].channel == channel)
+                               return &il->channel_info[i];
+               }
+               break;
+       case IEEE80211_BAND_2GHZ:
+               if (channel >= 1 && channel <= 14)
+                       return &il->channel_info[channel - 1];
+               break;
+       default:
+               BUG();
+       }
+
+       return NULL;
+}
+EXPORT_SYMBOL(il_get_channel_info);
+
+/*
+ * Setting power level allows the card to go to sleep when not busy.
+ *
+ * We calculate a sleep command based on the required latency, which
+ * we get from mac80211.
+ */
+
+#define SLP_VEC(X0, X1, X2, X3, X4) { \
+               cpu_to_le32(X0), \
+               cpu_to_le32(X1), \
+               cpu_to_le32(X2), \
+               cpu_to_le32(X3), \
+               cpu_to_le32(X4)  \
+}
+
+static void
+il_build_powertable_cmd(struct il_priv *il, struct il_powertable_cmd *cmd)
+{
+       const __le32 interval[3][IL_POWER_VEC_SIZE] = {
+               SLP_VEC(2, 2, 4, 6, 0xFF),
+               SLP_VEC(2, 4, 7, 10, 10),
+               SLP_VEC(4, 7, 10, 10, 0xFF)
+       };
+       int i, dtim_period, no_dtim;
+       u32 max_sleep;
+       bool skip;
+
+       memset(cmd, 0, sizeof(*cmd));
+
+       if (il->power_data.pci_pm)
+               cmd->flags |= IL_POWER_PCI_PM_MSK;
+
+       /* if no Power Save, we are done */
+       if (il->power_data.ps_disabled)
+               return;
+
+       cmd->flags = IL_POWER_DRIVER_ALLOW_SLEEP_MSK;
+       cmd->keep_alive_seconds = 0;
+       cmd->debug_flags = 0;
+       cmd->rx_data_timeout = cpu_to_le32(25 * 1024);
+       cmd->tx_data_timeout = cpu_to_le32(25 * 1024);
+       cmd->keep_alive_beacons = 0;
+
+       dtim_period = il->vif ? il->vif->bss_conf.dtim_period : 0;
+
+       if (dtim_period <= 2) {
+               memcpy(cmd->sleep_interval, interval[0], sizeof(interval[0]));
+               no_dtim = 2;
+       } else if (dtim_period <= 10) {
+               memcpy(cmd->sleep_interval, interval[1], sizeof(interval[1]));
+               no_dtim = 2;
+       } else {
+               memcpy(cmd->sleep_interval, interval[2], sizeof(interval[2]));
+               no_dtim = 0;
+       }
+
+       if (dtim_period == 0) {
+               dtim_period = 1;
+               skip = false;
+       } else {
+               skip = !!no_dtim;
+       }
+
+       if (skip) {
+               __le32 tmp = cmd->sleep_interval[IL_POWER_VEC_SIZE - 1];
+
+               max_sleep = le32_to_cpu(tmp);
+               if (max_sleep == 0xFF)
+                       max_sleep = dtim_period * (skip + 1);
+               else if (max_sleep >  dtim_period)
+                       max_sleep = (max_sleep / dtim_period) * dtim_period;
+               cmd->flags |= IL_POWER_SLEEP_OVER_DTIM_MSK;
+       } else {
+               max_sleep = dtim_period;
+               cmd->flags &= ~IL_POWER_SLEEP_OVER_DTIM_MSK;
+       }
+
+       for (i = 0; i < IL_POWER_VEC_SIZE; i++)
+               if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep)
+                       cmd->sleep_interval[i] = cpu_to_le32(max_sleep);
+}
+
+static int
+il_set_power(struct il_priv *il, struct il_powertable_cmd *cmd)
+{
+       D_POWER("Sending power/sleep command\n");
+       D_POWER("Flags value = 0x%08X\n", cmd->flags);
+       D_POWER("Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
+       D_POWER("Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
+       D_POWER("Sleep interval vector = { %d , %d , %d , %d , %d }\n",
+               le32_to_cpu(cmd->sleep_interval[0]),
+               le32_to_cpu(cmd->sleep_interval[1]),
+               le32_to_cpu(cmd->sleep_interval[2]),
+               le32_to_cpu(cmd->sleep_interval[3]),
+               le32_to_cpu(cmd->sleep_interval[4]));
+
+       return il_send_cmd_pdu(il, C_POWER_TBL,
+                              sizeof(struct il_powertable_cmd), cmd);
+}
+
+static int
+il_power_set_mode(struct il_priv *il, struct il_powertable_cmd *cmd, bool force)
+{
+       int ret;
+       bool update_chains;
+
+       lockdep_assert_held(&il->mutex);
+
+       /* Don't update the RX chain when chain noise calibration is running */
+       update_chains = il->chain_noise_data.state == IL_CHAIN_NOISE_DONE ||
+           il->chain_noise_data.state == IL_CHAIN_NOISE_ALIVE;
+
+       if (!memcmp(&il->power_data.sleep_cmd, cmd, sizeof(*cmd)) && !force)
+               return 0;
+
+       if (!il_is_ready_rf(il))
+               return -EIO;
+
+       /* scan complete use sleep_power_next, need to be updated */
+       memcpy(&il->power_data.sleep_cmd_next, cmd, sizeof(*cmd));
+       if (test_bit(S_SCANNING, &il->status) && !force) {
+               D_INFO("Defer power set mode while scanning\n");
+               return 0;
+       }
+
+       if (cmd->flags & IL_POWER_DRIVER_ALLOW_SLEEP_MSK)
+               set_bit(S_POWER_PMI, &il->status);
+
+       ret = il_set_power(il, cmd);
+       if (!ret) {
+               if (!(cmd->flags & IL_POWER_DRIVER_ALLOW_SLEEP_MSK))
+                       clear_bit(S_POWER_PMI, &il->status);
+
+               if (il->ops->update_chain_flags && update_chains)
+                       il->ops->update_chain_flags(il);
+               else if (il->ops->update_chain_flags)
+                       D_POWER("Cannot update the power, chain noise "
+                               "calibration running: %d\n",
+                               il->chain_noise_data.state);
+
+               memcpy(&il->power_data.sleep_cmd, cmd, sizeof(*cmd));
+       } else
+               IL_ERR("set power fail, ret = %d", ret);
+
+       return ret;
+}
+
+int
+il_power_update_mode(struct il_priv *il, bool force)
+{
+       struct il_powertable_cmd cmd;
+
+       il_build_powertable_cmd(il, &cmd);
+
+       return il_power_set_mode(il, &cmd, force);
+}
+EXPORT_SYMBOL(il_power_update_mode);
+
+/* initialize to default */
+void
+il_power_initialize(struct il_priv *il)
+{
+       u16 lctl;
+
+       pcie_capability_read_word(il->pci_dev, PCI_EXP_LNKCTL, &lctl);
+       il->power_data.pci_pm = !(lctl & PCI_EXP_LNKCTL_ASPM_L0S);
+
+       il->power_data.debug_sleep_level_override = -1;
+
+       memset(&il->power_data.sleep_cmd, 0, sizeof(il->power_data.sleep_cmd));
+}
+EXPORT_SYMBOL(il_power_initialize);
+
+/* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
+ * sending probe req.  This should be set long enough to hear probe responses
+ * from more than one AP.  */
+#define IL_ACTIVE_DWELL_TIME_24    (30)        /* all times in msec */
+#define IL_ACTIVE_DWELL_TIME_52    (20)
+
+#define IL_ACTIVE_DWELL_FACTOR_24GHZ (3)
+#define IL_ACTIVE_DWELL_FACTOR_52GHZ (2)
+
+/* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
+ * Must be set longer than active dwell time.
+ * For the most reliable scan, set > AP beacon interval (typically 100msec). */
+#define IL_PASSIVE_DWELL_TIME_24   (20)        /* all times in msec */
+#define IL_PASSIVE_DWELL_TIME_52   (10)
+#define IL_PASSIVE_DWELL_BASE      (100)
+#define IL_CHANNEL_TUNE_TIME       5
+
+static int
+il_send_scan_abort(struct il_priv *il)
+{
+       int ret;
+       struct il_rx_pkt *pkt;
+       struct il_host_cmd cmd = {
+               .id = C_SCAN_ABORT,
+               .flags = CMD_WANT_SKB,
+       };
+
+       /* Exit instantly with error when device is not ready
+        * to receive scan abort command or it does not perform
+        * hardware scan currently */
+       if (!test_bit(S_READY, &il->status) ||
+           !test_bit(S_GEO_CONFIGURED, &il->status) ||
+           !test_bit(S_SCAN_HW, &il->status) ||
+           test_bit(S_FW_ERROR, &il->status) ||
+           test_bit(S_EXIT_PENDING, &il->status))
+               return -EIO;
+
+       ret = il_send_cmd_sync(il, &cmd);
+       if (ret)
+               return ret;
+
+       pkt = (struct il_rx_pkt *)cmd.reply_page;
+       if (pkt->u.status != CAN_ABORT_STATUS) {
+               /* The scan abort will return 1 for success or
+                * 2 for "failure".  A failure condition can be
+                * due to simply not being in an active scan which
+                * can occur if we send the scan abort before we
+                * the microcode has notified us that a scan is
+                * completed. */
+               D_SCAN("SCAN_ABORT ret %d.\n", pkt->u.status);
+               ret = -EIO;
+       }
+
+       il_free_pages(il, cmd.reply_page);
+       return ret;
+}
+
+static void
+il_complete_scan(struct il_priv *il, bool aborted)
+{
+       /* check if scan was requested from mac80211 */
+       if (il->scan_request) {
+               D_SCAN("Complete scan in mac80211\n");
+               ieee80211_scan_completed(il->hw, aborted);
+       }
+
+       il->scan_vif = NULL;
+       il->scan_request = NULL;
+}
+
+void
+il_force_scan_end(struct il_priv *il)
+{
+       lockdep_assert_held(&il->mutex);
+
+       if (!test_bit(S_SCANNING, &il->status)) {
+               D_SCAN("Forcing scan end while not scanning\n");
+               return;
+       }
+
+       D_SCAN("Forcing scan end\n");
+       clear_bit(S_SCANNING, &il->status);
+       clear_bit(S_SCAN_HW, &il->status);
+       clear_bit(S_SCAN_ABORTING, &il->status);
+       il_complete_scan(il, true);
+}
+
+static void
+il_do_scan_abort(struct il_priv *il)
+{
+       int ret;
+
+       lockdep_assert_held(&il->mutex);
+
+       if (!test_bit(S_SCANNING, &il->status)) {
+               D_SCAN("Not performing scan to abort\n");
+               return;
+       }
+
+       if (test_and_set_bit(S_SCAN_ABORTING, &il->status)) {
+               D_SCAN("Scan abort in progress\n");
+               return;
+       }
+
+       ret = il_send_scan_abort(il);
+       if (ret) {
+               D_SCAN("Send scan abort failed %d\n", ret);
+               il_force_scan_end(il);
+       } else
+               D_SCAN("Successfully send scan abort\n");
+}
+
+/**
+ * il_scan_cancel - Cancel any currently executing HW scan
+ */
+int
+il_scan_cancel(struct il_priv *il)
+{
+       D_SCAN("Queuing abort scan\n");
+       queue_work(il->workqueue, &il->abort_scan);
+       return 0;
+}
+EXPORT_SYMBOL(il_scan_cancel);
+
+/**
+ * il_scan_cancel_timeout - Cancel any currently executing HW scan
+ * @ms: amount of time to wait (in milliseconds) for scan to abort
+ *
+ */
+int
+il_scan_cancel_timeout(struct il_priv *il, unsigned long ms)
+{
+       unsigned long timeout = jiffies + msecs_to_jiffies(ms);
+
+       lockdep_assert_held(&il->mutex);
+
+       D_SCAN("Scan cancel timeout\n");
+
+       il_do_scan_abort(il);
+
+       while (time_before_eq(jiffies, timeout)) {
+               if (!test_bit(S_SCAN_HW, &il->status))
+                       break;
+               msleep(20);
+       }
+
+       return test_bit(S_SCAN_HW, &il->status);
+}
+EXPORT_SYMBOL(il_scan_cancel_timeout);
+
+/* Service response to C_SCAN (0x80) */
+static void
+il_hdl_scan(struct il_priv *il, struct il_rx_buf *rxb)
+{
+#ifdef CONFIG_IWLEGACY_DEBUG
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_scanreq_notification *notif =
+           (struct il_scanreq_notification *)pkt->u.raw;
+
+       D_SCAN("Scan request status = 0x%x\n", notif->status);
+#endif
+}
+
+/* Service N_SCAN_START (0x82) */
+static void
+il_hdl_scan_start(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_scanstart_notification *notif =
+           (struct il_scanstart_notification *)pkt->u.raw;
+       il->scan_start_tsf = le32_to_cpu(notif->tsf_low);
+       D_SCAN("Scan start: " "%d [802.11%s] "
+              "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n", notif->channel,
+              notif->band ? "bg" : "a", le32_to_cpu(notif->tsf_high),
+              le32_to_cpu(notif->tsf_low), notif->status, notif->beacon_timer);
+}
+
+/* Service N_SCAN_RESULTS (0x83) */
+static void
+il_hdl_scan_results(struct il_priv *il, struct il_rx_buf *rxb)
+{
+#ifdef CONFIG_IWLEGACY_DEBUG
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_scanresults_notification *notif =
+           (struct il_scanresults_notification *)pkt->u.raw;
+
+       D_SCAN("Scan ch.res: " "%d [802.11%s] " "(TSF: 0x%08X:%08X) - %d "
+              "elapsed=%lu usec\n", notif->channel, notif->band ? "bg" : "a",
+              le32_to_cpu(notif->tsf_high), le32_to_cpu(notif->tsf_low),
+              le32_to_cpu(notif->stats[0]),
+              le32_to_cpu(notif->tsf_low) - il->scan_start_tsf);
+#endif
+}
+
+/* Service N_SCAN_COMPLETE (0x84) */
+static void
+il_hdl_scan_complete(struct il_priv *il, struct il_rx_buf *rxb)
+{
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
+#endif
+
+       D_SCAN("Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
+              scan_notif->scanned_channels, scan_notif->tsf_low,
+              scan_notif->tsf_high, scan_notif->status);
+
+       /* The HW is no longer scanning */
+       clear_bit(S_SCAN_HW, &il->status);
+
+       D_SCAN("Scan on %sGHz took %dms\n",
+              (il->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
+              jiffies_to_msecs(jiffies - il->scan_start));
+
+       queue_work(il->workqueue, &il->scan_completed);
+}
+
+void
+il_setup_rx_scan_handlers(struct il_priv *il)
+{
+       /* scan handlers */
+       il->handlers[C_SCAN] = il_hdl_scan;
+       il->handlers[N_SCAN_START] = il_hdl_scan_start;
+       il->handlers[N_SCAN_RESULTS] = il_hdl_scan_results;
+       il->handlers[N_SCAN_COMPLETE] = il_hdl_scan_complete;
+}
+EXPORT_SYMBOL(il_setup_rx_scan_handlers);
+
+u16
+il_get_active_dwell_time(struct il_priv *il, enum ieee80211_band band,
+                        u8 n_probes)
+{
+       if (band == IEEE80211_BAND_5GHZ)
+               return IL_ACTIVE_DWELL_TIME_52 +
+                   IL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
+       else
+               return IL_ACTIVE_DWELL_TIME_24 +
+                   IL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
+}
+EXPORT_SYMBOL(il_get_active_dwell_time);
+
+u16
+il_get_passive_dwell_time(struct il_priv *il, enum ieee80211_band band,
+                         struct ieee80211_vif *vif)
+{
+       u16 value;
+
+       u16 passive =
+           (band ==
+            IEEE80211_BAND_2GHZ) ? IL_PASSIVE_DWELL_BASE +
+           IL_PASSIVE_DWELL_TIME_24 : IL_PASSIVE_DWELL_BASE +
+           IL_PASSIVE_DWELL_TIME_52;
+
+       if (il_is_any_associated(il)) {
+               /*
+                * If we're associated, we clamp the maximum passive
+                * dwell time to be 98% of the smallest beacon interval
+                * (minus 2 * channel tune time)
+                */
+               value = il->vif ? il->vif->bss_conf.beacon_int : 0;
+               if (value > IL_PASSIVE_DWELL_BASE || !value)
+                       value = IL_PASSIVE_DWELL_BASE;
+               value = (value * 98) / 100 - IL_CHANNEL_TUNE_TIME * 2;
+               passive = min(value, passive);
+       }
+
+       return passive;
+}
+EXPORT_SYMBOL(il_get_passive_dwell_time);
+
+void
+il_init_scan_params(struct il_priv *il)
+{
+       u8 ant_idx = fls(il->hw_params.valid_tx_ant) - 1;
+       if (!il->scan_tx_ant[IEEE80211_BAND_5GHZ])
+               il->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
+       if (!il->scan_tx_ant[IEEE80211_BAND_2GHZ])
+               il->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
+}
+EXPORT_SYMBOL(il_init_scan_params);
+
+static int
+il_scan_initiate(struct il_priv *il, struct ieee80211_vif *vif)
+{
+       int ret;
+
+       lockdep_assert_held(&il->mutex);
+
+       cancel_delayed_work(&il->scan_check);
+
+       if (!il_is_ready_rf(il)) {
+               IL_WARN("Request scan called when driver not ready.\n");
+               return -EIO;
+       }
+
+       if (test_bit(S_SCAN_HW, &il->status)) {
+               D_SCAN("Multiple concurrent scan requests in parallel.\n");
+               return -EBUSY;
+       }
+
+       if (test_bit(S_SCAN_ABORTING, &il->status)) {
+               D_SCAN("Scan request while abort pending.\n");
+               return -EBUSY;
+       }
+
+       D_SCAN("Starting scan...\n");
+
+       set_bit(S_SCANNING, &il->status);
+       il->scan_start = jiffies;
+
+       ret = il->ops->request_scan(il, vif);
+       if (ret) {
+               clear_bit(S_SCANNING, &il->status);
+               return ret;
+       }
+
+       queue_delayed_work(il->workqueue, &il->scan_check,
+                          IL_SCAN_CHECK_WATCHDOG);
+
+       return 0;
+}
+
+int
+il_mac_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+              struct ieee80211_scan_request *hw_req)
+{
+       struct cfg80211_scan_request *req = &hw_req->req;
+       struct il_priv *il = hw->priv;
+       int ret;
+
+       if (req->n_channels == 0) {
+               IL_ERR("Can not scan on no channels.\n");
+               return -EINVAL;
+       }
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter\n");
+
+       if (test_bit(S_SCANNING, &il->status)) {
+               D_SCAN("Scan already in progress.\n");
+               ret = -EAGAIN;
+               goto out_unlock;
+       }
+
+       /* mac80211 will only ask for one band at a time */
+       il->scan_request = req;
+       il->scan_vif = vif;
+       il->scan_band = req->channels[0]->band;
+
+       ret = il_scan_initiate(il, vif);
+
+out_unlock:
+       D_MAC80211("leave ret %d\n", ret);
+       mutex_unlock(&il->mutex);
+
+       return ret;
+}
+EXPORT_SYMBOL(il_mac_hw_scan);
+
+static void
+il_bg_scan_check(struct work_struct *data)
+{
+       struct il_priv *il =
+           container_of(data, struct il_priv, scan_check.work);
+
+       D_SCAN("Scan check work\n");
+
+       /* Since we are here firmware does not finish scan and
+        * most likely is in bad shape, so we don't bother to
+        * send abort command, just force scan complete to mac80211 */
+       mutex_lock(&il->mutex);
+       il_force_scan_end(il);
+       mutex_unlock(&il->mutex);
+}
+
+/**
+ * il_fill_probe_req - fill in all required fields and IE for probe request
+ */
+
+u16
+il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
+                 const u8 *ta, const u8 *ies, int ie_len, int left)
+{
+       int len = 0;
+       u8 *pos = NULL;
+
+       /* Make sure there is enough space for the probe request,
+        * two mandatory IEs and the data */
+       left -= 24;
+       if (left < 0)
+               return 0;
+
+       frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
+       eth_broadcast_addr(frame->da);
+       memcpy(frame->sa, ta, ETH_ALEN);
+       eth_broadcast_addr(frame->bssid);
+       frame->seq_ctrl = 0;
+
+       len += 24;
+
+       /* ...next IE... */
+       pos = &frame->u.probe_req.variable[0];
+
+       /* fill in our indirect SSID IE */
+       left -= 2;
+       if (left < 0)
+               return 0;
+       *pos++ = WLAN_EID_SSID;
+       *pos++ = 0;
+
+       len += 2;
+
+       if (WARN_ON(left < ie_len))
+               return len;
+
+       if (ies && ie_len) {
+               memcpy(pos, ies, ie_len);
+               len += ie_len;
+       }
+
+       return (u16) len;
+}
+EXPORT_SYMBOL(il_fill_probe_req);
+
+static void
+il_bg_abort_scan(struct work_struct *work)
+{
+       struct il_priv *il = container_of(work, struct il_priv, abort_scan);
+
+       D_SCAN("Abort scan work\n");
+
+       /* We keep scan_check work queued in case when firmware will not
+        * report back scan completed notification */
+       mutex_lock(&il->mutex);
+       il_scan_cancel_timeout(il, 200);
+       mutex_unlock(&il->mutex);
+}
+
+static void
+il_bg_scan_completed(struct work_struct *work)
+{
+       struct il_priv *il = container_of(work, struct il_priv, scan_completed);
+       bool aborted;
+
+       D_SCAN("Completed scan.\n");
+
+       cancel_delayed_work(&il->scan_check);
+
+       mutex_lock(&il->mutex);
+
+       aborted = test_and_clear_bit(S_SCAN_ABORTING, &il->status);
+       if (aborted)
+               D_SCAN("Aborted scan completed.\n");
+
+       if (!test_and_clear_bit(S_SCANNING, &il->status)) {
+               D_SCAN("Scan already completed.\n");
+               goto out_settings;
+       }
+
+       il_complete_scan(il, aborted);
+
+out_settings:
+       /* Can we still talk to firmware ? */
+       if (!il_is_ready_rf(il))
+               goto out;
+
+       /*
+        * We do not commit power settings while scan is pending,
+        * do it now if the settings changed.
+        */
+       il_power_set_mode(il, &il->power_data.sleep_cmd_next, false);
+       il_set_tx_power(il, il->tx_power_next, false);
+
+       il->ops->post_scan(il);
+
+out:
+       mutex_unlock(&il->mutex);
+}
+
+void
+il_setup_scan_deferred_work(struct il_priv *il)
+{
+       INIT_WORK(&il->scan_completed, il_bg_scan_completed);
+       INIT_WORK(&il->abort_scan, il_bg_abort_scan);
+       INIT_DELAYED_WORK(&il->scan_check, il_bg_scan_check);
+}
+EXPORT_SYMBOL(il_setup_scan_deferred_work);
+
+void
+il_cancel_scan_deferred_work(struct il_priv *il)
+{
+       cancel_work_sync(&il->abort_scan);
+       cancel_work_sync(&il->scan_completed);
+
+       if (cancel_delayed_work_sync(&il->scan_check)) {
+               mutex_lock(&il->mutex);
+               il_force_scan_end(il);
+               mutex_unlock(&il->mutex);
+       }
+}
+EXPORT_SYMBOL(il_cancel_scan_deferred_work);
+
+/* il->sta_lock must be held */
+static void
+il_sta_ucode_activate(struct il_priv *il, u8 sta_id)
+{
+
+       if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE))
+               IL_ERR("ACTIVATE a non DRIVER active station id %u addr %pM\n",
+                      sta_id, il->stations[sta_id].sta.sta.addr);
+
+       if (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) {
+               D_ASSOC("STA id %u addr %pM already present"
+                       " in uCode (according to driver)\n", sta_id,
+                       il->stations[sta_id].sta.sta.addr);
+       } else {
+               il->stations[sta_id].used |= IL_STA_UCODE_ACTIVE;
+               D_ASSOC("Added STA id %u addr %pM to uCode\n", sta_id,
+                       il->stations[sta_id].sta.sta.addr);
+       }
+}
+
+static int
+il_process_add_sta_resp(struct il_priv *il, struct il_addsta_cmd *addsta,
+                       struct il_rx_pkt *pkt, bool sync)
+{
+       u8 sta_id = addsta->sta.sta_id;
+       unsigned long flags;
+       int ret = -EIO;
+
+       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
+               IL_ERR("Bad return from C_ADD_STA (0x%08X)\n", pkt->hdr.flags);
+               return ret;
+       }
+
+       D_INFO("Processing response for adding station %u\n", sta_id);
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+
+       switch (pkt->u.add_sta.status) {
+       case ADD_STA_SUCCESS_MSK:
+               D_INFO("C_ADD_STA PASSED\n");
+               il_sta_ucode_activate(il, sta_id);
+               ret = 0;
+               break;
+       case ADD_STA_NO_ROOM_IN_TBL:
+               IL_ERR("Adding station %d failed, no room in table.\n", sta_id);
+               break;
+       case ADD_STA_NO_BLOCK_ACK_RESOURCE:
+               IL_ERR("Adding station %d failed, no block ack resource.\n",
+                      sta_id);
+               break;
+       case ADD_STA_MODIFY_NON_EXIST_STA:
+               IL_ERR("Attempting to modify non-existing station %d\n",
+                      sta_id);
+               break;
+       default:
+               D_ASSOC("Received C_ADD_STA:(0x%08X)\n", pkt->u.add_sta.status);
+               break;
+       }
+
+       D_INFO("%s station id %u addr %pM\n",
+              il->stations[sta_id].sta.mode ==
+              STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", sta_id,
+              il->stations[sta_id].sta.sta.addr);
+
+       /*
+        * XXX: The MAC address in the command buffer is often changed from
+        * the original sent to the device. That is, the MAC address
+        * written to the command buffer often is not the same MAC address
+        * read from the command buffer when the command returns. This
+        * issue has not yet been resolved and this debugging is left to
+        * observe the problem.
+        */
+       D_INFO("%s station according to cmd buffer %pM\n",
+              il->stations[sta_id].sta.mode ==
+              STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", addsta->sta.addr);
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return ret;
+}
+
+static void
+il_add_sta_callback(struct il_priv *il, struct il_device_cmd *cmd,
+                   struct il_rx_pkt *pkt)
+{
+       struct il_addsta_cmd *addsta = (struct il_addsta_cmd *)cmd->cmd.payload;
+
+       il_process_add_sta_resp(il, addsta, pkt, false);
+
+}
+
+int
+il_send_add_sta(struct il_priv *il, struct il_addsta_cmd *sta, u8 flags)
+{
+       struct il_rx_pkt *pkt = NULL;
+       int ret = 0;
+       u8 data[sizeof(*sta)];
+       struct il_host_cmd cmd = {
+               .id = C_ADD_STA,
+               .flags = flags,
+               .data = data,
+       };
+       u8 sta_id __maybe_unused = sta->sta.sta_id;
+
+       D_INFO("Adding sta %u (%pM) %ssynchronously\n", sta_id, sta->sta.addr,
+              flags & CMD_ASYNC ? "a" : "");
+
+       if (flags & CMD_ASYNC)
+               cmd.callback = il_add_sta_callback;
+       else {
+               cmd.flags |= CMD_WANT_SKB;
+               might_sleep();
+       }
+
+       cmd.len = il->ops->build_addsta_hcmd(sta, data);
+       ret = il_send_cmd(il, &cmd);
+
+       if (ret || (flags & CMD_ASYNC))
+               return ret;
+
+       if (ret == 0) {
+               pkt = (struct il_rx_pkt *)cmd.reply_page;
+               ret = il_process_add_sta_resp(il, sta, pkt, true);
+       }
+       il_free_pages(il, cmd.reply_page);
+
+       return ret;
+}
+EXPORT_SYMBOL(il_send_add_sta);
+
+static void
+il_set_ht_add_station(struct il_priv *il, u8 idx, struct ieee80211_sta *sta)
+{
+       struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->ht_cap;
+       __le32 sta_flags;
+
+       if (!sta || !sta_ht_inf->ht_supported)
+               goto done;
+
+       D_ASSOC("spatial multiplexing power save mode: %s\n",
+               (sta->smps_mode == IEEE80211_SMPS_STATIC) ? "static" :
+               (sta->smps_mode == IEEE80211_SMPS_DYNAMIC) ? "dynamic" :
+               "disabled");
+
+       sta_flags = il->stations[idx].sta.station_flags;
+
+       sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK);
+
+       switch (sta->smps_mode) {
+       case IEEE80211_SMPS_STATIC:
+               sta_flags |= STA_FLG_MIMO_DIS_MSK;
+               break;
+       case IEEE80211_SMPS_DYNAMIC:
+               sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK;
+               break;
+       case IEEE80211_SMPS_OFF:
+               break;
+       default:
+               IL_WARN("Invalid MIMO PS mode %d\n", sta->smps_mode);
+               break;
+       }
+
+       sta_flags |=
+           cpu_to_le32((u32) sta_ht_inf->
+                       ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);
+
+       sta_flags |=
+           cpu_to_le32((u32) sta_ht_inf->
+                       ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);
+
+       if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
+               sta_flags |= STA_FLG_HT40_EN_MSK;
+       else
+               sta_flags &= ~STA_FLG_HT40_EN_MSK;
+
+       il->stations[idx].sta.station_flags = sta_flags;
+done:
+       return;
+}
+
+/**
+ * il_prep_station - Prepare station information for addition
+ *
+ * should be called with sta_lock held
+ */
+u8
+il_prep_station(struct il_priv *il, const u8 *addr, bool is_ap,
+               struct ieee80211_sta *sta)
+{
+       struct il_station_entry *station;
+       int i;
+       u8 sta_id = IL_INVALID_STATION;
+       u16 rate;
+
+       if (is_ap)
+               sta_id = IL_AP_ID;
+       else if (is_broadcast_ether_addr(addr))
+               sta_id = il->hw_params.bcast_id;
+       else
+               for (i = IL_STA_ID; i < il->hw_params.max_stations; i++) {
+                       if (ether_addr_equal(il->stations[i].sta.sta.addr,
+                                            addr)) {
+                               sta_id = i;
+                               break;
+                       }
+
+                       if (!il->stations[i].used &&
+                           sta_id == IL_INVALID_STATION)
+                               sta_id = i;
+               }
+
+       /*
+        * These two conditions have the same outcome, but keep them
+        * separate
+        */
+       if (unlikely(sta_id == IL_INVALID_STATION))
+               return sta_id;
+
+       /*
+        * uCode is not able to deal with multiple requests to add a
+        * station. Keep track if one is in progress so that we do not send
+        * another.
+        */
+       if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) {
+               D_INFO("STA %d already in process of being added.\n", sta_id);
+               return sta_id;
+       }
+
+       if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) &&
+           (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) &&
+           ether_addr_equal(il->stations[sta_id].sta.sta.addr, addr)) {
+               D_ASSOC("STA %d (%pM) already added, not adding again.\n",
+                       sta_id, addr);
+               return sta_id;
+       }
+
+       station = &il->stations[sta_id];
+       station->used = IL_STA_DRIVER_ACTIVE;
+       D_ASSOC("Add STA to driver ID %d: %pM\n", sta_id, addr);
+       il->num_stations++;
+
+       /* Set up the C_ADD_STA command to send to device */
+       memset(&station->sta, 0, sizeof(struct il_addsta_cmd));
+       memcpy(station->sta.sta.addr, addr, ETH_ALEN);
+       station->sta.mode = 0;
+       station->sta.sta.sta_id = sta_id;
+       station->sta.station_flags = 0;
+
+       /*
+        * OK to call unconditionally, since local stations (IBSS BSSID
+        * STA and broadcast STA) pass in a NULL sta, and mac80211
+        * doesn't allow HT IBSS.
+        */
+       il_set_ht_add_station(il, sta_id, sta);
+
+       /* 3945 only */
+       rate = (il->band == IEEE80211_BAND_5GHZ) ? RATE_6M_PLCP : RATE_1M_PLCP;
+       /* Turn on both antennas for the station... */
+       station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK);
+
+       return sta_id;
+
+}
+EXPORT_SYMBOL_GPL(il_prep_station);
+
+#define STA_WAIT_TIMEOUT (HZ/2)
+
+/**
+ * il_add_station_common -
+ */
+int
+il_add_station_common(struct il_priv *il, const u8 *addr, bool is_ap,
+                     struct ieee80211_sta *sta, u8 *sta_id_r)
+{
+       unsigned long flags_spin;
+       int ret = 0;
+       u8 sta_id;
+       struct il_addsta_cmd sta_cmd;
+
+       *sta_id_r = 0;
+       spin_lock_irqsave(&il->sta_lock, flags_spin);
+       sta_id = il_prep_station(il, addr, is_ap, sta);
+       if (sta_id == IL_INVALID_STATION) {
+               IL_ERR("Unable to prepare station %pM for addition\n", addr);
+               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+               return -EINVAL;
+       }
+
+       /*
+        * uCode is not able to deal with multiple requests to add a
+        * station. Keep track if one is in progress so that we do not send
+        * another.
+        */
+       if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) {
+               D_INFO("STA %d already in process of being added.\n", sta_id);
+               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+               return -EEXIST;
+       }
+
+       if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) &&
+           (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) {
+               D_ASSOC("STA %d (%pM) already added, not adding again.\n",
+                       sta_id, addr);
+               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+               return -EEXIST;
+       }
+
+       il->stations[sta_id].used |= IL_STA_UCODE_INPROGRESS;
+       memcpy(&sta_cmd, &il->stations[sta_id].sta,
+              sizeof(struct il_addsta_cmd));
+       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+
+       /* Add station to device's station table */
+       ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+       if (ret) {
+               spin_lock_irqsave(&il->sta_lock, flags_spin);
+               IL_ERR("Adding station %pM failed.\n",
+                      il->stations[sta_id].sta.sta.addr);
+               il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE;
+               il->stations[sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
+               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+       }
+       *sta_id_r = sta_id;
+       return ret;
+}
+EXPORT_SYMBOL(il_add_station_common);
+
+/**
+ * il_sta_ucode_deactivate - deactivate ucode status for a station
+ *
+ * il->sta_lock must be held
+ */
+static void
+il_sta_ucode_deactivate(struct il_priv *il, u8 sta_id)
+{
+       /* Ucode must be active and driver must be non active */
+       if ((il->stations[sta_id].
+            used & (IL_STA_UCODE_ACTIVE | IL_STA_DRIVER_ACTIVE)) !=
+           IL_STA_UCODE_ACTIVE)
+               IL_ERR("removed non active STA %u\n", sta_id);
+
+       il->stations[sta_id].used &= ~IL_STA_UCODE_ACTIVE;
+
+       memset(&il->stations[sta_id], 0, sizeof(struct il_station_entry));
+       D_ASSOC("Removed STA %u\n", sta_id);
+}
+
+static int
+il_send_remove_station(struct il_priv *il, const u8 * addr, int sta_id,
+                      bool temporary)
+{
+       struct il_rx_pkt *pkt;
+       int ret;
+
+       unsigned long flags_spin;
+       struct il_rem_sta_cmd rm_sta_cmd;
+
+       struct il_host_cmd cmd = {
+               .id = C_REM_STA,
+               .len = sizeof(struct il_rem_sta_cmd),
+               .flags = CMD_SYNC,
+               .data = &rm_sta_cmd,
+       };
+
+       memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
+       rm_sta_cmd.num_sta = 1;
+       memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN);
+
+       cmd.flags |= CMD_WANT_SKB;
+
+       ret = il_send_cmd(il, &cmd);
+
+       if (ret)
+               return ret;
+
+       pkt = (struct il_rx_pkt *)cmd.reply_page;
+       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
+               IL_ERR("Bad return from C_REM_STA (0x%08X)\n", pkt->hdr.flags);
+               ret = -EIO;
+       }
+
+       if (!ret) {
+               switch (pkt->u.rem_sta.status) {
+               case REM_STA_SUCCESS_MSK:
+                       if (!temporary) {
+                               spin_lock_irqsave(&il->sta_lock, flags_spin);
+                               il_sta_ucode_deactivate(il, sta_id);
+                               spin_unlock_irqrestore(&il->sta_lock,
+                                                      flags_spin);
+                       }
+                       D_ASSOC("C_REM_STA PASSED\n");
+                       break;
+               default:
+                       ret = -EIO;
+                       IL_ERR("C_REM_STA failed\n");
+                       break;
+               }
+       }
+       il_free_pages(il, cmd.reply_page);
+
+       return ret;
+}
+
+/**
+ * il_remove_station - Remove driver's knowledge of station.
+ */
+int
+il_remove_station(struct il_priv *il, const u8 sta_id, const u8 * addr)
+{
+       unsigned long flags;
+
+       if (!il_is_ready(il)) {
+               D_INFO("Unable to remove station %pM, device not ready.\n",
+                      addr);
+               /*
+                * It is typical for stations to be removed when we are
+                * going down. Return success since device will be down
+                * soon anyway
+                */
+               return 0;
+       }
+
+       D_ASSOC("Removing STA from driver:%d  %pM\n", sta_id, addr);
+
+       if (WARN_ON(sta_id == IL_INVALID_STATION))
+               return -EINVAL;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+
+       if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE)) {
+               D_INFO("Removing %pM but non DRIVER active\n", addr);
+               goto out_err;
+       }
+
+       if (!(il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) {
+               D_INFO("Removing %pM but non UCODE active\n", addr);
+               goto out_err;
+       }
+
+       if (il->stations[sta_id].used & IL_STA_LOCAL) {
+               kfree(il->stations[sta_id].lq);
+               il->stations[sta_id].lq = NULL;
+       }
+
+       il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE;
+
+       il->num_stations--;
+
+       BUG_ON(il->num_stations < 0);
+
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+
+       return il_send_remove_station(il, addr, sta_id, false);
+out_err:
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+       return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(il_remove_station);
+
+/**
+ * il_clear_ucode_stations - clear ucode station table bits
+ *
+ * This function clears all the bits in the driver indicating
+ * which stations are active in the ucode. Call when something
+ * other than explicit station management would cause this in
+ * the ucode, e.g. unassociated RXON.
+ */
+void
+il_clear_ucode_stations(struct il_priv *il)
+{
+       int i;
+       unsigned long flags_spin;
+       bool cleared = false;
+
+       D_INFO("Clearing ucode stations in driver\n");
+
+       spin_lock_irqsave(&il->sta_lock, flags_spin);
+       for (i = 0; i < il->hw_params.max_stations; i++) {
+               if (il->stations[i].used & IL_STA_UCODE_ACTIVE) {
+                       D_INFO("Clearing ucode active for station %d\n", i);
+                       il->stations[i].used &= ~IL_STA_UCODE_ACTIVE;
+                       cleared = true;
+               }
+       }
+       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+
+       if (!cleared)
+               D_INFO("No active stations found to be cleared\n");
+}
+EXPORT_SYMBOL(il_clear_ucode_stations);
+
+/**
+ * il_restore_stations() - Restore driver known stations to device
+ *
+ * All stations considered active by driver, but not present in ucode, is
+ * restored.
+ *
+ * Function sleeps.
+ */
+void
+il_restore_stations(struct il_priv *il)
+{
+       struct il_addsta_cmd sta_cmd;
+       struct il_link_quality_cmd lq;
+       unsigned long flags_spin;
+       int i;
+       bool found = false;
+       int ret;
+       bool send_lq;
+
+       if (!il_is_ready(il)) {
+               D_INFO("Not ready yet, not restoring any stations.\n");
+               return;
+       }
+
+       D_ASSOC("Restoring all known stations ... start.\n");
+       spin_lock_irqsave(&il->sta_lock, flags_spin);
+       for (i = 0; i < il->hw_params.max_stations; i++) {
+               if ((il->stations[i].used & IL_STA_DRIVER_ACTIVE) &&
+                   !(il->stations[i].used & IL_STA_UCODE_ACTIVE)) {
+                       D_ASSOC("Restoring sta %pM\n",
+                               il->stations[i].sta.sta.addr);
+                       il->stations[i].sta.mode = 0;
+                       il->stations[i].used |= IL_STA_UCODE_INPROGRESS;
+                       found = true;
+               }
+       }
+
+       for (i = 0; i < il->hw_params.max_stations; i++) {
+               if ((il->stations[i].used & IL_STA_UCODE_INPROGRESS)) {
+                       memcpy(&sta_cmd, &il->stations[i].sta,
+                              sizeof(struct il_addsta_cmd));
+                       send_lq = false;
+                       if (il->stations[i].lq) {
+                               memcpy(&lq, il->stations[i].lq,
+                                      sizeof(struct il_link_quality_cmd));
+                               send_lq = true;
+                       }
+                       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+                       ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC);
+                       if (ret) {
+                               spin_lock_irqsave(&il->sta_lock, flags_spin);
+                               IL_ERR("Adding station %pM failed.\n",
+                                      il->stations[i].sta.sta.addr);
+                               il->stations[i].used &= ~IL_STA_DRIVER_ACTIVE;
+                               il->stations[i].used &=
+                                   ~IL_STA_UCODE_INPROGRESS;
+                               spin_unlock_irqrestore(&il->sta_lock,
+                                                      flags_spin);
+                       }
+                       /*
+                        * Rate scaling has already been initialized, send
+                        * current LQ command
+                        */
+                       if (send_lq)
+                               il_send_lq_cmd(il, &lq, CMD_SYNC, true);
+                       spin_lock_irqsave(&il->sta_lock, flags_spin);
+                       il->stations[i].used &= ~IL_STA_UCODE_INPROGRESS;
+               }
+       }
+
+       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+       if (!found)
+               D_INFO("Restoring all known stations"
+                      " .... no stations to be restored.\n");
+       else
+               D_INFO("Restoring all known stations" " .... complete.\n");
+}
+EXPORT_SYMBOL(il_restore_stations);
+
+int
+il_get_free_ucode_key_idx(struct il_priv *il)
+{
+       int i;
+
+       for (i = 0; i < il->sta_key_max_num; i++)
+               if (!test_and_set_bit(i, &il->ucode_key_table))
+                       return i;
+
+       return WEP_INVALID_OFFSET;
+}
+EXPORT_SYMBOL(il_get_free_ucode_key_idx);
+
+void
+il_dealloc_bcast_stations(struct il_priv *il)
+{
+       unsigned long flags;
+       int i;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       for (i = 0; i < il->hw_params.max_stations; i++) {
+               if (!(il->stations[i].used & IL_STA_BCAST))
+                       continue;
+
+               il->stations[i].used &= ~IL_STA_UCODE_ACTIVE;
+               il->num_stations--;
+               BUG_ON(il->num_stations < 0);
+               kfree(il->stations[i].lq);
+               il->stations[i].lq = NULL;
+       }
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+}
+EXPORT_SYMBOL_GPL(il_dealloc_bcast_stations);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+static void
+il_dump_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq)
+{
+       int i;
+       D_RATE("lq station id 0x%x\n", lq->sta_id);
+       D_RATE("lq ant 0x%X 0x%X\n", lq->general_params.single_stream_ant_msk,
+              lq->general_params.dual_stream_ant_msk);
+
+       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
+               D_RATE("lq idx %d 0x%X\n", i, lq->rs_table[i].rate_n_flags);
+}
+#else
+static inline void
+il_dump_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq)
+{
+}
+#endif
+
+/**
+ * il_is_lq_table_valid() - Test one aspect of LQ cmd for validity
+ *
+ * It sometimes happens when a HT rate has been in use and we
+ * loose connectivity with AP then mac80211 will first tell us that the
+ * current channel is not HT anymore before removing the station. In such a
+ * scenario the RXON flags will be updated to indicate we are not
+ * communicating HT anymore, but the LQ command may still contain HT rates.
+ * Test for this to prevent driver from sending LQ command between the time
+ * RXON flags are updated and when LQ command is updated.
+ */
+static bool
+il_is_lq_table_valid(struct il_priv *il, struct il_link_quality_cmd *lq)
+{
+       int i;
+
+       if (il->ht.enabled)
+               return true;
+
+       D_INFO("Channel %u is not an HT channel\n", il->active.channel);
+       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
+               if (le32_to_cpu(lq->rs_table[i].rate_n_flags) & RATE_MCS_HT_MSK) {
+                       D_INFO("idx %d of LQ expects HT channel\n", i);
+                       return false;
+               }
+       }
+       return true;
+}
+
+/**
+ * il_send_lq_cmd() - Send link quality command
+ * @init: This command is sent as part of station initialization right
+ *        after station has been added.
+ *
+ * The link quality command is sent as the last step of station creation.
+ * This is the special case in which init is set and we call a callback in
+ * this case to clear the state indicating that station creation is in
+ * progress.
+ */
+int
+il_send_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq,
+              u8 flags, bool init)
+{
+       int ret = 0;
+       unsigned long flags_spin;
+
+       struct il_host_cmd cmd = {
+               .id = C_TX_LINK_QUALITY_CMD,
+               .len = sizeof(struct il_link_quality_cmd),
+               .flags = flags,
+               .data = lq,
+       };
+
+       if (WARN_ON(lq->sta_id == IL_INVALID_STATION))
+               return -EINVAL;
+
+       spin_lock_irqsave(&il->sta_lock, flags_spin);
+       if (!(il->stations[lq->sta_id].used & IL_STA_DRIVER_ACTIVE)) {
+               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+               return -EINVAL;
+       }
+       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+
+       il_dump_lq_cmd(il, lq);
+       BUG_ON(init && (cmd.flags & CMD_ASYNC));
+
+       if (il_is_lq_table_valid(il, lq))
+               ret = il_send_cmd(il, &cmd);
+       else
+               ret = -EINVAL;
+
+       if (cmd.flags & CMD_ASYNC)
+               return ret;
+
+       if (init) {
+               D_INFO("init LQ command complete,"
+                      " clearing sta addition status for sta %d\n",
+                      lq->sta_id);
+               spin_lock_irqsave(&il->sta_lock, flags_spin);
+               il->stations[lq->sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
+               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
+       }
+       return ret;
+}
+EXPORT_SYMBOL(il_send_lq_cmd);
+
+int
+il_mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                 struct ieee80211_sta *sta)
+{
+       struct il_priv *il = hw->priv;
+       struct il_station_priv_common *sta_common = (void *)sta->drv_priv;
+       int ret;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter station %pM\n", sta->addr);
+
+       ret = il_remove_station(il, sta_common->sta_id, sta->addr);
+       if (ret)
+               IL_ERR("Error removing station %pM\n", sta->addr);
+
+       D_MAC80211("leave ret %d\n", ret);
+       mutex_unlock(&il->mutex);
+
+       return ret;
+}
+EXPORT_SYMBOL(il_mac_sta_remove);
+
+/************************** RX-FUNCTIONS ****************************/
+/*
+ * Rx theory of operation
+ *
+ * Driver allocates a circular buffer of Receive Buffer Descriptors (RBDs),
+ * each of which point to Receive Buffers to be filled by the NIC.  These get
+ * used not only for Rx frames, but for any command response or notification
+ * from the NIC.  The driver and NIC manage the Rx buffers by means
+ * of idxes into the circular buffer.
+ *
+ * Rx Queue Indexes
+ * The host/firmware share two idx registers for managing the Rx buffers.
+ *
+ * The READ idx maps to the first position that the firmware may be writing
+ * to -- the driver can read up to (but not including) this position and get
+ * good data.
+ * The READ idx is managed by the firmware once the card is enabled.
+ *
+ * The WRITE idx maps to the last position the driver has read from -- the
+ * position preceding WRITE is the last slot the firmware can place a packet.
+ *
+ * The queue is empty (no good data) if WRITE = READ - 1, and is full if
+ * WRITE = READ.
+ *
+ * During initialization, the host sets up the READ queue position to the first
+ * IDX position, and WRITE to the last (READ - 1 wrapped)
+ *
+ * When the firmware places a packet in a buffer, it will advance the READ idx
+ * and fire the RX interrupt.  The driver can then query the READ idx and
+ * process as many packets as possible, moving the WRITE idx forward as it
+ * resets the Rx queue buffers with new memory.
+ *
+ * The management in the driver is as follows:
+ * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free.  When
+ *   iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
+ *   to replenish the iwl->rxq->rx_free.
+ * + In il_rx_replenish (scheduled) if 'processed' != 'read' then the
+ *   iwl->rxq is replenished and the READ IDX is updated (updating the
+ *   'processed' and 'read' driver idxes as well)
+ * + A received packet is processed and handed to the kernel network stack,
+ *   detached from the iwl->rxq.  The driver 'processed' idx is updated.
+ * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
+ *   list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
+ *   IDX is not incremented and iwl->status(RX_STALLED) is set.  If there
+ *   were enough free buffers and RX_STALLED is set it is cleared.
+ *
+ *
+ * Driver sequence:
+ *
+ * il_rx_queue_alloc()   Allocates rx_free
+ * il_rx_replenish()     Replenishes rx_free list from rx_used, and calls
+ *                            il_rx_queue_restock
+ * il_rx_queue_restock() Moves available buffers from rx_free into Rx
+ *                            queue, updates firmware pointers, and updates
+ *                            the WRITE idx.  If insufficient rx_free buffers
+ *                            are available, schedules il_rx_replenish
+ *
+ * -- enable interrupts --
+ * ISR - il_rx()         Detach il_rx_bufs from pool up to the
+ *                            READ IDX, detaching the SKB from the pool.
+ *                            Moves the packet buffer from queue to rx_used.
+ *                            Calls il_rx_queue_restock to refill any empty
+ *                            slots.
+ * ...
+ *
+ */
+
+/**
+ * il_rx_queue_space - Return number of free slots available in queue.
+ */
+int
+il_rx_queue_space(const struct il_rx_queue *q)
+{
+       int s = q->read - q->write;
+       if (s <= 0)
+               s += RX_QUEUE_SIZE;
+       /* keep some buffer to not confuse full and empty queue */
+       s -= 2;
+       if (s < 0)
+               s = 0;
+       return s;
+}
+EXPORT_SYMBOL(il_rx_queue_space);
+
+/**
+ * il_rx_queue_update_write_ptr - Update the write pointer for the RX queue
+ */
+void
+il_rx_queue_update_write_ptr(struct il_priv *il, struct il_rx_queue *q)
+{
+       unsigned long flags;
+       u32 rx_wrt_ptr_reg = il->hw_params.rx_wrt_ptr_reg;
+       u32 reg;
+
+       spin_lock_irqsave(&q->lock, flags);
+
+       if (q->need_update == 0)
+               goto exit_unlock;
+
+       /* If power-saving is in use, make sure device is awake */
+       if (test_bit(S_POWER_PMI, &il->status)) {
+               reg = _il_rd(il, CSR_UCODE_DRV_GP1);
+
+               if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
+                       D_INFO("Rx queue requesting wakeup," " GP1 = 0x%x\n",
+                              reg);
+                       il_set_bit(il, CSR_GP_CNTRL,
+                                  CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+                       goto exit_unlock;
+               }
+
+               q->write_actual = (q->write & ~0x7);
+               il_wr(il, rx_wrt_ptr_reg, q->write_actual);
+
+               /* Else device is assumed to be awake */
+       } else {
+               /* Device expects a multiple of 8 */
+               q->write_actual = (q->write & ~0x7);
+               il_wr(il, rx_wrt_ptr_reg, q->write_actual);
+       }
+
+       q->need_update = 0;
+
+exit_unlock:
+       spin_unlock_irqrestore(&q->lock, flags);
+}
+EXPORT_SYMBOL(il_rx_queue_update_write_ptr);
+
+int
+il_rx_queue_alloc(struct il_priv *il)
+{
+       struct il_rx_queue *rxq = &il->rxq;
+       struct device *dev = &il->pci_dev->dev;
+       int i;
+
+       spin_lock_init(&rxq->lock);
+       INIT_LIST_HEAD(&rxq->rx_free);
+       INIT_LIST_HEAD(&rxq->rx_used);
+
+       /* Alloc the circular buffer of Read Buffer Descriptors (RBDs) */
+       rxq->bd = dma_alloc_coherent(dev, 4 * RX_QUEUE_SIZE, &rxq->bd_dma,
+                                    GFP_KERNEL);
+       if (!rxq->bd)
+               goto err_bd;
+
+       rxq->rb_stts = dma_alloc_coherent(dev, sizeof(struct il_rb_status),
+                                         &rxq->rb_stts_dma, GFP_KERNEL);
+       if (!rxq->rb_stts)
+               goto err_rb;
+
+       /* Fill the rx_used queue with _all_ of the Rx buffers */
+       for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
+               list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
+
+       /* Set us so that we have processed and used all buffers, but have
+        * not restocked the Rx queue with fresh buffers */
+       rxq->read = rxq->write = 0;
+       rxq->write_actual = 0;
+       rxq->free_count = 0;
+       rxq->need_update = 0;
+       return 0;
+
+err_rb:
+       dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
+                         rxq->bd_dma);
+err_bd:
+       return -ENOMEM;
+}
+EXPORT_SYMBOL(il_rx_queue_alloc);
+
+void
+il_hdl_spectrum_measurement(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_spectrum_notification *report = &(pkt->u.spectrum_notif);
+
+       if (!report->state) {
+               D_11H("Spectrum Measure Notification: Start\n");
+               return;
+       }
+
+       memcpy(&il->measure_report, report, sizeof(*report));
+       il->measurement_status |= MEASUREMENT_READY;
+}
+EXPORT_SYMBOL(il_hdl_spectrum_measurement);
+
+/*
+ * returns non-zero if packet should be dropped
+ */
+int
+il_set_decrypted_flag(struct il_priv *il, struct ieee80211_hdr *hdr,
+                     u32 decrypt_res, struct ieee80211_rx_status *stats)
+{
+       u16 fc = le16_to_cpu(hdr->frame_control);
+
+       /*
+        * All contexts have the same setting here due to it being
+        * a module parameter, so OK to check any context.
+        */
+       if (il->active.filter_flags & RXON_FILTER_DIS_DECRYPT_MSK)
+               return 0;
+
+       if (!(fc & IEEE80211_FCTL_PROTECTED))
+               return 0;
+
+       D_RX("decrypt_res:0x%x\n", decrypt_res);
+       switch (decrypt_res & RX_RES_STATUS_SEC_TYPE_MSK) {
+       case RX_RES_STATUS_SEC_TYPE_TKIP:
+               /* The uCode has got a bad phase 1 Key, pushes the packet.
+                * Decryption will be done in SW. */
+               if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
+                   RX_RES_STATUS_BAD_KEY_TTAK)
+                       break;
+
+       case RX_RES_STATUS_SEC_TYPE_WEP:
+               if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
+                   RX_RES_STATUS_BAD_ICV_MIC) {
+                       /* bad ICV, the packet is destroyed since the
+                        * decryption is inplace, drop it */
+                       D_RX("Packet destroyed\n");
+                       return -1;
+               }
+       case RX_RES_STATUS_SEC_TYPE_CCMP:
+               if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
+                   RX_RES_STATUS_DECRYPT_OK) {
+                       D_RX("hw decrypt successfully!!!\n");
+                       stats->flag |= RX_FLAG_DECRYPTED;
+               }
+               break;
+
+       default:
+               break;
+       }
+       return 0;
+}
+EXPORT_SYMBOL(il_set_decrypted_flag);
+
+/**
+ * il_txq_update_write_ptr - Send new write idx to hardware
+ */
+void
+il_txq_update_write_ptr(struct il_priv *il, struct il_tx_queue *txq)
+{
+       u32 reg = 0;
+       int txq_id = txq->q.id;
+
+       if (txq->need_update == 0)
+               return;
+
+       /* if we're trying to save power */
+       if (test_bit(S_POWER_PMI, &il->status)) {
+               /* wake up nic if it's powered down ...
+                * uCode will wake up, and interrupt us again, so next
+                * time we'll skip this part. */
+               reg = _il_rd(il, CSR_UCODE_DRV_GP1);
+
+               if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
+                       D_INFO("Tx queue %d requesting wakeup," " GP1 = 0x%x\n",
+                              txq_id, reg);
+                       il_set_bit(il, CSR_GP_CNTRL,
+                                  CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+                       return;
+               }
+
+               il_wr(il, HBUS_TARG_WRPTR, txq->q.write_ptr | (txq_id << 8));
+
+               /*
+                * else not in power-save mode,
+                * uCode will never sleep when we're
+                * trying to tx (during RFKILL, we're not trying to tx).
+                */
+       } else
+               _il_wr(il, HBUS_TARG_WRPTR, txq->q.write_ptr | (txq_id << 8));
+       txq->need_update = 0;
+}
+EXPORT_SYMBOL(il_txq_update_write_ptr);
+
+/**
+ * il_tx_queue_unmap -  Unmap any remaining DMA mappings and free skb's
+ */
+void
+il_tx_queue_unmap(struct il_priv *il, int txq_id)
+{
+       struct il_tx_queue *txq = &il->txq[txq_id];
+       struct il_queue *q = &txq->q;
+
+       if (q->n_bd == 0)
+               return;
+
+       while (q->write_ptr != q->read_ptr) {
+               il->ops->txq_free_tfd(il, txq);
+               q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd);
+       }
+}
+EXPORT_SYMBOL(il_tx_queue_unmap);
+
+/**
+ * il_tx_queue_free - Deallocate DMA queue.
+ * @txq: Transmit queue to deallocate.
+ *
+ * Empty queue by removing and destroying all BD's.
+ * Free all buffers.
+ * 0-fill, but do not free "txq" descriptor structure.
+ */
+void
+il_tx_queue_free(struct il_priv *il, int txq_id)
+{
+       struct il_tx_queue *txq = &il->txq[txq_id];
+       struct device *dev = &il->pci_dev->dev;
+       int i;
+
+       il_tx_queue_unmap(il, txq_id);
+
+       /* De-alloc array of command/tx buffers */
+       for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
+               kfree(txq->cmd[i]);
+
+       /* De-alloc circular buffer of TFDs */
+       if (txq->q.n_bd)
+               dma_free_coherent(dev, il->hw_params.tfd_size * txq->q.n_bd,
+                                 txq->tfds, txq->q.dma_addr);
+
+       /* De-alloc array of per-TFD driver data */
+       kfree(txq->skbs);
+       txq->skbs = NULL;
+
+       /* deallocate arrays */
+       kfree(txq->cmd);
+       kfree(txq->meta);
+       txq->cmd = NULL;
+       txq->meta = NULL;
+
+       /* 0-fill queue descriptor structure */
+       memset(txq, 0, sizeof(*txq));
+}
+EXPORT_SYMBOL(il_tx_queue_free);
+
+/**
+ * il_cmd_queue_unmap - Unmap any remaining DMA mappings from command queue
+ */
+void
+il_cmd_queue_unmap(struct il_priv *il)
+{
+       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
+       struct il_queue *q = &txq->q;
+       int i;
+
+       if (q->n_bd == 0)
+               return;
+
+       while (q->read_ptr != q->write_ptr) {
+               i = il_get_cmd_idx(q, q->read_ptr, 0);
+
+               if (txq->meta[i].flags & CMD_MAPPED) {
+                       pci_unmap_single(il->pci_dev,
+                                        dma_unmap_addr(&txq->meta[i], mapping),
+                                        dma_unmap_len(&txq->meta[i], len),
+                                        PCI_DMA_BIDIRECTIONAL);
+                       txq->meta[i].flags = 0;
+               }
+
+               q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd);
+       }
+
+       i = q->n_win;
+       if (txq->meta[i].flags & CMD_MAPPED) {
+               pci_unmap_single(il->pci_dev,
+                                dma_unmap_addr(&txq->meta[i], mapping),
+                                dma_unmap_len(&txq->meta[i], len),
+                                PCI_DMA_BIDIRECTIONAL);
+               txq->meta[i].flags = 0;
+       }
+}
+EXPORT_SYMBOL(il_cmd_queue_unmap);
+
+/**
+ * il_cmd_queue_free - Deallocate DMA queue.
+ * @txq: Transmit queue to deallocate.
+ *
+ * Empty queue by removing and destroying all BD's.
+ * Free all buffers.
+ * 0-fill, but do not free "txq" descriptor structure.
+ */
+void
+il_cmd_queue_free(struct il_priv *il)
+{
+       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
+       struct device *dev = &il->pci_dev->dev;
+       int i;
+
+       il_cmd_queue_unmap(il);
+
+       /* De-alloc array of command/tx buffers */
+       for (i = 0; i <= TFD_CMD_SLOTS; i++)
+               kfree(txq->cmd[i]);
+
+       /* De-alloc circular buffer of TFDs */
+       if (txq->q.n_bd)
+               dma_free_coherent(dev, il->hw_params.tfd_size * txq->q.n_bd,
+                                 txq->tfds, txq->q.dma_addr);
+
+       /* deallocate arrays */
+       kfree(txq->cmd);
+       kfree(txq->meta);
+       txq->cmd = NULL;
+       txq->meta = NULL;
+
+       /* 0-fill queue descriptor structure */
+       memset(txq, 0, sizeof(*txq));
+}
+EXPORT_SYMBOL(il_cmd_queue_free);
+
+/*************** DMA-QUEUE-GENERAL-FUNCTIONS  *****
+ * DMA services
+ *
+ * Theory of operation
+ *
+ * A Tx or Rx queue resides in host DRAM, and is comprised of a circular buffer
+ * of buffer descriptors, each of which points to one or more data buffers for
+ * the device to read from or fill.  Driver and device exchange status of each
+ * queue via "read" and "write" pointers.  Driver keeps minimum of 2 empty
+ * entries in each circular buffer, to protect against confusing empty and full
+ * queue states.
+ *
+ * The device reads or writes the data in the queues via the device's several
+ * DMA/FIFO channels.  Each queue is mapped to a single DMA channel.
+ *
+ * For Tx queue, there are low mark and high mark limits. If, after queuing
+ * the packet for Tx, free space become < low mark, Tx queue stopped. When
+ * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
+ * Tx queue resumed.
+ *
+ * See more detailed info in 4965.h.
+ ***************************************************/
+
+int
+il_queue_space(const struct il_queue *q)
+{
+       int s = q->read_ptr - q->write_ptr;
+
+       if (q->read_ptr > q->write_ptr)
+               s -= q->n_bd;
+
+       if (s <= 0)
+               s += q->n_win;
+       /* keep some reserve to not confuse empty and full situations */
+       s -= 2;
+       if (s < 0)
+               s = 0;
+       return s;
+}
+EXPORT_SYMBOL(il_queue_space);
+
+
+/**
+ * il_queue_init - Initialize queue's high/low-water and read/write idxes
+ */
+static int
+il_queue_init(struct il_priv *il, struct il_queue *q, int slots, u32 id)
+{
+       /*
+        * TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
+        * il_queue_inc_wrap and il_queue_dec_wrap are broken.
+        */
+       BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
+       /* FIXME: remove q->n_bd */
+       q->n_bd = TFD_QUEUE_SIZE_MAX;
+
+       q->n_win = slots;
+       q->id = id;
+
+       /* slots_must be power-of-two size, otherwise
+        * il_get_cmd_idx is broken. */
+       BUG_ON(!is_power_of_2(slots));
+
+       q->low_mark = q->n_win / 4;
+       if (q->low_mark < 4)
+               q->low_mark = 4;
+
+       q->high_mark = q->n_win / 8;
+       if (q->high_mark < 2)
+               q->high_mark = 2;
+
+       q->write_ptr = q->read_ptr = 0;
+
+       return 0;
+}
+
+/**
+ * il_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
+ */
+static int
+il_tx_queue_alloc(struct il_priv *il, struct il_tx_queue *txq, u32 id)
+{
+       struct device *dev = &il->pci_dev->dev;
+       size_t tfd_sz = il->hw_params.tfd_size * TFD_QUEUE_SIZE_MAX;
+
+       /* Driver ilate data, only for Tx (not command) queues,
+        * not shared with device. */
+       if (id != il->cmd_queue) {
+               txq->skbs = kcalloc(TFD_QUEUE_SIZE_MAX,
+                                   sizeof(struct sk_buff *),
+                                   GFP_KERNEL);
+               if (!txq->skbs) {
+                       IL_ERR("Fail to alloc skbs\n");
+                       goto error;
+               }
+       } else
+               txq->skbs = NULL;
+
+       /* Circular buffer of transmit frame descriptors (TFDs),
+        * shared with device */
+       txq->tfds =
+           dma_alloc_coherent(dev, tfd_sz, &txq->q.dma_addr, GFP_KERNEL);
+       if (!txq->tfds)
+               goto error;
+
+       txq->q.id = id;
+
+       return 0;
+
+error:
+       kfree(txq->skbs);
+       txq->skbs = NULL;
+
+       return -ENOMEM;
+}
+
+/**
+ * il_tx_queue_init - Allocate and initialize one tx/cmd queue
+ */
+int
+il_tx_queue_init(struct il_priv *il, u32 txq_id)
+{
+       int i, len, ret;
+       int slots, actual_slots;
+       struct il_tx_queue *txq = &il->txq[txq_id];
+
+       /*
+        * Alloc buffer array for commands (Tx or other types of commands).
+        * For the command queue (#4/#9), allocate command space + one big
+        * command for scan, since scan command is very huge; the system will
+        * not have two scans at the same time, so only one is needed.
+        * For normal Tx queues (all other queues), no super-size command
+        * space is needed.
+        */
+       if (txq_id == il->cmd_queue) {
+               slots = TFD_CMD_SLOTS;
+               actual_slots = slots + 1;
+       } else {
+               slots = TFD_TX_CMD_SLOTS;
+               actual_slots = slots;
+       }
+
+       txq->meta =
+           kzalloc(sizeof(struct il_cmd_meta) * actual_slots, GFP_KERNEL);
+       txq->cmd =
+           kzalloc(sizeof(struct il_device_cmd *) * actual_slots, GFP_KERNEL);
+
+       if (!txq->meta || !txq->cmd)
+               goto out_free_arrays;
+
+       len = sizeof(struct il_device_cmd);
+       for (i = 0; i < actual_slots; i++) {
+               /* only happens for cmd queue */
+               if (i == slots)
+                       len = IL_MAX_CMD_SIZE;
+
+               txq->cmd[i] = kmalloc(len, GFP_KERNEL);
+               if (!txq->cmd[i])
+                       goto err;
+       }
+
+       /* Alloc driver data array and TFD circular buffer */
+       ret = il_tx_queue_alloc(il, txq, txq_id);
+       if (ret)
+               goto err;
+
+       txq->need_update = 0;
+
+       /*
+        * For the default queues 0-3, set up the swq_id
+        * already -- all others need to get one later
+        * (if they need one at all).
+        */
+       if (txq_id < 4)
+               il_set_swq_id(txq, txq_id, txq_id);
+
+       /* Initialize queue's high/low-water marks, and head/tail idxes */
+       il_queue_init(il, &txq->q, slots, txq_id);
+
+       /* Tell device where to find queue */
+       il->ops->txq_init(il, txq);
+
+       return 0;
+err:
+       for (i = 0; i < actual_slots; i++)
+               kfree(txq->cmd[i]);
+out_free_arrays:
+       kfree(txq->meta);
+       kfree(txq->cmd);
+
+       return -ENOMEM;
+}
+EXPORT_SYMBOL(il_tx_queue_init);
+
+void
+il_tx_queue_reset(struct il_priv *il, u32 txq_id)
+{
+       int slots, actual_slots;
+       struct il_tx_queue *txq = &il->txq[txq_id];
+
+       if (txq_id == il->cmd_queue) {
+               slots = TFD_CMD_SLOTS;
+               actual_slots = TFD_CMD_SLOTS + 1;
+       } else {
+               slots = TFD_TX_CMD_SLOTS;
+               actual_slots = TFD_TX_CMD_SLOTS;
+       }
+
+       memset(txq->meta, 0, sizeof(struct il_cmd_meta) * actual_slots);
+       txq->need_update = 0;
+
+       /* Initialize queue's high/low-water marks, and head/tail idxes */
+       il_queue_init(il, &txq->q, slots, txq_id);
+
+       /* Tell device where to find queue */
+       il->ops->txq_init(il, txq);
+}
+EXPORT_SYMBOL(il_tx_queue_reset);
+
+/*************** HOST COMMAND QUEUE FUNCTIONS   *****/
+
+/**
+ * il_enqueue_hcmd - enqueue a uCode command
+ * @il: device ilate data point
+ * @cmd: a point to the ucode command structure
+ *
+ * The function returns < 0 values to indicate the operation is
+ * failed. On success, it turns the idx (> 0) of command in the
+ * command queue.
+ */
+int
+il_enqueue_hcmd(struct il_priv *il, struct il_host_cmd *cmd)
+{
+       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
+       struct il_queue *q = &txq->q;
+       struct il_device_cmd *out_cmd;
+       struct il_cmd_meta *out_meta;
+       dma_addr_t phys_addr;
+       unsigned long flags;
+       int len;
+       u32 idx;
+       u16 fix_size;
+
+       cmd->len = il->ops->get_hcmd_size(cmd->id, cmd->len);
+       fix_size = (u16) (cmd->len + sizeof(out_cmd->hdr));
+
+       /* If any of the command structures end up being larger than
+        * the TFD_MAX_PAYLOAD_SIZE, and it sent as a 'small' command then
+        * we will need to increase the size of the TFD entries
+        * Also, check to see if command buffer should not exceed the size
+        * of device_cmd and max_cmd_size. */
+       BUG_ON((fix_size > TFD_MAX_PAYLOAD_SIZE) &&
+              !(cmd->flags & CMD_SIZE_HUGE));
+       BUG_ON(fix_size > IL_MAX_CMD_SIZE);
+
+       if (il_is_rfkill(il) || il_is_ctkill(il)) {
+               IL_WARN("Not sending command - %s KILL\n",
+                       il_is_rfkill(il) ? "RF" : "CT");
+               return -EIO;
+       }
+
+       spin_lock_irqsave(&il->hcmd_lock, flags);
+
+       if (il_queue_space(q) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {
+               spin_unlock_irqrestore(&il->hcmd_lock, flags);
+
+               IL_ERR("Restarting adapter due to command queue full\n");
+               queue_work(il->workqueue, &il->restart);
+               return -ENOSPC;
+       }
+
+       idx = il_get_cmd_idx(q, q->write_ptr, cmd->flags & CMD_SIZE_HUGE);
+       out_cmd = txq->cmd[idx];
+       out_meta = &txq->meta[idx];
+
+       if (WARN_ON(out_meta->flags & CMD_MAPPED)) {
+               spin_unlock_irqrestore(&il->hcmd_lock, flags);
+               return -ENOSPC;
+       }
+
+       memset(out_meta, 0, sizeof(*out_meta)); /* re-initialize to NULL */
+       out_meta->flags = cmd->flags | CMD_MAPPED;
+       if (cmd->flags & CMD_WANT_SKB)
+               out_meta->source = cmd;
+       if (cmd->flags & CMD_ASYNC)
+               out_meta->callback = cmd->callback;
+
+       out_cmd->hdr.cmd = cmd->id;
+       memcpy(&out_cmd->cmd.payload, cmd->data, cmd->len);
+
+       /* At this point, the out_cmd now has all of the incoming cmd
+        * information */
+
+       out_cmd->hdr.flags = 0;
+       out_cmd->hdr.sequence =
+           cpu_to_le16(QUEUE_TO_SEQ(il->cmd_queue) | IDX_TO_SEQ(q->write_ptr));
+       if (cmd->flags & CMD_SIZE_HUGE)
+               out_cmd->hdr.sequence |= SEQ_HUGE_FRAME;
+       len = sizeof(struct il_device_cmd);
+       if (idx == TFD_CMD_SLOTS)
+               len = IL_MAX_CMD_SIZE;
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       switch (out_cmd->hdr.cmd) {
+       case C_TX_LINK_QUALITY_CMD:
+       case C_SENSITIVITY:
+               D_HC_DUMP("Sending command %s (#%x), seq: 0x%04X, "
+                         "%d bytes at %d[%d]:%d\n",
+                         il_get_cmd_string(out_cmd->hdr.cmd), out_cmd->hdr.cmd,
+                         le16_to_cpu(out_cmd->hdr.sequence), fix_size,
+                         q->write_ptr, idx, il->cmd_queue);
+               break;
+       default:
+               D_HC("Sending command %s (#%x), seq: 0x%04X, "
+                    "%d bytes at %d[%d]:%d\n",
+                    il_get_cmd_string(out_cmd->hdr.cmd), out_cmd->hdr.cmd,
+                    le16_to_cpu(out_cmd->hdr.sequence), fix_size, q->write_ptr,
+                    idx, il->cmd_queue);
+       }
+#endif
+
+       phys_addr =
+           pci_map_single(il->pci_dev, &out_cmd->hdr, fix_size,
+                          PCI_DMA_BIDIRECTIONAL);
+       if (unlikely(pci_dma_mapping_error(il->pci_dev, phys_addr))) {
+               idx = -ENOMEM;
+               goto out;
+       }
+       dma_unmap_addr_set(out_meta, mapping, phys_addr);
+       dma_unmap_len_set(out_meta, len, fix_size);
+
+       txq->need_update = 1;
+
+       if (il->ops->txq_update_byte_cnt_tbl)
+               /* Set up entry in queue's byte count circular buffer */
+               il->ops->txq_update_byte_cnt_tbl(il, txq, 0);
+
+       il->ops->txq_attach_buf_to_tfd(il, txq, phys_addr, fix_size, 1,
+                                           U32_PAD(cmd->len));
+
+       /* Increment and update queue's write idx */
+       q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
+       il_txq_update_write_ptr(il, txq);
+
+out:
+       spin_unlock_irqrestore(&il->hcmd_lock, flags);
+       return idx;
+}
+
+/**
+ * il_hcmd_queue_reclaim - Reclaim TX command queue entries already Tx'd
+ *
+ * When FW advances 'R' idx, all entries between old and new 'R' idx
+ * need to be reclaimed. As result, some free space forms.  If there is
+ * enough free space (> low mark), wake the stack that feeds us.
+ */
+static void
+il_hcmd_queue_reclaim(struct il_priv *il, int txq_id, int idx, int cmd_idx)
+{
+       struct il_tx_queue *txq = &il->txq[txq_id];
+       struct il_queue *q = &txq->q;
+       int nfreed = 0;
+
+       if (idx >= q->n_bd || il_queue_used(q, idx) == 0) {
+               IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
+                      "is out of range [0-%d] %d %d.\n", txq_id, idx, q->n_bd,
+                      q->write_ptr, q->read_ptr);
+               return;
+       }
+
+       for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
+            q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
+
+               if (nfreed++ > 0) {
+                       IL_ERR("HCMD skipped: idx (%d) %d %d\n", idx,
+                              q->write_ptr, q->read_ptr);
+                       queue_work(il->workqueue, &il->restart);
+               }
+
+       }
+}
+
+/**
+ * il_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
+ */
+void
+il_tx_cmd_complete(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       u16 sequence = le16_to_cpu(pkt->hdr.sequence);
+       int txq_id = SEQ_TO_QUEUE(sequence);
+       int idx = SEQ_TO_IDX(sequence);
+       int cmd_idx;
+       bool huge = !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
+       struct il_device_cmd *cmd;
+       struct il_cmd_meta *meta;
+       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
+       unsigned long flags;
+
+       /* If a Tx command is being handled and it isn't in the actual
+        * command queue then there a command routing bug has been introduced
+        * in the queue management code. */
+       if (WARN
+           (txq_id != il->cmd_queue,
+            "wrong command queue %d (should be %d), sequence 0x%X readp=%d writep=%d\n",
+            txq_id, il->cmd_queue, sequence, il->txq[il->cmd_queue].q.read_ptr,
+            il->txq[il->cmd_queue].q.write_ptr)) {
+               il_print_hex_error(il, pkt, 32);
+               return;
+       }
+
+       cmd_idx = il_get_cmd_idx(&txq->q, idx, huge);
+       cmd = txq->cmd[cmd_idx];
+       meta = &txq->meta[cmd_idx];
+
+       txq->time_stamp = jiffies;
+
+       pci_unmap_single(il->pci_dev, dma_unmap_addr(meta, mapping),
+                        dma_unmap_len(meta, len), PCI_DMA_BIDIRECTIONAL);
+
+       /* Input error checking is done when commands are added to queue. */
+       if (meta->flags & CMD_WANT_SKB) {
+               meta->source->reply_page = (unsigned long)rxb_addr(rxb);
+               rxb->page = NULL;
+       } else if (meta->callback)
+               meta->callback(il, cmd, pkt);
+
+       spin_lock_irqsave(&il->hcmd_lock, flags);
+
+       il_hcmd_queue_reclaim(il, txq_id, idx, cmd_idx);
+
+       if (!(meta->flags & CMD_ASYNC)) {
+               clear_bit(S_HCMD_ACTIVE, &il->status);
+               D_INFO("Clearing HCMD_ACTIVE for command %s\n",
+                      il_get_cmd_string(cmd->hdr.cmd));
+               wake_up(&il->wait_command_queue);
+       }
+
+       /* Mark as unmapped */
+       meta->flags = 0;
+
+       spin_unlock_irqrestore(&il->hcmd_lock, flags);
+}
+EXPORT_SYMBOL(il_tx_cmd_complete);
+
+MODULE_DESCRIPTION("iwl-legacy: common functions for 3945 and 4965");
+MODULE_VERSION(IWLWIFI_VERSION);
+MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
+MODULE_LICENSE("GPL");
+
+/*
+ * set bt_coex_active to true, uCode will do kill/defer
+ * every time the priority line is asserted (BT is sending signals on the
+ * priority line in the PCIx).
+ * set bt_coex_active to false, uCode will ignore the BT activity and
+ * perform the normal operation
+ *
+ * User might experience transmit issue on some platform due to WiFi/BT
+ * co-exist problem. The possible behaviors are:
+ *   Able to scan and finding all the available AP
+ *   Not able to associate with any AP
+ * On those platforms, WiFi communication can be restored by set
+ * "bt_coex_active" module parameter to "false"
+ *
+ * default: bt_coex_active = true (BT_COEX_ENABLE)
+ */
+static bool bt_coex_active = true;
+module_param(bt_coex_active, bool, S_IRUGO);
+MODULE_PARM_DESC(bt_coex_active, "enable wifi/bluetooth co-exist");
+
+u32 il_debug_level;
+EXPORT_SYMBOL(il_debug_level);
+
+const u8 il_bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+EXPORT_SYMBOL(il_bcast_addr);
+
+#define MAX_BIT_RATE_40_MHZ 150        /* Mbps */
+#define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
+static void
+il_init_ht_hw_capab(const struct il_priv *il,
+                   struct ieee80211_sta_ht_cap *ht_info,
+                   enum ieee80211_band band)
+{
+       u16 max_bit_rate = 0;
+       u8 rx_chains_num = il->hw_params.rx_chains_num;
+       u8 tx_chains_num = il->hw_params.tx_chains_num;
+
+       ht_info->cap = 0;
+       memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
+
+       ht_info->ht_supported = true;
+
+       ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
+       max_bit_rate = MAX_BIT_RATE_20_MHZ;
+       if (il->hw_params.ht40_channel & BIT(band)) {
+               ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
+               ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
+               ht_info->mcs.rx_mask[4] = 0x01;
+               max_bit_rate = MAX_BIT_RATE_40_MHZ;
+       }
+
+       if (il->cfg->mod_params->amsdu_size_8K)
+               ht_info->cap |= IEEE80211_HT_CAP_MAX_AMSDU;
+
+       ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
+       ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
+
+       ht_info->mcs.rx_mask[0] = 0xFF;
+       if (rx_chains_num >= 2)
+               ht_info->mcs.rx_mask[1] = 0xFF;
+       if (rx_chains_num >= 3)
+               ht_info->mcs.rx_mask[2] = 0xFF;
+
+       /* Highest supported Rx data rate */
+       max_bit_rate *= rx_chains_num;
+       WARN_ON(max_bit_rate & ~IEEE80211_HT_MCS_RX_HIGHEST_MASK);
+       ht_info->mcs.rx_highest = cpu_to_le16(max_bit_rate);
+
+       /* Tx MCS capabilities */
+       ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
+       if (tx_chains_num != rx_chains_num) {
+               ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
+               ht_info->mcs.tx_params |=
+                   ((tx_chains_num -
+                     1) << IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
+       }
+}
+
+/**
+ * il_init_geos - Initialize mac80211's geo/channel info based from eeprom
+ */
+int
+il_init_geos(struct il_priv *il)
+{
+       struct il_channel_info *ch;
+       struct ieee80211_supported_band *sband;
+       struct ieee80211_channel *channels;
+       struct ieee80211_channel *geo_ch;
+       struct ieee80211_rate *rates;
+       int i = 0;
+       s8 max_tx_power = 0;
+
+       if (il->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
+           il->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
+               D_INFO("Geography modes already initialized.\n");
+               set_bit(S_GEO_CONFIGURED, &il->status);
+               return 0;
+       }
+
+       channels =
+           kzalloc(sizeof(struct ieee80211_channel) * il->channel_count,
+                   GFP_KERNEL);
+       if (!channels)
+               return -ENOMEM;
+
+       rates =
+           kzalloc((sizeof(struct ieee80211_rate) * RATE_COUNT_LEGACY),
+                   GFP_KERNEL);
+       if (!rates) {
+               kfree(channels);
+               return -ENOMEM;
+       }
+
+       /* 5.2GHz channels start after the 2.4GHz channels */
+       sband = &il->bands[IEEE80211_BAND_5GHZ];
+       sband->channels = &channels[ARRAY_SIZE(il_eeprom_band_1)];
+       /* just OFDM */
+       sband->bitrates = &rates[IL_FIRST_OFDM_RATE];
+       sband->n_bitrates = RATE_COUNT_LEGACY - IL_FIRST_OFDM_RATE;
+
+       if (il->cfg->sku & IL_SKU_N)
+               il_init_ht_hw_capab(il, &sband->ht_cap, IEEE80211_BAND_5GHZ);
+
+       sband = &il->bands[IEEE80211_BAND_2GHZ];
+       sband->channels = channels;
+       /* OFDM & CCK */
+       sband->bitrates = rates;
+       sband->n_bitrates = RATE_COUNT_LEGACY;
+
+       if (il->cfg->sku & IL_SKU_N)
+               il_init_ht_hw_capab(il, &sband->ht_cap, IEEE80211_BAND_2GHZ);
+
+       il->ieee_channels = channels;
+       il->ieee_rates = rates;
+
+       for (i = 0; i < il->channel_count; i++) {
+               ch = &il->channel_info[i];
+
+               if (!il_is_channel_valid(ch))
+                       continue;
+
+               sband = &il->bands[ch->band];
+
+               geo_ch = &sband->channels[sband->n_channels++];
+
+               geo_ch->center_freq =
+                   ieee80211_channel_to_frequency(ch->channel, ch->band);
+               geo_ch->max_power = ch->max_power_avg;
+               geo_ch->max_antenna_gain = 0xff;
+               geo_ch->hw_value = ch->channel;
+
+               if (il_is_channel_valid(ch)) {
+                       if (!(ch->flags & EEPROM_CHANNEL_IBSS))
+                               geo_ch->flags |= IEEE80211_CHAN_NO_IR;
+
+                       if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
+                               geo_ch->flags |= IEEE80211_CHAN_NO_IR;
+
+                       if (ch->flags & EEPROM_CHANNEL_RADAR)
+                               geo_ch->flags |= IEEE80211_CHAN_RADAR;
+
+                       geo_ch->flags |= ch->ht40_extension_channel;
+
+                       if (ch->max_power_avg > max_tx_power)
+                               max_tx_power = ch->max_power_avg;
+               } else {
+                       geo_ch->flags |= IEEE80211_CHAN_DISABLED;
+               }
+
+               D_INFO("Channel %d Freq=%d[%sGHz] %s flag=0x%X\n", ch->channel,
+                      geo_ch->center_freq,
+                      il_is_channel_a_band(ch) ? "5.2" : "2.4",
+                      geo_ch->
+                      flags & IEEE80211_CHAN_DISABLED ? "restricted" : "valid",
+                      geo_ch->flags);
+       }
+
+       il->tx_power_device_lmt = max_tx_power;
+       il->tx_power_user_lmt = max_tx_power;
+       il->tx_power_next = max_tx_power;
+
+       if (il->bands[IEEE80211_BAND_5GHZ].n_channels == 0 &&
+           (il->cfg->sku & IL_SKU_A)) {
+               IL_INFO("Incorrectly detected BG card as ABG. "
+                       "Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
+                       il->pci_dev->device, il->pci_dev->subsystem_device);
+               il->cfg->sku &= ~IL_SKU_A;
+       }
+
+       IL_INFO("Tunable channels: %d 802.11bg, %d 802.11a channels\n",
+               il->bands[IEEE80211_BAND_2GHZ].n_channels,
+               il->bands[IEEE80211_BAND_5GHZ].n_channels);
+
+       set_bit(S_GEO_CONFIGURED, &il->status);
+
+       return 0;
+}
+EXPORT_SYMBOL(il_init_geos);
+
+/*
+ * il_free_geos - undo allocations in il_init_geos
+ */
+void
+il_free_geos(struct il_priv *il)
+{
+       kfree(il->ieee_channels);
+       kfree(il->ieee_rates);
+       clear_bit(S_GEO_CONFIGURED, &il->status);
+}
+EXPORT_SYMBOL(il_free_geos);
+
+static bool
+il_is_channel_extension(struct il_priv *il, enum ieee80211_band band,
+                       u16 channel, u8 extension_chan_offset)
+{
+       const struct il_channel_info *ch_info;
+
+       ch_info = il_get_channel_info(il, band, channel);
+       if (!il_is_channel_valid(ch_info))
+               return false;
+
+       if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE)
+               return !(ch_info->
+                        ht40_extension_channel & IEEE80211_CHAN_NO_HT40PLUS);
+       else if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW)
+               return !(ch_info->
+                        ht40_extension_channel & IEEE80211_CHAN_NO_HT40MINUS);
+
+       return false;
+}
+
+bool
+il_is_ht40_tx_allowed(struct il_priv *il, struct ieee80211_sta_ht_cap *ht_cap)
+{
+       if (!il->ht.enabled || !il->ht.is_40mhz)
+               return false;
+
+       /*
+        * We do not check for IEEE80211_HT_CAP_SUP_WIDTH_20_40
+        * the bit will not set if it is pure 40MHz case
+        */
+       if (ht_cap && !ht_cap->ht_supported)
+               return false;
+
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       if (il->disable_ht40)
+               return false;
+#endif
+
+       return il_is_channel_extension(il, il->band,
+                                      le16_to_cpu(il->staging.channel),
+                                      il->ht.extension_chan_offset);
+}
+EXPORT_SYMBOL(il_is_ht40_tx_allowed);
+
+static u16
+il_adjust_beacon_interval(u16 beacon_val, u16 max_beacon_val)
+{
+       u16 new_val;
+       u16 beacon_factor;
+
+       /*
+        * If mac80211 hasn't given us a beacon interval, program
+        * the default into the device.
+        */
+       if (!beacon_val)
+               return DEFAULT_BEACON_INTERVAL;
+
+       /*
+        * If the beacon interval we obtained from the peer
+        * is too large, we'll have to wake up more often
+        * (and in IBSS case, we'll beacon too much)
+        *
+        * For example, if max_beacon_val is 4096, and the
+        * requested beacon interval is 7000, we'll have to
+        * use 3500 to be able to wake up on the beacons.
+        *
+        * This could badly influence beacon detection stats.
+        */
+
+       beacon_factor = (beacon_val + max_beacon_val) / max_beacon_val;
+       new_val = beacon_val / beacon_factor;
+
+       if (!new_val)
+               new_val = max_beacon_val;
+
+       return new_val;
+}
+
+int
+il_send_rxon_timing(struct il_priv *il)
+{
+       u64 tsf;
+       s32 interval_tm, rem;
+       struct ieee80211_conf *conf = NULL;
+       u16 beacon_int;
+       struct ieee80211_vif *vif = il->vif;
+
+       conf = &il->hw->conf;
+
+       lockdep_assert_held(&il->mutex);
+
+       memset(&il->timing, 0, sizeof(struct il_rxon_time_cmd));
+
+       il->timing.timestamp = cpu_to_le64(il->timestamp);
+       il->timing.listen_interval = cpu_to_le16(conf->listen_interval);
+
+       beacon_int = vif ? vif->bss_conf.beacon_int : 0;
+
+       /*
+        * TODO: For IBSS we need to get atim_win from mac80211,
+        *       for now just always use 0
+        */
+       il->timing.atim_win = 0;
+
+       beacon_int =
+           il_adjust_beacon_interval(beacon_int,
+                                     il->hw_params.max_beacon_itrvl *
+                                     TIME_UNIT);
+       il->timing.beacon_interval = cpu_to_le16(beacon_int);
+
+       tsf = il->timestamp;    /* tsf is modifed by do_div: copy it */
+       interval_tm = beacon_int * TIME_UNIT;
+       rem = do_div(tsf, interval_tm);
+       il->timing.beacon_init_val = cpu_to_le32(interval_tm - rem);
+
+       il->timing.dtim_period = vif ? (vif->bss_conf.dtim_period ? : 1) : 1;
+
+       D_ASSOC("beacon interval %d beacon timer %d beacon tim %d\n",
+               le16_to_cpu(il->timing.beacon_interval),
+               le32_to_cpu(il->timing.beacon_init_val),
+               le16_to_cpu(il->timing.atim_win));
+
+       return il_send_cmd_pdu(il, C_RXON_TIMING, sizeof(il->timing),
+                              &il->timing);
+}
+EXPORT_SYMBOL(il_send_rxon_timing);
+
+void
+il_set_rxon_hwcrypto(struct il_priv *il, int hw_decrypt)
+{
+       struct il_rxon_cmd *rxon = &il->staging;
+
+       if (hw_decrypt)
+               rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
+       else
+               rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
+
+}
+EXPORT_SYMBOL(il_set_rxon_hwcrypto);
+
+/* validate RXON structure is valid */
+int
+il_check_rxon_cmd(struct il_priv *il)
+{
+       struct il_rxon_cmd *rxon = &il->staging;
+       bool error = false;
+
+       if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
+               if (rxon->flags & RXON_FLG_TGJ_NARROW_BAND_MSK) {
+                       IL_WARN("check 2.4G: wrong narrow\n");
+                       error = true;
+               }
+               if (rxon->flags & RXON_FLG_RADAR_DETECT_MSK) {
+                       IL_WARN("check 2.4G: wrong radar\n");
+                       error = true;
+               }
+       } else {
+               if (!(rxon->flags & RXON_FLG_SHORT_SLOT_MSK)) {
+                       IL_WARN("check 5.2G: not short slot!\n");
+                       error = true;
+               }
+               if (rxon->flags & RXON_FLG_CCK_MSK) {
+                       IL_WARN("check 5.2G: CCK!\n");
+                       error = true;
+               }
+       }
+       if ((rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1) {
+               IL_WARN("mac/bssid mcast!\n");
+               error = true;
+       }
+
+       /* make sure basic rates 6Mbps and 1Mbps are supported */
+       if ((rxon->ofdm_basic_rates & RATE_6M_MASK) == 0 &&
+           (rxon->cck_basic_rates & RATE_1M_MASK) == 0) {
+               IL_WARN("neither 1 nor 6 are basic\n");
+               error = true;
+       }
+
+       if (le16_to_cpu(rxon->assoc_id) > 2007) {
+               IL_WARN("aid > 2007\n");
+               error = true;
+       }
+
+       if ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK)) ==
+           (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK)) {
+               IL_WARN("CCK and short slot\n");
+               error = true;
+       }
+
+       if ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK)) ==
+           (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK)) {
+               IL_WARN("CCK and auto detect");
+               error = true;
+       }
+
+       if ((rxon->
+            flags & (RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK)) ==
+           RXON_FLG_TGG_PROTECT_MSK) {
+               IL_WARN("TGg but no auto-detect\n");
+               error = true;
+       }
+
+       if (error)
+               IL_WARN("Tuning to channel %d\n", le16_to_cpu(rxon->channel));
+
+       if (error) {
+               IL_ERR("Invalid RXON\n");
+               return -EINVAL;
+       }
+       return 0;
+}
+EXPORT_SYMBOL(il_check_rxon_cmd);
+
+/**
+ * il_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
+ * @il: staging_rxon is compared to active_rxon
+ *
+ * If the RXON structure is changing enough to require a new tune,
+ * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
+ * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
+ */
+int
+il_full_rxon_required(struct il_priv *il)
+{
+       const struct il_rxon_cmd *staging = &il->staging;
+       const struct il_rxon_cmd *active = &il->active;
+
+#define CHK(cond)                                                      \
+       if ((cond)) {                                                   \
+               D_INFO("need full RXON - " #cond "\n"); \
+               return 1;                                               \
+       }
+
+#define CHK_NEQ(c1, c2)                                                \
+       if ((c1) != (c2)) {                                     \
+               D_INFO("need full RXON - "      \
+                              #c1 " != " #c2 " - %d != %d\n",  \
+                              (c1), (c2));                     \
+               return 1;                                       \
+       }
+
+       /* These items are only settable from the full RXON command */
+       CHK(!il_is_associated(il));
+       CHK(!ether_addr_equal_64bits(staging->bssid_addr, active->bssid_addr));
+       CHK(!ether_addr_equal_64bits(staging->node_addr, active->node_addr));
+       CHK(!ether_addr_equal_64bits(staging->wlap_bssid_addr,
+                                    active->wlap_bssid_addr));
+       CHK_NEQ(staging->dev_type, active->dev_type);
+       CHK_NEQ(staging->channel, active->channel);
+       CHK_NEQ(staging->air_propagation, active->air_propagation);
+       CHK_NEQ(staging->ofdm_ht_single_stream_basic_rates,
+               active->ofdm_ht_single_stream_basic_rates);
+       CHK_NEQ(staging->ofdm_ht_dual_stream_basic_rates,
+               active->ofdm_ht_dual_stream_basic_rates);
+       CHK_NEQ(staging->assoc_id, active->assoc_id);
+
+       /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
+        * be updated with the RXON_ASSOC command -- however only some
+        * flag transitions are allowed using RXON_ASSOC */
+
+       /* Check if we are not switching bands */
+       CHK_NEQ(staging->flags & RXON_FLG_BAND_24G_MSK,
+               active->flags & RXON_FLG_BAND_24G_MSK);
+
+       /* Check if we are switching association toggle */
+       CHK_NEQ(staging->filter_flags & RXON_FILTER_ASSOC_MSK,
+               active->filter_flags & RXON_FILTER_ASSOC_MSK);
+
+#undef CHK
+#undef CHK_NEQ
+
+       return 0;
+}
+EXPORT_SYMBOL(il_full_rxon_required);
+
+u8
+il_get_lowest_plcp(struct il_priv *il)
+{
+       /*
+        * Assign the lowest rate -- should really get this from
+        * the beacon skb from mac80211.
+        */
+       if (il->staging.flags & RXON_FLG_BAND_24G_MSK)
+               return RATE_1M_PLCP;
+       else
+               return RATE_6M_PLCP;
+}
+EXPORT_SYMBOL(il_get_lowest_plcp);
+
+static void
+_il_set_rxon_ht(struct il_priv *il, struct il_ht_config *ht_conf)
+{
+       struct il_rxon_cmd *rxon = &il->staging;
+
+       if (!il->ht.enabled) {
+               rxon->flags &=
+                   ~(RXON_FLG_CHANNEL_MODE_MSK |
+                     RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK | RXON_FLG_HT40_PROT_MSK
+                     | RXON_FLG_HT_PROT_MSK);
+               return;
+       }
+
+       rxon->flags |=
+           cpu_to_le32(il->ht.protection << RXON_FLG_HT_OPERATING_MODE_POS);
+
+       /* Set up channel bandwidth:
+        * 20 MHz only, 20/40 mixed or pure 40 if ht40 ok */
+       /* clear the HT channel mode before set the mode */
+       rxon->flags &=
+           ~(RXON_FLG_CHANNEL_MODE_MSK | RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
+       if (il_is_ht40_tx_allowed(il, NULL)) {
+               /* pure ht40 */
+               if (il->ht.protection == IEEE80211_HT_OP_MODE_PROTECTION_20MHZ) {
+                       rxon->flags |= RXON_FLG_CHANNEL_MODE_PURE_40;
+                       /* Note: control channel is opposite of extension channel */
+                       switch (il->ht.extension_chan_offset) {
+                       case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+                               rxon->flags &=
+                                   ~RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
+                               break;
+                       case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+                               rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
+                               break;
+                       }
+               } else {
+                       /* Note: control channel is opposite of extension channel */
+                       switch (il->ht.extension_chan_offset) {
+                       case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+                               rxon->flags &=
+                                   ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
+                               rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
+                               break;
+                       case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+                               rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
+                               rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
+                               break;
+                       case IEEE80211_HT_PARAM_CHA_SEC_NONE:
+                       default:
+                               /* channel location only valid if in Mixed mode */
+                               IL_ERR("invalid extension channel offset\n");
+                               break;
+                       }
+               }
+       } else {
+               rxon->flags |= RXON_FLG_CHANNEL_MODE_LEGACY;
+       }
+
+       if (il->ops->set_rxon_chain)
+               il->ops->set_rxon_chain(il);
+
+       D_ASSOC("rxon flags 0x%X operation mode :0x%X "
+               "extension channel offset 0x%x\n", le32_to_cpu(rxon->flags),
+               il->ht.protection, il->ht.extension_chan_offset);
+}
+
+void
+il_set_rxon_ht(struct il_priv *il, struct il_ht_config *ht_conf)
+{
+       _il_set_rxon_ht(il, ht_conf);
+}
+EXPORT_SYMBOL(il_set_rxon_ht);
+
+/* Return valid, unused, channel for a passive scan to reset the RF */
+u8
+il_get_single_channel_number(struct il_priv *il, enum ieee80211_band band)
+{
+       const struct il_channel_info *ch_info;
+       int i;
+       u8 channel = 0;
+       u8 min, max;
+
+       if (band == IEEE80211_BAND_5GHZ) {
+               min = 14;
+               max = il->channel_count;
+       } else {
+               min = 0;
+               max = 14;
+       }
+
+       for (i = min; i < max; i++) {
+               channel = il->channel_info[i].channel;
+               if (channel == le16_to_cpu(il->staging.channel))
+                       continue;
+
+               ch_info = il_get_channel_info(il, band, channel);
+               if (il_is_channel_valid(ch_info))
+                       break;
+       }
+
+       return channel;
+}
+EXPORT_SYMBOL(il_get_single_channel_number);
+
+/**
+ * il_set_rxon_channel - Set the band and channel values in staging RXON
+ * @ch: requested channel as a pointer to struct ieee80211_channel
+
+ * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
+ * in the staging RXON flag structure based on the ch->band
+ */
+int
+il_set_rxon_channel(struct il_priv *il, struct ieee80211_channel *ch)
+{
+       enum ieee80211_band band = ch->band;
+       u16 channel = ch->hw_value;
+
+       if (le16_to_cpu(il->staging.channel) == channel && il->band == band)
+               return 0;
+
+       il->staging.channel = cpu_to_le16(channel);
+       if (band == IEEE80211_BAND_5GHZ)
+               il->staging.flags &= ~RXON_FLG_BAND_24G_MSK;
+       else
+               il->staging.flags |= RXON_FLG_BAND_24G_MSK;
+
+       il->band = band;
+
+       D_INFO("Staging channel set to %d [%d]\n", channel, band);
+
+       return 0;
+}
+EXPORT_SYMBOL(il_set_rxon_channel);
+
+void
+il_set_flags_for_band(struct il_priv *il, enum ieee80211_band band,
+                     struct ieee80211_vif *vif)
+{
+       if (band == IEEE80211_BAND_5GHZ) {
+               il->staging.flags &=
+                   ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK |
+                     RXON_FLG_CCK_MSK);
+               il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
+       } else {
+               /* Copied from il_post_associate() */
+               if (vif && vif->bss_conf.use_short_slot)
+                       il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
+               else
+                       il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
+
+               il->staging.flags |= RXON_FLG_BAND_24G_MSK;
+               il->staging.flags |= RXON_FLG_AUTO_DETECT_MSK;
+               il->staging.flags &= ~RXON_FLG_CCK_MSK;
+       }
+}
+EXPORT_SYMBOL(il_set_flags_for_band);
+
+/*
+ * initialize rxon structure with default values from eeprom
+ */
+void
+il_connection_init_rx_config(struct il_priv *il)
+{
+       const struct il_channel_info *ch_info;
+
+       memset(&il->staging, 0, sizeof(il->staging));
+
+       switch (il->iw_mode) {
+       case NL80211_IFTYPE_UNSPECIFIED:
+               il->staging.dev_type = RXON_DEV_TYPE_ESS;
+               break;
+       case NL80211_IFTYPE_STATION:
+               il->staging.dev_type = RXON_DEV_TYPE_ESS;
+               il->staging.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
+               break;
+       case NL80211_IFTYPE_ADHOC:
+               il->staging.dev_type = RXON_DEV_TYPE_IBSS;
+               il->staging.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
+               il->staging.filter_flags =
+                   RXON_FILTER_BCON_AWARE_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
+               break;
+       default:
+               IL_ERR("Unsupported interface type %d\n", il->vif->type);
+               return;
+       }
+
+#if 0
+       /* TODO:  Figure out when short_preamble would be set and cache from
+        * that */
+       if (!hw_to_local(il->hw)->short_preamble)
+               il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+       else
+               il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+#endif
+
+       ch_info =
+           il_get_channel_info(il, il->band, le16_to_cpu(il->active.channel));
+
+       if (!ch_info)
+               ch_info = &il->channel_info[0];
+
+       il->staging.channel = cpu_to_le16(ch_info->channel);
+       il->band = ch_info->band;
+
+       il_set_flags_for_band(il, il->band, il->vif);
+
+       il->staging.ofdm_basic_rates =
+           (IL_OFDM_RATES_MASK >> IL_FIRST_OFDM_RATE) & 0xFF;
+       il->staging.cck_basic_rates =
+           (IL_CCK_RATES_MASK >> IL_FIRST_CCK_RATE) & 0xF;
+
+       /* clear both MIX and PURE40 mode flag */
+       il->staging.flags &=
+           ~(RXON_FLG_CHANNEL_MODE_MIXED | RXON_FLG_CHANNEL_MODE_PURE_40);
+       if (il->vif)
+               memcpy(il->staging.node_addr, il->vif->addr, ETH_ALEN);
+
+       il->staging.ofdm_ht_single_stream_basic_rates = 0xff;
+       il->staging.ofdm_ht_dual_stream_basic_rates = 0xff;
+}
+EXPORT_SYMBOL(il_connection_init_rx_config);
+
+void
+il_set_rate(struct il_priv *il)
+{
+       const struct ieee80211_supported_band *hw = NULL;
+       struct ieee80211_rate *rate;
+       int i;
+
+       hw = il_get_hw_mode(il, il->band);
+       if (!hw) {
+               IL_ERR("Failed to set rate: unable to get hw mode\n");
+               return;
+       }
+
+       il->active_rate = 0;
+
+       for (i = 0; i < hw->n_bitrates; i++) {
+               rate = &(hw->bitrates[i]);
+               if (rate->hw_value < RATE_COUNT_LEGACY)
+                       il->active_rate |= (1 << rate->hw_value);
+       }
+
+       D_RATE("Set active_rate = %0x\n", il->active_rate);
+
+       il->staging.cck_basic_rates =
+           (IL_CCK_BASIC_RATES_MASK >> IL_FIRST_CCK_RATE) & 0xF;
+
+       il->staging.ofdm_basic_rates =
+           (IL_OFDM_BASIC_RATES_MASK >> IL_FIRST_OFDM_RATE) & 0xFF;
+}
+EXPORT_SYMBOL(il_set_rate);
+
+void
+il_chswitch_done(struct il_priv *il, bool is_success)
+{
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       if (test_and_clear_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
+               ieee80211_chswitch_done(il->vif, is_success);
+}
+EXPORT_SYMBOL(il_chswitch_done);
+
+void
+il_hdl_csa(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_csa_notification *csa = &(pkt->u.csa_notif);
+       struct il_rxon_cmd *rxon = (void *)&il->active;
+
+       if (!test_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
+               return;
+
+       if (!le32_to_cpu(csa->status) && csa->channel == il->switch_channel) {
+               rxon->channel = csa->channel;
+               il->staging.channel = csa->channel;
+               D_11H("CSA notif: channel %d\n", le16_to_cpu(csa->channel));
+               il_chswitch_done(il, true);
+       } else {
+               IL_ERR("CSA notif (fail) : channel %d\n",
+                      le16_to_cpu(csa->channel));
+               il_chswitch_done(il, false);
+       }
+}
+EXPORT_SYMBOL(il_hdl_csa);
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+void
+il_print_rx_config_cmd(struct il_priv *il)
+{
+       struct il_rxon_cmd *rxon = &il->staging;
+
+       D_RADIO("RX CONFIG:\n");
+       il_print_hex_dump(il, IL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
+       D_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
+       D_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
+       D_RADIO("u32 filter_flags: 0x%08x\n", le32_to_cpu(rxon->filter_flags));
+       D_RADIO("u8 dev_type: 0x%x\n", rxon->dev_type);
+       D_RADIO("u8 ofdm_basic_rates: 0x%02x\n", rxon->ofdm_basic_rates);
+       D_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
+       D_RADIO("u8[6] node_addr: %pM\n", rxon->node_addr);
+       D_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
+       D_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
+}
+EXPORT_SYMBOL(il_print_rx_config_cmd);
+#endif
+/**
+ * il_irq_handle_error - called for HW or SW error interrupt from card
+ */
+void
+il_irq_handle_error(struct il_priv *il)
+{
+       /* Set the FW error flag -- cleared on il_down */
+       set_bit(S_FW_ERROR, &il->status);
+
+       /* Cancel currently queued command. */
+       clear_bit(S_HCMD_ACTIVE, &il->status);
+
+       IL_ERR("Loaded firmware version: %s\n", il->hw->wiphy->fw_version);
+
+       il->ops->dump_nic_error_log(il);
+       if (il->ops->dump_fh)
+               il->ops->dump_fh(il, NULL, false);
+#ifdef CONFIG_IWLEGACY_DEBUG
+       if (il_get_debug_level(il) & IL_DL_FW_ERRORS)
+               il_print_rx_config_cmd(il);
+#endif
+
+       wake_up(&il->wait_command_queue);
+
+       /* Keep the restart process from trying to send host
+        * commands by clearing the INIT status bit */
+       clear_bit(S_READY, &il->status);
+
+       if (!test_bit(S_EXIT_PENDING, &il->status)) {
+               IL_DBG(IL_DL_FW_ERRORS,
+                      "Restarting adapter due to uCode error.\n");
+
+               if (il->cfg->mod_params->restart_fw)
+                       queue_work(il->workqueue, &il->restart);
+       }
+}
+EXPORT_SYMBOL(il_irq_handle_error);
+
+static int
+_il_apm_stop_master(struct il_priv *il)
+{
+       int ret = 0;
+
+       /* stop device's busmaster DMA activity */
+       _il_set_bit(il, CSR_RESET, CSR_RESET_REG_FLAG_STOP_MASTER);
+
+       ret =
+           _il_poll_bit(il, CSR_RESET, CSR_RESET_REG_FLAG_MASTER_DISABLED,
+                        CSR_RESET_REG_FLAG_MASTER_DISABLED, 100);
+       if (ret < 0)
+               IL_WARN("Master Disable Timed Out, 100 usec\n");
+
+       D_INFO("stop master\n");
+
+       return ret;
+}
+
+void
+_il_apm_stop(struct il_priv *il)
+{
+       lockdep_assert_held(&il->reg_lock);
+
+       D_INFO("Stop card, put in low power state\n");
+
+       /* Stop device's DMA activity */
+       _il_apm_stop_master(il);
+
+       /* Reset the entire device */
+       _il_set_bit(il, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);
+
+       udelay(10);
+
+       /*
+        * Clear "initialization complete" bit to move adapter from
+        * D0A* (powered-up Active) --> D0U* (Uninitialized) state.
+        */
+       _il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
+}
+EXPORT_SYMBOL(_il_apm_stop);
+
+void
+il_apm_stop(struct il_priv *il)
+{
+       unsigned long flags;
+
+       spin_lock_irqsave(&il->reg_lock, flags);
+       _il_apm_stop(il);
+       spin_unlock_irqrestore(&il->reg_lock, flags);
+}
+EXPORT_SYMBOL(il_apm_stop);
+
+/*
+ * Start up NIC's basic functionality after it has been reset
+ * (e.g. after platform boot, or shutdown via il_apm_stop())
+ * NOTE:  This does not load uCode nor start the embedded processor
+ */
+int
+il_apm_init(struct il_priv *il)
+{
+       int ret = 0;
+       u16 lctl;
+
+       D_INFO("Init card's basic functions\n");
+
+       /*
+        * Use "set_bit" below rather than "write", to preserve any hardware
+        * bits already set by default after reset.
+        */
+
+       /* Disable L0S exit timer (platform NMI Work/Around) */
+       il_set_bit(il, CSR_GIO_CHICKEN_BITS,
+                  CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
+
+       /*
+        * Disable L0s without affecting L1;
+        *  don't wait for ICH L0s (ICH bug W/A)
+        */
+       il_set_bit(il, CSR_GIO_CHICKEN_BITS,
+                  CSR_GIO_CHICKEN_BITS_REG_BIT_L1A_NO_L0S_RX);
+
+       /* Set FH wait threshold to maximum (HW error during stress W/A) */
+       il_set_bit(il, CSR_DBG_HPET_MEM_REG, CSR_DBG_HPET_MEM_REG_VAL);
+
+       /*
+        * Enable HAP INTA (interrupt from management bus) to
+        * wake device's PCI Express link L1a -> L0s
+        * NOTE:  This is no-op for 3945 (non-existent bit)
+        */
+       il_set_bit(il, CSR_HW_IF_CONFIG_REG,
+                  CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A);
+
+       /*
+        * HW bug W/A for instability in PCIe bus L0->L0S->L1 transition.
+        * Check if BIOS (or OS) enabled L1-ASPM on this device.
+        * If so (likely), disable L0S, so device moves directly L0->L1;
+        *    costs negligible amount of power savings.
+        * If not (unlikely), enable L0S, so there is at least some
+        *    power savings, even without L1.
+        */
+       if (il->cfg->set_l0s) {
+               pcie_capability_read_word(il->pci_dev, PCI_EXP_LNKCTL, &lctl);
+               if (lctl & PCI_EXP_LNKCTL_ASPM_L1) {
+                       /* L1-ASPM enabled; disable(!) L0S  */
+                       il_set_bit(il, CSR_GIO_REG,
+                                  CSR_GIO_REG_VAL_L0S_ENABLED);
+                       D_POWER("L1 Enabled; Disabling L0S\n");
+               } else {
+                       /* L1-ASPM disabled; enable(!) L0S */
+                       il_clear_bit(il, CSR_GIO_REG,
+                                    CSR_GIO_REG_VAL_L0S_ENABLED);
+                       D_POWER("L1 Disabled; Enabling L0S\n");
+               }
+       }
+
+       /* Configure analog phase-lock-loop before activating to D0A */
+       if (il->cfg->pll_cfg_val)
+               il_set_bit(il, CSR_ANA_PLL_CFG,
+                          il->cfg->pll_cfg_val);
+
+       /*
+        * Set "initialization complete" bit to move adapter from
+        * D0U* --> D0A* (powered-up active) state.
+        */
+       il_set_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
+
+       /*
+        * Wait for clock stabilization; once stabilized, access to
+        * device-internal resources is supported, e.g. il_wr_prph()
+        * and accesses to uCode SRAM.
+        */
+       ret =
+           _il_poll_bit(il, CSR_GP_CNTRL,
+                        CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
+                        CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
+       if (ret < 0) {
+               D_INFO("Failed to init the card\n");
+               goto out;
+       }
+
+       /*
+        * Enable DMA and BSM (if used) clocks, wait for them to stabilize.
+        * BSM (Boostrap State Machine) is only in 3945 and 4965.
+        *
+        * Write to "CLK_EN_REG"; "1" bits enable clocks, while "0" bits
+        * do not disable clocks.  This preserves any hardware bits already
+        * set by default in "CLK_CTRL_REG" after reset.
+        */
+       if (il->cfg->use_bsm)
+               il_wr_prph(il, APMG_CLK_EN_REG,
+                          APMG_CLK_VAL_DMA_CLK_RQT | APMG_CLK_VAL_BSM_CLK_RQT);
+       else
+               il_wr_prph(il, APMG_CLK_EN_REG, APMG_CLK_VAL_DMA_CLK_RQT);
+       udelay(20);
+
+       /* Disable L1-Active */
+       il_set_bits_prph(il, APMG_PCIDEV_STT_REG,
+                        APMG_PCIDEV_STT_VAL_L1_ACT_DIS);
+
+out:
+       return ret;
+}
+EXPORT_SYMBOL(il_apm_init);
+
+int
+il_set_tx_power(struct il_priv *il, s8 tx_power, bool force)
+{
+       int ret;
+       s8 prev_tx_power;
+       bool defer;
+
+       lockdep_assert_held(&il->mutex);
+
+       if (il->tx_power_user_lmt == tx_power && !force)
+               return 0;
+
+       if (!il->ops->send_tx_power)
+               return -EOPNOTSUPP;
+
+       /* 0 dBm mean 1 milliwatt */
+       if (tx_power < 0) {
+               IL_WARN("Requested user TXPOWER %d below 1 mW.\n", tx_power);
+               return -EINVAL;
+       }
+
+       if (tx_power > il->tx_power_device_lmt) {
+               IL_WARN("Requested user TXPOWER %d above upper limit %d.\n",
+                       tx_power, il->tx_power_device_lmt);
+               return -EINVAL;
+       }
+
+       if (!il_is_ready_rf(il))
+               return -EIO;
+
+       /* scan complete and commit_rxon use tx_power_next value,
+        * it always need to be updated for newest request */
+       il->tx_power_next = tx_power;
+
+       /* do not set tx power when scanning or channel changing */
+       defer = test_bit(S_SCANNING, &il->status) ||
+           memcmp(&il->active, &il->staging, sizeof(il->staging));
+       if (defer && !force) {
+               D_INFO("Deferring tx power set\n");
+               return 0;
+       }
+
+       prev_tx_power = il->tx_power_user_lmt;
+       il->tx_power_user_lmt = tx_power;
+
+       ret = il->ops->send_tx_power(il);
+
+       /* if fail to set tx_power, restore the orig. tx power */
+       if (ret) {
+               il->tx_power_user_lmt = prev_tx_power;
+               il->tx_power_next = prev_tx_power;
+       }
+       return ret;
+}
+EXPORT_SYMBOL(il_set_tx_power);
+
+void
+il_send_bt_config(struct il_priv *il)
+{
+       struct il_bt_cmd bt_cmd = {
+               .lead_time = BT_LEAD_TIME_DEF,
+               .max_kill = BT_MAX_KILL_DEF,
+               .kill_ack_mask = 0,
+               .kill_cts_mask = 0,
+       };
+
+       if (!bt_coex_active)
+               bt_cmd.flags = BT_COEX_DISABLE;
+       else
+               bt_cmd.flags = BT_COEX_ENABLE;
+
+       D_INFO("BT coex %s\n",
+              (bt_cmd.flags == BT_COEX_DISABLE) ? "disable" : "active");
+
+       if (il_send_cmd_pdu(il, C_BT_CONFIG, sizeof(struct il_bt_cmd), &bt_cmd))
+               IL_ERR("failed to send BT Coex Config\n");
+}
+EXPORT_SYMBOL(il_send_bt_config);
+
+int
+il_send_stats_request(struct il_priv *il, u8 flags, bool clear)
+{
+       struct il_stats_cmd stats_cmd = {
+               .configuration_flags = clear ? IL_STATS_CONF_CLEAR_STATS : 0,
+       };
+
+       if (flags & CMD_ASYNC)
+               return il_send_cmd_pdu_async(il, C_STATS, sizeof(struct il_stats_cmd),
+                                            &stats_cmd, NULL);
+       else
+               return il_send_cmd_pdu(il, C_STATS, sizeof(struct il_stats_cmd),
+                                      &stats_cmd);
+}
+EXPORT_SYMBOL(il_send_stats_request);
+
+void
+il_hdl_pm_sleep(struct il_priv *il, struct il_rx_buf *rxb)
+{
+#ifdef CONFIG_IWLEGACY_DEBUG
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       struct il_sleep_notification *sleep = &(pkt->u.sleep_notif);
+       D_RX("sleep mode: %d, src: %d\n",
+            sleep->pm_sleep_mode, sleep->pm_wakeup_src);
+#endif
+}
+EXPORT_SYMBOL(il_hdl_pm_sleep);
+
+void
+il_hdl_pm_debug_stats(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+       u32 len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
+       D_RADIO("Dumping %d bytes of unhandled notification for %s:\n", len,
+               il_get_cmd_string(pkt->hdr.cmd));
+       il_print_hex_dump(il, IL_DL_RADIO, pkt->u.raw, len);
+}
+EXPORT_SYMBOL(il_hdl_pm_debug_stats);
+
+void
+il_hdl_error(struct il_priv *il, struct il_rx_buf *rxb)
+{
+       struct il_rx_pkt *pkt = rxb_addr(rxb);
+
+       IL_ERR("Error Reply type 0x%08X cmd %s (0x%02X) "
+              "seq 0x%04X ser 0x%08X\n",
+              le32_to_cpu(pkt->u.err_resp.error_type),
+              il_get_cmd_string(pkt->u.err_resp.cmd_id),
+              pkt->u.err_resp.cmd_id,
+              le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
+              le32_to_cpu(pkt->u.err_resp.error_info));
+}
+EXPORT_SYMBOL(il_hdl_error);
+
+void
+il_clear_isr_stats(struct il_priv *il)
+{
+       memset(&il->isr_stats, 0, sizeof(il->isr_stats));
+}
+
+int
+il_mac_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue,
+              const struct ieee80211_tx_queue_params *params)
+{
+       struct il_priv *il = hw->priv;
+       unsigned long flags;
+       int q;
+
+       D_MAC80211("enter\n");
+
+       if (!il_is_ready_rf(il)) {
+               D_MAC80211("leave - RF not ready\n");
+               return -EIO;
+       }
+
+       if (queue >= AC_NUM) {
+               D_MAC80211("leave - queue >= AC_NUM %d\n", queue);
+               return 0;
+       }
+
+       q = AC_NUM - 1 - queue;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       il->qos_data.def_qos_parm.ac[q].cw_min =
+           cpu_to_le16(params->cw_min);
+       il->qos_data.def_qos_parm.ac[q].cw_max =
+           cpu_to_le16(params->cw_max);
+       il->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
+       il->qos_data.def_qos_parm.ac[q].edca_txop =
+           cpu_to_le16((params->txop * 32));
+
+       il->qos_data.def_qos_parm.ac[q].reserved1 = 0;
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       D_MAC80211("leave\n");
+       return 0;
+}
+EXPORT_SYMBOL(il_mac_conf_tx);
+
+int
+il_mac_tx_last_beacon(struct ieee80211_hw *hw)
+{
+       struct il_priv *il = hw->priv;
+       int ret;
+
+       D_MAC80211("enter\n");
+
+       ret = (il->ibss_manager == IL_IBSS_MANAGER);
+
+       D_MAC80211("leave ret %d\n", ret);
+       return ret;
+}
+EXPORT_SYMBOL_GPL(il_mac_tx_last_beacon);
+
+static int
+il_set_mode(struct il_priv *il)
+{
+       il_connection_init_rx_config(il);
+
+       if (il->ops->set_rxon_chain)
+               il->ops->set_rxon_chain(il);
+
+       return il_commit_rxon(il);
+}
+
+int
+il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+{
+       struct il_priv *il = hw->priv;
+       int err;
+       bool reset;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
+
+       if (!il_is_ready_rf(il)) {
+               IL_WARN("Try to add interface when device not ready\n");
+               err = -EINVAL;
+               goto out;
+       }
+
+       /*
+        * We do not support multiple virtual interfaces, but on hardware reset
+        * we have to add the same interface again.
+        */
+       reset = (il->vif == vif);
+       if (il->vif && !reset) {
+               err = -EOPNOTSUPP;
+               goto out;
+       }
+
+       il->vif = vif;
+       il->iw_mode = vif->type;
+
+       err = il_set_mode(il);
+       if (err) {
+               IL_WARN("Fail to set mode %d\n", vif->type);
+               if (!reset) {
+                       il->vif = NULL;
+                       il->iw_mode = NL80211_IFTYPE_STATION;
+               }
+       }
+
+out:
+       D_MAC80211("leave err %d\n", err);
+       mutex_unlock(&il->mutex);
+
+       return err;
+}
+EXPORT_SYMBOL(il_mac_add_interface);
+
+static void
+il_teardown_interface(struct il_priv *il, struct ieee80211_vif *vif)
+{
+       lockdep_assert_held(&il->mutex);
+
+       if (il->scan_vif == vif) {
+               il_scan_cancel_timeout(il, 200);
+               il_force_scan_end(il);
+       }
+
+       il_set_mode(il);
+}
+
+void
+il_mac_remove_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+{
+       struct il_priv *il = hw->priv;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
+
+       WARN_ON(il->vif != vif);
+       il->vif = NULL;
+       il->iw_mode = NL80211_IFTYPE_UNSPECIFIED;
+       il_teardown_interface(il, vif);
+       eth_zero_addr(il->bssid);
+
+       D_MAC80211("leave\n");
+       mutex_unlock(&il->mutex);
+}
+EXPORT_SYMBOL(il_mac_remove_interface);
+
+int
+il_alloc_txq_mem(struct il_priv *il)
+{
+       if (!il->txq)
+               il->txq =
+                   kzalloc(sizeof(struct il_tx_queue) *
+                           il->cfg->num_of_queues, GFP_KERNEL);
+       if (!il->txq) {
+               IL_ERR("Not enough memory for txq\n");
+               return -ENOMEM;
+       }
+       return 0;
+}
+EXPORT_SYMBOL(il_alloc_txq_mem);
+
+void
+il_free_txq_mem(struct il_priv *il)
+{
+       kfree(il->txq);
+       il->txq = NULL;
+}
+EXPORT_SYMBOL(il_free_txq_mem);
+
+int
+il_force_reset(struct il_priv *il, bool external)
+{
+       struct il_force_reset *force_reset;
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return -EINVAL;
+
+       force_reset = &il->force_reset;
+       force_reset->reset_request_count++;
+       if (!external) {
+               if (force_reset->last_force_reset_jiffies &&
+                   time_after(force_reset->last_force_reset_jiffies +
+                              force_reset->reset_duration, jiffies)) {
+                       D_INFO("force reset rejected\n");
+                       force_reset->reset_reject_count++;
+                       return -EAGAIN;
+               }
+       }
+       force_reset->reset_success_count++;
+       force_reset->last_force_reset_jiffies = jiffies;
+
+       /*
+        * if the request is from external(ex: debugfs),
+        * then always perform the request in regardless the module
+        * parameter setting
+        * if the request is from internal (uCode error or driver
+        * detect failure), then fw_restart module parameter
+        * need to be check before performing firmware reload
+        */
+
+       if (!external && !il->cfg->mod_params->restart_fw) {
+               D_INFO("Cancel firmware reload based on "
+                      "module parameter setting\n");
+               return 0;
+       }
+
+       IL_ERR("On demand firmware reload\n");
+
+       /* Set the FW error flag -- cleared on il_down */
+       set_bit(S_FW_ERROR, &il->status);
+       wake_up(&il->wait_command_queue);
+       /*
+        * Keep the restart process from trying to send host
+        * commands by clearing the INIT status bit
+        */
+       clear_bit(S_READY, &il->status);
+       queue_work(il->workqueue, &il->restart);
+
+       return 0;
+}
+EXPORT_SYMBOL(il_force_reset);
+
+int
+il_mac_change_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                       enum nl80211_iftype newtype, bool newp2p)
+{
+       struct il_priv *il = hw->priv;
+       int err;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter: type %d, addr %pM newtype %d newp2p %d\n",
+                   vif->type, vif->addr, newtype, newp2p);
+
+       if (newp2p) {
+               err = -EOPNOTSUPP;
+               goto out;
+       }
+
+       if (!il->vif || !il_is_ready_rf(il)) {
+               /*
+                * Huh? But wait ... this can maybe happen when
+                * we're in the middle of a firmware restart!
+                */
+               err = -EBUSY;
+               goto out;
+       }
+
+       /* success */
+       vif->type = newtype;
+       vif->p2p = false;
+       il->iw_mode = newtype;
+       il_teardown_interface(il, vif);
+       err = 0;
+
+out:
+       D_MAC80211("leave err %d\n", err);
+       mutex_unlock(&il->mutex);
+
+       return err;
+}
+EXPORT_SYMBOL(il_mac_change_interface);
+
+void il_mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                 u32 queues, bool drop)
+{
+       struct il_priv *il = hw->priv;
+       unsigned long timeout = jiffies + msecs_to_jiffies(500);
+       int i;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter\n");
+
+       if (il->txq == NULL)
+               goto out;
+
+       for (i = 0; i < il->hw_params.max_txq_num; i++) {
+               struct il_queue *q;
+
+               if (i == il->cmd_queue)
+                       continue;
+
+               q = &il->txq[i].q;
+               if (q->read_ptr == q->write_ptr)
+                       continue;
+
+               if (time_after(jiffies, timeout)) {
+                       IL_ERR("Failed to flush queue %d\n", q->id);
+                       break;
+               }
+
+               msleep(20);
+       }
+out:
+       D_MAC80211("leave\n");
+       mutex_unlock(&il->mutex);
+}
+EXPORT_SYMBOL(il_mac_flush);
+
+/*
+ * On every watchdog tick we check (latest) time stamp. If it does not
+ * change during timeout period and queue is not empty we reset firmware.
+ */
+static int
+il_check_stuck_queue(struct il_priv *il, int cnt)
+{
+       struct il_tx_queue *txq = &il->txq[cnt];
+       struct il_queue *q = &txq->q;
+       unsigned long timeout;
+       unsigned long now = jiffies;
+       int ret;
+
+       if (q->read_ptr == q->write_ptr) {
+               txq->time_stamp = now;
+               return 0;
+       }
+
+       timeout =
+           txq->time_stamp +
+           msecs_to_jiffies(il->cfg->wd_timeout);
+
+       if (time_after(now, timeout)) {
+               IL_ERR("Queue %d stuck for %u ms.\n", q->id,
+                      jiffies_to_msecs(now - txq->time_stamp));
+               ret = il_force_reset(il, false);
+               return (ret == -EAGAIN) ? 0 : 1;
+       }
+
+       return 0;
+}
+
+/*
+ * Making watchdog tick be a quarter of timeout assure we will
+ * discover the queue hung between timeout and 1.25*timeout
+ */
+#define IL_WD_TICK(timeout) ((timeout) / 4)
+
+/*
+ * Watchdog timer callback, we check each tx queue for stuck, if if hung
+ * we reset the firmware. If everything is fine just rearm the timer.
+ */
+void
+il_bg_watchdog(unsigned long data)
+{
+       struct il_priv *il = (struct il_priv *)data;
+       int cnt;
+       unsigned long timeout;
+
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       timeout = il->cfg->wd_timeout;
+       if (timeout == 0)
+               return;
+
+       /* monitor and check for stuck cmd queue */
+       if (il_check_stuck_queue(il, il->cmd_queue))
+               return;
+
+       /* monitor and check for other stuck queues */
+       for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
+               /* skip as we already checked the command queue */
+               if (cnt == il->cmd_queue)
+                       continue;
+               if (il_check_stuck_queue(il, cnt))
+                       return;
+       }
+
+       mod_timer(&il->watchdog,
+                 jiffies + msecs_to_jiffies(IL_WD_TICK(timeout)));
+}
+EXPORT_SYMBOL(il_bg_watchdog);
+
+void
+il_setup_watchdog(struct il_priv *il)
+{
+       unsigned int timeout = il->cfg->wd_timeout;
+
+       if (timeout)
+               mod_timer(&il->watchdog,
+                         jiffies + msecs_to_jiffies(IL_WD_TICK(timeout)));
+       else
+               del_timer(&il->watchdog);
+}
+EXPORT_SYMBOL(il_setup_watchdog);
+
+/*
+ * extended beacon time format
+ * time in usec will be changed into a 32-bit value in extended:internal format
+ * the extended part is the beacon counts
+ * the internal part is the time in usec within one beacon interval
+ */
+u32
+il_usecs_to_beacons(struct il_priv *il, u32 usec, u32 beacon_interval)
+{
+       u32 quot;
+       u32 rem;
+       u32 interval = beacon_interval * TIME_UNIT;
+
+       if (!interval || !usec)
+               return 0;
+
+       quot =
+           (usec /
+            interval) & (il_beacon_time_mask_high(il,
+                                                  il->hw_params.
+                                                  beacon_time_tsf_bits) >> il->
+                         hw_params.beacon_time_tsf_bits);
+       rem =
+           (usec % interval) & il_beacon_time_mask_low(il,
+                                                       il->hw_params.
+                                                       beacon_time_tsf_bits);
+
+       return (quot << il->hw_params.beacon_time_tsf_bits) + rem;
+}
+EXPORT_SYMBOL(il_usecs_to_beacons);
+
+/* base is usually what we get from ucode with each received frame,
+ * the same as HW timer counter counting down
+ */
+__le32
+il_add_beacon_time(struct il_priv *il, u32 base, u32 addon,
+                  u32 beacon_interval)
+{
+       u32 base_low = base & il_beacon_time_mask_low(il,
+                                                     il->hw_params.
+                                                     beacon_time_tsf_bits);
+       u32 addon_low = addon & il_beacon_time_mask_low(il,
+                                                       il->hw_params.
+                                                       beacon_time_tsf_bits);
+       u32 interval = beacon_interval * TIME_UNIT;
+       u32 res = (base & il_beacon_time_mask_high(il,
+                                                  il->hw_params.
+                                                  beacon_time_tsf_bits)) +
+           (addon & il_beacon_time_mask_high(il,
+                                             il->hw_params.
+                                             beacon_time_tsf_bits));
+
+       if (base_low > addon_low)
+               res += base_low - addon_low;
+       else if (base_low < addon_low) {
+               res += interval + base_low - addon_low;
+               res += (1 << il->hw_params.beacon_time_tsf_bits);
+       } else
+               res += (1 << il->hw_params.beacon_time_tsf_bits);
+
+       return cpu_to_le32(res);
+}
+EXPORT_SYMBOL(il_add_beacon_time);
+
+#ifdef CONFIG_PM_SLEEP
+
+static int
+il_pci_suspend(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct il_priv *il = pci_get_drvdata(pdev);
+
+       /*
+        * This function is called when system goes into suspend state
+        * mac80211 will call il_mac_stop() from the mac80211 suspend function
+        * first but since il_mac_stop() has no knowledge of who the caller is,
+        * it will not call apm_ops.stop() to stop the DMA operation.
+        * Calling apm_ops.stop here to make sure we stop the DMA.
+        */
+       il_apm_stop(il);
+
+       return 0;
+}
+
+static int
+il_pci_resume(struct device *device)
+{
+       struct pci_dev *pdev = to_pci_dev(device);
+       struct il_priv *il = pci_get_drvdata(pdev);
+       bool hw_rfkill = false;
+
+       /*
+        * We disable the RETRY_TIMEOUT register (0x41) to keep
+        * PCI Tx retries from interfering with C3 CPU state.
+        */
+       pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
+
+       il_enable_interrupts(il);
+
+       if (!(_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
+               hw_rfkill = true;
+
+       if (hw_rfkill)
+               set_bit(S_RFKILL, &il->status);
+       else
+               clear_bit(S_RFKILL, &il->status);
+
+       wiphy_rfkill_set_hw_state(il->hw->wiphy, hw_rfkill);
+
+       return 0;
+}
+
+SIMPLE_DEV_PM_OPS(il_pm_ops, il_pci_suspend, il_pci_resume);
+EXPORT_SYMBOL(il_pm_ops);
+
+#endif /* CONFIG_PM_SLEEP */
+
+static void
+il_update_qos(struct il_priv *il)
+{
+       if (test_bit(S_EXIT_PENDING, &il->status))
+               return;
+
+       il->qos_data.def_qos_parm.qos_flags = 0;
+
+       if (il->qos_data.qos_active)
+               il->qos_data.def_qos_parm.qos_flags |=
+                   QOS_PARAM_FLG_UPDATE_EDCA_MSK;
+
+       if (il->ht.enabled)
+               il->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;
+
+       D_QOS("send QoS cmd with Qos active=%d FLAGS=0x%X\n",
+             il->qos_data.qos_active, il->qos_data.def_qos_parm.qos_flags);
+
+       il_send_cmd_pdu_async(il, C_QOS_PARAM, sizeof(struct il_qosparam_cmd),
+                             &il->qos_data.def_qos_parm, NULL);
+}
+
+/**
+ * il_mac_config - mac80211 config callback
+ */
+int
+il_mac_config(struct ieee80211_hw *hw, u32 changed)
+{
+       struct il_priv *il = hw->priv;
+       const struct il_channel_info *ch_info;
+       struct ieee80211_conf *conf = &hw->conf;
+       struct ieee80211_channel *channel = conf->chandef.chan;
+       struct il_ht_config *ht_conf = &il->current_ht_config;
+       unsigned long flags = 0;
+       int ret = 0;
+       u16 ch;
+       int scan_active = 0;
+       bool ht_changed = false;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter: channel %d changed 0x%X\n", channel->hw_value,
+                  changed);
+
+       if (unlikely(test_bit(S_SCANNING, &il->status))) {
+               scan_active = 1;
+               D_MAC80211("scan active\n");
+       }
+
+       if (changed &
+           (IEEE80211_CONF_CHANGE_SMPS | IEEE80211_CONF_CHANGE_CHANNEL)) {
+               /* mac80211 uses static for non-HT which is what we want */
+               il->current_ht_config.smps = conf->smps_mode;
+
+               /*
+                * Recalculate chain counts.
+                *
+                * If monitor mode is enabled then mac80211 will
+                * set up the SM PS mode to OFF if an HT channel is
+                * configured.
+                */
+               if (il->ops->set_rxon_chain)
+                       il->ops->set_rxon_chain(il);
+       }
+
+       /* during scanning mac80211 will delay channel setting until
+        * scan finish with changed = 0
+        */
+       if (!changed || (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
+
+               if (scan_active)
+                       goto set_ch_out;
+
+               ch = channel->hw_value;
+               ch_info = il_get_channel_info(il, channel->band, ch);
+               if (!il_is_channel_valid(ch_info)) {
+                       D_MAC80211("leave - invalid channel\n");
+                       ret = -EINVAL;
+                       goto set_ch_out;
+               }
+
+               if (il->iw_mode == NL80211_IFTYPE_ADHOC &&
+                   !il_is_channel_ibss(ch_info)) {
+                       D_MAC80211("leave - not IBSS channel\n");
+                       ret = -EINVAL;
+                       goto set_ch_out;
+               }
+
+               spin_lock_irqsave(&il->lock, flags);
+
+               /* Configure HT40 channels */
+               if (il->ht.enabled != conf_is_ht(conf)) {
+                       il->ht.enabled = conf_is_ht(conf);
+                       ht_changed = true;
+               }
+               if (il->ht.enabled) {
+                       if (conf_is_ht40_minus(conf)) {
+                               il->ht.extension_chan_offset =
+                                   IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+                               il->ht.is_40mhz = true;
+                       } else if (conf_is_ht40_plus(conf)) {
+                               il->ht.extension_chan_offset =
+                                   IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
+                               il->ht.is_40mhz = true;
+                       } else {
+                               il->ht.extension_chan_offset =
+                                   IEEE80211_HT_PARAM_CHA_SEC_NONE;
+                               il->ht.is_40mhz = false;
+                       }
+               } else
+                       il->ht.is_40mhz = false;
+
+               /*
+                * Default to no protection. Protection mode will
+                * later be set from BSS config in il_ht_conf
+                */
+               il->ht.protection = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
+
+               /* if we are switching from ht to 2.4 clear flags
+                * from any ht related info since 2.4 does not
+                * support ht */
+               if ((le16_to_cpu(il->staging.channel) != ch))
+                       il->staging.flags = 0;
+
+               il_set_rxon_channel(il, channel);
+               il_set_rxon_ht(il, ht_conf);
+
+               il_set_flags_for_band(il, channel->band, il->vif);
+
+               spin_unlock_irqrestore(&il->lock, flags);
+
+               if (il->ops->update_bcast_stations)
+                       ret = il->ops->update_bcast_stations(il);
+
+set_ch_out:
+               /* The list of supported rates and rate mask can be different
+                * for each band; since the band may have changed, reset
+                * the rate mask to what mac80211 lists */
+               il_set_rate(il);
+       }
+
+       if (changed & (IEEE80211_CONF_CHANGE_PS | IEEE80211_CONF_CHANGE_IDLE)) {
+               il->power_data.ps_disabled = !(conf->flags & IEEE80211_CONF_PS);
+               ret = il_power_update_mode(il, false);
+               if (ret)
+                       D_MAC80211("Error setting sleep level\n");
+       }
+
+       if (changed & IEEE80211_CONF_CHANGE_POWER) {
+               D_MAC80211("TX Power old=%d new=%d\n", il->tx_power_user_lmt,
+                          conf->power_level);
+
+               il_set_tx_power(il, conf->power_level, false);
+       }
+
+       if (!il_is_ready(il)) {
+               D_MAC80211("leave - not ready\n");
+               goto out;
+       }
+
+       if (scan_active)
+               goto out;
+
+       if (memcmp(&il->active, &il->staging, sizeof(il->staging)))
+               il_commit_rxon(il);
+       else
+               D_INFO("Not re-sending same RXON configuration.\n");
+       if (ht_changed)
+               il_update_qos(il);
+
+out:
+       D_MAC80211("leave ret %d\n", ret);
+       mutex_unlock(&il->mutex);
+
+       return ret;
+}
+EXPORT_SYMBOL(il_mac_config);
+
+void
+il_mac_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+{
+       struct il_priv *il = hw->priv;
+       unsigned long flags;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       memset(&il->current_ht_config, 0, sizeof(struct il_ht_config));
+
+       /* new association get rid of ibss beacon skb */
+       if (il->beacon_skb)
+               dev_kfree_skb(il->beacon_skb);
+       il->beacon_skb = NULL;
+       il->timestamp = 0;
+
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       il_scan_cancel_timeout(il, 100);
+       if (!il_is_ready_rf(il)) {
+               D_MAC80211("leave - not ready\n");
+               mutex_unlock(&il->mutex);
+               return;
+       }
+
+       /* we are restarting association process */
+       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+       il_commit_rxon(il);
+
+       il_set_rate(il);
+
+       D_MAC80211("leave\n");
+       mutex_unlock(&il->mutex);
+}
+EXPORT_SYMBOL(il_mac_reset_tsf);
+
+static void
+il_ht_conf(struct il_priv *il, struct ieee80211_vif *vif)
+{
+       struct il_ht_config *ht_conf = &il->current_ht_config;
+       struct ieee80211_sta *sta;
+       struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
+
+       D_ASSOC("enter:\n");
+
+       if (!il->ht.enabled)
+               return;
+
+       il->ht.protection =
+           bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
+       il->ht.non_gf_sta_present =
+           !!(bss_conf->
+              ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
+
+       ht_conf->single_chain_sufficient = false;
+
+       switch (vif->type) {
+       case NL80211_IFTYPE_STATION:
+               rcu_read_lock();
+               sta = ieee80211_find_sta(vif, bss_conf->bssid);
+               if (sta) {
+                       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
+                       int maxstreams;
+
+                       maxstreams =
+                           (ht_cap->mcs.
+                            tx_params & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
+                           >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
+                       maxstreams += 1;
+
+                       if (ht_cap->mcs.rx_mask[1] == 0 &&
+                           ht_cap->mcs.rx_mask[2] == 0)
+                               ht_conf->single_chain_sufficient = true;
+                       if (maxstreams <= 1)
+                               ht_conf->single_chain_sufficient = true;
+               } else {
+                       /*
+                        * If at all, this can only happen through a race
+                        * when the AP disconnects us while we're still
+                        * setting up the connection, in that case mac80211
+                        * will soon tell us about that.
+                        */
+                       ht_conf->single_chain_sufficient = true;
+               }
+               rcu_read_unlock();
+               break;
+       case NL80211_IFTYPE_ADHOC:
+               ht_conf->single_chain_sufficient = true;
+               break;
+       default:
+               break;
+       }
+
+       D_ASSOC("leave\n");
+}
+
+static inline void
+il_set_no_assoc(struct il_priv *il, struct ieee80211_vif *vif)
+{
+       /*
+        * inform the ucode that there is no longer an
+        * association and that no more packets should be
+        * sent
+        */
+       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+       il->staging.assoc_id = 0;
+       il_commit_rxon(il);
+}
+
+static void
+il_beacon_update(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+{
+       struct il_priv *il = hw->priv;
+       unsigned long flags;
+       __le64 timestamp;
+       struct sk_buff *skb = ieee80211_beacon_get(hw, vif);
+
+       if (!skb)
+               return;
+
+       D_MAC80211("enter\n");
+
+       lockdep_assert_held(&il->mutex);
+
+       if (!il->beacon_enabled) {
+               IL_ERR("update beacon with no beaconing enabled\n");
+               dev_kfree_skb(skb);
+               return;
+       }
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       if (il->beacon_skb)
+               dev_kfree_skb(il->beacon_skb);
+
+       il->beacon_skb = skb;
+
+       timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
+       il->timestamp = le64_to_cpu(timestamp);
+
+       D_MAC80211("leave\n");
+       spin_unlock_irqrestore(&il->lock, flags);
+
+       if (!il_is_ready_rf(il)) {
+               D_MAC80211("leave - RF not ready\n");
+               return;
+       }
+
+       il->ops->post_associate(il);
+}
+
+void
+il_mac_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                       struct ieee80211_bss_conf *bss_conf, u32 changes)
+{
+       struct il_priv *il = hw->priv;
+       int ret;
+
+       mutex_lock(&il->mutex);
+       D_MAC80211("enter: changes 0x%x\n", changes);
+
+       if (!il_is_alive(il)) {
+               D_MAC80211("leave - not alive\n");
+               mutex_unlock(&il->mutex);
+               return;
+       }
+
+       if (changes & BSS_CHANGED_QOS) {
+               unsigned long flags;
+
+               spin_lock_irqsave(&il->lock, flags);
+               il->qos_data.qos_active = bss_conf->qos;
+               il_update_qos(il);
+               spin_unlock_irqrestore(&il->lock, flags);
+       }
+
+       if (changes & BSS_CHANGED_BEACON_ENABLED) {
+               /* FIXME: can we remove beacon_enabled ? */
+               if (vif->bss_conf.enable_beacon)
+                       il->beacon_enabled = true;
+               else
+                       il->beacon_enabled = false;
+       }
+
+       if (changes & BSS_CHANGED_BSSID) {
+               D_MAC80211("BSSID %pM\n", bss_conf->bssid);
+
+               /*
+                * On passive channel we wait with blocked queues to see if
+                * there is traffic on that channel. If no frame will be
+                * received (what is very unlikely since scan detects AP on
+                * that channel, but theoretically possible), mac80211 associate
+                * procedure will time out and mac80211 will call us with NULL
+                * bssid. We have to unblock queues on such condition.
+                */
+               if (is_zero_ether_addr(bss_conf->bssid))
+                       il_wake_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
+
+               /*
+                * If there is currently a HW scan going on in the background,
+                * then we need to cancel it, otherwise sometimes we are not
+                * able to authenticate (FIXME: why ?)
+                */
+               if (il_scan_cancel_timeout(il, 100)) {
+                       D_MAC80211("leave - scan abort failed\n");
+                       mutex_unlock(&il->mutex);
+                       return;
+               }
+
+               /* mac80211 only sets assoc when in STATION mode */
+               memcpy(il->staging.bssid_addr, bss_conf->bssid, ETH_ALEN);
+
+               /* FIXME: currently needed in a few places */
+               memcpy(il->bssid, bss_conf->bssid, ETH_ALEN);
+       }
+
+       /*
+        * This needs to be after setting the BSSID in case
+        * mac80211 decides to do both changes at once because
+        * it will invoke post_associate.
+        */
+       if (vif->type == NL80211_IFTYPE_ADHOC && (changes & BSS_CHANGED_BEACON))
+               il_beacon_update(hw, vif);
+
+       if (changes & BSS_CHANGED_ERP_PREAMBLE) {
+               D_MAC80211("ERP_PREAMBLE %d\n", bss_conf->use_short_preamble);
+               if (bss_conf->use_short_preamble)
+                       il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+               else
+                       il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+       }
+
+       if (changes & BSS_CHANGED_ERP_CTS_PROT) {
+               D_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
+               if (bss_conf->use_cts_prot && il->band != IEEE80211_BAND_5GHZ)
+                       il->staging.flags |= RXON_FLG_TGG_PROTECT_MSK;
+               else
+                       il->staging.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
+               if (bss_conf->use_cts_prot)
+                       il->staging.flags |= RXON_FLG_SELF_CTS_EN;
+               else
+                       il->staging.flags &= ~RXON_FLG_SELF_CTS_EN;
+       }
+
+       if (changes & BSS_CHANGED_BASIC_RATES) {
+               /* XXX use this information
+                *
+                * To do that, remove code from il_set_rate() and put something
+                * like this here:
+                *
+                if (A-band)
+                il->staging.ofdm_basic_rates =
+                bss_conf->basic_rates;
+                else
+                il->staging.ofdm_basic_rates =
+                bss_conf->basic_rates >> 4;
+                il->staging.cck_basic_rates =
+                bss_conf->basic_rates & 0xF;
+                */
+       }
+
+       if (changes & BSS_CHANGED_HT) {
+               il_ht_conf(il, vif);
+
+               if (il->ops->set_rxon_chain)
+                       il->ops->set_rxon_chain(il);
+       }
+
+       if (changes & BSS_CHANGED_ASSOC) {
+               D_MAC80211("ASSOC %d\n", bss_conf->assoc);
+               if (bss_conf->assoc) {
+                       il->timestamp = bss_conf->sync_tsf;
+
+                       if (!il_is_rfkill(il))
+                               il->ops->post_associate(il);
+               } else
+                       il_set_no_assoc(il, vif);
+       }
+
+       if (changes && il_is_associated(il) && bss_conf->aid) {
+               D_MAC80211("Changes (%#x) while associated\n", changes);
+               ret = il_send_rxon_assoc(il);
+               if (!ret) {
+                       /* Sync active_rxon with latest change. */
+                       memcpy((void *)&il->active, &il->staging,
+                              sizeof(struct il_rxon_cmd));
+               }
+       }
+
+       if (changes & BSS_CHANGED_BEACON_ENABLED) {
+               if (vif->bss_conf.enable_beacon) {
+                       memcpy(il->staging.bssid_addr, bss_conf->bssid,
+                              ETH_ALEN);
+                       memcpy(il->bssid, bss_conf->bssid, ETH_ALEN);
+                       il->ops->config_ap(il);
+               } else
+                       il_set_no_assoc(il, vif);
+       }
+
+       if (changes & BSS_CHANGED_IBSS) {
+               ret = il->ops->manage_ibss_station(il, vif,
+                                                  bss_conf->ibss_joined);
+               if (ret)
+                       IL_ERR("failed to %s IBSS station %pM\n",
+                              bss_conf->ibss_joined ? "add" : "remove",
+                              bss_conf->bssid);
+       }
+
+       D_MAC80211("leave\n");
+       mutex_unlock(&il->mutex);
+}
+EXPORT_SYMBOL(il_mac_bss_info_changed);
+
+irqreturn_t
+il_isr(int irq, void *data)
+{
+       struct il_priv *il = data;
+       u32 inta, inta_mask;
+       u32 inta_fh;
+       unsigned long flags;
+       if (!il)
+               return IRQ_NONE;
+
+       spin_lock_irqsave(&il->lock, flags);
+
+       /* Disable (but don't clear!) interrupts here to avoid
+        *    back-to-back ISRs and sporadic interrupts from our NIC.
+        * If we have something to service, the tasklet will re-enable ints.
+        * If we *don't* have something, we'll re-enable before leaving here. */
+       inta_mask = _il_rd(il, CSR_INT_MASK);   /* just for debug */
+       _il_wr(il, CSR_INT_MASK, 0x00000000);
+
+       /* Discover which interrupts are active/pending */
+       inta = _il_rd(il, CSR_INT);
+       inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
+
+       /* Ignore interrupt if there's nothing in NIC to service.
+        * This may be due to IRQ shared with another device,
+        * or due to sporadic interrupts thrown from our NIC. */
+       if (!inta && !inta_fh) {
+               D_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
+               goto none;
+       }
+
+       if (inta == 0xFFFFFFFF || (inta & 0xFFFFFFF0) == 0xa5a5a5a0) {
+               /* Hardware disappeared. It might have already raised
+                * an interrupt */
+               IL_WARN("HARDWARE GONE?? INTA == 0x%08x\n", inta);
+               goto unplugged;
+       }
+
+       D_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta, inta_mask,
+             inta_fh);
+
+       inta &= ~CSR_INT_BIT_SCD;
+
+       /* il_irq_tasklet() will service interrupts and re-enable them */
+       if (likely(inta || inta_fh))
+               tasklet_schedule(&il->irq_tasklet);
+
+unplugged:
+       spin_unlock_irqrestore(&il->lock, flags);
+       return IRQ_HANDLED;
+
+none:
+       /* re-enable interrupts here since we don't have anything to service. */
+       /* only Re-enable if disabled by irq */
+       if (test_bit(S_INT_ENABLED, &il->status))
+               il_enable_interrupts(il);
+       spin_unlock_irqrestore(&il->lock, flags);
+       return IRQ_NONE;
+}
+EXPORT_SYMBOL(il_isr);
+
+/*
+ *  il_tx_cmd_protection: Set rts/cts. 3945 and 4965 only share this
+ *  function.
+ */
+void
+il_tx_cmd_protection(struct il_priv *il, struct ieee80211_tx_info *info,
+                    __le16 fc, __le32 *tx_flags)
+{
+       if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) {
+               *tx_flags |= TX_CMD_FLG_RTS_MSK;
+               *tx_flags &= ~TX_CMD_FLG_CTS_MSK;
+               *tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
+
+               if (!ieee80211_is_mgmt(fc))
+                       return;
+
+               switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
+               case cpu_to_le16(IEEE80211_STYPE_AUTH):
+               case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
+               case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
+               case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
+                       *tx_flags &= ~TX_CMD_FLG_RTS_MSK;
+                       *tx_flags |= TX_CMD_FLG_CTS_MSK;
+                       break;
+               }
+       } else if (info->control.rates[0].
+                  flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
+               *tx_flags &= ~TX_CMD_FLG_RTS_MSK;
+               *tx_flags |= TX_CMD_FLG_CTS_MSK;
+               *tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
+       }
+}
+EXPORT_SYMBOL(il_tx_cmd_protection);
diff --git a/drivers/net/wireless/intel/iwlegacy/common.h b/drivers/net/wireless/intel/iwlegacy/common.h
new file mode 100644 (file)
index 0000000..ce52cf1
--- /dev/null
@@ -0,0 +1,3084 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+#ifndef __il_core_h__
+#define __il_core_h__
+
+#include <linux/interrupt.h>
+#include <linux/pci.h>         /* for struct pci_device_id */
+#include <linux/kernel.h>
+#include <linux/leds.h>
+#include <linux/wait.h>
+#include <linux/io.h>
+#include <net/mac80211.h>
+#include <net/ieee80211_radiotap.h>
+
+#include "commands.h"
+#include "csr.h"
+#include "prph.h"
+
+struct il_host_cmd;
+struct il_cmd;
+struct il_tx_queue;
+
+#define IL_ERR(f, a...) dev_err(&il->pci_dev->dev, f, ## a)
+#define IL_WARN(f, a...) dev_warn(&il->pci_dev->dev, f, ## a)
+#define IL_INFO(f, a...) dev_info(&il->pci_dev->dev, f, ## a)
+
+#define RX_QUEUE_SIZE                         256
+#define RX_QUEUE_MASK                         255
+#define RX_QUEUE_SIZE_LOG                     8
+
+/*
+ * RX related structures and functions
+ */
+#define RX_FREE_BUFFERS 64
+#define RX_LOW_WATERMARK 8
+
+#define U32_PAD(n)             ((4-(n))&0x3)
+
+/* CT-KILL constants */
+#define CT_KILL_THRESHOLD_LEGACY   110 /* in Celsius */
+
+/* Default noise level to report when noise measurement is not available.
+ *   This may be because we're:
+ *   1)  Not associated (4965, no beacon stats being sent to driver)
+ *   2)  Scanning (noise measurement does not apply to associated channel)
+ *   3)  Receiving CCK (3945 delivers noise info only for OFDM frames)
+ * Use default noise value of -127 ... this is below the range of measurable
+ *   Rx dBm for either 3945 or 4965, so it can indicate "unmeasurable" to user.
+ *   Also, -127 works better than 0 when averaging frames with/without
+ *   noise info (e.g. averaging might be done in app); measured dBm values are
+ *   always negative ... using a negative value as the default keeps all
+ *   averages within an s8's (used in some apps) range of negative values. */
+#define IL_NOISE_MEAS_NOT_AVAILABLE (-127)
+
+/*
+ * RTS threshold here is total size [2347] minus 4 FCS bytes
+ * Per spec:
+ *   a value of 0 means RTS on all data/management packets
+ *   a value > max MSDU size means no RTS
+ * else RTS for data/management frames where MPDU is larger
+ *   than RTS value.
+ */
+#define DEFAULT_RTS_THRESHOLD     2347U
+#define MIN_RTS_THRESHOLD         0U
+#define MAX_RTS_THRESHOLD         2347U
+#define MAX_MSDU_SIZE            2304U
+#define MAX_MPDU_SIZE            2346U
+#define DEFAULT_BEACON_INTERVAL   100U
+#define        DEFAULT_SHORT_RETRY_LIMIT 7U
+#define        DEFAULT_LONG_RETRY_LIMIT  4U
+
+struct il_rx_buf {
+       dma_addr_t page_dma;
+       struct page *page;
+       struct list_head list;
+};
+
+#define rxb_addr(r) page_address(r->page)
+
+/* defined below */
+struct il_device_cmd;
+
+struct il_cmd_meta {
+       /* only for SYNC commands, iff the reply skb is wanted */
+       struct il_host_cmd *source;
+       /*
+        * only for ASYNC commands
+        * (which is somewhat stupid -- look at common.c for instance
+        * which duplicates a bunch of code because the callback isn't
+        * invoked for SYNC commands, if it were and its result passed
+        * through it would be simpler...)
+        */
+       void (*callback) (struct il_priv *il, struct il_device_cmd *cmd,
+                         struct il_rx_pkt *pkt);
+
+       /* The CMD_SIZE_HUGE flag bit indicates that the command
+        * structure is stored at the end of the shared queue memory. */
+       u32 flags;
+
+        DEFINE_DMA_UNMAP_ADDR(mapping);
+        DEFINE_DMA_UNMAP_LEN(len);
+};
+
+/*
+ * Generic queue structure
+ *
+ * Contains common data for Rx and Tx queues
+ */
+struct il_queue {
+       int n_bd;               /* number of BDs in this queue */
+       int write_ptr;          /* 1-st empty entry (idx) host_w */
+       int read_ptr;           /* last used entry (idx) host_r */
+       /* use for monitoring and recovering the stuck queue */
+       dma_addr_t dma_addr;    /* physical addr for BD's */
+       int n_win;              /* safe queue win */
+       u32 id;
+       int low_mark;           /* low watermark, resume queue if free
+                                * space more than this */
+       int high_mark;          /* high watermark, stop queue if free
+                                * space less than this */
+};
+
+/**
+ * struct il_tx_queue - Tx Queue for DMA
+ * @q: generic Rx/Tx queue descriptor
+ * @bd: base of circular buffer of TFDs
+ * @cmd: array of command/TX buffer pointers
+ * @meta: array of meta data for each command/tx buffer
+ * @dma_addr_cmd: physical address of cmd/tx buffer array
+ * @skbs: array of per-TFD socket buffer pointers
+ * @time_stamp: time (in jiffies) of last read_ptr change
+ * @need_update: indicates need to update read/write idx
+ * @sched_retry: indicates queue is high-throughput aggregation (HT AGG) enabled
+ *
+ * A Tx queue consists of circular buffer of BDs (a.k.a. TFDs, transmit frame
+ * descriptors) and required locking structures.
+ */
+#define TFD_TX_CMD_SLOTS 256
+#define TFD_CMD_SLOTS 32
+
+struct il_tx_queue {
+       struct il_queue q;
+       void *tfds;
+       struct il_device_cmd **cmd;
+       struct il_cmd_meta *meta;
+       struct sk_buff **skbs;
+       unsigned long time_stamp;
+       u8 need_update;
+       u8 sched_retry;
+       u8 active;
+       u8 swq_id;
+};
+
+/*
+ * EEPROM access time values:
+ *
+ * Driver initiates EEPROM read by writing byte address << 1 to CSR_EEPROM_REG.
+ * Driver then polls CSR_EEPROM_REG for CSR_EEPROM_REG_READ_VALID_MSK (0x1).
+ * When polling, wait 10 uSec between polling loops, up to a maximum 5000 uSec.
+ * Driver reads 16-bit value from bits 31-16 of CSR_EEPROM_REG.
+ */
+#define IL_EEPROM_ACCESS_TIMEOUT       5000    /* uSec */
+
+#define IL_EEPROM_SEM_TIMEOUT          10      /* microseconds */
+#define IL_EEPROM_SEM_RETRY_LIMIT      1000    /* number of attempts (not time) */
+
+/*
+ * Regulatory channel usage flags in EEPROM struct il4965_eeprom_channel.flags.
+ *
+ * IBSS and/or AP operation is allowed *only* on those channels with
+ * (VALID && IBSS && ACTIVE && !RADAR).  This restriction is in place because
+ * RADAR detection is not supported by the 4965 driver, but is a
+ * requirement for establishing a new network for legal operation on channels
+ * requiring RADAR detection or restricting ACTIVE scanning.
+ *
+ * NOTE:  "WIDE" flag does not indicate anything about "HT40" 40 MHz channels.
+ *        It only indicates that 20 MHz channel use is supported; HT40 channel
+ *        usage is indicated by a separate set of regulatory flags for each
+ *        HT40 channel pair.
+ *
+ * NOTE:  Using a channel inappropriately will result in a uCode error!
+ */
+#define IL_NUM_TX_CALIB_GROUPS 5
+enum {
+       EEPROM_CHANNEL_VALID = (1 << 0),        /* usable for this SKU/geo */
+       EEPROM_CHANNEL_IBSS = (1 << 1), /* usable as an IBSS channel */
+       /* Bit 2 Reserved */
+       EEPROM_CHANNEL_ACTIVE = (1 << 3),       /* active scanning allowed */
+       EEPROM_CHANNEL_RADAR = (1 << 4),        /* radar detection required */
+       EEPROM_CHANNEL_WIDE = (1 << 5), /* 20 MHz channel okay */
+       /* Bit 6 Reserved (was Narrow Channel) */
+       EEPROM_CHANNEL_DFS = (1 << 7),  /* dynamic freq selection candidate */
+};
+
+/* SKU Capabilities */
+/* 3945 only */
+#define EEPROM_SKU_CAP_SW_RF_KILL_ENABLE                (1 << 0)
+#define EEPROM_SKU_CAP_HW_RF_KILL_ENABLE                (1 << 1)
+
+/* *regulatory* channel data format in eeprom, one for each channel.
+ * There are separate entries for HT40 (40 MHz) vs. normal (20 MHz) channels. */
+struct il_eeprom_channel {
+       u8 flags;               /* EEPROM_CHANNEL_* flags copied from EEPROM */
+       s8 max_power_avg;       /* max power (dBm) on this chnl, limit 31 */
+} __packed;
+
+/* 3945 Specific */
+#define EEPROM_3945_EEPROM_VERSION     (0x2f)
+
+/* 4965 has two radio transmitters (and 3 radio receivers) */
+#define EEPROM_TX_POWER_TX_CHAINS      (2)
+
+/* 4965 has room for up to 8 sets of txpower calibration data */
+#define EEPROM_TX_POWER_BANDS          (8)
+
+/* 4965 factory calibration measures txpower gain settings for
+ * each of 3 target output levels */
+#define EEPROM_TX_POWER_MEASUREMENTS   (3)
+
+/* 4965 Specific */
+/* 4965 driver does not work with txpower calibration version < 5 */
+#define EEPROM_4965_TX_POWER_VERSION    (5)
+#define EEPROM_4965_EEPROM_VERSION     (0x2f)
+#define EEPROM_4965_CALIB_VERSION_OFFSET       (2*0xB6)        /* 2 bytes */
+#define EEPROM_4965_CALIB_TXPOWER_OFFSET       (2*0xE8)        /* 48  bytes */
+#define EEPROM_4965_BOARD_REVISION             (2*0x4F)        /* 2 bytes */
+#define EEPROM_4965_BOARD_PBA                  (2*0x56+1)      /* 9 bytes */
+
+/* 2.4 GHz */
+extern const u8 il_eeprom_band_1[14];
+
+/*
+ * factory calibration data for one txpower level, on one channel,
+ * measured on one of the 2 tx chains (radio transmitter and associated
+ * antenna).  EEPROM contains:
+ *
+ * 1)  Temperature (degrees Celsius) of device when measurement was made.
+ *
+ * 2)  Gain table idx used to achieve the target measurement power.
+ *     This refers to the "well-known" gain tables (see 4965.h).
+ *
+ * 3)  Actual measured output power, in half-dBm ("34" = 17 dBm).
+ *
+ * 4)  RF power amplifier detector level measurement (not used).
+ */
+struct il_eeprom_calib_measure {
+       u8 temperature;         /* Device temperature (Celsius) */
+       u8 gain_idx;            /* Index into gain table */
+       u8 actual_pow;          /* Measured RF output power, half-dBm */
+       s8 pa_det;              /* Power amp detector level (not used) */
+} __packed;
+
+/*
+ * measurement set for one channel.  EEPROM contains:
+ *
+ * 1)  Channel number measured
+ *
+ * 2)  Measurements for each of 3 power levels for each of 2 radio transmitters
+ *     (a.k.a. "tx chains") (6 measurements altogether)
+ */
+struct il_eeprom_calib_ch_info {
+       u8 ch_num;
+       struct il_eeprom_calib_measure
+           measurements[EEPROM_TX_POWER_TX_CHAINS]
+           [EEPROM_TX_POWER_MEASUREMENTS];
+} __packed;
+
+/*
+ * txpower subband info.
+ *
+ * For each frequency subband, EEPROM contains the following:
+ *
+ * 1)  First and last channels within range of the subband.  "0" values
+ *     indicate that this sample set is not being used.
+ *
+ * 2)  Sample measurement sets for 2 channels close to the range endpoints.
+ */
+struct il_eeprom_calib_subband_info {
+       u8 ch_from;             /* channel number of lowest channel in subband */
+       u8 ch_to;               /* channel number of highest channel in subband */
+       struct il_eeprom_calib_ch_info ch1;
+       struct il_eeprom_calib_ch_info ch2;
+} __packed;
+
+/*
+ * txpower calibration info.  EEPROM contains:
+ *
+ * 1)  Factory-measured saturation power levels (maximum levels at which
+ *     tx power amplifier can output a signal without too much distortion).
+ *     There is one level for 2.4 GHz band and one for 5 GHz band.  These
+ *     values apply to all channels within each of the bands.
+ *
+ * 2)  Factory-measured power supply voltage level.  This is assumed to be
+ *     constant (i.e. same value applies to all channels/bands) while the
+ *     factory measurements are being made.
+ *
+ * 3)  Up to 8 sets of factory-measured txpower calibration values.
+ *     These are for different frequency ranges, since txpower gain
+ *     characteristics of the analog radio circuitry vary with frequency.
+ *
+ *     Not all sets need to be filled with data;
+ *     struct il_eeprom_calib_subband_info contains range of channels
+ *     (0 if unused) for each set of data.
+ */
+struct il_eeprom_calib_info {
+       u8 saturation_power24;  /* half-dBm (e.g. "34" = 17 dBm) */
+       u8 saturation_power52;  /* half-dBm */
+       __le16 voltage;         /* signed */
+       struct il_eeprom_calib_subband_info band_info[EEPROM_TX_POWER_BANDS];
+} __packed;
+
+/* General */
+#define EEPROM_DEVICE_ID                    (2*0x08)   /* 2 bytes */
+#define EEPROM_MAC_ADDRESS                  (2*0x15)   /* 6  bytes */
+#define EEPROM_BOARD_REVISION               (2*0x35)   /* 2  bytes */
+#define EEPROM_BOARD_PBA_NUMBER             (2*0x3B+1) /* 9  bytes */
+#define EEPROM_VERSION                      (2*0x44)   /* 2  bytes */
+#define EEPROM_SKU_CAP                      (2*0x45)   /* 2  bytes */
+#define EEPROM_OEM_MODE                     (2*0x46)   /* 2  bytes */
+#define EEPROM_WOWLAN_MODE                  (2*0x47)   /* 2  bytes */
+#define EEPROM_RADIO_CONFIG                 (2*0x48)   /* 2  bytes */
+#define EEPROM_NUM_MAC_ADDRESS              (2*0x4C)   /* 2  bytes */
+
+/* The following masks are to be applied on EEPROM_RADIO_CONFIG */
+#define EEPROM_RF_CFG_TYPE_MSK(x)   (x & 0x3)  /* bits 0-1   */
+#define EEPROM_RF_CFG_STEP_MSK(x)   ((x >> 2)  & 0x3)  /* bits 2-3   */
+#define EEPROM_RF_CFG_DASH_MSK(x)   ((x >> 4)  & 0x3)  /* bits 4-5   */
+#define EEPROM_RF_CFG_PNUM_MSK(x)   ((x >> 6)  & 0x3)  /* bits 6-7   */
+#define EEPROM_RF_CFG_TX_ANT_MSK(x) ((x >> 8)  & 0xF)  /* bits 8-11  */
+#define EEPROM_RF_CFG_RX_ANT_MSK(x) ((x >> 12) & 0xF)  /* bits 12-15 */
+
+#define EEPROM_3945_RF_CFG_TYPE_MAX  0x0
+#define EEPROM_4965_RF_CFG_TYPE_MAX  0x1
+
+/*
+ * Per-channel regulatory data.
+ *
+ * Each channel that *might* be supported by iwl has a fixed location
+ * in EEPROM containing EEPROM_CHANNEL_* usage flags (LSB) and max regulatory
+ * txpower (MSB).
+ *
+ * Entries immediately below are for 20 MHz channel width.  HT40 (40 MHz)
+ * channels (only for 4965, not supported by 3945) appear later in the EEPROM.
+ *
+ * 2.4 GHz channels 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
+ */
+#define EEPROM_REGULATORY_SKU_ID            (2*0x60)   /* 4  bytes */
+#define EEPROM_REGULATORY_BAND_1            (2*0x62)   /* 2  bytes */
+#define EEPROM_REGULATORY_BAND_1_CHANNELS   (2*0x63)   /* 28 bytes */
+
+/*
+ * 4.9 GHz channels 183, 184, 185, 187, 188, 189, 192, 196,
+ * 5.0 GHz channels 7, 8, 11, 12, 16
+ * (4915-5080MHz) (none of these is ever supported)
+ */
+#define EEPROM_REGULATORY_BAND_2            (2*0x71)   /* 2  bytes */
+#define EEPROM_REGULATORY_BAND_2_CHANNELS   (2*0x72)   /* 26 bytes */
+
+/*
+ * 5.2 GHz channels 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
+ * (5170-5320MHz)
+ */
+#define EEPROM_REGULATORY_BAND_3            (2*0x7F)   /* 2  bytes */
+#define EEPROM_REGULATORY_BAND_3_CHANNELS   (2*0x80)   /* 24 bytes */
+
+/*
+ * 5.5 GHz channels 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
+ * (5500-5700MHz)
+ */
+#define EEPROM_REGULATORY_BAND_4            (2*0x8C)   /* 2  bytes */
+#define EEPROM_REGULATORY_BAND_4_CHANNELS   (2*0x8D)   /* 22 bytes */
+
+/*
+ * 5.7 GHz channels 145, 149, 153, 157, 161, 165
+ * (5725-5825MHz)
+ */
+#define EEPROM_REGULATORY_BAND_5            (2*0x98)   /* 2  bytes */
+#define EEPROM_REGULATORY_BAND_5_CHANNELS   (2*0x99)   /* 12 bytes */
+
+/*
+ * 2.4 GHz HT40 channels 1 (5), 2 (6), 3 (7), 4 (8), 5 (9), 6 (10), 7 (11)
+ *
+ * The channel listed is the center of the lower 20 MHz half of the channel.
+ * The overall center frequency is actually 2 channels (10 MHz) above that,
+ * and the upper half of each HT40 channel is centered 4 channels (20 MHz) away
+ * from the lower half; e.g. the upper half of HT40 channel 1 is channel 5,
+ * and the overall HT40 channel width centers on channel 3.
+ *
+ * NOTE:  The RXON command uses 20 MHz channel numbers to specify the
+ *        control channel to which to tune.  RXON also specifies whether the
+ *        control channel is the upper or lower half of a HT40 channel.
+ *
+ * NOTE:  4965 does not support HT40 channels on 2.4 GHz.
+ */
+#define EEPROM_4965_REGULATORY_BAND_24_HT40_CHANNELS (2*0xA0)  /* 14 bytes */
+
+/*
+ * 5.2 GHz HT40 channels 36 (40), 44 (48), 52 (56), 60 (64),
+ * 100 (104), 108 (112), 116 (120), 124 (128), 132 (136), 149 (153), 157 (161)
+ */
+#define EEPROM_4965_REGULATORY_BAND_52_HT40_CHANNELS (2*0xA8)  /* 22 bytes */
+
+#define EEPROM_REGULATORY_BAND_NO_HT40                 (0)
+
+int il_eeprom_init(struct il_priv *il);
+void il_eeprom_free(struct il_priv *il);
+const u8 *il_eeprom_query_addr(const struct il_priv *il, size_t offset);
+u16 il_eeprom_query16(const struct il_priv *il, size_t offset);
+int il_init_channel_map(struct il_priv *il);
+void il_free_channel_map(struct il_priv *il);
+const struct il_channel_info *il_get_channel_info(const struct il_priv *il,
+                                                 enum ieee80211_band band,
+                                                 u16 channel);
+
+#define IL_NUM_SCAN_RATES         (2)
+
+struct il4965_channel_tgd_info {
+       u8 type;
+       s8 max_power;
+};
+
+struct il4965_channel_tgh_info {
+       s64 last_radar_time;
+};
+
+#define IL4965_MAX_RATE (33)
+
+struct il3945_clip_group {
+       /* maximum power level to prevent clipping for each rate, derived by
+        *   us from this band's saturation power in EEPROM */
+       const s8 clip_powers[IL_MAX_RATES];
+};
+
+/* current Tx power values to use, one for each rate for each channel.
+ * requested power is limited by:
+ * -- regulatory EEPROM limits for this channel
+ * -- hardware capabilities (clip-powers)
+ * -- spectrum management
+ * -- user preference (e.g. iwconfig)
+ * when requested power is set, base power idx must also be set. */
+struct il3945_channel_power_info {
+       struct il3945_tx_power tpc;     /* actual radio and DSP gain settings */
+       s8 power_table_idx;     /* actual (compenst'd) idx into gain table */
+       s8 base_power_idx;      /* gain idx for power at factory temp. */
+       s8 requested_power;     /* power (dBm) requested for this chnl/rate */
+};
+
+/* current scan Tx power values to use, one for each scan rate for each
+ * channel. */
+struct il3945_scan_power_info {
+       struct il3945_tx_power tpc;     /* actual radio and DSP gain settings */
+       s8 power_table_idx;     /* actual (compenst'd) idx into gain table */
+       s8 requested_power;     /* scan pwr (dBm) requested for chnl/rate */
+};
+
+/*
+ * One for each channel, holds all channel setup data
+ * Some of the fields (e.g. eeprom and flags/max_power_avg) are redundant
+ *     with one another!
+ */
+struct il_channel_info {
+       struct il4965_channel_tgd_info tgd;
+       struct il4965_channel_tgh_info tgh;
+       struct il_eeprom_channel eeprom;        /* EEPROM regulatory limit */
+       struct il_eeprom_channel ht40_eeprom;   /* EEPROM regulatory limit for
+                                                * HT40 channel */
+
+       u8 channel;             /* channel number */
+       u8 flags;               /* flags copied from EEPROM */
+       s8 max_power_avg;       /* (dBm) regul. eeprom, normal Tx, any rate */
+       s8 curr_txpow;          /* (dBm) regulatory/spectrum/user (not h/w) limit */
+       s8 min_power;           /* always 0 */
+       s8 scan_power;          /* (dBm) regul. eeprom, direct scans, any rate */
+
+       u8 group_idx;           /* 0-4, maps channel to group1/2/3/4/5 */
+       u8 band_idx;            /* 0-4, maps channel to band1/2/3/4/5 */
+       enum ieee80211_band band;
+
+       /* HT40 channel info */
+       s8 ht40_max_power_avg;  /* (dBm) regul. eeprom, normal Tx, any rate */
+       u8 ht40_flags;          /* flags copied from EEPROM */
+       u8 ht40_extension_channel;      /* HT_IE_EXT_CHANNEL_* */
+
+       /* Radio/DSP gain settings for each "normal" data Tx rate.
+        * These include, in addition to RF and DSP gain, a few fields for
+        *   remembering/modifying gain settings (idxes). */
+       struct il3945_channel_power_info power_info[IL4965_MAX_RATE];
+
+       /* Radio/DSP gain settings for each scan rate, for directed scans. */
+       struct il3945_scan_power_info scan_pwr_info[IL_NUM_SCAN_RATES];
+};
+
+#define IL_TX_FIFO_BK          0       /* shared */
+#define IL_TX_FIFO_BE          1
+#define IL_TX_FIFO_VI          2       /* shared */
+#define IL_TX_FIFO_VO          3
+#define IL_TX_FIFO_UNUSED      -1
+
+/* Minimum number of queues. MAX_NUM is defined in hw specific files.
+ * Set the minimum to accommodate the 4 standard TX queues, 1 command
+ * queue, 2 (unused) HCCA queues, and 4 HT queues (one for each AC) */
+#define IL_MIN_NUM_QUEUES      10
+
+#define IL_DEFAULT_CMD_QUEUE_NUM       4
+
+#define IEEE80211_DATA_LEN              2304
+#define IEEE80211_4ADDR_LEN             30
+#define IEEE80211_HLEN                  (IEEE80211_4ADDR_LEN)
+#define IEEE80211_FRAME_LEN             (IEEE80211_DATA_LEN + IEEE80211_HLEN)
+
+struct il_frame {
+       union {
+               struct ieee80211_hdr frame;
+               struct il_tx_beacon_cmd beacon;
+               u8 raw[IEEE80211_FRAME_LEN];
+               u8 cmd[360];
+       } u;
+       struct list_head list;
+};
+
+enum {
+       CMD_SYNC = 0,
+       CMD_SIZE_NORMAL = 0,
+       CMD_NO_SKB = 0,
+       CMD_SIZE_HUGE = (1 << 0),
+       CMD_ASYNC = (1 << 1),
+       CMD_WANT_SKB = (1 << 2),
+       CMD_MAPPED = (1 << 3),
+};
+
+#define DEF_CMD_PAYLOAD_SIZE 320
+
+/**
+ * struct il_device_cmd
+ *
+ * For allocation of the command and tx queues, this establishes the overall
+ * size of the largest command we send to uCode, except for a scan command
+ * (which is relatively huge; space is allocated separately).
+ */
+struct il_device_cmd {
+       struct il_cmd_header hdr;       /* uCode API */
+       union {
+               u32 flags;
+               u8 val8;
+               u16 val16;
+               u32 val32;
+               struct il_tx_cmd tx;
+               u8 payload[DEF_CMD_PAYLOAD_SIZE];
+       } __packed cmd;
+} __packed;
+
+#define TFD_MAX_PAYLOAD_SIZE (sizeof(struct il_device_cmd))
+
+struct il_host_cmd {
+       const void *data;
+       unsigned long reply_page;
+       void (*callback) (struct il_priv *il, struct il_device_cmd *cmd,
+                         struct il_rx_pkt *pkt);
+       u32 flags;
+       u16 len;
+       u8 id;
+};
+
+#define SUP_RATE_11A_MAX_NUM_CHANNELS  8
+#define SUP_RATE_11B_MAX_NUM_CHANNELS  4
+#define SUP_RATE_11G_MAX_NUM_CHANNELS  12
+
+/**
+ * struct il_rx_queue - Rx queue
+ * @bd: driver's pointer to buffer of receive buffer descriptors (rbd)
+ * @bd_dma: bus address of buffer of receive buffer descriptors (rbd)
+ * @read: Shared idx to newest available Rx buffer
+ * @write: Shared idx to oldest written Rx packet
+ * @free_count: Number of pre-allocated buffers in rx_free
+ * @rx_free: list of free SKBs for use
+ * @rx_used: List of Rx buffers with no SKB
+ * @need_update: flag to indicate we need to update read/write idx
+ * @rb_stts: driver's pointer to receive buffer status
+ * @rb_stts_dma: bus address of receive buffer status
+ *
+ * NOTE:  rx_free and rx_used are used as a FIFO for il_rx_bufs
+ */
+struct il_rx_queue {
+       __le32 *bd;
+       dma_addr_t bd_dma;
+       struct il_rx_buf pool[RX_QUEUE_SIZE + RX_FREE_BUFFERS];
+       struct il_rx_buf *queue[RX_QUEUE_SIZE];
+       u32 read;
+       u32 write;
+       u32 free_count;
+       u32 write_actual;
+       struct list_head rx_free;
+       struct list_head rx_used;
+       int need_update;
+       struct il_rb_status *rb_stts;
+       dma_addr_t rb_stts_dma;
+       spinlock_t lock;
+};
+
+#define IL_SUPPORTED_RATES_IE_LEN         8
+
+#define MAX_TID_COUNT        9
+
+#define IL_INVALID_RATE     0xFF
+#define IL_INVALID_VALUE    -1
+
+/**
+ * struct il_ht_agg -- aggregation status while waiting for block-ack
+ * @txq_id: Tx queue used for Tx attempt
+ * @frame_count: # frames attempted by Tx command
+ * @wait_for_ba: Expect block-ack before next Tx reply
+ * @start_idx: Index of 1st Transmit Frame Descriptor (TFD) in Tx win
+ * @bitmap0: Low order bitmap, one bit for each frame pending ACK in Tx win
+ * @bitmap1: High order, one bit for each frame pending ACK in Tx win
+ * @rate_n_flags: Rate at which Tx was attempted
+ *
+ * If C_TX indicates that aggregation was attempted, driver must wait
+ * for block ack (N_COMPRESSED_BA).  This struct stores tx reply info
+ * until block ack arrives.
+ */
+struct il_ht_agg {
+       u16 txq_id;
+       u16 frame_count;
+       u16 wait_for_ba;
+       u16 start_idx;
+       u64 bitmap;
+       u32 rate_n_flags;
+#define IL_AGG_OFF 0
+#define IL_AGG_ON 1
+#define IL_EMPTYING_HW_QUEUE_ADDBA 2
+#define IL_EMPTYING_HW_QUEUE_DELBA 3
+       u8 state;
+};
+
+struct il_tid_data {
+       u16 seq_number;         /* 4965 only */
+       u16 tfds_in_queue;
+       struct il_ht_agg agg;
+};
+
+struct il_hw_key {
+       u32 cipher;
+       int keylen;
+       u8 keyidx;
+       u8 key[32];
+};
+
+union il_ht_rate_supp {
+       u16 rates;
+       struct {
+               u8 siso_rate;
+               u8 mimo_rate;
+       };
+};
+
+#define CFG_HT_RX_AMPDU_FACTOR_8K   (0x0)
+#define CFG_HT_RX_AMPDU_FACTOR_16K  (0x1)
+#define CFG_HT_RX_AMPDU_FACTOR_32K  (0x2)
+#define CFG_HT_RX_AMPDU_FACTOR_64K  (0x3)
+#define CFG_HT_RX_AMPDU_FACTOR_DEF  CFG_HT_RX_AMPDU_FACTOR_64K
+#define CFG_HT_RX_AMPDU_FACTOR_MAX  CFG_HT_RX_AMPDU_FACTOR_64K
+#define CFG_HT_RX_AMPDU_FACTOR_MIN  CFG_HT_RX_AMPDU_FACTOR_8K
+
+/*
+ * Maximal MPDU density for TX aggregation
+ * 4 - 2us density
+ * 5 - 4us density
+ * 6 - 8us density
+ * 7 - 16us density
+ */
+#define CFG_HT_MPDU_DENSITY_2USEC   (0x4)
+#define CFG_HT_MPDU_DENSITY_4USEC   (0x5)
+#define CFG_HT_MPDU_DENSITY_8USEC   (0x6)
+#define CFG_HT_MPDU_DENSITY_16USEC  (0x7)
+#define CFG_HT_MPDU_DENSITY_DEF CFG_HT_MPDU_DENSITY_4USEC
+#define CFG_HT_MPDU_DENSITY_MAX CFG_HT_MPDU_DENSITY_16USEC
+#define CFG_HT_MPDU_DENSITY_MIN     (0x1)
+
+struct il_ht_config {
+       bool single_chain_sufficient;
+       enum ieee80211_smps_mode smps;  /* current smps mode */
+};
+
+/* QoS structures */
+struct il_qos_info {
+       int qos_active;
+       struct il_qosparam_cmd def_qos_parm;
+};
+
+/*
+ * Structure should be accessed with sta_lock held. When station addition
+ * is in progress (IL_STA_UCODE_INPROGRESS) it is possible to access only
+ * the commands (il_addsta_cmd and il_link_quality_cmd) without
+ * sta_lock held.
+ */
+struct il_station_entry {
+       struct il_addsta_cmd sta;
+       struct il_tid_data tid[MAX_TID_COUNT];
+       u8 used;
+       struct il_hw_key keyinfo;
+       struct il_link_quality_cmd *lq;
+};
+
+struct il_station_priv_common {
+       u8 sta_id;
+};
+
+/**
+ * struct il_vif_priv - driver's ilate per-interface information
+ *
+ * When mac80211 allocates a virtual interface, it can allocate
+ * space for us to put data into.
+ */
+struct il_vif_priv {
+       u8 ibss_bssid_sta_id;
+};
+
+/* one for each uCode image (inst/data, boot/init/runtime) */
+struct fw_desc {
+       void *v_addr;           /* access by driver */
+       dma_addr_t p_addr;      /* access by card's busmaster DMA */
+       u32 len;                /* bytes */
+};
+
+/* uCode file layout */
+struct il_ucode_header {
+       __le32 ver;             /* major/minor/API/serial */
+       struct {
+               __le32 inst_size;       /* bytes of runtime code */
+               __le32 data_size;       /* bytes of runtime data */
+               __le32 init_size;       /* bytes of init code */
+               __le32 init_data_size;  /* bytes of init data */
+               __le32 boot_size;       /* bytes of bootstrap code */
+               u8 data[0];     /* in same order as sizes */
+       } v1;
+};
+
+struct il4965_ibss_seq {
+       u8 mac[ETH_ALEN];
+       u16 seq_num;
+       u16 frag_num;
+       unsigned long packet_time;
+       struct list_head list;
+};
+
+struct il_sensitivity_ranges {
+       u16 min_nrg_cck;
+       u16 max_nrg_cck;
+
+       u16 nrg_th_cck;
+       u16 nrg_th_ofdm;
+
+       u16 auto_corr_min_ofdm;
+       u16 auto_corr_min_ofdm_mrc;
+       u16 auto_corr_min_ofdm_x1;
+       u16 auto_corr_min_ofdm_mrc_x1;
+
+       u16 auto_corr_max_ofdm;
+       u16 auto_corr_max_ofdm_mrc;
+       u16 auto_corr_max_ofdm_x1;
+       u16 auto_corr_max_ofdm_mrc_x1;
+
+       u16 auto_corr_max_cck;
+       u16 auto_corr_max_cck_mrc;
+       u16 auto_corr_min_cck;
+       u16 auto_corr_min_cck_mrc;
+
+       u16 barker_corr_th_min;
+       u16 barker_corr_th_min_mrc;
+       u16 nrg_th_cca;
+};
+
+#define KELVIN_TO_CELSIUS(x) ((x)-273)
+#define CELSIUS_TO_KELVIN(x) ((x)+273)
+
+/**
+ * struct il_hw_params
+ * @bcast_id: f/w broadcast station ID
+ * @max_txq_num: Max # Tx queues supported
+ * @dma_chnl_num: Number of Tx DMA/FIFO channels
+ * @scd_bc_tbls_size: size of scheduler byte count tables
+ * @tfd_size: TFD size
+ * @tx/rx_chains_num: Number of TX/RX chains
+ * @valid_tx/rx_ant: usable antennas
+ * @max_rxq_size: Max # Rx frames in Rx queue (must be power-of-2)
+ * @max_rxq_log: Log-base-2 of max_rxq_size
+ * @rx_page_order: Rx buffer page order
+ * @rx_wrt_ptr_reg: FH{39}_RSCSR_CHNL0_WPTR
+ * @max_stations:
+ * @ht40_channel: is 40MHz width possible in band 2.4
+ * BIT(IEEE80211_BAND_5GHZ) BIT(IEEE80211_BAND_5GHZ)
+ * @sw_crypto: 0 for hw, 1 for sw
+ * @max_xxx_size: for ucode uses
+ * @ct_kill_threshold: temperature threshold
+ * @beacon_time_tsf_bits: number of valid tsf bits for beacon time
+ * @struct il_sensitivity_ranges: range of sensitivity values
+ */
+struct il_hw_params {
+       u8 bcast_id;
+       u8 max_txq_num;
+       u8 dma_chnl_num;
+       u16 scd_bc_tbls_size;
+       u32 tfd_size;
+       u8 tx_chains_num;
+       u8 rx_chains_num;
+       u8 valid_tx_ant;
+       u8 valid_rx_ant;
+       u16 max_rxq_size;
+       u16 max_rxq_log;
+       u32 rx_page_order;
+       u32 rx_wrt_ptr_reg;
+       u8 max_stations;
+       u8 ht40_channel;
+       u8 max_beacon_itrvl;    /* in 1024 ms */
+       u32 max_inst_size;
+       u32 max_data_size;
+       u32 max_bsm_size;
+       u32 ct_kill_threshold;  /* value in hw-dependent units */
+       u16 beacon_time_tsf_bits;
+       const struct il_sensitivity_ranges *sens;
+};
+
+/******************************************************************************
+ *
+ * Functions implemented in core module which are forward declared here
+ * for use by iwl-[4-5].c
+ *
+ * NOTE:  The implementation of these functions are not hardware specific
+ * which is why they are in the core module files.
+ *
+ * Naming convention --
+ * il_         <-- Is part of iwlwifi
+ * iwlXXXX_     <-- Hardware specific (implemented in iwl-XXXX.c for XXXX)
+ * il4965_bg_      <-- Called from work queue context
+ * il4965_mac_     <-- mac80211 callback
+ *
+ ****************************************************************************/
+void il4965_update_chain_flags(struct il_priv *il);
+extern const u8 il_bcast_addr[ETH_ALEN];
+int il_queue_space(const struct il_queue *q);
+static inline int
+il_queue_used(const struct il_queue *q, int i)
+{
+       return q->write_ptr >= q->read_ptr ? (i >= q->read_ptr &&
+                                             i < q->write_ptr) : !(i <
+                                                                   q->read_ptr
+                                                                   && i >=
+                                                                   q->
+                                                                   write_ptr);
+}
+
+static inline u8
+il_get_cmd_idx(struct il_queue *q, u32 idx, int is_huge)
+{
+       /*
+        * This is for init calibration result and scan command which
+        * required buffer > TFD_MAX_PAYLOAD_SIZE,
+        * the big buffer at end of command array
+        */
+       if (is_huge)
+               return q->n_win;        /* must be power of 2 */
+
+       /* Otherwise, use normal size buffers */
+       return idx & (q->n_win - 1);
+}
+
+struct il_dma_ptr {
+       dma_addr_t dma;
+       void *addr;
+       size_t size;
+};
+
+#define IL_OPERATION_MODE_AUTO     0
+#define IL_OPERATION_MODE_HT_ONLY  1
+#define IL_OPERATION_MODE_MIXED    2
+#define IL_OPERATION_MODE_20MHZ    3
+
+#define IL_TX_CRC_SIZE 4
+#define IL_TX_DELIMITER_SIZE 4
+
+#define TX_POWER_IL_ILLEGAL_VOLTAGE -10000
+
+/* Sensitivity and chain noise calibration */
+#define INITIALIZATION_VALUE           0xFFFF
+#define IL4965_CAL_NUM_BEACONS         20
+#define IL_CAL_NUM_BEACONS             16
+#define MAXIMUM_ALLOWED_PATHLOSS       15
+
+#define CHAIN_NOISE_MAX_DELTA_GAIN_CODE 3
+
+#define MAX_FA_OFDM  50
+#define MIN_FA_OFDM  5
+#define MAX_FA_CCK   50
+#define MIN_FA_CCK   5
+
+#define AUTO_CORR_STEP_OFDM       1
+
+#define AUTO_CORR_STEP_CCK     3
+#define AUTO_CORR_MAX_TH_CCK   160
+
+#define NRG_DIFF               2
+#define NRG_STEP_CCK           2
+#define NRG_MARGIN             8
+#define MAX_NUMBER_CCK_NO_FA 100
+
+#define AUTO_CORR_CCK_MIN_VAL_DEF    (125)
+
+#define CHAIN_A             0
+#define CHAIN_B             1
+#define CHAIN_C             2
+#define CHAIN_NOISE_DELTA_GAIN_INIT_VAL 4
+#define ALL_BAND_FILTER                        0xFF00
+#define IN_BAND_FILTER                 0xFF
+#define MIN_AVERAGE_NOISE_MAX_VALUE    0xFFFFFFFF
+
+#define NRG_NUM_PREV_STAT_L     20
+#define NUM_RX_CHAINS           3
+
+enum il4965_false_alarm_state {
+       IL_FA_TOO_MANY = 0,
+       IL_FA_TOO_FEW = 1,
+       IL_FA_GOOD_RANGE = 2,
+};
+
+enum il4965_chain_noise_state {
+       IL_CHAIN_NOISE_ALIVE = 0,       /* must be 0 */
+       IL_CHAIN_NOISE_ACCUMULATE,
+       IL_CHAIN_NOISE_CALIBRATED,
+       IL_CHAIN_NOISE_DONE,
+};
+
+enum ucode_type {
+       UCODE_NONE = 0,
+       UCODE_INIT,
+       UCODE_RT
+};
+
+/* Sensitivity calib data */
+struct il_sensitivity_data {
+       u32 auto_corr_ofdm;
+       u32 auto_corr_ofdm_mrc;
+       u32 auto_corr_ofdm_x1;
+       u32 auto_corr_ofdm_mrc_x1;
+       u32 auto_corr_cck;
+       u32 auto_corr_cck_mrc;
+
+       u32 last_bad_plcp_cnt_ofdm;
+       u32 last_fa_cnt_ofdm;
+       u32 last_bad_plcp_cnt_cck;
+       u32 last_fa_cnt_cck;
+
+       u32 nrg_curr_state;
+       u32 nrg_prev_state;
+       u32 nrg_value[10];
+       u8 nrg_silence_rssi[NRG_NUM_PREV_STAT_L];
+       u32 nrg_silence_ref;
+       u32 nrg_energy_idx;
+       u32 nrg_silence_idx;
+       u32 nrg_th_cck;
+       s32 nrg_auto_corr_silence_diff;
+       u32 num_in_cck_no_fa;
+       u32 nrg_th_ofdm;
+
+       u16 barker_corr_th_min;
+       u16 barker_corr_th_min_mrc;
+       u16 nrg_th_cca;
+};
+
+/* Chain noise (differential Rx gain) calib data */
+struct il_chain_noise_data {
+       u32 active_chains;
+       u32 chain_noise_a;
+       u32 chain_noise_b;
+       u32 chain_noise_c;
+       u32 chain_signal_a;
+       u32 chain_signal_b;
+       u32 chain_signal_c;
+       u16 beacon_count;
+       u8 disconn_array[NUM_RX_CHAINS];
+       u8 delta_gain_code[NUM_RX_CHAINS];
+       u8 radio_write;
+       u8 state;
+};
+
+#define        EEPROM_SEM_TIMEOUT 10   /* milliseconds */
+#define EEPROM_SEM_RETRY_LIMIT 1000    /* number of attempts (not time) */
+
+#define IL_TRAFFIC_ENTRIES     (256)
+#define IL_TRAFFIC_ENTRY_SIZE  (64)
+
+enum {
+       MEASUREMENT_READY = (1 << 0),
+       MEASUREMENT_ACTIVE = (1 << 1),
+};
+
+/* interrupt stats */
+struct isr_stats {
+       u32 hw;
+       u32 sw;
+       u32 err_code;
+       u32 sch;
+       u32 alive;
+       u32 rfkill;
+       u32 ctkill;
+       u32 wakeup;
+       u32 rx;
+       u32 handlers[IL_CN_MAX];
+       u32 tx;
+       u32 unhandled;
+};
+
+/* management stats */
+enum il_mgmt_stats {
+       MANAGEMENT_ASSOC_REQ = 0,
+       MANAGEMENT_ASSOC_RESP,
+       MANAGEMENT_REASSOC_REQ,
+       MANAGEMENT_REASSOC_RESP,
+       MANAGEMENT_PROBE_REQ,
+       MANAGEMENT_PROBE_RESP,
+       MANAGEMENT_BEACON,
+       MANAGEMENT_ATIM,
+       MANAGEMENT_DISASSOC,
+       MANAGEMENT_AUTH,
+       MANAGEMENT_DEAUTH,
+       MANAGEMENT_ACTION,
+       MANAGEMENT_MAX,
+};
+/* control stats */
+enum il_ctrl_stats {
+       CONTROL_BACK_REQ = 0,
+       CONTROL_BACK,
+       CONTROL_PSPOLL,
+       CONTROL_RTS,
+       CONTROL_CTS,
+       CONTROL_ACK,
+       CONTROL_CFEND,
+       CONTROL_CFENDACK,
+       CONTROL_MAX,
+};
+
+struct traffic_stats {
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       u32 mgmt[MANAGEMENT_MAX];
+       u32 ctrl[CONTROL_MAX];
+       u32 data_cnt;
+       u64 data_bytes;
+#endif
+};
+
+/*
+ * host interrupt timeout value
+ * used with setting interrupt coalescing timer
+ * the CSR_INT_COALESCING is an 8 bit register in 32-usec unit
+ *
+ * default interrupt coalescing timer is 64 x 32 = 2048 usecs
+ * default interrupt coalescing calibration timer is 16 x 32 = 512 usecs
+ */
+#define IL_HOST_INT_TIMEOUT_MAX        (0xFF)
+#define IL_HOST_INT_TIMEOUT_DEF        (0x40)
+#define IL_HOST_INT_TIMEOUT_MIN        (0x0)
+#define IL_HOST_INT_CALIB_TIMEOUT_MAX  (0xFF)
+#define IL_HOST_INT_CALIB_TIMEOUT_DEF  (0x10)
+#define IL_HOST_INT_CALIB_TIMEOUT_MIN  (0x0)
+
+#define IL_DELAY_NEXT_FORCE_FW_RELOAD (HZ*5)
+
+/* TX queue watchdog timeouts in mSecs */
+#define IL_DEF_WD_TIMEOUT      (2000)
+#define IL_LONG_WD_TIMEOUT     (10000)
+#define IL_MAX_WD_TIMEOUT      (120000)
+
+struct il_force_reset {
+       int reset_request_count;
+       int reset_success_count;
+       int reset_reject_count;
+       unsigned long reset_duration;
+       unsigned long last_force_reset_jiffies;
+};
+
+/* extend beacon time format bit shifting  */
+/*
+ * for _3945 devices
+ * bits 31:24 - extended
+ * bits 23:0  - interval
+ */
+#define IL3945_EXT_BEACON_TIME_POS     24
+/*
+ * for _4965 devices
+ * bits 31:22 - extended
+ * bits 21:0  - interval
+ */
+#define IL4965_EXT_BEACON_TIME_POS     22
+
+struct il_rxon_context {
+       struct ieee80211_vif *vif;
+};
+
+struct il_power_mgr {
+       struct il_powertable_cmd sleep_cmd;
+       struct il_powertable_cmd sleep_cmd_next;
+       int debug_sleep_level_override;
+       bool pci_pm;
+       bool ps_disabled;
+};
+
+struct il_priv {
+       struct ieee80211_hw *hw;
+       struct ieee80211_channel *ieee_channels;
+       struct ieee80211_rate *ieee_rates;
+
+       struct il_cfg *cfg;
+       const struct il_ops *ops;
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       const struct il_debugfs_ops *debugfs_ops;
+#endif
+
+       /* temporary frame storage list */
+       struct list_head free_frames;
+       int frames_count;
+
+       enum ieee80211_band band;
+       int alloc_rxb_page;
+
+       void (*handlers[IL_CN_MAX]) (struct il_priv *il,
+                                    struct il_rx_buf *rxb);
+
+       struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+
+       /* spectrum measurement report caching */
+       struct il_spectrum_notification measure_report;
+       u8 measurement_status;
+
+       /* ucode beacon time */
+       u32 ucode_beacon_time;
+       int missed_beacon_threshold;
+
+       /* track IBSS manager (last beacon) status */
+       u32 ibss_manager;
+
+       /* force reset */
+       struct il_force_reset force_reset;
+
+       /* we allocate array of il_channel_info for NIC's valid channels.
+        *    Access via channel # using indirect idx array */
+       struct il_channel_info *channel_info;   /* channel info array */
+       u8 channel_count;       /* # of channels */
+
+       /* thermal calibration */
+       s32 temperature;        /* degrees Kelvin */
+       s32 last_temperature;
+
+       /* Scan related variables */
+       unsigned long scan_start;
+       unsigned long scan_start_tsf;
+       void *scan_cmd;
+       enum ieee80211_band scan_band;
+       struct cfg80211_scan_request *scan_request;
+       struct ieee80211_vif *scan_vif;
+       u8 scan_tx_ant[IEEE80211_NUM_BANDS];
+       u8 mgmt_tx_ant;
+
+       /* spinlock */
+       spinlock_t lock;        /* protect general shared data */
+       spinlock_t hcmd_lock;   /* protect hcmd */
+       spinlock_t reg_lock;    /* protect hw register access */
+       struct mutex mutex;
+
+       /* basic pci-network driver stuff */
+       struct pci_dev *pci_dev;
+
+       /* pci hardware address support */
+       void __iomem *hw_base;
+       u32 hw_rev;
+       u32 hw_wa_rev;
+       u8 rev_id;
+
+       /* command queue number */
+       u8 cmd_queue;
+
+       /* max number of station keys */
+       u8 sta_key_max_num;
+
+       /* EEPROM MAC addresses */
+       struct mac_address addresses[1];
+
+       /* uCode images, save to reload in case of failure */
+       int fw_idx;             /* firmware we're trying to load */
+       u32 ucode_ver;          /* version of ucode, copy of
+                                  il_ucode.ver */
+       struct fw_desc ucode_code;      /* runtime inst */
+       struct fw_desc ucode_data;      /* runtime data original */
+       struct fw_desc ucode_data_backup;       /* runtime data save/restore */
+       struct fw_desc ucode_init;      /* initialization inst */
+       struct fw_desc ucode_init_data; /* initialization data */
+       struct fw_desc ucode_boot;      /* bootstrap inst */
+       enum ucode_type ucode_type;
+       u8 ucode_write_complete;        /* the image write is complete */
+       char firmware_name[25];
+
+       struct ieee80211_vif *vif;
+
+       struct il_qos_info qos_data;
+
+       struct {
+               bool enabled;
+               bool is_40mhz;
+               bool non_gf_sta_present;
+               u8 protection;
+               u8 extension_chan_offset;
+       } ht;
+
+       /*
+        * We declare this const so it can only be
+        * changed via explicit cast within the
+        * routines that actually update the physical
+        * hardware.
+        */
+       const struct il_rxon_cmd active;
+       struct il_rxon_cmd staging;
+
+       struct il_rxon_time_cmd timing;
+
+       __le16 switch_channel;
+
+       /* 1st responses from initialize and runtime uCode images.
+        * _4965's initialize alive response contains some calibration data. */
+       struct il_init_alive_resp card_alive_init;
+       struct il_alive_resp card_alive;
+
+       u16 active_rate;
+
+       u8 start_calib;
+       struct il_sensitivity_data sensitivity_data;
+       struct il_chain_noise_data chain_noise_data;
+       __le16 sensitivity_tbl[HD_TBL_SIZE];
+
+       struct il_ht_config current_ht_config;
+
+       /* Rate scaling data */
+       u8 retry_rate;
+
+       wait_queue_head_t wait_command_queue;
+
+       int activity_timer_active;
+
+       /* Rx and Tx DMA processing queues */
+       struct il_rx_queue rxq;
+       struct il_tx_queue *txq;
+       unsigned long txq_ctx_active_msk;
+       struct il_dma_ptr kw;   /* keep warm address */
+       struct il_dma_ptr scd_bc_tbls;
+
+       u32 scd_base_addr;      /* scheduler sram base address */
+
+       unsigned long status;
+
+       /* counts mgmt, ctl, and data packets */
+       struct traffic_stats tx_stats;
+       struct traffic_stats rx_stats;
+
+       /* counts interrupts */
+       struct isr_stats isr_stats;
+
+       struct il_power_mgr power_data;
+
+       /* context information */
+       u8 bssid[ETH_ALEN];     /* used only on 3945 but filled by core */
+
+       /* station table variables */
+
+       /* Note: if lock and sta_lock are needed, lock must be acquired first */
+       spinlock_t sta_lock;
+       int num_stations;
+       struct il_station_entry stations[IL_STATION_COUNT];
+       unsigned long ucode_key_table;
+
+       /* queue refcounts */
+#define IL_MAX_HW_QUEUES       32
+       unsigned long queue_stopped[BITS_TO_LONGS(IL_MAX_HW_QUEUES)];
+#define IL_STOP_REASON_PASSIVE 0
+       unsigned long stop_reason;
+       /* for each AC */
+       atomic_t queue_stop_count[4];
+
+       /* Indication if ieee80211_ops->open has been called */
+       u8 is_open;
+
+       u8 mac80211_registered;
+
+       /* eeprom -- this is in the card's little endian byte order */
+       u8 *eeprom;
+       struct il_eeprom_calib_info *calib_info;
+
+       enum nl80211_iftype iw_mode;
+
+       /* Last Rx'd beacon timestamp */
+       u64 timestamp;
+
+       union {
+#if defined(CONFIG_IWL3945) || defined(CONFIG_IWL3945_MODULE)
+               struct {
+                       void *shared_virt;
+                       dma_addr_t shared_phys;
+
+                       struct delayed_work thermal_periodic;
+                       struct delayed_work rfkill_poll;
+
+                       struct il3945_notif_stats stats;
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+                       struct il3945_notif_stats accum_stats;
+                       struct il3945_notif_stats delta_stats;
+                       struct il3945_notif_stats max_delta;
+#endif
+
+                       u32 sta_supp_rates;
+                       int last_rx_rssi;       /* From Rx packet stats */
+
+                       /* Rx'd packet timing information */
+                       u32 last_beacon_time;
+                       u64 last_tsf;
+
+                       /*
+                        * each calibration channel group in the
+                        * EEPROM has a derived clip setting for
+                        * each rate.
+                        */
+                       const struct il3945_clip_group clip_groups[5];
+
+               } _3945;
+#endif
+#if defined(CONFIG_IWL4965) || defined(CONFIG_IWL4965_MODULE)
+               struct {
+                       struct il_rx_phy_res last_phy_res;
+                       bool last_phy_res_valid;
+                       u32 ampdu_ref;
+
+                       struct completion firmware_loading_complete;
+
+                       /*
+                        * chain noise reset and gain commands are the
+                        * two extra calibration commands follows the standard
+                        * phy calibration commands
+                        */
+                       u8 phy_calib_chain_noise_reset_cmd;
+                       u8 phy_calib_chain_noise_gain_cmd;
+
+                       u8 key_mapping_keys;
+                       struct il_wep_key wep_keys[WEP_KEYS_MAX];
+
+                       struct il_notif_stats stats;
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+                       struct il_notif_stats accum_stats;
+                       struct il_notif_stats delta_stats;
+                       struct il_notif_stats max_delta;
+#endif
+
+               } _4965;
+#endif
+       };
+
+       struct il_hw_params hw_params;
+
+       u32 inta_mask;
+
+       struct workqueue_struct *workqueue;
+
+       struct work_struct restart;
+       struct work_struct scan_completed;
+       struct work_struct rx_replenish;
+       struct work_struct abort_scan;
+
+       bool beacon_enabled;
+       struct sk_buff *beacon_skb;
+
+       struct work_struct tx_flush;
+
+       struct tasklet_struct irq_tasklet;
+
+       struct delayed_work init_alive_start;
+       struct delayed_work alive_start;
+       struct delayed_work scan_check;
+
+       /* TX Power */
+       s8 tx_power_user_lmt;
+       s8 tx_power_device_lmt;
+       s8 tx_power_next;
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+       /* debugging info */
+       u32 debug_level;        /* per device debugging will override global
+                                  il_debug_level if set */
+#endif                         /* CONFIG_IWLEGACY_DEBUG */
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+       /* debugfs */
+       u16 tx_traffic_idx;
+       u16 rx_traffic_idx;
+       u8 *tx_traffic;
+       u8 *rx_traffic;
+       struct dentry *debugfs_dir;
+       u32 dbgfs_sram_offset, dbgfs_sram_len;
+       bool disable_ht40;
+#endif                         /* CONFIG_IWLEGACY_DEBUGFS */
+
+       struct work_struct txpower_work;
+       bool disable_sens_cal;
+       bool disable_chain_noise_cal;
+       bool disable_tx_power_cal;
+       struct work_struct run_time_calib_work;
+       struct timer_list stats_periodic;
+       struct timer_list watchdog;
+       bool hw_ready;
+
+       struct led_classdev led;
+       unsigned long blink_on, blink_off;
+       bool led_registered;
+};                             /*il_priv */
+
+static inline void
+il_txq_ctx_activate(struct il_priv *il, int txq_id)
+{
+       set_bit(txq_id, &il->txq_ctx_active_msk);
+}
+
+static inline void
+il_txq_ctx_deactivate(struct il_priv *il, int txq_id)
+{
+       clear_bit(txq_id, &il->txq_ctx_active_msk);
+}
+
+static inline int
+il_is_associated(struct il_priv *il)
+{
+       return (il->active.filter_flags & RXON_FILTER_ASSOC_MSK) ? 1 : 0;
+}
+
+static inline int
+il_is_any_associated(struct il_priv *il)
+{
+       return il_is_associated(il);
+}
+
+static inline int
+il_is_channel_valid(const struct il_channel_info *ch_info)
+{
+       if (ch_info == NULL)
+               return 0;
+       return (ch_info->flags & EEPROM_CHANNEL_VALID) ? 1 : 0;
+}
+
+static inline int
+il_is_channel_radar(const struct il_channel_info *ch_info)
+{
+       return (ch_info->flags & EEPROM_CHANNEL_RADAR) ? 1 : 0;
+}
+
+static inline u8
+il_is_channel_a_band(const struct il_channel_info *ch_info)
+{
+       return ch_info->band == IEEE80211_BAND_5GHZ;
+}
+
+static inline int
+il_is_channel_passive(const struct il_channel_info *ch)
+{
+       return (!(ch->flags & EEPROM_CHANNEL_ACTIVE)) ? 1 : 0;
+}
+
+static inline int
+il_is_channel_ibss(const struct il_channel_info *ch)
+{
+       return (ch->flags & EEPROM_CHANNEL_IBSS) ? 1 : 0;
+}
+
+static inline void
+__il_free_pages(struct il_priv *il, struct page *page)
+{
+       __free_pages(page, il->hw_params.rx_page_order);
+       il->alloc_rxb_page--;
+}
+
+static inline void
+il_free_pages(struct il_priv *il, unsigned long page)
+{
+       free_pages(page, il->hw_params.rx_page_order);
+       il->alloc_rxb_page--;
+}
+
+#define IWLWIFI_VERSION "in-tree:"
+#define DRV_COPYRIGHT  "Copyright(c) 2003-2011 Intel Corporation"
+#define DRV_AUTHOR     "<ilw@linux.intel.com>"
+
+#define IL_PCI_DEVICE(dev, subdev, cfg) \
+       .vendor = PCI_VENDOR_ID_INTEL,  .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = (subdev), \
+       .driver_data = (kernel_ulong_t)&(cfg)
+
+#define TIME_UNIT              1024
+
+#define IL_SKU_G       0x1
+#define IL_SKU_A       0x2
+#define IL_SKU_N       0x8
+
+#define IL_CMD(x) case x: return #x
+
+/* Size of one Rx buffer in host DRAM */
+#define IL_RX_BUF_SIZE_3K (3 * 1000)   /* 3945 only */
+#define IL_RX_BUF_SIZE_4K (4 * 1024)
+#define IL_RX_BUF_SIZE_8K (8 * 1024)
+
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+struct il_debugfs_ops {
+       ssize_t(*rx_stats_read) (struct file *file, char __user *user_buf,
+                                size_t count, loff_t *ppos);
+       ssize_t(*tx_stats_read) (struct file *file, char __user *user_buf,
+                                size_t count, loff_t *ppos);
+       ssize_t(*general_stats_read) (struct file *file,
+                                     char __user *user_buf, size_t count,
+                                     loff_t *ppos);
+};
+#endif
+
+struct il_ops {
+       /* Handling TX */
+       void (*txq_update_byte_cnt_tbl) (struct il_priv *il,
+                                        struct il_tx_queue *txq,
+                                        u16 byte_cnt);
+       int (*txq_attach_buf_to_tfd) (struct il_priv *il,
+                                     struct il_tx_queue *txq, dma_addr_t addr,
+                                     u16 len, u8 reset, u8 pad);
+       void (*txq_free_tfd) (struct il_priv *il, struct il_tx_queue *txq);
+       int (*txq_init) (struct il_priv *il, struct il_tx_queue *txq);
+       /* alive notification after init uCode load */
+       void (*init_alive_start) (struct il_priv *il);
+       /* check validity of rtc data address */
+       int (*is_valid_rtc_data_addr) (u32 addr);
+       /* 1st ucode load */
+       int (*load_ucode) (struct il_priv *il);
+
+       void (*dump_nic_error_log) (struct il_priv *il);
+       int (*dump_fh) (struct il_priv *il, char **buf, bool display);
+       int (*set_channel_switch) (struct il_priv *il,
+                                  struct ieee80211_channel_switch *ch_switch);
+       /* power management */
+       int (*apm_init) (struct il_priv *il);
+
+       /* tx power */
+       int (*send_tx_power) (struct il_priv *il);
+       void (*update_chain_flags) (struct il_priv *il);
+
+       /* eeprom operations */
+       int (*eeprom_acquire_semaphore) (struct il_priv *il);
+       void (*eeprom_release_semaphore) (struct il_priv *il);
+
+       int (*rxon_assoc) (struct il_priv *il);
+       int (*commit_rxon) (struct il_priv *il);
+       void (*set_rxon_chain) (struct il_priv *il);
+
+       u16(*get_hcmd_size) (u8 cmd_id, u16 len);
+       u16(*build_addsta_hcmd) (const struct il_addsta_cmd *cmd, u8 *data);
+
+       int (*request_scan) (struct il_priv *il, struct ieee80211_vif *vif);
+       void (*post_scan) (struct il_priv *il);
+       void (*post_associate) (struct il_priv *il);
+       void (*config_ap) (struct il_priv *il);
+       /* station management */
+       int (*update_bcast_stations) (struct il_priv *il);
+       int (*manage_ibss_station) (struct il_priv *il,
+                                   struct ieee80211_vif *vif, bool add);
+
+       int (*send_led_cmd) (struct il_priv *il, struct il_led_cmd *led_cmd);
+};
+
+struct il_mod_params {
+       int sw_crypto;          /* def: 0 = using hardware encryption */
+       int disable_hw_scan;    /* def: 0 = use h/w scan */
+       int num_of_queues;      /* def: HW dependent */
+       int disable_11n;        /* def: 0 = 11n capabilities enabled */
+       int amsdu_size_8K;      /* def: 0 = disable 8K amsdu size */
+       int antenna;            /* def: 0 = both antennas (use diversity) */
+       int restart_fw;         /* def: 1 = restart firmware */
+};
+
+#define IL_LED_SOLID 11
+#define IL_DEF_LED_INTRVL cpu_to_le32(1000)
+
+#define IL_LED_ACTIVITY       (0<<1)
+#define IL_LED_LINK           (1<<1)
+
+/*
+ * LED mode
+ *    IL_LED_DEFAULT:  use device default
+ *    IL_LED_RF_STATE: turn LED on/off based on RF state
+ *                     LED ON  = RF ON
+ *                     LED OFF = RF OFF
+ *    IL_LED_BLINK:    adjust led blink rate based on blink table
+ */
+enum il_led_mode {
+       IL_LED_DEFAULT,
+       IL_LED_RF_STATE,
+       IL_LED_BLINK,
+};
+
+void il_leds_init(struct il_priv *il);
+void il_leds_exit(struct il_priv *il);
+
+/**
+ * struct il_cfg
+ * @fw_name_pre: Firmware filename prefix. The api version and extension
+ *     (.ucode) will be added to filename before loading from disk. The
+ *     filename is constructed as fw_name_pre<api>.ucode.
+ * @ucode_api_max: Highest version of uCode API supported by driver.
+ * @ucode_api_min: Lowest version of uCode API supported by driver.
+ * @scan_antennas: available antenna for scan operation
+ * @led_mode: 0=blinking, 1=On(RF On)/Off(RF Off)
+ *
+ * We enable the driver to be backward compatible wrt API version. The
+ * driver specifies which APIs it supports (with @ucode_api_max being the
+ * highest and @ucode_api_min the lowest). Firmware will only be loaded if
+ * it has a supported API version. The firmware's API version will be
+ * stored in @il_priv, enabling the driver to make runtime changes based
+ * on firmware version used.
+ *
+ * For example,
+ * if (IL_UCODE_API(il->ucode_ver) >= 2) {
+ *     Driver interacts with Firmware API version >= 2.
+ * } else {
+ *     Driver interacts with Firmware API version 1.
+ * }
+ *
+ * The ideal usage of this infrastructure is to treat a new ucode API
+ * release as a new hardware revision. That is, through utilizing the
+ * il_hcmd_utils_ops etc. we accommodate different command structures
+ * and flows between hardware versions as well as their API
+ * versions.
+ *
+ */
+struct il_cfg {
+       /* params specific to an individual device within a device family */
+       const char *name;
+       const char *fw_name_pre;
+       const unsigned int ucode_api_max;
+       const unsigned int ucode_api_min;
+       u8 valid_tx_ant;
+       u8 valid_rx_ant;
+       unsigned int sku;
+       u16 eeprom_ver;
+       u16 eeprom_calib_ver;
+       /* module based parameters which can be set from modprobe cmd */
+       const struct il_mod_params *mod_params;
+       /* params not likely to change within a device family */
+       struct il_base_params *base_params;
+       /* params likely to change within a device family */
+       u8 scan_rx_antennas[IEEE80211_NUM_BANDS];
+       enum il_led_mode led_mode;
+
+       int eeprom_size;
+       int num_of_queues;              /* def: HW dependent */
+       int num_of_ampdu_queues;        /* def: HW dependent */
+       /* for il_apm_init() */
+       u32 pll_cfg_val;
+       bool set_l0s;
+       bool use_bsm;
+
+       u16 led_compensation;
+       int chain_noise_num_beacons;
+       unsigned int wd_timeout;
+       bool temperature_kelvin;
+       const bool ucode_tracing;
+       const bool sensitivity_calib_by_driver;
+       const bool chain_noise_calib_by_driver;
+
+       const u32 regulatory_bands[7];
+};
+
+/***************************
+ *   L i b                 *
+ ***************************/
+
+int il_mac_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                  u16 queue, const struct ieee80211_tx_queue_params *params);
+int il_mac_tx_last_beacon(struct ieee80211_hw *hw);
+
+void il_set_rxon_hwcrypto(struct il_priv *il, int hw_decrypt);
+int il_check_rxon_cmd(struct il_priv *il);
+int il_full_rxon_required(struct il_priv *il);
+int il_set_rxon_channel(struct il_priv *il, struct ieee80211_channel *ch);
+void il_set_flags_for_band(struct il_priv *il, enum ieee80211_band band,
+                          struct ieee80211_vif *vif);
+u8 il_get_single_channel_number(struct il_priv *il, enum ieee80211_band band);
+void il_set_rxon_ht(struct il_priv *il, struct il_ht_config *ht_conf);
+bool il_is_ht40_tx_allowed(struct il_priv *il,
+                          struct ieee80211_sta_ht_cap *ht_cap);
+void il_connection_init_rx_config(struct il_priv *il);
+void il_set_rate(struct il_priv *il);
+int il_set_decrypted_flag(struct il_priv *il, struct ieee80211_hdr *hdr,
+                         u32 decrypt_res, struct ieee80211_rx_status *stats);
+void il_irq_handle_error(struct il_priv *il);
+int il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
+void il_mac_remove_interface(struct ieee80211_hw *hw,
+                            struct ieee80211_vif *vif);
+int il_mac_change_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                           enum nl80211_iftype newtype, bool newp2p);
+void il_mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                 u32 queues, bool drop);
+int il_alloc_txq_mem(struct il_priv *il);
+void il_free_txq_mem(struct il_priv *il);
+
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+void il_update_stats(struct il_priv *il, bool is_tx, __le16 fc, u16 len);
+#else
+static inline void
+il_update_stats(struct il_priv *il, bool is_tx, __le16 fc, u16 len)
+{
+}
+#endif
+
+/*****************************************************
+ * Handlers
+ ***************************************************/
+void il_hdl_pm_sleep(struct il_priv *il, struct il_rx_buf *rxb);
+void il_hdl_pm_debug_stats(struct il_priv *il, struct il_rx_buf *rxb);
+void il_hdl_error(struct il_priv *il, struct il_rx_buf *rxb);
+void il_hdl_csa(struct il_priv *il, struct il_rx_buf *rxb);
+
+/*****************************************************
+* RX
+******************************************************/
+void il_cmd_queue_unmap(struct il_priv *il);
+void il_cmd_queue_free(struct il_priv *il);
+int il_rx_queue_alloc(struct il_priv *il);
+void il_rx_queue_update_write_ptr(struct il_priv *il, struct il_rx_queue *q);
+int il_rx_queue_space(const struct il_rx_queue *q);
+void il_tx_cmd_complete(struct il_priv *il, struct il_rx_buf *rxb);
+
+void il_hdl_spectrum_measurement(struct il_priv *il, struct il_rx_buf *rxb);
+void il_recover_from_stats(struct il_priv *il, struct il_rx_pkt *pkt);
+void il_chswitch_done(struct il_priv *il, bool is_success);
+
+/*****************************************************
+* TX
+******************************************************/
+void il_txq_update_write_ptr(struct il_priv *il, struct il_tx_queue *txq);
+int il_tx_queue_init(struct il_priv *il, u32 txq_id);
+void il_tx_queue_reset(struct il_priv *il, u32 txq_id);
+void il_tx_queue_unmap(struct il_priv *il, int txq_id);
+void il_tx_queue_free(struct il_priv *il, int txq_id);
+void il_setup_watchdog(struct il_priv *il);
+/*****************************************************
+ * TX power
+ ****************************************************/
+int il_set_tx_power(struct il_priv *il, s8 tx_power, bool force);
+
+/*******************************************************************************
+ * Rate
+ ******************************************************************************/
+
+u8 il_get_lowest_plcp(struct il_priv *il);
+
+/*******************************************************************************
+ * Scanning
+ ******************************************************************************/
+void il_init_scan_params(struct il_priv *il);
+int il_scan_cancel(struct il_priv *il);
+int il_scan_cancel_timeout(struct il_priv *il, unsigned long ms);
+void il_force_scan_end(struct il_priv *il);
+int il_mac_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                  struct ieee80211_scan_request *hw_req);
+void il_internal_short_hw_scan(struct il_priv *il);
+int il_force_reset(struct il_priv *il, bool external);
+u16 il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
+                     const u8 *ta, const u8 *ie, int ie_len, int left);
+void il_setup_rx_scan_handlers(struct il_priv *il);
+u16 il_get_active_dwell_time(struct il_priv *il, enum ieee80211_band band,
+                            u8 n_probes);
+u16 il_get_passive_dwell_time(struct il_priv *il, enum ieee80211_band band,
+                             struct ieee80211_vif *vif);
+void il_setup_scan_deferred_work(struct il_priv *il);
+void il_cancel_scan_deferred_work(struct il_priv *il);
+
+/* For faster active scanning, scan will move to the next channel if fewer than
+ * PLCP_QUIET_THRESH packets are heard on this channel within
+ * ACTIVE_QUIET_TIME after sending probe request.  This shortens the dwell
+ * time if it's a quiet channel (nothing responded to our probe, and there's
+ * no other traffic).
+ * Disable "quiet" feature by setting PLCP_QUIET_THRESH to 0. */
+#define IL_ACTIVE_QUIET_TIME       cpu_to_le16(10)     /* msec */
+#define IL_PLCP_QUIET_THRESH       cpu_to_le16(1)      /* packets */
+
+#define IL_SCAN_CHECK_WATCHDOG         (HZ * 7)
+
+/*****************************************************
+ *   S e n d i n g     H o s t     C o m m a n d s   *
+ *****************************************************/
+
+const char *il_get_cmd_string(u8 cmd);
+int __must_check il_send_cmd_sync(struct il_priv *il, struct il_host_cmd *cmd);
+int il_send_cmd(struct il_priv *il, struct il_host_cmd *cmd);
+int __must_check il_send_cmd_pdu(struct il_priv *il, u8 id, u16 len,
+                                const void *data);
+int il_send_cmd_pdu_async(struct il_priv *il, u8 id, u16 len, const void *data,
+                         void (*callback) (struct il_priv *il,
+                                           struct il_device_cmd *cmd,
+                                           struct il_rx_pkt *pkt));
+
+int il_enqueue_hcmd(struct il_priv *il, struct il_host_cmd *cmd);
+
+/*****************************************************
+ * PCI                                              *
+ *****************************************************/
+
+void il_bg_watchdog(unsigned long data);
+u32 il_usecs_to_beacons(struct il_priv *il, u32 usec, u32 beacon_interval);
+__le32 il_add_beacon_time(struct il_priv *il, u32 base, u32 addon,
+                         u32 beacon_interval);
+
+#ifdef CONFIG_PM_SLEEP
+extern const struct dev_pm_ops il_pm_ops;
+
+#define IL_LEGACY_PM_OPS       (&il_pm_ops)
+
+#else /* !CONFIG_PM_SLEEP */
+
+#define IL_LEGACY_PM_OPS       NULL
+
+#endif /* !CONFIG_PM_SLEEP */
+
+/*****************************************************
+*  Error Handling Debugging
+******************************************************/
+void il4965_dump_nic_error_log(struct il_priv *il);
+#ifdef CONFIG_IWLEGACY_DEBUG
+void il_print_rx_config_cmd(struct il_priv *il);
+#else
+static inline void
+il_print_rx_config_cmd(struct il_priv *il)
+{
+}
+#endif
+
+void il_clear_isr_stats(struct il_priv *il);
+
+/*****************************************************
+*  GEOS
+******************************************************/
+int il_init_geos(struct il_priv *il);
+void il_free_geos(struct il_priv *il);
+
+/*************** DRIVER STATUS FUNCTIONS   *****/
+
+#define S_HCMD_ACTIVE  0       /* host command in progress */
+/* 1 is unused (used to be S_HCMD_SYNC_ACTIVE) */
+#define S_INT_ENABLED  2
+#define S_RFKILL       3
+#define S_CT_KILL              4
+#define S_INIT         5
+#define S_ALIVE                6
+#define S_READY                7
+#define S_TEMPERATURE  8
+#define S_GEO_CONFIGURED       9
+#define S_EXIT_PENDING 10
+#define S_STATS                12
+#define S_SCANNING             13
+#define S_SCAN_ABORTING        14
+#define S_SCAN_HW              15
+#define S_POWER_PMI    16
+#define S_FW_ERROR             17
+#define S_CHANNEL_SWITCH_PENDING 18
+
+static inline int
+il_is_ready(struct il_priv *il)
+{
+       /* The adapter is 'ready' if READY and GEO_CONFIGURED bits are
+        * set but EXIT_PENDING is not */
+       return test_bit(S_READY, &il->status) &&
+           test_bit(S_GEO_CONFIGURED, &il->status) &&
+           !test_bit(S_EXIT_PENDING, &il->status);
+}
+
+static inline int
+il_is_alive(struct il_priv *il)
+{
+       return test_bit(S_ALIVE, &il->status);
+}
+
+static inline int
+il_is_init(struct il_priv *il)
+{
+       return test_bit(S_INIT, &il->status);
+}
+
+static inline int
+il_is_rfkill(struct il_priv *il)
+{
+       return test_bit(S_RFKILL, &il->status);
+}
+
+static inline int
+il_is_ctkill(struct il_priv *il)
+{
+       return test_bit(S_CT_KILL, &il->status);
+}
+
+static inline int
+il_is_ready_rf(struct il_priv *il)
+{
+
+       if (il_is_rfkill(il))
+               return 0;
+
+       return il_is_ready(il);
+}
+
+void il_send_bt_config(struct il_priv *il);
+int il_send_stats_request(struct il_priv *il, u8 flags, bool clear);
+void il_apm_stop(struct il_priv *il);
+void _il_apm_stop(struct il_priv *il);
+
+int il_apm_init(struct il_priv *il);
+
+int il_send_rxon_timing(struct il_priv *il);
+
+static inline int
+il_send_rxon_assoc(struct il_priv *il)
+{
+       return il->ops->rxon_assoc(il);
+}
+
+static inline int
+il_commit_rxon(struct il_priv *il)
+{
+       return il->ops->commit_rxon(il);
+}
+
+static inline const struct ieee80211_supported_band *
+il_get_hw_mode(struct il_priv *il, enum ieee80211_band band)
+{
+       return il->hw->wiphy->bands[band];
+}
+
+/* mac80211 handlers */
+int il_mac_config(struct ieee80211_hw *hw, u32 changed);
+void il_mac_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
+void il_mac_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                            struct ieee80211_bss_conf *bss_conf, u32 changes);
+void il_tx_cmd_protection(struct il_priv *il, struct ieee80211_tx_info *info,
+                         __le16 fc, __le32 *tx_flags);
+
+irqreturn_t il_isr(int irq, void *data);
+
+void il_set_bit(struct il_priv *p, u32 r, u32 m);
+void il_clear_bit(struct il_priv *p, u32 r, u32 m);
+bool _il_grab_nic_access(struct il_priv *il);
+int _il_poll_bit(struct il_priv *il, u32 addr, u32 bits, u32 mask, int timeout);
+int il_poll_bit(struct il_priv *il, u32 addr, u32 mask, int timeout);
+u32 il_rd_prph(struct il_priv *il, u32 reg);
+void il_wr_prph(struct il_priv *il, u32 addr, u32 val);
+u32 il_read_targ_mem(struct il_priv *il, u32 addr);
+void il_write_targ_mem(struct il_priv *il, u32 addr, u32 val);
+
+static inline bool il_need_reclaim(struct il_priv *il, struct il_rx_pkt *pkt)
+{
+       /* Reclaim a command buffer only if this packet is a response
+        * to a (driver-originated) command. If the packet (e.g. Rx frame)
+        * originated from uCode, there is no command buffer to reclaim.
+        * Ucode should set SEQ_RX_FRAME bit if ucode-originated, but
+        * apparently a few don't get set; catch them here.
+        */
+       return !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
+              pkt->hdr.cmd != N_STATS && pkt->hdr.cmd != C_TX &&
+              pkt->hdr.cmd != N_RX_PHY && pkt->hdr.cmd != N_RX &&
+              pkt->hdr.cmd != N_RX_MPDU && pkt->hdr.cmd != N_COMPRESSED_BA;
+}
+
+static inline void
+_il_write8(struct il_priv *il, u32 ofs, u8 val)
+{
+       writeb(val, il->hw_base + ofs);
+}
+#define il_write8(il, ofs, val) _il_write8(il, ofs, val)
+
+static inline void
+_il_wr(struct il_priv *il, u32 ofs, u32 val)
+{
+       writel(val, il->hw_base + ofs);
+}
+
+static inline u32
+_il_rd(struct il_priv *il, u32 ofs)
+{
+       return readl(il->hw_base + ofs);
+}
+
+static inline void
+_il_clear_bit(struct il_priv *il, u32 reg, u32 mask)
+{
+       _il_wr(il, reg, _il_rd(il, reg) & ~mask);
+}
+
+static inline void
+_il_set_bit(struct il_priv *il, u32 reg, u32 mask)
+{
+       _il_wr(il, reg, _il_rd(il, reg) | mask);
+}
+
+static inline void
+_il_release_nic_access(struct il_priv *il)
+{
+       _il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+       /*
+        * In above we are reading CSR_GP_CNTRL register, what will flush any
+        * previous writes, but still want write, which clear MAC_ACCESS_REQ
+        * bit, be performed on PCI bus before any other writes scheduled on
+        * different CPUs (after we drop reg_lock).
+        */
+       mmiowb();
+}
+
+static inline u32
+il_rd(struct il_priv *il, u32 reg)
+{
+       u32 value;
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       _il_grab_nic_access(il);
+       value = _il_rd(il, reg);
+       _il_release_nic_access(il);
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+       return value;
+}
+
+static inline void
+il_wr(struct il_priv *il, u32 reg, u32 value)
+{
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       if (likely(_il_grab_nic_access(il))) {
+               _il_wr(il, reg, value);
+               _il_release_nic_access(il);
+       }
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+
+static inline u32
+_il_rd_prph(struct il_priv *il, u32 reg)
+{
+       _il_wr(il, HBUS_TARG_PRPH_RADDR, reg | (3 << 24));
+       return _il_rd(il, HBUS_TARG_PRPH_RDAT);
+}
+
+static inline void
+_il_wr_prph(struct il_priv *il, u32 addr, u32 val)
+{
+       _il_wr(il, HBUS_TARG_PRPH_WADDR, ((addr & 0x0000FFFF) | (3 << 24)));
+       _il_wr(il, HBUS_TARG_PRPH_WDAT, val);
+}
+
+static inline void
+il_set_bits_prph(struct il_priv *il, u32 reg, u32 mask)
+{
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       if (likely(_il_grab_nic_access(il))) {
+               _il_wr_prph(il, reg, (_il_rd_prph(il, reg) | mask));
+               _il_release_nic_access(il);
+       }
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+
+static inline void
+il_set_bits_mask_prph(struct il_priv *il, u32 reg, u32 bits, u32 mask)
+{
+       unsigned long reg_flags;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       if (likely(_il_grab_nic_access(il))) {
+               _il_wr_prph(il, reg, ((_il_rd_prph(il, reg) & mask) | bits));
+               _il_release_nic_access(il);
+       }
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+
+static inline void
+il_clear_bits_prph(struct il_priv *il, u32 reg, u32 mask)
+{
+       unsigned long reg_flags;
+       u32 val;
+
+       spin_lock_irqsave(&il->reg_lock, reg_flags);
+       if (likely(_il_grab_nic_access(il))) {
+               val = _il_rd_prph(il, reg);
+               _il_wr_prph(il, reg, (val & ~mask));
+               _il_release_nic_access(il);
+       }
+       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+
+#define HW_KEY_DYNAMIC 0
+#define HW_KEY_DEFAULT 1
+
+#define IL_STA_DRIVER_ACTIVE BIT(0)    /* driver entry is active */
+#define IL_STA_UCODE_ACTIVE  BIT(1)    /* ucode entry is active */
+#define IL_STA_UCODE_INPROGRESS  BIT(2)        /* ucode entry is in process of
+                                          being activated */
+#define IL_STA_LOCAL BIT(3)    /* station state not directed by mac80211;
+                                  (this is for the IBSS BSSID stations) */
+#define IL_STA_BCAST BIT(4)    /* this station is the special bcast station */
+
+void il_restore_stations(struct il_priv *il);
+void il_clear_ucode_stations(struct il_priv *il);
+void il_dealloc_bcast_stations(struct il_priv *il);
+int il_get_free_ucode_key_idx(struct il_priv *il);
+int il_send_add_sta(struct il_priv *il, struct il_addsta_cmd *sta, u8 flags);
+int il_add_station_common(struct il_priv *il, const u8 *addr, bool is_ap,
+                         struct ieee80211_sta *sta, u8 *sta_id_r);
+int il_remove_station(struct il_priv *il, const u8 sta_id, const u8 * addr);
+int il_mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                     struct ieee80211_sta *sta);
+
+u8 il_prep_station(struct il_priv *il, const u8 *addr, bool is_ap,
+                  struct ieee80211_sta *sta);
+
+int il_send_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq,
+                  u8 flags, bool init);
+
+/**
+ * il_clear_driver_stations - clear knowledge of all stations from driver
+ * @il: iwl il struct
+ *
+ * This is called during il_down() to make sure that in the case
+ * we're coming there from a hardware restart mac80211 will be
+ * able to reconfigure stations -- if we're getting there in the
+ * normal down flow then the stations will already be cleared.
+ */
+static inline void
+il_clear_driver_stations(struct il_priv *il)
+{
+       unsigned long flags;
+
+       spin_lock_irqsave(&il->sta_lock, flags);
+       memset(il->stations, 0, sizeof(il->stations));
+       il->num_stations = 0;
+       il->ucode_key_table = 0;
+       spin_unlock_irqrestore(&il->sta_lock, flags);
+}
+
+static inline int
+il_sta_id(struct ieee80211_sta *sta)
+{
+       if (WARN_ON(!sta))
+               return IL_INVALID_STATION;
+
+       return ((struct il_station_priv_common *)sta->drv_priv)->sta_id;
+}
+
+/**
+ * il_sta_id_or_broadcast - return sta_id or broadcast sta
+ * @il: iwl il
+ * @context: the current context
+ * @sta: mac80211 station
+ *
+ * In certain circumstances mac80211 passes a station pointer
+ * that may be %NULL, for example during TX or key setup. In
+ * that case, we need to use the broadcast station, so this
+ * inline wraps that pattern.
+ */
+static inline int
+il_sta_id_or_broadcast(struct il_priv *il, struct ieee80211_sta *sta)
+{
+       int sta_id;
+
+       if (!sta)
+               return il->hw_params.bcast_id;
+
+       sta_id = il_sta_id(sta);
+
+       /*
+        * mac80211 should not be passing a partially
+        * initialised station!
+        */
+       WARN_ON(sta_id == IL_INVALID_STATION);
+
+       return sta_id;
+}
+
+/**
+ * il_queue_inc_wrap - increment queue idx, wrap back to beginning
+ * @idx -- current idx
+ * @n_bd -- total number of entries in queue (must be power of 2)
+ */
+static inline int
+il_queue_inc_wrap(int idx, int n_bd)
+{
+       return ++idx & (n_bd - 1);
+}
+
+/**
+ * il_queue_dec_wrap - decrement queue idx, wrap back to end
+ * @idx -- current idx
+ * @n_bd -- total number of entries in queue (must be power of 2)
+ */
+static inline int
+il_queue_dec_wrap(int idx, int n_bd)
+{
+       return --idx & (n_bd - 1);
+}
+
+/* TODO: Move fw_desc functions to iwl-pci.ko */
+static inline void
+il_free_fw_desc(struct pci_dev *pci_dev, struct fw_desc *desc)
+{
+       if (desc->v_addr)
+               dma_free_coherent(&pci_dev->dev, desc->len, desc->v_addr,
+                                 desc->p_addr);
+       desc->v_addr = NULL;
+       desc->len = 0;
+}
+
+static inline int
+il_alloc_fw_desc(struct pci_dev *pci_dev, struct fw_desc *desc)
+{
+       if (!desc->len) {
+               desc->v_addr = NULL;
+               return -EINVAL;
+       }
+
+       desc->v_addr = dma_alloc_coherent(&pci_dev->dev, desc->len,
+                                         &desc->p_addr, GFP_KERNEL);
+       return (desc->v_addr != NULL) ? 0 : -ENOMEM;
+}
+
+/*
+ * we have 8 bits used like this:
+ *
+ * 7 6 5 4 3 2 1 0
+ * | | | | | | | |
+ * | | | | | | +-+-------- AC queue (0-3)
+ * | | | | | |
+ * | +-+-+-+-+------------ HW queue ID
+ * |
+ * +---------------------- unused
+ */
+static inline void
+il_set_swq_id(struct il_tx_queue *txq, u8 ac, u8 hwq)
+{
+       BUG_ON(ac > 3);         /* only have 2 bits */
+       BUG_ON(hwq > 31);       /* only use 5 bits */
+
+       txq->swq_id = (hwq << 2) | ac;
+}
+
+static inline void
+_il_wake_queue(struct il_priv *il, u8 ac)
+{
+       if (atomic_dec_return(&il->queue_stop_count[ac]) <= 0)
+               ieee80211_wake_queue(il->hw, ac);
+}
+
+static inline void
+_il_stop_queue(struct il_priv *il, u8 ac)
+{
+       if (atomic_inc_return(&il->queue_stop_count[ac]) > 0)
+               ieee80211_stop_queue(il->hw, ac);
+}
+static inline void
+il_wake_queue(struct il_priv *il, struct il_tx_queue *txq)
+{
+       u8 queue = txq->swq_id;
+       u8 ac = queue & 3;
+       u8 hwq = (queue >> 2) & 0x1f;
+
+       if (test_and_clear_bit(hwq, il->queue_stopped))
+               _il_wake_queue(il, ac);
+}
+
+static inline void
+il_stop_queue(struct il_priv *il, struct il_tx_queue *txq)
+{
+       u8 queue = txq->swq_id;
+       u8 ac = queue & 3;
+       u8 hwq = (queue >> 2) & 0x1f;
+
+       if (!test_and_set_bit(hwq, il->queue_stopped))
+               _il_stop_queue(il, ac);
+}
+
+static inline void
+il_wake_queues_by_reason(struct il_priv *il, int reason)
+{
+       u8 ac;
+
+       if (test_and_clear_bit(reason, &il->stop_reason))
+               for (ac = 0; ac < 4; ac++)
+                       _il_wake_queue(il, ac);
+}
+
+static inline void
+il_stop_queues_by_reason(struct il_priv *il, int reason)
+{
+       u8 ac;
+
+       if (!test_and_set_bit(reason, &il->stop_reason))
+               for (ac = 0; ac < 4; ac++)
+                       _il_stop_queue(il, ac);
+}
+
+#ifdef ieee80211_stop_queue
+#undef ieee80211_stop_queue
+#endif
+
+#define ieee80211_stop_queue DO_NOT_USE_ieee80211_stop_queue
+
+#ifdef ieee80211_wake_queue
+#undef ieee80211_wake_queue
+#endif
+
+#define ieee80211_wake_queue DO_NOT_USE_ieee80211_wake_queue
+
+static inline void
+il_disable_interrupts(struct il_priv *il)
+{
+       clear_bit(S_INT_ENABLED, &il->status);
+
+       /* disable interrupts from uCode/NIC to host */
+       _il_wr(il, CSR_INT_MASK, 0x00000000);
+
+       /* acknowledge/clear/reset any interrupts still pending
+        * from uCode or flow handler (Rx/Tx DMA) */
+       _il_wr(il, CSR_INT, 0xffffffff);
+       _il_wr(il, CSR_FH_INT_STATUS, 0xffffffff);
+}
+
+static inline void
+il_enable_rfkill_int(struct il_priv *il)
+{
+       _il_wr(il, CSR_INT_MASK, CSR_INT_BIT_RF_KILL);
+}
+
+static inline void
+il_enable_interrupts(struct il_priv *il)
+{
+       set_bit(S_INT_ENABLED, &il->status);
+       _il_wr(il, CSR_INT_MASK, il->inta_mask);
+}
+
+/**
+ * il_beacon_time_mask_low - mask of lower 32 bit of beacon time
+ * @il -- pointer to il_priv data structure
+ * @tsf_bits -- number of bits need to shift for masking)
+ */
+static inline u32
+il_beacon_time_mask_low(struct il_priv *il, u16 tsf_bits)
+{
+       return (1 << tsf_bits) - 1;
+}
+
+/**
+ * il_beacon_time_mask_high - mask of higher 32 bit of beacon time
+ * @il -- pointer to il_priv data structure
+ * @tsf_bits -- number of bits need to shift for masking)
+ */
+static inline u32
+il_beacon_time_mask_high(struct il_priv *il, u16 tsf_bits)
+{
+       return ((1 << (32 - tsf_bits)) - 1) << tsf_bits;
+}
+
+/**
+ * struct il_rb_status - reseve buffer status host memory mapped FH registers
+ *
+ * @closed_rb_num [0:11] - Indicates the idx of the RB which was closed
+ * @closed_fr_num [0:11] - Indicates the idx of the RX Frame which was closed
+ * @finished_rb_num [0:11] - Indicates the idx of the current RB
+ *                          in which the last frame was written to
+ * @finished_fr_num [0:11] - Indicates the idx of the RX Frame
+ *                          which was transferred
+ */
+struct il_rb_status {
+       __le16 closed_rb_num;
+       __le16 closed_fr_num;
+       __le16 finished_rb_num;
+       __le16 finished_fr_nam;
+       __le32 __unused;        /* 3945 only */
+} __packed;
+
+#define TFD_QUEUE_SIZE_MAX      256
+#define TFD_QUEUE_SIZE_BC_DUP  64
+#define TFD_QUEUE_BC_SIZE      (TFD_QUEUE_SIZE_MAX + TFD_QUEUE_SIZE_BC_DUP)
+#define IL_TX_DMA_MASK         DMA_BIT_MASK(36)
+#define IL_NUM_OF_TBS          20
+
+static inline u8
+il_get_dma_hi_addr(dma_addr_t addr)
+{
+       return (sizeof(addr) > sizeof(u32) ? (addr >> 16) >> 16 : 0) & 0xF;
+}
+
+/**
+ * struct il_tfd_tb transmit buffer descriptor within transmit frame descriptor
+ *
+ * This structure contains dma address and length of transmission address
+ *
+ * @lo: low [31:0] portion of the dma address of TX buffer every even is
+ *     unaligned on 16 bit boundary
+ * @hi_n_len: 0-3 [35:32] portion of dma
+ *           4-15 length of the tx buffer
+ */
+struct il_tfd_tb {
+       __le32 lo;
+       __le16 hi_n_len;
+} __packed;
+
+/**
+ * struct il_tfd
+ *
+ * Transmit Frame Descriptor (TFD)
+ *
+ * @ __reserved1[3] reserved
+ * @ num_tbs 0-4 number of active tbs
+ *          5   reserved
+ *          6-7 padding (not used)
+ * @ tbs[20]   transmit frame buffer descriptors
+ * @ __pad     padding
+ *
+ * Each Tx queue uses a circular buffer of 256 TFDs stored in host DRAM.
+ * Both driver and device share these circular buffers, each of which must be
+ * contiguous 256 TFDs x 128 bytes-per-TFD = 32 KBytes
+ *
+ * Driver must indicate the physical address of the base of each
+ * circular buffer via the FH49_MEM_CBBC_QUEUE registers.
+ *
+ * Each TFD contains pointer/size information for up to 20 data buffers
+ * in host DRAM.  These buffers collectively contain the (one) frame described
+ * by the TFD.  Each buffer must be a single contiguous block of memory within
+ * itself, but buffers may be scattered in host DRAM.  Each buffer has max size
+ * of (4K - 4).  The concatenates all of a TFD's buffers into a single
+ * Tx frame, up to 8 KBytes in size.
+ *
+ * A maximum of 255 (not 256!) TFDs may be on a queue waiting for Tx.
+ */
+struct il_tfd {
+       u8 __reserved1[3];
+       u8 num_tbs;
+       struct il_tfd_tb tbs[IL_NUM_OF_TBS];
+       __le32 __pad;
+} __packed;
+/* PCI registers */
+#define PCI_CFG_RETRY_TIMEOUT  0x041
+
+struct il_rate_info {
+       u8 plcp;                /* uCode API:  RATE_6M_PLCP, etc. */
+       u8 plcp_siso;           /* uCode API:  RATE_SISO_6M_PLCP, etc. */
+       u8 plcp_mimo2;          /* uCode API:  RATE_MIMO2_6M_PLCP, etc. */
+       u8 ieee;                /* MAC header:  RATE_6M_IEEE, etc. */
+       u8 prev_ieee;           /* previous rate in IEEE speeds */
+       u8 next_ieee;           /* next rate in IEEE speeds */
+       u8 prev_rs;             /* previous rate used in rs algo */
+       u8 next_rs;             /* next rate used in rs algo */
+       u8 prev_rs_tgg;         /* previous rate used in TGG rs algo */
+       u8 next_rs_tgg;         /* next rate used in TGG rs algo */
+};
+
+struct il3945_rate_info {
+       u8 plcp;                /* uCode API:  RATE_6M_PLCP, etc. */
+       u8 ieee;                /* MAC header:  RATE_6M_IEEE, etc. */
+       u8 prev_ieee;           /* previous rate in IEEE speeds */
+       u8 next_ieee;           /* next rate in IEEE speeds */
+       u8 prev_rs;             /* previous rate used in rs algo */
+       u8 next_rs;             /* next rate used in rs algo */
+       u8 prev_rs_tgg;         /* previous rate used in TGG rs algo */
+       u8 next_rs_tgg;         /* next rate used in TGG rs algo */
+       u8 table_rs_idx;        /* idx in rate scale table cmd */
+       u8 prev_table_rs;       /* prev in rate table cmd */
+};
+
+/*
+ * These serve as idxes into
+ * struct il_rate_info il_rates[RATE_COUNT];
+ */
+enum {
+       RATE_1M_IDX = 0,
+       RATE_2M_IDX,
+       RATE_5M_IDX,
+       RATE_11M_IDX,
+       RATE_6M_IDX,
+       RATE_9M_IDX,
+       RATE_12M_IDX,
+       RATE_18M_IDX,
+       RATE_24M_IDX,
+       RATE_36M_IDX,
+       RATE_48M_IDX,
+       RATE_54M_IDX,
+       RATE_60M_IDX,
+       RATE_COUNT,
+       RATE_COUNT_LEGACY = RATE_COUNT - 1,     /* Excluding 60M */
+       RATE_COUNT_3945 = RATE_COUNT - 1,
+       RATE_INVM_IDX = RATE_COUNT,
+       RATE_INVALID = RATE_COUNT,
+};
+
+enum {
+       RATE_6M_IDX_TBL = 0,
+       RATE_9M_IDX_TBL,
+       RATE_12M_IDX_TBL,
+       RATE_18M_IDX_TBL,
+       RATE_24M_IDX_TBL,
+       RATE_36M_IDX_TBL,
+       RATE_48M_IDX_TBL,
+       RATE_54M_IDX_TBL,
+       RATE_1M_IDX_TBL,
+       RATE_2M_IDX_TBL,
+       RATE_5M_IDX_TBL,
+       RATE_11M_IDX_TBL,
+       RATE_INVM_IDX_TBL = RATE_INVM_IDX - 1,
+};
+
+enum {
+       IL_FIRST_OFDM_RATE = RATE_6M_IDX,
+       IL39_LAST_OFDM_RATE = RATE_54M_IDX,
+       IL_LAST_OFDM_RATE = RATE_60M_IDX,
+       IL_FIRST_CCK_RATE = RATE_1M_IDX,
+       IL_LAST_CCK_RATE = RATE_11M_IDX,
+};
+
+/* #define vs. enum to keep from defaulting to 'large integer' */
+#define        RATE_6M_MASK   (1 << RATE_6M_IDX)
+#define        RATE_9M_MASK   (1 << RATE_9M_IDX)
+#define        RATE_12M_MASK  (1 << RATE_12M_IDX)
+#define        RATE_18M_MASK  (1 << RATE_18M_IDX)
+#define        RATE_24M_MASK  (1 << RATE_24M_IDX)
+#define        RATE_36M_MASK  (1 << RATE_36M_IDX)
+#define        RATE_48M_MASK  (1 << RATE_48M_IDX)
+#define        RATE_54M_MASK  (1 << RATE_54M_IDX)
+#define RATE_60M_MASK  (1 << RATE_60M_IDX)
+#define        RATE_1M_MASK   (1 << RATE_1M_IDX)
+#define        RATE_2M_MASK   (1 << RATE_2M_IDX)
+#define        RATE_5M_MASK   (1 << RATE_5M_IDX)
+#define        RATE_11M_MASK  (1 << RATE_11M_IDX)
+
+/* uCode API values for legacy bit rates, both OFDM and CCK */
+enum {
+       RATE_6M_PLCP = 13,
+       RATE_9M_PLCP = 15,
+       RATE_12M_PLCP = 5,
+       RATE_18M_PLCP = 7,
+       RATE_24M_PLCP = 9,
+       RATE_36M_PLCP = 11,
+       RATE_48M_PLCP = 1,
+       RATE_54M_PLCP = 3,
+       RATE_60M_PLCP = 3,      /*FIXME:RS:should be removed */
+       RATE_1M_PLCP = 10,
+       RATE_2M_PLCP = 20,
+       RATE_5M_PLCP = 55,
+       RATE_11M_PLCP = 110,
+       /*FIXME:RS:add RATE_LEGACY_INVM_PLCP = 0, */
+};
+
+/* uCode API values for OFDM high-throughput (HT) bit rates */
+enum {
+       RATE_SISO_6M_PLCP = 0,
+       RATE_SISO_12M_PLCP = 1,
+       RATE_SISO_18M_PLCP = 2,
+       RATE_SISO_24M_PLCP = 3,
+       RATE_SISO_36M_PLCP = 4,
+       RATE_SISO_48M_PLCP = 5,
+       RATE_SISO_54M_PLCP = 6,
+       RATE_SISO_60M_PLCP = 7,
+       RATE_MIMO2_6M_PLCP = 0x8,
+       RATE_MIMO2_12M_PLCP = 0x9,
+       RATE_MIMO2_18M_PLCP = 0xa,
+       RATE_MIMO2_24M_PLCP = 0xb,
+       RATE_MIMO2_36M_PLCP = 0xc,
+       RATE_MIMO2_48M_PLCP = 0xd,
+       RATE_MIMO2_54M_PLCP = 0xe,
+       RATE_MIMO2_60M_PLCP = 0xf,
+       RATE_SISO_INVM_PLCP,
+       RATE_MIMO2_INVM_PLCP = RATE_SISO_INVM_PLCP,
+};
+
+/* MAC header values for bit rates */
+enum {
+       RATE_6M_IEEE = 12,
+       RATE_9M_IEEE = 18,
+       RATE_12M_IEEE = 24,
+       RATE_18M_IEEE = 36,
+       RATE_24M_IEEE = 48,
+       RATE_36M_IEEE = 72,
+       RATE_48M_IEEE = 96,
+       RATE_54M_IEEE = 108,
+       RATE_60M_IEEE = 120,
+       RATE_1M_IEEE = 2,
+       RATE_2M_IEEE = 4,
+       RATE_5M_IEEE = 11,
+       RATE_11M_IEEE = 22,
+};
+
+#define IL_CCK_BASIC_RATES_MASK    \
+       (RATE_1M_MASK          | \
+       RATE_2M_MASK)
+
+#define IL_CCK_RATES_MASK          \
+       (IL_CCK_BASIC_RATES_MASK  | \
+       RATE_5M_MASK          | \
+       RATE_11M_MASK)
+
+#define IL_OFDM_BASIC_RATES_MASK   \
+       (RATE_6M_MASK         | \
+       RATE_12M_MASK         | \
+       RATE_24M_MASK)
+
+#define IL_OFDM_RATES_MASK         \
+       (IL_OFDM_BASIC_RATES_MASK | \
+       RATE_9M_MASK          | \
+       RATE_18M_MASK         | \
+       RATE_36M_MASK         | \
+       RATE_48M_MASK         | \
+       RATE_54M_MASK)
+
+#define IL_BASIC_RATES_MASK         \
+       (IL_OFDM_BASIC_RATES_MASK | \
+        IL_CCK_BASIC_RATES_MASK)
+
+#define RATES_MASK ((1 << RATE_COUNT) - 1)
+#define RATES_MASK_3945 ((1 << RATE_COUNT_3945) - 1)
+
+#define IL_INVALID_VALUE    -1
+
+#define IL_MIN_RSSI_VAL                 -100
+#define IL_MAX_RSSI_VAL                    0
+
+/* These values specify how many Tx frame attempts before
+ * searching for a new modulation mode */
+#define IL_LEGACY_FAILURE_LIMIT        160
+#define IL_LEGACY_SUCCESS_LIMIT        480
+#define IL_LEGACY_TBL_COUNT            160
+
+#define IL_NONE_LEGACY_FAILURE_LIMIT   400
+#define IL_NONE_LEGACY_SUCCESS_LIMIT   4500
+#define IL_NONE_LEGACY_TBL_COUNT       1500
+
+/* Success ratio (ACKed / attempted tx frames) values (perfect is 128 * 100) */
+#define IL_RS_GOOD_RATIO               12800   /* 100% */
+#define RATE_SCALE_SWITCH              10880   /*  85% */
+#define RATE_HIGH_TH           10880   /*  85% */
+#define RATE_INCREASE_TH               6400    /*  50% */
+#define RATE_DECREASE_TH               1920    /*  15% */
+
+/* possible actions when in legacy mode */
+#define IL_LEGACY_SWITCH_ANTENNA1      0
+#define IL_LEGACY_SWITCH_ANTENNA2      1
+#define IL_LEGACY_SWITCH_SISO          2
+#define IL_LEGACY_SWITCH_MIMO2_AB      3
+#define IL_LEGACY_SWITCH_MIMO2_AC      4
+#define IL_LEGACY_SWITCH_MIMO2_BC      5
+
+/* possible actions when in siso mode */
+#define IL_SISO_SWITCH_ANTENNA1        0
+#define IL_SISO_SWITCH_ANTENNA2        1
+#define IL_SISO_SWITCH_MIMO2_AB        2
+#define IL_SISO_SWITCH_MIMO2_AC        3
+#define IL_SISO_SWITCH_MIMO2_BC        4
+#define IL_SISO_SWITCH_GI              5
+
+/* possible actions when in mimo mode */
+#define IL_MIMO2_SWITCH_ANTENNA1       0
+#define IL_MIMO2_SWITCH_ANTENNA2       1
+#define IL_MIMO2_SWITCH_SISO_A         2
+#define IL_MIMO2_SWITCH_SISO_B         3
+#define IL_MIMO2_SWITCH_SISO_C         4
+#define IL_MIMO2_SWITCH_GI             5
+
+#define IL_MAX_SEARCH IL_MIMO2_SWITCH_GI
+
+#define IL_ACTION_LIMIT                3       /* # possible actions */
+
+#define LQ_SIZE                2       /* 2 mode tables:  "Active" and "Search" */
+
+/* load per tid defines for A-MPDU activation */
+#define IL_AGG_TPT_THREHOLD    0
+#define IL_AGG_LOAD_THRESHOLD  10
+#define IL_AGG_ALL_TID         0xff
+#define TID_QUEUE_CELL_SPACING 50      /*mS */
+#define TID_QUEUE_MAX_SIZE     20
+#define TID_ROUND_VALUE                5       /* mS */
+#define TID_MAX_LOAD_COUNT     8
+
+#define TID_MAX_TIME_DIFF ((TID_QUEUE_MAX_SIZE - 1) * TID_QUEUE_CELL_SPACING)
+#define TIME_WRAP_AROUND(x, y) (((y) > (x)) ? (y) - (x) : (0-(x)) + (y))
+
+extern const struct il_rate_info il_rates[RATE_COUNT];
+
+enum il_table_type {
+       LQ_NONE,
+       LQ_G,                   /* legacy types */
+       LQ_A,
+       LQ_SISO,                /* high-throughput types */
+       LQ_MIMO2,
+       LQ_MAX,
+};
+
+#define is_legacy(tbl) ((tbl) == LQ_G || (tbl) == LQ_A)
+#define is_siso(tbl) ((tbl) == LQ_SISO)
+#define is_mimo2(tbl) ((tbl) == LQ_MIMO2)
+#define is_mimo(tbl) (is_mimo2(tbl))
+#define is_Ht(tbl) (is_siso(tbl) || is_mimo(tbl))
+#define is_a_band(tbl) ((tbl) == LQ_A)
+#define is_g_and(tbl) ((tbl) == LQ_G)
+
+#define        ANT_NONE        0x0
+#define        ANT_A           BIT(0)
+#define        ANT_B           BIT(1)
+#define        ANT_AB          (ANT_A | ANT_B)
+#define ANT_C          BIT(2)
+#define        ANT_AC          (ANT_A | ANT_C)
+#define ANT_BC         (ANT_B | ANT_C)
+#define ANT_ABC                (ANT_AB | ANT_C)
+
+#define IL_MAX_MCS_DISPLAY_SIZE        12
+
+struct il_rate_mcs_info {
+       char mbps[IL_MAX_MCS_DISPLAY_SIZE];
+       char mcs[IL_MAX_MCS_DISPLAY_SIZE];
+};
+
+/**
+ * struct il_rate_scale_data -- tx success history for one rate
+ */
+struct il_rate_scale_data {
+       u64 data;               /* bitmap of successful frames */
+       s32 success_counter;    /* number of frames successful */
+       s32 success_ratio;      /* per-cent * 128  */
+       s32 counter;            /* number of frames attempted */
+       s32 average_tpt;        /* success ratio * expected throughput */
+       unsigned long stamp;
+};
+
+/**
+ * struct il_scale_tbl_info -- tx params and success history for all rates
+ *
+ * There are two of these in struct il_lq_sta,
+ * one for "active", and one for "search".
+ */
+struct il_scale_tbl_info {
+       enum il_table_type lq_type;
+       u8 ant_type;
+       u8 is_SGI;              /* 1 = short guard interval */
+       u8 is_ht40;             /* 1 = 40 MHz channel width */
+       u8 is_dup;              /* 1 = duplicated data streams */
+       u8 action;              /* change modulation; IL_[LEGACY/SISO/MIMO]_SWITCH_* */
+       u8 max_search;          /* maximun number of tables we can search */
+       s32 *expected_tpt;      /* throughput metrics; expected_tpt_G, etc. */
+       u32 current_rate;       /* rate_n_flags, uCode API format */
+       struct il_rate_scale_data win[RATE_COUNT];      /* rate histories */
+};
+
+struct il_traffic_load {
+       unsigned long time_stamp;       /* age of the oldest stats */
+       u32 packet_count[TID_QUEUE_MAX_SIZE];   /* packet count in this time
+                                                * slice */
+       u32 total;              /* total num of packets during the
+                                * last TID_MAX_TIME_DIFF */
+       u8 queue_count;         /* number of queues that has
+                                * been used since the last cleanup */
+       u8 head;                /* start of the circular buffer */
+};
+
+/**
+ * struct il_lq_sta -- driver's rate scaling ilate structure
+ *
+ * Pointer to this gets passed back and forth between driver and mac80211.
+ */
+struct il_lq_sta {
+       u8 active_tbl;          /* idx of active table, range 0-1 */
+       u8 enable_counter;      /* indicates HT mode */
+       u8 stay_in_tbl;         /* 1: disallow, 0: allow search for new mode */
+       u8 search_better_tbl;   /* 1: currently trying alternate mode */
+       s32 last_tpt;
+
+       /* The following determine when to search for a new mode */
+       u32 table_count_limit;
+       u32 max_failure_limit;  /* # failed frames before new search */
+       u32 max_success_limit;  /* # successful frames before new search */
+       u32 table_count;
+       u32 total_failed;       /* total failed frames, any/all rates */
+       u32 total_success;      /* total successful frames, any/all rates */
+       u64 flush_timer;        /* time staying in mode before new search */
+
+       u8 action_counter;      /* # mode-switch actions tried */
+       u8 is_green;
+       u8 is_dup;
+       enum ieee80211_band band;
+
+       /* The following are bitmaps of rates; RATE_6M_MASK, etc. */
+       u32 supp_rates;
+       u16 active_legacy_rate;
+       u16 active_siso_rate;
+       u16 active_mimo2_rate;
+       s8 max_rate_idx;        /* Max rate set by user */
+       u8 missed_rate_counter;
+
+       struct il_link_quality_cmd lq;
+       struct il_scale_tbl_info lq_info[LQ_SIZE];      /* "active", "search" */
+       struct il_traffic_load load[TID_MAX_LOAD_COUNT];
+       u8 tx_agg_tid_en;
+#ifdef CONFIG_MAC80211_DEBUGFS
+       struct dentry *rs_sta_dbgfs_scale_table_file;
+       struct dentry *rs_sta_dbgfs_stats_table_file;
+       struct dentry *rs_sta_dbgfs_rate_scale_data_file;
+       struct dentry *rs_sta_dbgfs_tx_agg_tid_en_file;
+       u32 dbg_fixed_rate;
+#endif
+       struct il_priv *drv;
+
+       /* used to be in sta_info */
+       int last_txrate_idx;
+       /* last tx rate_n_flags */
+       u32 last_rate_n_flags;
+       /* packets destined for this STA are aggregated */
+       u8 is_agg;
+};
+
+/*
+ * il_station_priv: Driver's ilate station information
+ *
+ * When mac80211 creates a station it reserves some space (hw->sta_data_size)
+ * in the structure for use by driver. This structure is places in that
+ * space.
+ *
+ * The common struct MUST be first because it is shared between
+ * 3945 and 4965!
+ */
+struct il_station_priv {
+       struct il_station_priv_common common;
+       struct il_lq_sta lq_sta;
+       atomic_t pending_frames;
+       bool client;
+       bool asleep;
+};
+
+static inline u8
+il4965_num_of_ant(u8 m)
+{
+       return !!(m & ANT_A) + !!(m & ANT_B) + !!(m & ANT_C);
+}
+
+static inline u8
+il4965_first_antenna(u8 mask)
+{
+       if (mask & ANT_A)
+               return ANT_A;
+       if (mask & ANT_B)
+               return ANT_B;
+       return ANT_C;
+}
+
+/**
+ * il3945_rate_scale_init - Initialize the rate scale table based on assoc info
+ *
+ * The specific throughput table used is based on the type of network
+ * the associated with, including A, B, G, and G w/ TGG protection
+ */
+void il3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id);
+
+/* Initialize station's rate scaling information after adding station */
+void il4965_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta,
+                        u8 sta_id);
+void il3945_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta,
+                        u8 sta_id);
+
+/**
+ * il_rate_control_register - Register the rate control algorithm callbacks
+ *
+ * Since the rate control algorithm is hardware specific, there is no need
+ * or reason to place it as a stand alone module.  The driver can call
+ * il_rate_control_register in order to register the rate control callbacks
+ * with the mac80211 subsystem.  This should be performed prior to calling
+ * ieee80211_register_hw
+ *
+ */
+int il4965_rate_control_register(void);
+int il3945_rate_control_register(void);
+
+/**
+ * il_rate_control_unregister - Unregister the rate control callbacks
+ *
+ * This should be called after calling ieee80211_unregister_hw, but before
+ * the driver is unloaded.
+ */
+void il4965_rate_control_unregister(void);
+void il3945_rate_control_unregister(void);
+
+int il_power_update_mode(struct il_priv *il, bool force);
+void il_power_initialize(struct il_priv *il);
+
+extern u32 il_debug_level;
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+/*
+ * il_get_debug_level: Return active debug level for device
+ *
+ * Using sysfs it is possible to set per device debug level. This debug
+ * level will be used if set, otherwise the global debug level which can be
+ * set via module parameter is used.
+ */
+static inline u32
+il_get_debug_level(struct il_priv *il)
+{
+       if (il->debug_level)
+               return il->debug_level;
+       else
+               return il_debug_level;
+}
+#else
+static inline u32
+il_get_debug_level(struct il_priv *il)
+{
+       return il_debug_level;
+}
+#endif
+
+#define il_print_hex_error(il, p, len)                                 \
+do {                                                                   \
+       print_hex_dump(KERN_ERR, "iwl data: ",                          \
+                      DUMP_PREFIX_OFFSET, 16, 1, p, len, 1);           \
+} while (0)
+
+#ifdef CONFIG_IWLEGACY_DEBUG
+#define IL_DBG(level, fmt, args...)                                    \
+do {                                                                   \
+       if (il_get_debug_level(il) & level)                             \
+               dev_err(&il->hw->wiphy->dev, "%c %s " fmt,              \
+                       in_interrupt() ? 'I' : 'U', __func__ , ##args); \
+} while (0)
+
+#define il_print_hex_dump(il, level, p, len)                           \
+do {                                                                   \
+       if (il_get_debug_level(il) & level)                             \
+               print_hex_dump(KERN_DEBUG, "iwl data: ",                \
+                              DUMP_PREFIX_OFFSET, 16, 1, p, len, 1);   \
+} while (0)
+
+#else
+#define IL_DBG(level, fmt, args...)
+static inline void
+il_print_hex_dump(struct il_priv *il, int level, const void *p, u32 len)
+{
+}
+#endif /* CONFIG_IWLEGACY_DEBUG */
+
+#ifdef CONFIG_IWLEGACY_DEBUGFS
+int il_dbgfs_register(struct il_priv *il, const char *name);
+void il_dbgfs_unregister(struct il_priv *il);
+#else
+static inline int
+il_dbgfs_register(struct il_priv *il, const char *name)
+{
+       return 0;
+}
+
+static inline void
+il_dbgfs_unregister(struct il_priv *il)
+{
+}
+#endif /* CONFIG_IWLEGACY_DEBUGFS */
+
+/*
+ * To use the debug system:
+ *
+ * If you are defining a new debug classification, simply add it to the #define
+ * list here in the form of
+ *
+ * #define IL_DL_xxxx VALUE
+ *
+ * where xxxx should be the name of the classification (for example, WEP).
+ *
+ * You then need to either add a IL_xxxx_DEBUG() macro definition for your
+ * classification, or use IL_DBG(IL_DL_xxxx, ...) whenever you want
+ * to send output to that classification.
+ *
+ * The active debug levels can be accessed via files
+ *
+ *     /sys/module/iwl4965/parameters/debug
+ *     /sys/module/iwl3945/parameters/debug
+ *     /sys/class/net/wlan0/device/debug_level
+ *
+ * when CONFIG_IWLEGACY_DEBUG=y.
+ */
+
+/* 0x0000000F - 0x00000001 */
+#define IL_DL_INFO             (1 << 0)
+#define IL_DL_MAC80211         (1 << 1)
+#define IL_DL_HCMD             (1 << 2)
+#define IL_DL_STATE            (1 << 3)
+/* 0x000000F0 - 0x00000010 */
+#define IL_DL_MACDUMP          (1 << 4)
+#define IL_DL_HCMD_DUMP                (1 << 5)
+#define IL_DL_EEPROM           (1 << 6)
+#define IL_DL_RADIO            (1 << 7)
+/* 0x00000F00 - 0x00000100 */
+#define IL_DL_POWER            (1 << 8)
+#define IL_DL_TEMP             (1 << 9)
+#define IL_DL_NOTIF            (1 << 10)
+#define IL_DL_SCAN             (1 << 11)
+/* 0x0000F000 - 0x00001000 */
+#define IL_DL_ASSOC            (1 << 12)
+#define IL_DL_DROP             (1 << 13)
+#define IL_DL_TXPOWER          (1 << 14)
+#define IL_DL_AP               (1 << 15)
+/* 0x000F0000 - 0x00010000 */
+#define IL_DL_FW               (1 << 16)
+#define IL_DL_RF_KILL          (1 << 17)
+#define IL_DL_FW_ERRORS                (1 << 18)
+#define IL_DL_LED              (1 << 19)
+/* 0x00F00000 - 0x00100000 */
+#define IL_DL_RATE             (1 << 20)
+#define IL_DL_CALIB            (1 << 21)
+#define IL_DL_WEP              (1 << 22)
+#define IL_DL_TX               (1 << 23)
+/* 0x0F000000 - 0x01000000 */
+#define IL_DL_RX               (1 << 24)
+#define IL_DL_ISR              (1 << 25)
+#define IL_DL_HT               (1 << 26)
+/* 0xF0000000 - 0x10000000 */
+#define IL_DL_11H              (1 << 28)
+#define IL_DL_STATS            (1 << 29)
+#define IL_DL_TX_REPLY         (1 << 30)
+#define IL_DL_QOS              (1 << 31)
+
+#define D_INFO(f, a...)                IL_DBG(IL_DL_INFO, f, ## a)
+#define D_MAC80211(f, a...)    IL_DBG(IL_DL_MAC80211, f, ## a)
+#define D_MACDUMP(f, a...)     IL_DBG(IL_DL_MACDUMP, f, ## a)
+#define D_TEMP(f, a...)                IL_DBG(IL_DL_TEMP, f, ## a)
+#define D_SCAN(f, a...)                IL_DBG(IL_DL_SCAN, f, ## a)
+#define D_RX(f, a...)          IL_DBG(IL_DL_RX, f, ## a)
+#define D_TX(f, a...)          IL_DBG(IL_DL_TX, f, ## a)
+#define D_ISR(f, a...)         IL_DBG(IL_DL_ISR, f, ## a)
+#define D_LED(f, a...)         IL_DBG(IL_DL_LED, f, ## a)
+#define D_WEP(f, a...)         IL_DBG(IL_DL_WEP, f, ## a)
+#define D_HC(f, a...)          IL_DBG(IL_DL_HCMD, f, ## a)
+#define D_HC_DUMP(f, a...)     IL_DBG(IL_DL_HCMD_DUMP, f, ## a)
+#define D_EEPROM(f, a...)      IL_DBG(IL_DL_EEPROM, f, ## a)
+#define D_CALIB(f, a...)       IL_DBG(IL_DL_CALIB, f, ## a)
+#define D_FW(f, a...)          IL_DBG(IL_DL_FW, f, ## a)
+#define D_RF_KILL(f, a...)     IL_DBG(IL_DL_RF_KILL, f, ## a)
+#define D_DROP(f, a...)                IL_DBG(IL_DL_DROP, f, ## a)
+#define D_AP(f, a...)          IL_DBG(IL_DL_AP, f, ## a)
+#define D_TXPOWER(f, a...)     IL_DBG(IL_DL_TXPOWER, f, ## a)
+#define D_RATE(f, a...)                IL_DBG(IL_DL_RATE, f, ## a)
+#define D_NOTIF(f, a...)       IL_DBG(IL_DL_NOTIF, f, ## a)
+#define D_ASSOC(f, a...)       IL_DBG(IL_DL_ASSOC, f, ## a)
+#define D_HT(f, a...)          IL_DBG(IL_DL_HT, f, ## a)
+#define D_STATS(f, a...)       IL_DBG(IL_DL_STATS, f, ## a)
+#define D_TX_REPLY(f, a...)    IL_DBG(IL_DL_TX_REPLY, f, ## a)
+#define D_QOS(f, a...)         IL_DBG(IL_DL_QOS, f, ## a)
+#define D_RADIO(f, a...)       IL_DBG(IL_DL_RADIO, f, ## a)
+#define D_POWER(f, a...)       IL_DBG(IL_DL_POWER, f, ## a)
+#define D_11H(f, a...)         IL_DBG(IL_DL_11H, f, ## a)
+
+#endif /* __il_core_h__ */
diff --git a/drivers/net/wireless/intel/iwlegacy/csr.h b/drivers/net/wireless/intel/iwlegacy/csr.h
new file mode 100644 (file)
index 0000000..9138e15
--- /dev/null
@@ -0,0 +1,419 @@
+/******************************************************************************
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *  * Neither the name Intel Corporation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *****************************************************************************/
+#ifndef __il_csr_h__
+#define __il_csr_h__
+/*
+ * CSR (control and status registers)
+ *
+ * CSR registers are mapped directly into PCI bus space, and are accessible
+ * whenever platform supplies power to device, even when device is in
+ * low power states due to driver-invoked device resets
+ * (e.g. CSR_RESET_REG_FLAG_SW_RESET) or uCode-driven power-saving modes.
+ *
+ * Use _il_wr() and _il_rd() family to access these registers;
+ * these provide simple PCI bus access, without waking up the MAC.
+ * Do not use il_wr() family for these registers;
+ * no need to "grab nic access" via CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ.
+ * The MAC (uCode processor, etc.) does not need to be powered up for accessing
+ * the CSR registers.
+ *
+ * NOTE:  Device does need to be awake in order to read this memory
+ *        via CSR_EEPROM register
+ */
+#define CSR_BASE    (0x000)
+
+#define CSR_HW_IF_CONFIG_REG    (CSR_BASE+0x000)       /* hardware interface config */
+#define CSR_INT_COALESCING      (CSR_BASE+0x004)       /* accum ints, 32-usec units */
+#define CSR_INT                 (CSR_BASE+0x008)       /* host interrupt status/ack */
+#define CSR_INT_MASK            (CSR_BASE+0x00c)       /* host interrupt enable */
+#define CSR_FH_INT_STATUS       (CSR_BASE+0x010)       /* busmaster int status/ack */
+#define CSR_GPIO_IN             (CSR_BASE+0x018)       /* read external chip pins */
+#define CSR_RESET               (CSR_BASE+0x020)       /* busmaster enable, NMI, etc */
+#define CSR_GP_CNTRL            (CSR_BASE+0x024)
+
+/* 2nd byte of CSR_INT_COALESCING, not accessible via _il_wr()! */
+#define CSR_INT_PERIODIC_REG   (CSR_BASE+0x005)
+
+/*
+ * Hardware revision info
+ * Bit fields:
+ * 31-8:  Reserved
+ *  7-4:  Type of device:  see CSR_HW_REV_TYPE_xxx definitions
+ *  3-2:  Revision step:  0 = A, 1 = B, 2 = C, 3 = D
+ *  1-0:  "Dash" (-) value, as in A-1, etc.
+ *
+ * NOTE:  Revision step affects calculation of CCK txpower for 4965.
+ * NOTE:  See also CSR_HW_REV_WA_REG (work-around for bug in 4965).
+ */
+#define CSR_HW_REV              (CSR_BASE+0x028)
+
+/*
+ * EEPROM memory reads
+ *
+ * NOTE:  Device must be awake, initialized via apm_ops.init(),
+ *        in order to read.
+ */
+#define CSR_EEPROM_REG          (CSR_BASE+0x02c)
+#define CSR_EEPROM_GP           (CSR_BASE+0x030)
+
+#define CSR_GIO_REG            (CSR_BASE+0x03C)
+#define CSR_GP_UCODE_REG       (CSR_BASE+0x048)
+#define CSR_GP_DRIVER_REG      (CSR_BASE+0x050)
+
+/*
+ * UCODE-DRIVER GP (general purpose) mailbox registers.
+ * SET/CLR registers set/clear bit(s) if "1" is written.
+ */
+#define CSR_UCODE_DRV_GP1       (CSR_BASE+0x054)
+#define CSR_UCODE_DRV_GP1_SET   (CSR_BASE+0x058)
+#define CSR_UCODE_DRV_GP1_CLR   (CSR_BASE+0x05c)
+#define CSR_UCODE_DRV_GP2       (CSR_BASE+0x060)
+
+#define CSR_LED_REG             (CSR_BASE+0x094)
+#define CSR_DRAM_INT_TBL_REG   (CSR_BASE+0x0A0)
+
+/* GIO Chicken Bits (PCI Express bus link power management) */
+#define CSR_GIO_CHICKEN_BITS    (CSR_BASE+0x100)
+
+/* Analog phase-lock-loop configuration  */
+#define CSR_ANA_PLL_CFG         (CSR_BASE+0x20c)
+
+/*
+ * CSR Hardware Revision Workaround Register.  Indicates hardware rev;
+ * "step" determines CCK backoff for txpower calculation.  Used for 4965 only.
+ * See also CSR_HW_REV register.
+ * Bit fields:
+ *  3-2:  0 = A, 1 = B, 2 = C, 3 = D step
+ *  1-0:  "Dash" (-) value, as in C-1, etc.
+ */
+#define CSR_HW_REV_WA_REG              (CSR_BASE+0x22C)
+
+#define CSR_DBG_HPET_MEM_REG           (CSR_BASE+0x240)
+#define CSR_DBG_LINK_PWR_MGMT_REG      (CSR_BASE+0x250)
+
+/* Bits for CSR_HW_IF_CONFIG_REG */
+#define CSR49_HW_IF_CONFIG_REG_BIT_4965_R      (0x00000010)
+#define CSR_HW_IF_CONFIG_REG_MSK_BOARD_VER     (0x00000C00)
+#define CSR_HW_IF_CONFIG_REG_BIT_MAC_SI        (0x00000100)
+#define CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI      (0x00000200)
+
+#define CSR39_HW_IF_CONFIG_REG_BIT_3945_MB         (0x00000100)
+#define CSR39_HW_IF_CONFIG_REG_BIT_3945_MM         (0x00000200)
+#define CSR39_HW_IF_CONFIG_REG_BIT_SKU_MRC            (0x00000400)
+#define CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE         (0x00000800)
+#define CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_A    (0x00000000)
+#define CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_B    (0x00001000)
+
+#define CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A  (0x00080000)
+#define CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM        (0x00200000)
+#define CSR_HW_IF_CONFIG_REG_BIT_NIC_READY     (0x00400000)    /* PCI_OWN_SEM */
+#define CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE (0x02000000) /* ME_OWN */
+#define CSR_HW_IF_CONFIG_REG_PREPARE             (0x08000000)  /* WAKE_ME */
+
+#define CSR_INT_PERIODIC_DIS                   (0x00)  /* disable periodic int */
+#define CSR_INT_PERIODIC_ENA                   (0xFF)  /* 255*32 usec ~ 8 msec */
+
+/* interrupt flags in INTA, set by uCode or hardware (e.g. dma),
+ * acknowledged (reset) by host writing "1" to flagged bits. */
+#define CSR_INT_BIT_FH_RX        (1 << 31)     /* Rx DMA, cmd responses, FH_INT[17:16] */
+#define CSR_INT_BIT_HW_ERR       (1 << 29)     /* DMA hardware error FH_INT[31] */
+#define CSR_INT_BIT_RX_PERIODIC         (1 << 28)      /* Rx periodic */
+#define CSR_INT_BIT_FH_TX        (1 << 27)     /* Tx DMA FH_INT[1:0] */
+#define CSR_INT_BIT_SCD          (1 << 26)     /* TXQ pointer advanced */
+#define CSR_INT_BIT_SW_ERR       (1 << 25)     /* uCode error */
+#define CSR_INT_BIT_RF_KILL      (1 << 7)      /* HW RFKILL switch GP_CNTRL[27] toggled */
+#define CSR_INT_BIT_CT_KILL      (1 << 6)      /* Critical temp (chip too hot) rfkill */
+#define CSR_INT_BIT_SW_RX        (1 << 3)      /* Rx, command responses, 3945 */
+#define CSR_INT_BIT_WAKEUP       (1 << 1)      /* NIC controller waking up (pwr mgmt) */
+#define CSR_INT_BIT_ALIVE        (1 << 0)      /* uCode interrupts once it initializes */
+
+#define CSR_INI_SET_MASK       (CSR_INT_BIT_FH_RX   | \
+                                CSR_INT_BIT_HW_ERR  | \
+                                CSR_INT_BIT_FH_TX   | \
+                                CSR_INT_BIT_SW_ERR  | \
+                                CSR_INT_BIT_RF_KILL | \
+                                CSR_INT_BIT_SW_RX   | \
+                                CSR_INT_BIT_WAKEUP  | \
+                                CSR_INT_BIT_ALIVE)
+
+/* interrupt flags in FH (flow handler) (PCI busmaster DMA) */
+#define CSR_FH_INT_BIT_ERR       (1 << 31)     /* Error */
+#define CSR_FH_INT_BIT_HI_PRIOR  (1 << 30)     /* High priority Rx, bypass coalescing */
+#define CSR39_FH_INT_BIT_RX_CHNL2  (1 << 18)   /* Rx channel 2 (3945 only) */
+#define CSR_FH_INT_BIT_RX_CHNL1  (1 << 17)     /* Rx channel 1 */
+#define CSR_FH_INT_BIT_RX_CHNL0  (1 << 16)     /* Rx channel 0 */
+#define CSR39_FH_INT_BIT_TX_CHNL6  (1 << 6)    /* Tx channel 6 (3945 only) */
+#define CSR_FH_INT_BIT_TX_CHNL1  (1 << 1)      /* Tx channel 1 */
+#define CSR_FH_INT_BIT_TX_CHNL0  (1 << 0)      /* Tx channel 0 */
+
+#define CSR39_FH_INT_RX_MASK   (CSR_FH_INT_BIT_HI_PRIOR | \
+                                CSR39_FH_INT_BIT_RX_CHNL2 | \
+                                CSR_FH_INT_BIT_RX_CHNL1 | \
+                                CSR_FH_INT_BIT_RX_CHNL0)
+
+#define CSR39_FH_INT_TX_MASK   (CSR39_FH_INT_BIT_TX_CHNL6 | \
+                                CSR_FH_INT_BIT_TX_CHNL1 | \
+                                CSR_FH_INT_BIT_TX_CHNL0)
+
+#define CSR49_FH_INT_RX_MASK   (CSR_FH_INT_BIT_HI_PRIOR | \
+                                CSR_FH_INT_BIT_RX_CHNL1 | \
+                                CSR_FH_INT_BIT_RX_CHNL0)
+
+#define CSR49_FH_INT_TX_MASK   (CSR_FH_INT_BIT_TX_CHNL1 | \
+                                CSR_FH_INT_BIT_TX_CHNL0)
+
+/* GPIO */
+#define CSR_GPIO_IN_BIT_AUX_POWER                   (0x00000200)
+#define CSR_GPIO_IN_VAL_VAUX_PWR_SRC                (0x00000000)
+#define CSR_GPIO_IN_VAL_VMAIN_PWR_SRC               (0x00000200)
+
+/* RESET */
+#define CSR_RESET_REG_FLAG_NEVO_RESET                (0x00000001)
+#define CSR_RESET_REG_FLAG_FORCE_NMI                 (0x00000002)
+#define CSR_RESET_REG_FLAG_SW_RESET                  (0x00000080)
+#define CSR_RESET_REG_FLAG_MASTER_DISABLED           (0x00000100)
+#define CSR_RESET_REG_FLAG_STOP_MASTER               (0x00000200)
+#define CSR_RESET_LINK_PWR_MGMT_DISABLED             (0x80000000)
+
+/*
+ * GP (general purpose) CONTROL REGISTER
+ * Bit fields:
+ *    27:  HW_RF_KILL_SW
+ *         Indicates state of (platform's) hardware RF-Kill switch
+ * 26-24:  POWER_SAVE_TYPE
+ *         Indicates current power-saving mode:
+ *         000 -- No power saving
+ *         001 -- MAC power-down
+ *         010 -- PHY (radio) power-down
+ *         011 -- Error
+ *   9-6:  SYS_CONFIG
+ *         Indicates current system configuration, reflecting pins on chip
+ *         as forced high/low by device circuit board.
+ *     4:  GOING_TO_SLEEP
+ *         Indicates MAC is entering a power-saving sleep power-down.
+ *         Not a good time to access device-internal resources.
+ *     3:  MAC_ACCESS_REQ
+ *         Host sets this to request and maintain MAC wakeup, to allow host
+ *         access to device-internal resources.  Host must wait for
+ *         MAC_CLOCK_READY (and !GOING_TO_SLEEP) before accessing non-CSR
+ *         device registers.
+ *     2:  INIT_DONE
+ *         Host sets this to put device into fully operational D0 power mode.
+ *         Host resets this after SW_RESET to put device into low power mode.
+ *     0:  MAC_CLOCK_READY
+ *         Indicates MAC (ucode processor, etc.) is powered up and can run.
+ *         Internal resources are accessible.
+ *         NOTE:  This does not indicate that the processor is actually running.
+ *         NOTE:  This does not indicate that 4965 or 3945 has completed
+ *                init or post-power-down restore of internal SRAM memory.
+ *                Use CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP as indication that
+ *                SRAM is restored and uCode is in normal operation mode.
+ *                Later devices (5xxx/6xxx/1xxx) use non-volatile SRAM, and
+ *                do not need to save/restore it.
+ *         NOTE:  After device reset, this bit remains "0" until host sets
+ *                INIT_DONE
+ */
+#define CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY        (0x00000001)
+#define CSR_GP_CNTRL_REG_FLAG_INIT_DONE              (0x00000004)
+#define CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ         (0x00000008)
+#define CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP         (0x00000010)
+
+#define CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN           (0x00000001)
+
+#define CSR_GP_CNTRL_REG_MSK_POWER_SAVE_TYPE         (0x07000000)
+#define CSR_GP_CNTRL_REG_FLAG_MAC_POWER_SAVE         (0x04000000)
+#define CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW          (0x08000000)
+
+/* EEPROM REG */
+#define CSR_EEPROM_REG_READ_VALID_MSK  (0x00000001)
+#define CSR_EEPROM_REG_BIT_CMD         (0x00000002)
+#define CSR_EEPROM_REG_MSK_ADDR                (0x0000FFFC)
+#define CSR_EEPROM_REG_MSK_DATA                (0xFFFF0000)
+
+/* EEPROM GP */
+#define CSR_EEPROM_GP_VALID_MSK                (0x00000007)    /* signature */
+#define CSR_EEPROM_GP_IF_OWNER_MSK     (0x00000180)
+#define CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K                (0x00000002)
+#define CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K                (0x00000004)
+
+/* GP REG */
+#define CSR_GP_REG_POWER_SAVE_STATUS_MSK            (0x03000000)       /* bit 24/25 */
+#define CSR_GP_REG_NO_POWER_SAVE            (0x00000000)
+#define CSR_GP_REG_MAC_POWER_SAVE           (0x01000000)
+#define CSR_GP_REG_PHY_POWER_SAVE           (0x02000000)
+#define CSR_GP_REG_POWER_SAVE_ERROR         (0x03000000)
+
+/* CSR GIO */
+#define CSR_GIO_REG_VAL_L0S_ENABLED    (0x00000002)
+
+/*
+ * UCODE-DRIVER GP (general purpose) mailbox register 1
+ * Host driver and uCode write and/or read this register to communicate with
+ * each other.
+ * Bit fields:
+ *     4:  UCODE_DISABLE
+ *         Host sets this to request permanent halt of uCode, same as
+ *         sending CARD_STATE command with "halt" bit set.
+ *     3:  CT_KILL_EXIT
+ *         Host sets this to request exit from CT_KILL state, i.e. host thinks
+ *         device temperature is low enough to continue normal operation.
+ *     2:  CMD_BLOCKED
+ *         Host sets this during RF KILL power-down sequence (HW, SW, CT KILL)
+ *         to release uCode to clear all Tx and command queues, enter
+ *         unassociated mode, and power down.
+ *         NOTE:  Some devices also use HBUS_TARG_MBX_C register for this bit.
+ *     1:  SW_BIT_RFKILL
+ *         Host sets this when issuing CARD_STATE command to request
+ *         device sleep.
+ *     0:  MAC_SLEEP
+ *         uCode sets this when preparing a power-saving power-down.
+ *         uCode resets this when power-up is complete and SRAM is sane.
+ *         NOTE:  3945/4965 saves internal SRAM data to host when powering down,
+ *                and must restore this data after powering back up.
+ *                MAC_SLEEP is the best indication that restore is complete.
+ *                Later devices (5xxx/6xxx/1xxx) use non-volatile SRAM, and
+ *                do not need to save/restore it.
+ */
+#define CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP             (0x00000001)
+#define CSR_UCODE_SW_BIT_RFKILL                     (0x00000002)
+#define CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED           (0x00000004)
+#define CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT      (0x00000008)
+
+/* GIO Chicken Bits (PCI Express bus link power management) */
+#define CSR_GIO_CHICKEN_BITS_REG_BIT_L1A_NO_L0S_RX  (0x00800000)
+#define CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER  (0x20000000)
+
+/* LED */
+#define CSR_LED_BSM_CTRL_MSK (0xFFFFFFDF)
+#define CSR_LED_REG_TRUN_ON (0x78)
+#define CSR_LED_REG_TRUN_OFF (0x38)
+
+/* ANA_PLL */
+#define CSR39_ANA_PLL_CFG_VAL        (0x01000000)
+
+/* HPET MEM debug */
+#define CSR_DBG_HPET_MEM_REG_VAL       (0xFFFF0000)
+
+/* DRAM INT TBL */
+#define CSR_DRAM_INT_TBL_ENABLE                (1 << 31)
+#define CSR_DRAM_INIT_TBL_WRAP_CHECK   (1 << 27)
+
+/*
+ * HBUS (Host-side Bus)
+ *
+ * HBUS registers are mapped directly into PCI bus space, but are used
+ * to indirectly access device's internal memory or registers that
+ * may be powered-down.
+ *
+ * Use il_wr()/il_rd() family
+ * for these registers;
+ * host must "grab nic access" via CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
+ * to make sure the MAC (uCode processor, etc.) is powered up for accessing
+ * internal resources.
+ *
+ * Do not use _il_wr()/_il_rd() family to access these registers;
+ * these provide only simple PCI bus access, without waking up the MAC.
+ */
+#define HBUS_BASE      (0x400)
+
+/*
+ * Registers for accessing device's internal SRAM memory (e.g. SCD SRAM
+ * structures, error log, event log, verifying uCode load).
+ * First write to address register, then read from or write to data register
+ * to complete the job.  Once the address register is set up, accesses to
+ * data registers auto-increment the address by one dword.
+ * Bit usage for address registers (read or write):
+ *  0-31:  memory address within device
+ */
+#define HBUS_TARG_MEM_RADDR     (HBUS_BASE+0x00c)
+#define HBUS_TARG_MEM_WADDR     (HBUS_BASE+0x010)
+#define HBUS_TARG_MEM_WDAT      (HBUS_BASE+0x018)
+#define HBUS_TARG_MEM_RDAT      (HBUS_BASE+0x01c)
+
+/* Mailbox C, used as workaround alternative to CSR_UCODE_DRV_GP1 mailbox */
+#define HBUS_TARG_MBX_C         (HBUS_BASE+0x030)
+#define HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED         (0x00000004)
+
+/*
+ * Registers for accessing device's internal peripheral registers
+ * (e.g. SCD, BSM, etc.).  First write to address register,
+ * then read from or write to data register to complete the job.
+ * Bit usage for address registers (read or write):
+ *  0-15:  register address (offset) within device
+ * 24-25:  (# bytes - 1) to read or write (e.g. 3 for dword)
+ */
+#define HBUS_TARG_PRPH_WADDR    (HBUS_BASE+0x044)
+#define HBUS_TARG_PRPH_RADDR    (HBUS_BASE+0x048)
+#define HBUS_TARG_PRPH_WDAT     (HBUS_BASE+0x04c)
+#define HBUS_TARG_PRPH_RDAT     (HBUS_BASE+0x050)
+
+/*
+ * Per-Tx-queue write pointer (idx, really!)
+ * Indicates idx to next TFD that driver will fill (1 past latest filled).
+ * Bit usage:
+ *  0-7:  queue write idx
+ * 11-8:  queue selector
+ */
+#define HBUS_TARG_WRPTR         (HBUS_BASE+0x060)
+
+#endif /* !__il_csr_h__ */
diff --git a/drivers/net/wireless/intel/iwlegacy/debug.c b/drivers/net/wireless/intel/iwlegacy/debug.c
new file mode 100644 (file)
index 0000000..908b9f4
--- /dev/null
@@ -0,0 +1,1426 @@
+/******************************************************************************
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *****************************************************************************/
+#include <linux/ieee80211.h>
+#include <linux/export.h>
+#include <net/mac80211.h>
+
+#include "common.h"
+
+static void
+il_clear_traffic_stats(struct il_priv *il)
+{
+       memset(&il->tx_stats, 0, sizeof(struct traffic_stats));
+       memset(&il->rx_stats, 0, sizeof(struct traffic_stats));
+}
+
+/*
+ * il_update_stats function record all the MGMT, CTRL and DATA pkt for
+ * both TX and Rx . Use debugfs to display the rx/rx_stats
+ */
+void
+il_update_stats(struct il_priv *il, bool is_tx, __le16 fc, u16 len)
+{
+       struct traffic_stats *stats;
+
+       if (is_tx)
+               stats = &il->tx_stats;
+       else
+               stats = &il->rx_stats;
+
+       if (ieee80211_is_mgmt(fc)) {
+               switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
+               case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
+                       stats->mgmt[MANAGEMENT_ASSOC_REQ]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
+                       stats->mgmt[MANAGEMENT_ASSOC_RESP]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
+                       stats->mgmt[MANAGEMENT_REASSOC_REQ]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
+                       stats->mgmt[MANAGEMENT_REASSOC_RESP]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
+                       stats->mgmt[MANAGEMENT_PROBE_REQ]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
+                       stats->mgmt[MANAGEMENT_PROBE_RESP]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_BEACON):
+                       stats->mgmt[MANAGEMENT_BEACON]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_ATIM):
+                       stats->mgmt[MANAGEMENT_ATIM]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
+                       stats->mgmt[MANAGEMENT_DISASSOC]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_AUTH):
+                       stats->mgmt[MANAGEMENT_AUTH]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
+                       stats->mgmt[MANAGEMENT_DEAUTH]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_ACTION):
+                       stats->mgmt[MANAGEMENT_ACTION]++;
+                       break;
+               }
+       } else if (ieee80211_is_ctl(fc)) {
+               switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
+               case cpu_to_le16(IEEE80211_STYPE_BACK_REQ):
+                       stats->ctrl[CONTROL_BACK_REQ]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_BACK):
+                       stats->ctrl[CONTROL_BACK]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_PSPOLL):
+                       stats->ctrl[CONTROL_PSPOLL]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_RTS):
+                       stats->ctrl[CONTROL_RTS]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_CTS):
+                       stats->ctrl[CONTROL_CTS]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_ACK):
+                       stats->ctrl[CONTROL_ACK]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_CFEND):
+                       stats->ctrl[CONTROL_CFEND]++;
+                       break;
+               case cpu_to_le16(IEEE80211_STYPE_CFENDACK):
+                       stats->ctrl[CONTROL_CFENDACK]++;
+                       break;
+               }
+       } else {
+               /* data */
+               stats->data_cnt++;
+               stats->data_bytes += len;
+       }
+}
+EXPORT_SYMBOL(il_update_stats);
+
+/* create and remove of files */
+#define DEBUGFS_ADD_FILE(name, parent, mode) do {                      \
+       if (!debugfs_create_file(#name, mode, parent, il,               \
+                        &il_dbgfs_##name##_ops))               \
+               goto err;                                               \
+} while (0)
+
+#define DEBUGFS_ADD_BOOL(name, parent, ptr) do {                       \
+       struct dentry *__tmp;                                           \
+       __tmp = debugfs_create_bool(#name, S_IWUSR | S_IRUSR,           \
+                                   parent, ptr);                       \
+       if (IS_ERR(__tmp) || !__tmp)                                    \
+               goto err;                                               \
+} while (0)
+
+#define DEBUGFS_ADD_X32(name, parent, ptr) do {                                \
+       struct dentry *__tmp;                                           \
+       __tmp = debugfs_create_x32(#name, S_IWUSR | S_IRUSR,            \
+                                  parent, ptr);                        \
+       if (IS_ERR(__tmp) || !__tmp)                                    \
+               goto err;                                               \
+} while (0)
+
+/* file operation */
+#define DEBUGFS_READ_FUNC(name)                                         \
+static ssize_t il_dbgfs_##name##_read(struct file *file,               \
+                                       char __user *user_buf,          \
+                                       size_t count, loff_t *ppos);
+
+#define DEBUGFS_WRITE_FUNC(name)                                        \
+static ssize_t il_dbgfs_##name##_write(struct file *file,              \
+                                       const char __user *user_buf,    \
+                                       size_t count, loff_t *ppos);
+
+
+#define DEBUGFS_READ_FILE_OPS(name)                            \
+       DEBUGFS_READ_FUNC(name);                                \
+static const struct file_operations il_dbgfs_##name##_ops = {  \
+       .read = il_dbgfs_##name##_read,                         \
+       .open = simple_open,                                    \
+       .llseek = generic_file_llseek,                          \
+};
+
+#define DEBUGFS_WRITE_FILE_OPS(name)                           \
+       DEBUGFS_WRITE_FUNC(name);                               \
+static const struct file_operations il_dbgfs_##name##_ops = {  \
+       .write = il_dbgfs_##name##_write,                       \
+       .open = simple_open,                                    \
+       .llseek = generic_file_llseek,                          \
+};
+
+#define DEBUGFS_READ_WRITE_FILE_OPS(name)                      \
+       DEBUGFS_READ_FUNC(name);                                \
+       DEBUGFS_WRITE_FUNC(name);                               \
+static const struct file_operations il_dbgfs_##name##_ops = {  \
+       .write = il_dbgfs_##name##_write,                       \
+       .read = il_dbgfs_##name##_read,                         \
+       .open = simple_open,                                    \
+       .llseek = generic_file_llseek,                          \
+};
+
+static const char *
+il_get_mgmt_string(int cmd)
+{
+       switch (cmd) {
+       IL_CMD(MANAGEMENT_ASSOC_REQ);
+       IL_CMD(MANAGEMENT_ASSOC_RESP);
+       IL_CMD(MANAGEMENT_REASSOC_REQ);
+       IL_CMD(MANAGEMENT_REASSOC_RESP);
+       IL_CMD(MANAGEMENT_PROBE_REQ);
+       IL_CMD(MANAGEMENT_PROBE_RESP);
+       IL_CMD(MANAGEMENT_BEACON);
+       IL_CMD(MANAGEMENT_ATIM);
+       IL_CMD(MANAGEMENT_DISASSOC);
+       IL_CMD(MANAGEMENT_AUTH);
+       IL_CMD(MANAGEMENT_DEAUTH);
+       IL_CMD(MANAGEMENT_ACTION);
+       default:
+               return "UNKNOWN";
+
+       }
+}
+
+static const char *
+il_get_ctrl_string(int cmd)
+{
+       switch (cmd) {
+       IL_CMD(CONTROL_BACK_REQ);
+       IL_CMD(CONTROL_BACK);
+       IL_CMD(CONTROL_PSPOLL);
+       IL_CMD(CONTROL_RTS);
+       IL_CMD(CONTROL_CTS);
+       IL_CMD(CONTROL_ACK);
+       IL_CMD(CONTROL_CFEND);
+       IL_CMD(CONTROL_CFENDACK);
+       default:
+               return "UNKNOWN";
+
+       }
+}
+
+static ssize_t
+il_dbgfs_tx_stats_read(struct file *file, char __user *user_buf, size_t count,
+                      loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       char *buf;
+       int pos = 0;
+
+       int cnt;
+       ssize_t ret;
+       const size_t bufsz =
+           100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX);
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+       pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
+       for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
+                             il_get_mgmt_string(cnt), il->tx_stats.mgmt[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "Control\n");
+       for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
+                             il_get_ctrl_string(cnt), il->tx_stats.ctrl[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
+                     il->tx_stats.data_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
+                     il->tx_stats.data_bytes);
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_clear_traffic_stats_write(struct file *file,
+                                  const char __user *user_buf, size_t count,
+                                  loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       u32 clear_flag;
+       char buf[8];
+       int buf_size;
+
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+       if (sscanf(buf, "%x", &clear_flag) != 1)
+               return -EFAULT;
+       il_clear_traffic_stats(il);
+
+       return count;
+}
+
+static ssize_t
+il_dbgfs_rx_stats_read(struct file *file, char __user *user_buf, size_t count,
+                      loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       char *buf;
+       int pos = 0;
+       int cnt;
+       ssize_t ret;
+       const size_t bufsz =
+           100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX);
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+
+       pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
+       for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
+                             il_get_mgmt_string(cnt), il->rx_stats.mgmt[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "Control:\n");
+       for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
+                             il_get_ctrl_string(cnt), il->rx_stats.ctrl[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
+                     il->rx_stats.data_cnt);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
+                     il->rx_stats.data_bytes);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+#define BYTE1_MASK 0x000000ff;
+#define BYTE2_MASK 0x0000ffff;
+#define BYTE3_MASK 0x00ffffff;
+static ssize_t
+il_dbgfs_sram_read(struct file *file, char __user *user_buf, size_t count,
+                  loff_t *ppos)
+{
+       u32 val;
+       char *buf;
+       ssize_t ret;
+       int i;
+       int pos = 0;
+       struct il_priv *il = file->private_data;
+       size_t bufsz;
+
+       /* default is to dump the entire data segment */
+       if (!il->dbgfs_sram_offset && !il->dbgfs_sram_len) {
+               il->dbgfs_sram_offset = 0x800000;
+               if (il->ucode_type == UCODE_INIT)
+                       il->dbgfs_sram_len = il->ucode_init_data.len;
+               else
+                       il->dbgfs_sram_len = il->ucode_data.len;
+       }
+       bufsz = 30 + il->dbgfs_sram_len * sizeof(char) * 10;
+       buf = kmalloc(bufsz, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "sram_len: 0x%x\n",
+                     il->dbgfs_sram_len);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "sram_offset: 0x%x\n",
+                     il->dbgfs_sram_offset);
+       for (i = il->dbgfs_sram_len; i > 0; i -= 4) {
+               val =
+                   il_read_targ_mem(il,
+                                    il->dbgfs_sram_offset +
+                                    il->dbgfs_sram_len - i);
+               if (i < 4) {
+                       switch (i) {
+                       case 1:
+                               val &= BYTE1_MASK;
+                               break;
+                       case 2:
+                               val &= BYTE2_MASK;
+                               break;
+                       case 3:
+                               val &= BYTE3_MASK;
+                               break;
+                       }
+               }
+               if (!(i % 16))
+                       pos += scnprintf(buf + pos, bufsz - pos, "\n");
+               pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "\n");
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_sram_write(struct file *file, const char __user *user_buf,
+                   size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char buf[64];
+       int buf_size;
+       u32 offset, len;
+
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+
+       if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
+               il->dbgfs_sram_offset = offset;
+               il->dbgfs_sram_len = len;
+       } else {
+               il->dbgfs_sram_offset = 0;
+               il->dbgfs_sram_len = 0;
+       }
+
+       return count;
+}
+
+static ssize_t
+il_dbgfs_stations_read(struct file *file, char __user *user_buf, size_t count,
+                      loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       struct il_station_entry *station;
+       int max_sta = il->hw_params.max_stations;
+       char *buf;
+       int i, j, pos = 0;
+       ssize_t ret;
+       /* Add 30 for initial string */
+       const size_t bufsz = 30 + sizeof(char) * 500 * (il->num_stations);
+
+       buf = kmalloc(bufsz, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
+                     il->num_stations);
+
+       for (i = 0; i < max_sta; i++) {
+               station = &il->stations[i];
+               if (!station->used)
+                       continue;
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "station %d - addr: %pM, flags: %#x\n", i,
+                             station->sta.sta.addr,
+                             station->sta.station_flags_msk);
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "TID\tseq_num\ttxq_id\tframes\ttfds\t");
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "start_idx\tbitmap\t\t\trate_n_flags\n");
+
+               for (j = 0; j < MAX_TID_COUNT; j++) {
+                       pos +=
+                           scnprintf(buf + pos, bufsz - pos,
+                                     "%d:\t%#x\t%#x\t%u\t%u\t%u\t\t%#.16llx\t%#x",
+                                     j, station->tid[j].seq_number,
+                                     station->tid[j].agg.txq_id,
+                                     station->tid[j].agg.frame_count,
+                                     station->tid[j].tfds_in_queue,
+                                     station->tid[j].agg.start_idx,
+                                     station->tid[j].agg.bitmap,
+                                     station->tid[j].agg.rate_n_flags);
+
+                       if (station->tid[j].agg.wait_for_ba)
+                               pos +=
+                                   scnprintf(buf + pos, bufsz - pos,
+                                             " - waitforba");
+                       pos += scnprintf(buf + pos, bufsz - pos, "\n");
+               }
+
+               pos += scnprintf(buf + pos, bufsz - pos, "\n");
+       }
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_nvm_read(struct file *file, char __user *user_buf, size_t count,
+                 loff_t *ppos)
+{
+       ssize_t ret;
+       struct il_priv *il = file->private_data;
+       int pos = 0, ofs = 0, buf_size = 0;
+       const u8 *ptr;
+       char *buf;
+       u16 eeprom_ver;
+       size_t eeprom_len = il->cfg->eeprom_size;
+       buf_size = 4 * eeprom_len + 256;
+
+       if (eeprom_len % 16) {
+               IL_ERR("NVM size is not multiple of 16.\n");
+               return -ENODATA;
+       }
+
+       ptr = il->eeprom;
+       if (!ptr) {
+               IL_ERR("Invalid EEPROM memory\n");
+               return -ENOMEM;
+       }
+
+       /* 4 characters for byte 0xYY */
+       buf = kzalloc(buf_size, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+       eeprom_ver = il_eeprom_query16(il, EEPROM_VERSION);
+       pos +=
+           scnprintf(buf + pos, buf_size - pos, "EEPROM " "version: 0x%x\n",
+                     eeprom_ver);
+       for (ofs = 0; ofs < eeprom_len; ofs += 16) {
+               pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x %16ph\n",
+                                ofs, ptr + ofs);
+       }
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_channels_read(struct file *file, char __user *user_buf, size_t count,
+                      loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       struct ieee80211_channel *channels = NULL;
+       const struct ieee80211_supported_band *supp_band = NULL;
+       int pos = 0, i, bufsz = PAGE_SIZE;
+       char *buf;
+       ssize_t ret;
+
+       if (!test_bit(S_GEO_CONFIGURED, &il->status))
+               return -EAGAIN;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       supp_band = il_get_hw_mode(il, IEEE80211_BAND_2GHZ);
+       if (supp_band) {
+               channels = supp_band->channels;
+
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "Displaying %d channels in 2.4GHz band 802.11bg):\n",
+                             supp_band->n_channels);
+
+               for (i = 0; i < supp_band->n_channels; i++)
+                       pos +=
+                           scnprintf(buf + pos, bufsz - pos,
+                                     "%d: %ddBm: BSS%s%s, %s.\n",
+                                     channels[i].hw_value,
+                                     channels[i].max_power,
+                                     channels[i].
+                                     flags & IEEE80211_CHAN_RADAR ?
+                                     " (IEEE 802.11h required)" : "",
+                                     ((channels[i].
+                                       flags & IEEE80211_CHAN_NO_IR) ||
+                                      (channels[i].
+                                       flags & IEEE80211_CHAN_RADAR)) ? "" :
+                                     ", IBSS",
+                                     channels[i].
+                                     flags & IEEE80211_CHAN_NO_IR ?
+                                     "passive only" : "active/passive");
+       }
+       supp_band = il_get_hw_mode(il, IEEE80211_BAND_5GHZ);
+       if (supp_band) {
+               channels = supp_band->channels;
+
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "Displaying %d channels in 5.2GHz band (802.11a)\n",
+                             supp_band->n_channels);
+
+               for (i = 0; i < supp_band->n_channels; i++)
+                       pos +=
+                           scnprintf(buf + pos, bufsz - pos,
+                                     "%d: %ddBm: BSS%s%s, %s.\n",
+                                     channels[i].hw_value,
+                                     channels[i].max_power,
+                                     channels[i].
+                                     flags & IEEE80211_CHAN_RADAR ?
+                                     " (IEEE 802.11h required)" : "",
+                                     ((channels[i].
+                                       flags & IEEE80211_CHAN_NO_IR) ||
+                                      (channels[i].
+                                       flags & IEEE80211_CHAN_RADAR)) ? "" :
+                                     ", IBSS",
+                                     channels[i].
+                                     flags & IEEE80211_CHAN_NO_IR ?
+                                     "passive only" : "active/passive");
+       }
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_status_read(struct file *file, char __user *user_buf, size_t count,
+                    loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       char buf[512];
+       int pos = 0;
+       const size_t bufsz = sizeof(buf);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_HCMD_ACTIVE:\t %d\n",
+                     test_bit(S_HCMD_ACTIVE, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_INT_ENABLED:\t %d\n",
+                     test_bit(S_INT_ENABLED, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_RFKILL:\t %d\n",
+                     test_bit(S_RFKILL, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_CT_KILL:\t\t %d\n",
+                     test_bit(S_CT_KILL, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_INIT:\t\t %d\n",
+                     test_bit(S_INIT, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_ALIVE:\t\t %d\n",
+                     test_bit(S_ALIVE, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_READY:\t\t %d\n",
+                     test_bit(S_READY, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_TEMPERATURE:\t %d\n",
+                     test_bit(S_TEMPERATURE, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_GEO_CONFIGURED:\t %d\n",
+                     test_bit(S_GEO_CONFIGURED, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_EXIT_PENDING:\t %d\n",
+                     test_bit(S_EXIT_PENDING, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_STATS:\t %d\n",
+                     test_bit(S_STATS, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_SCANNING:\t %d\n",
+                     test_bit(S_SCANNING, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_SCAN_ABORTING:\t %d\n",
+                     test_bit(S_SCAN_ABORTING, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_SCAN_HW:\t\t %d\n",
+                     test_bit(S_SCAN_HW, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_POWER_PMI:\t %d\n",
+                     test_bit(S_POWER_PMI, &il->status));
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "S_FW_ERROR:\t %d\n",
+                     test_bit(S_FW_ERROR, &il->status));
+       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+}
+
+static ssize_t
+il_dbgfs_interrupt_read(struct file *file, char __user *user_buf, size_t count,
+                       loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       int cnt = 0;
+       char *buf;
+       int bufsz = 24 * 64;    /* 24 items * 64 char per item */
+       ssize_t ret;
+
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "Interrupt Statistics Report:\n");
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "HW Error:\t\t\t %u\n",
+                     il->isr_stats.hw);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "SW Error:\t\t\t %u\n",
+                     il->isr_stats.sw);
+       if (il->isr_stats.sw || il->isr_stats.hw) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "\tLast Restarting Code:  0x%X\n",
+                             il->isr_stats.err_code);
+       }
+#ifdef CONFIG_IWLEGACY_DEBUG
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "Frame transmitted:\t\t %u\n",
+                     il->isr_stats.sch);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "Alive interrupt:\t\t %u\n",
+                     il->isr_stats.alive);
+#endif
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "HW RF KILL switch toggled:\t %u\n",
+                     il->isr_stats.rfkill);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "CT KILL:\t\t\t %u\n",
+                     il->isr_stats.ctkill);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "Wakeup Interrupt:\t\t %u\n",
+                     il->isr_stats.wakeup);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "Rx command responses:\t\t %u\n",
+                     il->isr_stats.rx);
+       for (cnt = 0; cnt < IL_CN_MAX; cnt++) {
+               if (il->isr_stats.handlers[cnt] > 0)
+                       pos +=
+                           scnprintf(buf + pos, bufsz - pos,
+                                     "\tRx handler[%36s]:\t\t %u\n",
+                                     il_get_cmd_string(cnt),
+                                     il->isr_stats.handlers[cnt]);
+       }
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "Tx/FH interrupt:\t\t %u\n",
+                     il->isr_stats.tx);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "Unexpected INTA:\t\t %u\n",
+                     il->isr_stats.unhandled);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_interrupt_write(struct file *file, const char __user *user_buf,
+                        size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char buf[8];
+       int buf_size;
+       u32 reset_flag;
+
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+       if (sscanf(buf, "%x", &reset_flag) != 1)
+               return -EFAULT;
+       if (reset_flag == 0)
+               il_clear_isr_stats(il);
+
+       return count;
+}
+
+static ssize_t
+il_dbgfs_qos_read(struct file *file, char __user *user_buf, size_t count,
+                 loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       int pos = 0, i;
+       char buf[256];
+       const size_t bufsz = sizeof(buf);
+
+       for (i = 0; i < AC_NUM; i++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "\tcw_min\tcw_max\taifsn\ttxop\n");
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "AC[%d]\t%u\t%u\t%u\t%u\n", i,
+                             il->qos_data.def_qos_parm.ac[i].cw_min,
+                             il->qos_data.def_qos_parm.ac[i].cw_max,
+                             il->qos_data.def_qos_parm.ac[i].aifsn,
+                             il->qos_data.def_qos_parm.ac[i].edca_txop);
+       }
+
+       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+}
+
+static ssize_t
+il_dbgfs_disable_ht40_write(struct file *file, const char __user *user_buf,
+                           size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char buf[8];
+       int buf_size;
+       int ht40;
+
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+       if (sscanf(buf, "%d", &ht40) != 1)
+               return -EFAULT;
+       if (!il_is_any_associated(il))
+               il->disable_ht40 = ht40 ? true : false;
+       else {
+               IL_ERR("Sta associated with AP - "
+                      "Change to 40MHz channel support is not allowed\n");
+               return -EINVAL;
+       }
+
+       return count;
+}
+
+static ssize_t
+il_dbgfs_disable_ht40_read(struct file *file, char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char buf[100];
+       int pos = 0;
+       const size_t bufsz = sizeof(buf);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "11n 40MHz Mode: %s\n",
+                     il->disable_ht40 ? "Disabled" : "Enabled");
+       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+}
+
+DEBUGFS_READ_WRITE_FILE_OPS(sram);
+DEBUGFS_READ_FILE_OPS(nvm);
+DEBUGFS_READ_FILE_OPS(stations);
+DEBUGFS_READ_FILE_OPS(channels);
+DEBUGFS_READ_FILE_OPS(status);
+DEBUGFS_READ_WRITE_FILE_OPS(interrupt);
+DEBUGFS_READ_FILE_OPS(qos);
+DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40);
+
+static ssize_t
+il_dbgfs_tx_queue_read(struct file *file, char __user *user_buf, size_t count,
+                      loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       struct il_tx_queue *txq;
+       struct il_queue *q;
+       char *buf;
+       int pos = 0;
+       int cnt;
+       int ret;
+       const size_t bufsz =
+           sizeof(char) * 64 * il->cfg->num_of_queues;
+
+       if (!il->txq) {
+               IL_ERR("txq not ready\n");
+               return -EAGAIN;
+       }
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf)
+               return -ENOMEM;
+
+       for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
+               txq = &il->txq[cnt];
+               q = &txq->q;
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "hwq %.2d: read=%u write=%u stop=%d"
+                             " swq_id=%#.2x (ac %d/hwq %d)\n", cnt,
+                             q->read_ptr, q->write_ptr,
+                             !!test_bit(cnt, il->queue_stopped),
+                             txq->swq_id, txq->swq_id & 3,
+                             (txq->swq_id >> 2) & 0x1f);
+               if (cnt >= 4)
+                       continue;
+               /* for the ACs, display the stop count too */
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "        stop-count: %d\n",
+                             atomic_read(&il->queue_stop_count[cnt]));
+       }
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_rx_queue_read(struct file *file, char __user *user_buf, size_t count,
+                      loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       struct il_rx_queue *rxq = &il->rxq;
+       char buf[256];
+       int pos = 0;
+       const size_t bufsz = sizeof(buf);
+
+       pos += scnprintf(buf + pos, bufsz - pos, "read: %u\n", rxq->read);
+       pos += scnprintf(buf + pos, bufsz - pos, "write: %u\n", rxq->write);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "free_count: %u\n",
+                     rxq->free_count);
+       if (rxq->rb_stts) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, "closed_rb_num: %u\n",
+                             le16_to_cpu(rxq->rb_stts->
+                                         closed_rb_num) & 0x0FFF);
+       } else {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos,
+                             "closed_rb_num: Not Allocated\n");
+       }
+       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+}
+
+static ssize_t
+il_dbgfs_ucode_rx_stats_read(struct file *file, char __user *user_buf,
+                            size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+
+       return il->debugfs_ops->rx_stats_read(file, user_buf, count, ppos);
+}
+
+static ssize_t
+il_dbgfs_ucode_tx_stats_read(struct file *file, char __user *user_buf,
+                            size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+
+       return il->debugfs_ops->tx_stats_read(file, user_buf, count, ppos);
+}
+
+static ssize_t
+il_dbgfs_ucode_general_stats_read(struct file *file, char __user *user_buf,
+                                 size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+
+       return il->debugfs_ops->general_stats_read(file, user_buf, count, ppos);
+}
+
+static ssize_t
+il_dbgfs_sensitivity_read(struct file *file, char __user *user_buf,
+                         size_t count, loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       int cnt = 0;
+       char *buf;
+       int bufsz = sizeof(struct il_sensitivity_data) * 4 + 100;
+       ssize_t ret;
+       struct il_sensitivity_data *data;
+
+       data = &il->sensitivity_data;
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm:\t\t\t %u\n",
+                     data->auto_corr_ofdm);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc:\t\t %u\n",
+                     data->auto_corr_ofdm_mrc);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_x1:\t\t %u\n",
+                     data->auto_corr_ofdm_x1);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc_x1:\t\t %u\n",
+                     data->auto_corr_ofdm_mrc_x1);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "auto_corr_cck:\t\t\t %u\n",
+                     data->auto_corr_cck);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "auto_corr_cck_mrc:\t\t %u\n",
+                     data->auto_corr_cck_mrc);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "last_bad_plcp_cnt_ofdm:\t\t %u\n",
+                     data->last_bad_plcp_cnt_ofdm);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_ofdm:\t\t %u\n",
+                     data->last_fa_cnt_ofdm);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "last_bad_plcp_cnt_cck:\t\t %u\n",
+                     data->last_bad_plcp_cnt_cck);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_cck:\t\t %u\n",
+                     data->last_fa_cnt_cck);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "nrg_curr_state:\t\t\t %u\n",
+                     data->nrg_curr_state);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "nrg_prev_state:\t\t\t %u\n",
+                     data->nrg_prev_state);
+       pos += scnprintf(buf + pos, bufsz - pos, "nrg_value:\t\t\t");
+       for (cnt = 0; cnt < 10; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, " %u",
+                             data->nrg_value[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "\n");
+       pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_rssi:\t\t");
+       for (cnt = 0; cnt < NRG_NUM_PREV_STAT_L; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, " %u",
+                             data->nrg_silence_rssi[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "\n");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "nrg_silence_ref:\t\t %u\n",
+                     data->nrg_silence_ref);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "nrg_energy_idx:\t\t\t %u\n",
+                     data->nrg_energy_idx);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "nrg_silence_idx:\t\t %u\n",
+                     data->nrg_silence_idx);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "nrg_th_cck:\t\t\t %u\n",
+                     data->nrg_th_cck);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "nrg_auto_corr_silence_diff:\t %u\n",
+                     data->nrg_auto_corr_silence_diff);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "num_in_cck_no_fa:\t\t %u\n",
+                     data->num_in_cck_no_fa);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "nrg_th_ofdm:\t\t\t %u\n",
+                     data->nrg_th_ofdm);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_chain_noise_read(struct file *file, char __user *user_buf,
+                         size_t count, loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       int cnt = 0;
+       char *buf;
+       int bufsz = sizeof(struct il_chain_noise_data) * 4 + 100;
+       ssize_t ret;
+       struct il_chain_noise_data *data;
+
+       data = &il->chain_noise_data;
+       buf = kzalloc(bufsz, GFP_KERNEL);
+       if (!buf) {
+               IL_ERR("Can not allocate Buffer\n");
+               return -ENOMEM;
+       }
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "active_chains:\t\t\t %u\n",
+                     data->active_chains);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "chain_noise_a:\t\t\t %u\n",
+                     data->chain_noise_a);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "chain_noise_b:\t\t\t %u\n",
+                     data->chain_noise_b);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "chain_noise_c:\t\t\t %u\n",
+                     data->chain_noise_c);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "chain_signal_a:\t\t\t %u\n",
+                     data->chain_signal_a);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "chain_signal_b:\t\t\t %u\n",
+                     data->chain_signal_b);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "chain_signal_c:\t\t\t %u\n",
+                     data->chain_signal_c);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "beacon_count:\t\t\t %u\n",
+                     data->beacon_count);
+
+       pos += scnprintf(buf + pos, bufsz - pos, "disconn_array:\t\t\t");
+       for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, " %u",
+                             data->disconn_array[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "\n");
+       pos += scnprintf(buf + pos, bufsz - pos, "delta_gain_code:\t\t");
+       for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
+               pos +=
+                   scnprintf(buf + pos, bufsz - pos, " %u",
+                             data->delta_gain_code[cnt]);
+       }
+       pos += scnprintf(buf + pos, bufsz - pos, "\n");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "radio_write:\t\t\t %u\n",
+                     data->radio_write);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "state:\t\t\t\t %u\n",
+                     data->state);
+
+       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+       kfree(buf);
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_power_save_status_read(struct file *file, char __user *user_buf,
+                               size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char buf[60];
+       int pos = 0;
+       const size_t bufsz = sizeof(buf);
+       u32 pwrsave_status;
+
+       pwrsave_status =
+           _il_rd(il, CSR_GP_CNTRL) & CSR_GP_REG_POWER_SAVE_STATUS_MSK;
+
+       pos += scnprintf(buf + pos, bufsz - pos, "Power Save Status: ");
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "%s\n",
+                     (pwrsave_status == CSR_GP_REG_NO_POWER_SAVE) ? "none" :
+                     (pwrsave_status == CSR_GP_REG_MAC_POWER_SAVE) ? "MAC" :
+                     (pwrsave_status == CSR_GP_REG_PHY_POWER_SAVE) ? "PHY" :
+                     "error");
+
+       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+}
+
+static ssize_t
+il_dbgfs_clear_ucode_stats_write(struct file *file,
+                                const char __user *user_buf, size_t count,
+                                loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char buf[8];
+       int buf_size;
+       int clear;
+
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+       if (sscanf(buf, "%d", &clear) != 1)
+               return -EFAULT;
+
+       /* make request to uCode to retrieve stats information */
+       mutex_lock(&il->mutex);
+       il_send_stats_request(il, CMD_SYNC, true);
+       mutex_unlock(&il->mutex);
+
+       return count;
+}
+
+static ssize_t
+il_dbgfs_rxon_flags_read(struct file *file, char __user *user_buf,
+                        size_t count, loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       int len = 0;
+       char buf[20];
+
+       len = sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.flags));
+       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t
+il_dbgfs_rxon_filter_flags_read(struct file *file, char __user *user_buf,
+                               size_t count, loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       int len = 0;
+       char buf[20];
+
+       len =
+           sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.filter_flags));
+       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t
+il_dbgfs_fh_reg_read(struct file *file, char __user *user_buf, size_t count,
+                    loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char *buf;
+       int pos = 0;
+       ssize_t ret = -EFAULT;
+
+       if (il->ops->dump_fh) {
+               ret = pos = il->ops->dump_fh(il, &buf, true);
+               if (buf) {
+                       ret =
+                           simple_read_from_buffer(user_buf, count, ppos, buf,
+                                                   pos);
+                       kfree(buf);
+               }
+       }
+
+       return ret;
+}
+
+static ssize_t
+il_dbgfs_missed_beacon_read(struct file *file, char __user *user_buf,
+                           size_t count, loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char buf[12];
+       const size_t bufsz = sizeof(buf);
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "%d\n",
+                     il->missed_beacon_threshold);
+
+       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+}
+
+static ssize_t
+il_dbgfs_missed_beacon_write(struct file *file, const char __user *user_buf,
+                            size_t count, loff_t *ppos)
+{
+       struct il_priv *il = file->private_data;
+       char buf[8];
+       int buf_size;
+       int missed;
+
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+       if (sscanf(buf, "%d", &missed) != 1)
+               return -EINVAL;
+
+       if (missed < IL_MISSED_BEACON_THRESHOLD_MIN ||
+           missed > IL_MISSED_BEACON_THRESHOLD_MAX)
+               il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
+       else
+               il->missed_beacon_threshold = missed;
+
+       return count;
+}
+
+static ssize_t
+il_dbgfs_force_reset_read(struct file *file, char __user *user_buf,
+                         size_t count, loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       int pos = 0;
+       char buf[300];
+       const size_t bufsz = sizeof(buf);
+       struct il_force_reset *force_reset;
+
+       force_reset = &il->force_reset;
+
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "\tnumber of reset request: %d\n",
+                     force_reset->reset_request_count);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "\tnumber of reset request success: %d\n",
+                     force_reset->reset_success_count);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos,
+                     "\tnumber of reset request reject: %d\n",
+                     force_reset->reset_reject_count);
+       pos +=
+           scnprintf(buf + pos, bufsz - pos, "\treset duration: %lu\n",
+                     force_reset->reset_duration);
+
+       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
+}
+
+static ssize_t
+il_dbgfs_force_reset_write(struct file *file, const char __user *user_buf,
+                          size_t count, loff_t *ppos)
+{
+
+       int ret;
+       struct il_priv *il = file->private_data;
+
+       ret = il_force_reset(il, true);
+
+       return ret ? ret : count;
+}
+
+static ssize_t
+il_dbgfs_wd_timeout_write(struct file *file, const char __user *user_buf,
+                         size_t count, loff_t *ppos)
+{
+
+       struct il_priv *il = file->private_data;
+       char buf[8];
+       int buf_size;
+       int timeout;
+
+       memset(buf, 0, sizeof(buf));
+       buf_size = min(count, sizeof(buf) - 1);
+       if (copy_from_user(buf, user_buf, buf_size))
+               return -EFAULT;
+       if (sscanf(buf, "%d", &timeout) != 1)
+               return -EINVAL;
+       if (timeout < 0 || timeout > IL_MAX_WD_TIMEOUT)
+               timeout = IL_DEF_WD_TIMEOUT;
+
+       il->cfg->wd_timeout = timeout;
+       il_setup_watchdog(il);
+       return count;
+}
+
+DEBUGFS_READ_FILE_OPS(rx_stats);
+DEBUGFS_READ_FILE_OPS(tx_stats);
+DEBUGFS_READ_FILE_OPS(rx_queue);
+DEBUGFS_READ_FILE_OPS(tx_queue);
+DEBUGFS_READ_FILE_OPS(ucode_rx_stats);
+DEBUGFS_READ_FILE_OPS(ucode_tx_stats);
+DEBUGFS_READ_FILE_OPS(ucode_general_stats);
+DEBUGFS_READ_FILE_OPS(sensitivity);
+DEBUGFS_READ_FILE_OPS(chain_noise);
+DEBUGFS_READ_FILE_OPS(power_save_status);
+DEBUGFS_WRITE_FILE_OPS(clear_ucode_stats);
+DEBUGFS_WRITE_FILE_OPS(clear_traffic_stats);
+DEBUGFS_READ_FILE_OPS(fh_reg);
+DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon);
+DEBUGFS_READ_WRITE_FILE_OPS(force_reset);
+DEBUGFS_READ_FILE_OPS(rxon_flags);
+DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
+DEBUGFS_WRITE_FILE_OPS(wd_timeout);
+
+/*
+ * Create the debugfs files and directories
+ *
+ */
+int
+il_dbgfs_register(struct il_priv *il, const char *name)
+{
+       struct dentry *phyd = il->hw->wiphy->debugfsdir;
+       struct dentry *dir_drv, *dir_data, *dir_rf, *dir_debug;
+
+       dir_drv = debugfs_create_dir(name, phyd);
+       if (!dir_drv)
+               return -ENOMEM;
+
+       il->debugfs_dir = dir_drv;
+
+       dir_data = debugfs_create_dir("data", dir_drv);
+       if (!dir_data)
+               goto err;
+       dir_rf = debugfs_create_dir("rf", dir_drv);
+       if (!dir_rf)
+               goto err;
+       dir_debug = debugfs_create_dir("debug", dir_drv);
+       if (!dir_debug)
+               goto err;
+
+       DEBUGFS_ADD_FILE(nvm, dir_data, S_IRUSR);
+       DEBUGFS_ADD_FILE(sram, dir_data, S_IWUSR | S_IRUSR);
+       DEBUGFS_ADD_FILE(stations, dir_data, S_IRUSR);
+       DEBUGFS_ADD_FILE(channels, dir_data, S_IRUSR);
+       DEBUGFS_ADD_FILE(status, dir_data, S_IRUSR);
+       DEBUGFS_ADD_FILE(interrupt, dir_data, S_IWUSR | S_IRUSR);
+       DEBUGFS_ADD_FILE(qos, dir_data, S_IRUSR);
+       DEBUGFS_ADD_FILE(disable_ht40, dir_data, S_IWUSR | S_IRUSR);
+       DEBUGFS_ADD_FILE(rx_stats, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(tx_stats, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(rx_queue, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(tx_queue, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(power_save_status, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(clear_ucode_stats, dir_debug, S_IWUSR);
+       DEBUGFS_ADD_FILE(clear_traffic_stats, dir_debug, S_IWUSR);
+       DEBUGFS_ADD_FILE(fh_reg, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(missed_beacon, dir_debug, S_IWUSR);
+       DEBUGFS_ADD_FILE(force_reset, dir_debug, S_IWUSR | S_IRUSR);
+       DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(ucode_general_stats, dir_debug, S_IRUSR);
+
+       if (il->cfg->sensitivity_calib_by_driver)
+               DEBUGFS_ADD_FILE(sensitivity, dir_debug, S_IRUSR);
+       if (il->cfg->chain_noise_calib_by_driver)
+               DEBUGFS_ADD_FILE(chain_noise, dir_debug, S_IRUSR);
+       DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR);
+       DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR);
+       DEBUGFS_ADD_FILE(wd_timeout, dir_debug, S_IWUSR);
+       if (il->cfg->sensitivity_calib_by_driver)
+               DEBUGFS_ADD_BOOL(disable_sensitivity, dir_rf,
+                                &il->disable_sens_cal);
+       if (il->cfg->chain_noise_calib_by_driver)
+               DEBUGFS_ADD_BOOL(disable_chain_noise, dir_rf,
+                                &il->disable_chain_noise_cal);
+       DEBUGFS_ADD_BOOL(disable_tx_power, dir_rf, &il->disable_tx_power_cal);
+       return 0;
+
+err:
+       IL_ERR("Can't create the debugfs directory\n");
+       il_dbgfs_unregister(il);
+       return -ENOMEM;
+}
+EXPORT_SYMBOL(il_dbgfs_register);
+
+/**
+ * Remove the debugfs files and directories
+ *
+ */
+void
+il_dbgfs_unregister(struct il_priv *il)
+{
+       if (!il->debugfs_dir)
+               return;
+
+       debugfs_remove_recursive(il->debugfs_dir);
+       il->debugfs_dir = NULL;
+}
+EXPORT_SYMBOL(il_dbgfs_unregister);
diff --git a/drivers/net/wireless/intel/iwlegacy/iwl-spectrum.h b/drivers/net/wireless/intel/iwlegacy/iwl-spectrum.h
new file mode 100644 (file)
index 0000000..85fe48e
--- /dev/null
@@ -0,0 +1,92 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
+ *
+ * Portions of this file are derived from the ieee80211 subsystem header files.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
+#ifndef __il_spectrum_h__
+#define __il_spectrum_h__
+enum {                         /* ieee80211_basic_report.map */
+       IEEE80211_BASIC_MAP_BSS = (1 << 0),
+       IEEE80211_BASIC_MAP_OFDM = (1 << 1),
+       IEEE80211_BASIC_MAP_UNIDENTIFIED = (1 << 2),
+       IEEE80211_BASIC_MAP_RADAR = (1 << 3),
+       IEEE80211_BASIC_MAP_UNMEASURED = (1 << 4),
+       /* Bits 5-7 are reserved */
+
+};
+struct ieee80211_basic_report {
+       u8 channel;
+       __le64 start_time;
+       __le16 duration;
+       u8 map;
+} __packed;
+
+enum {                         /* ieee80211_measurement_request.mode */
+       /* Bit 0 is reserved */
+       IEEE80211_MEASUREMENT_ENABLE = (1 << 1),
+       IEEE80211_MEASUREMENT_REQUEST = (1 << 2),
+       IEEE80211_MEASUREMENT_REPORT = (1 << 3),
+       /* Bits 4-7 are reserved */
+};
+
+enum {
+       IEEE80211_REPORT_BASIC = 0,     /* required */
+       IEEE80211_REPORT_CCA = 1,       /* optional */
+       IEEE80211_REPORT_RPI = 2,       /* optional */
+       /* 3-255 reserved */
+};
+
+struct ieee80211_measurement_params {
+       u8 channel;
+       __le64 start_time;
+       __le16 duration;
+} __packed;
+
+struct ieee80211_info_element {
+       u8 id;
+       u8 len;
+       u8 data[0];
+} __packed;
+
+struct ieee80211_measurement_request {
+       struct ieee80211_info_element ie;
+       u8 token;
+       u8 mode;
+       u8 type;
+       struct ieee80211_measurement_params params[0];
+} __packed;
+
+struct ieee80211_measurement_report {
+       struct ieee80211_info_element ie;
+       u8 token;
+       u8 mode;
+       u8 type;
+       union {
+               struct ieee80211_basic_report basic[0];
+       } u;
+} __packed;
+
+#endif
diff --git a/drivers/net/wireless/intel/iwlegacy/prph.h b/drivers/net/wireless/intel/iwlegacy/prph.h
new file mode 100644 (file)
index 0000000..ffec4b4
--- /dev/null
@@ -0,0 +1,522 @@
+/******************************************************************************
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
+ * USA
+ *
+ * The full GNU General Public License is included in this distribution
+ * in the file called LICENSE.GPL.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *  * Neither the name Intel Corporation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+
+#ifndef        __il_prph_h__
+#define __il_prph_h__
+
+/*
+ * Registers in this file are internal, not PCI bus memory mapped.
+ * Driver accesses these via HBUS_TARG_PRPH_* registers.
+ */
+#define PRPH_BASE      (0x00000)
+#define PRPH_END       (0xFFFFF)
+
+/* APMG (power management) constants */
+#define APMG_BASE                      (PRPH_BASE + 0x3000)
+#define APMG_CLK_CTRL_REG              (APMG_BASE + 0x0000)
+#define APMG_CLK_EN_REG                        (APMG_BASE + 0x0004)
+#define APMG_CLK_DIS_REG               (APMG_BASE + 0x0008)
+#define APMG_PS_CTRL_REG               (APMG_BASE + 0x000c)
+#define APMG_PCIDEV_STT_REG            (APMG_BASE + 0x0010)
+#define APMG_RFKILL_REG                        (APMG_BASE + 0x0014)
+#define APMG_RTC_INT_STT_REG           (APMG_BASE + 0x001c)
+#define APMG_RTC_INT_MSK_REG           (APMG_BASE + 0x0020)
+#define APMG_DIGITAL_SVR_REG           (APMG_BASE + 0x0058)
+#define APMG_ANALOG_SVR_REG            (APMG_BASE + 0x006C)
+
+#define APMS_CLK_VAL_MRB_FUNC_MODE     (0x00000001)
+#define APMG_CLK_VAL_DMA_CLK_RQT       (0x00000200)
+#define APMG_CLK_VAL_BSM_CLK_RQT       (0x00000800)
+
+#define APMG_PS_CTRL_EARLY_PWR_OFF_RESET_DIS   (0x00400000)
+#define APMG_PS_CTRL_VAL_RESET_REQ             (0x04000000)
+#define APMG_PS_CTRL_MSK_PWR_SRC               (0x03000000)
+#define APMG_PS_CTRL_VAL_PWR_SRC_VMAIN         (0x00000000)
+#define APMG_PS_CTRL_VAL_PWR_SRC_MAX           (0x01000000)    /* 3945 only */
+#define APMG_PS_CTRL_VAL_PWR_SRC_VAUX          (0x02000000)
+#define APMG_SVR_VOLTAGE_CONFIG_BIT_MSK        (0x000001E0)    /* bit 8:5 */
+#define APMG_SVR_DIGITAL_VOLTAGE_1_32          (0x00000060)
+
+#define APMG_PCIDEV_STT_VAL_L1_ACT_DIS         (0x00000800)
+
+/**
+ * BSM (Bootstrap State Machine)
+ *
+ * The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
+ * in special SRAM that does not power down when the embedded control
+ * processor is sleeping (e.g. for periodic power-saving shutdowns of radio).
+ *
+ * When powering back up after sleeps (or during initial uCode load), the BSM
+ * internally loads the short bootstrap program from the special SRAM into the
+ * embedded processor's instruction SRAM, and starts the processor so it runs
+ * the bootstrap program.
+ *
+ * This bootstrap program loads (via PCI busmaster DMA) instructions and data
+ * images for a uCode program from host DRAM locations.  The host driver
+ * indicates DRAM locations and sizes for instruction and data images via the
+ * four BSM_DRAM_* registers.  Once the bootstrap program loads the new program,
+ * the new program starts automatically.
+ *
+ * The uCode used for open-source drivers includes two programs:
+ *
+ * 1)  Initialization -- performs hardware calibration and sets up some
+ *     internal data, then notifies host via "initialize alive" notification
+ *     (struct il_init_alive_resp) that it has completed all of its work.
+ *     After signal from host, it then loads and starts the runtime program.
+ *     The initialization program must be used when initially setting up the
+ *     NIC after loading the driver.
+ *
+ * 2)  Runtime/Protocol -- performs all normal runtime operations.  This
+ *     notifies host via "alive" notification (struct il_alive_resp) that it
+ *     is ready to be used.
+ *
+ * When initializing the NIC, the host driver does the following procedure:
+ *
+ * 1)  Load bootstrap program (instructions only, no data image for bootstrap)
+ *     into bootstrap memory.  Use dword writes starting at BSM_SRAM_LOWER_BOUND
+ *
+ * 2)  Point (via BSM_DRAM_*) to the "initialize" uCode data and instruction
+ *     images in host DRAM.
+ *
+ * 3)  Set up BSM to copy from BSM SRAM into uCode instruction SRAM when asked:
+ *     BSM_WR_MEM_SRC_REG = 0
+ *     BSM_WR_MEM_DST_REG = RTC_INST_LOWER_BOUND
+ *     BSM_WR_MEM_DWCOUNT_REG = # dwords in bootstrap instruction image
+ *
+ * 4)  Load bootstrap into instruction SRAM:
+ *     BSM_WR_CTRL_REG = BSM_WR_CTRL_REG_BIT_START
+ *
+ * 5)  Wait for load completion:
+ *     Poll BSM_WR_CTRL_REG for BSM_WR_CTRL_REG_BIT_START = 0
+ *
+ * 6)  Enable future boot loads whenever NIC's power management triggers it:
+ *     BSM_WR_CTRL_REG = BSM_WR_CTRL_REG_BIT_START_EN
+ *
+ * 7)  Start the NIC by removing all reset bits:
+ *     CSR_RESET = 0
+ *
+ *     The bootstrap uCode (already in instruction SRAM) loads initialization
+ *     uCode.  Initialization uCode performs data initialization, sends
+ *     "initialize alive" notification to host, and waits for a signal from
+ *     host to load runtime code.
+ *
+ * 4)  Point (via BSM_DRAM_*) to the "runtime" uCode data and instruction
+ *     images in host DRAM.  The last register loaded must be the instruction
+ *     byte count register ("1" in MSbit tells initialization uCode to load
+ *     the runtime uCode):
+ *     BSM_DRAM_INST_BYTECOUNT_REG = byte count | BSM_DRAM_INST_LOAD
+ *
+ * 5)  Wait for "alive" notification, then issue normal runtime commands.
+ *
+ * Data caching during power-downs:
+ *
+ * Just before the embedded controller powers down (e.g for automatic
+ * power-saving modes, or for RFKILL), uCode stores (via PCI busmaster DMA)
+ * a current snapshot of the embedded processor's data SRAM into host DRAM.
+ * This caches the data while the embedded processor's memory is powered down.
+ * Location and size are controlled by BSM_DRAM_DATA_* registers.
+ *
+ * NOTE:  Instruction SRAM does not need to be saved, since that doesn't
+ *        change during operation; the original image (from uCode distribution
+ *        file) can be used for reload.
+ *
+ * When powering back up, the BSM loads the bootstrap program.  Bootstrap looks
+ * at the BSM_DRAM_* registers, which now point to the runtime instruction
+ * image and the cached (modified) runtime data (*not* the initialization
+ * uCode).  Bootstrap reloads these runtime images into SRAM, and restarts the
+ * uCode from where it left off before the power-down.
+ *
+ * NOTE:  Initialization uCode does *not* run as part of the save/restore
+ *        procedure.
+ *
+ * This save/restore method is mostly for autonomous power management during
+ * normal operation (result of C_POWER_TBL).  Platform suspend/resume and
+ * RFKILL should use complete restarts (with total re-initialization) of uCode,
+ * allowing total shutdown (including BSM memory).
+ *
+ * Note that, during normal operation, the host DRAM that held the initial
+ * startup data for the runtime code is now being used as a backup data cache
+ * for modified data!  If you need to completely re-initialize the NIC, make
+ * sure that you use the runtime data image from the uCode distribution file,
+ * not the modified/saved runtime data.  You may want to store a separate
+ * "clean" runtime data image in DRAM to avoid disk reads of distribution file.
+ */
+
+/* BSM bit fields */
+#define BSM_WR_CTRL_REG_BIT_START     (0x80000000)     /* start boot load now */
+#define BSM_WR_CTRL_REG_BIT_START_EN  (0x40000000)     /* enable boot after pwrup */
+#define BSM_DRAM_INST_LOAD            (0x80000000)     /* start program load now */
+
+/* BSM addresses */
+#define BSM_BASE                     (PRPH_BASE + 0x3400)
+#define BSM_END                      (PRPH_BASE + 0x3800)
+
+#define BSM_WR_CTRL_REG              (BSM_BASE + 0x000)        /* ctl and status */
+#define BSM_WR_MEM_SRC_REG           (BSM_BASE + 0x004)        /* source in BSM mem */
+#define BSM_WR_MEM_DST_REG           (BSM_BASE + 0x008)        /* dest in SRAM mem */
+#define BSM_WR_DWCOUNT_REG           (BSM_BASE + 0x00C)        /* bytes */
+#define BSM_WR_STATUS_REG            (BSM_BASE + 0x010)        /* bit 0:  1 == done */
+
+/*
+ * Pointers and size regs for bootstrap load and data SRAM save/restore.
+ * NOTE:  3945 pointers use bits 31:0 of DRAM address.
+ *        4965 pointers use bits 35:4 of DRAM address.
+ */
+#define BSM_DRAM_INST_PTR_REG        (BSM_BASE + 0x090)
+#define BSM_DRAM_INST_BYTECOUNT_REG  (BSM_BASE + 0x094)
+#define BSM_DRAM_DATA_PTR_REG        (BSM_BASE + 0x098)
+#define BSM_DRAM_DATA_BYTECOUNT_REG  (BSM_BASE + 0x09C)
+
+/*
+ * BSM special memory, stays powered on during power-save sleeps.
+ * Read/write, address range from LOWER_BOUND to (LOWER_BOUND + SIZE -1)
+ */
+#define BSM_SRAM_LOWER_BOUND         (PRPH_BASE + 0x3800)
+#define BSM_SRAM_SIZE                  (1024)  /* bytes */
+
+/* 3945 Tx scheduler registers */
+#define ALM_SCD_BASE                        (PRPH_BASE + 0x2E00)
+#define ALM_SCD_MODE_REG                    (ALM_SCD_BASE + 0x000)
+#define ALM_SCD_ARASTAT_REG                 (ALM_SCD_BASE + 0x004)
+#define ALM_SCD_TXFACT_REG                  (ALM_SCD_BASE + 0x010)
+#define ALM_SCD_TXF4MF_REG                  (ALM_SCD_BASE + 0x014)
+#define ALM_SCD_TXF5MF_REG                  (ALM_SCD_BASE + 0x020)
+#define ALM_SCD_SBYP_MODE_1_REG             (ALM_SCD_BASE + 0x02C)
+#define ALM_SCD_SBYP_MODE_2_REG             (ALM_SCD_BASE + 0x030)
+
+/**
+ * Tx Scheduler
+ *
+ * The Tx Scheduler selects the next frame to be transmitted, choosing TFDs
+ * (Transmit Frame Descriptors) from up to 16 circular Tx queues resident in
+ * host DRAM.  It steers each frame's Tx command (which contains the frame
+ * data) into one of up to 7 prioritized Tx DMA FIFO channels within the
+ * device.  A queue maps to only one (selectable by driver) Tx DMA channel,
+ * but one DMA channel may take input from several queues.
+ *
+ * Tx DMA FIFOs have dedicated purposes.  For 4965, they are used as follows
+ * (cf. default_queue_to_tx_fifo in 4965.c):
+ *
+ * 0 -- EDCA BK (background) frames, lowest priority
+ * 1 -- EDCA BE (best effort) frames, normal priority
+ * 2 -- EDCA VI (video) frames, higher priority
+ * 3 -- EDCA VO (voice) and management frames, highest priority
+ * 4 -- Commands (e.g. RXON, etc.)
+ * 5 -- unused (HCCA)
+ * 6 -- unused (HCCA)
+ * 7 -- not used by driver (device-internal only)
+ *
+ *
+ * Driver should normally map queues 0-6 to Tx DMA/FIFO channels 0-6.
+ * In addition, driver can map the remaining queues to Tx DMA/FIFO
+ * channels 0-3 to support 11n aggregation via EDCA DMA channels.
+ *
+ * The driver sets up each queue to work in one of two modes:
+ *
+ * 1)  Scheduler-Ack, in which the scheduler automatically supports a
+ *     block-ack (BA) win of up to 64 TFDs.  In this mode, each queue
+ *     contains TFDs for a unique combination of Recipient Address (RA)
+ *     and Traffic Identifier (TID), that is, traffic of a given
+ *     Quality-Of-Service (QOS) priority, destined for a single station.
+ *
+ *     In scheduler-ack mode, the scheduler keeps track of the Tx status of
+ *     each frame within the BA win, including whether it's been transmitted,
+ *     and whether it's been acknowledged by the receiving station.  The device
+ *     automatically processes block-acks received from the receiving STA,
+ *     and reschedules un-acked frames to be retransmitted (successful
+ *     Tx completion may end up being out-of-order).
+ *
+ *     The driver must maintain the queue's Byte Count table in host DRAM
+ *     (struct il4965_sched_queue_byte_cnt_tbl) for this mode.
+ *     This mode does not support fragmentation.
+ *
+ * 2)  FIFO (a.k.a. non-Scheduler-ACK), in which each TFD is processed in order.
+ *     The device may automatically retry Tx, but will retry only one frame
+ *     at a time, until receiving ACK from receiving station, or reaching
+ *     retry limit and giving up.
+ *
+ *     The command queue (#4/#9) must use this mode!
+ *     This mode does not require use of the Byte Count table in host DRAM.
+ *
+ * Driver controls scheduler operation via 3 means:
+ * 1)  Scheduler registers
+ * 2)  Shared scheduler data base in internal 4956 SRAM
+ * 3)  Shared data in host DRAM
+ *
+ * Initialization:
+ *
+ * When loading, driver should allocate memory for:
+ * 1)  16 TFD circular buffers, each with space for (typically) 256 TFDs.
+ * 2)  16 Byte Count circular buffers in 16 KBytes contiguous memory
+ *     (1024 bytes for each queue).
+ *
+ * After receiving "Alive" response from uCode, driver must initialize
+ * the scheduler (especially for queue #4/#9, the command queue, otherwise
+ * the driver can't issue commands!):
+ */
+
+/**
+ * Max Tx win size is the max number of contiguous TFDs that the scheduler
+ * can keep track of at one time when creating block-ack chains of frames.
+ * Note that "64" matches the number of ack bits in a block-ack packet.
+ * Driver should use SCD_WIN_SIZE and SCD_FRAME_LIMIT values to initialize
+ * IL49_SCD_CONTEXT_QUEUE_OFFSET(x) values.
+ */
+#define SCD_WIN_SIZE                           64
+#define SCD_FRAME_LIMIT                                64
+
+/* SCD registers are internal, must be accessed via HBUS_TARG_PRPH regs */
+#define IL49_SCD_START_OFFSET          0xa02c00
+
+/*
+ * 4965 tells driver SRAM address for internal scheduler structs via this reg.
+ * Value is valid only after "Alive" response from uCode.
+ */
+#define IL49_SCD_SRAM_BASE_ADDR           (IL49_SCD_START_OFFSET + 0x0)
+
+/*
+ * Driver may need to update queue-empty bits after changing queue's
+ * write and read pointers (idxes) during (re-)initialization (i.e. when
+ * scheduler is not tracking what's happening).
+ * Bit fields:
+ * 31-16:  Write mask -- 1: update empty bit, 0: don't change empty bit
+ * 15-00:  Empty state, one for each queue -- 1: empty, 0: non-empty
+ * NOTE:  This register is not used by Linux driver.
+ */
+#define IL49_SCD_EMPTY_BITS               (IL49_SCD_START_OFFSET + 0x4)
+
+/*
+ * Physical base address of array of byte count (BC) circular buffers (CBs).
+ * Each Tx queue has a BC CB in host DRAM to support Scheduler-ACK mode.
+ * This register points to BC CB for queue 0, must be on 1024-byte boundary.
+ * Others are spaced by 1024 bytes.
+ * Each BC CB is 2 bytes * (256 + 64) = 740 bytes, followed by 384 bytes pad.
+ * (Index into a queue's BC CB) = (idx into queue's TFD CB) = (SSN & 0xff).
+ * Bit fields:
+ * 25-00:  Byte Count CB physical address [35:10], must be 1024-byte aligned.
+ */
+#define IL49_SCD_DRAM_BASE_ADDR           (IL49_SCD_START_OFFSET + 0x10)
+
+/*
+ * Enables any/all Tx DMA/FIFO channels.
+ * Scheduler generates requests for only the active channels.
+ * Set this to 0xff to enable all 8 channels (normal usage).
+ * Bit fields:
+ *  7- 0:  Enable (1), disable (0), one bit for each channel 0-7
+ */
+#define IL49_SCD_TXFACT                   (IL49_SCD_START_OFFSET + 0x1c)
+/*
+ * Queue (x) Write Pointers (idxes, really!), one for each Tx queue.
+ * Initialized and updated by driver as new TFDs are added to queue.
+ * NOTE:  If using Block Ack, idx must correspond to frame's
+ *        Start Sequence Number; idx = (SSN & 0xff)
+ * NOTE:  Alternative to HBUS_TARG_WRPTR, which is what Linux driver uses?
+ */
+#define IL49_SCD_QUEUE_WRPTR(x)  (IL49_SCD_START_OFFSET + 0x24 + (x) * 4)
+
+/*
+ * Queue (x) Read Pointers (idxes, really!), one for each Tx queue.
+ * For FIFO mode, idx indicates next frame to transmit.
+ * For Scheduler-ACK mode, idx indicates first frame in Tx win.
+ * Initialized by driver, updated by scheduler.
+ */
+#define IL49_SCD_QUEUE_RDPTR(x)  (IL49_SCD_START_OFFSET + 0x64 + (x) * 4)
+
+/*
+ * Select which queues work in chain mode (1) vs. not (0).
+ * Use chain mode to build chains of aggregated frames.
+ * Bit fields:
+ * 31-16:  Reserved
+ * 15-00:  Mode, one bit for each queue -- 1: Chain mode, 0: one-at-a-time
+ * NOTE:  If driver sets up queue for chain mode, it should be also set up
+ *        Scheduler-ACK mode as well, via SCD_QUEUE_STATUS_BITS(x).
+ */
+#define IL49_SCD_QUEUECHAIN_SEL  (IL49_SCD_START_OFFSET + 0xd0)
+
+/*
+ * Select which queues interrupt driver when scheduler increments
+ * a queue's read pointer (idx).
+ * Bit fields:
+ * 31-16:  Reserved
+ * 15-00:  Interrupt enable, one bit for each queue -- 1: enabled, 0: disabled
+ * NOTE:  This functionality is apparently a no-op; driver relies on interrupts
+ *        from Rx queue to read Tx command responses and update Tx queues.
+ */
+#define IL49_SCD_INTERRUPT_MASK  (IL49_SCD_START_OFFSET + 0xe4)
+
+/*
+ * Queue search status registers.  One for each queue.
+ * Sets up queue mode and assigns queue to Tx DMA channel.
+ * Bit fields:
+ * 19-10: Write mask/enable bits for bits 0-9
+ *     9: Driver should init to "0"
+ *     8: Scheduler-ACK mode (1), non-Scheduler-ACK (i.e. FIFO) mode (0).
+ *        Driver should init to "1" for aggregation mode, or "0" otherwise.
+ *   7-6: Driver should init to "0"
+ *     5: Window Size Left; indicates whether scheduler can request
+ *        another TFD, based on win size, etc.  Driver should init
+ *        this bit to "1" for aggregation mode, or "0" for non-agg.
+ *   4-1: Tx FIFO to use (range 0-7).
+ *     0: Queue is active (1), not active (0).
+ * Other bits should be written as "0"
+ *
+ * NOTE:  If enabling Scheduler-ACK mode, chain mode should also be enabled
+ *        via SCD_QUEUECHAIN_SEL.
+ */
+#define IL49_SCD_QUEUE_STATUS_BITS(x)\
+       (IL49_SCD_START_OFFSET + 0x104 + (x) * 4)
+
+/* Bit field positions */
+#define IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE     (0)
+#define IL49_SCD_QUEUE_STTS_REG_POS_TXF        (1)
+#define IL49_SCD_QUEUE_STTS_REG_POS_WSL        (5)
+#define IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACK    (8)
+
+/* Write masks */
+#define IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN (10)
+#define IL49_SCD_QUEUE_STTS_REG_MSK            (0x0007FC00)
+
+/**
+ * 4965 internal SRAM structures for scheduler, shared with driver ...
+ *
+ * Driver should clear and initialize the following areas after receiving
+ * "Alive" response from 4965 uCode, i.e. after initial
+ * uCode load, or after a uCode load done for error recovery:
+ *
+ * SCD_CONTEXT_DATA_OFFSET (size 128 bytes)
+ * SCD_TX_STTS_BITMAP_OFFSET (size 256 bytes)
+ * SCD_TRANSLATE_TBL_OFFSET (size 32 bytes)
+ *
+ * Driver accesses SRAM via HBUS_TARG_MEM_* registers.
+ * Driver reads base address of this scheduler area from SCD_SRAM_BASE_ADDR.
+ * All OFFSET values must be added to this base address.
+ */
+
+/*
+ * Queue context.  One 8-byte entry for each of 16 queues.
+ *
+ * Driver should clear this entire area (size 0x80) to 0 after receiving
+ * "Alive" notification from uCode.  Additionally, driver should init
+ * each queue's entry as follows:
+ *
+ * LS Dword bit fields:
+ *  0-06:  Max Tx win size for Scheduler-ACK.  Driver should init to 64.
+ *
+ * MS Dword bit fields:
+ * 16-22:  Frame limit.  Driver should init to 10 (0xa).
+ *
+ * Driver should init all other bits to 0.
+ *
+ * Init must be done after driver receives "Alive" response from 4965 uCode,
+ * and when setting up queue for aggregation.
+ */
+#define IL49_SCD_CONTEXT_DATA_OFFSET                   0x380
+#define IL49_SCD_CONTEXT_QUEUE_OFFSET(x) \
+                       (IL49_SCD_CONTEXT_DATA_OFFSET + ((x) * 8))
+
+#define IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS           (0)
+#define IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK           (0x0000007F)
+#define IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS        (16)
+#define IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK        (0x007F0000)
+
+/*
+ * Tx Status Bitmap
+ *
+ * Driver should clear this entire area (size 0x100) to 0 after receiving
+ * "Alive" notification from uCode.  Area is used only by device itself;
+ * no other support (besides clearing) is required from driver.
+ */
+#define IL49_SCD_TX_STTS_BITMAP_OFFSET         0x400
+
+/*
+ * RAxTID to queue translation mapping.
+ *
+ * When queue is in Scheduler-ACK mode, frames placed in a that queue must be
+ * for only one combination of receiver address (RA) and traffic ID (TID), i.e.
+ * one QOS priority level destined for one station (for this wireless link,
+ * not final destination).  The SCD_TRANSLATE_TBL area provides 16 16-bit
+ * mappings, one for each of the 16 queues.  If queue is not in Scheduler-ACK
+ * mode, the device ignores the mapping value.
+ *
+ * Bit fields, for each 16-bit map:
+ * 15-9:  Reserved, set to 0
+ *  8-4:  Index into device's station table for recipient station
+ *  3-0:  Traffic ID (tid), range 0-15
+ *
+ * Driver should clear this entire area (size 32 bytes) to 0 after receiving
+ * "Alive" notification from uCode.  To update a 16-bit map value, driver
+ * must read a dword-aligned value from device SRAM, replace the 16-bit map
+ * value of interest, and write the dword value back into device SRAM.
+ */
+#define IL49_SCD_TRANSLATE_TBL_OFFSET          0x500
+
+/* Find translation table dword to read/write for given queue */
+#define IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(x) \
+       ((IL49_SCD_TRANSLATE_TBL_OFFSET + ((x) * 2)) & 0xfffffffc)
+
+#define IL_SCD_TXFIFO_POS_TID                  (0)
+#define IL_SCD_TXFIFO_POS_RA                   (4)
+#define IL_SCD_QUEUE_RA_TID_MAP_RATID_MSK      (0x01FF)
+
+/*********************** END TX SCHEDULER *************************************/
+
+#endif /* __il_prph_h__ */
diff --git a/drivers/net/wireless/iwlegacy/3945-debug.c b/drivers/net/wireless/iwlegacy/3945-debug.c
deleted file mode 100644 (file)
index c1b4441..0000000
+++ /dev/null
@@ -1,511 +0,0 @@
-/******************************************************************************
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *****************************************************************************/
-
-#include "common.h"
-#include "3945.h"
-
-static int
-il3945_stats_flag(struct il_priv *il, char *buf, int bufsz)
-{
-       int p = 0;
-
-       p += scnprintf(buf + p, bufsz - p, "Statistics Flag(0x%X):\n",
-                      le32_to_cpu(il->_3945.stats.flag));
-       if (le32_to_cpu(il->_3945.stats.flag) & UCODE_STATS_CLEAR_MSK)
-               p += scnprintf(buf + p, bufsz - p,
-                              "\tStatistics have been cleared\n");
-       p += scnprintf(buf + p, bufsz - p, "\tOperational Frequency: %s\n",
-                      (le32_to_cpu(il->_3945.stats.flag) &
-                       UCODE_STATS_FREQUENCY_MSK) ? "2.4 GHz" : "5.2 GHz");
-       p += scnprintf(buf + p, bufsz - p, "\tTGj Narrow Band: %s\n",
-                      (le32_to_cpu(il->_3945.stats.flag) &
-                       UCODE_STATS_NARROW_BAND_MSK) ? "enabled" : "disabled");
-       return p;
-}
-
-static ssize_t
-il3945_ucode_rx_stats_read(struct file *file, char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char *buf;
-       int bufsz =
-           sizeof(struct iwl39_stats_rx_phy) * 40 +
-           sizeof(struct iwl39_stats_rx_non_phy) * 40 + 400;
-       ssize_t ret;
-       struct iwl39_stats_rx_phy *ofdm, *accum_ofdm, *delta_ofdm, *max_ofdm;
-       struct iwl39_stats_rx_phy *cck, *accum_cck, *delta_cck, *max_cck;
-       struct iwl39_stats_rx_non_phy *general, *accum_general;
-       struct iwl39_stats_rx_non_phy *delta_general, *max_general;
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       /*
-        * The statistic information display here is based on
-        * the last stats notification from uCode
-        * might not reflect the current uCode activity
-        */
-       ofdm = &il->_3945.stats.rx.ofdm;
-       cck = &il->_3945.stats.rx.cck;
-       general = &il->_3945.stats.rx.general;
-       accum_ofdm = &il->_3945.accum_stats.rx.ofdm;
-       accum_cck = &il->_3945.accum_stats.rx.cck;
-       accum_general = &il->_3945.accum_stats.rx.general;
-       delta_ofdm = &il->_3945.delta_stats.rx.ofdm;
-       delta_cck = &il->_3945.delta_stats.rx.cck;
-       delta_general = &il->_3945.delta_stats.rx.general;
-       max_ofdm = &il->_3945.max_delta.rx.ofdm;
-       max_cck = &il->_3945.max_delta.rx.cck;
-       max_general = &il->_3945.max_delta.rx.general;
-
-       pos += il3945_stats_flag(il, buf, bufsz);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "%-32s     current"
-                     "acumulative       delta         max\n",
-                     "Statistics_Rx - OFDM:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "ina_cnt:",
-                     le32_to_cpu(ofdm->ina_cnt), accum_ofdm->ina_cnt,
-                     delta_ofdm->ina_cnt, max_ofdm->ina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_cnt:",
-                     le32_to_cpu(ofdm->fina_cnt), accum_ofdm->fina_cnt,
-                     delta_ofdm->fina_cnt, max_ofdm->fina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "plcp_err:",
-                     le32_to_cpu(ofdm->plcp_err), accum_ofdm->plcp_err,
-                     delta_ofdm->plcp_err, max_ofdm->plcp_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_err:",
-                     le32_to_cpu(ofdm->crc32_err), accum_ofdm->crc32_err,
-                     delta_ofdm->crc32_err, max_ofdm->crc32_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "overrun_err:",
-                     le32_to_cpu(ofdm->overrun_err), accum_ofdm->overrun_err,
-                     delta_ofdm->overrun_err, max_ofdm->overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "early_overrun_err:",
-                     le32_to_cpu(ofdm->early_overrun_err),
-                     accum_ofdm->early_overrun_err,
-                     delta_ofdm->early_overrun_err,
-                     max_ofdm->early_overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_good:",
-                     le32_to_cpu(ofdm->crc32_good), accum_ofdm->crc32_good,
-                     delta_ofdm->crc32_good, max_ofdm->crc32_good);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "false_alarm_cnt:",
-                     le32_to_cpu(ofdm->false_alarm_cnt),
-                     accum_ofdm->false_alarm_cnt, delta_ofdm->false_alarm_cnt,
-                     max_ofdm->false_alarm_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_sync_err_cnt:",
-                     le32_to_cpu(ofdm->fina_sync_err_cnt),
-                     accum_ofdm->fina_sync_err_cnt,
-                     delta_ofdm->fina_sync_err_cnt,
-                     max_ofdm->fina_sync_err_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "sfd_timeout:",
-                     le32_to_cpu(ofdm->sfd_timeout), accum_ofdm->sfd_timeout,
-                     delta_ofdm->sfd_timeout, max_ofdm->sfd_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_timeout:",
-                     le32_to_cpu(ofdm->fina_timeout), accum_ofdm->fina_timeout,
-                     delta_ofdm->fina_timeout, max_ofdm->fina_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "unresponded_rts:",
-                     le32_to_cpu(ofdm->unresponded_rts),
-                     accum_ofdm->unresponded_rts, delta_ofdm->unresponded_rts,
-                     max_ofdm->unresponded_rts);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n",
-                     "rxe_frame_lmt_ovrun:",
-                     le32_to_cpu(ofdm->rxe_frame_limit_overrun),
-                     accum_ofdm->rxe_frame_limit_overrun,
-                     delta_ofdm->rxe_frame_limit_overrun,
-                     max_ofdm->rxe_frame_limit_overrun);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_ack_cnt:",
-                     le32_to_cpu(ofdm->sent_ack_cnt), accum_ofdm->sent_ack_cnt,
-                     delta_ofdm->sent_ack_cnt, max_ofdm->sent_ack_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_cts_cnt:",
-                     le32_to_cpu(ofdm->sent_cts_cnt), accum_ofdm->sent_cts_cnt,
-                     delta_ofdm->sent_cts_cnt, max_ofdm->sent_cts_cnt);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "%-32s     current"
-                     "acumulative       delta         max\n",
-                     "Statistics_Rx - CCK:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "ina_cnt:",
-                     le32_to_cpu(cck->ina_cnt), accum_cck->ina_cnt,
-                     delta_cck->ina_cnt, max_cck->ina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_cnt:",
-                     le32_to_cpu(cck->fina_cnt), accum_cck->fina_cnt,
-                     delta_cck->fina_cnt, max_cck->fina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "plcp_err:",
-                     le32_to_cpu(cck->plcp_err), accum_cck->plcp_err,
-                     delta_cck->plcp_err, max_cck->plcp_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_err:",
-                     le32_to_cpu(cck->crc32_err), accum_cck->crc32_err,
-                     delta_cck->crc32_err, max_cck->crc32_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "overrun_err:",
-                     le32_to_cpu(cck->overrun_err), accum_cck->overrun_err,
-                     delta_cck->overrun_err, max_cck->overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "early_overrun_err:",
-                     le32_to_cpu(cck->early_overrun_err),
-                     accum_cck->early_overrun_err,
-                     delta_cck->early_overrun_err, max_cck->early_overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "crc32_good:",
-                     le32_to_cpu(cck->crc32_good), accum_cck->crc32_good,
-                     delta_cck->crc32_good, max_cck->crc32_good);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "false_alarm_cnt:",
-                     le32_to_cpu(cck->false_alarm_cnt),
-                     accum_cck->false_alarm_cnt, delta_cck->false_alarm_cnt,
-                     max_cck->false_alarm_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_sync_err_cnt:",
-                     le32_to_cpu(cck->fina_sync_err_cnt),
-                     accum_cck->fina_sync_err_cnt,
-                     delta_cck->fina_sync_err_cnt, max_cck->fina_sync_err_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "sfd_timeout:",
-                     le32_to_cpu(cck->sfd_timeout), accum_cck->sfd_timeout,
-                     delta_cck->sfd_timeout, max_cck->sfd_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "fina_timeout:",
-                     le32_to_cpu(cck->fina_timeout), accum_cck->fina_timeout,
-                     delta_cck->fina_timeout, max_cck->fina_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "unresponded_rts:",
-                     le32_to_cpu(cck->unresponded_rts),
-                     accum_cck->unresponded_rts, delta_cck->unresponded_rts,
-                     max_cck->unresponded_rts);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n",
-                     "rxe_frame_lmt_ovrun:",
-                     le32_to_cpu(cck->rxe_frame_limit_overrun),
-                     accum_cck->rxe_frame_limit_overrun,
-                     delta_cck->rxe_frame_limit_overrun,
-                     max_cck->rxe_frame_limit_overrun);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_ack_cnt:",
-                     le32_to_cpu(cck->sent_ack_cnt), accum_cck->sent_ack_cnt,
-                     delta_cck->sent_ack_cnt, max_cck->sent_ack_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "sent_cts_cnt:",
-                     le32_to_cpu(cck->sent_cts_cnt), accum_cck->sent_cts_cnt,
-                     delta_cck->sent_cts_cnt, max_cck->sent_cts_cnt);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "%-32s     current"
-                     "acumulative       delta         max\n",
-                     "Statistics_Rx - GENERAL:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "bogus_cts:",
-                     le32_to_cpu(general->bogus_cts), accum_general->bogus_cts,
-                     delta_general->bogus_cts, max_general->bogus_cts);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "bogus_ack:",
-                     le32_to_cpu(general->bogus_ack), accum_general->bogus_ack,
-                     delta_general->bogus_ack, max_general->bogus_ack);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "non_bssid_frames:",
-                     le32_to_cpu(general->non_bssid_frames),
-                     accum_general->non_bssid_frames,
-                     delta_general->non_bssid_frames,
-                     max_general->non_bssid_frames);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "filtered_frames:",
-                     le32_to_cpu(general->filtered_frames),
-                     accum_general->filtered_frames,
-                     delta_general->filtered_frames,
-                     max_general->filtered_frames);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n",
-                     "non_channel_beacons:",
-                     le32_to_cpu(general->non_channel_beacons),
-                     accum_general->non_channel_beacons,
-                     delta_general->non_channel_beacons,
-                     max_general->non_channel_beacons);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il3945_ucode_tx_stats_read(struct file *file, char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char *buf;
-       int bufsz = (sizeof(struct iwl39_stats_tx) * 48) + 250;
-       ssize_t ret;
-       struct iwl39_stats_tx *tx, *accum_tx, *delta_tx, *max_tx;
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       /*
-        * The statistic information display here is based on
-        * the last stats notification from uCode
-        * might not reflect the current uCode activity
-        */
-       tx = &il->_3945.stats.tx;
-       accum_tx = &il->_3945.accum_stats.tx;
-       delta_tx = &il->_3945.delta_stats.tx;
-       max_tx = &il->_3945.max_delta.tx;
-       pos += il3945_stats_flag(il, buf, bufsz);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "%-32s     current"
-                     "acumulative       delta         max\n",
-                     "Statistics_Tx:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "preamble:",
-                     le32_to_cpu(tx->preamble_cnt), accum_tx->preamble_cnt,
-                     delta_tx->preamble_cnt, max_tx->preamble_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "rx_detected_cnt:",
-                     le32_to_cpu(tx->rx_detected_cnt),
-                     accum_tx->rx_detected_cnt, delta_tx->rx_detected_cnt,
-                     max_tx->rx_detected_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "bt_prio_defer_cnt:",
-                     le32_to_cpu(tx->bt_prio_defer_cnt),
-                     accum_tx->bt_prio_defer_cnt, delta_tx->bt_prio_defer_cnt,
-                     max_tx->bt_prio_defer_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "bt_prio_kill_cnt:",
-                     le32_to_cpu(tx->bt_prio_kill_cnt),
-                     accum_tx->bt_prio_kill_cnt, delta_tx->bt_prio_kill_cnt,
-                     max_tx->bt_prio_kill_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "few_bytes_cnt:",
-                     le32_to_cpu(tx->few_bytes_cnt), accum_tx->few_bytes_cnt,
-                     delta_tx->few_bytes_cnt, max_tx->few_bytes_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "cts_timeout:",
-                     le32_to_cpu(tx->cts_timeout), accum_tx->cts_timeout,
-                     delta_tx->cts_timeout, max_tx->cts_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "ack_timeout:",
-                     le32_to_cpu(tx->ack_timeout), accum_tx->ack_timeout,
-                     delta_tx->ack_timeout, max_tx->ack_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "expected_ack_cnt:",
-                     le32_to_cpu(tx->expected_ack_cnt),
-                     accum_tx->expected_ack_cnt, delta_tx->expected_ack_cnt,
-                     max_tx->expected_ack_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "actual_ack_cnt:",
-                     le32_to_cpu(tx->actual_ack_cnt), accum_tx->actual_ack_cnt,
-                     delta_tx->actual_ack_cnt, max_tx->actual_ack_cnt);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il3945_ucode_general_stats_read(struct file *file, char __user *user_buf,
-                               size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char *buf;
-       int bufsz = sizeof(struct iwl39_stats_general) * 10 + 300;
-       ssize_t ret;
-       struct iwl39_stats_general *general, *accum_general;
-       struct iwl39_stats_general *delta_general, *max_general;
-       struct stats_dbg *dbg, *accum_dbg, *delta_dbg, *max_dbg;
-       struct iwl39_stats_div *div, *accum_div, *delta_div, *max_div;
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       /*
-        * The statistic information display here is based on
-        * the last stats notification from uCode
-        * might not reflect the current uCode activity
-        */
-       general = &il->_3945.stats.general;
-       dbg = &il->_3945.stats.general.dbg;
-       div = &il->_3945.stats.general.div;
-       accum_general = &il->_3945.accum_stats.general;
-       delta_general = &il->_3945.delta_stats.general;
-       max_general = &il->_3945.max_delta.general;
-       accum_dbg = &il->_3945.accum_stats.general.dbg;
-       delta_dbg = &il->_3945.delta_stats.general.dbg;
-       max_dbg = &il->_3945.max_delta.general.dbg;
-       accum_div = &il->_3945.accum_stats.general.div;
-       delta_div = &il->_3945.delta_stats.general.div;
-       max_div = &il->_3945.max_delta.general.div;
-       pos += il3945_stats_flag(il, buf, bufsz);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "%-32s     current"
-                     "acumulative       delta         max\n",
-                     "Statistics_General:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "burst_check:",
-                     le32_to_cpu(dbg->burst_check), accum_dbg->burst_check,
-                     delta_dbg->burst_check, max_dbg->burst_check);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "burst_count:",
-                     le32_to_cpu(dbg->burst_count), accum_dbg->burst_count,
-                     delta_dbg->burst_count, max_dbg->burst_count);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "sleep_time:",
-                     le32_to_cpu(general->sleep_time),
-                     accum_general->sleep_time, delta_general->sleep_time,
-                     max_general->sleep_time);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "slots_out:",
-                     le32_to_cpu(general->slots_out), accum_general->slots_out,
-                     delta_general->slots_out, max_general->slots_out);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "slots_idle:",
-                     le32_to_cpu(general->slots_idle),
-                     accum_general->slots_idle, delta_general->slots_idle,
-                     max_general->slots_idle);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "ttl_timestamp:\t\t\t%u\n",
-                     le32_to_cpu(general->ttl_timestamp));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "tx_on_a:",
-                     le32_to_cpu(div->tx_on_a), accum_div->tx_on_a,
-                     delta_div->tx_on_a, max_div->tx_on_a);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "tx_on_b:",
-                     le32_to_cpu(div->tx_on_b), accum_div->tx_on_b,
-                     delta_div->tx_on_b, max_div->tx_on_b);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "exec_time:",
-                     le32_to_cpu(div->exec_time), accum_div->exec_time,
-                     delta_div->exec_time, max_div->exec_time);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "  %-30s %10u  %10u  %10u  %10u\n", "probe_time:",
-                     le32_to_cpu(div->probe_time), accum_div->probe_time,
-                     delta_div->probe_time, max_div->probe_time);
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-const struct il_debugfs_ops il3945_debugfs_ops = {
-       .rx_stats_read = il3945_ucode_rx_stats_read,
-       .tx_stats_read = il3945_ucode_tx_stats_read,
-       .general_stats_read = il3945_ucode_general_stats_read,
-};
diff --git a/drivers/net/wireless/iwlegacy/3945-mac.c b/drivers/net/wireless/iwlegacy/3945-mac.c
deleted file mode 100644 (file)
index af1b3e6..0000000
+++ /dev/null
@@ -1,3959 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * Portions of this file are derived from the ipw3945 project, as well
- * as portions of the ieee80211 subsystem header files.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/pci.h>
-#include <linux/pci-aspm.h>
-#include <linux/slab.h>
-#include <linux/dma-mapping.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/skbuff.h>
-#include <linux/netdevice.h>
-#include <linux/firmware.h>
-#include <linux/etherdevice.h>
-#include <linux/if_arp.h>
-
-#include <net/ieee80211_radiotap.h>
-#include <net/mac80211.h>
-
-#include <asm/div64.h>
-
-#define DRV_NAME       "iwl3945"
-
-#include "commands.h"
-#include "common.h"
-#include "3945.h"
-#include "iwl-spectrum.h"
-
-/*
- * module name, copyright, version, etc.
- */
-
-#define DRV_DESCRIPTION        \
-"Intel(R) PRO/Wireless 3945ABG/BG Network Connection driver for Linux"
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-#define VD "d"
-#else
-#define VD
-#endif
-
-/*
- * add "s" to indicate spectrum measurement included.
- * we add it here to be consistent with previous releases in which
- * this was configurable.
- */
-#define DRV_VERSION  IWLWIFI_VERSION VD "s"
-#define DRV_COPYRIGHT  "Copyright(c) 2003-2011 Intel Corporation"
-#define DRV_AUTHOR     "<ilw@linux.intel.com>"
-
-MODULE_DESCRIPTION(DRV_DESCRIPTION);
-MODULE_VERSION(DRV_VERSION);
-MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
-MODULE_LICENSE("GPL");
-
- /* module parameters */
-struct il_mod_params il3945_mod_params = {
-       .sw_crypto = 1,
-       .restart_fw = 1,
-       .disable_hw_scan = 1,
-       /* the rest are 0 by default */
-};
-
-/**
- * il3945_get_antenna_flags - Get antenna flags for RXON command
- * @il: eeprom and antenna fields are used to determine antenna flags
- *
- * il->eeprom39  is used to determine if antenna AUX/MAIN are reversed
- * il3945_mod_params.antenna specifies the antenna diversity mode:
- *
- * IL_ANTENNA_DIVERSITY - NIC selects best antenna by itself
- * IL_ANTENNA_MAIN      - Force MAIN antenna
- * IL_ANTENNA_AUX       - Force AUX antenna
- */
-__le32
-il3945_get_antenna_flags(const struct il_priv *il)
-{
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-
-       switch (il3945_mod_params.antenna) {
-       case IL_ANTENNA_DIVERSITY:
-               return 0;
-
-       case IL_ANTENNA_MAIN:
-               if (eeprom->antenna_switch_type)
-                       return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
-               return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
-
-       case IL_ANTENNA_AUX:
-               if (eeprom->antenna_switch_type)
-                       return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
-               return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
-       }
-
-       /* bad antenna selector value */
-       IL_ERR("Bad antenna selector value (0x%x)\n",
-              il3945_mod_params.antenna);
-
-       return 0;               /* "diversity" is default if error */
-}
-
-static int
-il3945_set_ccmp_dynamic_key_info(struct il_priv *il,
-                                struct ieee80211_key_conf *keyconf, u8 sta_id)
-{
-       unsigned long flags;
-       __le16 key_flags = 0;
-       int ret;
-
-       key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
-       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
-
-       if (sta_id == il->hw_params.bcast_id)
-               key_flags |= STA_KEY_MULTICAST_MSK;
-
-       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
-       keyconf->hw_key_idx = keyconf->keyidx;
-       key_flags &= ~STA_KEY_FLG_INVALID;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
-       il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
-       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
-
-       memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
-
-       if ((il->stations[sta_id].sta.key.
-            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
-               il->stations[sta_id].sta.key.key_offset =
-                   il_get_free_ucode_key_idx(il);
-       /* else, we are overriding an existing key => no need to allocated room
-        * in uCode. */
-
-       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
-            "no space for a new key");
-
-       il->stations[sta_id].sta.key.key_flags = key_flags;
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-
-       D_INFO("hwcrypto: modify ucode station key info\n");
-
-       ret = il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
-
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return ret;
-}
-
-static int
-il3945_set_tkip_dynamic_key_info(struct il_priv *il,
-                                struct ieee80211_key_conf *keyconf, u8 sta_id)
-{
-       return -EOPNOTSUPP;
-}
-
-static int
-il3945_set_wep_dynamic_key_info(struct il_priv *il,
-                               struct ieee80211_key_conf *keyconf, u8 sta_id)
-{
-       return -EOPNOTSUPP;
-}
-
-static int
-il3945_clear_sta_key_info(struct il_priv *il, u8 sta_id)
-{
-       unsigned long flags;
-       struct il_addsta_cmd sta_cmd;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       memset(&il->stations[sta_id].keyinfo, 0, sizeof(struct il_hw_key));
-       memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
-       il->stations[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       D_INFO("hwcrypto: clear ucode station key info\n");
-       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-}
-
-static int
-il3945_set_dynamic_key(struct il_priv *il, struct ieee80211_key_conf *keyconf,
-                      u8 sta_id)
-{
-       int ret = 0;
-
-       keyconf->hw_key_idx = HW_KEY_DYNAMIC;
-
-       switch (keyconf->cipher) {
-       case WLAN_CIPHER_SUITE_CCMP:
-               ret = il3945_set_ccmp_dynamic_key_info(il, keyconf, sta_id);
-               break;
-       case WLAN_CIPHER_SUITE_TKIP:
-               ret = il3945_set_tkip_dynamic_key_info(il, keyconf, sta_id);
-               break;
-       case WLAN_CIPHER_SUITE_WEP40:
-       case WLAN_CIPHER_SUITE_WEP104:
-               ret = il3945_set_wep_dynamic_key_info(il, keyconf, sta_id);
-               break;
-       default:
-               IL_ERR("Unknown alg: %s alg=%x\n", __func__, keyconf->cipher);
-               ret = -EINVAL;
-       }
-
-       D_WEP("Set dynamic key: alg=%x len=%d idx=%d sta=%d ret=%d\n",
-             keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
-
-       return ret;
-}
-
-static int
-il3945_remove_static_key(struct il_priv *il)
-{
-       int ret = -EOPNOTSUPP;
-
-       return ret;
-}
-
-static int
-il3945_set_static_key(struct il_priv *il, struct ieee80211_key_conf *key)
-{
-       if (key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
-           key->cipher == WLAN_CIPHER_SUITE_WEP104)
-               return -EOPNOTSUPP;
-
-       IL_ERR("Static key invalid: cipher %x\n", key->cipher);
-       return -EINVAL;
-}
-
-static void
-il3945_clear_free_frames(struct il_priv *il)
-{
-       struct list_head *element;
-
-       D_INFO("%d frames on pre-allocated heap on clear.\n", il->frames_count);
-
-       while (!list_empty(&il->free_frames)) {
-               element = il->free_frames.next;
-               list_del(element);
-               kfree(list_entry(element, struct il3945_frame, list));
-               il->frames_count--;
-       }
-
-       if (il->frames_count) {
-               IL_WARN("%d frames still in use.  Did we lose one?\n",
-                       il->frames_count);
-               il->frames_count = 0;
-       }
-}
-
-static struct il3945_frame *
-il3945_get_free_frame(struct il_priv *il)
-{
-       struct il3945_frame *frame;
-       struct list_head *element;
-       if (list_empty(&il->free_frames)) {
-               frame = kzalloc(sizeof(*frame), GFP_KERNEL);
-               if (!frame) {
-                       IL_ERR("Could not allocate frame!\n");
-                       return NULL;
-               }
-
-               il->frames_count++;
-               return frame;
-       }
-
-       element = il->free_frames.next;
-       list_del(element);
-       return list_entry(element, struct il3945_frame, list);
-}
-
-static void
-il3945_free_frame(struct il_priv *il, struct il3945_frame *frame)
-{
-       memset(frame, 0, sizeof(*frame));
-       list_add(&frame->list, &il->free_frames);
-}
-
-unsigned int
-il3945_fill_beacon_frame(struct il_priv *il, struct ieee80211_hdr *hdr,
-                        int left)
-{
-
-       if (!il_is_associated(il) || !il->beacon_skb)
-               return 0;
-
-       if (il->beacon_skb->len > left)
-               return 0;
-
-       memcpy(hdr, il->beacon_skb->data, il->beacon_skb->len);
-
-       return il->beacon_skb->len;
-}
-
-static int
-il3945_send_beacon_cmd(struct il_priv *il)
-{
-       struct il3945_frame *frame;
-       unsigned int frame_size;
-       int rc;
-       u8 rate;
-
-       frame = il3945_get_free_frame(il);
-
-       if (!frame) {
-               IL_ERR("Could not obtain free frame buffer for beacon "
-                      "command.\n");
-               return -ENOMEM;
-       }
-
-       rate = il_get_lowest_plcp(il);
-
-       frame_size = il3945_hw_get_beacon_cmd(il, frame, rate);
-
-       rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size, &frame->u.cmd[0]);
-
-       il3945_free_frame(il, frame);
-
-       return rc;
-}
-
-static void
-il3945_unset_hw_params(struct il_priv *il)
-{
-       if (il->_3945.shared_virt)
-               dma_free_coherent(&il->pci_dev->dev,
-                                 sizeof(struct il3945_shared),
-                                 il->_3945.shared_virt, il->_3945.shared_phys);
-}
-
-static void
-il3945_build_tx_cmd_hwcrypto(struct il_priv *il, struct ieee80211_tx_info *info,
-                            struct il_device_cmd *cmd,
-                            struct sk_buff *skb_frag, int sta_id)
-{
-       struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
-       struct il_hw_key *keyinfo = &il->stations[sta_id].keyinfo;
-
-       tx_cmd->sec_ctl = 0;
-
-       switch (keyinfo->cipher) {
-       case WLAN_CIPHER_SUITE_CCMP:
-               tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
-               memcpy(tx_cmd->key, keyinfo->key, keyinfo->keylen);
-               D_TX("tx_cmd with AES hwcrypto\n");
-               break;
-
-       case WLAN_CIPHER_SUITE_TKIP:
-               break;
-
-       case WLAN_CIPHER_SUITE_WEP104:
-               tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
-               /* fall through */
-       case WLAN_CIPHER_SUITE_WEP40:
-               tx_cmd->sec_ctl |=
-                   TX_CMD_SEC_WEP | (info->control.hw_key->
-                                     hw_key_idx & TX_CMD_SEC_MSK) <<
-                   TX_CMD_SEC_SHIFT;
-
-               memcpy(&tx_cmd->key[3], keyinfo->key, keyinfo->keylen);
-
-               D_TX("Configuring packet for WEP encryption " "with key %d\n",
-                    info->control.hw_key->hw_key_idx);
-               break;
-
-       default:
-               IL_ERR("Unknown encode cipher %x\n", keyinfo->cipher);
-               break;
-       }
-}
-
-/*
- * handle build C_TX command notification.
- */
-static void
-il3945_build_tx_cmd_basic(struct il_priv *il, struct il_device_cmd *cmd,
-                         struct ieee80211_tx_info *info,
-                         struct ieee80211_hdr *hdr, u8 std_id)
-{
-       struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
-       __le32 tx_flags = tx_cmd->tx_flags;
-       __le16 fc = hdr->frame_control;
-
-       tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
-       if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
-               tx_flags |= TX_CMD_FLG_ACK_MSK;
-               if (ieee80211_is_mgmt(fc))
-                       tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
-               if (ieee80211_is_probe_resp(fc) &&
-                   !(le16_to_cpu(hdr->seq_ctrl) & 0xf))
-                       tx_flags |= TX_CMD_FLG_TSF_MSK;
-       } else {
-               tx_flags &= (~TX_CMD_FLG_ACK_MSK);
-               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
-       }
-
-       tx_cmd->sta_id = std_id;
-       if (ieee80211_has_morefrags(fc))
-               tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;
-
-       if (ieee80211_is_data_qos(fc)) {
-               u8 *qc = ieee80211_get_qos_ctl(hdr);
-               tx_cmd->tid_tspec = qc[0] & 0xf;
-               tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
-       } else {
-               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
-       }
-
-       il_tx_cmd_protection(il, info, fc, &tx_flags);
-
-       tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
-       if (ieee80211_is_mgmt(fc)) {
-               if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
-                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
-               else
-                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
-       } else {
-               tx_cmd->timeout.pm_frame_timeout = 0;
-       }
-
-       tx_cmd->driver_txop = 0;
-       tx_cmd->tx_flags = tx_flags;
-       tx_cmd->next_frame_len = 0;
-}
-
-/*
- * start C_TX command process
- */
-static int
-il3945_tx_skb(struct il_priv *il,
-             struct ieee80211_sta *sta,
-             struct sk_buff *skb)
-{
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-       struct il3945_tx_cmd *tx_cmd;
-       struct il_tx_queue *txq = NULL;
-       struct il_queue *q = NULL;
-       struct il_device_cmd *out_cmd;
-       struct il_cmd_meta *out_meta;
-       dma_addr_t phys_addr;
-       dma_addr_t txcmd_phys;
-       int txq_id = skb_get_queue_mapping(skb);
-       u16 len, idx, hdr_len;
-       u16 firstlen, secondlen;
-       u8 id;
-       u8 unicast;
-       u8 sta_id;
-       u8 tid = 0;
-       __le16 fc;
-       u8 wait_write_ptr = 0;
-       unsigned long flags;
-
-       spin_lock_irqsave(&il->lock, flags);
-       if (il_is_rfkill(il)) {
-               D_DROP("Dropping - RF KILL\n");
-               goto drop_unlock;
-       }
-
-       if ((ieee80211_get_tx_rate(il->hw, info)->hw_value & 0xFF) ==
-           IL_INVALID_RATE) {
-               IL_ERR("ERROR: No TX rate available.\n");
-               goto drop_unlock;
-       }
-
-       unicast = !is_multicast_ether_addr(hdr->addr1);
-       id = 0;
-
-       fc = hdr->frame_control;
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (ieee80211_is_auth(fc))
-               D_TX("Sending AUTH frame\n");
-       else if (ieee80211_is_assoc_req(fc))
-               D_TX("Sending ASSOC frame\n");
-       else if (ieee80211_is_reassoc_req(fc))
-               D_TX("Sending REASSOC frame\n");
-#endif
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       hdr_len = ieee80211_hdrlen(fc);
-
-       /* Find idx into station table for destination station */
-       sta_id = il_sta_id_or_broadcast(il, sta);
-       if (sta_id == IL_INVALID_STATION) {
-               D_DROP("Dropping - INVALID STATION: %pM\n", hdr->addr1);
-               goto drop;
-       }
-
-       D_RATE("station Id %d\n", sta_id);
-
-       if (ieee80211_is_data_qos(fc)) {
-               u8 *qc = ieee80211_get_qos_ctl(hdr);
-               tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
-               if (unlikely(tid >= MAX_TID_COUNT))
-                       goto drop;
-       }
-
-       /* Descriptor for chosen Tx queue */
-       txq = &il->txq[txq_id];
-       q = &txq->q;
-
-       if ((il_queue_space(q) < q->high_mark))
-               goto drop;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       idx = il_get_cmd_idx(q, q->write_ptr, 0);
-
-       txq->skbs[q->write_ptr] = skb;
-
-       /* Init first empty entry in queue's array of Tx/cmd buffers */
-       out_cmd = txq->cmd[idx];
-       out_meta = &txq->meta[idx];
-       tx_cmd = (struct il3945_tx_cmd *)out_cmd->cmd.payload;
-       memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
-       memset(tx_cmd, 0, sizeof(*tx_cmd));
-
-       /*
-        * Set up the Tx-command (not MAC!) header.
-        * Store the chosen Tx queue and TFD idx within the sequence field;
-        * after Tx, uCode's Tx response will return this value so driver can
-        * locate the frame within the tx queue and do post-tx processing.
-        */
-       out_cmd->hdr.cmd = C_TX;
-       out_cmd->hdr.sequence =
-           cpu_to_le16((u16)
-                       (QUEUE_TO_SEQ(txq_id) | IDX_TO_SEQ(q->write_ptr)));
-
-       /* Copy MAC header from skb into command buffer */
-       memcpy(tx_cmd->hdr, hdr, hdr_len);
-
-       if (info->control.hw_key)
-               il3945_build_tx_cmd_hwcrypto(il, info, out_cmd, skb, sta_id);
-
-       /* TODO need this for burst mode later on */
-       il3945_build_tx_cmd_basic(il, out_cmd, info, hdr, sta_id);
-
-       il3945_hw_build_tx_cmd_rate(il, out_cmd, info, hdr, sta_id);
-
-       /* Total # bytes to be transmitted */
-       tx_cmd->len = cpu_to_le16((u16) skb->len);
-
-       tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
-       tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
-
-       /*
-        * Use the first empty entry in this queue's command buffer array
-        * to contain the Tx command and MAC header concatenated together
-        * (payload data will be in another buffer).
-        * Size of this varies, due to varying MAC header length.
-        * If end is not dword aligned, we'll have 2 extra bytes at the end
-        * of the MAC header (device reads on dword boundaries).
-        * We'll tell device about this padding later.
-        */
-       len =
-           sizeof(struct il3945_tx_cmd) + sizeof(struct il_cmd_header) +
-           hdr_len;
-       firstlen = (len + 3) & ~3;
-
-       /* Physical address of this Tx command's header (not MAC header!),
-        * within command buffer array. */
-       txcmd_phys =
-           pci_map_single(il->pci_dev, &out_cmd->hdr, firstlen,
-                          PCI_DMA_TODEVICE);
-       if (unlikely(pci_dma_mapping_error(il->pci_dev, txcmd_phys)))
-               goto drop_unlock;
-
-       /* Set up TFD's 2nd entry to point directly to remainder of skb,
-        * if any (802.11 null frames have no payload). */
-       secondlen = skb->len - hdr_len;
-       if (secondlen > 0) {
-               phys_addr =
-                   pci_map_single(il->pci_dev, skb->data + hdr_len, secondlen,
-                                  PCI_DMA_TODEVICE);
-               if (unlikely(pci_dma_mapping_error(il->pci_dev, phys_addr)))
-                       goto drop_unlock;
-       }
-
-       /* Add buffer containing Tx command and MAC(!) header to TFD's
-        * first entry */
-       il->ops->txq_attach_buf_to_tfd(il, txq, txcmd_phys, firstlen, 1, 0);
-       dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
-       dma_unmap_len_set(out_meta, len, firstlen);
-       if (secondlen > 0)
-               il->ops->txq_attach_buf_to_tfd(il, txq, phys_addr, secondlen, 0,
-                                              U32_PAD(secondlen));
-
-       if (!ieee80211_has_morefrags(hdr->frame_control)) {
-               txq->need_update = 1;
-       } else {
-               wait_write_ptr = 1;
-               txq->need_update = 0;
-       }
-
-       il_update_stats(il, true, fc, skb->len);
-
-       D_TX("sequence nr = 0X%x\n", le16_to_cpu(out_cmd->hdr.sequence));
-       D_TX("tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
-       il_print_hex_dump(il, IL_DL_TX, tx_cmd, sizeof(*tx_cmd));
-       il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd->hdr,
-                         ieee80211_hdrlen(fc));
-
-       /* Tell device the write idx *just past* this latest filled TFD */
-       q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
-       il_txq_update_write_ptr(il, txq);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       if (il_queue_space(q) < q->high_mark && il->mac80211_registered) {
-               if (wait_write_ptr) {
-                       spin_lock_irqsave(&il->lock, flags);
-                       txq->need_update = 1;
-                       il_txq_update_write_ptr(il, txq);
-                       spin_unlock_irqrestore(&il->lock, flags);
-               }
-
-               il_stop_queue(il, txq);
-       }
-
-       return 0;
-
-drop_unlock:
-       spin_unlock_irqrestore(&il->lock, flags);
-drop:
-       return -1;
-}
-
-static int
-il3945_get_measurement(struct il_priv *il,
-                      struct ieee80211_measurement_params *params, u8 type)
-{
-       struct il_spectrum_cmd spectrum;
-       struct il_rx_pkt *pkt;
-       struct il_host_cmd cmd = {
-               .id = C_SPECTRUM_MEASUREMENT,
-               .data = (void *)&spectrum,
-               .flags = CMD_WANT_SKB,
-       };
-       u32 add_time = le64_to_cpu(params->start_time);
-       int rc;
-       int spectrum_resp_status;
-       int duration = le16_to_cpu(params->duration);
-
-       if (il_is_associated(il))
-               add_time =
-                   il_usecs_to_beacons(il,
-                                       le64_to_cpu(params->start_time) -
-                                       il->_3945.last_tsf,
-                                       le16_to_cpu(il->timing.beacon_interval));
-
-       memset(&spectrum, 0, sizeof(spectrum));
-
-       spectrum.channel_count = cpu_to_le16(1);
-       spectrum.flags =
-           RXON_FLG_TSF2HOST_MSK | RXON_FLG_ANT_A_MSK | RXON_FLG_DIS_DIV_MSK;
-       spectrum.filter_flags = MEASUREMENT_FILTER_FLAG;
-       cmd.len = sizeof(spectrum);
-       spectrum.len = cpu_to_le16(cmd.len - sizeof(spectrum.len));
-
-       if (il_is_associated(il))
-               spectrum.start_time =
-                   il_add_beacon_time(il, il->_3945.last_beacon_time, add_time,
-                                      le16_to_cpu(il->timing.beacon_interval));
-       else
-               spectrum.start_time = 0;
-
-       spectrum.channels[0].duration = cpu_to_le32(duration * TIME_UNIT);
-       spectrum.channels[0].channel = params->channel;
-       spectrum.channels[0].type = type;
-       if (il->active.flags & RXON_FLG_BAND_24G_MSK)
-               spectrum.flags |=
-                   RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK |
-                   RXON_FLG_TGG_PROTECT_MSK;
-
-       rc = il_send_cmd_sync(il, &cmd);
-       if (rc)
-               return rc;
-
-       pkt = (struct il_rx_pkt *)cmd.reply_page;
-       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
-               IL_ERR("Bad return from N_RX_ON_ASSOC command\n");
-               rc = -EIO;
-       }
-
-       spectrum_resp_status = le16_to_cpu(pkt->u.spectrum.status);
-       switch (spectrum_resp_status) {
-       case 0:         /* Command will be handled */
-               if (pkt->u.spectrum.id != 0xff) {
-                       D_INFO("Replaced existing measurement: %d\n",
-                              pkt->u.spectrum.id);
-                       il->measurement_status &= ~MEASUREMENT_READY;
-               }
-               il->measurement_status |= MEASUREMENT_ACTIVE;
-               rc = 0;
-               break;
-
-       case 1:         /* Command will not be handled */
-               rc = -EAGAIN;
-               break;
-       }
-
-       il_free_pages(il, cmd.reply_page);
-
-       return rc;
-}
-
-static void
-il3945_hdl_alive(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_alive_resp *palive;
-       struct delayed_work *pwork;
-
-       palive = &pkt->u.alive_frame;
-
-       D_INFO("Alive ucode status 0x%08X revision " "0x%01X 0x%01X\n",
-              palive->is_valid, palive->ver_type, palive->ver_subtype);
-
-       if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
-               D_INFO("Initialization Alive received.\n");
-               memcpy(&il->card_alive_init, &pkt->u.alive_frame,
-                      sizeof(struct il_alive_resp));
-               pwork = &il->init_alive_start;
-       } else {
-               D_INFO("Runtime Alive received.\n");
-               memcpy(&il->card_alive, &pkt->u.alive_frame,
-                      sizeof(struct il_alive_resp));
-               pwork = &il->alive_start;
-               il3945_disable_events(il);
-       }
-
-       /* We delay the ALIVE response by 5ms to
-        * give the HW RF Kill time to activate... */
-       if (palive->is_valid == UCODE_VALID_OK)
-               queue_delayed_work(il->workqueue, pwork, msecs_to_jiffies(5));
-       else
-               IL_WARN("uCode did not respond OK.\n");
-}
-
-static void
-il3945_hdl_add_sta(struct il_priv *il, struct il_rx_buf *rxb)
-{
-#ifdef CONFIG_IWLEGACY_DEBUG
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-#endif
-
-       D_RX("Received C_ADD_STA: 0x%02X\n", pkt->u.status);
-}
-
-static void
-il3945_hdl_beacon(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il3945_beacon_notif *beacon = &(pkt->u.beacon_status);
-#ifdef CONFIG_IWLEGACY_DEBUG
-       u8 rate = beacon->beacon_notify_hdr.rate;
-
-       D_RX("beacon status %x retries %d iss %d " "tsf %d %d rate %d\n",
-            le32_to_cpu(beacon->beacon_notify_hdr.status) & TX_STATUS_MSK,
-            beacon->beacon_notify_hdr.failure_frame,
-            le32_to_cpu(beacon->ibss_mgr_status),
-            le32_to_cpu(beacon->high_tsf), le32_to_cpu(beacon->low_tsf), rate);
-#endif
-
-       il->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
-
-}
-
-/* Handle notification from uCode that card's power state is changing
- * due to software, hardware, or critical temperature RFKILL */
-static void
-il3945_hdl_card_state(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
-       unsigned long status = il->status;
-
-       IL_WARN("Card state received: HW:%s SW:%s\n",
-               (flags & HW_CARD_DISABLED) ? "Kill" : "On",
-               (flags & SW_CARD_DISABLED) ? "Kill" : "On");
-
-       _il_wr(il, CSR_UCODE_DRV_GP1_SET, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
-
-       if (flags & HW_CARD_DISABLED)
-               set_bit(S_RFKILL, &il->status);
-       else
-               clear_bit(S_RFKILL, &il->status);
-
-       il_scan_cancel(il);
-
-       if ((test_bit(S_RFKILL, &status) !=
-            test_bit(S_RFKILL, &il->status)))
-               wiphy_rfkill_set_hw_state(il->hw->wiphy,
-                                         test_bit(S_RFKILL, &il->status));
-       else
-               wake_up(&il->wait_command_queue);
-}
-
-/**
- * il3945_setup_handlers - Initialize Rx handler callbacks
- *
- * Setup the RX handlers for each of the reply types sent from the uCode
- * to the host.
- *
- * This function chains into the hardware specific files for them to setup
- * any hardware specific handlers as well.
- */
-static void
-il3945_setup_handlers(struct il_priv *il)
-{
-       il->handlers[N_ALIVE] = il3945_hdl_alive;
-       il->handlers[C_ADD_STA] = il3945_hdl_add_sta;
-       il->handlers[N_ERROR] = il_hdl_error;
-       il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;
-       il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;
-       il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;
-       il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;
-       il->handlers[N_BEACON] = il3945_hdl_beacon;
-
-       /*
-        * The same handler is used for both the REPLY to a discrete
-        * stats request from the host as well as for the periodic
-        * stats notifications (after received beacons) from the uCode.
-        */
-       il->handlers[C_STATS] = il3945_hdl_c_stats;
-       il->handlers[N_STATS] = il3945_hdl_stats;
-
-       il_setup_rx_scan_handlers(il);
-       il->handlers[N_CARD_STATE] = il3945_hdl_card_state;
-
-       /* Set up hardware specific Rx handlers */
-       il3945_hw_handler_setup(il);
-}
-
-/************************** RX-FUNCTIONS ****************************/
-/*
- * Rx theory of operation
- *
- * The host allocates 32 DMA target addresses and passes the host address
- * to the firmware at register IL_RFDS_TBL_LOWER + N * RFD_SIZE where N is
- * 0 to 31
- *
- * Rx Queue Indexes
- * The host/firmware share two idx registers for managing the Rx buffers.
- *
- * The READ idx maps to the first position that the firmware may be writing
- * to -- the driver can read up to (but not including) this position and get
- * good data.
- * The READ idx is managed by the firmware once the card is enabled.
- *
- * The WRITE idx maps to the last position the driver has read from -- the
- * position preceding WRITE is the last slot the firmware can place a packet.
- *
- * The queue is empty (no good data) if WRITE = READ - 1, and is full if
- * WRITE = READ.
- *
- * During initialization, the host sets up the READ queue position to the first
- * IDX position, and WRITE to the last (READ - 1 wrapped)
- *
- * When the firmware places a packet in a buffer, it will advance the READ idx
- * and fire the RX interrupt.  The driver can then query the READ idx and
- * process as many packets as possible, moving the WRITE idx forward as it
- * resets the Rx queue buffers with new memory.
- *
- * The management in the driver is as follows:
- * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free.  When
- *   iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
- *   to replenish the iwl->rxq->rx_free.
- * + In il3945_rx_replenish (scheduled) if 'processed' != 'read' then the
- *   iwl->rxq is replenished and the READ IDX is updated (updating the
- *   'processed' and 'read' driver idxes as well)
- * + A received packet is processed and handed to the kernel network stack,
- *   detached from the iwl->rxq.  The driver 'processed' idx is updated.
- * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
- *   list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
- *   IDX is not incremented and iwl->status(RX_STALLED) is set.  If there
- *   were enough free buffers and RX_STALLED is set it is cleared.
- *
- *
- * Driver sequence:
- *
- * il3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
- *                            il3945_rx_queue_restock
- * il3945_rx_queue_restock() Moves available buffers from rx_free into Rx
- *                            queue, updates firmware pointers, and updates
- *                            the WRITE idx.  If insufficient rx_free buffers
- *                            are available, schedules il3945_rx_replenish
- *
- * -- enable interrupts --
- * ISR - il3945_rx()         Detach il_rx_bufs from pool up to the
- *                            READ IDX, detaching the SKB from the pool.
- *                            Moves the packet buffer from queue to rx_used.
- *                            Calls il3945_rx_queue_restock to refill any empty
- *                            slots.
- * ...
- *
- */
-
-/**
- * il3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
- */
-static inline __le32
-il3945_dma_addr2rbd_ptr(struct il_priv *il, dma_addr_t dma_addr)
-{
-       return cpu_to_le32((u32) dma_addr);
-}
-
-/**
- * il3945_rx_queue_restock - refill RX queue from pre-allocated pool
- *
- * If there are slots in the RX queue that need to be restocked,
- * and we have free pre-allocated buffers, fill the ranks as much
- * as we can, pulling from rx_free.
- *
- * This moves the 'write' idx forward to catch up with 'processed', and
- * also updates the memory address in the firmware to reference the new
- * target buffer.
- */
-static void
-il3945_rx_queue_restock(struct il_priv *il)
-{
-       struct il_rx_queue *rxq = &il->rxq;
-       struct list_head *element;
-       struct il_rx_buf *rxb;
-       unsigned long flags;
-       int write;
-
-       spin_lock_irqsave(&rxq->lock, flags);
-       write = rxq->write & ~0x7;
-       while (il_rx_queue_space(rxq) > 0 && rxq->free_count) {
-               /* Get next free Rx buffer, remove from free list */
-               element = rxq->rx_free.next;
-               rxb = list_entry(element, struct il_rx_buf, list);
-               list_del(element);
-
-               /* Point to Rx buffer via next RBD in circular buffer */
-               rxq->bd[rxq->write] =
-                   il3945_dma_addr2rbd_ptr(il, rxb->page_dma);
-               rxq->queue[rxq->write] = rxb;
-               rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
-               rxq->free_count--;
-       }
-       spin_unlock_irqrestore(&rxq->lock, flags);
-       /* If the pre-allocated buffer pool is dropping low, schedule to
-        * refill it */
-       if (rxq->free_count <= RX_LOW_WATERMARK)
-               queue_work(il->workqueue, &il->rx_replenish);
-
-       /* If we've added more space for the firmware to place data, tell it.
-        * Increment device's write pointer in multiples of 8. */
-       if (rxq->write_actual != (rxq->write & ~0x7) ||
-           abs(rxq->write - rxq->read) > 7) {
-               spin_lock_irqsave(&rxq->lock, flags);
-               rxq->need_update = 1;
-               spin_unlock_irqrestore(&rxq->lock, flags);
-               il_rx_queue_update_write_ptr(il, rxq);
-       }
-}
-
-/**
- * il3945_rx_replenish - Move all used packet from rx_used to rx_free
- *
- * When moving to rx_free an SKB is allocated for the slot.
- *
- * Also restock the Rx queue via il3945_rx_queue_restock.
- * This is called as a scheduled work item (except for during initialization)
- */
-static void
-il3945_rx_allocate(struct il_priv *il, gfp_t priority)
-{
-       struct il_rx_queue *rxq = &il->rxq;
-       struct list_head *element;
-       struct il_rx_buf *rxb;
-       struct page *page;
-       dma_addr_t page_dma;
-       unsigned long flags;
-       gfp_t gfp_mask = priority;
-
-       while (1) {
-               spin_lock_irqsave(&rxq->lock, flags);
-               if (list_empty(&rxq->rx_used)) {
-                       spin_unlock_irqrestore(&rxq->lock, flags);
-                       return;
-               }
-               spin_unlock_irqrestore(&rxq->lock, flags);
-
-               if (rxq->free_count > RX_LOW_WATERMARK)
-                       gfp_mask |= __GFP_NOWARN;
-
-               if (il->hw_params.rx_page_order > 0)
-                       gfp_mask |= __GFP_COMP;
-
-               /* Alloc a new receive buffer */
-               page = alloc_pages(gfp_mask, il->hw_params.rx_page_order);
-               if (!page) {
-                       if (net_ratelimit())
-                               D_INFO("Failed to allocate SKB buffer.\n");
-                       if (rxq->free_count <= RX_LOW_WATERMARK &&
-                           net_ratelimit())
-                               IL_ERR("Failed to allocate SKB buffer with %0x."
-                                      "Only %u free buffers remaining.\n",
-                                      priority, rxq->free_count);
-                       /* We don't reschedule replenish work here -- we will
-                        * call the restock method and if it still needs
-                        * more buffers it will schedule replenish */
-                       break;
-               }
-
-               /* Get physical address of RB/SKB */
-               page_dma =
-                   pci_map_page(il->pci_dev, page, 0,
-                                PAGE_SIZE << il->hw_params.rx_page_order,
-                                PCI_DMA_FROMDEVICE);
-
-               if (unlikely(pci_dma_mapping_error(il->pci_dev, page_dma))) {
-                       __free_pages(page, il->hw_params.rx_page_order);
-                       break;
-               }
-
-               spin_lock_irqsave(&rxq->lock, flags);
-
-               if (list_empty(&rxq->rx_used)) {
-                       spin_unlock_irqrestore(&rxq->lock, flags);
-                       pci_unmap_page(il->pci_dev, page_dma,
-                                      PAGE_SIZE << il->hw_params.rx_page_order,
-                                      PCI_DMA_FROMDEVICE);
-                       __free_pages(page, il->hw_params.rx_page_order);
-                       return;
-               }
-
-               element = rxq->rx_used.next;
-               rxb = list_entry(element, struct il_rx_buf, list);
-               list_del(element);
-
-               rxb->page = page;
-               rxb->page_dma = page_dma;
-               list_add_tail(&rxb->list, &rxq->rx_free);
-               rxq->free_count++;
-               il->alloc_rxb_page++;
-
-               spin_unlock_irqrestore(&rxq->lock, flags);
-       }
-}
-
-void
-il3945_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
-{
-       unsigned long flags;
-       int i;
-       spin_lock_irqsave(&rxq->lock, flags);
-       INIT_LIST_HEAD(&rxq->rx_free);
-       INIT_LIST_HEAD(&rxq->rx_used);
-       /* Fill the rx_used queue with _all_ of the Rx buffers */
-       for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
-               /* In the reset function, these buffers may have been allocated
-                * to an SKB, so we need to unmap and free potential storage */
-               if (rxq->pool[i].page != NULL) {
-                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
-                                      PAGE_SIZE << il->hw_params.rx_page_order,
-                                      PCI_DMA_FROMDEVICE);
-                       __il_free_pages(il, rxq->pool[i].page);
-                       rxq->pool[i].page = NULL;
-               }
-               list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
-       }
-
-       /* Set us so that we have processed and used all buffers, but have
-        * not restocked the Rx queue with fresh buffers */
-       rxq->read = rxq->write = 0;
-       rxq->write_actual = 0;
-       rxq->free_count = 0;
-       spin_unlock_irqrestore(&rxq->lock, flags);
-}
-
-void
-il3945_rx_replenish(void *data)
-{
-       struct il_priv *il = data;
-       unsigned long flags;
-
-       il3945_rx_allocate(il, GFP_KERNEL);
-
-       spin_lock_irqsave(&il->lock, flags);
-       il3945_rx_queue_restock(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-}
-
-static void
-il3945_rx_replenish_now(struct il_priv *il)
-{
-       il3945_rx_allocate(il, GFP_ATOMIC);
-
-       il3945_rx_queue_restock(il);
-}
-
-/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
- * If an SKB has been detached, the POOL needs to have its SKB set to NULL
- * This free routine walks the list of POOL entries and if SKB is set to
- * non NULL it is unmapped and freed
- */
-static void
-il3945_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
-{
-       int i;
-       for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
-               if (rxq->pool[i].page != NULL) {
-                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
-                                      PAGE_SIZE << il->hw_params.rx_page_order,
-                                      PCI_DMA_FROMDEVICE);
-                       __il_free_pages(il, rxq->pool[i].page);
-                       rxq->pool[i].page = NULL;
-               }
-       }
-
-       dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
-                         rxq->bd_dma);
-       dma_free_coherent(&il->pci_dev->dev, sizeof(struct il_rb_status),
-                         rxq->rb_stts, rxq->rb_stts_dma);
-       rxq->bd = NULL;
-       rxq->rb_stts = NULL;
-}
-
-/* Convert linear signal-to-noise ratio into dB */
-static u8 ratio2dB[100] = {
-/*      0   1   2   3   4   5   6   7   8   9 */
-       0, 0, 6, 10, 12, 14, 16, 17, 18, 19,    /* 00 - 09 */
-       20, 21, 22, 22, 23, 23, 24, 25, 26, 26, /* 10 - 19 */
-       26, 26, 26, 27, 27, 28, 28, 28, 29, 29, /* 20 - 29 */
-       29, 30, 30, 30, 31, 31, 31, 31, 32, 32, /* 30 - 39 */
-       32, 32, 32, 33, 33, 33, 33, 33, 34, 34, /* 40 - 49 */
-       34, 34, 34, 34, 35, 35, 35, 35, 35, 35, /* 50 - 59 */
-       36, 36, 36, 36, 36, 36, 36, 37, 37, 37, /* 60 - 69 */
-       37, 37, 37, 37, 37, 38, 38, 38, 38, 38, /* 70 - 79 */
-       38, 38, 38, 38, 38, 39, 39, 39, 39, 39, /* 80 - 89 */
-       39, 39, 39, 39, 39, 40, 40, 40, 40, 40  /* 90 - 99 */
-};
-
-/* Calculates a relative dB value from a ratio of linear
- *   (i.e. not dB) signal levels.
- * Conversion assumes that levels are voltages (20*log), not powers (10*log). */
-int
-il3945_calc_db_from_ratio(int sig_ratio)
-{
-       /* 1000:1 or higher just report as 60 dB */
-       if (sig_ratio >= 1000)
-               return 60;
-
-       /* 100:1 or higher, divide by 10 and use table,
-        *   add 20 dB to make up for divide by 10 */
-       if (sig_ratio >= 100)
-               return 20 + (int)ratio2dB[sig_ratio / 10];
-
-       /* We shouldn't see this */
-       if (sig_ratio < 1)
-               return 0;
-
-       /* Use table for ratios 1:1 - 99:1 */
-       return (int)ratio2dB[sig_ratio];
-}
-
-/**
- * il3945_rx_handle - Main entry function for receiving responses from uCode
- *
- * Uses the il->handlers callback function array to invoke
- * the appropriate handlers, including command responses,
- * frame-received notifications, and other notifications.
- */
-static void
-il3945_rx_handle(struct il_priv *il)
-{
-       struct il_rx_buf *rxb;
-       struct il_rx_pkt *pkt;
-       struct il_rx_queue *rxq = &il->rxq;
-       u32 r, i;
-       int reclaim;
-       unsigned long flags;
-       u8 fill_rx = 0;
-       u32 count = 8;
-       int total_empty = 0;
-
-       /* uCode's read idx (stored in shared DRAM) indicates the last Rx
-        * buffer that the driver may process (last buffer filled by ucode). */
-       r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
-       i = rxq->read;
-
-       /* calculate total frames need to be restock after handling RX */
-       total_empty = r - rxq->write_actual;
-       if (total_empty < 0)
-               total_empty += RX_QUEUE_SIZE;
-
-       if (total_empty > (RX_QUEUE_SIZE / 2))
-               fill_rx = 1;
-       /* Rx interrupt, but nothing sent from uCode */
-       if (i == r)
-               D_RX("r = %d, i = %d\n", r, i);
-
-       while (i != r) {
-               int len;
-
-               rxb = rxq->queue[i];
-
-               /* If an RXB doesn't have a Rx queue slot associated with it,
-                * then a bug has been introduced in the queue refilling
-                * routines -- catch it here */
-               BUG_ON(rxb == NULL);
-
-               rxq->queue[i] = NULL;
-
-               pci_unmap_page(il->pci_dev, rxb->page_dma,
-                              PAGE_SIZE << il->hw_params.rx_page_order,
-                              PCI_DMA_FROMDEVICE);
-               pkt = rxb_addr(rxb);
-
-               len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
-               len += sizeof(u32);     /* account for status word */
-
-               reclaim = il_need_reclaim(il, pkt);
-
-               /* Based on type of command response or notification,
-                *   handle those that need handling via function in
-                *   handlers table.  See il3945_setup_handlers() */
-               if (il->handlers[pkt->hdr.cmd]) {
-                       D_RX("r = %d, i = %d, %s, 0x%02x\n", r, i,
-                            il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
-                       il->isr_stats.handlers[pkt->hdr.cmd]++;
-                       il->handlers[pkt->hdr.cmd] (il, rxb);
-               } else {
-                       /* No handling needed */
-                       D_RX("r %d i %d No handler needed for %s, 0x%02x\n", r,
-                            i, il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
-               }
-
-               /*
-                * XXX: After here, we should always check rxb->page
-                * against NULL before touching it or its virtual
-                * memory (pkt). Because some handler might have
-                * already taken or freed the pages.
-                */
-
-               if (reclaim) {
-                       /* Invoke any callbacks, transfer the buffer to caller,
-                        * and fire off the (possibly) blocking il_send_cmd()
-                        * as we reclaim the driver command queue */
-                       if (rxb->page)
-                               il_tx_cmd_complete(il, rxb);
-                       else
-                               IL_WARN("Claim null rxb?\n");
-               }
-
-               /* Reuse the page if possible. For notification packets and
-                * SKBs that fail to Rx correctly, add them back into the
-                * rx_free list for reuse later. */
-               spin_lock_irqsave(&rxq->lock, flags);
-               if (rxb->page != NULL) {
-                       rxb->page_dma =
-                           pci_map_page(il->pci_dev, rxb->page, 0,
-                                        PAGE_SIZE << il->hw_params.
-                                        rx_page_order, PCI_DMA_FROMDEVICE);
-                       if (unlikely(pci_dma_mapping_error(il->pci_dev,
-                                                          rxb->page_dma))) {
-                               __il_free_pages(il, rxb->page);
-                               rxb->page = NULL;
-                               list_add_tail(&rxb->list, &rxq->rx_used);
-                       } else {
-                               list_add_tail(&rxb->list, &rxq->rx_free);
-                               rxq->free_count++;
-                       }
-               } else
-                       list_add_tail(&rxb->list, &rxq->rx_used);
-
-               spin_unlock_irqrestore(&rxq->lock, flags);
-
-               i = (i + 1) & RX_QUEUE_MASK;
-               /* If there are a lot of unused frames,
-                * restock the Rx queue so ucode won't assert. */
-               if (fill_rx) {
-                       count++;
-                       if (count >= 8) {
-                               rxq->read = i;
-                               il3945_rx_replenish_now(il);
-                               count = 0;
-                       }
-               }
-       }
-
-       /* Backtrack one entry */
-       rxq->read = i;
-       if (fill_rx)
-               il3945_rx_replenish_now(il);
-       else
-               il3945_rx_queue_restock(il);
-}
-
-/* call this function to flush any scheduled tasklet */
-static inline void
-il3945_synchronize_irq(struct il_priv *il)
-{
-       /* wait to make sure we flush pending tasklet */
-       synchronize_irq(il->pci_dev->irq);
-       tasklet_kill(&il->irq_tasklet);
-}
-
-static const char *
-il3945_desc_lookup(int i)
-{
-       switch (i) {
-       case 1:
-               return "FAIL";
-       case 2:
-               return "BAD_PARAM";
-       case 3:
-               return "BAD_CHECKSUM";
-       case 4:
-               return "NMI_INTERRUPT";
-       case 5:
-               return "SYSASSERT";
-       case 6:
-               return "FATAL_ERROR";
-       }
-
-       return "UNKNOWN";
-}
-
-#define ERROR_START_OFFSET  (1 * sizeof(u32))
-#define ERROR_ELEM_SIZE     (7 * sizeof(u32))
-
-void
-il3945_dump_nic_error_log(struct il_priv *il)
-{
-       u32 i;
-       u32 desc, time, count, base, data1;
-       u32 blink1, blink2, ilink1, ilink2;
-
-       base = le32_to_cpu(il->card_alive.error_event_table_ptr);
-
-       if (!il3945_hw_valid_rtc_data_addr(base)) {
-               IL_ERR("Not valid error log pointer 0x%08X\n", base);
-               return;
-       }
-
-       count = il_read_targ_mem(il, base);
-
-       if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
-               IL_ERR("Start IWL Error Log Dump:\n");
-               IL_ERR("Status: 0x%08lX, count: %d\n", il->status, count);
-       }
-
-       IL_ERR("Desc       Time       asrtPC  blink2 "
-              "ilink1  nmiPC   Line\n");
-       for (i = ERROR_START_OFFSET;
-            i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
-            i += ERROR_ELEM_SIZE) {
-               desc = il_read_targ_mem(il, base + i);
-               time = il_read_targ_mem(il, base + i + 1 * sizeof(u32));
-               blink1 = il_read_targ_mem(il, base + i + 2 * sizeof(u32));
-               blink2 = il_read_targ_mem(il, base + i + 3 * sizeof(u32));
-               ilink1 = il_read_targ_mem(il, base + i + 4 * sizeof(u32));
-               ilink2 = il_read_targ_mem(il, base + i + 5 * sizeof(u32));
-               data1 = il_read_targ_mem(il, base + i + 6 * sizeof(u32));
-
-               IL_ERR("%-13s (0x%X) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
-                      il3945_desc_lookup(desc), desc, time, blink1, blink2,
-                      ilink1, ilink2, data1);
-       }
-}
-
-static void
-il3945_irq_tasklet(struct il_priv *il)
-{
-       u32 inta, handled = 0;
-       u32 inta_fh;
-       unsigned long flags;
-#ifdef CONFIG_IWLEGACY_DEBUG
-       u32 inta_mask;
-#endif
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Ack/clear/reset pending uCode interrupts.
-        * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
-        *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
-       inta = _il_rd(il, CSR_INT);
-       _il_wr(il, CSR_INT, inta);
-
-       /* Ack/clear/reset pending flow-handler (DMA) interrupts.
-        * Any new interrupts that happen after this, either while we're
-        * in this tasklet, or later, will show up in next ISR/tasklet. */
-       inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
-       _il_wr(il, CSR_FH_INT_STATUS, inta_fh);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (il_get_debug_level(il) & IL_DL_ISR) {
-               /* just for debug */
-               inta_mask = _il_rd(il, CSR_INT_MASK);
-               D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta,
-                     inta_mask, inta_fh);
-       }
-#endif
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       /* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
-        * atomic, make sure that inta covers all the interrupts that
-        * we've discovered, even if FH interrupt came in just after
-        * reading CSR_INT. */
-       if (inta_fh & CSR39_FH_INT_RX_MASK)
-               inta |= CSR_INT_BIT_FH_RX;
-       if (inta_fh & CSR39_FH_INT_TX_MASK)
-               inta |= CSR_INT_BIT_FH_TX;
-
-       /* Now service all interrupt bits discovered above. */
-       if (inta & CSR_INT_BIT_HW_ERR) {
-               IL_ERR("Hardware error detected.  Restarting.\n");
-
-               /* Tell the device to stop sending interrupts */
-               il_disable_interrupts(il);
-
-               il->isr_stats.hw++;
-               il_irq_handle_error(il);
-
-               handled |= CSR_INT_BIT_HW_ERR;
-
-               return;
-       }
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (il_get_debug_level(il) & (IL_DL_ISR)) {
-               /* NIC fires this, but we don't use it, redundant with WAKEUP */
-               if (inta & CSR_INT_BIT_SCD) {
-                       D_ISR("Scheduler finished to transmit "
-                             "the frame/frames.\n");
-                       il->isr_stats.sch++;
-               }
-
-               /* Alive notification via Rx interrupt will do the real work */
-               if (inta & CSR_INT_BIT_ALIVE) {
-                       D_ISR("Alive interrupt\n");
-                       il->isr_stats.alive++;
-               }
-       }
-#endif
-       /* Safely ignore these bits for debug checks below */
-       inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
-
-       /* Error detected by uCode */
-       if (inta & CSR_INT_BIT_SW_ERR) {
-               IL_ERR("Microcode SW error detected. " "Restarting 0x%X.\n",
-                      inta);
-               il->isr_stats.sw++;
-               il_irq_handle_error(il);
-               handled |= CSR_INT_BIT_SW_ERR;
-       }
-
-       /* uCode wakes up after power-down sleep */
-       if (inta & CSR_INT_BIT_WAKEUP) {
-               D_ISR("Wakeup interrupt\n");
-               il_rx_queue_update_write_ptr(il, &il->rxq);
-
-               spin_lock_irqsave(&il->lock, flags);
-               il_txq_update_write_ptr(il, &il->txq[0]);
-               il_txq_update_write_ptr(il, &il->txq[1]);
-               il_txq_update_write_ptr(il, &il->txq[2]);
-               il_txq_update_write_ptr(il, &il->txq[3]);
-               il_txq_update_write_ptr(il, &il->txq[4]);
-               spin_unlock_irqrestore(&il->lock, flags);
-
-               il->isr_stats.wakeup++;
-               handled |= CSR_INT_BIT_WAKEUP;
-       }
-
-       /* All uCode command responses, including Tx command responses,
-        * Rx "responses" (frame-received notification), and other
-        * notifications from uCode come through here*/
-       if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
-               il3945_rx_handle(il);
-               il->isr_stats.rx++;
-               handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
-       }
-
-       if (inta & CSR_INT_BIT_FH_TX) {
-               D_ISR("Tx interrupt\n");
-               il->isr_stats.tx++;
-
-               _il_wr(il, CSR_FH_INT_STATUS, (1 << 6));
-               il_wr(il, FH39_TCSR_CREDIT(FH39_SRVC_CHNL), 0x0);
-               handled |= CSR_INT_BIT_FH_TX;
-       }
-
-       if (inta & ~handled) {
-               IL_ERR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
-               il->isr_stats.unhandled++;
-       }
-
-       if (inta & ~il->inta_mask) {
-               IL_WARN("Disabled INTA bits 0x%08x were pending\n",
-                       inta & ~il->inta_mask);
-               IL_WARN("   with inta_fh = 0x%08x\n", inta_fh);
-       }
-
-       /* Re-enable all interrupts */
-       /* only Re-enable if disabled by irq */
-       if (test_bit(S_INT_ENABLED, &il->status))
-               il_enable_interrupts(il);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (il_get_debug_level(il) & (IL_DL_ISR)) {
-               inta = _il_rd(il, CSR_INT);
-               inta_mask = _il_rd(il, CSR_INT_MASK);
-               inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
-               D_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
-                     "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
-       }
-#endif
-}
-
-static int
-il3945_get_channels_for_scan(struct il_priv *il, enum ieee80211_band band,
-                            u8 is_active, u8 n_probes,
-                            struct il3945_scan_channel *scan_ch,
-                            struct ieee80211_vif *vif)
-{
-       struct ieee80211_channel *chan;
-       const struct ieee80211_supported_band *sband;
-       const struct il_channel_info *ch_info;
-       u16 passive_dwell = 0;
-       u16 active_dwell = 0;
-       int added, i;
-
-       sband = il_get_hw_mode(il, band);
-       if (!sband)
-               return 0;
-
-       active_dwell = il_get_active_dwell_time(il, band, n_probes);
-       passive_dwell = il_get_passive_dwell_time(il, band, vif);
-
-       if (passive_dwell <= active_dwell)
-               passive_dwell = active_dwell + 1;
-
-       for (i = 0, added = 0; i < il->scan_request->n_channels; i++) {
-               chan = il->scan_request->channels[i];
-
-               if (chan->band != band)
-                       continue;
-
-               scan_ch->channel = chan->hw_value;
-
-               ch_info = il_get_channel_info(il, band, scan_ch->channel);
-               if (!il_is_channel_valid(ch_info)) {
-                       D_SCAN("Channel %d is INVALID for this band.\n",
-                              scan_ch->channel);
-                       continue;
-               }
-
-               scan_ch->active_dwell = cpu_to_le16(active_dwell);
-               scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
-               /* If passive , set up for auto-switch
-                *  and use long active_dwell time.
-                */
-               if (!is_active || il_is_channel_passive(ch_info) ||
-                   (chan->flags & IEEE80211_CHAN_NO_IR)) {
-                       scan_ch->type = 0;      /* passive */
-                       if (IL_UCODE_API(il->ucode_ver) == 1)
-                               scan_ch->active_dwell =
-                                   cpu_to_le16(passive_dwell - 1);
-               } else {
-                       scan_ch->type = 1;      /* active */
-               }
-
-               /* Set direct probe bits. These may be used both for active
-                * scan channels (probes gets sent right away),
-                * or for passive channels (probes get se sent only after
-                * hearing clear Rx packet).*/
-               if (IL_UCODE_API(il->ucode_ver) >= 2) {
-                       if (n_probes)
-                               scan_ch->type |= IL39_SCAN_PROBE_MASK(n_probes);
-               } else {
-                       /* uCode v1 does not allow setting direct probe bits on
-                        * passive channel. */
-                       if ((scan_ch->type & 1) && n_probes)
-                               scan_ch->type |= IL39_SCAN_PROBE_MASK(n_probes);
-               }
-
-               /* Set txpower levels to defaults */
-               scan_ch->tpc.dsp_atten = 110;
-               /* scan_pwr_info->tpc.dsp_atten; */
-
-               /*scan_pwr_info->tpc.tx_gain; */
-               if (band == IEEE80211_BAND_5GHZ)
-                       scan_ch->tpc.tx_gain = ((1 << 5) | (3 << 3)) | 3;
-               else {
-                       scan_ch->tpc.tx_gain = ((1 << 5) | (5 << 3));
-                       /* NOTE: if we were doing 6Mb OFDM for scans we'd use
-                        * power level:
-                        * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
-                        */
-               }
-
-               D_SCAN("Scanning %d [%s %d]\n", scan_ch->channel,
-                      (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
-                      (scan_ch->type & 1) ? active_dwell : passive_dwell);
-
-               scan_ch++;
-               added++;
-       }
-
-       D_SCAN("total channels to scan %d\n", added);
-       return added;
-}
-
-static void
-il3945_init_hw_rates(struct il_priv *il, struct ieee80211_rate *rates)
-{
-       int i;
-
-       for (i = 0; i < RATE_COUNT_LEGACY; i++) {
-               rates[i].bitrate = il3945_rates[i].ieee * 5;
-               rates[i].hw_value = i;  /* Rate scaling will work on idxes */
-               rates[i].hw_value_short = i;
-               rates[i].flags = 0;
-               if (i > IL39_LAST_OFDM_RATE || i < IL_FIRST_OFDM_RATE) {
-                       /*
-                        * If CCK != 1M then set short preamble rate flag.
-                        */
-                       rates[i].flags |=
-                           (il3945_rates[i].plcp ==
-                            10) ? 0 : IEEE80211_RATE_SHORT_PREAMBLE;
-               }
-       }
-}
-
-/******************************************************************************
- *
- * uCode download functions
- *
- ******************************************************************************/
-
-static void
-il3945_dealloc_ucode_pci(struct il_priv *il)
-{
-       il_free_fw_desc(il->pci_dev, &il->ucode_code);
-       il_free_fw_desc(il->pci_dev, &il->ucode_data);
-       il_free_fw_desc(il->pci_dev, &il->ucode_data_backup);
-       il_free_fw_desc(il->pci_dev, &il->ucode_init);
-       il_free_fw_desc(il->pci_dev, &il->ucode_init_data);
-       il_free_fw_desc(il->pci_dev, &il->ucode_boot);
-}
-
-/**
- * il3945_verify_inst_full - verify runtime uCode image in card vs. host,
- *     looking at all data.
- */
-static int
-il3945_verify_inst_full(struct il_priv *il, __le32 * image, u32 len)
-{
-       u32 val;
-       u32 save_len = len;
-       int rc = 0;
-       u32 errcnt;
-
-       D_INFO("ucode inst image size is %u\n", len);
-
-       il_wr(il, HBUS_TARG_MEM_RADDR, IL39_RTC_INST_LOWER_BOUND);
-
-       errcnt = 0;
-       for (; len > 0; len -= sizeof(u32), image++) {
-               /* read data comes through single port, auto-incr addr */
-               /* NOTE: Use the debugless read so we don't flood kernel log
-                * if IL_DL_IO is set */
-               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
-               if (val != le32_to_cpu(*image)) {
-                       IL_ERR("uCode INST section is invalid at "
-                              "offset 0x%x, is 0x%x, s/b 0x%x\n",
-                              save_len - len, val, le32_to_cpu(*image));
-                       rc = -EIO;
-                       errcnt++;
-                       if (errcnt >= 20)
-                               break;
-               }
-       }
-
-       if (!errcnt)
-               D_INFO("ucode image in INSTRUCTION memory is good\n");
-
-       return rc;
-}
-
-/**
- * il3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
- *   using sample data 100 bytes apart.  If these sample points are good,
- *   it's a pretty good bet that everything between them is good, too.
- */
-static int
-il3945_verify_inst_sparse(struct il_priv *il, __le32 * image, u32 len)
-{
-       u32 val;
-       int rc = 0;
-       u32 errcnt = 0;
-       u32 i;
-
-       D_INFO("ucode inst image size is %u\n", len);
-
-       for (i = 0; i < len; i += 100, image += 100 / sizeof(u32)) {
-               /* read data comes through single port, auto-incr addr */
-               /* NOTE: Use the debugless read so we don't flood kernel log
-                * if IL_DL_IO is set */
-               il_wr(il, HBUS_TARG_MEM_RADDR, i + IL39_RTC_INST_LOWER_BOUND);
-               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
-               if (val != le32_to_cpu(*image)) {
-#if 0                          /* Enable this if you want to see details */
-                       IL_ERR("uCode INST section is invalid at "
-                              "offset 0x%x, is 0x%x, s/b 0x%x\n", i, val,
-                              *image);
-#endif
-                       rc = -EIO;
-                       errcnt++;
-                       if (errcnt >= 3)
-                               break;
-               }
-       }
-
-       return rc;
-}
-
-/**
- * il3945_verify_ucode - determine which instruction image is in SRAM,
- *    and verify its contents
- */
-static int
-il3945_verify_ucode(struct il_priv *il)
-{
-       __le32 *image;
-       u32 len;
-       int rc = 0;
-
-       /* Try bootstrap */
-       image = (__le32 *) il->ucode_boot.v_addr;
-       len = il->ucode_boot.len;
-       rc = il3945_verify_inst_sparse(il, image, len);
-       if (rc == 0) {
-               D_INFO("Bootstrap uCode is good in inst SRAM\n");
-               return 0;
-       }
-
-       /* Try initialize */
-       image = (__le32 *) il->ucode_init.v_addr;
-       len = il->ucode_init.len;
-       rc = il3945_verify_inst_sparse(il, image, len);
-       if (rc == 0) {
-               D_INFO("Initialize uCode is good in inst SRAM\n");
-               return 0;
-       }
-
-       /* Try runtime/protocol */
-       image = (__le32 *) il->ucode_code.v_addr;
-       len = il->ucode_code.len;
-       rc = il3945_verify_inst_sparse(il, image, len);
-       if (rc == 0) {
-               D_INFO("Runtime uCode is good in inst SRAM\n");
-               return 0;
-       }
-
-       IL_ERR("NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");
-
-       /* Since nothing seems to match, show first several data entries in
-        * instruction SRAM, so maybe visual inspection will give a clue.
-        * Selection of bootstrap image (vs. other images) is arbitrary. */
-       image = (__le32 *) il->ucode_boot.v_addr;
-       len = il->ucode_boot.len;
-       rc = il3945_verify_inst_full(il, image, len);
-
-       return rc;
-}
-
-static void
-il3945_nic_start(struct il_priv *il)
-{
-       /* Remove all resets to allow NIC to operate */
-       _il_wr(il, CSR_RESET, 0);
-}
-
-#define IL3945_UCODE_GET(item)                                         \
-static u32 il3945_ucode_get_##item(const struct il_ucode_header *ucode)\
-{                                                                      \
-       return le32_to_cpu(ucode->v1.item);                             \
-}
-
-static u32
-il3945_ucode_get_header_size(u32 api_ver)
-{
-       return 24;
-}
-
-static u8 *
-il3945_ucode_get_data(const struct il_ucode_header *ucode)
-{
-       return (u8 *) ucode->v1.data;
-}
-
-IL3945_UCODE_GET(inst_size);
-IL3945_UCODE_GET(data_size);
-IL3945_UCODE_GET(init_size);
-IL3945_UCODE_GET(init_data_size);
-IL3945_UCODE_GET(boot_size);
-
-/**
- * il3945_read_ucode - Read uCode images from disk file.
- *
- * Copy into buffers for card to fetch via bus-mastering
- */
-static int
-il3945_read_ucode(struct il_priv *il)
-{
-       const struct il_ucode_header *ucode;
-       int ret = -EINVAL, idx;
-       const struct firmware *ucode_raw;
-       /* firmware file name contains uCode/driver compatibility version */
-       const char *name_pre = il->cfg->fw_name_pre;
-       const unsigned int api_max = il->cfg->ucode_api_max;
-       const unsigned int api_min = il->cfg->ucode_api_min;
-       char buf[25];
-       u8 *src;
-       size_t len;
-       u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
-
-       /* Ask kernel firmware_class module to get the boot firmware off disk.
-        * request_firmware() is synchronous, file is in memory on return. */
-       for (idx = api_max; idx >= api_min; idx--) {
-               sprintf(buf, "%s%u%s", name_pre, idx, ".ucode");
-               ret = request_firmware(&ucode_raw, buf, &il->pci_dev->dev);
-               if (ret < 0) {
-                       IL_ERR("%s firmware file req failed: %d\n", buf, ret);
-                       if (ret == -ENOENT)
-                               continue;
-                       else
-                               goto error;
-               } else {
-                       if (idx < api_max)
-                               IL_ERR("Loaded firmware %s, "
-                                      "which is deprecated. "
-                                      " Please use API v%u instead.\n", buf,
-                                      api_max);
-                       D_INFO("Got firmware '%s' file "
-                              "(%zd bytes) from disk\n", buf, ucode_raw->size);
-                       break;
-               }
-       }
-
-       if (ret < 0)
-               goto error;
-
-       /* Make sure that we got at least our header! */
-       if (ucode_raw->size < il3945_ucode_get_header_size(1)) {
-               IL_ERR("File size way too small!\n");
-               ret = -EINVAL;
-               goto err_release;
-       }
-
-       /* Data from ucode file:  header followed by uCode images */
-       ucode = (struct il_ucode_header *)ucode_raw->data;
-
-       il->ucode_ver = le32_to_cpu(ucode->ver);
-       api_ver = IL_UCODE_API(il->ucode_ver);
-       inst_size = il3945_ucode_get_inst_size(ucode);
-       data_size = il3945_ucode_get_data_size(ucode);
-       init_size = il3945_ucode_get_init_size(ucode);
-       init_data_size = il3945_ucode_get_init_data_size(ucode);
-       boot_size = il3945_ucode_get_boot_size(ucode);
-       src = il3945_ucode_get_data(ucode);
-
-       /* api_ver should match the api version forming part of the
-        * firmware filename ... but we don't check for that and only rely
-        * on the API version read from firmware header from here on forward */
-
-       if (api_ver < api_min || api_ver > api_max) {
-               IL_ERR("Driver unable to support your firmware API. "
-                      "Driver supports v%u, firmware is v%u.\n", api_max,
-                      api_ver);
-               il->ucode_ver = 0;
-               ret = -EINVAL;
-               goto err_release;
-       }
-       if (api_ver != api_max)
-               IL_ERR("Firmware has old API version. Expected %u, "
-                      "got %u. New firmware can be obtained "
-                      "from http://www.intellinuxwireless.org.\n", api_max,
-                      api_ver);
-
-       IL_INFO("loaded firmware version %u.%u.%u.%u\n",
-               IL_UCODE_MAJOR(il->ucode_ver), IL_UCODE_MINOR(il->ucode_ver),
-               IL_UCODE_API(il->ucode_ver), IL_UCODE_SERIAL(il->ucode_ver));
-
-       snprintf(il->hw->wiphy->fw_version, sizeof(il->hw->wiphy->fw_version),
-                "%u.%u.%u.%u", IL_UCODE_MAJOR(il->ucode_ver),
-                IL_UCODE_MINOR(il->ucode_ver), IL_UCODE_API(il->ucode_ver),
-                IL_UCODE_SERIAL(il->ucode_ver));
-
-       D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver);
-       D_INFO("f/w package hdr runtime inst size = %u\n", inst_size);
-       D_INFO("f/w package hdr runtime data size = %u\n", data_size);
-       D_INFO("f/w package hdr init inst size = %u\n", init_size);
-       D_INFO("f/w package hdr init data size = %u\n", init_data_size);
-       D_INFO("f/w package hdr boot inst size = %u\n", boot_size);
-
-       /* Verify size of file vs. image size info in file's header */
-       if (ucode_raw->size !=
-           il3945_ucode_get_header_size(api_ver) + inst_size + data_size +
-           init_size + init_data_size + boot_size) {
-
-               D_INFO("uCode file size %zd does not match expected size\n",
-                      ucode_raw->size);
-               ret = -EINVAL;
-               goto err_release;
-       }
-
-       /* Verify that uCode images will fit in card's SRAM */
-       if (inst_size > IL39_MAX_INST_SIZE) {
-               D_INFO("uCode instr len %d too large to fit in\n", inst_size);
-               ret = -EINVAL;
-               goto err_release;
-       }
-
-       if (data_size > IL39_MAX_DATA_SIZE) {
-               D_INFO("uCode data len %d too large to fit in\n", data_size);
-               ret = -EINVAL;
-               goto err_release;
-       }
-       if (init_size > IL39_MAX_INST_SIZE) {
-               D_INFO("uCode init instr len %d too large to fit in\n",
-                      init_size);
-               ret = -EINVAL;
-               goto err_release;
-       }
-       if (init_data_size > IL39_MAX_DATA_SIZE) {
-               D_INFO("uCode init data len %d too large to fit in\n",
-                      init_data_size);
-               ret = -EINVAL;
-               goto err_release;
-       }
-       if (boot_size > IL39_MAX_BSM_SIZE) {
-               D_INFO("uCode boot instr len %d too large to fit in\n",
-                      boot_size);
-               ret = -EINVAL;
-               goto err_release;
-       }
-
-       /* Allocate ucode buffers for card's bus-master loading ... */
-
-       /* Runtime instructions and 2 copies of data:
-        * 1) unmodified from disk
-        * 2) backup cache for save/restore during power-downs */
-       il->ucode_code.len = inst_size;
-       il_alloc_fw_desc(il->pci_dev, &il->ucode_code);
-
-       il->ucode_data.len = data_size;
-       il_alloc_fw_desc(il->pci_dev, &il->ucode_data);
-
-       il->ucode_data_backup.len = data_size;
-       il_alloc_fw_desc(il->pci_dev, &il->ucode_data_backup);
-
-       if (!il->ucode_code.v_addr || !il->ucode_data.v_addr ||
-           !il->ucode_data_backup.v_addr)
-               goto err_pci_alloc;
-
-       /* Initialization instructions and data */
-       if (init_size && init_data_size) {
-               il->ucode_init.len = init_size;
-               il_alloc_fw_desc(il->pci_dev, &il->ucode_init);
-
-               il->ucode_init_data.len = init_data_size;
-               il_alloc_fw_desc(il->pci_dev, &il->ucode_init_data);
-
-               if (!il->ucode_init.v_addr || !il->ucode_init_data.v_addr)
-                       goto err_pci_alloc;
-       }
-
-       /* Bootstrap (instructions only, no data) */
-       if (boot_size) {
-               il->ucode_boot.len = boot_size;
-               il_alloc_fw_desc(il->pci_dev, &il->ucode_boot);
-
-               if (!il->ucode_boot.v_addr)
-                       goto err_pci_alloc;
-       }
-
-       /* Copy images into buffers for card's bus-master reads ... */
-
-       /* Runtime instructions (first block of data in file) */
-       len = inst_size;
-       D_INFO("Copying (but not loading) uCode instr len %zd\n", len);
-       memcpy(il->ucode_code.v_addr, src, len);
-       src += len;
-
-       D_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
-              il->ucode_code.v_addr, (u32) il->ucode_code.p_addr);
-
-       /* Runtime data (2nd block)
-        * NOTE:  Copy into backup buffer will be done in il3945_up()  */
-       len = data_size;
-       D_INFO("Copying (but not loading) uCode data len %zd\n", len);
-       memcpy(il->ucode_data.v_addr, src, len);
-       memcpy(il->ucode_data_backup.v_addr, src, len);
-       src += len;
-
-       /* Initialization instructions (3rd block) */
-       if (init_size) {
-               len = init_size;
-               D_INFO("Copying (but not loading) init instr len %zd\n", len);
-               memcpy(il->ucode_init.v_addr, src, len);
-               src += len;
-       }
-
-       /* Initialization data (4th block) */
-       if (init_data_size) {
-               len = init_data_size;
-               D_INFO("Copying (but not loading) init data len %zd\n", len);
-               memcpy(il->ucode_init_data.v_addr, src, len);
-               src += len;
-       }
-
-       /* Bootstrap instructions (5th block) */
-       len = boot_size;
-       D_INFO("Copying (but not loading) boot instr len %zd\n", len);
-       memcpy(il->ucode_boot.v_addr, src, len);
-
-       /* We have our copies now, allow OS release its copies */
-       release_firmware(ucode_raw);
-       return 0;
-
-err_pci_alloc:
-       IL_ERR("failed to allocate pci memory\n");
-       ret = -ENOMEM;
-       il3945_dealloc_ucode_pci(il);
-
-err_release:
-       release_firmware(ucode_raw);
-
-error:
-       return ret;
-}
-
-/**
- * il3945_set_ucode_ptrs - Set uCode address location
- *
- * Tell initialization uCode where to find runtime uCode.
- *
- * BSM registers initially contain pointers to initialization uCode.
- * We need to replace them to load runtime uCode inst and data,
- * and to save runtime data when powering down.
- */
-static int
-il3945_set_ucode_ptrs(struct il_priv *il)
-{
-       dma_addr_t pinst;
-       dma_addr_t pdata;
-
-       /* bits 31:0 for 3945 */
-       pinst = il->ucode_code.p_addr;
-       pdata = il->ucode_data_backup.p_addr;
-
-       /* Tell bootstrap uCode where to find image to load */
-       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
-       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
-       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, il->ucode_data.len);
-
-       /* Inst byte count must be last to set up, bit 31 signals uCode
-        *   that all new ptr/size info is in place */
-       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG,
-                  il->ucode_code.len | BSM_DRAM_INST_LOAD);
-
-       D_INFO("Runtime uCode pointers are set.\n");
-
-       return 0;
-}
-
-/**
- * il3945_init_alive_start - Called after N_ALIVE notification received
- *
- * Called after N_ALIVE notification received from "initialize" uCode.
- *
- * Tell "initialize" uCode to go ahead and load the runtime uCode.
- */
-static void
-il3945_init_alive_start(struct il_priv *il)
-{
-       /* Check alive response for "valid" sign from uCode */
-       if (il->card_alive_init.is_valid != UCODE_VALID_OK) {
-               /* We had an error bringing up the hardware, so take it
-                * all the way back down so we can try again */
-               D_INFO("Initialize Alive failed.\n");
-               goto restart;
-       }
-
-       /* Bootstrap uCode has loaded initialize uCode ... verify inst image.
-        * This is a paranoid check, because we would not have gotten the
-        * "initialize" alive if code weren't properly loaded.  */
-       if (il3945_verify_ucode(il)) {
-               /* Runtime instruction load was bad;
-                * take it all the way back down so we can try again */
-               D_INFO("Bad \"initialize\" uCode load.\n");
-               goto restart;
-       }
-
-       /* Send pointers to protocol/runtime uCode image ... init code will
-        * load and launch runtime uCode, which will send us another "Alive"
-        * notification. */
-       D_INFO("Initialization Alive received.\n");
-       if (il3945_set_ucode_ptrs(il)) {
-               /* Runtime instruction load won't happen;
-                * take it all the way back down so we can try again */
-               D_INFO("Couldn't set up uCode pointers.\n");
-               goto restart;
-       }
-       return;
-
-restart:
-       queue_work(il->workqueue, &il->restart);
-}
-
-/**
- * il3945_alive_start - called after N_ALIVE notification received
- *                   from protocol/runtime uCode (initialization uCode's
- *                   Alive gets handled by il3945_init_alive_start()).
- */
-static void
-il3945_alive_start(struct il_priv *il)
-{
-       int thermal_spin = 0;
-       u32 rfkill;
-
-       D_INFO("Runtime Alive received.\n");
-
-       if (il->card_alive.is_valid != UCODE_VALID_OK) {
-               /* We had an error bringing up the hardware, so take it
-                * all the way back down so we can try again */
-               D_INFO("Alive failed.\n");
-               goto restart;
-       }
-
-       /* Initialize uCode has loaded Runtime uCode ... verify inst image.
-        * This is a paranoid check, because we would not have gotten the
-        * "runtime" alive if code weren't properly loaded.  */
-       if (il3945_verify_ucode(il)) {
-               /* Runtime instruction load was bad;
-                * take it all the way back down so we can try again */
-               D_INFO("Bad runtime uCode load.\n");
-               goto restart;
-       }
-
-       rfkill = il_rd_prph(il, APMG_RFKILL_REG);
-       D_INFO("RFKILL status: 0x%x\n", rfkill);
-
-       if (rfkill & 0x1) {
-               clear_bit(S_RFKILL, &il->status);
-               /* if RFKILL is not on, then wait for thermal
-                * sensor in adapter to kick in */
-               while (il3945_hw_get_temperature(il) == 0) {
-                       thermal_spin++;
-                       udelay(10);
-               }
-
-               if (thermal_spin)
-                       D_INFO("Thermal calibration took %dus\n",
-                              thermal_spin * 10);
-       } else
-               set_bit(S_RFKILL, &il->status);
-
-       /* After the ALIVE response, we can send commands to 3945 uCode */
-       set_bit(S_ALIVE, &il->status);
-
-       /* Enable watchdog to monitor the driver tx queues */
-       il_setup_watchdog(il);
-
-       if (il_is_rfkill(il))
-               return;
-
-       ieee80211_wake_queues(il->hw);
-
-       il->active_rate = RATES_MASK_3945;
-
-       il_power_update_mode(il, true);
-
-       if (il_is_associated(il)) {
-               struct il3945_rxon_cmd *active_rxon =
-                   (struct il3945_rxon_cmd *)(&il->active);
-
-               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
-               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-       } else {
-               /* Initialize our rx_config data */
-               il_connection_init_rx_config(il);
-       }
-
-       /* Configure Bluetooth device coexistence support */
-       il_send_bt_config(il);
-
-       set_bit(S_READY, &il->status);
-
-       /* Configure the adapter for unassociated operation */
-       il3945_commit_rxon(il);
-
-       il3945_reg_txpower_periodic(il);
-
-       D_INFO("ALIVE processing complete.\n");
-       wake_up(&il->wait_command_queue);
-
-       return;
-
-restart:
-       queue_work(il->workqueue, &il->restart);
-}
-
-static void il3945_cancel_deferred_work(struct il_priv *il);
-
-static void
-__il3945_down(struct il_priv *il)
-{
-       unsigned long flags;
-       int exit_pending;
-
-       D_INFO(DRV_NAME " is going down\n");
-
-       il_scan_cancel_timeout(il, 200);
-
-       exit_pending = test_and_set_bit(S_EXIT_PENDING, &il->status);
-
-       /* Stop TX queues watchdog. We need to have S_EXIT_PENDING bit set
-        * to prevent rearm timer */
-       del_timer_sync(&il->watchdog);
-
-       /* Station information will now be cleared in device */
-       il_clear_ucode_stations(il);
-       il_dealloc_bcast_stations(il);
-       il_clear_driver_stations(il);
-
-       /* Unblock any waiting calls */
-       wake_up_all(&il->wait_command_queue);
-
-       /* Wipe out the EXIT_PENDING status bit if we are not actually
-        * exiting the module */
-       if (!exit_pending)
-               clear_bit(S_EXIT_PENDING, &il->status);
-
-       /* stop and reset the on-board processor */
-       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
-
-       /* tell the device to stop sending interrupts */
-       spin_lock_irqsave(&il->lock, flags);
-       il_disable_interrupts(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-       il3945_synchronize_irq(il);
-
-       if (il->mac80211_registered)
-               ieee80211_stop_queues(il->hw);
-
-       /* If we have not previously called il3945_init() then
-        * clear all bits but the RF Kill bits and return */
-       if (!il_is_init(il)) {
-               il->status =
-                   test_bit(S_RFKILL, &il->status) << S_RFKILL |
-                   test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
-                   test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
-               goto exit;
-       }
-
-       /* ...otherwise clear out all the status bits but the RF Kill
-        * bit and continue taking the NIC down. */
-       il->status &=
-           test_bit(S_RFKILL, &il->status) << S_RFKILL |
-           test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
-           test_bit(S_FW_ERROR, &il->status) << S_FW_ERROR |
-           test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
-
-       /*
-        * We disabled and synchronized interrupt, and priv->mutex is taken, so
-        * here is the only thread which will program device registers, but
-        * still have lockdep assertions, so we are taking reg_lock.
-        */
-       spin_lock_irq(&il->reg_lock);
-       /* FIXME: il_grab_nic_access if rfkill is off ? */
-
-       il3945_hw_txq_ctx_stop(il);
-       il3945_hw_rxq_stop(il);
-       /* Power-down device's busmaster DMA clocks */
-       _il_wr_prph(il, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
-       udelay(5);
-       /* Stop the device, and put it in low power state */
-       _il_apm_stop(il);
-
-       spin_unlock_irq(&il->reg_lock);
-
-       il3945_hw_txq_ctx_free(il);
-exit:
-       memset(&il->card_alive, 0, sizeof(struct il_alive_resp));
-
-       if (il->beacon_skb)
-               dev_kfree_skb(il->beacon_skb);
-       il->beacon_skb = NULL;
-
-       /* clear out any free frames */
-       il3945_clear_free_frames(il);
-}
-
-static void
-il3945_down(struct il_priv *il)
-{
-       mutex_lock(&il->mutex);
-       __il3945_down(il);
-       mutex_unlock(&il->mutex);
-
-       il3945_cancel_deferred_work(il);
-}
-
-#define MAX_HW_RESTARTS 5
-
-static int
-il3945_alloc_bcast_station(struct il_priv *il)
-{
-       unsigned long flags;
-       u8 sta_id;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       sta_id = il_prep_station(il, il_bcast_addr, false, NULL);
-       if (sta_id == IL_INVALID_STATION) {
-               IL_ERR("Unable to prepare broadcast station\n");
-               spin_unlock_irqrestore(&il->sta_lock, flags);
-
-               return -EINVAL;
-       }
-
-       il->stations[sta_id].used |= IL_STA_DRIVER_ACTIVE;
-       il->stations[sta_id].used |= IL_STA_BCAST;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return 0;
-}
-
-static int
-__il3945_up(struct il_priv *il)
-{
-       int rc, i;
-
-       rc = il3945_alloc_bcast_station(il);
-       if (rc)
-               return rc;
-
-       if (test_bit(S_EXIT_PENDING, &il->status)) {
-               IL_WARN("Exit pending; will not bring the NIC up\n");
-               return -EIO;
-       }
-
-       if (!il->ucode_data_backup.v_addr || !il->ucode_data.v_addr) {
-               IL_ERR("ucode not available for device bring up\n");
-               return -EIO;
-       }
-
-       /* If platform's RF_KILL switch is NOT set to KILL */
-       if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
-               clear_bit(S_RFKILL, &il->status);
-       else {
-               set_bit(S_RFKILL, &il->status);
-               return -ERFKILL;
-       }
-
-       _il_wr(il, CSR_INT, 0xFFFFFFFF);
-
-       rc = il3945_hw_nic_init(il);
-       if (rc) {
-               IL_ERR("Unable to int nic\n");
-               return rc;
-       }
-
-       /* make sure rfkill handshake bits are cleared */
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
-
-       /* clear (again), then enable host interrupts */
-       _il_wr(il, CSR_INT, 0xFFFFFFFF);
-       il_enable_interrupts(il);
-
-       /* really make sure rfkill handshake bits are cleared */
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-
-       /* Copy original ucode data image from disk into backup cache.
-        * This will be used to initialize the on-board processor's
-        * data SRAM for a clean start when the runtime program first loads. */
-       memcpy(il->ucode_data_backup.v_addr, il->ucode_data.v_addr,
-              il->ucode_data.len);
-
-       /* We return success when we resume from suspend and rf_kill is on. */
-       if (test_bit(S_RFKILL, &il->status))
-               return 0;
-
-       for (i = 0; i < MAX_HW_RESTARTS; i++) {
-
-               /* load bootstrap state machine,
-                * load bootstrap program into processor's memory,
-                * prepare to load the "initialize" uCode */
-               rc = il->ops->load_ucode(il);
-
-               if (rc) {
-                       IL_ERR("Unable to set up bootstrap uCode: %d\n", rc);
-                       continue;
-               }
-
-               /* start card; "initialize" will load runtime ucode */
-               il3945_nic_start(il);
-
-               D_INFO(DRV_NAME " is coming up\n");
-
-               return 0;
-       }
-
-       set_bit(S_EXIT_PENDING, &il->status);
-       __il3945_down(il);
-       clear_bit(S_EXIT_PENDING, &il->status);
-
-       /* tried to restart and config the device for as long as our
-        * patience could withstand */
-       IL_ERR("Unable to initialize device after %d attempts.\n", i);
-       return -EIO;
-}
-
-/*****************************************************************************
- *
- * Workqueue callbacks
- *
- *****************************************************************************/
-
-static void
-il3945_bg_init_alive_start(struct work_struct *data)
-{
-       struct il_priv *il =
-           container_of(data, struct il_priv, init_alive_start.work);
-
-       mutex_lock(&il->mutex);
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               goto out;
-
-       il3945_init_alive_start(il);
-out:
-       mutex_unlock(&il->mutex);
-}
-
-static void
-il3945_bg_alive_start(struct work_struct *data)
-{
-       struct il_priv *il =
-           container_of(data, struct il_priv, alive_start.work);
-
-       mutex_lock(&il->mutex);
-       if (test_bit(S_EXIT_PENDING, &il->status) || il->txq == NULL)
-               goto out;
-
-       il3945_alive_start(il);
-out:
-       mutex_unlock(&il->mutex);
-}
-
-/*
- * 3945 cannot interrupt driver when hardware rf kill switch toggles;
- * driver must poll CSR_GP_CNTRL_REG register for change.  This register
- * *is* readable even when device has been SW_RESET into low power mode
- * (e.g. during RF KILL).
- */
-static void
-il3945_rfkill_poll(struct work_struct *data)
-{
-       struct il_priv *il =
-           container_of(data, struct il_priv, _3945.rfkill_poll.work);
-       bool old_rfkill = test_bit(S_RFKILL, &il->status);
-       bool new_rfkill =
-           !(_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW);
-
-       if (new_rfkill != old_rfkill) {
-               if (new_rfkill)
-                       set_bit(S_RFKILL, &il->status);
-               else
-                       clear_bit(S_RFKILL, &il->status);
-
-               wiphy_rfkill_set_hw_state(il->hw->wiphy, new_rfkill);
-
-               D_RF_KILL("RF_KILL bit toggled to %s.\n",
-                         new_rfkill ? "disable radio" : "enable radio");
-       }
-
-       /* Keep this running, even if radio now enabled.  This will be
-        * cancelled in mac_start() if system decides to start again */
-       queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll,
-                          round_jiffies_relative(2 * HZ));
-
-}
-
-int
-il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
-{
-       struct il_host_cmd cmd = {
-               .id = C_SCAN,
-               .len = sizeof(struct il3945_scan_cmd),
-               .flags = CMD_SIZE_HUGE,
-       };
-       struct il3945_scan_cmd *scan;
-       u8 n_probes = 0;
-       enum ieee80211_band band;
-       bool is_active = false;
-       int ret;
-       u16 len;
-
-       lockdep_assert_held(&il->mutex);
-
-       if (!il->scan_cmd) {
-               il->scan_cmd =
-                   kmalloc(sizeof(struct il3945_scan_cmd) + IL_MAX_SCAN_SIZE,
-                           GFP_KERNEL);
-               if (!il->scan_cmd) {
-                       D_SCAN("Fail to allocate scan memory\n");
-                       return -ENOMEM;
-               }
-       }
-       scan = il->scan_cmd;
-       memset(scan, 0, sizeof(struct il3945_scan_cmd) + IL_MAX_SCAN_SIZE);
-
-       scan->quiet_plcp_th = IL_PLCP_QUIET_THRESH;
-       scan->quiet_time = IL_ACTIVE_QUIET_TIME;
-
-       if (il_is_associated(il)) {
-               u16 interval;
-               u32 extra;
-               u32 suspend_time = 100;
-               u32 scan_suspend_time = 100;
-
-               D_INFO("Scanning while associated...\n");
-
-               interval = vif->bss_conf.beacon_int;
-
-               scan->suspend_time = 0;
-               scan->max_out_time = cpu_to_le32(200 * 1024);
-               if (!interval)
-                       interval = suspend_time;
-               /*
-                * suspend time format:
-                *  0-19: beacon interval in usec (time before exec.)
-                * 20-23: 0
-                * 24-31: number of beacons (suspend between channels)
-                */
-
-               extra = (suspend_time / interval) << 24;
-               scan_suspend_time =
-                   0xFF0FFFFF & (extra | ((suspend_time % interval) * 1024));
-
-               scan->suspend_time = cpu_to_le32(scan_suspend_time);
-               D_SCAN("suspend_time 0x%X beacon interval %d\n",
-                      scan_suspend_time, interval);
-       }
-
-       if (il->scan_request->n_ssids) {
-               int i, p = 0;
-               D_SCAN("Kicking off active scan\n");
-               for (i = 0; i < il->scan_request->n_ssids; i++) {
-                       /* always does wildcard anyway */
-                       if (!il->scan_request->ssids[i].ssid_len)
-                               continue;
-                       scan->direct_scan[p].id = WLAN_EID_SSID;
-                       scan->direct_scan[p].len =
-                           il->scan_request->ssids[i].ssid_len;
-                       memcpy(scan->direct_scan[p].ssid,
-                              il->scan_request->ssids[i].ssid,
-                              il->scan_request->ssids[i].ssid_len);
-                       n_probes++;
-                       p++;
-               }
-               is_active = true;
-       } else
-               D_SCAN("Kicking off passive scan.\n");
-
-       /* We don't build a direct scan probe request; the uCode will do
-        * that based on the direct_mask added to each channel entry */
-       scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
-       scan->tx_cmd.sta_id = il->hw_params.bcast_id;
-       scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
-
-       /* flags + rate selection */
-
-       switch (il->scan_band) {
-       case IEEE80211_BAND_2GHZ:
-               scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
-               scan->tx_cmd.rate = RATE_1M_PLCP;
-               band = IEEE80211_BAND_2GHZ;
-               break;
-       case IEEE80211_BAND_5GHZ:
-               scan->tx_cmd.rate = RATE_6M_PLCP;
-               band = IEEE80211_BAND_5GHZ;
-               break;
-       default:
-               IL_WARN("Invalid scan band\n");
-               return -EIO;
-       }
-
-       /*
-        * If active scaning is requested but a certain channel is marked
-        * passive, we can do active scanning if we detect transmissions. For
-        * passive only scanning disable switching to active on any channel.
-        */
-       scan->good_CRC_th =
-           is_active ? IL_GOOD_CRC_TH_DEFAULT : IL_GOOD_CRC_TH_NEVER;
-
-       len =
-           il_fill_probe_req(il, (struct ieee80211_mgmt *)scan->data,
-                             vif->addr, il->scan_request->ie,
-                             il->scan_request->ie_len,
-                             IL_MAX_SCAN_SIZE - sizeof(*scan));
-       scan->tx_cmd.len = cpu_to_le16(len);
-
-       /* select Rx antennas */
-       scan->flags |= il3945_get_antenna_flags(il);
-
-       scan->channel_count =
-           il3945_get_channels_for_scan(il, band, is_active, n_probes,
-                                        (void *)&scan->data[len], vif);
-       if (scan->channel_count == 0) {
-               D_SCAN("channel count %d\n", scan->channel_count);
-               return -EIO;
-       }
-
-       cmd.len +=
-           le16_to_cpu(scan->tx_cmd.len) +
-           scan->channel_count * sizeof(struct il3945_scan_channel);
-       cmd.data = scan;
-       scan->len = cpu_to_le16(cmd.len);
-
-       set_bit(S_SCAN_HW, &il->status);
-       ret = il_send_cmd_sync(il, &cmd);
-       if (ret)
-               clear_bit(S_SCAN_HW, &il->status);
-       return ret;
-}
-
-void
-il3945_post_scan(struct il_priv *il)
-{
-       /*
-        * Since setting the RXON may have been deferred while
-        * performing the scan, fire one off if needed
-        */
-       if (memcmp(&il->staging, &il->active, sizeof(il->staging)))
-               il3945_commit_rxon(il);
-}
-
-static void
-il3945_bg_restart(struct work_struct *data)
-{
-       struct il_priv *il = container_of(data, struct il_priv, restart);
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
-               mutex_lock(&il->mutex);
-               il->is_open = 0;
-               mutex_unlock(&il->mutex);
-               il3945_down(il);
-               ieee80211_restart_hw(il->hw);
-       } else {
-               il3945_down(il);
-
-               mutex_lock(&il->mutex);
-               if (test_bit(S_EXIT_PENDING, &il->status)) {
-                       mutex_unlock(&il->mutex);
-                       return;
-               }
-
-               __il3945_up(il);
-               mutex_unlock(&il->mutex);
-       }
-}
-
-static void
-il3945_bg_rx_replenish(struct work_struct *data)
-{
-       struct il_priv *il = container_of(data, struct il_priv, rx_replenish);
-
-       mutex_lock(&il->mutex);
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               goto out;
-
-       il3945_rx_replenish(il);
-out:
-       mutex_unlock(&il->mutex);
-}
-
-void
-il3945_post_associate(struct il_priv *il)
-{
-       int rc = 0;
-       struct ieee80211_conf *conf = NULL;
-
-       if (!il->vif || !il->is_open)
-               return;
-
-       D_ASSOC("Associated as %d to: %pM\n", il->vif->bss_conf.aid,
-               il->active.bssid_addr);
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       il_scan_cancel_timeout(il, 200);
-
-       conf = &il->hw->conf;
-
-       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-       il3945_commit_rxon(il);
-
-       rc = il_send_rxon_timing(il);
-       if (rc)
-               IL_WARN("C_RXON_TIMING failed - " "Attempting to continue.\n");
-
-       il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
-
-       il->staging.assoc_id = cpu_to_le16(il->vif->bss_conf.aid);
-
-       D_ASSOC("assoc id %d beacon interval %d\n", il->vif->bss_conf.aid,
-               il->vif->bss_conf.beacon_int);
-
-       if (il->vif->bss_conf.use_short_preamble)
-               il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
-       else
-               il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
-
-       if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
-               if (il->vif->bss_conf.use_short_slot)
-                       il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
-               else
-                       il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
-       }
-
-       il3945_commit_rxon(il);
-
-       switch (il->vif->type) {
-       case NL80211_IFTYPE_STATION:
-               il3945_rate_scale_init(il->hw, IL_AP_ID);
-               break;
-       case NL80211_IFTYPE_ADHOC:
-               il3945_send_beacon_cmd(il);
-               break;
-       default:
-               IL_ERR("%s Should not be called in %d mode\n", __func__,
-                     il->vif->type);
-               break;
-       }
-}
-
-/*****************************************************************************
- *
- * mac80211 entry point functions
- *
- *****************************************************************************/
-
-#define UCODE_READY_TIMEOUT    (2 * HZ)
-
-static int
-il3945_mac_start(struct ieee80211_hw *hw)
-{
-       struct il_priv *il = hw->priv;
-       int ret;
-
-       /* we should be verifying the device is ready to be opened */
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter\n");
-
-       /* fetch ucode file from disk, alloc and copy to bus-master buffers ...
-        * ucode filename and max sizes are card-specific. */
-
-       if (!il->ucode_code.len) {
-               ret = il3945_read_ucode(il);
-               if (ret) {
-                       IL_ERR("Could not read microcode: %d\n", ret);
-                       mutex_unlock(&il->mutex);
-                       goto out_release_irq;
-               }
-       }
-
-       ret = __il3945_up(il);
-
-       mutex_unlock(&il->mutex);
-
-       if (ret)
-               goto out_release_irq;
-
-       D_INFO("Start UP work.\n");
-
-       /* Wait for START_ALIVE from ucode. Otherwise callbacks from
-        * mac80211 will not be run successfully. */
-       ret = wait_event_timeout(il->wait_command_queue,
-                                test_bit(S_READY, &il->status),
-                                UCODE_READY_TIMEOUT);
-       if (!ret) {
-               if (!test_bit(S_READY, &il->status)) {
-                       IL_ERR("Wait for START_ALIVE timeout after %dms.\n",
-                              jiffies_to_msecs(UCODE_READY_TIMEOUT));
-                       ret = -ETIMEDOUT;
-                       goto out_release_irq;
-               }
-       }
-
-       /* ucode is running and will send rfkill notifications,
-        * no need to poll the killswitch state anymore */
-       cancel_delayed_work(&il->_3945.rfkill_poll);
-
-       il->is_open = 1;
-       D_MAC80211("leave\n");
-       return 0;
-
-out_release_irq:
-       il->is_open = 0;
-       D_MAC80211("leave - failed\n");
-       return ret;
-}
-
-static void
-il3945_mac_stop(struct ieee80211_hw *hw)
-{
-       struct il_priv *il = hw->priv;
-
-       D_MAC80211("enter\n");
-
-       if (!il->is_open) {
-               D_MAC80211("leave - skip\n");
-               return;
-       }
-
-       il->is_open = 0;
-
-       il3945_down(il);
-
-       flush_workqueue(il->workqueue);
-
-       /* start polling the killswitch state again */
-       queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll,
-                          round_jiffies_relative(2 * HZ));
-
-       D_MAC80211("leave\n");
-}
-
-static void
-il3945_mac_tx(struct ieee80211_hw *hw,
-              struct ieee80211_tx_control *control,
-              struct sk_buff *skb)
-{
-       struct il_priv *il = hw->priv;
-
-       D_MAC80211("enter\n");
-
-       D_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
-            ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
-
-       if (il3945_tx_skb(il, control->sta, skb))
-               dev_kfree_skb_any(skb);
-
-       D_MAC80211("leave\n");
-}
-
-void
-il3945_config_ap(struct il_priv *il)
-{
-       struct ieee80211_vif *vif = il->vif;
-       int rc = 0;
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       /* The following should be done only at AP bring up */
-       if (!(il_is_associated(il))) {
-
-               /* RXON - unassoc (to set timing command) */
-               il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-               il3945_commit_rxon(il);
-
-               /* RXON Timing */
-               rc = il_send_rxon_timing(il);
-               if (rc)
-                       IL_WARN("C_RXON_TIMING failed - "
-                               "Attempting to continue.\n");
-
-               il->staging.assoc_id = 0;
-
-               if (vif->bss_conf.use_short_preamble)
-                       il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
-               else
-                       il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
-
-               if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
-                       if (vif->bss_conf.use_short_slot)
-                               il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
-                       else
-                               il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
-               }
-               /* restore RXON assoc */
-               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
-               il3945_commit_rxon(il);
-       }
-       il3945_send_beacon_cmd(il);
-}
-
-static int
-il3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
-                  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
-                  struct ieee80211_key_conf *key)
-{
-       struct il_priv *il = hw->priv;
-       int ret = 0;
-       u8 sta_id = IL_INVALID_STATION;
-       u8 static_key;
-
-       D_MAC80211("enter\n");
-
-       if (il3945_mod_params.sw_crypto) {
-               D_MAC80211("leave - hwcrypto disabled\n");
-               return -EOPNOTSUPP;
-       }
-
-       /*
-        * To support IBSS RSN, don't program group keys in IBSS, the
-        * hardware will then not attempt to decrypt the frames.
-        */
-       if (vif->type == NL80211_IFTYPE_ADHOC &&
-           !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
-               D_MAC80211("leave - IBSS RSN\n");
-               return -EOPNOTSUPP;
-       }
-
-       static_key = !il_is_associated(il);
-
-       if (!static_key) {
-               sta_id = il_sta_id_or_broadcast(il, sta);
-               if (sta_id == IL_INVALID_STATION) {
-                       D_MAC80211("leave - station not found\n");
-                       return -EINVAL;
-               }
-       }
-
-       mutex_lock(&il->mutex);
-       il_scan_cancel_timeout(il, 100);
-
-       switch (cmd) {
-       case SET_KEY:
-               if (static_key)
-                       ret = il3945_set_static_key(il, key);
-               else
-                       ret = il3945_set_dynamic_key(il, key, sta_id);
-               D_MAC80211("enable hwcrypto key\n");
-               break;
-       case DISABLE_KEY:
-               if (static_key)
-                       ret = il3945_remove_static_key(il);
-               else
-                       ret = il3945_clear_sta_key_info(il, sta_id);
-               D_MAC80211("disable hwcrypto key\n");
-               break;
-       default:
-               ret = -EINVAL;
-       }
-
-       D_MAC80211("leave ret %d\n", ret);
-       mutex_unlock(&il->mutex);
-
-       return ret;
-}
-
-static int
-il3945_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                  struct ieee80211_sta *sta)
-{
-       struct il_priv *il = hw->priv;
-       struct il3945_sta_priv *sta_priv = (void *)sta->drv_priv;
-       int ret;
-       bool is_ap = vif->type == NL80211_IFTYPE_STATION;
-       u8 sta_id;
-
-       mutex_lock(&il->mutex);
-       D_INFO("station %pM\n", sta->addr);
-       sta_priv->common.sta_id = IL_INVALID_STATION;
-
-       ret = il_add_station_common(il, sta->addr, is_ap, sta, &sta_id);
-       if (ret) {
-               IL_ERR("Unable to add station %pM (%d)\n", sta->addr, ret);
-               /* Should we return success if return code is EEXIST ? */
-               mutex_unlock(&il->mutex);
-               return ret;
-       }
-
-       sta_priv->common.sta_id = sta_id;
-
-       /* Initialize rate scaling */
-       D_INFO("Initializing rate scaling for station %pM\n", sta->addr);
-       il3945_rs_rate_init(il, sta, sta_id);
-       mutex_unlock(&il->mutex);
-
-       return 0;
-}
-
-static void
-il3945_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
-                       unsigned int *total_flags, u64 multicast)
-{
-       struct il_priv *il = hw->priv;
-       __le32 filter_or = 0, filter_nand = 0;
-
-#define CHK(test, flag)        do { \
-       if (*total_flags & (test))              \
-               filter_or |= (flag);            \
-       else                                    \
-               filter_nand |= (flag);          \
-       } while (0)
-
-       D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n", changed_flags,
-                  *total_flags);
-
-       CHK(FIF_OTHER_BSS, RXON_FILTER_PROMISC_MSK);
-       CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK);
-       CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
-
-#undef CHK
-
-       mutex_lock(&il->mutex);
-
-       il->staging.filter_flags &= ~filter_nand;
-       il->staging.filter_flags |= filter_or;
-
-       /*
-        * Not committing directly because hardware can perform a scan,
-        * but even if hw is ready, committing here breaks for some reason,
-        * we'll eventually commit the filter flags change anyway.
-        */
-
-       mutex_unlock(&il->mutex);
-
-       /*
-        * Receiving all multicast frames is always enabled by the
-        * default flags setup in il_connection_init_rx_config()
-        * since we currently do not support programming multicast
-        * filters into the device.
-        */
-       *total_flags &=
-           FIF_OTHER_BSS | FIF_ALLMULTI |
-           FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
-}
-
-/*****************************************************************************
- *
- * sysfs attributes
- *
- *****************************************************************************/
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-
-/*
- * The following adds a new attribute to the sysfs representation
- * of this device driver (i.e. a new file in /sys/bus/pci/drivers/iwl/)
- * used for controlling the debug level.
- *
- * See the level definitions in iwl for details.
- *
- * The debug_level being managed using sysfs below is a per device debug
- * level that is used instead of the global debug level if it (the per
- * device debug level) is set.
- */
-static ssize_t
-il3945_show_debug_level(struct device *d, struct device_attribute *attr,
-                       char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       return sprintf(buf, "0x%08X\n", il_get_debug_level(il));
-}
-
-static ssize_t
-il3945_store_debug_level(struct device *d, struct device_attribute *attr,
-                        const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       unsigned long val;
-       int ret;
-
-       ret = kstrtoul(buf, 0, &val);
-       if (ret)
-               IL_INFO("%s is not in hex or decimal form.\n", buf);
-       else
-               il->debug_level = val;
-
-       return strnlen(buf, count);
-}
-
-static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO, il3945_show_debug_level,
-                  il3945_store_debug_level);
-
-#endif /* CONFIG_IWLEGACY_DEBUG */
-
-static ssize_t
-il3945_show_temperature(struct device *d, struct device_attribute *attr,
-                       char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       return sprintf(buf, "%d\n", il3945_hw_get_temperature(il));
-}
-
-static DEVICE_ATTR(temperature, S_IRUGO, il3945_show_temperature, NULL);
-
-static ssize_t
-il3945_show_tx_power(struct device *d, struct device_attribute *attr, char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       return sprintf(buf, "%d\n", il->tx_power_user_lmt);
-}
-
-static ssize_t
-il3945_store_tx_power(struct device *d, struct device_attribute *attr,
-                     const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       char *p = (char *)buf;
-       u32 val;
-
-       val = simple_strtoul(p, &p, 10);
-       if (p == buf)
-               IL_INFO(": %s is not in decimal form.\n", buf);
-       else
-               il3945_hw_reg_set_txpower(il, val);
-
-       return count;
-}
-
-static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, il3945_show_tx_power,
-                  il3945_store_tx_power);
-
-static ssize_t
-il3945_show_flags(struct device *d, struct device_attribute *attr, char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-
-       return sprintf(buf, "0x%04X\n", il->active.flags);
-}
-
-static ssize_t
-il3945_store_flags(struct device *d, struct device_attribute *attr,
-                  const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       u32 flags = simple_strtoul(buf, NULL, 0);
-
-       mutex_lock(&il->mutex);
-       if (le32_to_cpu(il->staging.flags) != flags) {
-               /* Cancel any currently running scans... */
-               if (il_scan_cancel_timeout(il, 100))
-                       IL_WARN("Could not cancel scan.\n");
-               else {
-                       D_INFO("Committing rxon.flags = 0x%04X\n", flags);
-                       il->staging.flags = cpu_to_le32(flags);
-                       il3945_commit_rxon(il);
-               }
-       }
-       mutex_unlock(&il->mutex);
-
-       return count;
-}
-
-static DEVICE_ATTR(flags, S_IWUSR | S_IRUGO, il3945_show_flags,
-                  il3945_store_flags);
-
-static ssize_t
-il3945_show_filter_flags(struct device *d, struct device_attribute *attr,
-                        char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-
-       return sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.filter_flags));
-}
-
-static ssize_t
-il3945_store_filter_flags(struct device *d, struct device_attribute *attr,
-                         const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       u32 filter_flags = simple_strtoul(buf, NULL, 0);
-
-       mutex_lock(&il->mutex);
-       if (le32_to_cpu(il->staging.filter_flags) != filter_flags) {
-               /* Cancel any currently running scans... */
-               if (il_scan_cancel_timeout(il, 100))
-                       IL_WARN("Could not cancel scan.\n");
-               else {
-                       D_INFO("Committing rxon.filter_flags = " "0x%04X\n",
-                              filter_flags);
-                       il->staging.filter_flags = cpu_to_le32(filter_flags);
-                       il3945_commit_rxon(il);
-               }
-       }
-       mutex_unlock(&il->mutex);
-
-       return count;
-}
-
-static DEVICE_ATTR(filter_flags, S_IWUSR | S_IRUGO, il3945_show_filter_flags,
-                  il3945_store_filter_flags);
-
-static ssize_t
-il3945_show_measurement(struct device *d, struct device_attribute *attr,
-                       char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       struct il_spectrum_notification measure_report;
-       u32 size = sizeof(measure_report), len = 0, ofs = 0;
-       u8 *data = (u8 *) &measure_report;
-       unsigned long flags;
-
-       spin_lock_irqsave(&il->lock, flags);
-       if (!(il->measurement_status & MEASUREMENT_READY)) {
-               spin_unlock_irqrestore(&il->lock, flags);
-               return 0;
-       }
-       memcpy(&measure_report, &il->measure_report, size);
-       il->measurement_status = 0;
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       while (size && PAGE_SIZE - len) {
-               hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
-                                  PAGE_SIZE - len, true);
-               len = strlen(buf);
-               if (PAGE_SIZE - len)
-                       buf[len++] = '\n';
-
-               ofs += 16;
-               size -= min(size, 16U);
-       }
-
-       return len;
-}
-
-static ssize_t
-il3945_store_measurement(struct device *d, struct device_attribute *attr,
-                        const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       struct ieee80211_measurement_params params = {
-               .channel = le16_to_cpu(il->active.channel),
-               .start_time = cpu_to_le64(il->_3945.last_tsf),
-               .duration = cpu_to_le16(1),
-       };
-       u8 type = IL_MEASURE_BASIC;
-       u8 buffer[32];
-       u8 channel;
-
-       if (count) {
-               char *p = buffer;
-               strlcpy(buffer, buf, sizeof(buffer));
-               channel = simple_strtoul(p, NULL, 0);
-               if (channel)
-                       params.channel = channel;
-
-               p = buffer;
-               while (*p && *p != ' ')
-                       p++;
-               if (*p)
-                       type = simple_strtoul(p + 1, NULL, 0);
-       }
-
-       D_INFO("Invoking measurement of type %d on " "channel %d (for '%s')\n",
-              type, params.channel, buf);
-       il3945_get_measurement(il, &params, type);
-
-       return count;
-}
-
-static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR, il3945_show_measurement,
-                  il3945_store_measurement);
-
-static ssize_t
-il3945_store_retry_rate(struct device *d, struct device_attribute *attr,
-                       const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-
-       il->retry_rate = simple_strtoul(buf, NULL, 0);
-       if (il->retry_rate <= 0)
-               il->retry_rate = 1;
-
-       return count;
-}
-
-static ssize_t
-il3945_show_retry_rate(struct device *d, struct device_attribute *attr,
-                      char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       return sprintf(buf, "%d", il->retry_rate);
-}
-
-static DEVICE_ATTR(retry_rate, S_IWUSR | S_IRUSR, il3945_show_retry_rate,
-                  il3945_store_retry_rate);
-
-static ssize_t
-il3945_show_channels(struct device *d, struct device_attribute *attr, char *buf)
-{
-       /* all this shit doesn't belong into sysfs anyway */
-       return 0;
-}
-
-static DEVICE_ATTR(channels, S_IRUSR, il3945_show_channels, NULL);
-
-static ssize_t
-il3945_show_antenna(struct device *d, struct device_attribute *attr, char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       return sprintf(buf, "%d\n", il3945_mod_params.antenna);
-}
-
-static ssize_t
-il3945_store_antenna(struct device *d, struct device_attribute *attr,
-                    const char *buf, size_t count)
-{
-       struct il_priv *il __maybe_unused = dev_get_drvdata(d);
-       int ant;
-
-       if (count == 0)
-               return 0;
-
-       if (sscanf(buf, "%1i", &ant) != 1) {
-               D_INFO("not in hex or decimal form.\n");
-               return count;
-       }
-
-       if (ant >= 0 && ant <= 2) {
-               D_INFO("Setting antenna select to %d.\n", ant);
-               il3945_mod_params.antenna = (enum il3945_antenna)ant;
-       } else
-               D_INFO("Bad antenna select value %d.\n", ant);
-
-       return count;
-}
-
-static DEVICE_ATTR(antenna, S_IWUSR | S_IRUGO, il3945_show_antenna,
-                  il3945_store_antenna);
-
-static ssize_t
-il3945_show_status(struct device *d, struct device_attribute *attr, char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       if (!il_is_alive(il))
-               return -EAGAIN;
-       return sprintf(buf, "0x%08x\n", (int)il->status);
-}
-
-static DEVICE_ATTR(status, S_IRUGO, il3945_show_status, NULL);
-
-static ssize_t
-il3945_dump_error_log(struct device *d, struct device_attribute *attr,
-                     const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       char *p = (char *)buf;
-
-       if (p[0] == '1')
-               il3945_dump_nic_error_log(il);
-
-       return strnlen(buf, count);
-}
-
-static DEVICE_ATTR(dump_errors, S_IWUSR, NULL, il3945_dump_error_log);
-
-/*****************************************************************************
- *
- * driver setup and tear down
- *
- *****************************************************************************/
-
-static void
-il3945_setup_deferred_work(struct il_priv *il)
-{
-       il->workqueue = create_singlethread_workqueue(DRV_NAME);
-
-       init_waitqueue_head(&il->wait_command_queue);
-
-       INIT_WORK(&il->restart, il3945_bg_restart);
-       INIT_WORK(&il->rx_replenish, il3945_bg_rx_replenish);
-       INIT_DELAYED_WORK(&il->init_alive_start, il3945_bg_init_alive_start);
-       INIT_DELAYED_WORK(&il->alive_start, il3945_bg_alive_start);
-       INIT_DELAYED_WORK(&il->_3945.rfkill_poll, il3945_rfkill_poll);
-
-       il_setup_scan_deferred_work(il);
-
-       il3945_hw_setup_deferred_work(il);
-
-       setup_timer(&il->watchdog, il_bg_watchdog, (unsigned long)il);
-
-       tasklet_init(&il->irq_tasklet,
-                    (void (*)(unsigned long))il3945_irq_tasklet,
-                    (unsigned long)il);
-}
-
-static void
-il3945_cancel_deferred_work(struct il_priv *il)
-{
-       il3945_hw_cancel_deferred_work(il);
-
-       cancel_delayed_work_sync(&il->init_alive_start);
-       cancel_delayed_work(&il->alive_start);
-
-       il_cancel_scan_deferred_work(il);
-}
-
-static struct attribute *il3945_sysfs_entries[] = {
-       &dev_attr_antenna.attr,
-       &dev_attr_channels.attr,
-       &dev_attr_dump_errors.attr,
-       &dev_attr_flags.attr,
-       &dev_attr_filter_flags.attr,
-       &dev_attr_measurement.attr,
-       &dev_attr_retry_rate.attr,
-       &dev_attr_status.attr,
-       &dev_attr_temperature.attr,
-       &dev_attr_tx_power.attr,
-#ifdef CONFIG_IWLEGACY_DEBUG
-       &dev_attr_debug_level.attr,
-#endif
-       NULL
-};
-
-static struct attribute_group il3945_attribute_group = {
-       .name = NULL,           /* put in device directory */
-       .attrs = il3945_sysfs_entries,
-};
-
-static struct ieee80211_ops il3945_mac_ops __read_mostly = {
-       .tx = il3945_mac_tx,
-       .start = il3945_mac_start,
-       .stop = il3945_mac_stop,
-       .add_interface = il_mac_add_interface,
-       .remove_interface = il_mac_remove_interface,
-       .change_interface = il_mac_change_interface,
-       .config = il_mac_config,
-       .configure_filter = il3945_configure_filter,
-       .set_key = il3945_mac_set_key,
-       .conf_tx = il_mac_conf_tx,
-       .reset_tsf = il_mac_reset_tsf,
-       .bss_info_changed = il_mac_bss_info_changed,
-       .hw_scan = il_mac_hw_scan,
-       .sta_add = il3945_mac_sta_add,
-       .sta_remove = il_mac_sta_remove,
-       .tx_last_beacon = il_mac_tx_last_beacon,
-       .flush = il_mac_flush,
-};
-
-static int
-il3945_init_drv(struct il_priv *il)
-{
-       int ret;
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-
-       il->retry_rate = 1;
-       il->beacon_skb = NULL;
-
-       spin_lock_init(&il->sta_lock);
-       spin_lock_init(&il->hcmd_lock);
-
-       INIT_LIST_HEAD(&il->free_frames);
-
-       mutex_init(&il->mutex);
-
-       il->ieee_channels = NULL;
-       il->ieee_rates = NULL;
-       il->band = IEEE80211_BAND_2GHZ;
-
-       il->iw_mode = NL80211_IFTYPE_STATION;
-       il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
-
-       /* initialize force reset */
-       il->force_reset.reset_duration = IL_DELAY_NEXT_FORCE_FW_RELOAD;
-
-       if (eeprom->version < EEPROM_3945_EEPROM_VERSION) {
-               IL_WARN("Unsupported EEPROM version: 0x%04X\n",
-                       eeprom->version);
-               ret = -EINVAL;
-               goto err;
-       }
-       ret = il_init_channel_map(il);
-       if (ret) {
-               IL_ERR("initializing regulatory failed: %d\n", ret);
-               goto err;
-       }
-
-       /* Set up txpower settings in driver for all channels */
-       if (il3945_txpower_set_from_eeprom(il)) {
-               ret = -EIO;
-               goto err_free_channel_map;
-       }
-
-       ret = il_init_geos(il);
-       if (ret) {
-               IL_ERR("initializing geos failed: %d\n", ret);
-               goto err_free_channel_map;
-       }
-       il3945_init_hw_rates(il, il->ieee_rates);
-
-       return 0;
-
-err_free_channel_map:
-       il_free_channel_map(il);
-err:
-       return ret;
-}
-
-#define IL3945_MAX_PROBE_REQUEST       200
-
-static int
-il3945_setup_mac(struct il_priv *il)
-{
-       int ret;
-       struct ieee80211_hw *hw = il->hw;
-
-       hw->rate_control_algorithm = "iwl-3945-rs";
-       hw->sta_data_size = sizeof(struct il3945_sta_priv);
-       hw->vif_data_size = sizeof(struct il_vif_priv);
-
-       /* Tell mac80211 our characteristics */
-       ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
-       ieee80211_hw_set(hw, SUPPORTS_PS);
-       ieee80211_hw_set(hw, SIGNAL_DBM);
-       ieee80211_hw_set(hw, SPECTRUM_MGMT);
-
-       hw->wiphy->interface_modes =
-           BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
-
-       hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
-       hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
-                                      REGULATORY_DISABLE_BEACON_HINTS;
-
-       hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
-
-       hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX_3945;
-       /* we create the 802.11 header and a zero-length SSID element */
-       hw->wiphy->max_scan_ie_len = IL3945_MAX_PROBE_REQUEST - 24 - 2;
-
-       /* Default value; 4 EDCA QOS priorities */
-       hw->queues = 4;
-
-       if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
-               il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                   &il->bands[IEEE80211_BAND_2GHZ];
-
-       if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
-               il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                   &il->bands[IEEE80211_BAND_5GHZ];
-
-       il_leds_init(il);
-
-       ret = ieee80211_register_hw(il->hw);
-       if (ret) {
-               IL_ERR("Failed to register hw (error %d)\n", ret);
-               return ret;
-       }
-       il->mac80211_registered = 1;
-
-       return 0;
-}
-
-static int
-il3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
-{
-       int err = 0;
-       struct il_priv *il;
-       struct ieee80211_hw *hw;
-       struct il_cfg *cfg = (struct il_cfg *)(ent->driver_data);
-       struct il3945_eeprom *eeprom;
-       unsigned long flags;
-
-       /***********************
-        * 1. Allocating HW data
-        * ********************/
-
-       hw = ieee80211_alloc_hw(sizeof(struct il_priv), &il3945_mac_ops);
-       if (!hw) {
-               err = -ENOMEM;
-               goto out;
-       }
-       il = hw->priv;
-       il->hw = hw;
-       SET_IEEE80211_DEV(hw, &pdev->dev);
-
-       il->cmd_queue = IL39_CMD_QUEUE_NUM;
-
-       /*
-        * Disabling hardware scan means that mac80211 will perform scans
-        * "the hard way", rather than using device's scan.
-        */
-       if (il3945_mod_params.disable_hw_scan) {
-               D_INFO("Disabling hw_scan\n");
-               il3945_mac_ops.hw_scan = NULL;
-       }
-
-       D_INFO("*** LOAD DRIVER ***\n");
-       il->cfg = cfg;
-       il->ops = &il3945_ops;
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       il->debugfs_ops = &il3945_debugfs_ops;
-#endif
-       il->pci_dev = pdev;
-       il->inta_mask = CSR_INI_SET_MASK;
-
-       /***************************
-        * 2. Initializing PCI bus
-        * *************************/
-       pci_disable_link_state(pdev,
-                              PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
-                              PCIE_LINK_STATE_CLKPM);
-
-       if (pci_enable_device(pdev)) {
-               err = -ENODEV;
-               goto out_ieee80211_free_hw;
-       }
-
-       pci_set_master(pdev);
-
-       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
-       if (!err)
-               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
-       if (err) {
-               IL_WARN("No suitable DMA available.\n");
-               goto out_pci_disable_device;
-       }
-
-       pci_set_drvdata(pdev, il);
-       err = pci_request_regions(pdev, DRV_NAME);
-       if (err)
-               goto out_pci_disable_device;
-
-       /***********************
-        * 3. Read REV Register
-        * ********************/
-       il->hw_base = pci_ioremap_bar(pdev, 0);
-       if (!il->hw_base) {
-               err = -ENODEV;
-               goto out_pci_release_regions;
-       }
-
-       D_INFO("pci_resource_len = 0x%08llx\n",
-              (unsigned long long)pci_resource_len(pdev, 0));
-       D_INFO("pci_resource_base = %p\n", il->hw_base);
-
-       /* We disable the RETRY_TIMEOUT register (0x41) to keep
-        * PCI Tx retries from interfering with C3 CPU state */
-       pci_write_config_byte(pdev, 0x41, 0x00);
-
-       /* these spin locks will be used in apm_init and EEPROM access
-        * we should init now
-        */
-       spin_lock_init(&il->reg_lock);
-       spin_lock_init(&il->lock);
-
-       /*
-        * stop and reset the on-board processor just in case it is in a
-        * strange state ... like being left stranded by a primary kernel
-        * and this is now the kdump kernel trying to start up
-        */
-       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
-
-       /***********************
-        * 4. Read EEPROM
-        * ********************/
-
-       /* Read the EEPROM */
-       err = il_eeprom_init(il);
-       if (err) {
-               IL_ERR("Unable to init EEPROM\n");
-               goto out_iounmap;
-       }
-       /* MAC Address location in EEPROM same for 3945/4965 */
-       eeprom = (struct il3945_eeprom *)il->eeprom;
-       D_INFO("MAC address: %pM\n", eeprom->mac_address);
-       SET_IEEE80211_PERM_ADDR(il->hw, eeprom->mac_address);
-
-       /***********************
-        * 5. Setup HW Constants
-        * ********************/
-       /* Device-specific setup */
-       err = il3945_hw_set_hw_params(il);
-       if (err) {
-               IL_ERR("failed to set hw settings\n");
-               goto out_eeprom_free;
-       }
-
-       /***********************
-        * 6. Setup il
-        * ********************/
-
-       err = il3945_init_drv(il);
-       if (err) {
-               IL_ERR("initializing driver failed\n");
-               goto out_unset_hw_params;
-       }
-
-       IL_INFO("Detected Intel Wireless WiFi Link %s\n", il->cfg->name);
-
-       /***********************
-        * 7. Setup Services
-        * ********************/
-
-       spin_lock_irqsave(&il->lock, flags);
-       il_disable_interrupts(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       pci_enable_msi(il->pci_dev);
-
-       err = request_irq(il->pci_dev->irq, il_isr, IRQF_SHARED, DRV_NAME, il);
-       if (err) {
-               IL_ERR("Error allocating IRQ %d\n", il->pci_dev->irq);
-               goto out_disable_msi;
-       }
-
-       err = sysfs_create_group(&pdev->dev.kobj, &il3945_attribute_group);
-       if (err) {
-               IL_ERR("failed to create sysfs device attributes\n");
-               goto out_release_irq;
-       }
-
-       il_set_rxon_channel(il, &il->bands[IEEE80211_BAND_2GHZ].channels[5]);
-       il3945_setup_deferred_work(il);
-       il3945_setup_handlers(il);
-       il_power_initialize(il);
-
-       /*********************************
-        * 8. Setup and Register mac80211
-        * *******************************/
-
-       il_enable_interrupts(il);
-
-       err = il3945_setup_mac(il);
-       if (err)
-               goto out_remove_sysfs;
-
-       err = il_dbgfs_register(il, DRV_NAME);
-       if (err)
-               IL_ERR("failed to create debugfs files. Ignoring error: %d\n",
-                      err);
-
-       /* Start monitoring the killswitch */
-       queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll, 2 * HZ);
-
-       return 0;
-
-out_remove_sysfs:
-       destroy_workqueue(il->workqueue);
-       il->workqueue = NULL;
-       sysfs_remove_group(&pdev->dev.kobj, &il3945_attribute_group);
-out_release_irq:
-       free_irq(il->pci_dev->irq, il);
-out_disable_msi:
-       pci_disable_msi(il->pci_dev);
-       il_free_geos(il);
-       il_free_channel_map(il);
-out_unset_hw_params:
-       il3945_unset_hw_params(il);
-out_eeprom_free:
-       il_eeprom_free(il);
-out_iounmap:
-       iounmap(il->hw_base);
-out_pci_release_regions:
-       pci_release_regions(pdev);
-out_pci_disable_device:
-       pci_disable_device(pdev);
-out_ieee80211_free_hw:
-       ieee80211_free_hw(il->hw);
-out:
-       return err;
-}
-
-static void
-il3945_pci_remove(struct pci_dev *pdev)
-{
-       struct il_priv *il = pci_get_drvdata(pdev);
-       unsigned long flags;
-
-       if (!il)
-               return;
-
-       D_INFO("*** UNLOAD DRIVER ***\n");
-
-       il_dbgfs_unregister(il);
-
-       set_bit(S_EXIT_PENDING, &il->status);
-
-       il_leds_exit(il);
-
-       if (il->mac80211_registered) {
-               ieee80211_unregister_hw(il->hw);
-               il->mac80211_registered = 0;
-       } else {
-               il3945_down(il);
-       }
-
-       /*
-        * Make sure device is reset to low power before unloading driver.
-        * This may be redundant with il_down(), but there are paths to
-        * run il_down() without calling apm_ops.stop(), and there are
-        * paths to avoid running il_down() at all before leaving driver.
-        * This (inexpensive) call *makes sure* device is reset.
-        */
-       il_apm_stop(il);
-
-       /* make sure we flush any pending irq or
-        * tasklet for the driver
-        */
-       spin_lock_irqsave(&il->lock, flags);
-       il_disable_interrupts(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       il3945_synchronize_irq(il);
-
-       sysfs_remove_group(&pdev->dev.kobj, &il3945_attribute_group);
-
-       cancel_delayed_work_sync(&il->_3945.rfkill_poll);
-
-       il3945_dealloc_ucode_pci(il);
-
-       if (il->rxq.bd)
-               il3945_rx_queue_free(il, &il->rxq);
-       il3945_hw_txq_ctx_free(il);
-
-       il3945_unset_hw_params(il);
-
-       /*netif_stop_queue(dev); */
-       flush_workqueue(il->workqueue);
-
-       /* ieee80211_unregister_hw calls il3945_mac_stop, which flushes
-        * il->workqueue... so we can't take down the workqueue
-        * until now... */
-       destroy_workqueue(il->workqueue);
-       il->workqueue = NULL;
-
-       free_irq(pdev->irq, il);
-       pci_disable_msi(pdev);
-
-       iounmap(il->hw_base);
-       pci_release_regions(pdev);
-       pci_disable_device(pdev);
-
-       il_free_channel_map(il);
-       il_free_geos(il);
-       kfree(il->scan_cmd);
-       if (il->beacon_skb)
-               dev_kfree_skb(il->beacon_skb);
-
-       ieee80211_free_hw(il->hw);
-}
-
-/*****************************************************************************
- *
- * driver and module entry point
- *
- *****************************************************************************/
-
-static struct pci_driver il3945_driver = {
-       .name = DRV_NAME,
-       .id_table = il3945_hw_card_ids,
-       .probe = il3945_pci_probe,
-       .remove = il3945_pci_remove,
-       .driver.pm = IL_LEGACY_PM_OPS,
-};
-
-static int __init
-il3945_init(void)
-{
-
-       int ret;
-       pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
-       pr_info(DRV_COPYRIGHT "\n");
-
-       ret = il3945_rate_control_register();
-       if (ret) {
-               pr_err("Unable to register rate control algorithm: %d\n", ret);
-               return ret;
-       }
-
-       ret = pci_register_driver(&il3945_driver);
-       if (ret) {
-               pr_err("Unable to initialize PCI module\n");
-               goto error_register;
-       }
-
-       return ret;
-
-error_register:
-       il3945_rate_control_unregister();
-       return ret;
-}
-
-static void __exit
-il3945_exit(void)
-{
-       pci_unregister_driver(&il3945_driver);
-       il3945_rate_control_unregister();
-}
-
-MODULE_FIRMWARE(IL3945_MODULE_FIRMWARE(IL3945_UCODE_API_MAX));
-
-module_param_named(antenna, il3945_mod_params.antenna, int, S_IRUGO);
-MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
-module_param_named(swcrypto, il3945_mod_params.sw_crypto, int, S_IRUGO);
-MODULE_PARM_DESC(swcrypto, "using software crypto (default 1 [software])");
-module_param_named(disable_hw_scan, il3945_mod_params.disable_hw_scan, int,
-                  S_IRUGO);
-MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 1)");
-#ifdef CONFIG_IWLEGACY_DEBUG
-module_param_named(debug, il_debug_level, uint, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "debug output mask");
-#endif
-module_param_named(fw_restart, il3945_mod_params.restart_fw, int, S_IRUGO);
-MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
-
-module_exit(il3945_exit);
-module_init(il3945_init);
diff --git a/drivers/net/wireless/iwlegacy/3945-rs.c b/drivers/net/wireless/iwlegacy/3945-rs.c
deleted file mode 100644 (file)
index 76b0729..0000000
+++ /dev/null
@@ -1,979 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#include <linux/kernel.h>
-#include <linux/skbuff.h>
-#include <linux/slab.h>
-#include <net/mac80211.h>
-
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/delay.h>
-
-#include <linux/workqueue.h>
-
-#include "commands.h"
-#include "3945.h"
-
-#define RS_NAME "iwl-3945-rs"
-
-static s32 il3945_expected_tpt_g[RATE_COUNT_3945] = {
-       7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202
-};
-
-static s32 il3945_expected_tpt_g_prot[RATE_COUNT_3945] = {
-       7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125
-};
-
-static s32 il3945_expected_tpt_a[RATE_COUNT_3945] = {
-       0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186
-};
-
-static s32 il3945_expected_tpt_b[RATE_COUNT_3945] = {
-       7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
-struct il3945_tpt_entry {
-       s8 min_rssi;
-       u8 idx;
-};
-
-static struct il3945_tpt_entry il3945_tpt_table_a[] = {
-       {-60, RATE_54M_IDX},
-       {-64, RATE_48M_IDX},
-       {-72, RATE_36M_IDX},
-       {-80, RATE_24M_IDX},
-       {-84, RATE_18M_IDX},
-       {-85, RATE_12M_IDX},
-       {-87, RATE_9M_IDX},
-       {-89, RATE_6M_IDX}
-};
-
-static struct il3945_tpt_entry il3945_tpt_table_g[] = {
-       {-60, RATE_54M_IDX},
-       {-64, RATE_48M_IDX},
-       {-68, RATE_36M_IDX},
-       {-80, RATE_24M_IDX},
-       {-84, RATE_18M_IDX},
-       {-85, RATE_12M_IDX},
-       {-86, RATE_11M_IDX},
-       {-88, RATE_5M_IDX},
-       {-90, RATE_2M_IDX},
-       {-92, RATE_1M_IDX}
-};
-
-#define RATE_MAX_WINDOW                62
-#define RATE_FLUSH             (3*HZ)
-#define RATE_WIN_FLUSH         (HZ/2)
-#define IL39_RATE_HIGH_TH      11520
-#define IL_SUCCESS_UP_TH       8960
-#define IL_SUCCESS_DOWN_TH     10880
-#define RATE_MIN_FAILURE_TH    6
-#define RATE_MIN_SUCCESS_TH    8
-#define RATE_DECREASE_TH       1920
-#define RATE_RETRY_TH          15
-
-static u8
-il3945_get_rate_idx_by_rssi(s32 rssi, enum ieee80211_band band)
-{
-       u32 idx = 0;
-       u32 table_size = 0;
-       struct il3945_tpt_entry *tpt_table = NULL;
-
-       if (rssi < IL_MIN_RSSI_VAL || rssi > IL_MAX_RSSI_VAL)
-               rssi = IL_MIN_RSSI_VAL;
-
-       switch (band) {
-       case IEEE80211_BAND_2GHZ:
-               tpt_table = il3945_tpt_table_g;
-               table_size = ARRAY_SIZE(il3945_tpt_table_g);
-               break;
-       case IEEE80211_BAND_5GHZ:
-               tpt_table = il3945_tpt_table_a;
-               table_size = ARRAY_SIZE(il3945_tpt_table_a);
-               break;
-       default:
-               BUG();
-               break;
-       }
-
-       while (idx < table_size && rssi < tpt_table[idx].min_rssi)
-               idx++;
-
-       idx = min(idx, table_size - 1);
-
-       return tpt_table[idx].idx;
-}
-
-static void
-il3945_clear_win(struct il3945_rate_scale_data *win)
-{
-       win->data = 0;
-       win->success_counter = 0;
-       win->success_ratio = -1;
-       win->counter = 0;
-       win->average_tpt = IL_INVALID_VALUE;
-       win->stamp = 0;
-}
-
-/**
- * il3945_rate_scale_flush_wins - flush out the rate scale wins
- *
- * Returns the number of wins that have gathered data but were
- * not flushed.  If there were any that were not flushed, then
- * reschedule the rate flushing routine.
- */
-static int
-il3945_rate_scale_flush_wins(struct il3945_rs_sta *rs_sta)
-{
-       int unflushed = 0;
-       int i;
-       unsigned long flags;
-       struct il_priv *il __maybe_unused = rs_sta->il;
-
-       /*
-        * For each rate, if we have collected data on that rate
-        * and it has been more than RATE_WIN_FLUSH
-        * since we flushed, clear out the gathered stats
-        */
-       for (i = 0; i < RATE_COUNT_3945; i++) {
-               if (!rs_sta->win[i].counter)
-                       continue;
-
-               spin_lock_irqsave(&rs_sta->lock, flags);
-               if (time_after(jiffies, rs_sta->win[i].stamp + RATE_WIN_FLUSH)) {
-                       D_RATE("flushing %d samples of rate " "idx %d\n",
-                              rs_sta->win[i].counter, i);
-                       il3945_clear_win(&rs_sta->win[i]);
-               } else
-                       unflushed++;
-               spin_unlock_irqrestore(&rs_sta->lock, flags);
-       }
-
-       return unflushed;
-}
-
-#define RATE_FLUSH_MAX              5000       /* msec */
-#define RATE_FLUSH_MIN              50 /* msec */
-#define IL_AVERAGE_PACKETS             1500
-
-static void
-il3945_bg_rate_scale_flush(unsigned long data)
-{
-       struct il3945_rs_sta *rs_sta = (void *)data;
-       struct il_priv *il __maybe_unused = rs_sta->il;
-       int unflushed = 0;
-       unsigned long flags;
-       u32 packet_count, duration, pps;
-
-       D_RATE("enter\n");
-
-       unflushed = il3945_rate_scale_flush_wins(rs_sta);
-
-       spin_lock_irqsave(&rs_sta->lock, flags);
-
-       /* Number of packets Rx'd since last time this timer ran */
-       packet_count = (rs_sta->tx_packets - rs_sta->last_tx_packets) + 1;
-
-       rs_sta->last_tx_packets = rs_sta->tx_packets + 1;
-
-       if (unflushed) {
-               duration =
-                   jiffies_to_msecs(jiffies - rs_sta->last_partial_flush);
-
-               D_RATE("Tx'd %d packets in %dms\n", packet_count, duration);
-
-               /* Determine packets per second */
-               if (duration)
-                       pps = (packet_count * 1000) / duration;
-               else
-                       pps = 0;
-
-               if (pps) {
-                       duration = (IL_AVERAGE_PACKETS * 1000) / pps;
-                       if (duration < RATE_FLUSH_MIN)
-                               duration = RATE_FLUSH_MIN;
-                       else if (duration > RATE_FLUSH_MAX)
-                               duration = RATE_FLUSH_MAX;
-               } else
-                       duration = RATE_FLUSH_MAX;
-
-               rs_sta->flush_time = msecs_to_jiffies(duration);
-
-               D_RATE("new flush period: %d msec ave %d\n", duration,
-                      packet_count);
-
-               mod_timer(&rs_sta->rate_scale_flush,
-                         jiffies + rs_sta->flush_time);
-
-               rs_sta->last_partial_flush = jiffies;
-       } else {
-               rs_sta->flush_time = RATE_FLUSH;
-               rs_sta->flush_pending = 0;
-       }
-       /* If there weren't any unflushed entries, we don't schedule the timer
-        * to run again */
-
-       rs_sta->last_flush = jiffies;
-
-       spin_unlock_irqrestore(&rs_sta->lock, flags);
-
-       D_RATE("leave\n");
-}
-
-/**
- * il3945_collect_tx_data - Update the success/failure sliding win
- *
- * We keep a sliding win of the last 64 packets transmitted
- * at this rate.  win->data contains the bitmask of successful
- * packets.
- */
-static void
-il3945_collect_tx_data(struct il3945_rs_sta *rs_sta,
-                      struct il3945_rate_scale_data *win, int success,
-                      int retries, int idx)
-{
-       unsigned long flags;
-       s32 fail_count;
-       struct il_priv *il __maybe_unused = rs_sta->il;
-
-       if (!retries) {
-               D_RATE("leave: retries == 0 -- should be at least 1\n");
-               return;
-       }
-
-       spin_lock_irqsave(&rs_sta->lock, flags);
-
-       /*
-        * Keep track of only the latest 62 tx frame attempts in this rate's
-        * history win; anything older isn't really relevant any more.
-        * If we have filled up the sliding win, 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 (win->counter >= RATE_MAX_WINDOW) {
-
-                       /* remove earliest */
-                       win->counter = RATE_MAX_WINDOW - 1;
-
-                       if (win->data & (1ULL << (RATE_MAX_WINDOW - 1))) {
-                               win->data &= ~(1ULL << (RATE_MAX_WINDOW - 1));
-                               win->success_counter--;
-                       }
-               }
-
-               /* Increment frames-attempted counter */
-               win->counter++;
-
-               /* Shift bitmap by one frame (throw away oldest history),
-                * OR in "1", and increment "success" if this
-                * frame was successful. */
-               win->data <<= 1;
-               if (success > 0) {
-                       win->success_counter++;
-                       win->data |= 0x1;
-                       success--;
-               }
-
-               retries--;
-       }
-
-       /* Calculate current success ratio, avoid divide-by-0! */
-       if (win->counter > 0)
-               win->success_ratio =
-                   128 * (100 * win->success_counter) / win->counter;
-       else
-               win->success_ratio = IL_INVALID_VALUE;
-
-       fail_count = win->counter - win->success_counter;
-
-       /* Calculate average throughput, if we have enough history. */
-       if (fail_count >= RATE_MIN_FAILURE_TH ||
-           win->success_counter >= RATE_MIN_SUCCESS_TH)
-               win->average_tpt =
-                   ((win->success_ratio * rs_sta->expected_tpt[idx] +
-                     64) / 128);
-       else
-               win->average_tpt = IL_INVALID_VALUE;
-
-       /* Tag this win as having been updated */
-       win->stamp = jiffies;
-
-       spin_unlock_irqrestore(&rs_sta->lock, flags);
-}
-
-/*
- * Called after adding a new station to initialize rate scaling
- */
-void
-il3945_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
-{
-       struct ieee80211_hw *hw = il->hw;
-       struct ieee80211_conf *conf = &il->hw->conf;
-       struct il3945_sta_priv *psta;
-       struct il3945_rs_sta *rs_sta;
-       struct ieee80211_supported_band *sband;
-       int i;
-
-       D_INFO("enter\n");
-       if (sta_id == il->hw_params.bcast_id)
-               goto out;
-
-       psta = (struct il3945_sta_priv *)sta->drv_priv;
-       rs_sta = &psta->rs_sta;
-       sband = hw->wiphy->bands[conf->chandef.chan->band];
-
-       rs_sta->il = il;
-
-       rs_sta->start_rate = RATE_INVALID;
-
-       /* default to just 802.11b */
-       rs_sta->expected_tpt = il3945_expected_tpt_b;
-
-       rs_sta->last_partial_flush = jiffies;
-       rs_sta->last_flush = jiffies;
-       rs_sta->flush_time = RATE_FLUSH;
-       rs_sta->last_tx_packets = 0;
-
-       rs_sta->rate_scale_flush.data = (unsigned long)rs_sta;
-       rs_sta->rate_scale_flush.function = il3945_bg_rate_scale_flush;
-
-       for (i = 0; i < RATE_COUNT_3945; i++)
-               il3945_clear_win(&rs_sta->win[i]);
-
-       /* TODO: what is a good starting rate for STA? About middle? Maybe not
-        * the lowest or the highest rate.. Could consider using RSSI from
-        * previous packets? Need to have IEEE 802.1X auth succeed immediately
-        * after assoc.. */
-
-       for (i = sband->n_bitrates - 1; i >= 0; i--) {
-               if (sta->supp_rates[sband->band] & (1 << i)) {
-                       rs_sta->last_txrate_idx = i;
-                       break;
-               }
-       }
-
-       il->_3945.sta_supp_rates = sta->supp_rates[sband->band];
-       /* For 5 GHz band it start at IL_FIRST_OFDM_RATE */
-       if (sband->band == IEEE80211_BAND_5GHZ) {
-               rs_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
-               il->_3945.sta_supp_rates <<= IL_FIRST_OFDM_RATE;
-       }
-
-out:
-       il->stations[sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
-
-       D_INFO("leave\n");
-}
-
-static void *
-il3945_rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
-{
-       return hw->priv;
-}
-
-/* rate scale requires free function to be implemented */
-static void
-il3945_rs_free(void *il)
-{
-}
-
-static void *
-il3945_rs_alloc_sta(void *il_priv, struct ieee80211_sta *sta, gfp_t gfp)
-{
-       struct il3945_rs_sta *rs_sta;
-       struct il3945_sta_priv *psta = (void *)sta->drv_priv;
-       struct il_priv *il __maybe_unused = il_priv;
-
-       D_RATE("enter\n");
-
-       rs_sta = &psta->rs_sta;
-
-       spin_lock_init(&rs_sta->lock);
-       init_timer(&rs_sta->rate_scale_flush);
-
-       D_RATE("leave\n");
-
-       return rs_sta;
-}
-
-static void
-il3945_rs_free_sta(void *il_priv, struct ieee80211_sta *sta, void *il_sta)
-{
-       struct il3945_rs_sta *rs_sta = il_sta;
-
-       /*
-        * Be careful not to use any members of il3945_rs_sta (like trying
-        * to use il_priv to print out debugging) since it may not be fully
-        * initialized at this point.
-        */
-       del_timer_sync(&rs_sta->rate_scale_flush);
-}
-
-/**
- * il3945_rs_tx_status - Update rate control values based on Tx results
- *
- * NOTE: Uses il_priv->retry_rate for the # of retries attempted by
- * the hardware for each rate.
- */
-static void
-il3945_rs_tx_status(void *il_rate, struct ieee80211_supported_band *sband,
-                   struct ieee80211_sta *sta, void *il_sta,
-                   struct sk_buff *skb)
-{
-       s8 retries = 0, current_count;
-       int scale_rate_idx, first_idx, last_idx;
-       unsigned long flags;
-       struct il_priv *il = (struct il_priv *)il_rate;
-       struct il3945_rs_sta *rs_sta = il_sta;
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-
-       D_RATE("enter\n");
-
-       retries = info->status.rates[0].count;
-       /* Sanity Check for retries */
-       if (retries > RATE_RETRY_TH)
-               retries = RATE_RETRY_TH;
-
-       first_idx = sband->bitrates[info->status.rates[0].idx].hw_value;
-       if (first_idx < 0 || first_idx >= RATE_COUNT_3945) {
-               D_RATE("leave: Rate out of bounds: %d\n", first_idx);
-               return;
-       }
-
-       if (!il_sta) {
-               D_RATE("leave: No STA il data to update!\n");
-               return;
-       }
-
-       /* Treat uninitialized rate scaling data same as non-existing. */
-       if (!rs_sta->il) {
-               D_RATE("leave: STA il data uninitialized!\n");
-               return;
-       }
-
-       rs_sta->tx_packets++;
-
-       scale_rate_idx = first_idx;
-       last_idx = first_idx;
-
-       /*
-        * Update the win for each rate.  We determine which rates
-        * were Tx'd based on the total number of retries vs. the number
-        * of retries configured for each rate -- currently set to the
-        * il value 'retry_rate' vs. rate specific
-        *
-        * On exit from this while loop last_idx indicates the rate
-        * at which the frame was finally transmitted (or failed if no
-        * ACK)
-        */
-       while (retries > 1) {
-               if ((retries - 1) < il->retry_rate) {
-                       current_count = (retries - 1);
-                       last_idx = scale_rate_idx;
-               } else {
-                       current_count = il->retry_rate;
-                       last_idx = il3945_rs_next_rate(il, scale_rate_idx);
-               }
-
-               /* Update this rate accounting for as many retries
-                * as was used for it (per current_count) */
-               il3945_collect_tx_data(rs_sta, &rs_sta->win[scale_rate_idx], 0,
-                                      current_count, scale_rate_idx);
-               D_RATE("Update rate %d for %d retries.\n", scale_rate_idx,
-                      current_count);
-
-               retries -= current_count;
-
-               scale_rate_idx = last_idx;
-       }
-
-       /* Update the last idx win with success/failure based on ACK */
-       D_RATE("Update rate %d with %s.\n", last_idx,
-              (info->flags & IEEE80211_TX_STAT_ACK) ? "success" : "failure");
-       il3945_collect_tx_data(rs_sta, &rs_sta->win[last_idx],
-                              info->flags & IEEE80211_TX_STAT_ACK, 1,
-                              last_idx);
-
-       /* We updated the rate scale win -- if its been more than
-        * flush_time since the last run, schedule the flush
-        * again */
-       spin_lock_irqsave(&rs_sta->lock, flags);
-
-       if (!rs_sta->flush_pending &&
-           time_after(jiffies, rs_sta->last_flush + rs_sta->flush_time)) {
-
-               rs_sta->last_partial_flush = jiffies;
-               rs_sta->flush_pending = 1;
-               mod_timer(&rs_sta->rate_scale_flush,
-                         jiffies + rs_sta->flush_time);
-       }
-
-       spin_unlock_irqrestore(&rs_sta->lock, flags);
-
-       D_RATE("leave\n");
-}
-
-static u16
-il3945_get_adjacent_rate(struct il3945_rs_sta *rs_sta, u8 idx, u16 rate_mask,
-                        enum ieee80211_band band)
-{
-       u8 high = RATE_INVALID;
-       u8 low = RATE_INVALID;
-       struct il_priv *il __maybe_unused = rs_sta->il;
-
-       /* 802.11A walks to the next literal adjacent rate in
-        * the rate table */
-       if (unlikely(band == IEEE80211_BAND_5GHZ)) {
-               int i;
-               u32 mask;
-
-               /* Find the previous rate that is in the rate mask */
-               i = idx - 1;
-               for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
-                       if (rate_mask & mask) {
-                               low = i;
-                               break;
-                       }
-               }
-
-               /* Find the next rate that is in the rate mask */
-               i = idx + 1;
-               for (mask = (1 << i); i < RATE_COUNT_3945; i++, mask <<= 1) {
-                       if (rate_mask & mask) {
-                               high = i;
-                               break;
-                       }
-               }
-
-               return (high << 8) | low;
-       }
-
-       low = idx;
-       while (low != RATE_INVALID) {
-               if (rs_sta->tgg)
-                       low = il3945_rates[low].prev_rs_tgg;
-               else
-                       low = il3945_rates[low].prev_rs;
-               if (low == RATE_INVALID)
-                       break;
-               if (rate_mask & (1 << low))
-                       break;
-               D_RATE("Skipping masked lower rate: %d\n", low);
-       }
-
-       high = idx;
-       while (high != RATE_INVALID) {
-               if (rs_sta->tgg)
-                       high = il3945_rates[high].next_rs_tgg;
-               else
-                       high = il3945_rates[high].next_rs;
-               if (high == RATE_INVALID)
-                       break;
-               if (rate_mask & (1 << high))
-                       break;
-               D_RATE("Skipping masked higher rate: %d\n", high);
-       }
-
-       return (high << 8) | low;
-}
-
-/**
- * il3945_rs_get_rate - find the rate for the requested packet
- *
- * Returns the ieee80211_rate structure allocated by the driver.
- *
- * The rate control algorithm has no internal mapping between hw_mode's
- * rate ordering and the rate ordering used by the rate control algorithm.
- *
- * The rate control algorithm uses a single table of rates that goes across
- * the entire A/B/G spectrum vs. being limited to just one particular
- * hw_mode.
- *
- * As such, we can't convert the idx obtained below into the hw_mode's
- * rate table and must reference the driver allocated rate table
- *
- */
-static void
-il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
-                  struct ieee80211_tx_rate_control *txrc)
-{
-       struct ieee80211_supported_band *sband = txrc->sband;
-       struct sk_buff *skb = txrc->skb;
-       u8 low = RATE_INVALID;
-       u8 high = RATE_INVALID;
-       u16 high_low;
-       int idx;
-       struct il3945_rs_sta *rs_sta = il_sta;
-       struct il3945_rate_scale_data *win = NULL;
-       int current_tpt = IL_INVALID_VALUE;
-       int low_tpt = IL_INVALID_VALUE;
-       int high_tpt = IL_INVALID_VALUE;
-       u32 fail_count;
-       s8 scale_action = 0;
-       unsigned long flags;
-       u16 rate_mask;
-       s8 max_rate_idx = -1;
-       struct il_priv *il __maybe_unused = (struct il_priv *)il_r;
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-
-       D_RATE("enter\n");
-
-       /* Treat uninitialized rate scaling data same as non-existing. */
-       if (rs_sta && !rs_sta->il) {
-               D_RATE("Rate scaling information not initialized yet.\n");
-               il_sta = NULL;
-       }
-
-       if (rate_control_send_low(sta, il_sta, txrc))
-               return;
-
-       rate_mask = sta->supp_rates[sband->band];
-
-       /* get user max rate if set */
-       max_rate_idx = txrc->max_rate_idx;
-       if (sband->band == IEEE80211_BAND_5GHZ && max_rate_idx != -1)
-               max_rate_idx += IL_FIRST_OFDM_RATE;
-       if (max_rate_idx < 0 || max_rate_idx >= RATE_COUNT)
-               max_rate_idx = -1;
-
-       idx = min(rs_sta->last_txrate_idx & 0xffff, RATE_COUNT_3945 - 1);
-
-       if (sband->band == IEEE80211_BAND_5GHZ)
-               rate_mask = rate_mask << IL_FIRST_OFDM_RATE;
-
-       spin_lock_irqsave(&rs_sta->lock, flags);
-
-       /* for recent assoc, choose best rate regarding
-        * to rssi value
-        */
-       if (rs_sta->start_rate != RATE_INVALID) {
-               if (rs_sta->start_rate < idx &&
-                   (rate_mask & (1 << rs_sta->start_rate)))
-                       idx = rs_sta->start_rate;
-               rs_sta->start_rate = RATE_INVALID;
-       }
-
-       /* force user max rate if set by user */
-       if (max_rate_idx != -1 && max_rate_idx < idx) {
-               if (rate_mask & (1 << max_rate_idx))
-                       idx = max_rate_idx;
-       }
-
-       win = &(rs_sta->win[idx]);
-
-       fail_count = win->counter - win->success_counter;
-
-       if (fail_count < RATE_MIN_FAILURE_TH &&
-           win->success_counter < RATE_MIN_SUCCESS_TH) {
-               spin_unlock_irqrestore(&rs_sta->lock, flags);
-
-               D_RATE("Invalid average_tpt on rate %d: "
-                      "counter: %d, success_counter: %d, "
-                      "expected_tpt is %sNULL\n", idx, win->counter,
-                      win->success_counter,
-                      rs_sta->expected_tpt ? "not " : "");
-
-               /* Can't calculate this yet; not enough history */
-               win->average_tpt = IL_INVALID_VALUE;
-               goto out;
-
-       }
-
-       current_tpt = win->average_tpt;
-
-       high_low =
-           il3945_get_adjacent_rate(rs_sta, idx, rate_mask, sband->band);
-       low = high_low & 0xff;
-       high = (high_low >> 8) & 0xff;
-
-       /* If user set max rate, dont allow higher than user constrain */
-       if (max_rate_idx != -1 && max_rate_idx < high)
-               high = RATE_INVALID;
-
-       /* Collect Measured throughputs of adjacent rates */
-       if (low != RATE_INVALID)
-               low_tpt = rs_sta->win[low].average_tpt;
-
-       if (high != RATE_INVALID)
-               high_tpt = rs_sta->win[high].average_tpt;
-
-       spin_unlock_irqrestore(&rs_sta->lock, flags);
-
-       scale_action = 0;
-
-       /* Low success ratio , need to drop the rate */
-       if (win->success_ratio < RATE_DECREASE_TH || !current_tpt) {
-               D_RATE("decrease rate because of low success_ratio\n");
-               scale_action = -1;
-               /* No throughput measured yet for adjacent rates,
-                * try increase */
-       } else if (low_tpt == IL_INVALID_VALUE && high_tpt == IL_INVALID_VALUE) {
-
-               if (high != RATE_INVALID &&
-                   win->success_ratio >= RATE_INCREASE_TH)
-                       scale_action = 1;
-               else if (low != RATE_INVALID)
-                       scale_action = 0;
-
-               /* 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 != IL_INVALID_VALUE && high_tpt != IL_INVALID_VALUE
-                  && low_tpt < current_tpt && high_tpt < current_tpt) {
-
-               D_RATE("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 != IL_INVALID_VALUE) {
-
-                       /* High rate has better throughput, Increase
-                        * rate */
-                       if (high_tpt > current_tpt &&
-                           win->success_ratio >= RATE_INCREASE_TH)
-                               scale_action = 1;
-                       else {
-                               D_RATE("decrease rate because of high tpt\n");
-                               scale_action = 0;
-                       }
-               } else if (low_tpt != IL_INVALID_VALUE) {
-                       if (low_tpt > current_tpt) {
-                               D_RATE("decrease rate because of low tpt\n");
-                               scale_action = -1;
-                       } else if (win->success_ratio >= RATE_INCREASE_TH) {
-                               /* Lower rate has better
-                                * throughput,decrease rate */
-                               scale_action = 1;
-                       }
-               }
-       }
-
-       /* 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 != RATE_INVALID &&
-           (win->success_ratio > RATE_HIGH_TH ||
-            current_tpt > 100 * rs_sta->expected_tpt[low]))
-               scale_action = 0;
-
-       switch (scale_action) {
-       case -1:
-               /* Decrese rate */
-               if (low != RATE_INVALID)
-                       idx = low;
-               break;
-       case 1:
-               /* Increase rate */
-               if (high != RATE_INVALID)
-                       idx = high;
-
-               break;
-       case 0:
-       default:
-               /* No change */
-               break;
-       }
-
-       D_RATE("Selected %d (action %d) - low %d high %d\n", idx, scale_action,
-              low, high);
-
-out:
-
-       if (sband->band == IEEE80211_BAND_5GHZ) {
-               if (WARN_ON_ONCE(idx < IL_FIRST_OFDM_RATE))
-                       idx = IL_FIRST_OFDM_RATE;
-               rs_sta->last_txrate_idx = idx;
-               info->control.rates[0].idx = idx - IL_FIRST_OFDM_RATE;
-       } else {
-               rs_sta->last_txrate_idx = idx;
-               info->control.rates[0].idx = rs_sta->last_txrate_idx;
-       }
-       info->control.rates[0].count = 1;
-
-       D_RATE("leave: %d\n", idx);
-}
-
-#ifdef CONFIG_MAC80211_DEBUGFS
-
-static ssize_t
-il3945_sta_dbgfs_stats_table_read(struct file *file, char __user *user_buf,
-                                 size_t count, loff_t *ppos)
-{
-       char *buff;
-       int desc = 0;
-       int j;
-       ssize_t ret;
-       struct il3945_rs_sta *lq_sta = file->private_data;
-
-       buff = kmalloc(1024, GFP_KERNEL);
-       if (!buff)
-               return -ENOMEM;
-
-       desc +=
-           sprintf(buff + desc,
-                   "tx packets=%d last rate idx=%d\n"
-                   "rate=0x%X flush time %d\n", lq_sta->tx_packets,
-                   lq_sta->last_txrate_idx, lq_sta->start_rate,
-                   jiffies_to_msecs(lq_sta->flush_time));
-       for (j = 0; j < RATE_COUNT_3945; j++) {
-               desc +=
-                   sprintf(buff + desc, "counter=%d success=%d %%=%d\n",
-                           lq_sta->win[j].counter,
-                           lq_sta->win[j].success_counter,
-                           lq_sta->win[j].success_ratio);
-       }
-       ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
-       kfree(buff);
-       return ret;
-}
-
-static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
-       .read = il3945_sta_dbgfs_stats_table_read,
-       .open = simple_open,
-       .llseek = default_llseek,
-};
-
-static void
-il3945_add_debugfs(void *il, void *il_sta, struct dentry *dir)
-{
-       struct il3945_rs_sta *lq_sta = il_sta;
-
-       lq_sta->rs_sta_dbgfs_stats_table_file =
-           debugfs_create_file("rate_stats_table", 0600, dir, lq_sta,
-                               &rs_sta_dbgfs_stats_table_ops);
-
-}
-
-static void
-il3945_remove_debugfs(void *il, void *il_sta)
-{
-       struct il3945_rs_sta *lq_sta = il_sta;
-       debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
-}
-#endif
-
-/*
- * Initialization of rate scaling information is done by driver after
- * the station is added. Since mac80211 calls this function before a
- * station is added we ignore it.
- */
-static void
-il3945_rs_rate_init_stub(void *il_r, struct ieee80211_supported_band *sband,
-                        struct cfg80211_chan_def *chandef,
-                        struct ieee80211_sta *sta, void *il_sta)
-{
-}
-
-static const struct rate_control_ops rs_ops = {
-       .name = RS_NAME,
-       .tx_status = il3945_rs_tx_status,
-       .get_rate = il3945_rs_get_rate,
-       .rate_init = il3945_rs_rate_init_stub,
-       .alloc = il3945_rs_alloc,
-       .free = il3945_rs_free,
-       .alloc_sta = il3945_rs_alloc_sta,
-       .free_sta = il3945_rs_free_sta,
-#ifdef CONFIG_MAC80211_DEBUGFS
-       .add_sta_debugfs = il3945_add_debugfs,
-       .remove_sta_debugfs = il3945_remove_debugfs,
-#endif
-
-};
-
-void
-il3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
-{
-       struct il_priv *il = hw->priv;
-       s32 rssi = 0;
-       unsigned long flags;
-       struct il3945_rs_sta *rs_sta;
-       struct ieee80211_sta *sta;
-       struct il3945_sta_priv *psta;
-
-       D_RATE("enter\n");
-
-       rcu_read_lock();
-
-       sta = ieee80211_find_sta(il->vif, il->stations[sta_id].sta.sta.addr);
-       if (!sta) {
-               D_RATE("Unable to find station to initialize rate scaling.\n");
-               rcu_read_unlock();
-               return;
-       }
-
-       psta = (void *)sta->drv_priv;
-       rs_sta = &psta->rs_sta;
-
-       spin_lock_irqsave(&rs_sta->lock, flags);
-
-       rs_sta->tgg = 0;
-       switch (il->band) {
-       case IEEE80211_BAND_2GHZ:
-               /* TODO: this always does G, not a regression */
-               if (il->active.flags & RXON_FLG_TGG_PROTECT_MSK) {
-                       rs_sta->tgg = 1;
-                       rs_sta->expected_tpt = il3945_expected_tpt_g_prot;
-               } else
-                       rs_sta->expected_tpt = il3945_expected_tpt_g;
-               break;
-       case IEEE80211_BAND_5GHZ:
-               rs_sta->expected_tpt = il3945_expected_tpt_a;
-               break;
-       default:
-               BUG();
-               break;
-       }
-
-       spin_unlock_irqrestore(&rs_sta->lock, flags);
-
-       rssi = il->_3945.last_rx_rssi;
-       if (rssi == 0)
-               rssi = IL_MIN_RSSI_VAL;
-
-       D_RATE("Network RSSI: %d\n", rssi);
-
-       rs_sta->start_rate = il3945_get_rate_idx_by_rssi(rssi, il->band);
-
-       D_RATE("leave: rssi %d assign rate idx: " "%d (plcp 0x%x)\n", rssi,
-              rs_sta->start_rate, il3945_rates[rs_sta->start_rate].plcp);
-       rcu_read_unlock();
-}
-
-int
-il3945_rate_control_register(void)
-{
-       return ieee80211_rate_control_register(&rs_ops);
-}
-
-void
-il3945_rate_control_unregister(void)
-{
-       ieee80211_rate_control_unregister(&rs_ops);
-}
diff --git a/drivers/net/wireless/iwlegacy/3945.c b/drivers/net/wireless/iwlegacy/3945.c
deleted file mode 100644 (file)
index 93bdf68..0000000
+++ /dev/null
@@ -1,2741 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/pci.h>
-#include <linux/dma-mapping.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/skbuff.h>
-#include <linux/netdevice.h>
-#include <linux/firmware.h>
-#include <linux/etherdevice.h>
-#include <asm/unaligned.h>
-#include <net/mac80211.h>
-
-#include "common.h"
-#include "3945.h"
-
-/* Send led command */
-static int
-il3945_send_led_cmd(struct il_priv *il, struct il_led_cmd *led_cmd)
-{
-       struct il_host_cmd cmd = {
-               .id = C_LEDS,
-               .len = sizeof(struct il_led_cmd),
-               .data = led_cmd,
-               .flags = CMD_ASYNC,
-               .callback = NULL,
-       };
-
-       return il_send_cmd(il, &cmd);
-}
-
-#define IL_DECLARE_RATE_INFO(r, ip, in, rp, rn, pp, np)    \
-       [RATE_##r##M_IDX] = { RATE_##r##M_PLCP,   \
-                                   RATE_##r##M_IEEE,   \
-                                   RATE_##ip##M_IDX, \
-                                   RATE_##in##M_IDX, \
-                                   RATE_##rp##M_IDX, \
-                                   RATE_##rn##M_IDX, \
-                                   RATE_##pp##M_IDX, \
-                                   RATE_##np##M_IDX, \
-                                   RATE_##r##M_IDX_TBL, \
-                                   RATE_##ip##M_IDX_TBL }
-
-/*
- * Parameter order:
- *   rate, prev rate, next rate, prev tgg rate, next tgg rate
- *
- * If there isn't a valid next or previous rate then INV is used which
- * maps to RATE_INVALID
- *
- */
-const struct il3945_rate_info il3945_rates[RATE_COUNT_3945] = {
-       IL_DECLARE_RATE_INFO(1, INV, 2, INV, 2, INV, 2),        /*  1mbps */
-       IL_DECLARE_RATE_INFO(2, 1, 5, 1, 5, 1, 5),      /*  2mbps */
-       IL_DECLARE_RATE_INFO(5, 2, 6, 2, 11, 2, 11),    /*5.5mbps */
-       IL_DECLARE_RATE_INFO(11, 9, 12, 5, 12, 5, 18),  /* 11mbps */
-       IL_DECLARE_RATE_INFO(6, 5, 9, 5, 11, 5, 11),    /*  6mbps */
-       IL_DECLARE_RATE_INFO(9, 6, 11, 5, 11, 5, 11),   /*  9mbps */
-       IL_DECLARE_RATE_INFO(12, 11, 18, 11, 18, 11, 18),       /* 12mbps */
-       IL_DECLARE_RATE_INFO(18, 12, 24, 12, 24, 11, 24),       /* 18mbps */
-       IL_DECLARE_RATE_INFO(24, 18, 36, 18, 36, 18, 36),       /* 24mbps */
-       IL_DECLARE_RATE_INFO(36, 24, 48, 24, 48, 24, 48),       /* 36mbps */
-       IL_DECLARE_RATE_INFO(48, 36, 54, 36, 54, 36, 54),       /* 48mbps */
-       IL_DECLARE_RATE_INFO(54, 48, INV, 48, INV, 48, INV),    /* 54mbps */
-};
-
-static inline u8
-il3945_get_prev_ieee_rate(u8 rate_idx)
-{
-       u8 rate = il3945_rates[rate_idx].prev_ieee;
-
-       if (rate == RATE_INVALID)
-               rate = rate_idx;
-       return rate;
-}
-
-/* 1 = enable the il3945_disable_events() function */
-#define IL_EVT_DISABLE (0)
-#define IL_EVT_DISABLE_SIZE (1532/32)
-
-/**
- * il3945_disable_events - Disable selected events in uCode event log
- *
- * Disable an event by writing "1"s into "disable"
- *   bitmap in SRAM.  Bit position corresponds to Event # (id/type).
- *   Default values of 0 enable uCode events to be logged.
- * Use for only special debugging.  This function is just a placeholder as-is,
- *   you'll need to provide the special bits! ...
- *   ... and set IL_EVT_DISABLE to 1. */
-void
-il3945_disable_events(struct il_priv *il)
-{
-       int i;
-       u32 base;               /* SRAM address of event log header */
-       u32 disable_ptr;        /* SRAM address of event-disable bitmap array */
-       u32 array_size;         /* # of u32 entries in array */
-       static const u32 evt_disable[IL_EVT_DISABLE_SIZE] = {
-               0x00000000,     /*   31 -    0  Event id numbers */
-               0x00000000,     /*   63 -   32 */
-               0x00000000,     /*   95 -   64 */
-               0x00000000,     /*  127 -   96 */
-               0x00000000,     /*  159 -  128 */
-               0x00000000,     /*  191 -  160 */
-               0x00000000,     /*  223 -  192 */
-               0x00000000,     /*  255 -  224 */
-               0x00000000,     /*  287 -  256 */
-               0x00000000,     /*  319 -  288 */
-               0x00000000,     /*  351 -  320 */
-               0x00000000,     /*  383 -  352 */
-               0x00000000,     /*  415 -  384 */
-               0x00000000,     /*  447 -  416 */
-               0x00000000,     /*  479 -  448 */
-               0x00000000,     /*  511 -  480 */
-               0x00000000,     /*  543 -  512 */
-               0x00000000,     /*  575 -  544 */
-               0x00000000,     /*  607 -  576 */
-               0x00000000,     /*  639 -  608 */
-               0x00000000,     /*  671 -  640 */
-               0x00000000,     /*  703 -  672 */
-               0x00000000,     /*  735 -  704 */
-               0x00000000,     /*  767 -  736 */
-               0x00000000,     /*  799 -  768 */
-               0x00000000,     /*  831 -  800 */
-               0x00000000,     /*  863 -  832 */
-               0x00000000,     /*  895 -  864 */
-               0x00000000,     /*  927 -  896 */
-               0x00000000,     /*  959 -  928 */
-               0x00000000,     /*  991 -  960 */
-               0x00000000,     /* 1023 -  992 */
-               0x00000000,     /* 1055 - 1024 */
-               0x00000000,     /* 1087 - 1056 */
-               0x00000000,     /* 1119 - 1088 */
-               0x00000000,     /* 1151 - 1120 */
-               0x00000000,     /* 1183 - 1152 */
-               0x00000000,     /* 1215 - 1184 */
-               0x00000000,     /* 1247 - 1216 */
-               0x00000000,     /* 1279 - 1248 */
-               0x00000000,     /* 1311 - 1280 */
-               0x00000000,     /* 1343 - 1312 */
-               0x00000000,     /* 1375 - 1344 */
-               0x00000000,     /* 1407 - 1376 */
-               0x00000000,     /* 1439 - 1408 */
-               0x00000000,     /* 1471 - 1440 */
-               0x00000000,     /* 1503 - 1472 */
-       };
-
-       base = le32_to_cpu(il->card_alive.log_event_table_ptr);
-       if (!il3945_hw_valid_rtc_data_addr(base)) {
-               IL_ERR("Invalid event log pointer 0x%08X\n", base);
-               return;
-       }
-
-       disable_ptr = il_read_targ_mem(il, base + (4 * sizeof(u32)));
-       array_size = il_read_targ_mem(il, base + (5 * sizeof(u32)));
-
-       if (IL_EVT_DISABLE && array_size == IL_EVT_DISABLE_SIZE) {
-               D_INFO("Disabling selected uCode log events at 0x%x\n",
-                      disable_ptr);
-               for (i = 0; i < IL_EVT_DISABLE_SIZE; i++)
-                       il_write_targ_mem(il, disable_ptr + (i * sizeof(u32)),
-                                         evt_disable[i]);
-
-       } else {
-               D_INFO("Selected uCode log events may be disabled\n");
-               D_INFO("  by writing \"1\"s into disable bitmap\n");
-               D_INFO("  in SRAM at 0x%x, size %d u32s\n", disable_ptr,
-                      array_size);
-       }
-
-}
-
-static int
-il3945_hwrate_to_plcp_idx(u8 plcp)
-{
-       int idx;
-
-       for (idx = 0; idx < RATE_COUNT_3945; idx++)
-               if (il3945_rates[idx].plcp == plcp)
-                       return idx;
-       return -1;
-}
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-#define TX_STATUS_ENTRY(x) case TX_3945_STATUS_FAIL_ ## x: return #x
-
-static const char *
-il3945_get_tx_fail_reason(u32 status)
-{
-       switch (status & TX_STATUS_MSK) {
-       case TX_3945_STATUS_SUCCESS:
-               return "SUCCESS";
-               TX_STATUS_ENTRY(SHORT_LIMIT);
-               TX_STATUS_ENTRY(LONG_LIMIT);
-               TX_STATUS_ENTRY(FIFO_UNDERRUN);
-               TX_STATUS_ENTRY(MGMNT_ABORT);
-               TX_STATUS_ENTRY(NEXT_FRAG);
-               TX_STATUS_ENTRY(LIFE_EXPIRE);
-               TX_STATUS_ENTRY(DEST_PS);
-               TX_STATUS_ENTRY(ABORTED);
-               TX_STATUS_ENTRY(BT_RETRY);
-               TX_STATUS_ENTRY(STA_INVALID);
-               TX_STATUS_ENTRY(FRAG_DROPPED);
-               TX_STATUS_ENTRY(TID_DISABLE);
-               TX_STATUS_ENTRY(FRAME_FLUSHED);
-               TX_STATUS_ENTRY(INSUFFICIENT_CF_POLL);
-               TX_STATUS_ENTRY(TX_LOCKED);
-               TX_STATUS_ENTRY(NO_BEACON_ON_RADAR);
-       }
-
-       return "UNKNOWN";
-}
-#else
-static inline const char *
-il3945_get_tx_fail_reason(u32 status)
-{
-       return "";
-}
-#endif
-
-/*
- * get ieee prev rate from rate scale table.
- * for A and B mode we need to overright prev
- * value
- */
-int
-il3945_rs_next_rate(struct il_priv *il, int rate)
-{
-       int next_rate = il3945_get_prev_ieee_rate(rate);
-
-       switch (il->band) {
-       case IEEE80211_BAND_5GHZ:
-               if (rate == RATE_12M_IDX)
-                       next_rate = RATE_9M_IDX;
-               else if (rate == RATE_6M_IDX)
-                       next_rate = RATE_6M_IDX;
-               break;
-       case IEEE80211_BAND_2GHZ:
-               if (!(il->_3945.sta_supp_rates & IL_OFDM_RATES_MASK) &&
-                   il_is_associated(il)) {
-                       if (rate == RATE_11M_IDX)
-                               next_rate = RATE_5M_IDX;
-               }
-               break;
-
-       default:
-               break;
-       }
-
-       return next_rate;
-}
-
-/**
- * il3945_tx_queue_reclaim - Reclaim Tx queue entries already Tx'd
- *
- * When FW advances 'R' idx, all entries between old and new 'R' idx
- * need to be reclaimed. As result, some free space forms. If there is
- * enough free space (> low mark), wake the stack that feeds us.
- */
-static void
-il3945_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
-{
-       struct il_tx_queue *txq = &il->txq[txq_id];
-       struct il_queue *q = &txq->q;
-       struct sk_buff *skb;
-
-       BUG_ON(txq_id == IL39_CMD_QUEUE_NUM);
-
-       for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
-            q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
-
-               skb = txq->skbs[txq->q.read_ptr];
-               ieee80211_tx_status_irqsafe(il->hw, skb);
-               txq->skbs[txq->q.read_ptr] = NULL;
-               il->ops->txq_free_tfd(il, txq);
-       }
-
-       if (il_queue_space(q) > q->low_mark && txq_id >= 0 &&
-           txq_id != IL39_CMD_QUEUE_NUM && il->mac80211_registered)
-               il_wake_queue(il, txq);
-}
-
-/**
- * il3945_hdl_tx - Handle Tx response
- */
-static void
-il3945_hdl_tx(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       u16 sequence = le16_to_cpu(pkt->hdr.sequence);
-       int txq_id = SEQ_TO_QUEUE(sequence);
-       int idx = SEQ_TO_IDX(sequence);
-       struct il_tx_queue *txq = &il->txq[txq_id];
-       struct ieee80211_tx_info *info;
-       struct il3945_tx_resp *tx_resp = (void *)&pkt->u.raw[0];
-       u32 status = le32_to_cpu(tx_resp->status);
-       int rate_idx;
-       int fail;
-
-       if (idx >= txq->q.n_bd || il_queue_used(&txq->q, idx) == 0) {
-               IL_ERR("Read idx for DMA queue txq_id (%d) idx %d "
-                      "is out of range [0-%d] %d %d\n", txq_id, idx,
-                      txq->q.n_bd, txq->q.write_ptr, txq->q.read_ptr);
-               return;
-       }
-
-       /*
-        * Firmware will not transmit frame on passive channel, if it not yet
-        * received some valid frame on that channel. When this error happen
-        * we have to wait until firmware will unblock itself i.e. when we
-        * note received beacon or other frame. We unblock queues in
-        * il3945_pass_packet_to_mac80211 or in il_mac_bss_info_changed.
-        */
-       if (unlikely((status & TX_STATUS_MSK) == TX_STATUS_FAIL_PASSIVE_NO_RX) &&
-           il->iw_mode == NL80211_IFTYPE_STATION) {
-               il_stop_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
-               D_INFO("Stopped queues - RX waiting on passive channel\n");
-       }
-
-       txq->time_stamp = jiffies;
-       info = IEEE80211_SKB_CB(txq->skbs[txq->q.read_ptr]);
-       ieee80211_tx_info_clear_status(info);
-
-       /* Fill the MRR chain with some info about on-chip retransmissions */
-       rate_idx = il3945_hwrate_to_plcp_idx(tx_resp->rate);
-       if (info->band == IEEE80211_BAND_5GHZ)
-               rate_idx -= IL_FIRST_OFDM_RATE;
-
-       fail = tx_resp->failure_frame;
-
-       info->status.rates[0].idx = rate_idx;
-       info->status.rates[0].count = fail + 1; /* add final attempt */
-
-       /* tx_status->rts_retry_count = tx_resp->failure_rts; */
-       info->flags |=
-           ((status & TX_STATUS_MSK) ==
-            TX_STATUS_SUCCESS) ? IEEE80211_TX_STAT_ACK : 0;
-
-       D_TX("Tx queue %d Status %s (0x%08x) plcp rate %d retries %d\n", txq_id,
-            il3945_get_tx_fail_reason(status), status, tx_resp->rate,
-            tx_resp->failure_frame);
-
-       D_TX_REPLY("Tx queue reclaim %d\n", idx);
-       il3945_tx_queue_reclaim(il, txq_id, idx);
-
-       if (status & TX_ABORT_REQUIRED_MSK)
-               IL_ERR("TODO:  Implement Tx ABORT REQUIRED!!!\n");
-}
-
-/*****************************************************************************
- *
- * Intel PRO/Wireless 3945ABG/BG Network Connection
- *
- *  RX handler implementations
- *
- *****************************************************************************/
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-static void
-il3945_accumulative_stats(struct il_priv *il, __le32 * stats)
-{
-       int i;
-       __le32 *prev_stats;
-       u32 *accum_stats;
-       u32 *delta, *max_delta;
-
-       prev_stats = (__le32 *) &il->_3945.stats;
-       accum_stats = (u32 *) &il->_3945.accum_stats;
-       delta = (u32 *) &il->_3945.delta_stats;
-       max_delta = (u32 *) &il->_3945.max_delta;
-
-       for (i = sizeof(__le32); i < sizeof(struct il3945_notif_stats);
-            i +=
-            sizeof(__le32), stats++, prev_stats++, delta++, max_delta++,
-            accum_stats++) {
-               if (le32_to_cpu(*stats) > le32_to_cpu(*prev_stats)) {
-                       *delta =
-                           (le32_to_cpu(*stats) - le32_to_cpu(*prev_stats));
-                       *accum_stats += *delta;
-                       if (*delta > *max_delta)
-                               *max_delta = *delta;
-               }
-       }
-
-       /* reset accumulative stats for "no-counter" type stats */
-       il->_3945.accum_stats.general.temperature =
-           il->_3945.stats.general.temperature;
-       il->_3945.accum_stats.general.ttl_timestamp =
-           il->_3945.stats.general.ttl_timestamp;
-}
-#endif
-
-void
-il3945_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-
-       D_RX("Statistics notification received (%d vs %d).\n",
-            (int)sizeof(struct il3945_notif_stats),
-            le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK);
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       il3945_accumulative_stats(il, (__le32 *) &pkt->u.raw);
-#endif
-
-       memcpy(&il->_3945.stats, pkt->u.raw, sizeof(il->_3945.stats));
-}
-
-void
-il3945_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       __le32 *flag = (__le32 *) &pkt->u.raw;
-
-       if (le32_to_cpu(*flag) & UCODE_STATS_CLEAR_MSK) {
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-               memset(&il->_3945.accum_stats, 0,
-                      sizeof(struct il3945_notif_stats));
-               memset(&il->_3945.delta_stats, 0,
-                      sizeof(struct il3945_notif_stats));
-               memset(&il->_3945.max_delta, 0,
-                      sizeof(struct il3945_notif_stats));
-#endif
-               D_RX("Statistics have been cleared\n");
-       }
-       il3945_hdl_stats(il, rxb);
-}
-
-/******************************************************************************
- *
- * Misc. internal state and helper functions
- *
- ******************************************************************************/
-
-/* This is necessary only for a number of stats, see the caller. */
-static int
-il3945_is_network_packet(struct il_priv *il, struct ieee80211_hdr *header)
-{
-       /* Filter incoming packets to determine if they are targeted toward
-        * this network, discarding packets coming from ourselves */
-       switch (il->iw_mode) {
-       case NL80211_IFTYPE_ADHOC:      /* Header: Dest. | Source    | BSSID */
-               /* packets to our IBSS update information */
-               return ether_addr_equal_64bits(header->addr3, il->bssid);
-       case NL80211_IFTYPE_STATION:    /* Header: Dest. | AP{BSSID} | Source */
-               /* packets to our IBSS update information */
-               return ether_addr_equal_64bits(header->addr2, il->bssid);
-       default:
-               return 1;
-       }
-}
-
-#define SMALL_PACKET_SIZE 256
-
-static void
-il3945_pass_packet_to_mac80211(struct il_priv *il, struct il_rx_buf *rxb,
-                              struct ieee80211_rx_status *stats)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)IL_RX_DATA(pkt);
-       struct il3945_rx_frame_hdr *rx_hdr = IL_RX_HDR(pkt);
-       struct il3945_rx_frame_end *rx_end = IL_RX_END(pkt);
-       u32 len = le16_to_cpu(rx_hdr->len);
-       struct sk_buff *skb;
-       __le16 fc = hdr->frame_control;
-       u32 fraglen = PAGE_SIZE << il->hw_params.rx_page_order;
-
-       /* We received data from the HW, so stop the watchdog */
-       if (unlikely(len + IL39_RX_FRAME_SIZE > fraglen)) {
-               D_DROP("Corruption detected!\n");
-               return;
-       }
-
-       /* We only process data packets if the interface is open */
-       if (unlikely(!il->is_open)) {
-               D_DROP("Dropping packet while interface is not open.\n");
-               return;
-       }
-
-       if (unlikely(test_bit(IL_STOP_REASON_PASSIVE, &il->stop_reason))) {
-               il_wake_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
-               D_INFO("Woke queues - frame received on passive channel\n");
-       }
-
-       skb = dev_alloc_skb(SMALL_PACKET_SIZE);
-       if (!skb) {
-               IL_ERR("dev_alloc_skb failed\n");
-               return;
-       }
-
-       if (!il3945_mod_params.sw_crypto)
-               il_set_decrypted_flag(il, (struct ieee80211_hdr *)pkt,
-                                     le32_to_cpu(rx_end->status), stats);
-
-       /* If frame is small enough to fit into skb->head, copy it
-        * and do not consume a full page
-        */
-       if (len <= SMALL_PACKET_SIZE) {
-               memcpy(skb_put(skb, len), rx_hdr->payload, len);
-       } else {
-               skb_add_rx_frag(skb, 0, rxb->page,
-                               (void *)rx_hdr->payload - (void *)pkt, len,
-                               fraglen);
-               il->alloc_rxb_page--;
-               rxb->page = NULL;
-       }
-       il_update_stats(il, false, fc, len);
-       memcpy(IEEE80211_SKB_RXCB(skb), stats, sizeof(*stats));
-
-       ieee80211_rx(il->hw, skb);
-}
-
-#define IL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
-
-static void
-il3945_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct ieee80211_hdr *header;
-       struct ieee80211_rx_status rx_status = {};
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il3945_rx_frame_stats *rx_stats = IL_RX_STATS(pkt);
-       struct il3945_rx_frame_hdr *rx_hdr = IL_RX_HDR(pkt);
-       struct il3945_rx_frame_end *rx_end = IL_RX_END(pkt);
-       u16 rx_stats_sig_avg __maybe_unused = le16_to_cpu(rx_stats->sig_avg);
-       u16 rx_stats_noise_diff __maybe_unused =
-           le16_to_cpu(rx_stats->noise_diff);
-       u8 network_packet;
-
-       rx_status.flag = 0;
-       rx_status.mactime = le64_to_cpu(rx_end->timestamp);
-       rx_status.band =
-           (rx_hdr->
-            phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
-           IEEE80211_BAND_5GHZ;
-       rx_status.freq =
-           ieee80211_channel_to_frequency(le16_to_cpu(rx_hdr->channel),
-                                          rx_status.band);
-
-       rx_status.rate_idx = il3945_hwrate_to_plcp_idx(rx_hdr->rate);
-       if (rx_status.band == IEEE80211_BAND_5GHZ)
-               rx_status.rate_idx -= IL_FIRST_OFDM_RATE;
-
-       rx_status.antenna =
-           (le16_to_cpu(rx_hdr->phy_flags) & RX_RES_PHY_FLAGS_ANTENNA_MSK) >>
-           4;
-
-       /* set the preamble flag if appropriate */
-       if (rx_hdr->phy_flags & RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK)
-               rx_status.flag |= RX_FLAG_SHORTPRE;
-
-       if ((unlikely(rx_stats->phy_count > 20))) {
-               D_DROP("dsp size out of range [0,20]: %d\n",
-                      rx_stats->phy_count);
-               return;
-       }
-
-       if (!(rx_end->status & RX_RES_STATUS_NO_CRC32_ERROR) ||
-           !(rx_end->status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
-               D_RX("Bad CRC or FIFO: 0x%08X.\n", rx_end->status);
-               return;
-       }
-
-       /* Convert 3945's rssi indicator to dBm */
-       rx_status.signal = rx_stats->rssi - IL39_RSSI_OFFSET;
-
-       D_STATS("Rssi %d sig_avg %d noise_diff %d\n", rx_status.signal,
-               rx_stats_sig_avg, rx_stats_noise_diff);
-
-       header = (struct ieee80211_hdr *)IL_RX_DATA(pkt);
-
-       network_packet = il3945_is_network_packet(il, header);
-
-       D_STATS("[%c] %d RSSI:%d Signal:%u, Rate:%u\n",
-               network_packet ? '*' : ' ', le16_to_cpu(rx_hdr->channel),
-               rx_status.signal, rx_status.signal, rx_status.rate_idx);
-
-       if (network_packet) {
-               il->_3945.last_beacon_time =
-                   le32_to_cpu(rx_end->beacon_timestamp);
-               il->_3945.last_tsf = le64_to_cpu(rx_end->timestamp);
-               il->_3945.last_rx_rssi = rx_status.signal;
-       }
-
-       il3945_pass_packet_to_mac80211(il, rxb, &rx_status);
-}
-
-int
-il3945_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
-                               dma_addr_t addr, u16 len, u8 reset, u8 pad)
-{
-       int count;
-       struct il_queue *q;
-       struct il3945_tfd *tfd, *tfd_tmp;
-
-       q = &txq->q;
-       tfd_tmp = (struct il3945_tfd *)txq->tfds;
-       tfd = &tfd_tmp[q->write_ptr];
-
-       if (reset)
-               memset(tfd, 0, sizeof(*tfd));
-
-       count = TFD_CTL_COUNT_GET(le32_to_cpu(tfd->control_flags));
-
-       if (count >= NUM_TFD_CHUNKS || count < 0) {
-               IL_ERR("Error can not send more than %d chunks\n",
-                      NUM_TFD_CHUNKS);
-               return -EINVAL;
-       }
-
-       tfd->tbs[count].addr = cpu_to_le32(addr);
-       tfd->tbs[count].len = cpu_to_le32(len);
-
-       count++;
-
-       tfd->control_flags =
-           cpu_to_le32(TFD_CTL_COUNT_SET(count) | TFD_CTL_PAD_SET(pad));
-
-       return 0;
-}
-
-/**
- * il3945_hw_txq_free_tfd - Free one TFD, those at idx [txq->q.read_ptr]
- *
- * Does NOT advance any idxes
- */
-void
-il3945_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
-{
-       struct il3945_tfd *tfd_tmp = (struct il3945_tfd *)txq->tfds;
-       int idx = txq->q.read_ptr;
-       struct il3945_tfd *tfd = &tfd_tmp[idx];
-       struct pci_dev *dev = il->pci_dev;
-       int i;
-       int counter;
-
-       /* sanity check */
-       counter = TFD_CTL_COUNT_GET(le32_to_cpu(tfd->control_flags));
-       if (counter > NUM_TFD_CHUNKS) {
-               IL_ERR("Too many chunks: %i\n", counter);
-               /* @todo issue fatal error, it is quite serious situation */
-               return;
-       }
-
-       /* Unmap tx_cmd */
-       if (counter)
-               pci_unmap_single(dev, dma_unmap_addr(&txq->meta[idx], mapping),
-                                dma_unmap_len(&txq->meta[idx], len),
-                                PCI_DMA_TODEVICE);
-
-       /* unmap chunks if any */
-
-       for (i = 1; i < counter; i++)
-               pci_unmap_single(dev, le32_to_cpu(tfd->tbs[i].addr),
-                                le32_to_cpu(tfd->tbs[i].len),
-                                PCI_DMA_TODEVICE);
-
-       /* free SKB */
-       if (txq->skbs) {
-               struct sk_buff *skb = txq->skbs[txq->q.read_ptr];
-
-               /* can be called from irqs-disabled context */
-               if (skb) {
-                       dev_kfree_skb_any(skb);
-                       txq->skbs[txq->q.read_ptr] = NULL;
-               }
-       }
-}
-
-/**
- * il3945_hw_build_tx_cmd_rate - Add rate portion to TX_CMD:
- *
-*/
-void
-il3945_hw_build_tx_cmd_rate(struct il_priv *il, struct il_device_cmd *cmd,
-                           struct ieee80211_tx_info *info,
-                           struct ieee80211_hdr *hdr, int sta_id)
-{
-       u16 hw_value = ieee80211_get_tx_rate(il->hw, info)->hw_value;
-       u16 rate_idx = min(hw_value & 0xffff, RATE_COUNT_3945 - 1);
-       u16 rate_mask;
-       int rate;
-       const u8 rts_retry_limit = 7;
-       u8 data_retry_limit;
-       __le32 tx_flags;
-       __le16 fc = hdr->frame_control;
-       struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
-
-       rate = il3945_rates[rate_idx].plcp;
-       tx_flags = tx_cmd->tx_flags;
-
-       /* We need to figure out how to get the sta->supp_rates while
-        * in this running context */
-       rate_mask = RATES_MASK_3945;
-
-       /* Set retry limit on DATA packets and Probe Responses */
-       if (ieee80211_is_probe_resp(fc))
-               data_retry_limit = 3;
-       else
-               data_retry_limit = IL_DEFAULT_TX_RETRY;
-       tx_cmd->data_retry_limit = data_retry_limit;
-       /* Set retry limit on RTS packets */
-       tx_cmd->rts_retry_limit = min(data_retry_limit, rts_retry_limit);
-
-       tx_cmd->rate = rate;
-       tx_cmd->tx_flags = tx_flags;
-
-       /* OFDM */
-       tx_cmd->supp_rates[0] =
-           ((rate_mask & IL_OFDM_RATES_MASK) >> IL_FIRST_OFDM_RATE) & 0xFF;
-
-       /* CCK */
-       tx_cmd->supp_rates[1] = (rate_mask & 0xF);
-
-       D_RATE("Tx sta id: %d, rate: %d (plcp), flags: 0x%4X "
-              "cck/ofdm mask: 0x%x/0x%x\n", sta_id, tx_cmd->rate,
-              le32_to_cpu(tx_cmd->tx_flags), tx_cmd->supp_rates[1],
-              tx_cmd->supp_rates[0]);
-}
-
-static u8
-il3945_sync_sta(struct il_priv *il, int sta_id, u16 tx_rate)
-{
-       unsigned long flags_spin;
-       struct il_station_entry *station;
-
-       if (sta_id == IL_INVALID_STATION)
-               return IL_INVALID_STATION;
-
-       spin_lock_irqsave(&il->sta_lock, flags_spin);
-       station = &il->stations[sta_id];
-
-       station->sta.sta.modify_mask = STA_MODIFY_TX_RATE_MSK;
-       station->sta.rate_n_flags = cpu_to_le16(tx_rate);
-       station->sta.mode = STA_CONTROL_MODIFY_MSK;
-       il_send_add_sta(il, &station->sta, CMD_ASYNC);
-       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-
-       D_RATE("SCALE sync station %d to rate %d\n", sta_id, tx_rate);
-       return sta_id;
-}
-
-static void
-il3945_set_pwr_vmain(struct il_priv *il)
-{
-/*
- * (for documentation purposes)
- * to set power to V_AUX, do
-
-               if (pci_pme_capable(il->pci_dev, PCI_D3cold)) {
-                       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
-                                       APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
-                                       ~APMG_PS_CTRL_MSK_PWR_SRC);
-
-                       _il_poll_bit(il, CSR_GPIO_IN,
-                                    CSR_GPIO_IN_VAL_VAUX_PWR_SRC,
-                                    CSR_GPIO_IN_BIT_AUX_POWER, 5000);
-               }
- */
-
-       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
-                             APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
-                             ~APMG_PS_CTRL_MSK_PWR_SRC);
-
-       _il_poll_bit(il, CSR_GPIO_IN, CSR_GPIO_IN_VAL_VMAIN_PWR_SRC,
-                    CSR_GPIO_IN_BIT_AUX_POWER, 5000);
-}
-
-static int
-il3945_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
-{
-       il_wr(il, FH39_RCSR_RBD_BASE(0), rxq->bd_dma);
-       il_wr(il, FH39_RCSR_RPTR_ADDR(0), rxq->rb_stts_dma);
-       il_wr(il, FH39_RCSR_WPTR(0), 0);
-       il_wr(il, FH39_RCSR_CONFIG(0),
-             FH39_RCSR_RX_CONFIG_REG_VAL_DMA_CHNL_EN_ENABLE |
-             FH39_RCSR_RX_CONFIG_REG_VAL_RDRBD_EN_ENABLE |
-             FH39_RCSR_RX_CONFIG_REG_BIT_WR_STTS_EN |
-             FH39_RCSR_RX_CONFIG_REG_VAL_MAX_FRAG_SIZE_128 | (RX_QUEUE_SIZE_LOG
-                                                              <<
-                                                              FH39_RCSR_RX_CONFIG_REG_POS_RBDC_SIZE)
-             | FH39_RCSR_RX_CONFIG_REG_VAL_IRQ_DEST_INT_HOST | (1 <<
-                                                                FH39_RCSR_RX_CONFIG_REG_POS_IRQ_RBTH)
-             | FH39_RCSR_RX_CONFIG_REG_VAL_MSG_MODE_FH);
-
-       /* fake read to flush all prev I/O */
-       il_rd(il, FH39_RSSR_CTRL);
-
-       return 0;
-}
-
-static int
-il3945_tx_reset(struct il_priv *il)
-{
-       /* bypass mode */
-       il_wr_prph(il, ALM_SCD_MODE_REG, 0x2);
-
-       /* RA 0 is active */
-       il_wr_prph(il, ALM_SCD_ARASTAT_REG, 0x01);
-
-       /* all 6 fifo are active */
-       il_wr_prph(il, ALM_SCD_TXFACT_REG, 0x3f);
-
-       il_wr_prph(il, ALM_SCD_SBYP_MODE_1_REG, 0x010000);
-       il_wr_prph(il, ALM_SCD_SBYP_MODE_2_REG, 0x030002);
-       il_wr_prph(il, ALM_SCD_TXF4MF_REG, 0x000004);
-       il_wr_prph(il, ALM_SCD_TXF5MF_REG, 0x000005);
-
-       il_wr(il, FH39_TSSR_CBB_BASE, il->_3945.shared_phys);
-
-       il_wr(il, FH39_TSSR_MSG_CONFIG,
-             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TXPD_ON |
-             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_TXPD_ON |
-             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_MAX_FRAG_SIZE_128B |
-             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TFD_ON |
-             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_CBB_ON |
-             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RSP_WAIT_TH |
-             FH39_TSSR_TX_MSG_CONFIG_REG_VAL_RSP_WAIT_TH);
-
-       return 0;
-}
-
-/**
- * il3945_txq_ctx_reset - Reset TX queue context
- *
- * Destroys all DMA structures and initialize them again
- */
-static int
-il3945_txq_ctx_reset(struct il_priv *il)
-{
-       int rc, txq_id;
-
-       il3945_hw_txq_ctx_free(il);
-
-       /* allocate tx queue structure */
-       rc = il_alloc_txq_mem(il);
-       if (rc)
-               return rc;
-
-       /* Tx CMD queue */
-       rc = il3945_tx_reset(il);
-       if (rc)
-               goto error;
-
-       /* Tx queue(s) */
-       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
-               rc = il_tx_queue_init(il, txq_id);
-               if (rc) {
-                       IL_ERR("Tx %d queue init failed\n", txq_id);
-                       goto error;
-               }
-       }
-
-       return rc;
-
-error:
-       il3945_hw_txq_ctx_free(il);
-       return rc;
-}
-
-/*
- * Start up 3945's basic functionality after it has been reset
- * (e.g. after platform boot, or shutdown via il_apm_stop())
- * NOTE:  This does not load uCode nor start the embedded processor
- */
-static int
-il3945_apm_init(struct il_priv *il)
-{
-       int ret = il_apm_init(il);
-
-       /* Clear APMG (NIC's internal power management) interrupts */
-       il_wr_prph(il, APMG_RTC_INT_MSK_REG, 0x0);
-       il_wr_prph(il, APMG_RTC_INT_STT_REG, 0xFFFFFFFF);
-
-       /* Reset radio chip */
-       il_set_bits_prph(il, APMG_PS_CTRL_REG, APMG_PS_CTRL_VAL_RESET_REQ);
-       udelay(5);
-       il_clear_bits_prph(il, APMG_PS_CTRL_REG, APMG_PS_CTRL_VAL_RESET_REQ);
-
-       return ret;
-}
-
-static void
-il3945_nic_config(struct il_priv *il)
-{
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-       unsigned long flags;
-       u8 rev_id = il->pci_dev->revision;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Determine HW type */
-       D_INFO("HW Revision ID = 0x%X\n", rev_id);
-
-       if (rev_id & PCI_CFG_REV_ID_BIT_RTP)
-               D_INFO("RTP type\n");
-       else if (rev_id & PCI_CFG_REV_ID_BIT_BASIC_SKU) {
-               D_INFO("3945 RADIO-MB type\n");
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR39_HW_IF_CONFIG_REG_BIT_3945_MB);
-       } else {
-               D_INFO("3945 RADIO-MM type\n");
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR39_HW_IF_CONFIG_REG_BIT_3945_MM);
-       }
-
-       if (EEPROM_SKU_CAP_OP_MODE_MRC == eeprom->sku_cap) {
-               D_INFO("SKU OP mode is mrc\n");
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR39_HW_IF_CONFIG_REG_BIT_SKU_MRC);
-       } else
-               D_INFO("SKU OP mode is basic\n");
-
-       if ((eeprom->board_revision & 0xF0) == 0xD0) {
-               D_INFO("3945ABG revision is 0x%X\n", eeprom->board_revision);
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
-       } else {
-               D_INFO("3945ABG revision is 0x%X\n", eeprom->board_revision);
-               il_clear_bit(il, CSR_HW_IF_CONFIG_REG,
-                            CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
-       }
-
-       if (eeprom->almgor_m_version <= 1) {
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_A);
-               D_INFO("Card M type A version is 0x%X\n",
-                      eeprom->almgor_m_version);
-       } else {
-               D_INFO("Card M type B version is 0x%X\n",
-                      eeprom->almgor_m_version);
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_B);
-       }
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       if (eeprom->sku_cap & EEPROM_SKU_CAP_SW_RF_KILL_ENABLE)
-               D_RF_KILL("SW RF KILL supported in EEPROM.\n");
-
-       if (eeprom->sku_cap & EEPROM_SKU_CAP_HW_RF_KILL_ENABLE)
-               D_RF_KILL("HW RF KILL supported in EEPROM.\n");
-}
-
-int
-il3945_hw_nic_init(struct il_priv *il)
-{
-       int rc;
-       unsigned long flags;
-       struct il_rx_queue *rxq = &il->rxq;
-
-       spin_lock_irqsave(&il->lock, flags);
-       il3945_apm_init(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       il3945_set_pwr_vmain(il);
-       il3945_nic_config(il);
-
-       /* Allocate the RX queue, or reset if it is already allocated */
-       if (!rxq->bd) {
-               rc = il_rx_queue_alloc(il);
-               if (rc) {
-                       IL_ERR("Unable to initialize Rx queue\n");
-                       return -ENOMEM;
-               }
-       } else
-               il3945_rx_queue_reset(il, rxq);
-
-       il3945_rx_replenish(il);
-
-       il3945_rx_init(il, rxq);
-
-       /* Look at using this instead:
-          rxq->need_update = 1;
-          il_rx_queue_update_write_ptr(il, rxq);
-        */
-
-       il_wr(il, FH39_RCSR_WPTR(0), rxq->write & ~7);
-
-       rc = il3945_txq_ctx_reset(il);
-       if (rc)
-               return rc;
-
-       set_bit(S_INIT, &il->status);
-
-       return 0;
-}
-
-/**
- * il3945_hw_txq_ctx_free - Free TXQ Context
- *
- * Destroy all TX DMA queues and structures
- */
-void
-il3945_hw_txq_ctx_free(struct il_priv *il)
-{
-       int txq_id;
-
-       /* Tx queues */
-       if (il->txq)
-               for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
-                       if (txq_id == IL39_CMD_QUEUE_NUM)
-                               il_cmd_queue_free(il);
-                       else
-                               il_tx_queue_free(il, txq_id);
-
-       /* free tx queue structure */
-       il_free_txq_mem(il);
-}
-
-void
-il3945_hw_txq_ctx_stop(struct il_priv *il)
-{
-       int txq_id;
-
-       /* stop SCD */
-       _il_wr_prph(il, ALM_SCD_MODE_REG, 0);
-       _il_wr_prph(il, ALM_SCD_TXFACT_REG, 0);
-
-       /* reset TFD queues */
-       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
-               _il_wr(il, FH39_TCSR_CONFIG(txq_id), 0x0);
-               _il_poll_bit(il, FH39_TSSR_TX_STATUS,
-                            FH39_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(txq_id),
-                            FH39_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(txq_id),
-                            1000);
-       }
-}
-
-/**
- * il3945_hw_reg_adjust_power_by_temp
- * return idx delta into power gain settings table
-*/
-static int
-il3945_hw_reg_adjust_power_by_temp(int new_reading, int old_reading)
-{
-       return (new_reading - old_reading) * (-11) / 100;
-}
-
-/**
- * il3945_hw_reg_temp_out_of_range - Keep temperature in sane range
- */
-static inline int
-il3945_hw_reg_temp_out_of_range(int temperature)
-{
-       return (temperature < -260 || temperature > 25) ? 1 : 0;
-}
-
-int
-il3945_hw_get_temperature(struct il_priv *il)
-{
-       return _il_rd(il, CSR_UCODE_DRV_GP2);
-}
-
-/**
- * il3945_hw_reg_txpower_get_temperature
- * get the current temperature by reading from NIC
-*/
-static int
-il3945_hw_reg_txpower_get_temperature(struct il_priv *il)
-{
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-       int temperature;
-
-       temperature = il3945_hw_get_temperature(il);
-
-       /* driver's okay range is -260 to +25.
-        *   human readable okay range is 0 to +285 */
-       D_INFO("Temperature: %d\n", temperature + IL_TEMP_CONVERT);
-
-       /* handle insane temp reading */
-       if (il3945_hw_reg_temp_out_of_range(temperature)) {
-               IL_ERR("Error bad temperature value  %d\n", temperature);
-
-               /* if really really hot(?),
-                *   substitute the 3rd band/group's temp measured at factory */
-               if (il->last_temperature > 100)
-                       temperature = eeprom->groups[2].temperature;
-               else            /* else use most recent "sane" value from driver */
-                       temperature = il->last_temperature;
-       }
-
-       return temperature;     /* raw, not "human readable" */
-}
-
-/* Adjust Txpower only if temperature variance is greater than threshold.
- *
- * Both are lower than older versions' 9 degrees */
-#define IL_TEMPERATURE_LIMIT_TIMER   6
-
-/**
- * il3945_is_temp_calib_needed - determines if new calibration is needed
- *
- * records new temperature in tx_mgr->temperature.
- * replaces tx_mgr->last_temperature *only* if calib needed
- *    (assumes caller will actually do the calibration!). */
-static int
-il3945_is_temp_calib_needed(struct il_priv *il)
-{
-       int temp_diff;
-
-       il->temperature = il3945_hw_reg_txpower_get_temperature(il);
-       temp_diff = il->temperature - il->last_temperature;
-
-       /* get absolute value */
-       if (temp_diff < 0) {
-               D_POWER("Getting cooler, delta %d,\n", temp_diff);
-               temp_diff = -temp_diff;
-       } else if (temp_diff == 0)
-               D_POWER("Same temp,\n");
-       else
-               D_POWER("Getting warmer, delta %d,\n", temp_diff);
-
-       /* if we don't need calibration, *don't* update last_temperature */
-       if (temp_diff < IL_TEMPERATURE_LIMIT_TIMER) {
-               D_POWER("Timed thermal calib not needed\n");
-               return 0;
-       }
-
-       D_POWER("Timed thermal calib needed\n");
-
-       /* assume that caller will actually do calib ...
-        *   update the "last temperature" value */
-       il->last_temperature = il->temperature;
-       return 1;
-}
-
-#define IL_MAX_GAIN_ENTRIES 78
-#define IL_CCK_FROM_OFDM_POWER_DIFF  -5
-#define IL_CCK_FROM_OFDM_IDX_DIFF (10)
-
-/* radio and DSP power table, each step is 1/2 dB.
- * 1st number is for RF analog gain, 2nd number is for DSP pre-DAC gain. */
-static struct il3945_tx_power power_gain_table[2][IL_MAX_GAIN_ENTRIES] = {
-       {
-        {251, 127},            /* 2.4 GHz, highest power */
-        {251, 127},
-        {251, 127},
-        {251, 127},
-        {251, 125},
-        {251, 110},
-        {251, 105},
-        {251, 98},
-        {187, 125},
-        {187, 115},
-        {187, 108},
-        {187, 99},
-        {243, 119},
-        {243, 111},
-        {243, 105},
-        {243, 97},
-        {243, 92},
-        {211, 106},
-        {211, 100},
-        {179, 120},
-        {179, 113},
-        {179, 107},
-        {147, 125},
-        {147, 119},
-        {147, 112},
-        {147, 106},
-        {147, 101},
-        {147, 97},
-        {147, 91},
-        {115, 107},
-        {235, 121},
-        {235, 115},
-        {235, 109},
-        {203, 127},
-        {203, 121},
-        {203, 115},
-        {203, 108},
-        {203, 102},
-        {203, 96},
-        {203, 92},
-        {171, 110},
-        {171, 104},
-        {171, 98},
-        {139, 116},
-        {227, 125},
-        {227, 119},
-        {227, 113},
-        {227, 107},
-        {227, 101},
-        {227, 96},
-        {195, 113},
-        {195, 106},
-        {195, 102},
-        {195, 95},
-        {163, 113},
-        {163, 106},
-        {163, 102},
-        {163, 95},
-        {131, 113},
-        {131, 106},
-        {131, 102},
-        {131, 95},
-        {99, 113},
-        {99, 106},
-        {99, 102},
-        {99, 95},
-        {67, 113},
-        {67, 106},
-        {67, 102},
-        {67, 95},
-        {35, 113},
-        {35, 106},
-        {35, 102},
-        {35, 95},
-        {3, 113},
-        {3, 106},
-        {3, 102},
-        {3, 95}                /* 2.4 GHz, lowest power */
-       },
-       {
-        {251, 127},            /* 5.x GHz, highest power */
-        {251, 120},
-        {251, 114},
-        {219, 119},
-        {219, 101},
-        {187, 113},
-        {187, 102},
-        {155, 114},
-        {155, 103},
-        {123, 117},
-        {123, 107},
-        {123, 99},
-        {123, 92},
-        {91, 108},
-        {59, 125},
-        {59, 118},
-        {59, 109},
-        {59, 102},
-        {59, 96},
-        {59, 90},
-        {27, 104},
-        {27, 98},
-        {27, 92},
-        {115, 118},
-        {115, 111},
-        {115, 104},
-        {83, 126},
-        {83, 121},
-        {83, 113},
-        {83, 105},
-        {83, 99},
-        {51, 118},
-        {51, 111},
-        {51, 104},
-        {51, 98},
-        {19, 116},
-        {19, 109},
-        {19, 102},
-        {19, 98},
-        {19, 93},
-        {171, 113},
-        {171, 107},
-        {171, 99},
-        {139, 120},
-        {139, 113},
-        {139, 107},
-        {139, 99},
-        {107, 120},
-        {107, 113},
-        {107, 107},
-        {107, 99},
-        {75, 120},
-        {75, 113},
-        {75, 107},
-        {75, 99},
-        {43, 120},
-        {43, 113},
-        {43, 107},
-        {43, 99},
-        {11, 120},
-        {11, 113},
-        {11, 107},
-        {11, 99},
-        {131, 107},
-        {131, 99},
-        {99, 120},
-        {99, 113},
-        {99, 107},
-        {99, 99},
-        {67, 120},
-        {67, 113},
-        {67, 107},
-        {67, 99},
-        {35, 120},
-        {35, 113},
-        {35, 107},
-        {35, 99},
-        {3, 120}               /* 5.x GHz, lowest power */
-       }
-};
-
-static inline u8
-il3945_hw_reg_fix_power_idx(int idx)
-{
-       if (idx < 0)
-               return 0;
-       if (idx >= IL_MAX_GAIN_ENTRIES)
-               return IL_MAX_GAIN_ENTRIES - 1;
-       return (u8) idx;
-}
-
-/* Kick off thermal recalibration check every 60 seconds */
-#define REG_RECALIB_PERIOD (60)
-
-/**
- * il3945_hw_reg_set_scan_power - Set Tx power for scan probe requests
- *
- * Set (in our channel info database) the direct scan Tx power for 1 Mbit (CCK)
- * or 6 Mbit (OFDM) rates.
- */
-static void
-il3945_hw_reg_set_scan_power(struct il_priv *il, u32 scan_tbl_idx, s32 rate_idx,
-                            const s8 *clip_pwrs,
-                            struct il_channel_info *ch_info, int band_idx)
-{
-       struct il3945_scan_power_info *scan_power_info;
-       s8 power;
-       u8 power_idx;
-
-       scan_power_info = &ch_info->scan_pwr_info[scan_tbl_idx];
-
-       /* use this channel group's 6Mbit clipping/saturation pwr,
-        *   but cap at regulatory scan power restriction (set during init
-        *   based on eeprom channel data) for this channel.  */
-       power = min(ch_info->scan_power, clip_pwrs[RATE_6M_IDX_TBL]);
-
-       power = min(power, il->tx_power_user_lmt);
-       scan_power_info->requested_power = power;
-
-       /* find difference between new scan *power* and current "normal"
-        *   Tx *power* for 6Mb.  Use this difference (x2) to adjust the
-        *   current "normal" temperature-compensated Tx power *idx* for
-        *   this rate (1Mb or 6Mb) to yield new temp-compensated scan power
-        *   *idx*. */
-       power_idx =
-           ch_info->power_info[rate_idx].power_table_idx - (power -
-                                                            ch_info->
-                                                            power_info
-                                                            [RATE_6M_IDX_TBL].
-                                                            requested_power) *
-           2;
-
-       /* store reference idx that we use when adjusting *all* scan
-        *   powers.  So we can accommodate user (all channel) or spectrum
-        *   management (single channel) power changes "between" temperature
-        *   feedback compensation procedures.
-        * don't force fit this reference idx into gain table; it may be a
-        *   negative number.  This will help avoid errors when we're at
-        *   the lower bounds (highest gains, for warmest temperatures)
-        *   of the table. */
-
-       /* don't exceed table bounds for "real" setting */
-       power_idx = il3945_hw_reg_fix_power_idx(power_idx);
-
-       scan_power_info->power_table_idx = power_idx;
-       scan_power_info->tpc.tx_gain =
-           power_gain_table[band_idx][power_idx].tx_gain;
-       scan_power_info->tpc.dsp_atten =
-           power_gain_table[band_idx][power_idx].dsp_atten;
-}
-
-/**
- * il3945_send_tx_power - fill in Tx Power command with gain settings
- *
- * Configures power settings for all rates for the current channel,
- * using values from channel info struct, and send to NIC
- */
-static int
-il3945_send_tx_power(struct il_priv *il)
-{
-       int rate_idx, i;
-       const struct il_channel_info *ch_info = NULL;
-       struct il3945_txpowertable_cmd txpower = {
-               .channel = il->active.channel,
-       };
-       u16 chan;
-
-       if (WARN_ONCE
-           (test_bit(S_SCAN_HW, &il->status),
-            "TX Power requested while scanning!\n"))
-               return -EAGAIN;
-
-       chan = le16_to_cpu(il->active.channel);
-
-       txpower.band = (il->band == IEEE80211_BAND_5GHZ) ? 0 : 1;
-       ch_info = il_get_channel_info(il, il->band, chan);
-       if (!ch_info) {
-               IL_ERR("Failed to get channel info for channel %d [%d]\n", chan,
-                      il->band);
-               return -EINVAL;
-       }
-
-       if (!il_is_channel_valid(ch_info)) {
-               D_POWER("Not calling TX_PWR_TBL_CMD on " "non-Tx channel.\n");
-               return 0;
-       }
-
-       /* fill cmd with power settings for all rates for current channel */
-       /* Fill OFDM rate */
-       for (rate_idx = IL_FIRST_OFDM_RATE, i = 0;
-            rate_idx <= IL39_LAST_OFDM_RATE; rate_idx++, i++) {
-
-               txpower.power[i].tpc = ch_info->power_info[i].tpc;
-               txpower.power[i].rate = il3945_rates[rate_idx].plcp;
-
-               D_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
-                       le16_to_cpu(txpower.channel), txpower.band,
-                       txpower.power[i].tpc.tx_gain,
-                       txpower.power[i].tpc.dsp_atten, txpower.power[i].rate);
-       }
-       /* Fill CCK rates */
-       for (rate_idx = IL_FIRST_CCK_RATE; rate_idx <= IL_LAST_CCK_RATE;
-            rate_idx++, i++) {
-               txpower.power[i].tpc = ch_info->power_info[i].tpc;
-               txpower.power[i].rate = il3945_rates[rate_idx].plcp;
-
-               D_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
-                       le16_to_cpu(txpower.channel), txpower.band,
-                       txpower.power[i].tpc.tx_gain,
-                       txpower.power[i].tpc.dsp_atten, txpower.power[i].rate);
-       }
-
-       return il_send_cmd_pdu(il, C_TX_PWR_TBL,
-                              sizeof(struct il3945_txpowertable_cmd),
-                              &txpower);
-
-}
-
-/**
- * il3945_hw_reg_set_new_power - Configures power tables at new levels
- * @ch_info: Channel to update.  Uses power_info.requested_power.
- *
- * Replace requested_power and base_power_idx ch_info fields for
- * one channel.
- *
- * Called if user or spectrum management changes power preferences.
- * Takes into account h/w and modulation limitations (clip power).
- *
- * This does *not* send anything to NIC, just sets up ch_info for one channel.
- *
- * NOTE: reg_compensate_for_temperature_dif() *must* be run after this to
- *      properly fill out the scan powers, and actual h/w gain settings,
- *      and send changes to NIC
- */
-static int
-il3945_hw_reg_set_new_power(struct il_priv *il, struct il_channel_info *ch_info)
-{
-       struct il3945_channel_power_info *power_info;
-       int power_changed = 0;
-       int i;
-       const s8 *clip_pwrs;
-       int power;
-
-       /* Get this chnlgrp's rate-to-max/clip-powers table */
-       clip_pwrs = il->_3945.clip_groups[ch_info->group_idx].clip_powers;
-
-       /* Get this channel's rate-to-current-power settings table */
-       power_info = ch_info->power_info;
-
-       /* update OFDM Txpower settings */
-       for (i = RATE_6M_IDX_TBL; i <= RATE_54M_IDX_TBL; i++, ++power_info) {
-               int delta_idx;
-
-               /* limit new power to be no more than h/w capability */
-               power = min(ch_info->curr_txpow, clip_pwrs[i]);
-               if (power == power_info->requested_power)
-                       continue;
-
-               /* find difference between old and new requested powers,
-                *    update base (non-temp-compensated) power idx */
-               delta_idx = (power - power_info->requested_power) * 2;
-               power_info->base_power_idx -= delta_idx;
-
-               /* save new requested power value */
-               power_info->requested_power = power;
-
-               power_changed = 1;
-       }
-
-       /* update CCK Txpower settings, based on OFDM 12M setting ...
-        *    ... all CCK power settings for a given channel are the *same*. */
-       if (power_changed) {
-               power =
-                   ch_info->power_info[RATE_12M_IDX_TBL].requested_power +
-                   IL_CCK_FROM_OFDM_POWER_DIFF;
-
-               /* do all CCK rates' il3945_channel_power_info structures */
-               for (i = RATE_1M_IDX_TBL; i <= RATE_11M_IDX_TBL; i++) {
-                       power_info->requested_power = power;
-                       power_info->base_power_idx =
-                           ch_info->power_info[RATE_12M_IDX_TBL].
-                           base_power_idx + IL_CCK_FROM_OFDM_IDX_DIFF;
-                       ++power_info;
-               }
-       }
-
-       return 0;
-}
-
-/**
- * il3945_hw_reg_get_ch_txpower_limit - returns new power limit for channel
- *
- * NOTE: Returned power limit may be less (but not more) than requested,
- *      based strictly on regulatory (eeprom and spectrum mgt) limitations
- *      (no consideration for h/w clipping limitations).
- */
-static int
-il3945_hw_reg_get_ch_txpower_limit(struct il_channel_info *ch_info)
-{
-       s8 max_power;
-
-#if 0
-       /* if we're using TGd limits, use lower of TGd or EEPROM */
-       if (ch_info->tgd_data.max_power != 0)
-               max_power =
-                   min(ch_info->tgd_data.max_power,
-                       ch_info->eeprom.max_power_avg);
-
-       /* else just use EEPROM limits */
-       else
-#endif
-               max_power = ch_info->eeprom.max_power_avg;
-
-       return min(max_power, ch_info->max_power_avg);
-}
-
-/**
- * il3945_hw_reg_comp_txpower_temp - Compensate for temperature
- *
- * Compensate txpower settings of *all* channels for temperature.
- * This only accounts for the difference between current temperature
- *   and the factory calibration temperatures, and bases the new settings
- *   on the channel's base_power_idx.
- *
- * If RxOn is "associated", this sends the new Txpower to NIC!
- */
-static int
-il3945_hw_reg_comp_txpower_temp(struct il_priv *il)
-{
-       struct il_channel_info *ch_info = NULL;
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-       int delta_idx;
-       const s8 *clip_pwrs;    /* array of h/w max power levels for each rate */
-       u8 a_band;
-       u8 rate_idx;
-       u8 scan_tbl_idx;
-       u8 i;
-       int ref_temp;
-       int temperature = il->temperature;
-
-       if (il->disable_tx_power_cal || test_bit(S_SCANNING, &il->status)) {
-               /* do not perform tx power calibration */
-               return 0;
-       }
-       /* set up new Tx power info for each and every channel, 2.4 and 5.x */
-       for (i = 0; i < il->channel_count; i++) {
-               ch_info = &il->channel_info[i];
-               a_band = il_is_channel_a_band(ch_info);
-
-               /* Get this chnlgrp's factory calibration temperature */
-               ref_temp = (s16) eeprom->groups[ch_info->group_idx].temperature;
-
-               /* get power idx adjustment based on current and factory
-                * temps */
-               delta_idx =
-                   il3945_hw_reg_adjust_power_by_temp(temperature, ref_temp);
-
-               /* set tx power value for all rates, OFDM and CCK */
-               for (rate_idx = 0; rate_idx < RATE_COUNT_3945; rate_idx++) {
-                       int power_idx =
-                           ch_info->power_info[rate_idx].base_power_idx;
-
-                       /* temperature compensate */
-                       power_idx += delta_idx;
-
-                       /* stay within table range */
-                       power_idx = il3945_hw_reg_fix_power_idx(power_idx);
-                       ch_info->power_info[rate_idx].power_table_idx =
-                           (u8) power_idx;
-                       ch_info->power_info[rate_idx].tpc =
-                           power_gain_table[a_band][power_idx];
-               }
-
-               /* Get this chnlgrp's rate-to-max/clip-powers table */
-               clip_pwrs =
-                   il->_3945.clip_groups[ch_info->group_idx].clip_powers;
-
-               /* set scan tx power, 1Mbit for CCK, 6Mbit for OFDM */
-               for (scan_tbl_idx = 0; scan_tbl_idx < IL_NUM_SCAN_RATES;
-                    scan_tbl_idx++) {
-                       s32 actual_idx =
-                           (scan_tbl_idx ==
-                            0) ? RATE_1M_IDX_TBL : RATE_6M_IDX_TBL;
-                       il3945_hw_reg_set_scan_power(il, scan_tbl_idx,
-                                                    actual_idx, clip_pwrs,
-                                                    ch_info, a_band);
-               }
-       }
-
-       /* send Txpower command for current channel to ucode */
-       return il->ops->send_tx_power(il);
-}
-
-int
-il3945_hw_reg_set_txpower(struct il_priv *il, s8 power)
-{
-       struct il_channel_info *ch_info;
-       s8 max_power;
-       u8 a_band;
-       u8 i;
-
-       if (il->tx_power_user_lmt == power) {
-               D_POWER("Requested Tx power same as current " "limit: %ddBm.\n",
-                       power);
-               return 0;
-       }
-
-       D_POWER("Setting upper limit clamp to %ddBm.\n", power);
-       il->tx_power_user_lmt = power;
-
-       /* set up new Tx powers for each and every channel, 2.4 and 5.x */
-
-       for (i = 0; i < il->channel_count; i++) {
-               ch_info = &il->channel_info[i];
-               a_band = il_is_channel_a_band(ch_info);
-
-               /* find minimum power of all user and regulatory constraints
-                *    (does not consider h/w clipping limitations) */
-               max_power = il3945_hw_reg_get_ch_txpower_limit(ch_info);
-               max_power = min(power, max_power);
-               if (max_power != ch_info->curr_txpow) {
-                       ch_info->curr_txpow = max_power;
-
-                       /* this considers the h/w clipping limitations */
-                       il3945_hw_reg_set_new_power(il, ch_info);
-               }
-       }
-
-       /* update txpower settings for all channels,
-        *   send to NIC if associated. */
-       il3945_is_temp_calib_needed(il);
-       il3945_hw_reg_comp_txpower_temp(il);
-
-       return 0;
-}
-
-static int
-il3945_send_rxon_assoc(struct il_priv *il)
-{
-       int rc = 0;
-       struct il_rx_pkt *pkt;
-       struct il3945_rxon_assoc_cmd rxon_assoc;
-       struct il_host_cmd cmd = {
-               .id = C_RXON_ASSOC,
-               .len = sizeof(rxon_assoc),
-               .flags = CMD_WANT_SKB,
-               .data = &rxon_assoc,
-       };
-       const struct il_rxon_cmd *rxon1 = &il->staging;
-       const struct il_rxon_cmd *rxon2 = &il->active;
-
-       if (rxon1->flags == rxon2->flags &&
-           rxon1->filter_flags == rxon2->filter_flags &&
-           rxon1->cck_basic_rates == rxon2->cck_basic_rates &&
-           rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates) {
-               D_INFO("Using current RXON_ASSOC.  Not resending.\n");
-               return 0;
-       }
-
-       rxon_assoc.flags = il->staging.flags;
-       rxon_assoc.filter_flags = il->staging.filter_flags;
-       rxon_assoc.ofdm_basic_rates = il->staging.ofdm_basic_rates;
-       rxon_assoc.cck_basic_rates = il->staging.cck_basic_rates;
-       rxon_assoc.reserved = 0;
-
-       rc = il_send_cmd_sync(il, &cmd);
-       if (rc)
-               return rc;
-
-       pkt = (struct il_rx_pkt *)cmd.reply_page;
-       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
-               IL_ERR("Bad return from C_RXON_ASSOC command\n");
-               rc = -EIO;
-       }
-
-       il_free_pages(il, cmd.reply_page);
-
-       return rc;
-}
-
-/**
- * il3945_commit_rxon - commit staging_rxon to hardware
- *
- * The RXON command in staging_rxon is committed to the hardware and
- * the active_rxon structure is updated with the new data.  This
- * function correctly transitions out of the RXON_ASSOC_MSK state if
- * a HW tune is required based on the RXON structure changes.
- */
-int
-il3945_commit_rxon(struct il_priv *il)
-{
-       /* cast away the const for active_rxon in this function */
-       struct il3945_rxon_cmd *active_rxon = (void *)&il->active;
-       struct il3945_rxon_cmd *staging_rxon = (void *)&il->staging;
-       int rc = 0;
-       bool new_assoc = !!(staging_rxon->filter_flags & RXON_FILTER_ASSOC_MSK);
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return -EINVAL;
-
-       if (!il_is_alive(il))
-               return -1;
-
-       /* always get timestamp with Rx frame */
-       staging_rxon->flags |= RXON_FLG_TSF2HOST_MSK;
-
-       /* select antenna */
-       staging_rxon->flags &= ~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
-       staging_rxon->flags |= il3945_get_antenna_flags(il);
-
-       rc = il_check_rxon_cmd(il);
-       if (rc) {
-               IL_ERR("Invalid RXON configuration.  Not committing.\n");
-               return -EINVAL;
-       }
-
-       /* If we don't need to send a full RXON, we can use
-        * il3945_rxon_assoc_cmd which is used to reconfigure filter
-        * and other flags for the current radio configuration. */
-       if (!il_full_rxon_required(il)) {
-               rc = il_send_rxon_assoc(il);
-               if (rc) {
-                       IL_ERR("Error setting RXON_ASSOC "
-                              "configuration (%d).\n", rc);
-                       return rc;
-               }
-
-               memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
-               /*
-                * We do not commit tx power settings while channel changing,
-                * do it now if tx power changed.
-                */
-               il_set_tx_power(il, il->tx_power_next, false);
-               return 0;
-       }
-
-       /* If we are currently associated and the new config requires
-        * 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 (il_is_associated(il) && new_assoc) {
-               D_INFO("Toggling associated bit on current RXON\n");
-               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-
-               /*
-                * reserved4 and 5 could have been filled by the iwlcore code.
-                * Let's clear them before pushing to the 3945.
-                */
-               active_rxon->reserved4 = 0;
-               active_rxon->reserved5 = 0;
-               rc = il_send_cmd_pdu(il, C_RXON, sizeof(struct il3945_rxon_cmd),
-                                    &il->active);
-
-               /* If the mask clearing failed then we set
-                * active_rxon back to what it was previously */
-               if (rc) {
-                       active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
-                       IL_ERR("Error clearing ASSOC_MSK on current "
-                              "configuration (%d).\n", rc);
-                       return rc;
-               }
-               il_clear_ucode_stations(il);
-               il_restore_stations(il);
-       }
-
-       D_INFO("Sending RXON\n" "* with%s RXON_FILTER_ASSOC_MSK\n"
-              "* channel = %d\n" "* bssid = %pM\n", (new_assoc ? "" : "out"),
-              le16_to_cpu(staging_rxon->channel), staging_rxon->bssid_addr);
-
-       /*
-        * reserved4 and 5 could have been filled by the iwlcore code.
-        * Let's clear them before pushing to the 3945.
-        */
-       staging_rxon->reserved4 = 0;
-       staging_rxon->reserved5 = 0;
-
-       il_set_rxon_hwcrypto(il, !il3945_mod_params.sw_crypto);
-
-       /* Apply the new configuration */
-       rc = il_send_cmd_pdu(il, C_RXON, sizeof(struct il3945_rxon_cmd),
-                            staging_rxon);
-       if (rc) {
-               IL_ERR("Error setting new configuration (%d).\n", rc);
-               return rc;
-       }
-
-       memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
-
-       if (!new_assoc) {
-               il_clear_ucode_stations(il);
-               il_restore_stations(il);
-       }
-
-       /* If we issue a new RXON command which required a tune then we must
-        * send a new TXPOWER command or we won't be able to Tx any frames */
-       rc = il_set_tx_power(il, il->tx_power_next, true);
-       if (rc) {
-               IL_ERR("Error setting Tx power (%d).\n", rc);
-               return rc;
-       }
-
-       /* Init the hardware's rate fallback order based on the band */
-       rc = il3945_init_hw_rate_table(il);
-       if (rc) {
-               IL_ERR("Error setting HW rate table: %02X\n", rc);
-               return -EIO;
-       }
-
-       return 0;
-}
-
-/**
- * il3945_reg_txpower_periodic -  called when time to check our temperature.
- *
- * -- reset periodic timer
- * -- see if temp has changed enough to warrant re-calibration ... if so:
- *     -- correct coeffs for temp (can reset temp timer)
- *     -- save this temp as "last",
- *     -- send new set of gain settings to NIC
- * NOTE:  This should continue working, even when we're not associated,
- *   so we can keep our internal table of scan powers current. */
-void
-il3945_reg_txpower_periodic(struct il_priv *il)
-{
-       /* This will kick in the "brute force"
-        * il3945_hw_reg_comp_txpower_temp() below */
-       if (!il3945_is_temp_calib_needed(il))
-               goto reschedule;
-
-       /* Set up a new set of temp-adjusted TxPowers, send to NIC.
-        * This is based *only* on current temperature,
-        * ignoring any previous power measurements */
-       il3945_hw_reg_comp_txpower_temp(il);
-
-reschedule:
-       queue_delayed_work(il->workqueue, &il->_3945.thermal_periodic,
-                          REG_RECALIB_PERIOD * HZ);
-}
-
-static void
-il3945_bg_reg_txpower_periodic(struct work_struct *work)
-{
-       struct il_priv *il = container_of(work, struct il_priv,
-                                         _3945.thermal_periodic.work);
-
-       mutex_lock(&il->mutex);
-       if (test_bit(S_EXIT_PENDING, &il->status) || il->txq == NULL)
-               goto out;
-
-       il3945_reg_txpower_periodic(il);
-out:
-       mutex_unlock(&il->mutex);
-}
-
-/**
- * il3945_hw_reg_get_ch_grp_idx - find the channel-group idx (0-4) for channel.
- *
- * This function is used when initializing channel-info structs.
- *
- * NOTE: These channel groups do *NOT* match the bands above!
- *      These channel groups are based on factory-tested channels;
- *      on A-band, EEPROM's "group frequency" entries represent the top
- *      channel in each group 1-4.  Group 5 All B/G channels are in group 0.
- */
-static u16
-il3945_hw_reg_get_ch_grp_idx(struct il_priv *il,
-                            const struct il_channel_info *ch_info)
-{
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-       struct il3945_eeprom_txpower_group *ch_grp = &eeprom->groups[0];
-       u8 group;
-       u16 group_idx = 0;      /* based on factory calib frequencies */
-       u8 grp_channel;
-
-       /* Find the group idx for the channel ... don't use idx 1(?) */
-       if (il_is_channel_a_band(ch_info)) {
-               for (group = 1; group < 5; group++) {
-                       grp_channel = ch_grp[group].group_channel;
-                       if (ch_info->channel <= grp_channel) {
-                               group_idx = group;
-                               break;
-                       }
-               }
-               /* group 4 has a few channels *above* its factory cal freq */
-               if (group == 5)
-                       group_idx = 4;
-       } else
-               group_idx = 0;  /* 2.4 GHz, group 0 */
-
-       D_POWER("Chnl %d mapped to grp %d\n", ch_info->channel, group_idx);
-       return group_idx;
-}
-
-/**
- * il3945_hw_reg_get_matched_power_idx - Interpolate to get nominal idx
- *
- * Interpolate to get nominal (i.e. at factory calibration temperature) idx
- *   into radio/DSP gain settings table for requested power.
- */
-static int
-il3945_hw_reg_get_matched_power_idx(struct il_priv *il, s8 requested_power,
-                                   s32 setting_idx, s32 *new_idx)
-{
-       const struct il3945_eeprom_txpower_group *chnl_grp = NULL;
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-       s32 idx0, idx1;
-       s32 power = 2 * requested_power;
-       s32 i;
-       const struct il3945_eeprom_txpower_sample *samples;
-       s32 gains0, gains1;
-       s32 res;
-       s32 denominator;
-
-       chnl_grp = &eeprom->groups[setting_idx];
-       samples = chnl_grp->samples;
-       for (i = 0; i < 5; i++) {
-               if (power == samples[i].power) {
-                       *new_idx = samples[i].gain_idx;
-                       return 0;
-               }
-       }
-
-       if (power > samples[1].power) {
-               idx0 = 0;
-               idx1 = 1;
-       } else if (power > samples[2].power) {
-               idx0 = 1;
-               idx1 = 2;
-       } else if (power > samples[3].power) {
-               idx0 = 2;
-               idx1 = 3;
-       } else {
-               idx0 = 3;
-               idx1 = 4;
-       }
-
-       denominator = (s32) samples[idx1].power - (s32) samples[idx0].power;
-       if (denominator == 0)
-               return -EINVAL;
-       gains0 = (s32) samples[idx0].gain_idx * (1 << 19);
-       gains1 = (s32) samples[idx1].gain_idx * (1 << 19);
-       res =
-           gains0 + (gains1 - gains0) * ((s32) power -
-                                         (s32) samples[idx0].power) /
-           denominator + (1 << 18);
-       *new_idx = res >> 19;
-       return 0;
-}
-
-static void
-il3945_hw_reg_init_channel_groups(struct il_priv *il)
-{
-       u32 i;
-       s32 rate_idx;
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-       const struct il3945_eeprom_txpower_group *group;
-
-       D_POWER("Initializing factory calib info from EEPROM\n");
-
-       for (i = 0; i < IL_NUM_TX_CALIB_GROUPS; i++) {
-               s8 *clip_pwrs;  /* table of power levels for each rate */
-               s8 satur_pwr;   /* saturation power for each chnl group */
-               group = &eeprom->groups[i];
-
-               /* sanity check on factory saturation power value */
-               if (group->saturation_power < 40) {
-                       IL_WARN("Error: saturation power is %d, "
-                               "less than minimum expected 40\n",
-                               group->saturation_power);
-                       return;
-               }
-
-               /*
-                * Derive requested power levels for each rate, based on
-                *   hardware capabilities (saturation power for band).
-                * Basic value is 3dB down from saturation, with further
-                *   power reductions for highest 3 data rates.  These
-                *   backoffs provide headroom for high rate modulation
-                *   power peaks, without too much distortion (clipping).
-                */
-               /* we'll fill in this array with h/w max power levels */
-               clip_pwrs = (s8 *) il->_3945.clip_groups[i].clip_powers;
-
-               /* divide factory saturation power by 2 to find -3dB level */
-               satur_pwr = (s8) (group->saturation_power >> 1);
-
-               /* fill in channel group's nominal powers for each rate */
-               for (rate_idx = 0; rate_idx < RATE_COUNT_3945;
-                    rate_idx++, clip_pwrs++) {
-                       switch (rate_idx) {
-                       case RATE_36M_IDX_TBL:
-                               if (i == 0)     /* B/G */
-                                       *clip_pwrs = satur_pwr;
-                               else    /* A */
-                                       *clip_pwrs = satur_pwr - 5;
-                               break;
-                       case RATE_48M_IDX_TBL:
-                               if (i == 0)
-                                       *clip_pwrs = satur_pwr - 7;
-                               else
-                                       *clip_pwrs = satur_pwr - 10;
-                               break;
-                       case RATE_54M_IDX_TBL:
-                               if (i == 0)
-                                       *clip_pwrs = satur_pwr - 9;
-                               else
-                                       *clip_pwrs = satur_pwr - 12;
-                               break;
-                       default:
-                               *clip_pwrs = satur_pwr;
-                               break;
-                       }
-               }
-       }
-}
-
-/**
- * il3945_txpower_set_from_eeprom - Set channel power info based on EEPROM
- *
- * Second pass (during init) to set up il->channel_info
- *
- * Set up Tx-power settings in our channel info database for each VALID
- * (for this geo/SKU) channel, at all Tx data rates, based on eeprom values
- * and current temperature.
- *
- * Since this is based on current temperature (at init time), these values may
- * not be valid for very long, but it gives us a starting/default point,
- * and allows us to active (i.e. using Tx) scan.
- *
- * This does *not* write values to NIC, just sets up our internal table.
- */
-int
-il3945_txpower_set_from_eeprom(struct il_priv *il)
-{
-       struct il_channel_info *ch_info = NULL;
-       struct il3945_channel_power_info *pwr_info;
-       struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
-       int delta_idx;
-       u8 rate_idx;
-       u8 scan_tbl_idx;
-       const s8 *clip_pwrs;    /* array of power levels for each rate */
-       u8 gain, dsp_atten;
-       s8 power;
-       u8 pwr_idx, base_pwr_idx, a_band;
-       u8 i;
-       int temperature;
-
-       /* save temperature reference,
-        *   so we can determine next time to calibrate */
-       temperature = il3945_hw_reg_txpower_get_temperature(il);
-       il->last_temperature = temperature;
-
-       il3945_hw_reg_init_channel_groups(il);
-
-       /* initialize Tx power info for each and every channel, 2.4 and 5.x */
-       for (i = 0, ch_info = il->channel_info; i < il->channel_count;
-            i++, ch_info++) {
-               a_band = il_is_channel_a_band(ch_info);
-               if (!il_is_channel_valid(ch_info))
-                       continue;
-
-               /* find this channel's channel group (*not* "band") idx */
-               ch_info->group_idx = il3945_hw_reg_get_ch_grp_idx(il, ch_info);
-
-               /* Get this chnlgrp's rate->max/clip-powers table */
-               clip_pwrs =
-                   il->_3945.clip_groups[ch_info->group_idx].clip_powers;
-
-               /* calculate power idx *adjustment* value according to
-                *  diff between current temperature and factory temperature */
-               delta_idx =
-                   il3945_hw_reg_adjust_power_by_temp(temperature,
-                                                      eeprom->groups[ch_info->
-                                                                     group_idx].
-                                                      temperature);
-
-               D_POWER("Delta idx for channel %d: %d [%d]\n", ch_info->channel,
-                       delta_idx, temperature + IL_TEMP_CONVERT);
-
-               /* set tx power value for all OFDM rates */
-               for (rate_idx = 0; rate_idx < IL_OFDM_RATES; rate_idx++) {
-                       s32 uninitialized_var(power_idx);
-                       int rc;
-
-                       /* use channel group's clip-power table,
-                        *   but don't exceed channel's max power */
-                       s8 pwr = min(ch_info->max_power_avg,
-                                    clip_pwrs[rate_idx]);
-
-                       pwr_info = &ch_info->power_info[rate_idx];
-
-                       /* get base (i.e. at factory-measured temperature)
-                        *    power table idx for this rate's power */
-                       rc = il3945_hw_reg_get_matched_power_idx(il, pwr,
-                                                                ch_info->
-                                                                group_idx,
-                                                                &power_idx);
-                       if (rc) {
-                               IL_ERR("Invalid power idx\n");
-                               return rc;
-                       }
-                       pwr_info->base_power_idx = (u8) power_idx;
-
-                       /* temperature compensate */
-                       power_idx += delta_idx;
-
-                       /* stay within range of gain table */
-                       power_idx = il3945_hw_reg_fix_power_idx(power_idx);
-
-                       /* fill 1 OFDM rate's il3945_channel_power_info struct */
-                       pwr_info->requested_power = pwr;
-                       pwr_info->power_table_idx = (u8) power_idx;
-                       pwr_info->tpc.tx_gain =
-                           power_gain_table[a_band][power_idx].tx_gain;
-                       pwr_info->tpc.dsp_atten =
-                           power_gain_table[a_band][power_idx].dsp_atten;
-               }
-
-               /* set tx power for CCK rates, based on OFDM 12 Mbit settings */
-               pwr_info = &ch_info->power_info[RATE_12M_IDX_TBL];
-               power = pwr_info->requested_power + IL_CCK_FROM_OFDM_POWER_DIFF;
-               pwr_idx = pwr_info->power_table_idx + IL_CCK_FROM_OFDM_IDX_DIFF;
-               base_pwr_idx =
-                   pwr_info->base_power_idx + IL_CCK_FROM_OFDM_IDX_DIFF;
-
-               /* stay within table range */
-               pwr_idx = il3945_hw_reg_fix_power_idx(pwr_idx);
-               gain = power_gain_table[a_band][pwr_idx].tx_gain;
-               dsp_atten = power_gain_table[a_band][pwr_idx].dsp_atten;
-
-               /* fill each CCK rate's il3945_channel_power_info structure
-                * NOTE:  All CCK-rate Txpwrs are the same for a given chnl!
-                * NOTE:  CCK rates start at end of OFDM rates! */
-               for (rate_idx = 0; rate_idx < IL_CCK_RATES; rate_idx++) {
-                       pwr_info =
-                           &ch_info->power_info[rate_idx + IL_OFDM_RATES];
-                       pwr_info->requested_power = power;
-                       pwr_info->power_table_idx = pwr_idx;
-                       pwr_info->base_power_idx = base_pwr_idx;
-                       pwr_info->tpc.tx_gain = gain;
-                       pwr_info->tpc.dsp_atten = dsp_atten;
-               }
-
-               /* set scan tx power, 1Mbit for CCK, 6Mbit for OFDM */
-               for (scan_tbl_idx = 0; scan_tbl_idx < IL_NUM_SCAN_RATES;
-                    scan_tbl_idx++) {
-                       s32 actual_idx =
-                           (scan_tbl_idx ==
-                            0) ? RATE_1M_IDX_TBL : RATE_6M_IDX_TBL;
-                       il3945_hw_reg_set_scan_power(il, scan_tbl_idx,
-                                                    actual_idx, clip_pwrs,
-                                                    ch_info, a_band);
-               }
-       }
-
-       return 0;
-}
-
-int
-il3945_hw_rxq_stop(struct il_priv *il)
-{
-       int ret;
-
-       _il_wr(il, FH39_RCSR_CONFIG(0), 0);
-       ret = _il_poll_bit(il, FH39_RSSR_STATUS,
-                          FH39_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
-                          FH39_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
-                          1000);
-       if (ret < 0)
-               IL_ERR("Can't stop Rx DMA.\n");
-
-       return 0;
-}
-
-int
-il3945_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq)
-{
-       int txq_id = txq->q.id;
-
-       struct il3945_shared *shared_data = il->_3945.shared_virt;
-
-       shared_data->tx_base_ptr[txq_id] = cpu_to_le32((u32) txq->q.dma_addr);
-
-       il_wr(il, FH39_CBCC_CTRL(txq_id), 0);
-       il_wr(il, FH39_CBCC_BASE(txq_id), 0);
-
-       il_wr(il, FH39_TCSR_CONFIG(txq_id),
-             FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_NOINT |
-             FH39_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_TXF |
-             FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_IFTFD |
-             FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL |
-             FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE);
-
-       /* fake read to flush all prev. writes */
-       _il_rd(il, FH39_TSSR_CBB_BASE);
-
-       return 0;
-}
-
-/*
- * HCMD utils
- */
-static u16
-il3945_get_hcmd_size(u8 cmd_id, u16 len)
-{
-       switch (cmd_id) {
-       case C_RXON:
-               return sizeof(struct il3945_rxon_cmd);
-       case C_POWER_TBL:
-               return sizeof(struct il3945_powertable_cmd);
-       default:
-               return len;
-       }
-}
-
-static u16
-il3945_build_addsta_hcmd(const struct il_addsta_cmd *cmd, u8 * data)
-{
-       struct il3945_addsta_cmd *addsta = (struct il3945_addsta_cmd *)data;
-       addsta->mode = cmd->mode;
-       memcpy(&addsta->sta, &cmd->sta, sizeof(struct sta_id_modify));
-       memcpy(&addsta->key, &cmd->key, sizeof(struct il4965_keyinfo));
-       addsta->station_flags = cmd->station_flags;
-       addsta->station_flags_msk = cmd->station_flags_msk;
-       addsta->tid_disable_tx = cpu_to_le16(0);
-       addsta->rate_n_flags = cmd->rate_n_flags;
-       addsta->add_immediate_ba_tid = cmd->add_immediate_ba_tid;
-       addsta->remove_immediate_ba_tid = cmd->remove_immediate_ba_tid;
-       addsta->add_immediate_ba_ssn = cmd->add_immediate_ba_ssn;
-
-       return (u16) sizeof(struct il3945_addsta_cmd);
-}
-
-static int
-il3945_add_bssid_station(struct il_priv *il, const u8 * addr, u8 * sta_id_r)
-{
-       int ret;
-       u8 sta_id;
-       unsigned long flags;
-
-       if (sta_id_r)
-               *sta_id_r = IL_INVALID_STATION;
-
-       ret = il_add_station_common(il, addr, 0, NULL, &sta_id);
-       if (ret) {
-               IL_ERR("Unable to add station %pM\n", addr);
-               return ret;
-       }
-
-       if (sta_id_r)
-               *sta_id_r = sta_id;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].used |= IL_STA_LOCAL;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return 0;
-}
-
-static int
-il3945_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
-                          bool add)
-{
-       struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
-       int ret;
-
-       if (add) {
-               ret =
-                   il3945_add_bssid_station(il, vif->bss_conf.bssid,
-                                            &vif_priv->ibss_bssid_sta_id);
-               if (ret)
-                       return ret;
-
-               il3945_sync_sta(il, vif_priv->ibss_bssid_sta_id,
-                               (il->band ==
-                                IEEE80211_BAND_5GHZ) ? RATE_6M_PLCP :
-                               RATE_1M_PLCP);
-               il3945_rate_scale_init(il->hw, vif_priv->ibss_bssid_sta_id);
-
-               return 0;
-       }
-
-       return il_remove_station(il, vif_priv->ibss_bssid_sta_id,
-                                vif->bss_conf.bssid);
-}
-
-/**
- * il3945_init_hw_rate_table - Initialize the hardware rate fallback table
- */
-int
-il3945_init_hw_rate_table(struct il_priv *il)
-{
-       int rc, i, idx, prev_idx;
-       struct il3945_rate_scaling_cmd rate_cmd = {
-               .reserved = {0, 0, 0},
-       };
-       struct il3945_rate_scaling_info *table = rate_cmd.table;
-
-       for (i = 0; i < ARRAY_SIZE(il3945_rates); i++) {
-               idx = il3945_rates[i].table_rs_idx;
-
-               table[idx].rate_n_flags = cpu_to_le16(il3945_rates[i].plcp);
-               table[idx].try_cnt = il->retry_rate;
-               prev_idx = il3945_get_prev_ieee_rate(i);
-               table[idx].next_rate_idx = il3945_rates[prev_idx].table_rs_idx;
-       }
-
-       switch (il->band) {
-       case IEEE80211_BAND_5GHZ:
-               D_RATE("Select A mode rate scale\n");
-               /* If one of the following CCK rates is used,
-                * have it fall back to the 6M OFDM rate */
-               for (i = RATE_1M_IDX_TBL; i <= RATE_11M_IDX_TBL; i++)
-                       table[i].next_rate_idx =
-                           il3945_rates[IL_FIRST_OFDM_RATE].table_rs_idx;
-
-               /* Don't fall back to CCK rates */
-               table[RATE_12M_IDX_TBL].next_rate_idx = RATE_9M_IDX_TBL;
-
-               /* Don't drop out of OFDM rates */
-               table[RATE_6M_IDX_TBL].next_rate_idx =
-                   il3945_rates[IL_FIRST_OFDM_RATE].table_rs_idx;
-               break;
-
-       case IEEE80211_BAND_2GHZ:
-               D_RATE("Select B/G mode rate scale\n");
-               /* If an OFDM rate is used, have it fall back to the
-                * 1M CCK rates */
-
-               if (!(il->_3945.sta_supp_rates & IL_OFDM_RATES_MASK) &&
-                   il_is_associated(il)) {
-
-                       idx = IL_FIRST_CCK_RATE;
-                       for (i = RATE_6M_IDX_TBL; i <= RATE_54M_IDX_TBL; i++)
-                               table[i].next_rate_idx =
-                                   il3945_rates[idx].table_rs_idx;
-
-                       idx = RATE_11M_IDX_TBL;
-                       /* CCK shouldn't fall back to OFDM... */
-                       table[idx].next_rate_idx = RATE_5M_IDX_TBL;
-               }
-               break;
-
-       default:
-               WARN_ON(1);
-               break;
-       }
-
-       /* Update the rate scaling for control frame Tx */
-       rate_cmd.table_id = 0;
-       rc = il_send_cmd_pdu(il, C_RATE_SCALE, sizeof(rate_cmd), &rate_cmd);
-       if (rc)
-               return rc;
-
-       /* Update the rate scaling for data frame Tx */
-       rate_cmd.table_id = 1;
-       return il_send_cmd_pdu(il, C_RATE_SCALE, sizeof(rate_cmd), &rate_cmd);
-}
-
-/* Called when initializing driver */
-int
-il3945_hw_set_hw_params(struct il_priv *il)
-{
-       memset((void *)&il->hw_params, 0, sizeof(struct il_hw_params));
-
-       il->_3945.shared_virt =
-           dma_alloc_coherent(&il->pci_dev->dev, sizeof(struct il3945_shared),
-                              &il->_3945.shared_phys, GFP_KERNEL);
-       if (!il->_3945.shared_virt)
-               return -ENOMEM;
-
-       il->hw_params.bcast_id = IL3945_BROADCAST_ID;
-
-       /* Assign number of Usable TX queues */
-       il->hw_params.max_txq_num = il->cfg->num_of_queues;
-
-       il->hw_params.tfd_size = sizeof(struct il3945_tfd);
-       il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_3K);
-       il->hw_params.max_rxq_size = RX_QUEUE_SIZE;
-       il->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
-       il->hw_params.max_stations = IL3945_STATION_COUNT;
-
-       il->sta_key_max_num = STA_KEY_MAX_NUM;
-
-       il->hw_params.rx_wrt_ptr_reg = FH39_RSCSR_CHNL0_WPTR;
-       il->hw_params.max_beacon_itrvl = IL39_MAX_UCODE_BEACON_INTERVAL;
-       il->hw_params.beacon_time_tsf_bits = IL3945_EXT_BEACON_TIME_POS;
-
-       return 0;
-}
-
-unsigned int
-il3945_hw_get_beacon_cmd(struct il_priv *il, struct il3945_frame *frame,
-                        u8 rate)
-{
-       struct il3945_tx_beacon_cmd *tx_beacon_cmd;
-       unsigned int frame_size;
-
-       tx_beacon_cmd = (struct il3945_tx_beacon_cmd *)&frame->u;
-       memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
-
-       tx_beacon_cmd->tx.sta_id = il->hw_params.bcast_id;
-       tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
-
-       frame_size =
-           il3945_fill_beacon_frame(il, tx_beacon_cmd->frame,
-                                    sizeof(frame->u) - sizeof(*tx_beacon_cmd));
-
-       BUG_ON(frame_size > MAX_MPDU_SIZE);
-       tx_beacon_cmd->tx.len = cpu_to_le16((u16) frame_size);
-
-       tx_beacon_cmd->tx.rate = rate;
-       tx_beacon_cmd->tx.tx_flags =
-           (TX_CMD_FLG_SEQ_CTL_MSK | TX_CMD_FLG_TSF_MSK);
-
-       /* supp_rates[0] == OFDM start at IL_FIRST_OFDM_RATE */
-       tx_beacon_cmd->tx.supp_rates[0] =
-           (IL_OFDM_BASIC_RATES_MASK >> IL_FIRST_OFDM_RATE) & 0xFF;
-
-       tx_beacon_cmd->tx.supp_rates[1] = (IL_CCK_BASIC_RATES_MASK & 0xF);
-
-       return sizeof(struct il3945_tx_beacon_cmd) + frame_size;
-}
-
-void
-il3945_hw_handler_setup(struct il_priv *il)
-{
-       il->handlers[C_TX] = il3945_hdl_tx;
-       il->handlers[N_3945_RX] = il3945_hdl_rx;
-}
-
-void
-il3945_hw_setup_deferred_work(struct il_priv *il)
-{
-       INIT_DELAYED_WORK(&il->_3945.thermal_periodic,
-                         il3945_bg_reg_txpower_periodic);
-}
-
-void
-il3945_hw_cancel_deferred_work(struct il_priv *il)
-{
-       cancel_delayed_work(&il->_3945.thermal_periodic);
-}
-
-/* check contents of special bootstrap uCode SRAM */
-static int
-il3945_verify_bsm(struct il_priv *il)
-{
-       __le32 *image = il->ucode_boot.v_addr;
-       u32 len = il->ucode_boot.len;
-       u32 reg;
-       u32 val;
-
-       D_INFO("Begin verify bsm\n");
-
-       /* verify BSM SRAM contents */
-       val = il_rd_prph(il, BSM_WR_DWCOUNT_REG);
-       for (reg = BSM_SRAM_LOWER_BOUND; reg < BSM_SRAM_LOWER_BOUND + len;
-            reg += sizeof(u32), image++) {
-               val = il_rd_prph(il, reg);
-               if (val != le32_to_cpu(*image)) {
-                       IL_ERR("BSM uCode verification failed at "
-                              "addr 0x%08X+%u (of %u), is 0x%x, s/b 0x%x\n",
-                              BSM_SRAM_LOWER_BOUND, reg - BSM_SRAM_LOWER_BOUND,
-                              len, val, le32_to_cpu(*image));
-                       return -EIO;
-               }
-       }
-
-       D_INFO("BSM bootstrap uCode image OK\n");
-
-       return 0;
-}
-
-/******************************************************************************
- *
- * EEPROM related functions
- *
- ******************************************************************************/
-
-/*
- * Clear the OWNER_MSK, to establish driver (instead of uCode running on
- * embedded controller) as EEPROM reader; each read is a series of pulses
- * to/from the EEPROM chip, not a single event, so even reads could conflict
- * if they weren't arbitrated by some ownership mechanism.  Here, the driver
- * simply claims ownership, which should be safe when this function is called
- * (i.e. before loading uCode!).
- */
-static int
-il3945_eeprom_acquire_semaphore(struct il_priv *il)
-{
-       _il_clear_bit(il, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
-       return 0;
-}
-
-static void
-il3945_eeprom_release_semaphore(struct il_priv *il)
-{
-       return;
-}
-
- /**
-  * il3945_load_bsm - Load bootstrap instructions
-  *
-  * BSM operation:
-  *
-  * The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
-  * in special SRAM that does not power down during RFKILL.  When powering back
-  * up after power-saving sleeps (or during initial uCode load), the BSM loads
-  * the bootstrap program into the on-board processor, and starts it.
-  *
-  * The bootstrap program loads (via DMA) instructions and data for a new
-  * program from host DRAM locations indicated by the host driver in the
-  * BSM_DRAM_* registers.  Once the new program is loaded, it starts
-  * automatically.
-  *
-  * When initializing the NIC, the host driver points the BSM to the
-  * "initialize" uCode image.  This uCode sets up some internal data, then
-  * notifies host via "initialize alive" that it is complete.
-  *
-  * The host then replaces the BSM_DRAM_* pointer values to point to the
-  * normal runtime uCode instructions and a backup uCode data cache buffer
-  * (filled initially with starting data values for the on-board processor),
-  * then triggers the "initialize" uCode to load and launch the runtime uCode,
-  * which begins normal operation.
-  *
-  * When doing a power-save shutdown, runtime uCode saves data SRAM into
-  * the backup data cache in DRAM before SRAM is powered down.
-  *
-  * When powering back up, the BSM loads the bootstrap program.  This reloads
-  * the runtime uCode instructions and the backup data cache into SRAM,
-  * and re-launches the runtime uCode from where it left off.
-  */
-static int
-il3945_load_bsm(struct il_priv *il)
-{
-       __le32 *image = il->ucode_boot.v_addr;
-       u32 len = il->ucode_boot.len;
-       dma_addr_t pinst;
-       dma_addr_t pdata;
-       u32 inst_len;
-       u32 data_len;
-       int rc;
-       int i;
-       u32 done;
-       u32 reg_offset;
-
-       D_INFO("Begin load bsm\n");
-
-       /* make sure bootstrap program is no larger than BSM's SRAM size */
-       if (len > IL39_MAX_BSM_SIZE)
-               return -EINVAL;
-
-       /* Tell bootstrap uCode where to find the "Initialize" uCode
-        *   in host DRAM ... host DRAM physical address bits 31:0 for 3945.
-        * NOTE:  il3945_initialize_alive_start() will replace these values,
-        *        after the "initialize" uCode has run, to point to
-        *        runtime/protocol instructions and backup data cache. */
-       pinst = il->ucode_init.p_addr;
-       pdata = il->ucode_init_data.p_addr;
-       inst_len = il->ucode_init.len;
-       data_len = il->ucode_init_data.len;
-
-       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
-       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
-       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
-       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
-
-       /* Fill BSM memory with bootstrap instructions */
-       for (reg_offset = BSM_SRAM_LOWER_BOUND;
-            reg_offset < BSM_SRAM_LOWER_BOUND + len;
-            reg_offset += sizeof(u32), image++)
-               _il_wr_prph(il, reg_offset, le32_to_cpu(*image));
-
-       rc = il3945_verify_bsm(il);
-       if (rc)
-               return rc;
-
-       /* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
-       il_wr_prph(il, BSM_WR_MEM_SRC_REG, 0x0);
-       il_wr_prph(il, BSM_WR_MEM_DST_REG, IL39_RTC_INST_LOWER_BOUND);
-       il_wr_prph(il, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
-
-       /* Load bootstrap code into instruction SRAM now,
-        *   to prepare to load "initialize" uCode */
-       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START);
-
-       /* Wait for load of bootstrap uCode to finish */
-       for (i = 0; i < 100; i++) {
-               done = il_rd_prph(il, BSM_WR_CTRL_REG);
-               if (!(done & BSM_WR_CTRL_REG_BIT_START))
-                       break;
-               udelay(10);
-       }
-       if (i < 100)
-               D_INFO("BSM write complete, poll %d iterations\n", i);
-       else {
-               IL_ERR("BSM write did not complete!\n");
-               return -EIO;
-       }
-
-       /* Enable future boot loads whenever power management unit triggers it
-        *   (e.g. when powering back up after power-save shutdown) */
-       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START_EN);
-
-       return 0;
-}
-
-const struct il_ops il3945_ops = {
-       .txq_attach_buf_to_tfd = il3945_hw_txq_attach_buf_to_tfd,
-       .txq_free_tfd = il3945_hw_txq_free_tfd,
-       .txq_init = il3945_hw_tx_queue_init,
-       .load_ucode = il3945_load_bsm,
-       .dump_nic_error_log = il3945_dump_nic_error_log,
-       .apm_init = il3945_apm_init,
-       .send_tx_power = il3945_send_tx_power,
-       .is_valid_rtc_data_addr = il3945_hw_valid_rtc_data_addr,
-       .eeprom_acquire_semaphore = il3945_eeprom_acquire_semaphore,
-       .eeprom_release_semaphore = il3945_eeprom_release_semaphore,
-
-       .rxon_assoc = il3945_send_rxon_assoc,
-       .commit_rxon = il3945_commit_rxon,
-
-       .get_hcmd_size = il3945_get_hcmd_size,
-       .build_addsta_hcmd = il3945_build_addsta_hcmd,
-       .request_scan = il3945_request_scan,
-       .post_scan = il3945_post_scan,
-
-       .post_associate = il3945_post_associate,
-       .config_ap = il3945_config_ap,
-       .manage_ibss_station = il3945_manage_ibss_station,
-
-       .send_led_cmd = il3945_send_led_cmd,
-};
-
-static struct il_cfg il3945_bg_cfg = {
-       .name = "3945BG",
-       .fw_name_pre = IL3945_FW_PRE,
-       .ucode_api_max = IL3945_UCODE_API_MAX,
-       .ucode_api_min = IL3945_UCODE_API_MIN,
-       .sku = IL_SKU_G,
-       .eeprom_ver = EEPROM_3945_EEPROM_VERSION,
-       .mod_params = &il3945_mod_params,
-       .led_mode = IL_LED_BLINK,
-
-       .eeprom_size = IL3945_EEPROM_IMG_SIZE,
-       .num_of_queues = IL39_NUM_QUEUES,
-       .pll_cfg_val = CSR39_ANA_PLL_CFG_VAL,
-       .set_l0s = false,
-       .use_bsm = true,
-       .led_compensation = 64,
-       .wd_timeout = IL_DEF_WD_TIMEOUT,
-
-       .regulatory_bands = {
-               EEPROM_REGULATORY_BAND_1_CHANNELS,
-               EEPROM_REGULATORY_BAND_2_CHANNELS,
-               EEPROM_REGULATORY_BAND_3_CHANNELS,
-               EEPROM_REGULATORY_BAND_4_CHANNELS,
-               EEPROM_REGULATORY_BAND_5_CHANNELS,
-               EEPROM_REGULATORY_BAND_NO_HT40,
-               EEPROM_REGULATORY_BAND_NO_HT40,
-       },
-};
-
-static struct il_cfg il3945_abg_cfg = {
-       .name = "3945ABG",
-       .fw_name_pre = IL3945_FW_PRE,
-       .ucode_api_max = IL3945_UCODE_API_MAX,
-       .ucode_api_min = IL3945_UCODE_API_MIN,
-       .sku = IL_SKU_A | IL_SKU_G,
-       .eeprom_ver = EEPROM_3945_EEPROM_VERSION,
-       .mod_params = &il3945_mod_params,
-       .led_mode = IL_LED_BLINK,
-
-       .eeprom_size = IL3945_EEPROM_IMG_SIZE,
-       .num_of_queues = IL39_NUM_QUEUES,
-       .pll_cfg_val = CSR39_ANA_PLL_CFG_VAL,
-       .set_l0s = false,
-       .use_bsm = true,
-       .led_compensation = 64,
-       .wd_timeout = IL_DEF_WD_TIMEOUT,
-
-       .regulatory_bands = {
-               EEPROM_REGULATORY_BAND_1_CHANNELS,
-               EEPROM_REGULATORY_BAND_2_CHANNELS,
-               EEPROM_REGULATORY_BAND_3_CHANNELS,
-               EEPROM_REGULATORY_BAND_4_CHANNELS,
-               EEPROM_REGULATORY_BAND_5_CHANNELS,
-               EEPROM_REGULATORY_BAND_NO_HT40,
-               EEPROM_REGULATORY_BAND_NO_HT40,
-       },
-};
-
-const struct pci_device_id il3945_hw_card_ids[] = {
-       {IL_PCI_DEVICE(0x4222, 0x1005, il3945_bg_cfg)},
-       {IL_PCI_DEVICE(0x4222, 0x1034, il3945_bg_cfg)},
-       {IL_PCI_DEVICE(0x4222, 0x1044, il3945_bg_cfg)},
-       {IL_PCI_DEVICE(0x4227, 0x1014, il3945_bg_cfg)},
-       {IL_PCI_DEVICE(0x4222, PCI_ANY_ID, il3945_abg_cfg)},
-       {IL_PCI_DEVICE(0x4227, PCI_ANY_ID, il3945_abg_cfg)},
-       {0}
-};
-
-MODULE_DEVICE_TABLE(pci, il3945_hw_card_ids);
diff --git a/drivers/net/wireless/iwlegacy/3945.h b/drivers/net/wireless/iwlegacy/3945.h
deleted file mode 100644 (file)
index 00030d4..0000000
+++ /dev/null
@@ -1,593 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#ifndef __il_3945_h__
-#define __il_3945_h__
-
-#include <linux/pci.h>         /* for struct pci_device_id */
-#include <linux/kernel.h>
-#include <net/ieee80211_radiotap.h>
-
-/* Hardware specific file defines the PCI IDs table for that hardware module */
-extern const struct pci_device_id il3945_hw_card_ids[];
-
-#include "common.h"
-
-extern const struct il_ops il3945_ops;
-
-/* Highest firmware API version supported */
-#define IL3945_UCODE_API_MAX 2
-
-/* Lowest firmware API version supported */
-#define IL3945_UCODE_API_MIN 1
-
-#define IL3945_FW_PRE  "iwlwifi-3945-"
-#define _IL3945_MODULE_FIRMWARE(api) IL3945_FW_PRE #api ".ucode"
-#define IL3945_MODULE_FIRMWARE(api) _IL3945_MODULE_FIRMWARE(api)
-
-/* Default noise level to report when noise measurement is not available.
- *   This may be because we're:
- *   1)  Not associated (4965, no beacon stats being sent to driver)
- *   2)  Scanning (noise measurement does not apply to associated channel)
- *   3)  Receiving CCK (3945 delivers noise info only for OFDM frames)
- * Use default noise value of -127 ... this is below the range of measurable
- *   Rx dBm for either 3945 or 4965, so it can indicate "unmeasurable" to user.
- *   Also, -127 works better than 0 when averaging frames with/without
- *   noise info (e.g. averaging might be done in app); measured dBm values are
- *   always negative ... using a negative value as the default keeps all
- *   averages within an s8's (used in some apps) range of negative values. */
-#define IL_NOISE_MEAS_NOT_AVAILABLE (-127)
-
-/* Module parameters accessible from iwl-*.c */
-extern struct il_mod_params il3945_mod_params;
-
-struct il3945_rate_scale_data {
-       u64 data;
-       s32 success_counter;
-       s32 success_ratio;
-       s32 counter;
-       s32 average_tpt;
-       unsigned long stamp;
-};
-
-struct il3945_rs_sta {
-       spinlock_t lock;
-       struct il_priv *il;
-       s32 *expected_tpt;
-       unsigned long last_partial_flush;
-       unsigned long last_flush;
-       u32 flush_time;
-       u32 last_tx_packets;
-       u32 tx_packets;
-       u8 tgg;
-       u8 flush_pending;
-       u8 start_rate;
-       struct timer_list rate_scale_flush;
-       struct il3945_rate_scale_data win[RATE_COUNT_3945];
-#ifdef CONFIG_MAC80211_DEBUGFS
-       struct dentry *rs_sta_dbgfs_stats_table_file;
-#endif
-
-       /* used to be in sta_info */
-       int last_txrate_idx;
-};
-
-/*
- * The common struct MUST be first because it is shared between
- * 3945 and 4965!
- */
-struct il3945_sta_priv {
-       struct il_station_priv_common common;
-       struct il3945_rs_sta rs_sta;
-};
-
-enum il3945_antenna {
-       IL_ANTENNA_DIVERSITY,
-       IL_ANTENNA_MAIN,
-       IL_ANTENNA_AUX
-};
-
-/*
- * RTS threshold here is total size [2347] minus 4 FCS bytes
- * Per spec:
- *   a value of 0 means RTS on all data/management packets
- *   a value > max MSDU size means no RTS
- * else RTS for data/management frames where MPDU is larger
- *   than RTS value.
- */
-#define DEFAULT_RTS_THRESHOLD     2347U
-#define MIN_RTS_THRESHOLD         0U
-#define MAX_RTS_THRESHOLD         2347U
-#define MAX_MSDU_SIZE            2304U
-#define MAX_MPDU_SIZE            2346U
-#define DEFAULT_BEACON_INTERVAL   100U
-#define        DEFAULT_SHORT_RETRY_LIMIT 7U
-#define        DEFAULT_LONG_RETRY_LIMIT  4U
-
-#define IL_TX_FIFO_AC0 0
-#define IL_TX_FIFO_AC1 1
-#define IL_TX_FIFO_AC2 2
-#define IL_TX_FIFO_AC3 3
-#define IL_TX_FIFO_HCCA_1      5
-#define IL_TX_FIFO_HCCA_2      6
-#define IL_TX_FIFO_NONE        7
-
-#define IEEE80211_DATA_LEN              2304
-#define IEEE80211_4ADDR_LEN             30
-#define IEEE80211_HLEN                  (IEEE80211_4ADDR_LEN)
-#define IEEE80211_FRAME_LEN             (IEEE80211_DATA_LEN + IEEE80211_HLEN)
-
-struct il3945_frame {
-       union {
-               struct ieee80211_hdr frame;
-               struct il3945_tx_beacon_cmd beacon;
-               u8 raw[IEEE80211_FRAME_LEN];
-               u8 cmd[360];
-       } u;
-       struct list_head list;
-};
-
-#define SUP_RATE_11A_MAX_NUM_CHANNELS  8
-#define SUP_RATE_11B_MAX_NUM_CHANNELS  4
-#define SUP_RATE_11G_MAX_NUM_CHANNELS  12
-
-#define IL_SUPPORTED_RATES_IE_LEN         8
-
-#define SCAN_INTERVAL 100
-
-#define MAX_TID_COUNT        9
-
-#define IL_INVALID_RATE     0xFF
-#define IL_INVALID_VALUE    -1
-
-#define STA_PS_STATUS_WAKE             0
-#define STA_PS_STATUS_SLEEP            1
-
-struct il3945_ibss_seq {
-       u8 mac[ETH_ALEN];
-       u16 seq_num;
-       u16 frag_num;
-       unsigned long packet_time;
-       struct list_head list;
-};
-
-#define IL_RX_HDR(x) ((struct il3945_rx_frame_hdr *)(\
-                      x->u.rx_frame.stats.payload + \
-                      x->u.rx_frame.stats.phy_count))
-#define IL_RX_END(x) ((struct il3945_rx_frame_end *)(\
-                      IL_RX_HDR(x)->payload + \
-                      le16_to_cpu(IL_RX_HDR(x)->len)))
-#define IL_RX_STATS(x) (&x->u.rx_frame.stats)
-#define IL_RX_DATA(x) (IL_RX_HDR(x)->payload)
-
-/******************************************************************************
- *
- * Functions implemented in iwl3945-base.c which are forward declared here
- * for use by iwl-*.c
- *
- *****************************************************************************/
-int il3945_calc_db_from_ratio(int sig_ratio);
-void il3945_rx_replenish(void *data);
-void il3945_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq);
-unsigned int il3945_fill_beacon_frame(struct il_priv *il,
-                                     struct ieee80211_hdr *hdr, int left);
-int il3945_dump_nic_event_log(struct il_priv *il, bool full_log, char **buf,
-                             bool display);
-void il3945_dump_nic_error_log(struct il_priv *il);
-
-/******************************************************************************
- *
- * Functions implemented in iwl-[34]*.c which are forward declared here
- * for use by iwl3945-base.c
- *
- * NOTE:  The implementation of these functions are hardware specific
- * which is why they are in the hardware specific files (vs. iwl-base.c)
- *
- * Naming convention --
- * il3945_         <-- Its part of iwlwifi (should be changed to il3945_)
- * il3945_hw_      <-- Hardware specific (implemented in iwl-XXXX.c by all HW)
- * iwlXXXX_     <-- Hardware specific (implemented in iwl-XXXX.c for XXXX)
- * il3945_bg_      <-- Called from work queue context
- * il3945_mac_     <-- mac80211 callback
- *
- ****************************************************************************/
-void il3945_hw_handler_setup(struct il_priv *il);
-void il3945_hw_setup_deferred_work(struct il_priv *il);
-void il3945_hw_cancel_deferred_work(struct il_priv *il);
-int il3945_hw_rxq_stop(struct il_priv *il);
-int il3945_hw_set_hw_params(struct il_priv *il);
-int il3945_hw_nic_init(struct il_priv *il);
-int il3945_hw_nic_stop_master(struct il_priv *il);
-void il3945_hw_txq_ctx_free(struct il_priv *il);
-void il3945_hw_txq_ctx_stop(struct il_priv *il);
-int il3945_hw_nic_reset(struct il_priv *il);
-int il3945_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
-                                   dma_addr_t addr, u16 len, u8 reset, u8 pad);
-void il3945_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq);
-int il3945_hw_get_temperature(struct il_priv *il);
-int il3945_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq);
-unsigned int il3945_hw_get_beacon_cmd(struct il_priv *il,
-                                     struct il3945_frame *frame, u8 rate);
-void il3945_hw_build_tx_cmd_rate(struct il_priv *il, struct il_device_cmd *cmd,
-                                struct ieee80211_tx_info *info,
-                                struct ieee80211_hdr *hdr, int sta_id);
-int il3945_hw_reg_send_txpower(struct il_priv *il);
-int il3945_hw_reg_set_txpower(struct il_priv *il, s8 power);
-void il3945_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb);
-void il3945_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb);
-void il3945_disable_events(struct il_priv *il);
-int il4965_get_temperature(const struct il_priv *il);
-void il3945_post_associate(struct il_priv *il);
-void il3945_config_ap(struct il_priv *il);
-
-int il3945_commit_rxon(struct il_priv *il);
-
-/**
- * il3945_hw_find_station - Find station id for a given BSSID
- * @bssid: MAC address of station ID to find
- *
- * NOTE:  This should not be hardware specific but the code has
- * not yet been merged into a single common layer for managing the
- * station tables.
- */
-u8 il3945_hw_find_station(struct il_priv *il, const u8 *bssid);
-
-__le32 il3945_get_antenna_flags(const struct il_priv *il);
-int il3945_init_hw_rate_table(struct il_priv *il);
-void il3945_reg_txpower_periodic(struct il_priv *il);
-int il3945_txpower_set_from_eeprom(struct il_priv *il);
-
-int il3945_rs_next_rate(struct il_priv *il, int rate);
-
-/* scanning */
-int il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif);
-void il3945_post_scan(struct il_priv *il);
-
-/* rates */
-extern const struct il3945_rate_info il3945_rates[RATE_COUNT_3945];
-
-/* RSSI to dBm */
-#define IL39_RSSI_OFFSET       95
-
-/*
- * EEPROM related constants, enums, and structures.
- */
-#define EEPROM_SKU_CAP_OP_MODE_MRC                      (1 << 7)
-
-/*
- * Mapping of a Tx power level, at factory calibration temperature,
- *   to a radio/DSP gain table idx.
- * One for each of 5 "sample" power levels in each band.
- * v_det is measured at the factory, using the 3945's built-in power amplifier
- *   (PA) output voltage detector.  This same detector is used during Tx of
- *   long packets in normal operation to provide feedback as to proper output
- *   level.
- * Data copied from EEPROM.
- * DO NOT ALTER THIS STRUCTURE!!!
- */
-struct il3945_eeprom_txpower_sample {
-       u8 gain_idx;            /* idx into power (gain) setup table ... */
-       s8 power;               /* ... for this pwr level for this chnl group */
-       u16 v_det;              /* PA output voltage */
-} __packed;
-
-/*
- * Mappings of Tx power levels -> nominal radio/DSP gain table idxes.
- * One for each channel group (a.k.a. "band") (1 for BG, 4 for A).
- * Tx power setup code interpolates between the 5 "sample" power levels
- *    to determine the nominal setup for a requested power level.
- * Data copied from EEPROM.
- * DO NOT ALTER THIS STRUCTURE!!!
- */
-struct il3945_eeprom_txpower_group {
-       struct il3945_eeprom_txpower_sample samples[5]; /* 5 power levels */
-       s32 a, b, c, d, e;      /* coefficients for voltage->power
-                                * formula (signed) */
-       s32 Fa, Fb, Fc, Fd, Fe; /* these modify coeffs based on
-                                * frequency (signed) */
-       s8 saturation_power;    /* highest power possible by h/w in this
-                                * band */
-       u8 group_channel;       /* "representative" channel # in this band */
-       s16 temperature;        /* h/w temperature at factory calib this band
-                                * (signed) */
-} __packed;
-
-/*
- * Temperature-based Tx-power compensation data, not band-specific.
- * These coefficients are use to modify a/b/c/d/e coeffs based on
- *   difference between current temperature and factory calib temperature.
- * Data copied from EEPROM.
- */
-struct il3945_eeprom_temperature_corr {
-       u32 Ta;
-       u32 Tb;
-       u32 Tc;
-       u32 Td;
-       u32 Te;
-} __packed;
-
-/*
- * EEPROM map
- */
-struct il3945_eeprom {
-       u8 reserved0[16];
-       u16 device_id;          /* abs.ofs: 16 */
-       u8 reserved1[2];
-       u16 pmc;                /* abs.ofs: 20 */
-       u8 reserved2[20];
-       u8 mac_address[6];      /* abs.ofs: 42 */
-       u8 reserved3[58];
-       u16 board_revision;     /* abs.ofs: 106 */
-       u8 reserved4[11];
-       u8 board_pba_number[9]; /* abs.ofs: 119 */
-       u8 reserved5[8];
-       u16 version;            /* abs.ofs: 136 */
-       u8 sku_cap;             /* abs.ofs: 138 */
-       u8 leds_mode;           /* abs.ofs: 139 */
-       u16 oem_mode;
-       u16 wowlan_mode;        /* abs.ofs: 142 */
-       u16 leds_time_interval; /* abs.ofs: 144 */
-       u8 leds_off_time;       /* abs.ofs: 146 */
-       u8 leds_on_time;        /* abs.ofs: 147 */
-       u8 almgor_m_version;    /* abs.ofs: 148 */
-       u8 antenna_switch_type; /* abs.ofs: 149 */
-       u8 reserved6[42];
-       u8 sku_id[4];           /* abs.ofs: 192 */
-
-/*
- * Per-channel regulatory data.
- *
- * Each channel that *might* be supported by 3945 has a fixed location
- * in EEPROM containing EEPROM_CHANNEL_* usage flags (LSB) and max regulatory
- * txpower (MSB).
- *
- * Entries immediately below are for 20 MHz channel width.
- *
- * 2.4 GHz channels 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
- */
-       u16 band_1_count;       /* abs.ofs: 196 */
-       struct il_eeprom_channel band_1_channels[14];   /* abs.ofs: 198 */
-
-/*
- * 4.9 GHz channels 183, 184, 185, 187, 188, 189, 192, 196,
- * 5.0 GHz channels 7, 8, 11, 12, 16
- * (4915-5080MHz) (none of these is ever supported)
- */
-       u16 band_2_count;       /* abs.ofs: 226 */
-       struct il_eeprom_channel band_2_channels[13];   /* abs.ofs: 228 */
-
-/*
- * 5.2 GHz channels 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
- * (5170-5320MHz)
- */
-       u16 band_3_count;       /* abs.ofs: 254 */
-       struct il_eeprom_channel band_3_channels[12];   /* abs.ofs: 256 */
-
-/*
- * 5.5 GHz channels 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
- * (5500-5700MHz)
- */
-       u16 band_4_count;       /* abs.ofs: 280 */
-       struct il_eeprom_channel band_4_channels[11];   /* abs.ofs: 282 */
-
-/*
- * 5.7 GHz channels 145, 149, 153, 157, 161, 165
- * (5725-5825MHz)
- */
-       u16 band_5_count;       /* abs.ofs: 304 */
-       struct il_eeprom_channel band_5_channels[6];    /* abs.ofs: 306 */
-
-       u8 reserved9[194];
-
-/*
- * 3945 Txpower calibration data.
- */
-#define IL_NUM_TX_CALIB_GROUPS 5
-       struct il3945_eeprom_txpower_group groups[IL_NUM_TX_CALIB_GROUPS];
-/* abs.ofs: 512 */
-       struct il3945_eeprom_temperature_corr corrections;      /* abs.ofs: 832 */
-       u8 reserved16[172];     /* fill out to full 1024 byte block */
-} __packed;
-
-#define IL3945_EEPROM_IMG_SIZE 1024
-
-/* End of EEPROM */
-
-#define PCI_CFG_REV_ID_BIT_BASIC_SKU                (0x40)     /* bit 6    */
-#define PCI_CFG_REV_ID_BIT_RTP                      (0x80)     /* bit 7    */
-
-/* 4 DATA + 1 CMD. There are 2 HCCA queues that are not used. */
-#define IL39_NUM_QUEUES        5
-#define IL39_CMD_QUEUE_NUM     4
-
-#define IL_DEFAULT_TX_RETRY  15
-
-/*********************************************/
-
-#define RFD_SIZE                              4
-#define NUM_TFD_CHUNKS                        4
-
-#define TFD_CTL_COUNT_SET(n)       (n << 24)
-#define TFD_CTL_COUNT_GET(ctl)     ((ctl >> 24) & 7)
-#define TFD_CTL_PAD_SET(n)         (n << 28)
-#define TFD_CTL_PAD_GET(ctl)       (ctl >> 28)
-
-/* Sizes and addresses for instruction and data memory (SRAM) in
- * 3945's embedded processor.  Driver access is via HBUS_TARG_MEM_* regs. */
-#define IL39_RTC_INST_LOWER_BOUND              (0x000000)
-#define IL39_RTC_INST_UPPER_BOUND              (0x014000)
-
-#define IL39_RTC_DATA_LOWER_BOUND              (0x800000)
-#define IL39_RTC_DATA_UPPER_BOUND              (0x808000)
-
-#define IL39_RTC_INST_SIZE (IL39_RTC_INST_UPPER_BOUND - \
-                               IL39_RTC_INST_LOWER_BOUND)
-#define IL39_RTC_DATA_SIZE (IL39_RTC_DATA_UPPER_BOUND - \
-                               IL39_RTC_DATA_LOWER_BOUND)
-
-#define IL39_MAX_INST_SIZE IL39_RTC_INST_SIZE
-#define IL39_MAX_DATA_SIZE IL39_RTC_DATA_SIZE
-
-/* Size of uCode instruction memory in bootstrap state machine */
-#define IL39_MAX_BSM_SIZE IL39_RTC_INST_SIZE
-
-static inline int
-il3945_hw_valid_rtc_data_addr(u32 addr)
-{
-       return (addr >= IL39_RTC_DATA_LOWER_BOUND &&
-               addr < IL39_RTC_DATA_UPPER_BOUND);
-}
-
-/* Base physical address of il3945_shared is provided to FH39_TSSR_CBB_BASE
- * and &il3945_shared.rx_read_ptr[0] is provided to FH39_RCSR_RPTR_ADDR(0) */
-struct il3945_shared {
-       __le32 tx_base_ptr[8];
-} __packed;
-
-/************************************/
-/* iwl3945 Flow Handler Definitions */
-/************************************/
-
-/**
- * This I/O area is directly read/writable by driver (e.g. Linux uses writel())
- * Addresses are offsets from device's PCI hardware base address.
- */
-#define FH39_MEM_LOWER_BOUND                   (0x0800)
-#define FH39_MEM_UPPER_BOUND                   (0x1000)
-
-#define FH39_CBCC_TBL          (FH39_MEM_LOWER_BOUND + 0x140)
-#define FH39_TFDB_TBL          (FH39_MEM_LOWER_BOUND + 0x180)
-#define FH39_RCSR_TBL          (FH39_MEM_LOWER_BOUND + 0x400)
-#define FH39_RSSR_TBL          (FH39_MEM_LOWER_BOUND + 0x4c0)
-#define FH39_TCSR_TBL          (FH39_MEM_LOWER_BOUND + 0x500)
-#define FH39_TSSR_TBL          (FH39_MEM_LOWER_BOUND + 0x680)
-
-/* TFDB (Transmit Frame Buffer Descriptor) */
-#define FH39_TFDB(_ch, buf)                    (FH39_TFDB_TBL + \
-                                                ((_ch) * 2 + (buf)) * 0x28)
-#define FH39_TFDB_CHNL_BUF_CTRL_REG(_ch)       (FH39_TFDB_TBL + 0x50 * (_ch))
-
-/* CBCC channel is [0,2] */
-#define FH39_CBCC(_ch)         (FH39_CBCC_TBL + (_ch) * 0x8)
-#define FH39_CBCC_CTRL(_ch)    (FH39_CBCC(_ch) + 0x00)
-#define FH39_CBCC_BASE(_ch)    (FH39_CBCC(_ch) + 0x04)
-
-/* RCSR channel is [0,2] */
-#define FH39_RCSR(_ch)                 (FH39_RCSR_TBL + (_ch) * 0x40)
-#define FH39_RCSR_CONFIG(_ch)          (FH39_RCSR(_ch) + 0x00)
-#define FH39_RCSR_RBD_BASE(_ch)                (FH39_RCSR(_ch) + 0x04)
-#define FH39_RCSR_WPTR(_ch)            (FH39_RCSR(_ch) + 0x20)
-#define FH39_RCSR_RPTR_ADDR(_ch)       (FH39_RCSR(_ch) + 0x24)
-
-#define FH39_RSCSR_CHNL0_WPTR          (FH39_RCSR_WPTR(0))
-
-/* RSSR */
-#define FH39_RSSR_CTRL                 (FH39_RSSR_TBL + 0x000)
-#define FH39_RSSR_STATUS               (FH39_RSSR_TBL + 0x004)
-
-/* TCSR */
-#define FH39_TCSR(_ch)                 (FH39_TCSR_TBL + (_ch) * 0x20)
-#define FH39_TCSR_CONFIG(_ch)          (FH39_TCSR(_ch) + 0x00)
-#define FH39_TCSR_CREDIT(_ch)          (FH39_TCSR(_ch) + 0x04)
-#define FH39_TCSR_BUFF_STTS(_ch)       (FH39_TCSR(_ch) + 0x08)
-
-/* TSSR */
-#define FH39_TSSR_CBB_BASE        (FH39_TSSR_TBL + 0x000)
-#define FH39_TSSR_MSG_CONFIG      (FH39_TSSR_TBL + 0x008)
-#define FH39_TSSR_TX_STATUS       (FH39_TSSR_TBL + 0x010)
-
-/* DBM */
-
-#define FH39_SRVC_CHNL                            (6)
-
-#define FH39_RCSR_RX_CONFIG_REG_POS_RBDC_SIZE     (20)
-#define FH39_RCSR_RX_CONFIG_REG_POS_IRQ_RBTH      (4)
-
-#define FH39_RCSR_RX_CONFIG_REG_BIT_WR_STTS_EN    (0x08000000)
-
-#define FH39_RCSR_RX_CONFIG_REG_VAL_DMA_CHNL_EN_ENABLE        (0x80000000)
-
-#define FH39_RCSR_RX_CONFIG_REG_VAL_RDRBD_EN_ENABLE           (0x20000000)
-
-#define FH39_RCSR_RX_CONFIG_REG_VAL_MAX_FRAG_SIZE_128          (0x01000000)
-
-#define FH39_RCSR_RX_CONFIG_REG_VAL_IRQ_DEST_INT_HOST          (0x00001000)
-
-#define FH39_RCSR_RX_CONFIG_REG_VAL_MSG_MODE_FH                        (0x00000000)
-
-#define FH39_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_TXF               (0x00000000)
-#define FH39_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_DRIVER            (0x00000001)
-
-#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_DISABLE_VAL     (0x00000000)
-#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL      (0x00000008)
-
-#define FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_IFTFD            (0x00200000)
-
-#define FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_NOINT             (0x00000000)
-
-#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_PAUSE             (0x00000000)
-#define FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE            (0x80000000)
-
-#define FH39_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_VALID           (0x00004000)
-
-#define FH39_TCSR_CHNL_TX_BUF_STS_REG_BIT_TFDB_WPTR            (0x00000001)
-
-#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TXPD_ON       (0xFF000000)
-#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_TXPD_ON       (0x00FF0000)
-
-#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_MAX_FRAG_SIZE_128B     (0x00000400)
-
-#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TFD_ON                (0x00000100)
-#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_CBB_ON                (0x00000080)
-
-#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RSP_WAIT_TH      (0x00000020)
-#define FH39_TSSR_TX_MSG_CONFIG_REG_VAL_RSP_WAIT_TH            (0x00000005)
-
-#define FH39_TSSR_TX_STATUS_REG_BIT_BUFS_EMPTY(_ch)    (BIT(_ch) << 24)
-#define FH39_TSSR_TX_STATUS_REG_BIT_NO_PEND_REQ(_ch)   (BIT(_ch) << 16)
-
-#define FH39_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(_ch) \
-       (FH39_TSSR_TX_STATUS_REG_BIT_BUFS_EMPTY(_ch) | \
-        FH39_TSSR_TX_STATUS_REG_BIT_NO_PEND_REQ(_ch))
-
-#define FH39_RSSR_CHNL0_RX_STATUS_CHNL_IDLE                    (0x01000000)
-
-struct il3945_tfd_tb {
-       __le32 addr;
-       __le32 len;
-} __packed;
-
-struct il3945_tfd {
-       __le32 control_flags;
-       struct il3945_tfd_tb tbs[4];
-       u8 __pad[28];
-} __packed;
-
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-extern const struct il_debugfs_ops il3945_debugfs_ops;
-#endif
-
-#endif
diff --git a/drivers/net/wireless/iwlegacy/4965-calib.c b/drivers/net/wireless/iwlegacy/4965-calib.c
deleted file mode 100644 (file)
index e78bdef..0000000
+++ /dev/null
@@ -1,934 +0,0 @@
-/******************************************************************************
- *
- * This file is provided under a dual BSD/GPLv2 license.  When using or
- * redistributing this file, you may do so under either license.
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- * BSD LICENSE
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *  * Neither the name Intel Corporation nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-#include <linux/slab.h>
-#include <net/mac80211.h>
-
-#include "common.h"
-#include "4965.h"
-
-/*****************************************************************************
- * INIT calibrations framework
- *****************************************************************************/
-
-struct stats_general_data {
-       u32 beacon_silence_rssi_a;
-       u32 beacon_silence_rssi_b;
-       u32 beacon_silence_rssi_c;
-       u32 beacon_energy_a;
-       u32 beacon_energy_b;
-       u32 beacon_energy_c;
-};
-
-/*****************************************************************************
- * RUNTIME calibrations framework
- *****************************************************************************/
-
-/* "false alarms" are signals that our DSP tries to lock onto,
- *   but then determines that they are either noise, or transmissions
- *   from a distant wireless network (also "noise", really) that get
- *   "stepped on" by stronger transmissions within our own network.
- * This algorithm attempts to set a sensitivity level that is high
- *   enough to receive all of our own network traffic, but not so
- *   high that our DSP gets too busy trying to lock onto non-network
- *   activity/noise. */
-static int
-il4965_sens_energy_cck(struct il_priv *il, u32 norm_fa, u32 rx_enable_time,
-                      struct stats_general_data *rx_info)
-{
-       u32 max_nrg_cck = 0;
-       int i = 0;
-       u8 max_silence_rssi = 0;
-       u32 silence_ref = 0;
-       u8 silence_rssi_a = 0;
-       u8 silence_rssi_b = 0;
-       u8 silence_rssi_c = 0;
-       u32 val;
-
-       /* "false_alarms" values below are cross-multiplications to assess the
-        *   numbers of false alarms within the measured period of actual Rx
-        *   (Rx is off when we're txing), vs the min/max expected false alarms
-        *   (some should be expected if rx is sensitive enough) in a
-        *   hypothetical listening period of 200 time units (TU), 204.8 msec:
-        *
-        * MIN_FA/fixed-time < false_alarms/actual-rx-time < MAX_FA/beacon-time
-        *
-        * */
-       u32 false_alarms = norm_fa * 200 * 1024;
-       u32 max_false_alarms = MAX_FA_CCK * rx_enable_time;
-       u32 min_false_alarms = MIN_FA_CCK * rx_enable_time;
-       struct il_sensitivity_data *data = NULL;
-       const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
-
-       data = &(il->sensitivity_data);
-
-       data->nrg_auto_corr_silence_diff = 0;
-
-       /* Find max silence rssi among all 3 receivers.
-        * This is background noise, which may include transmissions from other
-        *    networks, measured during silence before our network's beacon */
-       silence_rssi_a =
-           (u8) ((rx_info->beacon_silence_rssi_a & ALL_BAND_FILTER) >> 8);
-       silence_rssi_b =
-           (u8) ((rx_info->beacon_silence_rssi_b & ALL_BAND_FILTER) >> 8);
-       silence_rssi_c =
-           (u8) ((rx_info->beacon_silence_rssi_c & ALL_BAND_FILTER) >> 8);
-
-       val = max(silence_rssi_b, silence_rssi_c);
-       max_silence_rssi = max(silence_rssi_a, (u8) val);
-
-       /* Store silence rssi in 20-beacon history table */
-       data->nrg_silence_rssi[data->nrg_silence_idx] = max_silence_rssi;
-       data->nrg_silence_idx++;
-       if (data->nrg_silence_idx >= NRG_NUM_PREV_STAT_L)
-               data->nrg_silence_idx = 0;
-
-       /* Find max silence rssi across 20 beacon history */
-       for (i = 0; i < NRG_NUM_PREV_STAT_L; i++) {
-               val = data->nrg_silence_rssi[i];
-               silence_ref = max(silence_ref, val);
-       }
-       D_CALIB("silence a %u, b %u, c %u, 20-bcn max %u\n", silence_rssi_a,
-               silence_rssi_b, silence_rssi_c, silence_ref);
-
-       /* Find max rx energy (min value!) among all 3 receivers,
-        *   measured during beacon frame.
-        * Save it in 10-beacon history table. */
-       i = data->nrg_energy_idx;
-       val = min(rx_info->beacon_energy_b, rx_info->beacon_energy_c);
-       data->nrg_value[i] = min(rx_info->beacon_energy_a, val);
-
-       data->nrg_energy_idx++;
-       if (data->nrg_energy_idx >= 10)
-               data->nrg_energy_idx = 0;
-
-       /* Find min rx energy (max value) across 10 beacon history.
-        * This is the minimum signal level that we want to receive well.
-        * Add backoff (margin so we don't miss slightly lower energy frames).
-        * This establishes an upper bound (min value) for energy threshold. */
-       max_nrg_cck = data->nrg_value[0];
-       for (i = 1; i < 10; i++)
-               max_nrg_cck = (u32) max(max_nrg_cck, (data->nrg_value[i]));
-       max_nrg_cck += 6;
-
-       D_CALIB("rx energy a %u, b %u, c %u, 10-bcn max/min %u\n",
-               rx_info->beacon_energy_a, rx_info->beacon_energy_b,
-               rx_info->beacon_energy_c, max_nrg_cck - 6);
-
-       /* Count number of consecutive beacons with fewer-than-desired
-        *   false alarms. */
-       if (false_alarms < min_false_alarms)
-               data->num_in_cck_no_fa++;
-       else
-               data->num_in_cck_no_fa = 0;
-       D_CALIB("consecutive bcns with few false alarms = %u\n",
-               data->num_in_cck_no_fa);
-
-       /* If we got too many false alarms this time, reduce sensitivity */
-       if (false_alarms > max_false_alarms &&
-           data->auto_corr_cck > AUTO_CORR_MAX_TH_CCK) {
-               D_CALIB("norm FA %u > max FA %u\n", false_alarms,
-                       max_false_alarms);
-               D_CALIB("... reducing sensitivity\n");
-               data->nrg_curr_state = IL_FA_TOO_MANY;
-               /* Store for "fewer than desired" on later beacon */
-               data->nrg_silence_ref = silence_ref;
-
-               /* increase energy threshold (reduce nrg value)
-                *   to decrease sensitivity */
-               data->nrg_th_cck = data->nrg_th_cck - NRG_STEP_CCK;
-               /* Else if we got fewer than desired, increase sensitivity */
-       } else if (false_alarms < min_false_alarms) {
-               data->nrg_curr_state = IL_FA_TOO_FEW;
-
-               /* Compare silence level with silence level for most recent
-                *   healthy number or too many false alarms */
-               data->nrg_auto_corr_silence_diff =
-                   (s32) data->nrg_silence_ref - (s32) silence_ref;
-
-               D_CALIB("norm FA %u < min FA %u, silence diff %d\n",
-                       false_alarms, min_false_alarms,
-                       data->nrg_auto_corr_silence_diff);
-
-               /* Increase value to increase sensitivity, but only if:
-                * 1a) previous beacon did *not* have *too many* false alarms
-                * 1b) AND there's a significant difference in Rx levels
-                *      from a previous beacon with too many, or healthy # FAs
-                * OR 2) We've seen a lot of beacons (100) with too few
-                *       false alarms */
-               if (data->nrg_prev_state != IL_FA_TOO_MANY &&
-                   (data->nrg_auto_corr_silence_diff > NRG_DIFF ||
-                    data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA)) {
-
-                       D_CALIB("... increasing sensitivity\n");
-                       /* Increase nrg value to increase sensitivity */
-                       val = data->nrg_th_cck + NRG_STEP_CCK;
-                       data->nrg_th_cck = min((u32) ranges->min_nrg_cck, val);
-               } else {
-                       D_CALIB("... but not changing sensitivity\n");
-               }
-
-               /* Else we got a healthy number of false alarms, keep status quo */
-       } else {
-               D_CALIB(" FA in safe zone\n");
-               data->nrg_curr_state = IL_FA_GOOD_RANGE;
-
-               /* Store for use in "fewer than desired" with later beacon */
-               data->nrg_silence_ref = silence_ref;
-
-               /* If previous beacon had too many false alarms,
-                *   give it some extra margin by reducing sensitivity again
-                *   (but don't go below measured energy of desired Rx) */
-               if (IL_FA_TOO_MANY == data->nrg_prev_state) {
-                       D_CALIB("... increasing margin\n");
-                       if (data->nrg_th_cck > (max_nrg_cck + NRG_MARGIN))
-                               data->nrg_th_cck -= NRG_MARGIN;
-                       else
-                               data->nrg_th_cck = max_nrg_cck;
-               }
-       }
-
-       /* Make sure the energy threshold does not go above the measured
-        * energy of the desired Rx signals (reduced by backoff margin),
-        * or else we might start missing Rx frames.
-        * Lower value is higher energy, so we use max()!
-        */
-       data->nrg_th_cck = max(max_nrg_cck, data->nrg_th_cck);
-       D_CALIB("new nrg_th_cck %u\n", data->nrg_th_cck);
-
-       data->nrg_prev_state = data->nrg_curr_state;
-
-       /* Auto-correlation CCK algorithm */
-       if (false_alarms > min_false_alarms) {
-
-               /* increase auto_corr values to decrease sensitivity
-                * so the DSP won't be disturbed by the noise
-                */
-               if (data->auto_corr_cck < AUTO_CORR_MAX_TH_CCK)
-                       data->auto_corr_cck = AUTO_CORR_MAX_TH_CCK + 1;
-               else {
-                       val = data->auto_corr_cck + AUTO_CORR_STEP_CCK;
-                       data->auto_corr_cck =
-                           min((u32) ranges->auto_corr_max_cck, val);
-               }
-               val = data->auto_corr_cck_mrc + AUTO_CORR_STEP_CCK;
-               data->auto_corr_cck_mrc =
-                   min((u32) ranges->auto_corr_max_cck_mrc, val);
-       } else if (false_alarms < min_false_alarms &&
-                  (data->nrg_auto_corr_silence_diff > NRG_DIFF ||
-                   data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA)) {
-
-               /* Decrease auto_corr values to increase sensitivity */
-               val = data->auto_corr_cck - AUTO_CORR_STEP_CCK;
-               data->auto_corr_cck = max((u32) ranges->auto_corr_min_cck, val);
-               val = data->auto_corr_cck_mrc - AUTO_CORR_STEP_CCK;
-               data->auto_corr_cck_mrc =
-                   max((u32) ranges->auto_corr_min_cck_mrc, val);
-       }
-
-       return 0;
-}
-
-static int
-il4965_sens_auto_corr_ofdm(struct il_priv *il, u32 norm_fa, u32 rx_enable_time)
-{
-       u32 val;
-       u32 false_alarms = norm_fa * 200 * 1024;
-       u32 max_false_alarms = MAX_FA_OFDM * rx_enable_time;
-       u32 min_false_alarms = MIN_FA_OFDM * rx_enable_time;
-       struct il_sensitivity_data *data = NULL;
-       const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
-
-       data = &(il->sensitivity_data);
-
-       /* If we got too many false alarms this time, reduce sensitivity */
-       if (false_alarms > max_false_alarms) {
-
-               D_CALIB("norm FA %u > max FA %u)\n", false_alarms,
-                       max_false_alarms);
-
-               val = data->auto_corr_ofdm + AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm =
-                   min((u32) ranges->auto_corr_max_ofdm, val);
-
-               val = data->auto_corr_ofdm_mrc + AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm_mrc =
-                   min((u32) ranges->auto_corr_max_ofdm_mrc, val);
-
-               val = data->auto_corr_ofdm_x1 + AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm_x1 =
-                   min((u32) ranges->auto_corr_max_ofdm_x1, val);
-
-               val = data->auto_corr_ofdm_mrc_x1 + AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm_mrc_x1 =
-                   min((u32) ranges->auto_corr_max_ofdm_mrc_x1, val);
-       }
-
-       /* Else if we got fewer than desired, increase sensitivity */
-       else if (false_alarms < min_false_alarms) {
-
-               D_CALIB("norm FA %u < min FA %u\n", false_alarms,
-                       min_false_alarms);
-
-               val = data->auto_corr_ofdm - AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm =
-                   max((u32) ranges->auto_corr_min_ofdm, val);
-
-               val = data->auto_corr_ofdm_mrc - AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm_mrc =
-                   max((u32) ranges->auto_corr_min_ofdm_mrc, val);
-
-               val = data->auto_corr_ofdm_x1 - AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm_x1 =
-                   max((u32) ranges->auto_corr_min_ofdm_x1, val);
-
-               val = data->auto_corr_ofdm_mrc_x1 - AUTO_CORR_STEP_OFDM;
-               data->auto_corr_ofdm_mrc_x1 =
-                   max((u32) ranges->auto_corr_min_ofdm_mrc_x1, val);
-       } else {
-               D_CALIB("min FA %u < norm FA %u < max FA %u OK\n",
-                       min_false_alarms, false_alarms, max_false_alarms);
-       }
-       return 0;
-}
-
-static void
-il4965_prepare_legacy_sensitivity_tbl(struct il_priv *il,
-                                     struct il_sensitivity_data *data,
-                                     __le16 *tbl)
-{
-       tbl[HD_AUTO_CORR32_X4_TH_ADD_MIN_IDX] =
-           cpu_to_le16((u16) data->auto_corr_ofdm);
-       tbl[HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_IDX] =
-           cpu_to_le16((u16) data->auto_corr_ofdm_mrc);
-       tbl[HD_AUTO_CORR32_X1_TH_ADD_MIN_IDX] =
-           cpu_to_le16((u16) data->auto_corr_ofdm_x1);
-       tbl[HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_IDX] =
-           cpu_to_le16((u16) data->auto_corr_ofdm_mrc_x1);
-
-       tbl[HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX] =
-           cpu_to_le16((u16) data->auto_corr_cck);
-       tbl[HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX] =
-           cpu_to_le16((u16) data->auto_corr_cck_mrc);
-
-       tbl[HD_MIN_ENERGY_CCK_DET_IDX] = cpu_to_le16((u16) data->nrg_th_cck);
-       tbl[HD_MIN_ENERGY_OFDM_DET_IDX] = cpu_to_le16((u16) data->nrg_th_ofdm);
-
-       tbl[HD_BARKER_CORR_TH_ADD_MIN_IDX] =
-           cpu_to_le16(data->barker_corr_th_min);
-       tbl[HD_BARKER_CORR_TH_ADD_MIN_MRC_IDX] =
-           cpu_to_le16(data->barker_corr_th_min_mrc);
-       tbl[HD_OFDM_ENERGY_TH_IN_IDX] = cpu_to_le16(data->nrg_th_cca);
-
-       D_CALIB("ofdm: ac %u mrc %u x1 %u mrc_x1 %u thresh %u\n",
-               data->auto_corr_ofdm, data->auto_corr_ofdm_mrc,
-               data->auto_corr_ofdm_x1, data->auto_corr_ofdm_mrc_x1,
-               data->nrg_th_ofdm);
-
-       D_CALIB("cck: ac %u mrc %u thresh %u\n", data->auto_corr_cck,
-               data->auto_corr_cck_mrc, data->nrg_th_cck);
-}
-
-/* Prepare a C_SENSITIVITY, send to uCode if values have changed */
-static int
-il4965_sensitivity_write(struct il_priv *il)
-{
-       struct il_sensitivity_cmd cmd;
-       struct il_sensitivity_data *data = NULL;
-       struct il_host_cmd cmd_out = {
-               .id = C_SENSITIVITY,
-               .len = sizeof(struct il_sensitivity_cmd),
-               .flags = CMD_ASYNC,
-               .data = &cmd,
-       };
-
-       data = &(il->sensitivity_data);
-
-       memset(&cmd, 0, sizeof(cmd));
-
-       il4965_prepare_legacy_sensitivity_tbl(il, data, &cmd.table[0]);
-
-       /* Update uCode's "work" table, and copy it to DSP */
-       cmd.control = C_SENSITIVITY_CONTROL_WORK_TBL;
-
-       /* Don't send command to uCode if nothing has changed */
-       if (!memcmp
-           (&cmd.table[0], &(il->sensitivity_tbl[0]),
-            sizeof(u16) * HD_TBL_SIZE)) {
-               D_CALIB("No change in C_SENSITIVITY\n");
-               return 0;
-       }
-
-       /* Copy table for comparison next time */
-       memcpy(&(il->sensitivity_tbl[0]), &(cmd.table[0]),
-              sizeof(u16) * HD_TBL_SIZE);
-
-       return il_send_cmd(il, &cmd_out);
-}
-
-void
-il4965_init_sensitivity(struct il_priv *il)
-{
-       int ret = 0;
-       int i;
-       struct il_sensitivity_data *data = NULL;
-       const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
-
-       if (il->disable_sens_cal)
-               return;
-
-       D_CALIB("Start il4965_init_sensitivity\n");
-
-       /* Clear driver's sensitivity algo data */
-       data = &(il->sensitivity_data);
-
-       if (ranges == NULL)
-               return;
-
-       memset(data, 0, sizeof(struct il_sensitivity_data));
-
-       data->num_in_cck_no_fa = 0;
-       data->nrg_curr_state = IL_FA_TOO_MANY;
-       data->nrg_prev_state = IL_FA_TOO_MANY;
-       data->nrg_silence_ref = 0;
-       data->nrg_silence_idx = 0;
-       data->nrg_energy_idx = 0;
-
-       for (i = 0; i < 10; i++)
-               data->nrg_value[i] = 0;
-
-       for (i = 0; i < NRG_NUM_PREV_STAT_L; i++)
-               data->nrg_silence_rssi[i] = 0;
-
-       data->auto_corr_ofdm = ranges->auto_corr_min_ofdm;
-       data->auto_corr_ofdm_mrc = ranges->auto_corr_min_ofdm_mrc;
-       data->auto_corr_ofdm_x1 = ranges->auto_corr_min_ofdm_x1;
-       data->auto_corr_ofdm_mrc_x1 = ranges->auto_corr_min_ofdm_mrc_x1;
-       data->auto_corr_cck = AUTO_CORR_CCK_MIN_VAL_DEF;
-       data->auto_corr_cck_mrc = ranges->auto_corr_min_cck_mrc;
-       data->nrg_th_cck = ranges->nrg_th_cck;
-       data->nrg_th_ofdm = ranges->nrg_th_ofdm;
-       data->barker_corr_th_min = ranges->barker_corr_th_min;
-       data->barker_corr_th_min_mrc = ranges->barker_corr_th_min_mrc;
-       data->nrg_th_cca = ranges->nrg_th_cca;
-
-       data->last_bad_plcp_cnt_ofdm = 0;
-       data->last_fa_cnt_ofdm = 0;
-       data->last_bad_plcp_cnt_cck = 0;
-       data->last_fa_cnt_cck = 0;
-
-       ret |= il4965_sensitivity_write(il);
-       D_CALIB("<<return 0x%X\n", ret);
-}
-
-void
-il4965_sensitivity_calibration(struct il_priv *il, void *resp)
-{
-       u32 rx_enable_time;
-       u32 fa_cck;
-       u32 fa_ofdm;
-       u32 bad_plcp_cck;
-       u32 bad_plcp_ofdm;
-       u32 norm_fa_ofdm;
-       u32 norm_fa_cck;
-       struct il_sensitivity_data *data = NULL;
-       struct stats_rx_non_phy *rx_info;
-       struct stats_rx_phy *ofdm, *cck;
-       unsigned long flags;
-       struct stats_general_data statis;
-
-       if (il->disable_sens_cal)
-               return;
-
-       data = &(il->sensitivity_data);
-
-       if (!il_is_any_associated(il)) {
-               D_CALIB("<< - not associated\n");
-               return;
-       }
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       rx_info = &(((struct il_notif_stats *)resp)->rx.general);
-       ofdm = &(((struct il_notif_stats *)resp)->rx.ofdm);
-       cck = &(((struct il_notif_stats *)resp)->rx.cck);
-
-       if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
-               D_CALIB("<< invalid data.\n");
-               spin_unlock_irqrestore(&il->lock, flags);
-               return;
-       }
-
-       /* Extract Statistics: */
-       rx_enable_time = le32_to_cpu(rx_info->channel_load);
-       fa_cck = le32_to_cpu(cck->false_alarm_cnt);
-       fa_ofdm = le32_to_cpu(ofdm->false_alarm_cnt);
-       bad_plcp_cck = le32_to_cpu(cck->plcp_err);
-       bad_plcp_ofdm = le32_to_cpu(ofdm->plcp_err);
-
-       statis.beacon_silence_rssi_a =
-           le32_to_cpu(rx_info->beacon_silence_rssi_a);
-       statis.beacon_silence_rssi_b =
-           le32_to_cpu(rx_info->beacon_silence_rssi_b);
-       statis.beacon_silence_rssi_c =
-           le32_to_cpu(rx_info->beacon_silence_rssi_c);
-       statis.beacon_energy_a = le32_to_cpu(rx_info->beacon_energy_a);
-       statis.beacon_energy_b = le32_to_cpu(rx_info->beacon_energy_b);
-       statis.beacon_energy_c = le32_to_cpu(rx_info->beacon_energy_c);
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       D_CALIB("rx_enable_time = %u usecs\n", rx_enable_time);
-
-       if (!rx_enable_time) {
-               D_CALIB("<< RX Enable Time == 0!\n");
-               return;
-       }
-
-       /* These stats increase monotonically, and do not reset
-        *   at each beacon.  Calculate difference from last value, or just
-        *   use the new stats value if it has reset or wrapped around. */
-       if (data->last_bad_plcp_cnt_cck > bad_plcp_cck)
-               data->last_bad_plcp_cnt_cck = bad_plcp_cck;
-       else {
-               bad_plcp_cck -= data->last_bad_plcp_cnt_cck;
-               data->last_bad_plcp_cnt_cck += bad_plcp_cck;
-       }
-
-       if (data->last_bad_plcp_cnt_ofdm > bad_plcp_ofdm)
-               data->last_bad_plcp_cnt_ofdm = bad_plcp_ofdm;
-       else {
-               bad_plcp_ofdm -= data->last_bad_plcp_cnt_ofdm;
-               data->last_bad_plcp_cnt_ofdm += bad_plcp_ofdm;
-       }
-
-       if (data->last_fa_cnt_ofdm > fa_ofdm)
-               data->last_fa_cnt_ofdm = fa_ofdm;
-       else {
-               fa_ofdm -= data->last_fa_cnt_ofdm;
-               data->last_fa_cnt_ofdm += fa_ofdm;
-       }
-
-       if (data->last_fa_cnt_cck > fa_cck)
-               data->last_fa_cnt_cck = fa_cck;
-       else {
-               fa_cck -= data->last_fa_cnt_cck;
-               data->last_fa_cnt_cck += fa_cck;
-       }
-
-       /* Total aborted signal locks */
-       norm_fa_ofdm = fa_ofdm + bad_plcp_ofdm;
-       norm_fa_cck = fa_cck + bad_plcp_cck;
-
-       D_CALIB("cck: fa %u badp %u  ofdm: fa %u badp %u\n", fa_cck,
-               bad_plcp_cck, fa_ofdm, bad_plcp_ofdm);
-
-       il4965_sens_auto_corr_ofdm(il, norm_fa_ofdm, rx_enable_time);
-       il4965_sens_energy_cck(il, norm_fa_cck, rx_enable_time, &statis);
-
-       il4965_sensitivity_write(il);
-}
-
-static inline u8
-il4965_find_first_chain(u8 mask)
-{
-       if (mask & ANT_A)
-               return CHAIN_A;
-       if (mask & ANT_B)
-               return CHAIN_B;
-       return CHAIN_C;
-}
-
-/**
- * Run disconnected antenna algorithm to find out which antennas are
- * disconnected.
- */
-static void
-il4965_find_disconn_antenna(struct il_priv *il, u32 * average_sig,
-                           struct il_chain_noise_data *data)
-{
-       u32 active_chains = 0;
-       u32 max_average_sig;
-       u16 max_average_sig_antenna_i;
-       u8 num_tx_chains;
-       u8 first_chain;
-       u16 i = 0;
-
-       average_sig[0] =
-           data->chain_signal_a /
-           il->cfg->chain_noise_num_beacons;
-       average_sig[1] =
-           data->chain_signal_b /
-           il->cfg->chain_noise_num_beacons;
-       average_sig[2] =
-           data->chain_signal_c /
-           il->cfg->chain_noise_num_beacons;
-
-       if (average_sig[0] >= average_sig[1]) {
-               max_average_sig = average_sig[0];
-               max_average_sig_antenna_i = 0;
-               active_chains = (1 << max_average_sig_antenna_i);
-       } else {
-               max_average_sig = average_sig[1];
-               max_average_sig_antenna_i = 1;
-               active_chains = (1 << max_average_sig_antenna_i);
-       }
-
-       if (average_sig[2] >= max_average_sig) {
-               max_average_sig = average_sig[2];
-               max_average_sig_antenna_i = 2;
-               active_chains = (1 << max_average_sig_antenna_i);
-       }
-
-       D_CALIB("average_sig: a %d b %d c %d\n", average_sig[0], average_sig[1],
-               average_sig[2]);
-       D_CALIB("max_average_sig = %d, antenna %d\n", max_average_sig,
-               max_average_sig_antenna_i);
-
-       /* Compare signal strengths for all 3 receivers. */
-       for (i = 0; i < NUM_RX_CHAINS; i++) {
-               if (i != max_average_sig_antenna_i) {
-                       s32 rssi_delta = (max_average_sig - average_sig[i]);
-
-                       /* If signal is very weak, compared with
-                        * strongest, mark it as disconnected. */
-                       if (rssi_delta > MAXIMUM_ALLOWED_PATHLOSS)
-                               data->disconn_array[i] = 1;
-                       else
-                               active_chains |= (1 << i);
-                       D_CALIB("i = %d  rssiDelta = %d  "
-                               "disconn_array[i] = %d\n", i, rssi_delta,
-                               data->disconn_array[i]);
-               }
-       }
-
-       /*
-        * The above algorithm sometimes fails when the ucode
-        * reports 0 for all chains. It's not clear why that
-        * happens to start with, but it is then causing trouble
-        * because this can make us enable more chains than the
-        * hardware really has.
-        *
-        * To be safe, simply mask out any chains that we know
-        * are not on the device.
-        */
-       active_chains &= il->hw_params.valid_rx_ant;
-
-       num_tx_chains = 0;
-       for (i = 0; i < NUM_RX_CHAINS; i++) {
-               /* loops on all the bits of
-                * il->hw_setting.valid_tx_ant */
-               u8 ant_msk = (1 << i);
-               if (!(il->hw_params.valid_tx_ant & ant_msk))
-                       continue;
-
-               num_tx_chains++;
-               if (data->disconn_array[i] == 0)
-                       /* there is a Tx antenna connected */
-                       break;
-               if (num_tx_chains == il->hw_params.tx_chains_num &&
-                   data->disconn_array[i]) {
-                       /*
-                        * If all chains are disconnected
-                        * connect the first valid tx chain
-                        */
-                       first_chain =
-                           il4965_find_first_chain(il->cfg->valid_tx_ant);
-                       data->disconn_array[first_chain] = 0;
-                       active_chains |= BIT(first_chain);
-                       D_CALIB("All Tx chains are disconnected"
-                               "- declare %d as connected\n", first_chain);
-                       break;
-               }
-       }
-
-       if (active_chains != il->hw_params.valid_rx_ant &&
-           active_chains != il->chain_noise_data.active_chains)
-               D_CALIB("Detected that not all antennas are connected! "
-                       "Connected: %#x, valid: %#x.\n", active_chains,
-                       il->hw_params.valid_rx_ant);
-
-       /* Save for use within RXON, TX, SCAN commands, etc. */
-       data->active_chains = active_chains;
-       D_CALIB("active_chains (bitwise) = 0x%x\n", active_chains);
-}
-
-static void
-il4965_gain_computation(struct il_priv *il, u32 * average_noise,
-                       u16 min_average_noise_antenna_i, u32 min_average_noise,
-                       u8 default_chain)
-{
-       int i, ret;
-       struct il_chain_noise_data *data = &il->chain_noise_data;
-
-       data->delta_gain_code[min_average_noise_antenna_i] = 0;
-
-       for (i = default_chain; i < NUM_RX_CHAINS; i++) {
-               s32 delta_g = 0;
-
-               if (!data->disconn_array[i] &&
-                   data->delta_gain_code[i] ==
-                   CHAIN_NOISE_DELTA_GAIN_INIT_VAL) {
-                       delta_g = average_noise[i] - min_average_noise;
-                       data->delta_gain_code[i] = (u8) ((delta_g * 10) / 15);
-                       data->delta_gain_code[i] =
-                           min(data->delta_gain_code[i],
-                               (u8) CHAIN_NOISE_MAX_DELTA_GAIN_CODE);
-
-                       data->delta_gain_code[i] =
-                           (data->delta_gain_code[i] | (1 << 2));
-               } else {
-                       data->delta_gain_code[i] = 0;
-               }
-       }
-       D_CALIB("delta_gain_codes: a %d b %d c %d\n", data->delta_gain_code[0],
-               data->delta_gain_code[1], data->delta_gain_code[2]);
-
-       /* Differential gain gets sent to uCode only once */
-       if (!data->radio_write) {
-               struct il_calib_diff_gain_cmd cmd;
-               data->radio_write = 1;
-
-               memset(&cmd, 0, sizeof(cmd));
-               cmd.hdr.op_code = IL_PHY_CALIBRATE_DIFF_GAIN_CMD;
-               cmd.diff_gain_a = data->delta_gain_code[0];
-               cmd.diff_gain_b = data->delta_gain_code[1];
-               cmd.diff_gain_c = data->delta_gain_code[2];
-               ret = il_send_cmd_pdu(il, C_PHY_CALIBRATION, sizeof(cmd), &cmd);
-               if (ret)
-                       D_CALIB("fail sending cmd " "C_PHY_CALIBRATION\n");
-
-               /* TODO we might want recalculate
-                * rx_chain in rxon cmd */
-
-               /* Mark so we run this algo only once! */
-               data->state = IL_CHAIN_NOISE_CALIBRATED;
-       }
-}
-
-/*
- * Accumulate 16 beacons of signal and noise stats for each of
- *   3 receivers/antennas/rx-chains, then figure out:
- * 1)  Which antennas are connected.
- * 2)  Differential rx gain settings to balance the 3 receivers.
- */
-void
-il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
-{
-       struct il_chain_noise_data *data = NULL;
-
-       u32 chain_noise_a;
-       u32 chain_noise_b;
-       u32 chain_noise_c;
-       u32 chain_sig_a;
-       u32 chain_sig_b;
-       u32 chain_sig_c;
-       u32 average_sig[NUM_RX_CHAINS] = { INITIALIZATION_VALUE };
-       u32 average_noise[NUM_RX_CHAINS] = { INITIALIZATION_VALUE };
-       u32 min_average_noise = MIN_AVERAGE_NOISE_MAX_VALUE;
-       u16 min_average_noise_antenna_i = INITIALIZATION_VALUE;
-       u16 i = 0;
-       u16 rxon_chnum = INITIALIZATION_VALUE;
-       u16 stat_chnum = INITIALIZATION_VALUE;
-       u8 rxon_band24;
-       u8 stat_band24;
-       unsigned long flags;
-       struct stats_rx_non_phy *rx_info;
-
-       if (il->disable_chain_noise_cal)
-               return;
-
-       data = &(il->chain_noise_data);
-
-       /*
-        * Accumulate just the first "chain_noise_num_beacons" after
-        * the first association, then we're done forever.
-        */
-       if (data->state != IL_CHAIN_NOISE_ACCUMULATE) {
-               if (data->state == IL_CHAIN_NOISE_ALIVE)
-                       D_CALIB("Wait for noise calib reset\n");
-               return;
-       }
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       rx_info = &(((struct il_notif_stats *)stat_resp)->rx.general);
-
-       if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
-               D_CALIB(" << Interference data unavailable\n");
-               spin_unlock_irqrestore(&il->lock, flags);
-               return;
-       }
-
-       rxon_band24 = !!(il->staging.flags & RXON_FLG_BAND_24G_MSK);
-       rxon_chnum = le16_to_cpu(il->staging.channel);
-
-       stat_band24 =
-           !!(((struct il_notif_stats *)stat_resp)->
-              flag & STATS_REPLY_FLG_BAND_24G_MSK);
-       stat_chnum =
-           le32_to_cpu(((struct il_notif_stats *)stat_resp)->flag) >> 16;
-
-       /* Make sure we accumulate data for just the associated channel
-        *   (even if scanning). */
-       if (rxon_chnum != stat_chnum || rxon_band24 != stat_band24) {
-               D_CALIB("Stats not from chan=%d, band24=%d\n", rxon_chnum,
-                       rxon_band24);
-               spin_unlock_irqrestore(&il->lock, flags);
-               return;
-       }
-
-       /*
-        *  Accumulate beacon stats values across
-        * "chain_noise_num_beacons"
-        */
-       chain_noise_a =
-           le32_to_cpu(rx_info->beacon_silence_rssi_a) & IN_BAND_FILTER;
-       chain_noise_b =
-           le32_to_cpu(rx_info->beacon_silence_rssi_b) & IN_BAND_FILTER;
-       chain_noise_c =
-           le32_to_cpu(rx_info->beacon_silence_rssi_c) & IN_BAND_FILTER;
-
-       chain_sig_a = le32_to_cpu(rx_info->beacon_rssi_a) & IN_BAND_FILTER;
-       chain_sig_b = le32_to_cpu(rx_info->beacon_rssi_b) & IN_BAND_FILTER;
-       chain_sig_c = le32_to_cpu(rx_info->beacon_rssi_c) & IN_BAND_FILTER;
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       data->beacon_count++;
-
-       data->chain_noise_a = (chain_noise_a + data->chain_noise_a);
-       data->chain_noise_b = (chain_noise_b + data->chain_noise_b);
-       data->chain_noise_c = (chain_noise_c + data->chain_noise_c);
-
-       data->chain_signal_a = (chain_sig_a + data->chain_signal_a);
-       data->chain_signal_b = (chain_sig_b + data->chain_signal_b);
-       data->chain_signal_c = (chain_sig_c + data->chain_signal_c);
-
-       D_CALIB("chan=%d, band24=%d, beacon=%d\n", rxon_chnum, rxon_band24,
-               data->beacon_count);
-       D_CALIB("chain_sig: a %d b %d c %d\n", chain_sig_a, chain_sig_b,
-               chain_sig_c);
-       D_CALIB("chain_noise: a %d b %d c %d\n", chain_noise_a, chain_noise_b,
-               chain_noise_c);
-
-       /* If this is the "chain_noise_num_beacons", determine:
-        * 1)  Disconnected antennas (using signal strengths)
-        * 2)  Differential gain (using silence noise) to balance receivers */
-       if (data->beacon_count != il->cfg->chain_noise_num_beacons)
-               return;
-
-       /* Analyze signal for disconnected antenna */
-       il4965_find_disconn_antenna(il, average_sig, data);
-
-       /* Analyze noise for rx balance */
-       average_noise[0] =
-           data->chain_noise_a / il->cfg->chain_noise_num_beacons;
-       average_noise[1] =
-           data->chain_noise_b / il->cfg->chain_noise_num_beacons;
-       average_noise[2] =
-           data->chain_noise_c / il->cfg->chain_noise_num_beacons;
-
-       for (i = 0; i < NUM_RX_CHAINS; i++) {
-               if (!data->disconn_array[i] &&
-                   average_noise[i] <= min_average_noise) {
-                       /* This means that chain i is active and has
-                        * lower noise values so far: */
-                       min_average_noise = average_noise[i];
-                       min_average_noise_antenna_i = i;
-               }
-       }
-
-       D_CALIB("average_noise: a %d b %d c %d\n", average_noise[0],
-               average_noise[1], average_noise[2]);
-
-       D_CALIB("min_average_noise = %d, antenna %d\n", min_average_noise,
-               min_average_noise_antenna_i);
-
-       il4965_gain_computation(il, average_noise, min_average_noise_antenna_i,
-                               min_average_noise,
-                               il4965_find_first_chain(il->cfg->valid_rx_ant));
-
-       /* Some power changes may have been made during the calibration.
-        * Update and commit the RXON
-        */
-       if (il->ops->update_chain_flags)
-               il->ops->update_chain_flags(il);
-
-       data->state = IL_CHAIN_NOISE_DONE;
-       il_power_update_mode(il, false);
-}
-
-void
-il4965_reset_run_time_calib(struct il_priv *il)
-{
-       int i;
-       memset(&(il->sensitivity_data), 0, sizeof(struct il_sensitivity_data));
-       memset(&(il->chain_noise_data), 0, sizeof(struct il_chain_noise_data));
-       for (i = 0; i < NUM_RX_CHAINS; i++)
-               il->chain_noise_data.delta_gain_code[i] =
-                   CHAIN_NOISE_DELTA_GAIN_INIT_VAL;
-
-       /* Ask for stats now, the uCode will send notification
-        * periodically after association */
-       il_send_stats_request(il, CMD_ASYNC, true);
-}
diff --git a/drivers/net/wireless/iwlegacy/4965-debug.c b/drivers/net/wireless/iwlegacy/4965-debug.c
deleted file mode 100644 (file)
index e0597bf..0000000
+++ /dev/null
@@ -1,752 +0,0 @@
-/******************************************************************************
-*
-* GPL LICENSE SUMMARY
-*
-* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
-*
-* This program is free software; you can redistribute it and/or modify
-* it under the terms of version 2 of the GNU General Public License as
-* published by the Free Software Foundation.
-*
-* This program is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-* General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program; if not, write to the Free Software
-* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
-* USA
-*
-* The full GNU General Public License is included in this distribution
-* in the file called LICENSE.GPL.
-*
-* Contact Information:
-*  Intel Linux Wireless <ilw@linux.intel.com>
-* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
-*****************************************************************************/
-#include "common.h"
-#include "4965.h"
-
-static const char *fmt_value = "  %-30s %10u\n";
-static const char *fmt_table = "  %-30s %10u  %10u  %10u  %10u\n";
-static const char *fmt_header =
-    "%-32s    current  cumulative       delta         max\n";
-
-static int
-il4965_stats_flag(struct il_priv *il, char *buf, int bufsz)
-{
-       int p = 0;
-       u32 flag;
-
-       flag = le32_to_cpu(il->_4965.stats.flag);
-
-       p += scnprintf(buf + p, bufsz - p, "Statistics Flag(0x%X):\n", flag);
-       if (flag & UCODE_STATS_CLEAR_MSK)
-               p += scnprintf(buf + p, bufsz - p,
-                              "\tStatistics have been cleared\n");
-       p += scnprintf(buf + p, bufsz - p, "\tOperational Frequency: %s\n",
-                      (flag & UCODE_STATS_FREQUENCY_MSK) ? "2.4 GHz" :
-                      "5.2 GHz");
-       p += scnprintf(buf + p, bufsz - p, "\tTGj Narrow Band: %s\n",
-                      (flag & UCODE_STATS_NARROW_BAND_MSK) ? "enabled" :
-                      "disabled");
-
-       return p;
-}
-
-static ssize_t
-il4965_ucode_rx_stats_read(struct file *file, char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char *buf;
-       int bufsz =
-           sizeof(struct stats_rx_phy) * 40 +
-           sizeof(struct stats_rx_non_phy) * 40 +
-           sizeof(struct stats_rx_ht_phy) * 40 + 400;
-       ssize_t ret;
-       struct stats_rx_phy *ofdm, *accum_ofdm, *delta_ofdm, *max_ofdm;
-       struct stats_rx_phy *cck, *accum_cck, *delta_cck, *max_cck;
-       struct stats_rx_non_phy *general, *accum_general;
-       struct stats_rx_non_phy *delta_general, *max_general;
-       struct stats_rx_ht_phy *ht, *accum_ht, *delta_ht, *max_ht;
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       /*
-        * the statistic information display here is based on
-        * the last stats notification from uCode
-        * might not reflect the current uCode activity
-        */
-       ofdm = &il->_4965.stats.rx.ofdm;
-       cck = &il->_4965.stats.rx.cck;
-       general = &il->_4965.stats.rx.general;
-       ht = &il->_4965.stats.rx.ofdm_ht;
-       accum_ofdm = &il->_4965.accum_stats.rx.ofdm;
-       accum_cck = &il->_4965.accum_stats.rx.cck;
-       accum_general = &il->_4965.accum_stats.rx.general;
-       accum_ht = &il->_4965.accum_stats.rx.ofdm_ht;
-       delta_ofdm = &il->_4965.delta_stats.rx.ofdm;
-       delta_cck = &il->_4965.delta_stats.rx.cck;
-       delta_general = &il->_4965.delta_stats.rx.general;
-       delta_ht = &il->_4965.delta_stats.rx.ofdm_ht;
-       max_ofdm = &il->_4965.max_delta.rx.ofdm;
-       max_cck = &il->_4965.max_delta.rx.cck;
-       max_general = &il->_4965.max_delta.rx.general;
-       max_ht = &il->_4965.max_delta.rx.ofdm_ht;
-
-       pos += il4965_stats_flag(il, buf, bufsz);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_header,
-                     "Statistics_Rx - OFDM:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "ina_cnt:",
-                     le32_to_cpu(ofdm->ina_cnt), accum_ofdm->ina_cnt,
-                     delta_ofdm->ina_cnt, max_ofdm->ina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_cnt:",
-                     le32_to_cpu(ofdm->fina_cnt), accum_ofdm->fina_cnt,
-                     delta_ofdm->fina_cnt, max_ofdm->fina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "plcp_err:",
-                     le32_to_cpu(ofdm->plcp_err), accum_ofdm->plcp_err,
-                     delta_ofdm->plcp_err, max_ofdm->plcp_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_err:",
-                     le32_to_cpu(ofdm->crc32_err), accum_ofdm->crc32_err,
-                     delta_ofdm->crc32_err, max_ofdm->crc32_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "overrun_err:",
-                     le32_to_cpu(ofdm->overrun_err), accum_ofdm->overrun_err,
-                     delta_ofdm->overrun_err, max_ofdm->overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "early_overrun_err:",
-                     le32_to_cpu(ofdm->early_overrun_err),
-                     accum_ofdm->early_overrun_err,
-                     delta_ofdm->early_overrun_err,
-                     max_ofdm->early_overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_good:",
-                     le32_to_cpu(ofdm->crc32_good), accum_ofdm->crc32_good,
-                     delta_ofdm->crc32_good, max_ofdm->crc32_good);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "false_alarm_cnt:",
-                     le32_to_cpu(ofdm->false_alarm_cnt),
-                     accum_ofdm->false_alarm_cnt, delta_ofdm->false_alarm_cnt,
-                     max_ofdm->false_alarm_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_sync_err_cnt:",
-                     le32_to_cpu(ofdm->fina_sync_err_cnt),
-                     accum_ofdm->fina_sync_err_cnt,
-                     delta_ofdm->fina_sync_err_cnt,
-                     max_ofdm->fina_sync_err_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sfd_timeout:",
-                     le32_to_cpu(ofdm->sfd_timeout), accum_ofdm->sfd_timeout,
-                     delta_ofdm->sfd_timeout, max_ofdm->sfd_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_timeout:",
-                     le32_to_cpu(ofdm->fina_timeout), accum_ofdm->fina_timeout,
-                     delta_ofdm->fina_timeout, max_ofdm->fina_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "unresponded_rts:",
-                     le32_to_cpu(ofdm->unresponded_rts),
-                     accum_ofdm->unresponded_rts, delta_ofdm->unresponded_rts,
-                     max_ofdm->unresponded_rts);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "rxe_frame_lmt_ovrun:",
-                     le32_to_cpu(ofdm->rxe_frame_limit_overrun),
-                     accum_ofdm->rxe_frame_limit_overrun,
-                     delta_ofdm->rxe_frame_limit_overrun,
-                     max_ofdm->rxe_frame_limit_overrun);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ack_cnt:",
-                     le32_to_cpu(ofdm->sent_ack_cnt), accum_ofdm->sent_ack_cnt,
-                     delta_ofdm->sent_ack_cnt, max_ofdm->sent_ack_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_cts_cnt:",
-                     le32_to_cpu(ofdm->sent_cts_cnt), accum_ofdm->sent_cts_cnt,
-                     delta_ofdm->sent_cts_cnt, max_ofdm->sent_cts_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ba_rsp_cnt:",
-                     le32_to_cpu(ofdm->sent_ba_rsp_cnt),
-                     accum_ofdm->sent_ba_rsp_cnt, delta_ofdm->sent_ba_rsp_cnt,
-                     max_ofdm->sent_ba_rsp_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "dsp_self_kill:",
-                     le32_to_cpu(ofdm->dsp_self_kill),
-                     accum_ofdm->dsp_self_kill, delta_ofdm->dsp_self_kill,
-                     max_ofdm->dsp_self_kill);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "mh_format_err:",
-                     le32_to_cpu(ofdm->mh_format_err),
-                     accum_ofdm->mh_format_err, delta_ofdm->mh_format_err,
-                     max_ofdm->mh_format_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "re_acq_main_rssi_sum:",
-                     le32_to_cpu(ofdm->re_acq_main_rssi_sum),
-                     accum_ofdm->re_acq_main_rssi_sum,
-                     delta_ofdm->re_acq_main_rssi_sum,
-                     max_ofdm->re_acq_main_rssi_sum);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_header,
-                     "Statistics_Rx - CCK:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "ina_cnt:",
-                     le32_to_cpu(cck->ina_cnt), accum_cck->ina_cnt,
-                     delta_cck->ina_cnt, max_cck->ina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_cnt:",
-                     le32_to_cpu(cck->fina_cnt), accum_cck->fina_cnt,
-                     delta_cck->fina_cnt, max_cck->fina_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "plcp_err:",
-                     le32_to_cpu(cck->plcp_err), accum_cck->plcp_err,
-                     delta_cck->plcp_err, max_cck->plcp_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_err:",
-                     le32_to_cpu(cck->crc32_err), accum_cck->crc32_err,
-                     delta_cck->crc32_err, max_cck->crc32_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "overrun_err:",
-                     le32_to_cpu(cck->overrun_err), accum_cck->overrun_err,
-                     delta_cck->overrun_err, max_cck->overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "early_overrun_err:",
-                     le32_to_cpu(cck->early_overrun_err),
-                     accum_cck->early_overrun_err,
-                     delta_cck->early_overrun_err, max_cck->early_overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_good:",
-                     le32_to_cpu(cck->crc32_good), accum_cck->crc32_good,
-                     delta_cck->crc32_good, max_cck->crc32_good);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "false_alarm_cnt:",
-                     le32_to_cpu(cck->false_alarm_cnt),
-                     accum_cck->false_alarm_cnt, delta_cck->false_alarm_cnt,
-                     max_cck->false_alarm_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_sync_err_cnt:",
-                     le32_to_cpu(cck->fina_sync_err_cnt),
-                     accum_cck->fina_sync_err_cnt,
-                     delta_cck->fina_sync_err_cnt, max_cck->fina_sync_err_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sfd_timeout:",
-                     le32_to_cpu(cck->sfd_timeout), accum_cck->sfd_timeout,
-                     delta_cck->sfd_timeout, max_cck->sfd_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "fina_timeout:",
-                     le32_to_cpu(cck->fina_timeout), accum_cck->fina_timeout,
-                     delta_cck->fina_timeout, max_cck->fina_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "unresponded_rts:",
-                     le32_to_cpu(cck->unresponded_rts),
-                     accum_cck->unresponded_rts, delta_cck->unresponded_rts,
-                     max_cck->unresponded_rts);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "rxe_frame_lmt_ovrun:",
-                     le32_to_cpu(cck->rxe_frame_limit_overrun),
-                     accum_cck->rxe_frame_limit_overrun,
-                     delta_cck->rxe_frame_limit_overrun,
-                     max_cck->rxe_frame_limit_overrun);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ack_cnt:",
-                     le32_to_cpu(cck->sent_ack_cnt), accum_cck->sent_ack_cnt,
-                     delta_cck->sent_ack_cnt, max_cck->sent_ack_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_cts_cnt:",
-                     le32_to_cpu(cck->sent_cts_cnt), accum_cck->sent_cts_cnt,
-                     delta_cck->sent_cts_cnt, max_cck->sent_cts_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sent_ba_rsp_cnt:",
-                     le32_to_cpu(cck->sent_ba_rsp_cnt),
-                     accum_cck->sent_ba_rsp_cnt, delta_cck->sent_ba_rsp_cnt,
-                     max_cck->sent_ba_rsp_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "dsp_self_kill:",
-                     le32_to_cpu(cck->dsp_self_kill), accum_cck->dsp_self_kill,
-                     delta_cck->dsp_self_kill, max_cck->dsp_self_kill);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "mh_format_err:",
-                     le32_to_cpu(cck->mh_format_err), accum_cck->mh_format_err,
-                     delta_cck->mh_format_err, max_cck->mh_format_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "re_acq_main_rssi_sum:",
-                     le32_to_cpu(cck->re_acq_main_rssi_sum),
-                     accum_cck->re_acq_main_rssi_sum,
-                     delta_cck->re_acq_main_rssi_sum,
-                     max_cck->re_acq_main_rssi_sum);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_header,
-                     "Statistics_Rx - GENERAL:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "bogus_cts:",
-                     le32_to_cpu(general->bogus_cts), accum_general->bogus_cts,
-                     delta_general->bogus_cts, max_general->bogus_cts);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "bogus_ack:",
-                     le32_to_cpu(general->bogus_ack), accum_general->bogus_ack,
-                     delta_general->bogus_ack, max_general->bogus_ack);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "non_bssid_frames:",
-                     le32_to_cpu(general->non_bssid_frames),
-                     accum_general->non_bssid_frames,
-                     delta_general->non_bssid_frames,
-                     max_general->non_bssid_frames);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "filtered_frames:",
-                     le32_to_cpu(general->filtered_frames),
-                     accum_general->filtered_frames,
-                     delta_general->filtered_frames,
-                     max_general->filtered_frames);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "non_channel_beacons:",
-                     le32_to_cpu(general->non_channel_beacons),
-                     accum_general->non_channel_beacons,
-                     delta_general->non_channel_beacons,
-                     max_general->non_channel_beacons);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "channel_beacons:",
-                     le32_to_cpu(general->channel_beacons),
-                     accum_general->channel_beacons,
-                     delta_general->channel_beacons,
-                     max_general->channel_beacons);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "num_missed_bcon:",
-                     le32_to_cpu(general->num_missed_bcon),
-                     accum_general->num_missed_bcon,
-                     delta_general->num_missed_bcon,
-                     max_general->num_missed_bcon);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "adc_rx_saturation_time:",
-                     le32_to_cpu(general->adc_rx_saturation_time),
-                     accum_general->adc_rx_saturation_time,
-                     delta_general->adc_rx_saturation_time,
-                     max_general->adc_rx_saturation_time);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "ina_detect_search_tm:",
-                     le32_to_cpu(general->ina_detection_search_time),
-                     accum_general->ina_detection_search_time,
-                     delta_general->ina_detection_search_time,
-                     max_general->ina_detection_search_time);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "beacon_silence_rssi_a:",
-                     le32_to_cpu(general->beacon_silence_rssi_a),
-                     accum_general->beacon_silence_rssi_a,
-                     delta_general->beacon_silence_rssi_a,
-                     max_general->beacon_silence_rssi_a);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "beacon_silence_rssi_b:",
-                     le32_to_cpu(general->beacon_silence_rssi_b),
-                     accum_general->beacon_silence_rssi_b,
-                     delta_general->beacon_silence_rssi_b,
-                     max_general->beacon_silence_rssi_b);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "beacon_silence_rssi_c:",
-                     le32_to_cpu(general->beacon_silence_rssi_c),
-                     accum_general->beacon_silence_rssi_c,
-                     delta_general->beacon_silence_rssi_c,
-                     max_general->beacon_silence_rssi_c);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "interference_data_flag:",
-                     le32_to_cpu(general->interference_data_flag),
-                     accum_general->interference_data_flag,
-                     delta_general->interference_data_flag,
-                     max_general->interference_data_flag);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "channel_load:",
-                     le32_to_cpu(general->channel_load),
-                     accum_general->channel_load, delta_general->channel_load,
-                     max_general->channel_load);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "dsp_false_alarms:",
-                     le32_to_cpu(general->dsp_false_alarms),
-                     accum_general->dsp_false_alarms,
-                     delta_general->dsp_false_alarms,
-                     max_general->dsp_false_alarms);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_rssi_a:",
-                     le32_to_cpu(general->beacon_rssi_a),
-                     accum_general->beacon_rssi_a,
-                     delta_general->beacon_rssi_a, max_general->beacon_rssi_a);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_rssi_b:",
-                     le32_to_cpu(general->beacon_rssi_b),
-                     accum_general->beacon_rssi_b,
-                     delta_general->beacon_rssi_b, max_general->beacon_rssi_b);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_rssi_c:",
-                     le32_to_cpu(general->beacon_rssi_c),
-                     accum_general->beacon_rssi_c,
-                     delta_general->beacon_rssi_c, max_general->beacon_rssi_c);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_energy_a:",
-                     le32_to_cpu(general->beacon_energy_a),
-                     accum_general->beacon_energy_a,
-                     delta_general->beacon_energy_a,
-                     max_general->beacon_energy_a);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_energy_b:",
-                     le32_to_cpu(general->beacon_energy_b),
-                     accum_general->beacon_energy_b,
-                     delta_general->beacon_energy_b,
-                     max_general->beacon_energy_b);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "beacon_energy_c:",
-                     le32_to_cpu(general->beacon_energy_c),
-                     accum_general->beacon_energy_c,
-                     delta_general->beacon_energy_c,
-                     max_general->beacon_energy_c);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_header,
-                     "Statistics_Rx - OFDM_HT:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "plcp_err:",
-                     le32_to_cpu(ht->plcp_err), accum_ht->plcp_err,
-                     delta_ht->plcp_err, max_ht->plcp_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "overrun_err:",
-                     le32_to_cpu(ht->overrun_err), accum_ht->overrun_err,
-                     delta_ht->overrun_err, max_ht->overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "early_overrun_err:",
-                     le32_to_cpu(ht->early_overrun_err),
-                     accum_ht->early_overrun_err, delta_ht->early_overrun_err,
-                     max_ht->early_overrun_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_good:",
-                     le32_to_cpu(ht->crc32_good), accum_ht->crc32_good,
-                     delta_ht->crc32_good, max_ht->crc32_good);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "crc32_err:",
-                     le32_to_cpu(ht->crc32_err), accum_ht->crc32_err,
-                     delta_ht->crc32_err, max_ht->crc32_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "mh_format_err:",
-                     le32_to_cpu(ht->mh_format_err), accum_ht->mh_format_err,
-                     delta_ht->mh_format_err, max_ht->mh_format_err);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg_crc32_good:",
-                     le32_to_cpu(ht->agg_crc32_good), accum_ht->agg_crc32_good,
-                     delta_ht->agg_crc32_good, max_ht->agg_crc32_good);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg_mpdu_cnt:",
-                     le32_to_cpu(ht->agg_mpdu_cnt), accum_ht->agg_mpdu_cnt,
-                     delta_ht->agg_mpdu_cnt, max_ht->agg_mpdu_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg_cnt:",
-                     le32_to_cpu(ht->agg_cnt), accum_ht->agg_cnt,
-                     delta_ht->agg_cnt, max_ht->agg_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "unsupport_mcs:",
-                     le32_to_cpu(ht->unsupport_mcs), accum_ht->unsupport_mcs,
-                     delta_ht->unsupport_mcs, max_ht->unsupport_mcs);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il4965_ucode_tx_stats_read(struct file *file, char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char *buf;
-       int bufsz = (sizeof(struct stats_tx) * 48) + 250;
-       ssize_t ret;
-       struct stats_tx *tx, *accum_tx, *delta_tx, *max_tx;
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       /* the statistic information display here is based on
-        * the last stats notification from uCode
-        * might not reflect the current uCode activity
-        */
-       tx = &il->_4965.stats.tx;
-       accum_tx = &il->_4965.accum_stats.tx;
-       delta_tx = &il->_4965.delta_stats.tx;
-       max_tx = &il->_4965.max_delta.tx;
-
-       pos += il4965_stats_flag(il, buf, bufsz);
-       pos += scnprintf(buf + pos, bufsz - pos, fmt_header, "Statistics_Tx:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "preamble:",
-                     le32_to_cpu(tx->preamble_cnt), accum_tx->preamble_cnt,
-                     delta_tx->preamble_cnt, max_tx->preamble_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "rx_detected_cnt:",
-                     le32_to_cpu(tx->rx_detected_cnt),
-                     accum_tx->rx_detected_cnt, delta_tx->rx_detected_cnt,
-                     max_tx->rx_detected_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "bt_prio_defer_cnt:",
-                     le32_to_cpu(tx->bt_prio_defer_cnt),
-                     accum_tx->bt_prio_defer_cnt, delta_tx->bt_prio_defer_cnt,
-                     max_tx->bt_prio_defer_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "bt_prio_kill_cnt:",
-                     le32_to_cpu(tx->bt_prio_kill_cnt),
-                     accum_tx->bt_prio_kill_cnt, delta_tx->bt_prio_kill_cnt,
-                     max_tx->bt_prio_kill_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "few_bytes_cnt:",
-                     le32_to_cpu(tx->few_bytes_cnt), accum_tx->few_bytes_cnt,
-                     delta_tx->few_bytes_cnt, max_tx->few_bytes_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "cts_timeout:",
-                     le32_to_cpu(tx->cts_timeout), accum_tx->cts_timeout,
-                     delta_tx->cts_timeout, max_tx->cts_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "ack_timeout:",
-                     le32_to_cpu(tx->ack_timeout), accum_tx->ack_timeout,
-                     delta_tx->ack_timeout, max_tx->ack_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "expected_ack_cnt:",
-                     le32_to_cpu(tx->expected_ack_cnt),
-                     accum_tx->expected_ack_cnt, delta_tx->expected_ack_cnt,
-                     max_tx->expected_ack_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "actual_ack_cnt:",
-                     le32_to_cpu(tx->actual_ack_cnt), accum_tx->actual_ack_cnt,
-                     delta_tx->actual_ack_cnt, max_tx->actual_ack_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "dump_msdu_cnt:",
-                     le32_to_cpu(tx->dump_msdu_cnt), accum_tx->dump_msdu_cnt,
-                     delta_tx->dump_msdu_cnt, max_tx->dump_msdu_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "abort_nxt_frame_mismatch:",
-                     le32_to_cpu(tx->burst_abort_next_frame_mismatch_cnt),
-                     accum_tx->burst_abort_next_frame_mismatch_cnt,
-                     delta_tx->burst_abort_next_frame_mismatch_cnt,
-                     max_tx->burst_abort_next_frame_mismatch_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "abort_missing_nxt_frame:",
-                     le32_to_cpu(tx->burst_abort_missing_next_frame_cnt),
-                     accum_tx->burst_abort_missing_next_frame_cnt,
-                     delta_tx->burst_abort_missing_next_frame_cnt,
-                     max_tx->burst_abort_missing_next_frame_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "cts_timeout_collision:",
-                     le32_to_cpu(tx->cts_timeout_collision),
-                     accum_tx->cts_timeout_collision,
-                     delta_tx->cts_timeout_collision,
-                     max_tx->cts_timeout_collision);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "ack_ba_timeout_collision:",
-                     le32_to_cpu(tx->ack_or_ba_timeout_collision),
-                     accum_tx->ack_or_ba_timeout_collision,
-                     delta_tx->ack_or_ba_timeout_collision,
-                     max_tx->ack_or_ba_timeout_collision);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg ba_timeout:",
-                     le32_to_cpu(tx->agg.ba_timeout), accum_tx->agg.ba_timeout,
-                     delta_tx->agg.ba_timeout, max_tx->agg.ba_timeout);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "agg ba_resched_frames:",
-                     le32_to_cpu(tx->agg.ba_reschedule_frames),
-                     accum_tx->agg.ba_reschedule_frames,
-                     delta_tx->agg.ba_reschedule_frames,
-                     max_tx->agg.ba_reschedule_frames);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "agg scd_query_agg_frame:",
-                     le32_to_cpu(tx->agg.scd_query_agg_frame_cnt),
-                     accum_tx->agg.scd_query_agg_frame_cnt,
-                     delta_tx->agg.scd_query_agg_frame_cnt,
-                     max_tx->agg.scd_query_agg_frame_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "agg scd_query_no_agg:",
-                     le32_to_cpu(tx->agg.scd_query_no_agg),
-                     accum_tx->agg.scd_query_no_agg,
-                     delta_tx->agg.scd_query_no_agg,
-                     max_tx->agg.scd_query_no_agg);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg scd_query_agg:",
-                     le32_to_cpu(tx->agg.scd_query_agg),
-                     accum_tx->agg.scd_query_agg, delta_tx->agg.scd_query_agg,
-                     max_tx->agg.scd_query_agg);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "agg scd_query_mismatch:",
-                     le32_to_cpu(tx->agg.scd_query_mismatch),
-                     accum_tx->agg.scd_query_mismatch,
-                     delta_tx->agg.scd_query_mismatch,
-                     max_tx->agg.scd_query_mismatch);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg frame_not_ready:",
-                     le32_to_cpu(tx->agg.frame_not_ready),
-                     accum_tx->agg.frame_not_ready,
-                     delta_tx->agg.frame_not_ready,
-                     max_tx->agg.frame_not_ready);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg underrun:",
-                     le32_to_cpu(tx->agg.underrun), accum_tx->agg.underrun,
-                     delta_tx->agg.underrun, max_tx->agg.underrun);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg bt_prio_kill:",
-                     le32_to_cpu(tx->agg.bt_prio_kill),
-                     accum_tx->agg.bt_prio_kill, delta_tx->agg.bt_prio_kill,
-                     max_tx->agg.bt_prio_kill);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "agg rx_ba_rsp_cnt:",
-                     le32_to_cpu(tx->agg.rx_ba_rsp_cnt),
-                     accum_tx->agg.rx_ba_rsp_cnt, delta_tx->agg.rx_ba_rsp_cnt,
-                     max_tx->agg.rx_ba_rsp_cnt);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il4965_ucode_general_stats_read(struct file *file, char __user *user_buf,
-                               size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char *buf;
-       int bufsz = sizeof(struct stats_general) * 10 + 300;
-       ssize_t ret;
-       struct stats_general_common *general, *accum_general;
-       struct stats_general_common *delta_general, *max_general;
-       struct stats_dbg *dbg, *accum_dbg, *delta_dbg, *max_dbg;
-       struct stats_div *div, *accum_div, *delta_div, *max_div;
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       /* the statistic information display here is based on
-        * the last stats notification from uCode
-        * might not reflect the current uCode activity
-        */
-       general = &il->_4965.stats.general.common;
-       dbg = &il->_4965.stats.general.common.dbg;
-       div = &il->_4965.stats.general.common.div;
-       accum_general = &il->_4965.accum_stats.general.common;
-       accum_dbg = &il->_4965.accum_stats.general.common.dbg;
-       accum_div = &il->_4965.accum_stats.general.common.div;
-       delta_general = &il->_4965.delta_stats.general.common;
-       max_general = &il->_4965.max_delta.general.common;
-       delta_dbg = &il->_4965.delta_stats.general.common.dbg;
-       max_dbg = &il->_4965.max_delta.general.common.dbg;
-       delta_div = &il->_4965.delta_stats.general.common.div;
-       max_div = &il->_4965.max_delta.general.common.div;
-
-       pos += il4965_stats_flag(il, buf, bufsz);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_header,
-                     "Statistics_General:");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_value, "temperature:",
-                     le32_to_cpu(general->temperature));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_value, "ttl_timestamp:",
-                     le32_to_cpu(general->ttl_timestamp));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "burst_check:",
-                     le32_to_cpu(dbg->burst_check), accum_dbg->burst_check,
-                     delta_dbg->burst_check, max_dbg->burst_check);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "burst_count:",
-                     le32_to_cpu(dbg->burst_count), accum_dbg->burst_count,
-                     delta_dbg->burst_count, max_dbg->burst_count);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table,
-                     "wait_for_silence_timeout_count:",
-                     le32_to_cpu(dbg->wait_for_silence_timeout_cnt),
-                     accum_dbg->wait_for_silence_timeout_cnt,
-                     delta_dbg->wait_for_silence_timeout_cnt,
-                     max_dbg->wait_for_silence_timeout_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "sleep_time:",
-                     le32_to_cpu(general->sleep_time),
-                     accum_general->sleep_time, delta_general->sleep_time,
-                     max_general->sleep_time);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "slots_out:",
-                     le32_to_cpu(general->slots_out), accum_general->slots_out,
-                     delta_general->slots_out, max_general->slots_out);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "slots_idle:",
-                     le32_to_cpu(general->slots_idle),
-                     accum_general->slots_idle, delta_general->slots_idle,
-                     max_general->slots_idle);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "tx_on_a:",
-                     le32_to_cpu(div->tx_on_a), accum_div->tx_on_a,
-                     delta_div->tx_on_a, max_div->tx_on_a);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "tx_on_b:",
-                     le32_to_cpu(div->tx_on_b), accum_div->tx_on_b,
-                     delta_div->tx_on_b, max_div->tx_on_b);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "exec_time:",
-                     le32_to_cpu(div->exec_time), accum_div->exec_time,
-                     delta_div->exec_time, max_div->exec_time);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "probe_time:",
-                     le32_to_cpu(div->probe_time), accum_div->probe_time,
-                     delta_div->probe_time, max_div->probe_time);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "rx_enable_counter:",
-                     le32_to_cpu(general->rx_enable_counter),
-                     accum_general->rx_enable_counter,
-                     delta_general->rx_enable_counter,
-                     max_general->rx_enable_counter);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, fmt_table, "num_of_sos_states:",
-                     le32_to_cpu(general->num_of_sos_states),
-                     accum_general->num_of_sos_states,
-                     delta_general->num_of_sos_states,
-                     max_general->num_of_sos_states);
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-const struct il_debugfs_ops il4965_debugfs_ops = {
-       .rx_stats_read = il4965_ucode_rx_stats_read,
-       .tx_stats_read = il4965_ucode_tx_stats_read,
-       .general_stats_read = il4965_ucode_general_stats_read,
-};
diff --git a/drivers/net/wireless/iwlegacy/4965-mac.c b/drivers/net/wireless/iwlegacy/4965-mac.c
deleted file mode 100644 (file)
index 6656215..0000000
+++ /dev/null
@@ -1,6868 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * Portions of this file are derived from the ipw3945 project, as well
- * as portions of the ieee80211 subsystem header files.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/pci.h>
-#include <linux/pci-aspm.h>
-#include <linux/slab.h>
-#include <linux/dma-mapping.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/skbuff.h>
-#include <linux/netdevice.h>
-#include <linux/firmware.h>
-#include <linux/etherdevice.h>
-#include <linux/if_arp.h>
-
-#include <net/mac80211.h>
-
-#include <asm/div64.h>
-
-#define DRV_NAME        "iwl4965"
-
-#include "common.h"
-#include "4965.h"
-
-/******************************************************************************
- *
- * module boiler plate
- *
- ******************************************************************************/
-
-/*
- * module name, copyright, version, etc.
- */
-#define DRV_DESCRIPTION        "Intel(R) Wireless WiFi 4965 driver for Linux"
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-#define VD "d"
-#else
-#define VD
-#endif
-
-#define DRV_VERSION     IWLWIFI_VERSION VD
-
-MODULE_DESCRIPTION(DRV_DESCRIPTION);
-MODULE_VERSION(DRV_VERSION);
-MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("iwl4965");
-
-void
-il4965_check_abort_status(struct il_priv *il, u8 frame_count, u32 status)
-{
-       if (frame_count == 1 && status == TX_STATUS_FAIL_RFKILL_FLUSH) {
-               IL_ERR("Tx flush command to flush out all frames\n");
-               if (!test_bit(S_EXIT_PENDING, &il->status))
-                       queue_work(il->workqueue, &il->tx_flush);
-       }
-}
-
-/*
- * EEPROM
- */
-struct il_mod_params il4965_mod_params = {
-       .restart_fw = 1,
-       /* the rest are 0 by default */
-};
-
-void
-il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
-{
-       unsigned long flags;
-       int i;
-       spin_lock_irqsave(&rxq->lock, flags);
-       INIT_LIST_HEAD(&rxq->rx_free);
-       INIT_LIST_HEAD(&rxq->rx_used);
-       /* Fill the rx_used queue with _all_ of the Rx buffers */
-       for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
-               /* In the reset function, these buffers may have been allocated
-                * to an SKB, so we need to unmap and free potential storage */
-               if (rxq->pool[i].page != NULL) {
-                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
-                                      PAGE_SIZE << il->hw_params.rx_page_order,
-                                      PCI_DMA_FROMDEVICE);
-                       __il_free_pages(il, rxq->pool[i].page);
-                       rxq->pool[i].page = NULL;
-               }
-               list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
-       }
-
-       for (i = 0; i < RX_QUEUE_SIZE; i++)
-               rxq->queue[i] = NULL;
-
-       /* Set us so that we have processed and used all buffers, but have
-        * not restocked the Rx queue with fresh buffers */
-       rxq->read = rxq->write = 0;
-       rxq->write_actual = 0;
-       rxq->free_count = 0;
-       spin_unlock_irqrestore(&rxq->lock, flags);
-}
-
-int
-il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
-{
-       u32 rb_size;
-       const u32 rfdnlog = RX_QUEUE_SIZE_LOG;  /* 256 RBDs */
-       u32 rb_timeout = 0;
-
-       if (il->cfg->mod_params->amsdu_size_8K)
-               rb_size = FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_8K;
-       else
-               rb_size = FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_4K;
-
-       /* Stop Rx DMA */
-       il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG, 0);
-
-       /* Reset driver's Rx queue write idx */
-       il_wr(il, FH49_RSCSR_CHNL0_RBDCB_WPTR_REG, 0);
-
-       /* Tell device where to find RBD circular buffer in DRAM */
-       il_wr(il, FH49_RSCSR_CHNL0_RBDCB_BASE_REG, (u32) (rxq->bd_dma >> 8));
-
-       /* Tell device where in DRAM to update its Rx status */
-       il_wr(il, FH49_RSCSR_CHNL0_STTS_WPTR_REG, rxq->rb_stts_dma >> 4);
-
-       /* Enable Rx DMA
-        * Direct rx interrupts to hosts
-        * Rx buffer size 4 or 8k
-        * RB timeout 0x10
-        * 256 RBDs
-        */
-       il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG,
-             FH49_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL |
-             FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL |
-             FH49_RCSR_CHNL0_RX_CONFIG_SINGLE_FRAME_MSK |
-             rb_size |
-             (rb_timeout << FH49_RCSR_RX_CONFIG_REG_IRQ_RBTH_POS) |
-             (rfdnlog << FH49_RCSR_RX_CONFIG_RBDCB_SIZE_POS));
-
-       /* Set interrupt coalescing timer to default (2048 usecs) */
-       il_write8(il, CSR_INT_COALESCING, IL_HOST_INT_TIMEOUT_DEF);
-
-       return 0;
-}
-
-static void
-il4965_set_pwr_vmain(struct il_priv *il)
-{
-/*
- * (for documentation purposes)
- * to set power to V_AUX, do:
-
-               if (pci_pme_capable(il->pci_dev, PCI_D3cold))
-                       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
-                                              APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
-                                              ~APMG_PS_CTRL_MSK_PWR_SRC);
- */
-
-       il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
-                             APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
-                             ~APMG_PS_CTRL_MSK_PWR_SRC);
-}
-
-int
-il4965_hw_nic_init(struct il_priv *il)
-{
-       unsigned long flags;
-       struct il_rx_queue *rxq = &il->rxq;
-       int ret;
-
-       spin_lock_irqsave(&il->lock, flags);
-       il_apm_init(il);
-       /* Set interrupt coalescing calibration timer to default (512 usecs) */
-       il_write8(il, CSR_INT_COALESCING, IL_HOST_INT_CALIB_TIMEOUT_DEF);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       il4965_set_pwr_vmain(il);
-       il4965_nic_config(il);
-
-       /* Allocate the RX queue, or reset if it is already allocated */
-       if (!rxq->bd) {
-               ret = il_rx_queue_alloc(il);
-               if (ret) {
-                       IL_ERR("Unable to initialize Rx queue\n");
-                       return -ENOMEM;
-               }
-       } else
-               il4965_rx_queue_reset(il, rxq);
-
-       il4965_rx_replenish(il);
-
-       il4965_rx_init(il, rxq);
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       rxq->need_update = 1;
-       il_rx_queue_update_write_ptr(il, rxq);
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       /* Allocate or reset and init all Tx and Command queues */
-       if (!il->txq) {
-               ret = il4965_txq_ctx_alloc(il);
-               if (ret)
-                       return ret;
-       } else
-               il4965_txq_ctx_reset(il);
-
-       set_bit(S_INIT, &il->status);
-
-       return 0;
-}
-
-/**
- * il4965_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
- */
-static inline __le32
-il4965_dma_addr2rbd_ptr(struct il_priv *il, dma_addr_t dma_addr)
-{
-       return cpu_to_le32((u32) (dma_addr >> 8));
-}
-
-/**
- * il4965_rx_queue_restock - refill RX queue from pre-allocated pool
- *
- * If there are slots in the RX queue that need to be restocked,
- * and we have free pre-allocated buffers, fill the ranks as much
- * as we can, pulling from rx_free.
- *
- * This moves the 'write' idx forward to catch up with 'processed', and
- * also updates the memory address in the firmware to reference the new
- * target buffer.
- */
-void
-il4965_rx_queue_restock(struct il_priv *il)
-{
-       struct il_rx_queue *rxq = &il->rxq;
-       struct list_head *element;
-       struct il_rx_buf *rxb;
-       unsigned long flags;
-
-       spin_lock_irqsave(&rxq->lock, flags);
-       while (il_rx_queue_space(rxq) > 0 && rxq->free_count) {
-               /* The overwritten rxb must be a used one */
-               rxb = rxq->queue[rxq->write];
-               BUG_ON(rxb && rxb->page);
-
-               /* Get next free Rx buffer, remove from free list */
-               element = rxq->rx_free.next;
-               rxb = list_entry(element, struct il_rx_buf, list);
-               list_del(element);
-
-               /* Point to Rx buffer via next RBD in circular buffer */
-               rxq->bd[rxq->write] =
-                   il4965_dma_addr2rbd_ptr(il, rxb->page_dma);
-               rxq->queue[rxq->write] = rxb;
-               rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
-               rxq->free_count--;
-       }
-       spin_unlock_irqrestore(&rxq->lock, flags);
-       /* If the pre-allocated buffer pool is dropping low, schedule to
-        * refill it */
-       if (rxq->free_count <= RX_LOW_WATERMARK)
-               queue_work(il->workqueue, &il->rx_replenish);
-
-       /* If we've added more space for the firmware to place data, tell it.
-        * Increment device's write pointer in multiples of 8. */
-       if (rxq->write_actual != (rxq->write & ~0x7)) {
-               spin_lock_irqsave(&rxq->lock, flags);
-               rxq->need_update = 1;
-               spin_unlock_irqrestore(&rxq->lock, flags);
-               il_rx_queue_update_write_ptr(il, rxq);
-       }
-}
-
-/**
- * il4965_rx_replenish - Move all used packet from rx_used to rx_free
- *
- * When moving to rx_free an SKB is allocated for the slot.
- *
- * Also restock the Rx queue via il_rx_queue_restock.
- * This is called as a scheduled work item (except for during initialization)
- */
-static void
-il4965_rx_allocate(struct il_priv *il, gfp_t priority)
-{
-       struct il_rx_queue *rxq = &il->rxq;
-       struct list_head *element;
-       struct il_rx_buf *rxb;
-       struct page *page;
-       dma_addr_t page_dma;
-       unsigned long flags;
-       gfp_t gfp_mask = priority;
-
-       while (1) {
-               spin_lock_irqsave(&rxq->lock, flags);
-               if (list_empty(&rxq->rx_used)) {
-                       spin_unlock_irqrestore(&rxq->lock, flags);
-                       return;
-               }
-               spin_unlock_irqrestore(&rxq->lock, flags);
-
-               if (rxq->free_count > RX_LOW_WATERMARK)
-                       gfp_mask |= __GFP_NOWARN;
-
-               if (il->hw_params.rx_page_order > 0)
-                       gfp_mask |= __GFP_COMP;
-
-               /* Alloc a new receive buffer */
-               page = alloc_pages(gfp_mask, il->hw_params.rx_page_order);
-               if (!page) {
-                       if (net_ratelimit())
-                               D_INFO("alloc_pages failed, " "order: %d\n",
-                                      il->hw_params.rx_page_order);
-
-                       if (rxq->free_count <= RX_LOW_WATERMARK &&
-                           net_ratelimit())
-                               IL_ERR("Failed to alloc_pages with %s. "
-                                      "Only %u free buffers remaining.\n",
-                                      priority ==
-                                      GFP_ATOMIC ? "GFP_ATOMIC" : "GFP_KERNEL",
-                                      rxq->free_count);
-                       /* We don't reschedule replenish work here -- we will
-                        * call the restock method and if it still needs
-                        * more buffers it will schedule replenish */
-                       return;
-               }
-
-               /* Get physical address of the RB */
-               page_dma =
-                   pci_map_page(il->pci_dev, page, 0,
-                                PAGE_SIZE << il->hw_params.rx_page_order,
-                                PCI_DMA_FROMDEVICE);
-               if (unlikely(pci_dma_mapping_error(il->pci_dev, page_dma))) {
-                       __free_pages(page, il->hw_params.rx_page_order);
-                       break;
-               }
-
-               spin_lock_irqsave(&rxq->lock, flags);
-
-               if (list_empty(&rxq->rx_used)) {
-                       spin_unlock_irqrestore(&rxq->lock, flags);
-                       pci_unmap_page(il->pci_dev, page_dma,
-                                      PAGE_SIZE << il->hw_params.rx_page_order,
-                                      PCI_DMA_FROMDEVICE);
-                       __free_pages(page, il->hw_params.rx_page_order);
-                       return;
-               }
-
-               element = rxq->rx_used.next;
-               rxb = list_entry(element, struct il_rx_buf, list);
-               list_del(element);
-
-               BUG_ON(rxb->page);
-
-               rxb->page = page;
-               rxb->page_dma = page_dma;
-               list_add_tail(&rxb->list, &rxq->rx_free);
-               rxq->free_count++;
-               il->alloc_rxb_page++;
-
-               spin_unlock_irqrestore(&rxq->lock, flags);
-       }
-}
-
-void
-il4965_rx_replenish(struct il_priv *il)
-{
-       unsigned long flags;
-
-       il4965_rx_allocate(il, GFP_KERNEL);
-
-       spin_lock_irqsave(&il->lock, flags);
-       il4965_rx_queue_restock(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-}
-
-void
-il4965_rx_replenish_now(struct il_priv *il)
-{
-       il4965_rx_allocate(il, GFP_ATOMIC);
-
-       il4965_rx_queue_restock(il);
-}
-
-/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
- * If an SKB has been detached, the POOL needs to have its SKB set to NULL
- * This free routine walks the list of POOL entries and if SKB is set to
- * non NULL it is unmapped and freed
- */
-void
-il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
-{
-       int i;
-       for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
-               if (rxq->pool[i].page != NULL) {
-                       pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
-                                      PAGE_SIZE << il->hw_params.rx_page_order,
-                                      PCI_DMA_FROMDEVICE);
-                       __il_free_pages(il, rxq->pool[i].page);
-                       rxq->pool[i].page = NULL;
-               }
-       }
-
-       dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
-                         rxq->bd_dma);
-       dma_free_coherent(&il->pci_dev->dev, sizeof(struct il_rb_status),
-                         rxq->rb_stts, rxq->rb_stts_dma);
-       rxq->bd = NULL;
-       rxq->rb_stts = NULL;
-}
-
-int
-il4965_rxq_stop(struct il_priv *il)
-{
-       int ret;
-
-       _il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG, 0);
-       ret = _il_poll_bit(il, FH49_MEM_RSSR_RX_STATUS_REG,
-                          FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
-                          FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
-                          1000);
-       if (ret < 0)
-               IL_ERR("Can't stop Rx DMA.\n");
-
-       return 0;
-}
-
-int
-il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
-{
-       int idx = 0;
-       int band_offset = 0;
-
-       /* HT rate format: mac80211 wants an MCS number, which is just LSB */
-       if (rate_n_flags & RATE_MCS_HT_MSK) {
-               idx = (rate_n_flags & 0xff);
-               return idx;
-               /* Legacy rate format, search for match in table */
-       } else {
-               if (band == IEEE80211_BAND_5GHZ)
-                       band_offset = IL_FIRST_OFDM_RATE;
-               for (idx = band_offset; idx < RATE_COUNT_LEGACY; idx++)
-                       if (il_rates[idx].plcp == (rate_n_flags & 0xFF))
-                               return idx - band_offset;
-       }
-
-       return -1;
-}
-
-static int
-il4965_calc_rssi(struct il_priv *il, struct il_rx_phy_res *rx_resp)
-{
-       /* data from PHY/DSP regarding signal strength, etc.,
-        *   contents are always there, not configurable by host.  */
-       struct il4965_rx_non_cfg_phy *ncphy =
-           (struct il4965_rx_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
-       u32 agc =
-           (le16_to_cpu(ncphy->agc_info) & IL49_AGC_DB_MASK) >>
-           IL49_AGC_DB_POS;
-
-       u32 valid_antennae =
-           (le16_to_cpu(rx_resp->phy_flags) & IL49_RX_PHY_FLAGS_ANTENNAE_MASK)
-           >> IL49_RX_PHY_FLAGS_ANTENNAE_OFFSET;
-       u8 max_rssi = 0;
-       u32 i;
-
-       /* Find max rssi among 3 possible receivers.
-        * These values are measured by the digital signal processor (DSP).
-        * They should stay fairly constant even as the signal strength varies,
-        *   if the radio's automatic gain control (AGC) is working right.
-        * AGC value (see below) will provide the "interesting" info. */
-       for (i = 0; i < 3; i++)
-               if (valid_antennae & (1 << i))
-                       max_rssi = max(ncphy->rssi_info[i << 1], max_rssi);
-
-       D_STATS("Rssi In A %d B %d C %d Max %d AGC dB %d\n",
-               ncphy->rssi_info[0], ncphy->rssi_info[2], ncphy->rssi_info[4],
-               max_rssi, agc);
-
-       /* dBm = max_rssi dB - agc dB - constant.
-        * Higher AGC (higher radio gain) means lower signal. */
-       return max_rssi - agc - IL4965_RSSI_OFFSET;
-}
-
-static u32
-il4965_translate_rx_status(struct il_priv *il, u32 decrypt_in)
-{
-       u32 decrypt_out = 0;
-
-       if ((decrypt_in & RX_RES_STATUS_STATION_FOUND) ==
-           RX_RES_STATUS_STATION_FOUND)
-               decrypt_out |=
-                   (RX_RES_STATUS_STATION_FOUND |
-                    RX_RES_STATUS_NO_STATION_INFO_MISMATCH);
-
-       decrypt_out |= (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK);
-
-       /* packet was not encrypted */
-       if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
-           RX_RES_STATUS_SEC_TYPE_NONE)
-               return decrypt_out;
-
-       /* packet was encrypted with unknown alg */
-       if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
-           RX_RES_STATUS_SEC_TYPE_ERR)
-               return decrypt_out;
-
-       /* decryption was not done in HW */
-       if ((decrypt_in & RX_MPDU_RES_STATUS_DEC_DONE_MSK) !=
-           RX_MPDU_RES_STATUS_DEC_DONE_MSK)
-               return decrypt_out;
-
-       switch (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) {
-
-       case RX_RES_STATUS_SEC_TYPE_CCMP:
-               /* alg is CCM: check MIC only */
-               if (!(decrypt_in & RX_MPDU_RES_STATUS_MIC_OK))
-                       /* Bad MIC */
-                       decrypt_out |= RX_RES_STATUS_BAD_ICV_MIC;
-               else
-                       decrypt_out |= RX_RES_STATUS_DECRYPT_OK;
-
-               break;
-
-       case RX_RES_STATUS_SEC_TYPE_TKIP:
-               if (!(decrypt_in & RX_MPDU_RES_STATUS_TTAK_OK)) {
-                       /* Bad TTAK */
-                       decrypt_out |= RX_RES_STATUS_BAD_KEY_TTAK;
-                       break;
-               }
-               /* fall through if TTAK OK */
-       default:
-               if (!(decrypt_in & RX_MPDU_RES_STATUS_ICV_OK))
-                       decrypt_out |= RX_RES_STATUS_BAD_ICV_MIC;
-               else
-                       decrypt_out |= RX_RES_STATUS_DECRYPT_OK;
-               break;
-       }
-
-       D_RX("decrypt_in:0x%x  decrypt_out = 0x%x\n", decrypt_in, decrypt_out);
-
-       return decrypt_out;
-}
-
-#define SMALL_PACKET_SIZE 256
-
-static void
-il4965_pass_packet_to_mac80211(struct il_priv *il, struct ieee80211_hdr *hdr,
-                              u32 len, u32 ampdu_status, struct il_rx_buf *rxb,
-                              struct ieee80211_rx_status *stats)
-{
-       struct sk_buff *skb;
-       __le16 fc = hdr->frame_control;
-
-       /* We only process data packets if the interface is open */
-       if (unlikely(!il->is_open)) {
-               D_DROP("Dropping packet while interface is not open.\n");
-               return;
-       }
-
-       if (unlikely(test_bit(IL_STOP_REASON_PASSIVE, &il->stop_reason))) {
-               il_wake_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
-               D_INFO("Woke queues - frame received on passive channel\n");
-       }
-
-       /* In case of HW accelerated crypto and bad decryption, drop */
-       if (!il->cfg->mod_params->sw_crypto &&
-           il_set_decrypted_flag(il, hdr, ampdu_status, stats))
-               return;
-
-       skb = dev_alloc_skb(SMALL_PACKET_SIZE);
-       if (!skb) {
-               IL_ERR("dev_alloc_skb failed\n");
-               return;
-       }
-
-       if (len <= SMALL_PACKET_SIZE) {
-               memcpy(skb_put(skb, len), hdr, len);
-       } else {
-               skb_add_rx_frag(skb, 0, rxb->page, (void *)hdr - rxb_addr(rxb),
-                               len, PAGE_SIZE << il->hw_params.rx_page_order);
-               il->alloc_rxb_page--;
-               rxb->page = NULL;
-       }
-
-       il_update_stats(il, false, fc, len);
-       memcpy(IEEE80211_SKB_RXCB(skb), stats, sizeof(*stats));
-
-       ieee80211_rx(il->hw, skb);
-}
-
-/* Called for N_RX (legacy ABG frames), or
- * N_RX_MPDU (HT high-throughput N frames). */
-static void
-il4965_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct ieee80211_hdr *header;
-       struct ieee80211_rx_status rx_status = {};
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_rx_phy_res *phy_res;
-       __le32 rx_pkt_status;
-       struct il_rx_mpdu_res_start *amsdu;
-       u32 len;
-       u32 ampdu_status;
-       u32 rate_n_flags;
-
-       /**
-        * N_RX and N_RX_MPDU are handled differently.
-        *      N_RX: physical layer info is in this buffer
-        *      N_RX_MPDU: physical layer info was sent in separate
-        *              command and cached in il->last_phy_res
-        *
-        * Here we set up local variables depending on which command is
-        * received.
-        */
-       if (pkt->hdr.cmd == N_RX) {
-               phy_res = (struct il_rx_phy_res *)pkt->u.raw;
-               header =
-                   (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*phy_res) +
-                                            phy_res->cfg_phy_cnt);
-
-               len = le16_to_cpu(phy_res->byte_count);
-               rx_pkt_status =
-                   *(__le32 *) (pkt->u.raw + sizeof(*phy_res) +
-                                phy_res->cfg_phy_cnt + len);
-               ampdu_status = le32_to_cpu(rx_pkt_status);
-       } else {
-               if (!il->_4965.last_phy_res_valid) {
-                       IL_ERR("MPDU frame without cached PHY data\n");
-                       return;
-               }
-               phy_res = &il->_4965.last_phy_res;
-               amsdu = (struct il_rx_mpdu_res_start *)pkt->u.raw;
-               header = (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*amsdu));
-               len = le16_to_cpu(amsdu->byte_count);
-               rx_pkt_status = *(__le32 *) (pkt->u.raw + sizeof(*amsdu) + len);
-               ampdu_status =
-                   il4965_translate_rx_status(il, le32_to_cpu(rx_pkt_status));
-       }
-
-       if ((unlikely(phy_res->cfg_phy_cnt > 20))) {
-               D_DROP("dsp size out of range [0,20]: %d\n",
-                      phy_res->cfg_phy_cnt);
-               return;
-       }
-
-       if (!(rx_pkt_status & RX_RES_STATUS_NO_CRC32_ERROR) ||
-           !(rx_pkt_status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
-               D_RX("Bad CRC or FIFO: 0x%08X.\n", le32_to_cpu(rx_pkt_status));
-               return;
-       }
-
-       /* This will be used in several places later */
-       rate_n_flags = le32_to_cpu(phy_res->rate_n_flags);
-
-       /* rx_status carries information about the packet to mac80211 */
-       rx_status.mactime = le64_to_cpu(phy_res->timestamp);
-       rx_status.band =
-           (phy_res->
-            phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
-           IEEE80211_BAND_5GHZ;
-       rx_status.freq =
-           ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
-                                          rx_status.band);
-       rx_status.rate_idx =
-           il4965_hwrate_to_mac80211_idx(rate_n_flags, rx_status.band);
-       rx_status.flag = 0;
-
-       /* TSF isn't reliable. In order to allow smooth user experience,
-        * this W/A doesn't propagate it to the mac80211 */
-       /*rx_status.flag |= RX_FLAG_MACTIME_START; */
-
-       il->ucode_beacon_time = le32_to_cpu(phy_res->beacon_time_stamp);
-
-       /* Find max signal strength (dBm) among 3 antenna/receiver chains */
-       rx_status.signal = il4965_calc_rssi(il, phy_res);
-
-       D_STATS("Rssi %d, TSF %llu\n", rx_status.signal,
-               (unsigned long long)rx_status.mactime);
-
-       /*
-        * "antenna number"
-        *
-        * It seems that the antenna field in the phy flags value
-        * is actually a bit field. This is undefined by radiotap,
-        * it wants an actual antenna number but I always get "7"
-        * for most legacy frames I receive indicating that the
-        * same frame was received on all three RX chains.
-        *
-        * I think this field should be removed in favor of a
-        * new 802.11n radiotap field "RX chains" that is defined
-        * as a bitmask.
-        */
-       rx_status.antenna =
-           (le16_to_cpu(phy_res->phy_flags) & RX_RES_PHY_FLAGS_ANTENNA_MSK) >>
-           RX_RES_PHY_FLAGS_ANTENNA_POS;
-
-       /* set the preamble flag if appropriate */
-       if (phy_res->phy_flags & RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK)
-               rx_status.flag |= RX_FLAG_SHORTPRE;
-
-       /* Set up the HT phy flags */
-       if (rate_n_flags & RATE_MCS_HT_MSK)
-               rx_status.flag |= RX_FLAG_HT;
-       if (rate_n_flags & RATE_MCS_HT40_MSK)
-               rx_status.flag |= RX_FLAG_40MHZ;
-       if (rate_n_flags & RATE_MCS_SGI_MSK)
-               rx_status.flag |= RX_FLAG_SHORT_GI;
-
-       if (phy_res->phy_flags & RX_RES_PHY_FLAGS_AGG_MSK) {
-               /* We know which subframes of an A-MPDU belong
-                * together since we get a single PHY response
-                * from the firmware for all of them.
-                */
-
-               rx_status.flag |= RX_FLAG_AMPDU_DETAILS;
-               rx_status.ampdu_reference = il->_4965.ampdu_ref;
-       }
-
-       il4965_pass_packet_to_mac80211(il, header, len, ampdu_status, rxb,
-                                      &rx_status);
-}
-
-/* Cache phy data (Rx signal strength, etc) for HT frame (N_RX_PHY).
- * This will be used later in il_hdl_rx() for N_RX_MPDU. */
-static void
-il4965_hdl_rx_phy(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       il->_4965.last_phy_res_valid = true;
-       il->_4965.ampdu_ref++;
-       memcpy(&il->_4965.last_phy_res, pkt->u.raw,
-              sizeof(struct il_rx_phy_res));
-}
-
-static int
-il4965_get_channels_for_scan(struct il_priv *il, struct ieee80211_vif *vif,
-                            enum ieee80211_band band, u8 is_active,
-                            u8 n_probes, struct il_scan_channel *scan_ch)
-{
-       struct ieee80211_channel *chan;
-       const struct ieee80211_supported_band *sband;
-       const struct il_channel_info *ch_info;
-       u16 passive_dwell = 0;
-       u16 active_dwell = 0;
-       int added, i;
-       u16 channel;
-
-       sband = il_get_hw_mode(il, band);
-       if (!sband)
-               return 0;
-
-       active_dwell = il_get_active_dwell_time(il, band, n_probes);
-       passive_dwell = il_get_passive_dwell_time(il, band, vif);
-
-       if (passive_dwell <= active_dwell)
-               passive_dwell = active_dwell + 1;
-
-       for (i = 0, added = 0; i < il->scan_request->n_channels; i++) {
-               chan = il->scan_request->channels[i];
-
-               if (chan->band != band)
-                       continue;
-
-               channel = chan->hw_value;
-               scan_ch->channel = cpu_to_le16(channel);
-
-               ch_info = il_get_channel_info(il, band, channel);
-               if (!il_is_channel_valid(ch_info)) {
-                       D_SCAN("Channel %d is INVALID for this band.\n",
-                              channel);
-                       continue;
-               }
-
-               if (!is_active || il_is_channel_passive(ch_info) ||
-                   (chan->flags & IEEE80211_CHAN_NO_IR))
-                       scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE;
-               else
-                       scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE;
-
-               if (n_probes)
-                       scan_ch->type |= IL_SCAN_PROBE_MASK(n_probes);
-
-               scan_ch->active_dwell = cpu_to_le16(active_dwell);
-               scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
-
-               /* Set txpower levels to defaults */
-               scan_ch->dsp_atten = 110;
-
-               /* NOTE: if we were doing 6Mb OFDM for scans we'd use
-                * power level:
-                * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
-                */
-               if (band == IEEE80211_BAND_5GHZ)
-                       scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3;
-               else
-                       scan_ch->tx_gain = ((1 << 5) | (5 << 3));
-
-               D_SCAN("Scanning ch=%d prob=0x%X [%s %d]\n", channel,
-                      le32_to_cpu(scan_ch->type),
-                      (scan_ch->
-                       type & SCAN_CHANNEL_TYPE_ACTIVE) ? "ACTIVE" : "PASSIVE",
-                      (scan_ch->
-                       type & SCAN_CHANNEL_TYPE_ACTIVE) ? active_dwell :
-                      passive_dwell);
-
-               scan_ch++;
-               added++;
-       }
-
-       D_SCAN("total channels to scan %d\n", added);
-       return added;
-}
-
-static void
-il4965_toggle_tx_ant(struct il_priv *il, u8 *ant, u8 valid)
-{
-       int i;
-       u8 ind = *ant;
-
-       for (i = 0; i < RATE_ANT_NUM - 1; i++) {
-               ind = (ind + 1) < RATE_ANT_NUM ? ind + 1 : 0;
-               if (valid & BIT(ind)) {
-                       *ant = ind;
-                       return;
-               }
-       }
-}
-
-int
-il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
-{
-       struct il_host_cmd cmd = {
-               .id = C_SCAN,
-               .len = sizeof(struct il_scan_cmd),
-               .flags = CMD_SIZE_HUGE,
-       };
-       struct il_scan_cmd *scan;
-       u32 rate_flags = 0;
-       u16 cmd_len;
-       u16 rx_chain = 0;
-       enum ieee80211_band band;
-       u8 n_probes = 0;
-       u8 rx_ant = il->hw_params.valid_rx_ant;
-       u8 rate;
-       bool is_active = false;
-       int chan_mod;
-       u8 active_chains;
-       u8 scan_tx_antennas = il->hw_params.valid_tx_ant;
-       int ret;
-
-       lockdep_assert_held(&il->mutex);
-
-       if (!il->scan_cmd) {
-               il->scan_cmd =
-                   kmalloc(sizeof(struct il_scan_cmd) + IL_MAX_SCAN_SIZE,
-                           GFP_KERNEL);
-               if (!il->scan_cmd) {
-                       D_SCAN("fail to allocate memory for scan\n");
-                       return -ENOMEM;
-               }
-       }
-       scan = il->scan_cmd;
-       memset(scan, 0, sizeof(struct il_scan_cmd) + IL_MAX_SCAN_SIZE);
-
-       scan->quiet_plcp_th = IL_PLCP_QUIET_THRESH;
-       scan->quiet_time = IL_ACTIVE_QUIET_TIME;
-
-       if (il_is_any_associated(il)) {
-               u16 interval;
-               u32 extra;
-               u32 suspend_time = 100;
-               u32 scan_suspend_time = 100;
-
-               D_INFO("Scanning while associated...\n");
-               interval = vif->bss_conf.beacon_int;
-
-               scan->suspend_time = 0;
-               scan->max_out_time = cpu_to_le32(200 * 1024);
-               if (!interval)
-                       interval = suspend_time;
-
-               extra = (suspend_time / interval) << 22;
-               scan_suspend_time =
-                   (extra | ((suspend_time % interval) * 1024));
-               scan->suspend_time = cpu_to_le32(scan_suspend_time);
-               D_SCAN("suspend_time 0x%X beacon interval %d\n",
-                      scan_suspend_time, interval);
-       }
-
-       if (il->scan_request->n_ssids) {
-               int i, p = 0;
-               D_SCAN("Kicking off active scan\n");
-               for (i = 0; i < il->scan_request->n_ssids; i++) {
-                       /* always does wildcard anyway */
-                       if (!il->scan_request->ssids[i].ssid_len)
-                               continue;
-                       scan->direct_scan[p].id = WLAN_EID_SSID;
-                       scan->direct_scan[p].len =
-                           il->scan_request->ssids[i].ssid_len;
-                       memcpy(scan->direct_scan[p].ssid,
-                              il->scan_request->ssids[i].ssid,
-                              il->scan_request->ssids[i].ssid_len);
-                       n_probes++;
-                       p++;
-               }
-               is_active = true;
-       } else
-               D_SCAN("Start passive scan.\n");
-
-       scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
-       scan->tx_cmd.sta_id = il->hw_params.bcast_id;
-       scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
-
-       switch (il->scan_band) {
-       case IEEE80211_BAND_2GHZ:
-               scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
-               chan_mod =
-                   le32_to_cpu(il->active.flags & RXON_FLG_CHANNEL_MODE_MSK) >>
-                   RXON_FLG_CHANNEL_MODE_POS;
-               if (chan_mod == CHANNEL_MODE_PURE_40) {
-                       rate = RATE_6M_PLCP;
-               } else {
-                       rate = RATE_1M_PLCP;
-                       rate_flags = RATE_MCS_CCK_MSK;
-               }
-               break;
-       case IEEE80211_BAND_5GHZ:
-               rate = RATE_6M_PLCP;
-               break;
-       default:
-               IL_WARN("Invalid scan band\n");
-               return -EIO;
-       }
-
-       /*
-        * If active scanning is requested but a certain channel is
-        * marked passive, we can do active scanning if we detect
-        * transmissions.
-        *
-        * There is an issue with some firmware versions that triggers
-        * a sysassert on a "good CRC threshold" of zero (== disabled),
-        * on a radar channel even though this means that we should NOT
-        * send probes.
-        *
-        * The "good CRC threshold" is the number of frames that we
-        * need to receive during our dwell time on a channel before
-        * sending out probes -- setting this to a huge value will
-        * mean we never reach it, but at the same time work around
-        * the aforementioned issue. Thus use IL_GOOD_CRC_TH_NEVER
-        * here instead of IL_GOOD_CRC_TH_DISABLED.
-        */
-       scan->good_CRC_th =
-           is_active ? IL_GOOD_CRC_TH_DEFAULT : IL_GOOD_CRC_TH_NEVER;
-
-       band = il->scan_band;
-
-       if (il->cfg->scan_rx_antennas[band])
-               rx_ant = il->cfg->scan_rx_antennas[band];
-
-       il4965_toggle_tx_ant(il, &il->scan_tx_ant[band], scan_tx_antennas);
-       rate_flags |= BIT(il->scan_tx_ant[band]) << RATE_MCS_ANT_POS;
-       scan->tx_cmd.rate_n_flags = cpu_to_le32(rate | rate_flags);
-
-       /* In power save mode use one chain, otherwise use all chains */
-       if (test_bit(S_POWER_PMI, &il->status)) {
-               /* rx_ant has been set to all valid chains previously */
-               active_chains =
-                   rx_ant & ((u8) (il->chain_noise_data.active_chains));
-               if (!active_chains)
-                       active_chains = rx_ant;
-
-               D_SCAN("chain_noise_data.active_chains: %u\n",
-                      il->chain_noise_data.active_chains);
-
-               rx_ant = il4965_first_antenna(active_chains);
-       }
-
-       /* MIMO is not used here, but value is required */
-       rx_chain |= il->hw_params.valid_rx_ant << RXON_RX_CHAIN_VALID_POS;
-       rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS;
-       rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS;
-       rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS;
-       scan->rx_chain = cpu_to_le16(rx_chain);
-
-       cmd_len =
-           il_fill_probe_req(il, (struct ieee80211_mgmt *)scan->data,
-                             vif->addr, il->scan_request->ie,
-                             il->scan_request->ie_len,
-                             IL_MAX_SCAN_SIZE - sizeof(*scan));
-       scan->tx_cmd.len = cpu_to_le16(cmd_len);
-
-       scan->filter_flags |=
-           (RXON_FILTER_ACCEPT_GRP_MSK | RXON_FILTER_BCON_AWARE_MSK);
-
-       scan->channel_count =
-           il4965_get_channels_for_scan(il, vif, band, is_active, n_probes,
-                                        (void *)&scan->data[cmd_len]);
-       if (scan->channel_count == 0) {
-               D_SCAN("channel count %d\n", scan->channel_count);
-               return -EIO;
-       }
-
-       cmd.len +=
-           le16_to_cpu(scan->tx_cmd.len) +
-           scan->channel_count * sizeof(struct il_scan_channel);
-       cmd.data = scan;
-       scan->len = cpu_to_le16(cmd.len);
-
-       set_bit(S_SCAN_HW, &il->status);
-
-       ret = il_send_cmd_sync(il, &cmd);
-       if (ret)
-               clear_bit(S_SCAN_HW, &il->status);
-
-       return ret;
-}
-
-int
-il4965_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
-                          bool add)
-{
-       struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
-
-       if (add)
-               return il4965_add_bssid_station(il, vif->bss_conf.bssid,
-                                               &vif_priv->ibss_bssid_sta_id);
-       return il_remove_station(il, vif_priv->ibss_bssid_sta_id,
-                                vif->bss_conf.bssid);
-}
-
-void
-il4965_free_tfds_in_queue(struct il_priv *il, int sta_id, int tid, int freed)
-{
-       lockdep_assert_held(&il->sta_lock);
-
-       if (il->stations[sta_id].tid[tid].tfds_in_queue >= freed)
-               il->stations[sta_id].tid[tid].tfds_in_queue -= freed;
-       else {
-               D_TX("free more than tfds_in_queue (%u:%d)\n",
-                    il->stations[sta_id].tid[tid].tfds_in_queue, freed);
-               il->stations[sta_id].tid[tid].tfds_in_queue = 0;
-       }
-}
-
-#define IL_TX_QUEUE_MSK        0xfffff
-
-static bool
-il4965_is_single_rx_stream(struct il_priv *il)
-{
-       return il->current_ht_config.smps == IEEE80211_SMPS_STATIC ||
-           il->current_ht_config.single_chain_sufficient;
-}
-
-#define IL_NUM_RX_CHAINS_MULTIPLE      3
-#define IL_NUM_RX_CHAINS_SINGLE        2
-#define IL_NUM_IDLE_CHAINS_DUAL        2
-#define IL_NUM_IDLE_CHAINS_SINGLE      1
-
-/*
- * Determine how many receiver/antenna chains to use.
- *
- * More provides better reception via diversity.  Fewer saves power
- * at the expense of throughput, but only when not in powersave to
- * start with.
- *
- * MIMO (dual stream) requires at least 2, but works better with 3.
- * This does not determine *which* chains to use, just how many.
- */
-static int
-il4965_get_active_rx_chain_count(struct il_priv *il)
-{
-       /* # of Rx chains to use when expecting MIMO. */
-       if (il4965_is_single_rx_stream(il))
-               return IL_NUM_RX_CHAINS_SINGLE;
-       else
-               return IL_NUM_RX_CHAINS_MULTIPLE;
-}
-
-/*
- * When we are in power saving mode, unless device support spatial
- * multiplexing power save, use the active count for rx chain count.
- */
-static int
-il4965_get_idle_rx_chain_count(struct il_priv *il, int active_cnt)
-{
-       /* # Rx chains when idling, depending on SMPS mode */
-       switch (il->current_ht_config.smps) {
-       case IEEE80211_SMPS_STATIC:
-       case IEEE80211_SMPS_DYNAMIC:
-               return IL_NUM_IDLE_CHAINS_SINGLE;
-       case IEEE80211_SMPS_OFF:
-               return active_cnt;
-       default:
-               WARN(1, "invalid SMPS mode %d", il->current_ht_config.smps);
-               return active_cnt;
-       }
-}
-
-/* up to 4 chains */
-static u8
-il4965_count_chain_bitmap(u32 chain_bitmap)
-{
-       u8 res;
-       res = (chain_bitmap & BIT(0)) >> 0;
-       res += (chain_bitmap & BIT(1)) >> 1;
-       res += (chain_bitmap & BIT(2)) >> 2;
-       res += (chain_bitmap & BIT(3)) >> 3;
-       return res;
-}
-
-/**
- * il4965_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
- *
- * Selects how many and which Rx receivers/antennas/chains to use.
- * This should not be used for scan command ... it puts data in wrong place.
- */
-void
-il4965_set_rxon_chain(struct il_priv *il)
-{
-       bool is_single = il4965_is_single_rx_stream(il);
-       bool is_cam = !test_bit(S_POWER_PMI, &il->status);
-       u8 idle_rx_cnt, active_rx_cnt, valid_rx_cnt;
-       u32 active_chains;
-       u16 rx_chain;
-
-       /* Tell uCode which antennas are actually connected.
-        * Before first association, we assume all antennas are connected.
-        * Just after first association, il4965_chain_noise_calibration()
-        *    checks which antennas actually *are* connected. */
-       if (il->chain_noise_data.active_chains)
-               active_chains = il->chain_noise_data.active_chains;
-       else
-               active_chains = il->hw_params.valid_rx_ant;
-
-       rx_chain = active_chains << RXON_RX_CHAIN_VALID_POS;
-
-       /* How many receivers should we use? */
-       active_rx_cnt = il4965_get_active_rx_chain_count(il);
-       idle_rx_cnt = il4965_get_idle_rx_chain_count(il, active_rx_cnt);
-
-       /* correct rx chain count according hw settings
-        * and chain noise calibration
-        */
-       valid_rx_cnt = il4965_count_chain_bitmap(active_chains);
-       if (valid_rx_cnt < active_rx_cnt)
-               active_rx_cnt = valid_rx_cnt;
-
-       if (valid_rx_cnt < idle_rx_cnt)
-               idle_rx_cnt = valid_rx_cnt;
-
-       rx_chain |= active_rx_cnt << RXON_RX_CHAIN_MIMO_CNT_POS;
-       rx_chain |= idle_rx_cnt << RXON_RX_CHAIN_CNT_POS;
-
-       il->staging.rx_chain = cpu_to_le16(rx_chain);
-
-       if (!is_single && active_rx_cnt >= IL_NUM_RX_CHAINS_SINGLE && is_cam)
-               il->staging.rx_chain |= RXON_RX_CHAIN_MIMO_FORCE_MSK;
-       else
-               il->staging.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
-
-       D_ASSOC("rx_chain=0x%X active=%d idle=%d\n", il->staging.rx_chain,
-               active_rx_cnt, idle_rx_cnt);
-
-       WARN_ON(active_rx_cnt == 0 || idle_rx_cnt == 0 ||
-               active_rx_cnt < idle_rx_cnt);
-}
-
-static const char *
-il4965_get_fh_string(int cmd)
-{
-       switch (cmd) {
-               IL_CMD(FH49_RSCSR_CHNL0_STTS_WPTR_REG);
-               IL_CMD(FH49_RSCSR_CHNL0_RBDCB_BASE_REG);
-               IL_CMD(FH49_RSCSR_CHNL0_WPTR);
-               IL_CMD(FH49_MEM_RCSR_CHNL0_CONFIG_REG);
-               IL_CMD(FH49_MEM_RSSR_SHARED_CTRL_REG);
-               IL_CMD(FH49_MEM_RSSR_RX_STATUS_REG);
-               IL_CMD(FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
-               IL_CMD(FH49_TSSR_TX_STATUS_REG);
-               IL_CMD(FH49_TSSR_TX_ERROR_REG);
-       default:
-               return "UNKNOWN";
-       }
-}
-
-int
-il4965_dump_fh(struct il_priv *il, char **buf, bool display)
-{
-       int i;
-#ifdef CONFIG_IWLEGACY_DEBUG
-       int pos = 0;
-       size_t bufsz = 0;
-#endif
-       static const u32 fh_tbl[] = {
-               FH49_RSCSR_CHNL0_STTS_WPTR_REG,
-               FH49_RSCSR_CHNL0_RBDCB_BASE_REG,
-               FH49_RSCSR_CHNL0_WPTR,
-               FH49_MEM_RCSR_CHNL0_CONFIG_REG,
-               FH49_MEM_RSSR_SHARED_CTRL_REG,
-               FH49_MEM_RSSR_RX_STATUS_REG,
-               FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV,
-               FH49_TSSR_TX_STATUS_REG,
-               FH49_TSSR_TX_ERROR_REG
-       };
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (display) {
-               bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
-               *buf = kmalloc(bufsz, GFP_KERNEL);
-               if (!*buf)
-                       return -ENOMEM;
-               pos +=
-                   scnprintf(*buf + pos, bufsz - pos, "FH register values:\n");
-               for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
-                       pos +=
-                           scnprintf(*buf + pos, bufsz - pos,
-                                     "  %34s: 0X%08x\n",
-                                     il4965_get_fh_string(fh_tbl[i]),
-                                     il_rd(il, fh_tbl[i]));
-               }
-               return pos;
-       }
-#endif
-       IL_ERR("FH register values:\n");
-       for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
-               IL_ERR("  %34s: 0X%08x\n", il4965_get_fh_string(fh_tbl[i]),
-                      il_rd(il, fh_tbl[i]));
-       }
-       return 0;
-}
-
-static void
-il4965_hdl_missed_beacon(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_missed_beacon_notif *missed_beacon;
-
-       missed_beacon = &pkt->u.missed_beacon;
-       if (le32_to_cpu(missed_beacon->consecutive_missed_beacons) >
-           il->missed_beacon_threshold) {
-               D_CALIB("missed bcn cnsq %d totl %d rcd %d expctd %d\n",
-                       le32_to_cpu(missed_beacon->consecutive_missed_beacons),
-                       le32_to_cpu(missed_beacon->total_missed_becons),
-                       le32_to_cpu(missed_beacon->num_recvd_beacons),
-                       le32_to_cpu(missed_beacon->num_expected_beacons));
-               if (!test_bit(S_SCANNING, &il->status))
-                       il4965_init_sensitivity(il);
-       }
-}
-
-/* Calculate noise level, based on measurements during network silence just
- *   before arriving beacon.  This measurement can be done only if we know
- *   exactly when to expect beacons, therefore only when we're associated. */
-static void
-il4965_rx_calc_noise(struct il_priv *il)
-{
-       struct stats_rx_non_phy *rx_info;
-       int num_active_rx = 0;
-       int total_silence = 0;
-       int bcn_silence_a, bcn_silence_b, bcn_silence_c;
-       int last_rx_noise;
-
-       rx_info = &(il->_4965.stats.rx.general);
-       bcn_silence_a =
-           le32_to_cpu(rx_info->beacon_silence_rssi_a) & IN_BAND_FILTER;
-       bcn_silence_b =
-           le32_to_cpu(rx_info->beacon_silence_rssi_b) & IN_BAND_FILTER;
-       bcn_silence_c =
-           le32_to_cpu(rx_info->beacon_silence_rssi_c) & IN_BAND_FILTER;
-
-       if (bcn_silence_a) {
-               total_silence += bcn_silence_a;
-               num_active_rx++;
-       }
-       if (bcn_silence_b) {
-               total_silence += bcn_silence_b;
-               num_active_rx++;
-       }
-       if (bcn_silence_c) {
-               total_silence += bcn_silence_c;
-               num_active_rx++;
-       }
-
-       /* Average among active antennas */
-       if (num_active_rx)
-               last_rx_noise = (total_silence / num_active_rx) - 107;
-       else
-               last_rx_noise = IL_NOISE_MEAS_NOT_AVAILABLE;
-
-       D_CALIB("inband silence a %u, b %u, c %u, dBm %d\n", bcn_silence_a,
-               bcn_silence_b, bcn_silence_c, last_rx_noise);
-}
-
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-/*
- *  based on the assumption of all stats counter are in DWORD
- *  FIXME: This function is for debugging, do not deal with
- *  the case of counters roll-over.
- */
-static void
-il4965_accumulative_stats(struct il_priv *il, __le32 * stats)
-{
-       int i, size;
-       __le32 *prev_stats;
-       u32 *accum_stats;
-       u32 *delta, *max_delta;
-       struct stats_general_common *general, *accum_general;
-       struct stats_tx *tx, *accum_tx;
-
-       prev_stats = (__le32 *) &il->_4965.stats;
-       accum_stats = (u32 *) &il->_4965.accum_stats;
-       size = sizeof(struct il_notif_stats);
-       general = &il->_4965.stats.general.common;
-       accum_general = &il->_4965.accum_stats.general.common;
-       tx = &il->_4965.stats.tx;
-       accum_tx = &il->_4965.accum_stats.tx;
-       delta = (u32 *) &il->_4965.delta_stats;
-       max_delta = (u32 *) &il->_4965.max_delta;
-
-       for (i = sizeof(__le32); i < size;
-            i +=
-            sizeof(__le32), stats++, prev_stats++, delta++, max_delta++,
-            accum_stats++) {
-               if (le32_to_cpu(*stats) > le32_to_cpu(*prev_stats)) {
-                       *delta =
-                           (le32_to_cpu(*stats) - le32_to_cpu(*prev_stats));
-                       *accum_stats += *delta;
-                       if (*delta > *max_delta)
-                               *max_delta = *delta;
-               }
-       }
-
-       /* reset accumulative stats for "no-counter" type stats */
-       accum_general->temperature = general->temperature;
-       accum_general->ttl_timestamp = general->ttl_timestamp;
-}
-#endif
-
-static void
-il4965_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       const int recalib_seconds = 60;
-       bool change;
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-
-       D_RX("Statistics notification received (%d vs %d).\n",
-            (int)sizeof(struct il_notif_stats),
-            le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK);
-
-       change =
-           ((il->_4965.stats.general.common.temperature !=
-             pkt->u.stats.general.common.temperature) ||
-            ((il->_4965.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK) !=
-             (pkt->u.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK)));
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       il4965_accumulative_stats(il, (__le32 *) &pkt->u.stats);
-#endif
-
-       /* TODO: reading some of stats is unneeded */
-       memcpy(&il->_4965.stats, &pkt->u.stats, sizeof(il->_4965.stats));
-
-       set_bit(S_STATS, &il->status);
-
-       /*
-        * Reschedule the stats timer to occur in recalib_seconds to ensure
-        * we get a thermal update even if the uCode doesn't give us one
-        */
-       mod_timer(&il->stats_periodic,
-                 jiffies + msecs_to_jiffies(recalib_seconds * 1000));
-
-       if (unlikely(!test_bit(S_SCANNING, &il->status)) &&
-           (pkt->hdr.cmd == N_STATS)) {
-               il4965_rx_calc_noise(il);
-               queue_work(il->workqueue, &il->run_time_calib_work);
-       }
-
-       if (change)
-               il4965_temperature_calib(il);
-}
-
-static void
-il4965_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-
-       if (le32_to_cpu(pkt->u.stats.flag) & UCODE_STATS_CLEAR_MSK) {
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-               memset(&il->_4965.accum_stats, 0,
-                      sizeof(struct il_notif_stats));
-               memset(&il->_4965.delta_stats, 0,
-                      sizeof(struct il_notif_stats));
-               memset(&il->_4965.max_delta, 0, sizeof(struct il_notif_stats));
-#endif
-               D_RX("Statistics have been cleared\n");
-       }
-       il4965_hdl_stats(il, rxb);
-}
-
-
-/*
- * mac80211 queues, ACs, hardware queues, FIFOs.
- *
- * Cf. http://wireless.kernel.org/en/developers/Documentation/mac80211/queues
- *
- * Mac80211 uses the following numbers, which we get as from it
- * by way of skb_get_queue_mapping(skb):
- *
- *     VO      0
- *     VI      1
- *     BE      2
- *     BK      3
- *
- *
- * Regular (not A-MPDU) frames are put into hardware queues corresponding
- * to the FIFOs, see comments in iwl-prph.h. Aggregated frames get their
- * own queue per aggregation session (RA/TID combination), such queues are
- * set up to map into FIFOs too, for which we need an AC->FIFO mapping. In
- * order to map frames to the right queue, we also need an AC->hw queue
- * mapping. This is implemented here.
- *
- * Due to the way hw queues are set up (by the hw specific modules like
- * 4965.c), the AC->hw queue mapping is the identity
- * mapping.
- */
-
-static const u8 tid_to_ac[] = {
-       IEEE80211_AC_BE,
-       IEEE80211_AC_BK,
-       IEEE80211_AC_BK,
-       IEEE80211_AC_BE,
-       IEEE80211_AC_VI,
-       IEEE80211_AC_VI,
-       IEEE80211_AC_VO,
-       IEEE80211_AC_VO
-};
-
-static inline int
-il4965_get_ac_from_tid(u16 tid)
-{
-       if (likely(tid < ARRAY_SIZE(tid_to_ac)))
-               return tid_to_ac[tid];
-
-       /* no support for TIDs 8-15 yet */
-       return -EINVAL;
-}
-
-static inline int
-il4965_get_fifo_from_tid(u16 tid)
-{
-       const u8 ac_to_fifo[] = {
-               IL_TX_FIFO_VO,
-               IL_TX_FIFO_VI,
-               IL_TX_FIFO_BE,
-               IL_TX_FIFO_BK,
-       };
-
-       if (likely(tid < ARRAY_SIZE(tid_to_ac)))
-               return ac_to_fifo[tid_to_ac[tid]];
-
-       /* no support for TIDs 8-15 yet */
-       return -EINVAL;
-}
-
-/*
- * handle build C_TX command notification.
- */
-static void
-il4965_tx_cmd_build_basic(struct il_priv *il, struct sk_buff *skb,
-                         struct il_tx_cmd *tx_cmd,
-                         struct ieee80211_tx_info *info,
-                         struct ieee80211_hdr *hdr, u8 std_id)
-{
-       __le16 fc = hdr->frame_control;
-       __le32 tx_flags = tx_cmd->tx_flags;
-
-       tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
-       if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
-               tx_flags |= TX_CMD_FLG_ACK_MSK;
-               if (ieee80211_is_mgmt(fc))
-                       tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
-               if (ieee80211_is_probe_resp(fc) &&
-                   !(le16_to_cpu(hdr->seq_ctrl) & 0xf))
-                       tx_flags |= TX_CMD_FLG_TSF_MSK;
-       } else {
-               tx_flags &= (~TX_CMD_FLG_ACK_MSK);
-               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
-       }
-
-       if (ieee80211_is_back_req(fc))
-               tx_flags |= TX_CMD_FLG_ACK_MSK | TX_CMD_FLG_IMM_BA_RSP_MASK;
-
-       tx_cmd->sta_id = std_id;
-       if (ieee80211_has_morefrags(fc))
-               tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;
-
-       if (ieee80211_is_data_qos(fc)) {
-               u8 *qc = ieee80211_get_qos_ctl(hdr);
-               tx_cmd->tid_tspec = qc[0] & 0xf;
-               tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
-       } else {
-               tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
-       }
-
-       il_tx_cmd_protection(il, info, fc, &tx_flags);
-
-       tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
-       if (ieee80211_is_mgmt(fc)) {
-               if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
-                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
-               else
-                       tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
-       } else {
-               tx_cmd->timeout.pm_frame_timeout = 0;
-       }
-
-       tx_cmd->driver_txop = 0;
-       tx_cmd->tx_flags = tx_flags;
-       tx_cmd->next_frame_len = 0;
-}
-
-static void
-il4965_tx_cmd_build_rate(struct il_priv *il,
-                        struct il_tx_cmd *tx_cmd,
-                        struct ieee80211_tx_info *info,
-                        struct ieee80211_sta *sta,
-                        __le16 fc)
-{
-       const u8 rts_retry_limit = 60;
-       u32 rate_flags;
-       int rate_idx;
-       u8 data_retry_limit;
-       u8 rate_plcp;
-
-       /* Set retry limit on DATA packets and Probe Responses */
-       if (ieee80211_is_probe_resp(fc))
-               data_retry_limit = 3;
-       else
-               data_retry_limit = IL4965_DEFAULT_TX_RETRY;
-       tx_cmd->data_retry_limit = data_retry_limit;
-       /* Set retry limit on RTS packets */
-       tx_cmd->rts_retry_limit = min(data_retry_limit, rts_retry_limit);
-
-       /* DATA packets will use the uCode station table for rate/antenna
-        * selection */
-       if (ieee80211_is_data(fc)) {
-               tx_cmd->initial_rate_idx = 0;
-               tx_cmd->tx_flags |= TX_CMD_FLG_STA_RATE_MSK;
-               return;
-       }
-
-       /**
-        * If the current TX rate stored in mac80211 has the MCS bit set, it's
-        * not really a TX rate.  Thus, we use the lowest supported rate for
-        * this band.  Also use the lowest supported rate if the stored rate
-        * idx is invalid.
-        */
-       rate_idx = info->control.rates[0].idx;
-       if ((info->control.rates[0].flags & IEEE80211_TX_RC_MCS) || rate_idx < 0
-           || rate_idx > RATE_COUNT_LEGACY)
-               rate_idx = rate_lowest_index(&il->bands[info->band], sta);
-       /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
-       if (info->band == IEEE80211_BAND_5GHZ)
-               rate_idx += IL_FIRST_OFDM_RATE;
-       /* Get PLCP rate for tx_cmd->rate_n_flags */
-       rate_plcp = il_rates[rate_idx].plcp;
-       /* Zero out flags for this packet */
-       rate_flags = 0;
-
-       /* Set CCK flag as needed */
-       if (rate_idx >= IL_FIRST_CCK_RATE && rate_idx <= IL_LAST_CCK_RATE)
-               rate_flags |= RATE_MCS_CCK_MSK;
-
-       /* Set up antennas */
-       il4965_toggle_tx_ant(il, &il->mgmt_tx_ant, il->hw_params.valid_tx_ant);
-       rate_flags |= BIT(il->mgmt_tx_ant) << RATE_MCS_ANT_POS;
-
-       /* Set the rate in the TX cmd */
-       tx_cmd->rate_n_flags = cpu_to_le32(rate_plcp | rate_flags);
-}
-
-static void
-il4965_tx_cmd_build_hwcrypto(struct il_priv *il, struct ieee80211_tx_info *info,
-                            struct il_tx_cmd *tx_cmd, struct sk_buff *skb_frag,
-                            int sta_id)
-{
-       struct ieee80211_key_conf *keyconf = info->control.hw_key;
-
-       switch (keyconf->cipher) {
-       case WLAN_CIPHER_SUITE_CCMP:
-               tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
-               memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
-               if (info->flags & IEEE80211_TX_CTL_AMPDU)
-                       tx_cmd->tx_flags |= TX_CMD_FLG_AGG_CCMP_MSK;
-               D_TX("tx_cmd with AES hwcrypto\n");
-               break;
-
-       case WLAN_CIPHER_SUITE_TKIP:
-               tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
-               ieee80211_get_tkip_p2k(keyconf, skb_frag, tx_cmd->key);
-               D_TX("tx_cmd with tkip hwcrypto\n");
-               break;
-
-       case WLAN_CIPHER_SUITE_WEP104:
-               tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
-               /* fall through */
-       case WLAN_CIPHER_SUITE_WEP40:
-               tx_cmd->sec_ctl |=
-                   (TX_CMD_SEC_WEP | (keyconf->keyidx & TX_CMD_SEC_MSK) <<
-                    TX_CMD_SEC_SHIFT);
-
-               memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
-
-               D_TX("Configuring packet for WEP encryption " "with key %d\n",
-                    keyconf->keyidx);
-               break;
-
-       default:
-               IL_ERR("Unknown encode cipher %x\n", keyconf->cipher);
-               break;
-       }
-}
-
-/*
- * start C_TX command process
- */
-int
-il4965_tx_skb(struct il_priv *il,
-             struct ieee80211_sta *sta,
-             struct sk_buff *skb)
-{
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-       struct il_station_priv *sta_priv = NULL;
-       struct il_tx_queue *txq;
-       struct il_queue *q;
-       struct il_device_cmd *out_cmd;
-       struct il_cmd_meta *out_meta;
-       struct il_tx_cmd *tx_cmd;
-       int txq_id;
-       dma_addr_t phys_addr;
-       dma_addr_t txcmd_phys;
-       dma_addr_t scratch_phys;
-       u16 len, firstlen, secondlen;
-       u16 seq_number = 0;
-       __le16 fc;
-       u8 hdr_len;
-       u8 sta_id;
-       u8 wait_write_ptr = 0;
-       u8 tid = 0;
-       u8 *qc = NULL;
-       unsigned long flags;
-       bool is_agg = false;
-
-       spin_lock_irqsave(&il->lock, flags);
-       if (il_is_rfkill(il)) {
-               D_DROP("Dropping - RF KILL\n");
-               goto drop_unlock;
-       }
-
-       fc = hdr->frame_control;
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (ieee80211_is_auth(fc))
-               D_TX("Sending AUTH frame\n");
-       else if (ieee80211_is_assoc_req(fc))
-               D_TX("Sending ASSOC frame\n");
-       else if (ieee80211_is_reassoc_req(fc))
-               D_TX("Sending REASSOC frame\n");
-#endif
-
-       hdr_len = ieee80211_hdrlen(fc);
-
-       /* For management frames use broadcast id to do not break aggregation */
-       if (!ieee80211_is_data(fc))
-               sta_id = il->hw_params.bcast_id;
-       else {
-               /* Find idx into station table for destination station */
-               sta_id = il_sta_id_or_broadcast(il, sta);
-
-               if (sta_id == IL_INVALID_STATION) {
-                       D_DROP("Dropping - INVALID STATION: %pM\n", hdr->addr1);
-                       goto drop_unlock;
-               }
-       }
-
-       D_TX("station Id %d\n", sta_id);
-
-       if (sta)
-               sta_priv = (void *)sta->drv_priv;
-
-       if (sta_priv && sta_priv->asleep &&
-           (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)) {
-               /*
-                * This sends an asynchronous command to the device,
-                * but we can rely on it being processed before the
-                * next frame is processed -- and the next frame to
-                * this station is the one that will consume this
-                * counter.
-                * For now set the counter to just 1 since we do not
-                * support uAPSD yet.
-                */
-               il4965_sta_modify_sleep_tx_count(il, sta_id, 1);
-       }
-
-       /* FIXME: remove me ? */
-       WARN_ON_ONCE(info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM);
-
-       /* Access category (AC) is also the queue number */
-       txq_id = skb_get_queue_mapping(skb);
-
-       /* irqs already disabled/saved above when locking il->lock */
-       spin_lock(&il->sta_lock);
-
-       if (ieee80211_is_data_qos(fc)) {
-               qc = ieee80211_get_qos_ctl(hdr);
-               tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
-               if (WARN_ON_ONCE(tid >= MAX_TID_COUNT)) {
-                       spin_unlock(&il->sta_lock);
-                       goto drop_unlock;
-               }
-               seq_number = il->stations[sta_id].tid[tid].seq_number;
-               seq_number &= IEEE80211_SCTL_SEQ;
-               hdr->seq_ctrl =
-                   hdr->seq_ctrl & cpu_to_le16(IEEE80211_SCTL_FRAG);
-               hdr->seq_ctrl |= cpu_to_le16(seq_number);
-               seq_number += 0x10;
-               /* aggregation is on for this <sta,tid> */
-               if (info->flags & IEEE80211_TX_CTL_AMPDU &&
-                   il->stations[sta_id].tid[tid].agg.state == IL_AGG_ON) {
-                       txq_id = il->stations[sta_id].tid[tid].agg.txq_id;
-                       is_agg = true;
-               }
-       }
-
-       txq = &il->txq[txq_id];
-       q = &txq->q;
-
-       if (unlikely(il_queue_space(q) < q->high_mark)) {
-               spin_unlock(&il->sta_lock);
-               goto drop_unlock;
-       }
-
-       if (ieee80211_is_data_qos(fc)) {
-               il->stations[sta_id].tid[tid].tfds_in_queue++;
-               if (!ieee80211_has_morefrags(fc))
-                       il->stations[sta_id].tid[tid].seq_number = seq_number;
-       }
-
-       spin_unlock(&il->sta_lock);
-
-       txq->skbs[q->write_ptr] = skb;
-
-       /* Set up first empty entry in queue's array of Tx/cmd buffers */
-       out_cmd = txq->cmd[q->write_ptr];
-       out_meta = &txq->meta[q->write_ptr];
-       tx_cmd = &out_cmd->cmd.tx;
-       memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
-       memset(tx_cmd, 0, sizeof(struct il_tx_cmd));
-
-       /*
-        * Set up the Tx-command (not MAC!) header.
-        * Store the chosen Tx queue and TFD idx within the sequence field;
-        * after Tx, uCode's Tx response will return this value so driver can
-        * locate the frame within the tx queue and do post-tx processing.
-        */
-       out_cmd->hdr.cmd = C_TX;
-       out_cmd->hdr.sequence =
-           cpu_to_le16((u16)
-                       (QUEUE_TO_SEQ(txq_id) | IDX_TO_SEQ(q->write_ptr)));
-
-       /* Copy MAC header from skb into command buffer */
-       memcpy(tx_cmd->hdr, hdr, hdr_len);
-
-       /* Total # bytes to be transmitted */
-       tx_cmd->len = cpu_to_le16((u16) skb->len);
-
-       if (info->control.hw_key)
-               il4965_tx_cmd_build_hwcrypto(il, info, tx_cmd, skb, sta_id);
-
-       /* TODO need this for burst mode later on */
-       il4965_tx_cmd_build_basic(il, skb, tx_cmd, info, hdr, sta_id);
-
-       il4965_tx_cmd_build_rate(il, tx_cmd, info, sta, fc);
-
-       /*
-        * Use the first empty entry in this queue's command buffer array
-        * to contain the Tx command and MAC header concatenated together
-        * (payload data will be in another buffer).
-        * Size of this varies, due to varying MAC header length.
-        * If end is not dword aligned, we'll have 2 extra bytes at the end
-        * of the MAC header (device reads on dword boundaries).
-        * We'll tell device about this padding later.
-        */
-       len = sizeof(struct il_tx_cmd) + sizeof(struct il_cmd_header) + hdr_len;
-       firstlen = (len + 3) & ~3;
-
-       /* Tell NIC about any 2-byte padding after MAC header */
-       if (firstlen != len)
-               tx_cmd->tx_flags |= TX_CMD_FLG_MH_PAD_MSK;
-
-       /* Physical address of this Tx command's header (not MAC header!),
-        * within command buffer array. */
-       txcmd_phys =
-           pci_map_single(il->pci_dev, &out_cmd->hdr, firstlen,
-                          PCI_DMA_BIDIRECTIONAL);
-       if (unlikely(pci_dma_mapping_error(il->pci_dev, txcmd_phys)))
-               goto drop_unlock;
-
-       /* Set up TFD's 2nd entry to point directly to remainder of skb,
-        * if any (802.11 null frames have no payload). */
-       secondlen = skb->len - hdr_len;
-       if (secondlen > 0) {
-               phys_addr =
-                   pci_map_single(il->pci_dev, skb->data + hdr_len, secondlen,
-                                  PCI_DMA_TODEVICE);
-               if (unlikely(pci_dma_mapping_error(il->pci_dev, phys_addr)))
-                       goto drop_unlock;
-       }
-
-       /* Add buffer containing Tx command and MAC(!) header to TFD's
-        * first entry */
-       il->ops->txq_attach_buf_to_tfd(il, txq, txcmd_phys, firstlen, 1, 0);
-       dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
-       dma_unmap_len_set(out_meta, len, firstlen);
-       if (secondlen)
-               il->ops->txq_attach_buf_to_tfd(il, txq, phys_addr, secondlen,
-                                              0, 0);
-
-       if (!ieee80211_has_morefrags(hdr->frame_control)) {
-               txq->need_update = 1;
-       } else {
-               wait_write_ptr = 1;
-               txq->need_update = 0;
-       }
-
-       scratch_phys =
-           txcmd_phys + sizeof(struct il_cmd_header) +
-           offsetof(struct il_tx_cmd, scratch);
-
-       /* take back ownership of DMA buffer to enable update */
-       pci_dma_sync_single_for_cpu(il->pci_dev, txcmd_phys, firstlen,
-                                   PCI_DMA_BIDIRECTIONAL);
-       tx_cmd->dram_lsb_ptr = cpu_to_le32(scratch_phys);
-       tx_cmd->dram_msb_ptr = il_get_dma_hi_addr(scratch_phys);
-
-       il_update_stats(il, true, fc, skb->len);
-
-       D_TX("sequence nr = 0X%x\n", le16_to_cpu(out_cmd->hdr.sequence));
-       D_TX("tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
-       il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd, sizeof(*tx_cmd));
-       il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd->hdr, hdr_len);
-
-       /* Set up entry for this TFD in Tx byte-count array */
-       if (info->flags & IEEE80211_TX_CTL_AMPDU)
-               il->ops->txq_update_byte_cnt_tbl(il, txq, le16_to_cpu(tx_cmd->len));
-
-       pci_dma_sync_single_for_device(il->pci_dev, txcmd_phys, firstlen,
-                                      PCI_DMA_BIDIRECTIONAL);
-
-       /* Tell device the write idx *just past* this latest filled TFD */
-       q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
-       il_txq_update_write_ptr(il, txq);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       /*
-        * At this point the frame is "transmitted" successfully
-        * and we will get a TX status notification eventually,
-        * regardless of the value of ret. "ret" only indicates
-        * whether or not we should update the write pointer.
-        */
-
-       /*
-        * Avoid atomic ops if it isn't an associated client.
-        * Also, if this is a packet for aggregation, don't
-        * increase the counter because the ucode will stop
-        * aggregation queues when their respective station
-        * goes to sleep.
-        */
-       if (sta_priv && sta_priv->client && !is_agg)
-               atomic_inc(&sta_priv->pending_frames);
-
-       if (il_queue_space(q) < q->high_mark && il->mac80211_registered) {
-               if (wait_write_ptr) {
-                       spin_lock_irqsave(&il->lock, flags);
-                       txq->need_update = 1;
-                       il_txq_update_write_ptr(il, txq);
-                       spin_unlock_irqrestore(&il->lock, flags);
-               } else {
-                       il_stop_queue(il, txq);
-               }
-       }
-
-       return 0;
-
-drop_unlock:
-       spin_unlock_irqrestore(&il->lock, flags);
-       return -1;
-}
-
-static inline int
-il4965_alloc_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr, size_t size)
-{
-       ptr->addr = dma_alloc_coherent(&il->pci_dev->dev, size, &ptr->dma,
-                                      GFP_KERNEL);
-       if (!ptr->addr)
-               return -ENOMEM;
-       ptr->size = size;
-       return 0;
-}
-
-static inline void
-il4965_free_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr)
-{
-       if (unlikely(!ptr->addr))
-               return;
-
-       dma_free_coherent(&il->pci_dev->dev, ptr->size, ptr->addr, ptr->dma);
-       memset(ptr, 0, sizeof(*ptr));
-}
-
-/**
- * il4965_hw_txq_ctx_free - Free TXQ Context
- *
- * Destroy all TX DMA queues and structures
- */
-void
-il4965_hw_txq_ctx_free(struct il_priv *il)
-{
-       int txq_id;
-
-       /* Tx queues */
-       if (il->txq) {
-               for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
-                       if (txq_id == il->cmd_queue)
-                               il_cmd_queue_free(il);
-                       else
-                               il_tx_queue_free(il, txq_id);
-       }
-       il4965_free_dma_ptr(il, &il->kw);
-
-       il4965_free_dma_ptr(il, &il->scd_bc_tbls);
-
-       /* free tx queue structure */
-       il_free_txq_mem(il);
-}
-
-/**
- * il4965_txq_ctx_alloc - allocate TX queue context
- * Allocate all Tx DMA structures and initialize them
- *
- * @param il
- * @return error code
- */
-int
-il4965_txq_ctx_alloc(struct il_priv *il)
-{
-       int ret, txq_id;
-       unsigned long flags;
-
-       /* Free all tx/cmd queues and keep-warm buffer */
-       il4965_hw_txq_ctx_free(il);
-
-       ret =
-           il4965_alloc_dma_ptr(il, &il->scd_bc_tbls,
-                                il->hw_params.scd_bc_tbls_size);
-       if (ret) {
-               IL_ERR("Scheduler BC Table allocation failed\n");
-               goto error_bc_tbls;
-       }
-       /* Alloc keep-warm buffer */
-       ret = il4965_alloc_dma_ptr(il, &il->kw, IL_KW_SIZE);
-       if (ret) {
-               IL_ERR("Keep Warm allocation failed\n");
-               goto error_kw;
-       }
-
-       /* allocate tx queue structure */
-       ret = il_alloc_txq_mem(il);
-       if (ret)
-               goto error;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Turn off all Tx DMA fifos */
-       il4965_txq_set_sched(il, 0);
-
-       /* Tell NIC where to find the "keep warm" buffer */
-       il_wr(il, FH49_KW_MEM_ADDR_REG, il->kw.dma >> 4);
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       /* Alloc and init all Tx queues, including the command queue (#4/#9) */
-       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
-               ret = il_tx_queue_init(il, txq_id);
-               if (ret) {
-                       IL_ERR("Tx %d queue init failed\n", txq_id);
-                       goto error;
-               }
-       }
-
-       return ret;
-
-error:
-       il4965_hw_txq_ctx_free(il);
-       il4965_free_dma_ptr(il, &il->kw);
-error_kw:
-       il4965_free_dma_ptr(il, &il->scd_bc_tbls);
-error_bc_tbls:
-       return ret;
-}
-
-void
-il4965_txq_ctx_reset(struct il_priv *il)
-{
-       int txq_id;
-       unsigned long flags;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Turn off all Tx DMA fifos */
-       il4965_txq_set_sched(il, 0);
-       /* Tell NIC where to find the "keep warm" buffer */
-       il_wr(il, FH49_KW_MEM_ADDR_REG, il->kw.dma >> 4);
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       /* Alloc and init all Tx queues, including the command queue (#4) */
-       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
-               il_tx_queue_reset(il, txq_id);
-}
-
-static void
-il4965_txq_ctx_unmap(struct il_priv *il)
-{
-       int txq_id;
-
-       if (!il->txq)
-               return;
-
-       /* Unmap DMA from host system and free skb's */
-       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
-               if (txq_id == il->cmd_queue)
-                       il_cmd_queue_unmap(il);
-               else
-                       il_tx_queue_unmap(il, txq_id);
-}
-
-/**
- * il4965_txq_ctx_stop - Stop all Tx DMA channels
- */
-void
-il4965_txq_ctx_stop(struct il_priv *il)
-{
-       int ch, ret;
-
-       _il_wr_prph(il, IL49_SCD_TXFACT, 0);
-
-       /* Stop each Tx DMA channel, and wait for it to be idle */
-       for (ch = 0; ch < il->hw_params.dma_chnl_num; ch++) {
-               _il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
-               ret =
-                   _il_poll_bit(il, FH49_TSSR_TX_STATUS_REG,
-                                FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
-                                FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
-                                1000);
-               if (ret < 0)
-                       IL_ERR("Timeout stopping DMA channel %d [0x%08x]",
-                              ch, _il_rd(il, FH49_TSSR_TX_STATUS_REG));
-       }
-}
-
-/*
- * Find first available (lowest unused) Tx Queue, mark it "active".
- * Called only when finding queue for aggregation.
- * Should never return anything < 7, because they should already
- * be in use as EDCA AC (0-3), Command (4), reserved (5, 6)
- */
-static int
-il4965_txq_ctx_activate_free(struct il_priv *il)
-{
-       int txq_id;
-
-       for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
-               if (!test_and_set_bit(txq_id, &il->txq_ctx_active_msk))
-                       return txq_id;
-       return -1;
-}
-
-/**
- * il4965_tx_queue_stop_scheduler - Stop queue, but keep configuration
- */
-static void
-il4965_tx_queue_stop_scheduler(struct il_priv *il, u16 txq_id)
-{
-       /* Simply stop the queue, but don't change any configuration;
-        * the SCD_ACT_EN bit is the write-enable mask for the ACTIVE bit. */
-       il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
-                  (0 << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
-                  (1 << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN));
-}
-
-/**
- * il4965_tx_queue_set_q2ratid - Map unique receiver/tid combination to a queue
- */
-static int
-il4965_tx_queue_set_q2ratid(struct il_priv *il, u16 ra_tid, u16 txq_id)
-{
-       u32 tbl_dw_addr;
-       u32 tbl_dw;
-       u16 scd_q2ratid;
-
-       scd_q2ratid = ra_tid & IL_SCD_QUEUE_RA_TID_MAP_RATID_MSK;
-
-       tbl_dw_addr =
-           il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id);
-
-       tbl_dw = il_read_targ_mem(il, tbl_dw_addr);
-
-       if (txq_id & 0x1)
-               tbl_dw = (scd_q2ratid << 16) | (tbl_dw & 0x0000FFFF);
-       else
-               tbl_dw = scd_q2ratid | (tbl_dw & 0xFFFF0000);
-
-       il_write_targ_mem(il, tbl_dw_addr, tbl_dw);
-
-       return 0;
-}
-
-/**
- * il4965_tx_queue_agg_enable - Set up & enable aggregation for selected queue
- *
- * NOTE:  txq_id must be greater than IL49_FIRST_AMPDU_QUEUE,
- *        i.e. it must be one of the higher queues used for aggregation
- */
-static int
-il4965_txq_agg_enable(struct il_priv *il, int txq_id, int tx_fifo, int sta_id,
-                     int tid, u16 ssn_idx)
-{
-       unsigned long flags;
-       u16 ra_tid;
-       int ret;
-
-       if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
-           (IL49_FIRST_AMPDU_QUEUE +
-            il->cfg->num_of_ampdu_queues <= txq_id)) {
-               IL_WARN("queue number out of range: %d, must be %d to %d\n",
-                       txq_id, IL49_FIRST_AMPDU_QUEUE,
-                       IL49_FIRST_AMPDU_QUEUE +
-                       il->cfg->num_of_ampdu_queues - 1);
-               return -EINVAL;
-       }
-
-       ra_tid = BUILD_RAxTID(sta_id, tid);
-
-       /* Modify device's station table to Tx this TID */
-       ret = il4965_sta_tx_modify_enable_tid(il, sta_id, tid);
-       if (ret)
-               return ret;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Stop this Tx queue before configuring it */
-       il4965_tx_queue_stop_scheduler(il, txq_id);
-
-       /* Map receiver-address / traffic-ID to this queue */
-       il4965_tx_queue_set_q2ratid(il, ra_tid, txq_id);
-
-       /* Set this queue as a chain-building queue */
-       il_set_bits_prph(il, IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
-
-       /* Place first TFD at idx corresponding to start sequence number.
-        * Assumes that ssn_idx is valid (!= 0xFFF) */
-       il->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
-       il->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
-       il4965_set_wr_ptrs(il, txq_id, ssn_idx);
-
-       /* Set up Tx win size and frame limit for this queue */
-       il_write_targ_mem(il,
-                         il->scd_base_addr +
-                         IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id),
-                         (SCD_WIN_SIZE << IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS)
-                         & IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
-
-       il_write_targ_mem(il,
-                         il->scd_base_addr +
-                         IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32),
-                         (SCD_FRAME_LIMIT <<
-                          IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
-                         IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
-
-       il_set_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
-
-       /* Set up Status area in SRAM, map to Tx DMA/FIFO, activate the queue */
-       il4965_tx_queue_set_status(il, &il->txq[txq_id], tx_fifo, 1);
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       return 0;
-}
-
-int
-il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
-                   struct ieee80211_sta *sta, u16 tid, u16 * ssn)
-{
-       int sta_id;
-       int tx_fifo;
-       int txq_id;
-       int ret;
-       unsigned long flags;
-       struct il_tid_data *tid_data;
-
-       /* FIXME: warning if tx fifo not found ? */
-       tx_fifo = il4965_get_fifo_from_tid(tid);
-       if (unlikely(tx_fifo < 0))
-               return tx_fifo;
-
-       D_HT("%s on ra = %pM tid = %d\n", __func__, sta->addr, tid);
-
-       sta_id = il_sta_id(sta);
-       if (sta_id == IL_INVALID_STATION) {
-               IL_ERR("Start AGG on invalid station\n");
-               return -ENXIO;
-       }
-       if (unlikely(tid >= MAX_TID_COUNT))
-               return -EINVAL;
-
-       if (il->stations[sta_id].tid[tid].agg.state != IL_AGG_OFF) {
-               IL_ERR("Start AGG when state is not IL_AGG_OFF !\n");
-               return -ENXIO;
-       }
-
-       txq_id = il4965_txq_ctx_activate_free(il);
-       if (txq_id == -1) {
-               IL_ERR("No free aggregation queue available\n");
-               return -ENXIO;
-       }
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       tid_data = &il->stations[sta_id].tid[tid];
-       *ssn = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
-       tid_data->agg.txq_id = txq_id;
-       il_set_swq_id(&il->txq[txq_id], il4965_get_ac_from_tid(tid), txq_id);
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       ret = il4965_txq_agg_enable(il, txq_id, tx_fifo, sta_id, tid, *ssn);
-       if (ret)
-               return ret;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       tid_data = &il->stations[sta_id].tid[tid];
-       if (tid_data->tfds_in_queue == 0) {
-               D_HT("HW queue is empty\n");
-               tid_data->agg.state = IL_AGG_ON;
-               ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
-       } else {
-               D_HT("HW queue is NOT empty: %d packets in HW queue\n",
-                    tid_data->tfds_in_queue);
-               tid_data->agg.state = IL_EMPTYING_HW_QUEUE_ADDBA;
-       }
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-       return ret;
-}
-
-/**
- * txq_id must be greater than IL49_FIRST_AMPDU_QUEUE
- * il->lock must be held by the caller
- */
-static int
-il4965_txq_agg_disable(struct il_priv *il, u16 txq_id, u16 ssn_idx, u8 tx_fifo)
-{
-       if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
-           (IL49_FIRST_AMPDU_QUEUE +
-            il->cfg->num_of_ampdu_queues <= txq_id)) {
-               IL_WARN("queue number out of range: %d, must be %d to %d\n",
-                       txq_id, IL49_FIRST_AMPDU_QUEUE,
-                       IL49_FIRST_AMPDU_QUEUE +
-                       il->cfg->num_of_ampdu_queues - 1);
-               return -EINVAL;
-       }
-
-       il4965_tx_queue_stop_scheduler(il, txq_id);
-
-       il_clear_bits_prph(il, IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
-
-       il->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
-       il->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
-       /* supposes that ssn_idx is valid (!= 0xFFF) */
-       il4965_set_wr_ptrs(il, txq_id, ssn_idx);
-
-       il_clear_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
-       il_txq_ctx_deactivate(il, txq_id);
-       il4965_tx_queue_set_status(il, &il->txq[txq_id], tx_fifo, 0);
-
-       return 0;
-}
-
-int
-il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
-                  struct ieee80211_sta *sta, u16 tid)
-{
-       int tx_fifo_id, txq_id, sta_id, ssn;
-       struct il_tid_data *tid_data;
-       int write_ptr, read_ptr;
-       unsigned long flags;
-
-       /* FIXME: warning if tx_fifo_id not found ? */
-       tx_fifo_id = il4965_get_fifo_from_tid(tid);
-       if (unlikely(tx_fifo_id < 0))
-               return tx_fifo_id;
-
-       sta_id = il_sta_id(sta);
-
-       if (sta_id == IL_INVALID_STATION) {
-               IL_ERR("Invalid station for AGG tid %d\n", tid);
-               return -ENXIO;
-       }
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-
-       tid_data = &il->stations[sta_id].tid[tid];
-       ssn = (tid_data->seq_number & IEEE80211_SCTL_SEQ) >> 4;
-       txq_id = tid_data->agg.txq_id;
-
-       switch (il->stations[sta_id].tid[tid].agg.state) {
-       case IL_EMPTYING_HW_QUEUE_ADDBA:
-               /*
-                * This can happen if the peer stops aggregation
-                * again before we've had a chance to drain the
-                * queue we selected previously, i.e. before the
-                * session was really started completely.
-                */
-               D_HT("AGG stop before setup done\n");
-               goto turn_off;
-       case IL_AGG_ON:
-               break;
-       default:
-               IL_WARN("Stopping AGG while state not ON or starting\n");
-       }
-
-       write_ptr = il->txq[txq_id].q.write_ptr;
-       read_ptr = il->txq[txq_id].q.read_ptr;
-
-       /* The queue is not empty */
-       if (write_ptr != read_ptr) {
-               D_HT("Stopping a non empty AGG HW QUEUE\n");
-               il->stations[sta_id].tid[tid].agg.state =
-                   IL_EMPTYING_HW_QUEUE_DELBA;
-               spin_unlock_irqrestore(&il->sta_lock, flags);
-               return 0;
-       }
-
-       D_HT("HW queue is empty\n");
-turn_off:
-       il->stations[sta_id].tid[tid].agg.state = IL_AGG_OFF;
-
-       /* do not restore/save irqs */
-       spin_unlock(&il->sta_lock);
-       spin_lock(&il->lock);
-
-       /*
-        * the only reason this call can fail is queue number out of range,
-        * which can happen if uCode is reloaded and all the station
-        * information are lost. if it is outside the range, there is no need
-        * to deactivate the uCode queue, just return "success" to allow
-        *  mac80211 to clean up it own data.
-        */
-       il4965_txq_agg_disable(il, txq_id, ssn, tx_fifo_id);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
-
-       return 0;
-}
-
-int
-il4965_txq_check_empty(struct il_priv *il, int sta_id, u8 tid, int txq_id)
-{
-       struct il_queue *q = &il->txq[txq_id].q;
-       u8 *addr = il->stations[sta_id].sta.sta.addr;
-       struct il_tid_data *tid_data = &il->stations[sta_id].tid[tid];
-
-       lockdep_assert_held(&il->sta_lock);
-
-       switch (il->stations[sta_id].tid[tid].agg.state) {
-       case IL_EMPTYING_HW_QUEUE_DELBA:
-               /* We are reclaiming the last packet of the */
-               /* aggregated HW queue */
-               if (txq_id == tid_data->agg.txq_id &&
-                   q->read_ptr == q->write_ptr) {
-                       u16 ssn = IEEE80211_SEQ_TO_SN(tid_data->seq_number);
-                       int tx_fifo = il4965_get_fifo_from_tid(tid);
-                       D_HT("HW queue empty: continue DELBA flow\n");
-                       il4965_txq_agg_disable(il, txq_id, ssn, tx_fifo);
-                       tid_data->agg.state = IL_AGG_OFF;
-                       ieee80211_stop_tx_ba_cb_irqsafe(il->vif, addr, tid);
-               }
-               break;
-       case IL_EMPTYING_HW_QUEUE_ADDBA:
-               /* We are reclaiming the last packet of the queue */
-               if (tid_data->tfds_in_queue == 0) {
-                       D_HT("HW queue empty: continue ADDBA flow\n");
-                       tid_data->agg.state = IL_AGG_ON;
-                       ieee80211_start_tx_ba_cb_irqsafe(il->vif, addr, tid);
-               }
-               break;
-       }
-
-       return 0;
-}
-
-static void
-il4965_non_agg_tx_status(struct il_priv *il, const u8 *addr1)
-{
-       struct ieee80211_sta *sta;
-       struct il_station_priv *sta_priv;
-
-       rcu_read_lock();
-       sta = ieee80211_find_sta(il->vif, addr1);
-       if (sta) {
-               sta_priv = (void *)sta->drv_priv;
-               /* avoid atomic ops if this isn't a client */
-               if (sta_priv->client &&
-                   atomic_dec_return(&sta_priv->pending_frames) == 0)
-                       ieee80211_sta_block_awake(il->hw, sta, false);
-       }
-       rcu_read_unlock();
-}
-
-static void
-il4965_tx_status(struct il_priv *il, struct sk_buff *skb, bool is_agg)
-{
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-
-       if (!is_agg)
-               il4965_non_agg_tx_status(il, hdr->addr1);
-
-       ieee80211_tx_status_irqsafe(il->hw, skb);
-}
-
-int
-il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
-{
-       struct il_tx_queue *txq = &il->txq[txq_id];
-       struct il_queue *q = &txq->q;
-       int nfreed = 0;
-       struct ieee80211_hdr *hdr;
-       struct sk_buff *skb;
-
-       if (idx >= q->n_bd || il_queue_used(q, idx) == 0) {
-               IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
-                      "is out of range [0-%d] %d %d.\n", txq_id, idx, q->n_bd,
-                      q->write_ptr, q->read_ptr);
-               return 0;
-       }
-
-       for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
-            q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
-
-               skb = txq->skbs[txq->q.read_ptr];
-
-               if (WARN_ON_ONCE(skb == NULL))
-                       continue;
-
-               hdr = (struct ieee80211_hdr *) skb->data;
-               if (ieee80211_is_data_qos(hdr->frame_control))
-                       nfreed++;
-
-               il4965_tx_status(il, skb, txq_id >= IL4965_FIRST_AMPDU_QUEUE);
-
-               txq->skbs[txq->q.read_ptr] = NULL;
-               il->ops->txq_free_tfd(il, txq);
-       }
-       return nfreed;
-}
-
-/**
- * il4965_tx_status_reply_compressed_ba - Update tx status from block-ack
- *
- * Go through block-ack's bitmap of ACK'd frames, update driver's record of
- * ACK vs. not.  This gets sent to mac80211, then to rate scaling algo.
- */
-static int
-il4965_tx_status_reply_compressed_ba(struct il_priv *il, struct il_ht_agg *agg,
-                                    struct il_compressed_ba_resp *ba_resp)
-{
-       int i, sh, ack;
-       u16 seq_ctl = le16_to_cpu(ba_resp->seq_ctl);
-       u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);
-       int successes = 0;
-       struct ieee80211_tx_info *info;
-       u64 bitmap, sent_bitmap;
-
-       if (unlikely(!agg->wait_for_ba)) {
-               if (unlikely(ba_resp->bitmap))
-                       IL_ERR("Received BA when not expected\n");
-               return -EINVAL;
-       }
-
-       /* Mark that the expected block-ack response arrived */
-       agg->wait_for_ba = 0;
-       D_TX_REPLY("BA %d %d\n", agg->start_idx, ba_resp->seq_ctl);
-
-       /* Calculate shift to align block-ack bits with our Tx win bits */
-       sh = agg->start_idx - SEQ_TO_IDX(seq_ctl >> 4);
-       if (sh < 0)             /* tbw something is wrong with indices */
-               sh += 0x100;
-
-       if (agg->frame_count > (64 - sh)) {
-               D_TX_REPLY("more frames than bitmap size");
-               return -1;
-       }
-
-       /* don't use 64-bit values for now */
-       bitmap = le64_to_cpu(ba_resp->bitmap) >> sh;
-
-       /* check for success or failure according to the
-        * transmitted bitmap and block-ack bitmap */
-       sent_bitmap = bitmap & agg->bitmap;
-
-       /* For each frame attempted in aggregation,
-        * update driver's record of tx frame's status. */
-       i = 0;
-       while (sent_bitmap) {
-               ack = sent_bitmap & 1ULL;
-               successes += ack;
-               D_TX_REPLY("%s ON i=%d idx=%d raw=%d\n", ack ? "ACK" : "NACK",
-                          i, (agg->start_idx + i) & 0xff, agg->start_idx + i);
-               sent_bitmap >>= 1;
-               ++i;
-       }
-
-       D_TX_REPLY("Bitmap %llx\n", (unsigned long long)bitmap);
-
-       info = IEEE80211_SKB_CB(il->txq[scd_flow].skbs[agg->start_idx]);
-       memset(&info->status, 0, sizeof(info->status));
-       info->flags |= IEEE80211_TX_STAT_ACK;
-       info->flags |= IEEE80211_TX_STAT_AMPDU;
-       info->status.ampdu_ack_len = successes;
-       info->status.ampdu_len = agg->frame_count;
-       il4965_hwrate_to_tx_control(il, agg->rate_n_flags, info);
-
-       return 0;
-}
-
-static inline bool
-il4965_is_tx_success(u32 status)
-{
-       status &= TX_STATUS_MSK;
-       return (status == TX_STATUS_SUCCESS || status == TX_STATUS_DIRECT_DONE);
-}
-
-static u8
-il4965_find_station(struct il_priv *il, const u8 *addr)
-{
-       int i;
-       int start = 0;
-       int ret = IL_INVALID_STATION;
-       unsigned long flags;
-
-       if (il->iw_mode == NL80211_IFTYPE_ADHOC)
-               start = IL_STA_ID;
-
-       if (is_broadcast_ether_addr(addr))
-               return il->hw_params.bcast_id;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       for (i = start; i < il->hw_params.max_stations; i++)
-               if (il->stations[i].used &&
-                   ether_addr_equal(il->stations[i].sta.sta.addr, addr)) {
-                       ret = i;
-                       goto out;
-               }
-
-       D_ASSOC("can not find STA %pM total %d\n", addr, il->num_stations);
-
-out:
-       /*
-        * It may be possible that more commands interacting with stations
-        * arrive before we completed processing the adding of
-        * station
-        */
-       if (ret != IL_INVALID_STATION &&
-           (!(il->stations[ret].used & IL_STA_UCODE_ACTIVE) ||
-            ((il->stations[ret].used & IL_STA_UCODE_ACTIVE) &&
-             (il->stations[ret].used & IL_STA_UCODE_INPROGRESS)))) {
-               IL_ERR("Requested station info for sta %d before ready.\n",
-                      ret);
-               ret = IL_INVALID_STATION;
-       }
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-       return ret;
-}
-
-static int
-il4965_get_ra_sta_id(struct il_priv *il, struct ieee80211_hdr *hdr)
-{
-       if (il->iw_mode == NL80211_IFTYPE_STATION)
-               return IL_AP_ID;
-       else {
-               u8 *da = ieee80211_get_DA(hdr);
-
-               return il4965_find_station(il, da);
-       }
-}
-
-static inline u32
-il4965_get_scd_ssn(struct il4965_tx_resp *tx_resp)
-{
-       return le32_to_cpup(&tx_resp->u.status +
-                           tx_resp->frame_count) & IEEE80211_MAX_SN;
-}
-
-static inline u32
-il4965_tx_status_to_mac80211(u32 status)
-{
-       status &= TX_STATUS_MSK;
-
-       switch (status) {
-       case TX_STATUS_SUCCESS:
-       case TX_STATUS_DIRECT_DONE:
-               return IEEE80211_TX_STAT_ACK;
-       case TX_STATUS_FAIL_DEST_PS:
-               return IEEE80211_TX_STAT_TX_FILTERED;
-       default:
-               return 0;
-       }
-}
-
-/**
- * il4965_tx_status_reply_tx - Handle Tx response for frames in aggregation queue
- */
-static int
-il4965_tx_status_reply_tx(struct il_priv *il, struct il_ht_agg *agg,
-                         struct il4965_tx_resp *tx_resp, int txq_id,
-                         u16 start_idx)
-{
-       u16 status;
-       struct agg_tx_status *frame_status = tx_resp->u.agg_status;
-       struct ieee80211_tx_info *info = NULL;
-       struct ieee80211_hdr *hdr = NULL;
-       u32 rate_n_flags = le32_to_cpu(tx_resp->rate_n_flags);
-       int i, sh, idx;
-       u16 seq;
-       if (agg->wait_for_ba)
-               D_TX_REPLY("got tx response w/o block-ack\n");
-
-       agg->frame_count = tx_resp->frame_count;
-       agg->start_idx = start_idx;
-       agg->rate_n_flags = rate_n_flags;
-       agg->bitmap = 0;
-
-       /* num frames attempted by Tx command */
-       if (agg->frame_count == 1) {
-               /* Only one frame was attempted; no block-ack will arrive */
-               status = le16_to_cpu(frame_status[0].status);
-               idx = start_idx;
-
-               D_TX_REPLY("FrameCnt = %d, StartIdx=%d idx=%d\n",
-                          agg->frame_count, agg->start_idx, idx);
-
-               info = IEEE80211_SKB_CB(il->txq[txq_id].skbs[idx]);
-               info->status.rates[0].count = tx_resp->failure_frame + 1;
-               info->flags &= ~IEEE80211_TX_CTL_AMPDU;
-               info->flags |= il4965_tx_status_to_mac80211(status);
-               il4965_hwrate_to_tx_control(il, rate_n_flags, info);
-
-               D_TX_REPLY("1 Frame 0x%x failure :%d\n", status & 0xff,
-                          tx_resp->failure_frame);
-               D_TX_REPLY("Rate Info rate_n_flags=%x\n", rate_n_flags);
-
-               agg->wait_for_ba = 0;
-       } else {
-               /* Two or more frames were attempted; expect block-ack */
-               u64 bitmap = 0;
-               int start = agg->start_idx;
-               struct sk_buff *skb;
-
-               /* Construct bit-map of pending frames within Tx win */
-               for (i = 0; i < agg->frame_count; i++) {
-                       u16 sc;
-                       status = le16_to_cpu(frame_status[i].status);
-                       seq = le16_to_cpu(frame_status[i].sequence);
-                       idx = SEQ_TO_IDX(seq);
-                       txq_id = SEQ_TO_QUEUE(seq);
-
-                       if (status &
-                           (AGG_TX_STATE_FEW_BYTES_MSK |
-                            AGG_TX_STATE_ABORT_MSK))
-                               continue;
-
-                       D_TX_REPLY("FrameCnt = %d, txq_id=%d idx=%d\n",
-                                  agg->frame_count, txq_id, idx);
-
-                       skb = il->txq[txq_id].skbs[idx];
-                       if (WARN_ON_ONCE(skb == NULL))
-                               return -1;
-                       hdr = (struct ieee80211_hdr *) skb->data;
-
-                       sc = le16_to_cpu(hdr->seq_ctrl);
-                       if (idx != (IEEE80211_SEQ_TO_SN(sc) & 0xff)) {
-                               IL_ERR("BUG_ON idx doesn't match seq control"
-                                      " idx=%d, seq_idx=%d, seq=%d\n", idx,
-                                      IEEE80211_SEQ_TO_SN(sc), hdr->seq_ctrl);
-                               return -1;
-                       }
-
-                       D_TX_REPLY("AGG Frame i=%d idx %d seq=%d\n", i, idx,
-                                  IEEE80211_SEQ_TO_SN(sc));
-
-                       sh = idx - start;
-                       if (sh > 64) {
-                               sh = (start - idx) + 0xff;
-                               bitmap = bitmap << sh;
-                               sh = 0;
-                               start = idx;
-                       } else if (sh < -64)
-                               sh = 0xff - (start - idx);
-                       else if (sh < 0) {
-                               sh = start - idx;
-                               start = idx;
-                               bitmap = bitmap << sh;
-                               sh = 0;
-                       }
-                       bitmap |= 1ULL << sh;
-                       D_TX_REPLY("start=%d bitmap=0x%llx\n", start,
-                                  (unsigned long long)bitmap);
-               }
-
-               agg->bitmap = bitmap;
-               agg->start_idx = start;
-               D_TX_REPLY("Frames %d start_idx=%d bitmap=0x%llx\n",
-                          agg->frame_count, agg->start_idx,
-                          (unsigned long long)agg->bitmap);
-
-               if (bitmap)
-                       agg->wait_for_ba = 1;
-       }
-       return 0;
-}
-
-/**
- * il4965_hdl_tx - Handle standard (non-aggregation) Tx response
- */
-static void
-il4965_hdl_tx(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       u16 sequence = le16_to_cpu(pkt->hdr.sequence);
-       int txq_id = SEQ_TO_QUEUE(sequence);
-       int idx = SEQ_TO_IDX(sequence);
-       struct il_tx_queue *txq = &il->txq[txq_id];
-       struct sk_buff *skb;
-       struct ieee80211_hdr *hdr;
-       struct ieee80211_tx_info *info;
-       struct il4965_tx_resp *tx_resp = (void *)&pkt->u.raw[0];
-       u32 status = le32_to_cpu(tx_resp->u.status);
-       int uninitialized_var(tid);
-       int sta_id;
-       int freed;
-       u8 *qc = NULL;
-       unsigned long flags;
-
-       if (idx >= txq->q.n_bd || il_queue_used(&txq->q, idx) == 0) {
-               IL_ERR("Read idx for DMA queue txq_id (%d) idx %d "
-                      "is out of range [0-%d] %d %d\n", txq_id, idx,
-                      txq->q.n_bd, txq->q.write_ptr, txq->q.read_ptr);
-               return;
-       }
-
-       txq->time_stamp = jiffies;
-
-       skb = txq->skbs[txq->q.read_ptr];
-       info = IEEE80211_SKB_CB(skb);
-       memset(&info->status, 0, sizeof(info->status));
-
-       hdr = (struct ieee80211_hdr *) skb->data;
-       if (ieee80211_is_data_qos(hdr->frame_control)) {
-               qc = ieee80211_get_qos_ctl(hdr);
-               tid = qc[0] & 0xf;
-       }
-
-       sta_id = il4965_get_ra_sta_id(il, hdr);
-       if (txq->sched_retry && unlikely(sta_id == IL_INVALID_STATION)) {
-               IL_ERR("Station not known\n");
-               return;
-       }
-
-       /*
-        * Firmware will not transmit frame on passive channel, if it not yet
-        * received some valid frame on that channel. When this error happen
-        * we have to wait until firmware will unblock itself i.e. when we
-        * note received beacon or other frame. We unblock queues in
-        * il4965_pass_packet_to_mac80211 or in il_mac_bss_info_changed.
-        */
-       if (unlikely((status & TX_STATUS_MSK) == TX_STATUS_FAIL_PASSIVE_NO_RX) &&
-           il->iw_mode == NL80211_IFTYPE_STATION) {
-               il_stop_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
-               D_INFO("Stopped queues - RX waiting on passive channel\n");
-       }
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       if (txq->sched_retry) {
-               const u32 scd_ssn = il4965_get_scd_ssn(tx_resp);
-               struct il_ht_agg *agg = NULL;
-               WARN_ON(!qc);
-
-               agg = &il->stations[sta_id].tid[tid].agg;
-
-               il4965_tx_status_reply_tx(il, agg, tx_resp, txq_id, idx);
-
-               /* check if BAR is needed */
-               if (tx_resp->frame_count == 1 &&
-                   !il4965_is_tx_success(status))
-                       info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
-
-               if (txq->q.read_ptr != (scd_ssn & 0xff)) {
-                       idx = il_queue_dec_wrap(scd_ssn & 0xff, txq->q.n_bd);
-                       D_TX_REPLY("Retry scheduler reclaim scd_ssn "
-                                  "%d idx %d\n", scd_ssn, idx);
-                       freed = il4965_tx_queue_reclaim(il, txq_id, idx);
-                       if (qc)
-                               il4965_free_tfds_in_queue(il, sta_id, tid,
-                                                         freed);
-
-                       if (il->mac80211_registered &&
-                           il_queue_space(&txq->q) > txq->q.low_mark &&
-                           agg->state != IL_EMPTYING_HW_QUEUE_DELBA)
-                               il_wake_queue(il, txq);
-               }
-       } else {
-               info->status.rates[0].count = tx_resp->failure_frame + 1;
-               info->flags |= il4965_tx_status_to_mac80211(status);
-               il4965_hwrate_to_tx_control(il,
-                                           le32_to_cpu(tx_resp->rate_n_flags),
-                                           info);
-
-               D_TX_REPLY("TXQ %d status %s (0x%08x) "
-                          "rate_n_flags 0x%x retries %d\n", txq_id,
-                          il4965_get_tx_fail_reason(status), status,
-                          le32_to_cpu(tx_resp->rate_n_flags),
-                          tx_resp->failure_frame);
-
-               freed = il4965_tx_queue_reclaim(il, txq_id, idx);
-               if (qc && likely(sta_id != IL_INVALID_STATION))
-                       il4965_free_tfds_in_queue(il, sta_id, tid, freed);
-               else if (sta_id == IL_INVALID_STATION)
-                       D_TX_REPLY("Station not known\n");
-
-               if (il->mac80211_registered &&
-                   il_queue_space(&txq->q) > txq->q.low_mark)
-                       il_wake_queue(il, txq);
-       }
-       if (qc && likely(sta_id != IL_INVALID_STATION))
-               il4965_txq_check_empty(il, sta_id, tid, txq_id);
-
-       il4965_check_abort_status(il, tx_resp->frame_count, status);
-
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-}
-
-/**
- * translate ucode response to mac80211 tx status control values
- */
-void
-il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
-                           struct ieee80211_tx_info *info)
-{
-       struct ieee80211_tx_rate *r = &info->status.rates[0];
-
-       info->status.antenna =
-           ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
-       if (rate_n_flags & RATE_MCS_HT_MSK)
-               r->flags |= IEEE80211_TX_RC_MCS;
-       if (rate_n_flags & RATE_MCS_GF_MSK)
-               r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
-       if (rate_n_flags & RATE_MCS_HT40_MSK)
-               r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
-       if (rate_n_flags & RATE_MCS_DUP_MSK)
-               r->flags |= IEEE80211_TX_RC_DUP_DATA;
-       if (rate_n_flags & RATE_MCS_SGI_MSK)
-               r->flags |= IEEE80211_TX_RC_SHORT_GI;
-       r->idx = il4965_hwrate_to_mac80211_idx(rate_n_flags, info->band);
-}
-
-/**
- * il4965_hdl_compressed_ba - Handler for N_COMPRESSED_BA
- *
- * Handles block-acknowledge notification from device, which reports success
- * of frames sent via aggregation.
- */
-static void
-il4965_hdl_compressed_ba(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_compressed_ba_resp *ba_resp = &pkt->u.compressed_ba;
-       struct il_tx_queue *txq = NULL;
-       struct il_ht_agg *agg;
-       int idx;
-       int sta_id;
-       int tid;
-       unsigned long flags;
-
-       /* "flow" corresponds to Tx queue */
-       u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);
-
-       /* "ssn" is start of block-ack Tx win, corresponds to idx
-        * (in Tx queue's circular buffer) of first TFD/frame in win */
-       u16 ba_resp_scd_ssn = le16_to_cpu(ba_resp->scd_ssn);
-
-       if (scd_flow >= il->hw_params.max_txq_num) {
-               IL_ERR("BUG_ON scd_flow is bigger than number of queues\n");
-               return;
-       }
-
-       txq = &il->txq[scd_flow];
-       sta_id = ba_resp->sta_id;
-       tid = ba_resp->tid;
-       agg = &il->stations[sta_id].tid[tid].agg;
-       if (unlikely(agg->txq_id != scd_flow)) {
-               /*
-                * FIXME: this is a uCode bug which need to be addressed,
-                * log the information and return for now!
-                * since it is possible happen very often and in order
-                * not to fill the syslog, don't enable the logging by default
-                */
-               D_TX_REPLY("BA scd_flow %d does not match txq_id %d\n",
-                          scd_flow, agg->txq_id);
-               return;
-       }
-
-       /* Find idx just before block-ack win */
-       idx = il_queue_dec_wrap(ba_resp_scd_ssn & 0xff, txq->q.n_bd);
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-
-       D_TX_REPLY("N_COMPRESSED_BA [%d] Received from %pM, " "sta_id = %d\n",
-                  agg->wait_for_ba, (u8 *) &ba_resp->sta_addr_lo32,
-                  ba_resp->sta_id);
-       D_TX_REPLY("TID = %d, SeqCtl = %d, bitmap = 0x%llx," "scd_flow = "
-                  "%d, scd_ssn = %d\n", ba_resp->tid, ba_resp->seq_ctl,
-                  (unsigned long long)le64_to_cpu(ba_resp->bitmap),
-                  ba_resp->scd_flow, ba_resp->scd_ssn);
-       D_TX_REPLY("DAT start_idx = %d, bitmap = 0x%llx\n", agg->start_idx,
-                  (unsigned long long)agg->bitmap);
-
-       /* Update driver's record of ACK vs. not for each frame in win */
-       il4965_tx_status_reply_compressed_ba(il, agg, ba_resp);
-
-       /* Release all TFDs before the SSN, i.e. all TFDs in front of
-        * block-ack win (we assume that they've been successfully
-        * transmitted ... if not, it's too late anyway). */
-       if (txq->q.read_ptr != (ba_resp_scd_ssn & 0xff)) {
-               /* calculate mac80211 ampdu sw queue to wake */
-               int freed = il4965_tx_queue_reclaim(il, scd_flow, idx);
-               il4965_free_tfds_in_queue(il, sta_id, tid, freed);
-
-               if (il_queue_space(&txq->q) > txq->q.low_mark &&
-                   il->mac80211_registered &&
-                   agg->state != IL_EMPTYING_HW_QUEUE_DELBA)
-                       il_wake_queue(il, txq);
-
-               il4965_txq_check_empty(il, sta_id, tid, scd_flow);
-       }
-
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-}
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-const char *
-il4965_get_tx_fail_reason(u32 status)
-{
-#define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
-#define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x
-
-       switch (status & TX_STATUS_MSK) {
-       case TX_STATUS_SUCCESS:
-               return "SUCCESS";
-               TX_STATUS_POSTPONE(DELAY);
-               TX_STATUS_POSTPONE(FEW_BYTES);
-               TX_STATUS_POSTPONE(QUIET_PERIOD);
-               TX_STATUS_POSTPONE(CALC_TTAK);
-               TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
-               TX_STATUS_FAIL(SHORT_LIMIT);
-               TX_STATUS_FAIL(LONG_LIMIT);
-               TX_STATUS_FAIL(FIFO_UNDERRUN);
-               TX_STATUS_FAIL(DRAIN_FLOW);
-               TX_STATUS_FAIL(RFKILL_FLUSH);
-               TX_STATUS_FAIL(LIFE_EXPIRE);
-               TX_STATUS_FAIL(DEST_PS);
-               TX_STATUS_FAIL(HOST_ABORTED);
-               TX_STATUS_FAIL(BT_RETRY);
-               TX_STATUS_FAIL(STA_INVALID);
-               TX_STATUS_FAIL(FRAG_DROPPED);
-               TX_STATUS_FAIL(TID_DISABLE);
-               TX_STATUS_FAIL(FIFO_FLUSHED);
-               TX_STATUS_FAIL(INSUFFICIENT_CF_POLL);
-               TX_STATUS_FAIL(PASSIVE_NO_RX);
-               TX_STATUS_FAIL(NO_BEACON_ON_RADAR);
-       }
-
-       return "UNKNOWN";
-
-#undef TX_STATUS_FAIL
-#undef TX_STATUS_POSTPONE
-}
-#endif /* CONFIG_IWLEGACY_DEBUG */
-
-static struct il_link_quality_cmd *
-il4965_sta_alloc_lq(struct il_priv *il, u8 sta_id)
-{
-       int i, r;
-       struct il_link_quality_cmd *link_cmd;
-       u32 rate_flags = 0;
-       __le32 rate_n_flags;
-
-       link_cmd = kzalloc(sizeof(struct il_link_quality_cmd), GFP_KERNEL);
-       if (!link_cmd) {
-               IL_ERR("Unable to allocate memory for LQ cmd.\n");
-               return NULL;
-       }
-       /* Set up the rate scaling to start at selected rate, fall back
-        * all the way down to 1M in IEEE order, and then spin on 1M */
-       if (il->band == IEEE80211_BAND_5GHZ)
-               r = RATE_6M_IDX;
-       else
-               r = RATE_1M_IDX;
-
-       if (r >= IL_FIRST_CCK_RATE && r <= IL_LAST_CCK_RATE)
-               rate_flags |= RATE_MCS_CCK_MSK;
-
-       rate_flags |=
-           il4965_first_antenna(il->hw_params.
-                                valid_tx_ant) << RATE_MCS_ANT_POS;
-       rate_n_flags = cpu_to_le32(il_rates[r].plcp | rate_flags);
-       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
-               link_cmd->rs_table[i].rate_n_flags = rate_n_flags;
-
-       link_cmd->general_params.single_stream_ant_msk =
-           il4965_first_antenna(il->hw_params.valid_tx_ant);
-
-       link_cmd->general_params.dual_stream_ant_msk =
-           il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
-                                                              valid_tx_ant);
-       if (!link_cmd->general_params.dual_stream_ant_msk) {
-               link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
-       } else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
-               link_cmd->general_params.dual_stream_ant_msk =
-                   il->hw_params.valid_tx_ant;
-       }
-
-       link_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
-       link_cmd->agg_params.agg_time_limit =
-           cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
-
-       link_cmd->sta_id = sta_id;
-
-       return link_cmd;
-}
-
-/*
- * il4965_add_bssid_station - Add the special IBSS BSSID station
- *
- * Function sleeps.
- */
-int
-il4965_add_bssid_station(struct il_priv *il, const u8 *addr, u8 *sta_id_r)
-{
-       int ret;
-       u8 sta_id;
-       struct il_link_quality_cmd *link_cmd;
-       unsigned long flags;
-
-       if (sta_id_r)
-               *sta_id_r = IL_INVALID_STATION;
-
-       ret = il_add_station_common(il, addr, 0, NULL, &sta_id);
-       if (ret) {
-               IL_ERR("Unable to add station %pM\n", addr);
-               return ret;
-       }
-
-       if (sta_id_r)
-               *sta_id_r = sta_id;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].used |= IL_STA_LOCAL;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       /* Set up default rate scaling table in device's station table */
-       link_cmd = il4965_sta_alloc_lq(il, sta_id);
-       if (!link_cmd) {
-               IL_ERR("Unable to initialize rate scaling for station %pM.\n",
-                      addr);
-               return -ENOMEM;
-       }
-
-       ret = il_send_lq_cmd(il, link_cmd, CMD_SYNC, true);
-       if (ret)
-               IL_ERR("Link quality command failed (%d)\n", ret);
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].lq = link_cmd;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return 0;
-}
-
-static int
-il4965_static_wepkey_cmd(struct il_priv *il, bool send_if_empty)
-{
-       int i;
-       u8 buff[sizeof(struct il_wep_cmd) +
-               sizeof(struct il_wep_key) * WEP_KEYS_MAX];
-       struct il_wep_cmd *wep_cmd = (struct il_wep_cmd *)buff;
-       size_t cmd_size = sizeof(struct il_wep_cmd);
-       struct il_host_cmd cmd = {
-               .id = C_WEPKEY,
-               .data = wep_cmd,
-               .flags = CMD_SYNC,
-       };
-       bool not_empty = false;
-
-       might_sleep();
-
-       memset(wep_cmd, 0,
-              cmd_size + (sizeof(struct il_wep_key) * WEP_KEYS_MAX));
-
-       for (i = 0; i < WEP_KEYS_MAX; i++) {
-               u8 key_size = il->_4965.wep_keys[i].key_size;
-
-               wep_cmd->key[i].key_idx = i;
-               if (key_size) {
-                       wep_cmd->key[i].key_offset = i;
-                       not_empty = true;
-               } else
-                       wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
-
-               wep_cmd->key[i].key_size = key_size;
-               memcpy(&wep_cmd->key[i].key[3], il->_4965.wep_keys[i].key, key_size);
-       }
-
-       wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
-       wep_cmd->num_keys = WEP_KEYS_MAX;
-
-       cmd_size += sizeof(struct il_wep_key) * WEP_KEYS_MAX;
-       cmd.len = cmd_size;
-
-       if (not_empty || send_if_empty)
-               return il_send_cmd(il, &cmd);
-       else
-               return 0;
-}
-
-int
-il4965_restore_default_wep_keys(struct il_priv *il)
-{
-       lockdep_assert_held(&il->mutex);
-
-       return il4965_static_wepkey_cmd(il, false);
-}
-
-int
-il4965_remove_default_wep_key(struct il_priv *il,
-                             struct ieee80211_key_conf *keyconf)
-{
-       int ret;
-       int idx = keyconf->keyidx;
-
-       lockdep_assert_held(&il->mutex);
-
-       D_WEP("Removing default WEP key: idx=%d\n", idx);
-
-       memset(&il->_4965.wep_keys[idx], 0, sizeof(struct il_wep_key));
-       if (il_is_rfkill(il)) {
-               D_WEP("Not sending C_WEPKEY command due to RFKILL.\n");
-               /* but keys in device are clear anyway so return success */
-               return 0;
-       }
-       ret = il4965_static_wepkey_cmd(il, 1);
-       D_WEP("Remove default WEP key: idx=%d ret=%d\n", idx, ret);
-
-       return ret;
-}
-
-int
-il4965_set_default_wep_key(struct il_priv *il,
-                          struct ieee80211_key_conf *keyconf)
-{
-       int ret;
-       int len = keyconf->keylen;
-       int idx = keyconf->keyidx;
-
-       lockdep_assert_held(&il->mutex);
-
-       if (len != WEP_KEY_LEN_128 && len != WEP_KEY_LEN_64) {
-               D_WEP("Bad WEP key length %d\n", keyconf->keylen);
-               return -EINVAL;
-       }
-
-       keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
-       keyconf->hw_key_idx = HW_KEY_DEFAULT;
-       il->stations[IL_AP_ID].keyinfo.cipher = keyconf->cipher;
-
-       il->_4965.wep_keys[idx].key_size = len;
-       memcpy(&il->_4965.wep_keys[idx].key, &keyconf->key, len);
-
-       ret = il4965_static_wepkey_cmd(il, false);
-
-       D_WEP("Set default WEP key: len=%d idx=%d ret=%d\n", len, idx, ret);
-       return ret;
-}
-
-static int
-il4965_set_wep_dynamic_key_info(struct il_priv *il,
-                               struct ieee80211_key_conf *keyconf, u8 sta_id)
-{
-       unsigned long flags;
-       __le16 key_flags = 0;
-       struct il_addsta_cmd sta_cmd;
-
-       lockdep_assert_held(&il->mutex);
-
-       keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
-
-       key_flags |= (STA_KEY_FLG_WEP | STA_KEY_FLG_MAP_KEY_MSK);
-       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
-       key_flags &= ~STA_KEY_FLG_INVALID;
-
-       if (keyconf->keylen == WEP_KEY_LEN_128)
-               key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;
-
-       if (sta_id == il->hw_params.bcast_id)
-               key_flags |= STA_KEY_MULTICAST_MSK;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-
-       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
-       il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
-       il->stations[sta_id].keyinfo.keyidx = keyconf->keyidx;
-
-       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
-
-       memcpy(&il->stations[sta_id].sta.key.key[3], keyconf->key,
-              keyconf->keylen);
-
-       if ((il->stations[sta_id].sta.key.
-            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
-               il->stations[sta_id].sta.key.key_offset =
-                   il_get_free_ucode_key_idx(il);
-       /* else, we are overriding an existing key => no need to allocated room
-        * in uCode. */
-
-       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
-            "no space for a new key");
-
-       il->stations[sta_id].sta.key.key_flags = key_flags;
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-}
-
-static int
-il4965_set_ccmp_dynamic_key_info(struct il_priv *il,
-                                struct ieee80211_key_conf *keyconf, u8 sta_id)
-{
-       unsigned long flags;
-       __le16 key_flags = 0;
-       struct il_addsta_cmd sta_cmd;
-
-       lockdep_assert_held(&il->mutex);
-
-       key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
-       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
-       key_flags &= ~STA_KEY_FLG_INVALID;
-
-       if (sta_id == il->hw_params.bcast_id)
-               key_flags |= STA_KEY_MULTICAST_MSK;
-
-       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
-       il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
-
-       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
-
-       memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
-
-       if ((il->stations[sta_id].sta.key.
-            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
-               il->stations[sta_id].sta.key.key_offset =
-                   il_get_free_ucode_key_idx(il);
-       /* else, we are overriding an existing key => no need to allocated room
-        * in uCode. */
-
-       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
-            "no space for a new key");
-
-       il->stations[sta_id].sta.key.key_flags = key_flags;
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-}
-
-static int
-il4965_set_tkip_dynamic_key_info(struct il_priv *il,
-                                struct ieee80211_key_conf *keyconf, u8 sta_id)
-{
-       unsigned long flags;
-       int ret = 0;
-       __le16 key_flags = 0;
-
-       key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
-       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
-       key_flags &= ~STA_KEY_FLG_INVALID;
-
-       if (sta_id == il->hw_params.bcast_id)
-               key_flags |= STA_KEY_MULTICAST_MSK;
-
-       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
-       keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-
-       il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
-       il->stations[sta_id].keyinfo.keylen = 16;
-
-       if ((il->stations[sta_id].sta.key.
-            key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
-               il->stations[sta_id].sta.key.key_offset =
-                   il_get_free_ucode_key_idx(il);
-       /* else, we are overriding an existing key => no need to allocated room
-        * in uCode. */
-
-       WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
-            "no space for a new key");
-
-       il->stations[sta_id].sta.key.key_flags = key_flags;
-
-       /* This copy is acutally not needed: we get the key with each TX */
-       memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, 16);
-
-       memcpy(il->stations[sta_id].sta.key.key, keyconf->key, 16);
-
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return ret;
-}
-
-void
-il4965_update_tkip_key(struct il_priv *il, struct ieee80211_key_conf *keyconf,
-                      struct ieee80211_sta *sta, u32 iv32, u16 *phase1key)
-{
-       u8 sta_id;
-       unsigned long flags;
-       int i;
-
-       if (il_scan_cancel(il)) {
-               /* cancel scan failed, just live w/ bad key and rely
-                  briefly on SW decryption */
-               return;
-       }
-
-       sta_id = il_sta_id_or_broadcast(il, sta);
-       if (sta_id == IL_INVALID_STATION)
-               return;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-
-       il->stations[sta_id].sta.key.tkip_rx_tsc_byte2 = (u8) iv32;
-
-       for (i = 0; i < 5; i++)
-               il->stations[sta_id].sta.key.tkip_rx_ttak[i] =
-                   cpu_to_le16(phase1key[i]);
-
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-
-       il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
-
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-}
-
-int
-il4965_remove_dynamic_key(struct il_priv *il,
-                         struct ieee80211_key_conf *keyconf, u8 sta_id)
-{
-       unsigned long flags;
-       u16 key_flags;
-       u8 keyidx;
-       struct il_addsta_cmd sta_cmd;
-
-       lockdep_assert_held(&il->mutex);
-
-       il->_4965.key_mapping_keys--;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       key_flags = le16_to_cpu(il->stations[sta_id].sta.key.key_flags);
-       keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;
-
-       D_WEP("Remove dynamic key: idx=%d sta=%d\n", keyconf->keyidx, sta_id);
-
-       if (keyconf->keyidx != keyidx) {
-               /* We need to remove a key with idx different that the one
-                * in the uCode. This means that the key we need to remove has
-                * been replaced by another one with different idx.
-                * Don't do anything and return ok
-                */
-               spin_unlock_irqrestore(&il->sta_lock, flags);
-               return 0;
-       }
-
-       if (il->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_INVALID) {
-               IL_WARN("Removing wrong key %d 0x%x\n", keyconf->keyidx,
-                       key_flags);
-               spin_unlock_irqrestore(&il->sta_lock, flags);
-               return 0;
-       }
-
-       if (!test_and_clear_bit
-           (il->stations[sta_id].sta.key.key_offset, &il->ucode_key_table))
-               IL_ERR("idx %d not used in uCode key table.\n",
-                      il->stations[sta_id].sta.key.key_offset);
-       memset(&il->stations[sta_id].keyinfo, 0, sizeof(struct il_hw_key));
-       memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
-       il->stations[sta_id].sta.key.key_flags =
-           STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
-       il->stations[sta_id].sta.key.key_offset = keyconf->hw_key_idx;
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-
-       if (il_is_rfkill(il)) {
-               D_WEP
-                   ("Not sending C_ADD_STA command because RFKILL enabled.\n");
-               spin_unlock_irqrestore(&il->sta_lock, flags);
-               return 0;
-       }
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-}
-
-int
-il4965_set_dynamic_key(struct il_priv *il, struct ieee80211_key_conf *keyconf,
-                      u8 sta_id)
-{
-       int ret;
-
-       lockdep_assert_held(&il->mutex);
-
-       il->_4965.key_mapping_keys++;
-       keyconf->hw_key_idx = HW_KEY_DYNAMIC;
-
-       switch (keyconf->cipher) {
-       case WLAN_CIPHER_SUITE_CCMP:
-               ret =
-                   il4965_set_ccmp_dynamic_key_info(il, keyconf, sta_id);
-               break;
-       case WLAN_CIPHER_SUITE_TKIP:
-               ret =
-                   il4965_set_tkip_dynamic_key_info(il, keyconf, sta_id);
-               break;
-       case WLAN_CIPHER_SUITE_WEP40:
-       case WLAN_CIPHER_SUITE_WEP104:
-               ret = il4965_set_wep_dynamic_key_info(il, keyconf, sta_id);
-               break;
-       default:
-               IL_ERR("Unknown alg: %s cipher = %x\n", __func__,
-                      keyconf->cipher);
-               ret = -EINVAL;
-       }
-
-       D_WEP("Set dynamic key: cipher=%x len=%d idx=%d sta=%d ret=%d\n",
-             keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
-
-       return ret;
-}
-
-/**
- * il4965_alloc_bcast_station - add broadcast station into driver's station table.
- *
- * This adds the broadcast station into the driver's station table
- * and marks it driver active, so that it will be restored to the
- * device at the next best time.
- */
-int
-il4965_alloc_bcast_station(struct il_priv *il)
-{
-       struct il_link_quality_cmd *link_cmd;
-       unsigned long flags;
-       u8 sta_id;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       sta_id = il_prep_station(il, il_bcast_addr, false, NULL);
-       if (sta_id == IL_INVALID_STATION) {
-               IL_ERR("Unable to prepare broadcast station\n");
-               spin_unlock_irqrestore(&il->sta_lock, flags);
-
-               return -EINVAL;
-       }
-
-       il->stations[sta_id].used |= IL_STA_DRIVER_ACTIVE;
-       il->stations[sta_id].used |= IL_STA_BCAST;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       link_cmd = il4965_sta_alloc_lq(il, sta_id);
-       if (!link_cmd) {
-               IL_ERR
-                   ("Unable to initialize rate scaling for bcast station.\n");
-               return -ENOMEM;
-       }
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].lq = link_cmd;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return 0;
-}
-
-/**
- * il4965_update_bcast_station - update broadcast station's LQ command
- *
- * Only used by iwl4965. Placed here to have all bcast station management
- * code together.
- */
-static int
-il4965_update_bcast_station(struct il_priv *il)
-{
-       unsigned long flags;
-       struct il_link_quality_cmd *link_cmd;
-       u8 sta_id = il->hw_params.bcast_id;
-
-       link_cmd = il4965_sta_alloc_lq(il, sta_id);
-       if (!link_cmd) {
-               IL_ERR("Unable to initialize rate scaling for bcast sta.\n");
-               return -ENOMEM;
-       }
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       if (il->stations[sta_id].lq)
-               kfree(il->stations[sta_id].lq);
-       else
-               D_INFO("Bcast sta rate scaling has not been initialized.\n");
-       il->stations[sta_id].lq = link_cmd;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return 0;
-}
-
-int
-il4965_update_bcast_stations(struct il_priv *il)
-{
-       return il4965_update_bcast_station(il);
-}
-
-/**
- * il4965_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
- */
-int
-il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid)
-{
-       unsigned long flags;
-       struct il_addsta_cmd sta_cmd;
-
-       lockdep_assert_held(&il->mutex);
-
-       /* Remove "disable" flag, to enable Tx for this TID */
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
-       il->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-}
-
-int
-il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta, int tid,
-                       u16 ssn)
-{
-       unsigned long flags;
-       int sta_id;
-       struct il_addsta_cmd sta_cmd;
-
-       lockdep_assert_held(&il->mutex);
-
-       sta_id = il_sta_id(sta);
-       if (sta_id == IL_INVALID_STATION)
-               return -ENXIO;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].sta.station_flags_msk = 0;
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
-       il->stations[sta_id].sta.add_immediate_ba_tid = (u8) tid;
-       il->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-}
-
-int
-il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta, int tid)
-{
-       unsigned long flags;
-       int sta_id;
-       struct il_addsta_cmd sta_cmd;
-
-       lockdep_assert_held(&il->mutex);
-
-       sta_id = il_sta_id(sta);
-       if (sta_id == IL_INVALID_STATION) {
-               IL_ERR("Invalid station for AGG tid %d\n", tid);
-               return -ENXIO;
-       }
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].sta.station_flags_msk = 0;
-       il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
-       il->stations[sta_id].sta.remove_immediate_ba_tid = (u8) tid;
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-}
-
-void
-il4965_sta_modify_sleep_tx_count(struct il_priv *il, int sta_id, int cnt)
-{
-       unsigned long flags;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       il->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
-       il->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
-       il->stations[sta_id].sta.sta.modify_mask =
-           STA_MODIFY_SLEEP_TX_COUNT_MSK;
-       il->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
-       il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
-       il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-}
-
-void
-il4965_update_chain_flags(struct il_priv *il)
-{
-       if (il->ops->set_rxon_chain) {
-               il->ops->set_rxon_chain(il);
-               if (il->active.rx_chain != il->staging.rx_chain)
-                       il_commit_rxon(il);
-       }
-}
-
-static void
-il4965_clear_free_frames(struct il_priv *il)
-{
-       struct list_head *element;
-
-       D_INFO("%d frames on pre-allocated heap on clear.\n", il->frames_count);
-
-       while (!list_empty(&il->free_frames)) {
-               element = il->free_frames.next;
-               list_del(element);
-               kfree(list_entry(element, struct il_frame, list));
-               il->frames_count--;
-       }
-
-       if (il->frames_count) {
-               IL_WARN("%d frames still in use.  Did we lose one?\n",
-                       il->frames_count);
-               il->frames_count = 0;
-       }
-}
-
-static struct il_frame *
-il4965_get_free_frame(struct il_priv *il)
-{
-       struct il_frame *frame;
-       struct list_head *element;
-       if (list_empty(&il->free_frames)) {
-               frame = kzalloc(sizeof(*frame), GFP_KERNEL);
-               if (!frame) {
-                       IL_ERR("Could not allocate frame!\n");
-                       return NULL;
-               }
-
-               il->frames_count++;
-               return frame;
-       }
-
-       element = il->free_frames.next;
-       list_del(element);
-       return list_entry(element, struct il_frame, list);
-}
-
-static void
-il4965_free_frame(struct il_priv *il, struct il_frame *frame)
-{
-       memset(frame, 0, sizeof(*frame));
-       list_add(&frame->list, &il->free_frames);
-}
-
-static u32
-il4965_fill_beacon_frame(struct il_priv *il, struct ieee80211_hdr *hdr,
-                        int left)
-{
-       lockdep_assert_held(&il->mutex);
-
-       if (!il->beacon_skb)
-               return 0;
-
-       if (il->beacon_skb->len > left)
-               return 0;
-
-       memcpy(hdr, il->beacon_skb->data, il->beacon_skb->len);
-
-       return il->beacon_skb->len;
-}
-
-/* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
-static void
-il4965_set_beacon_tim(struct il_priv *il,
-                     struct il_tx_beacon_cmd *tx_beacon_cmd, u8 * beacon,
-                     u32 frame_size)
-{
-       u16 tim_idx;
-       struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
-
-       /*
-        * The idx is relative to frame start but we start looking at the
-        * variable-length part of the beacon.
-        */
-       tim_idx = mgmt->u.beacon.variable - beacon;
-
-       /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
-       while ((tim_idx < (frame_size - 2)) &&
-              (beacon[tim_idx] != WLAN_EID_TIM))
-               tim_idx += beacon[tim_idx + 1] + 2;
-
-       /* If TIM field was found, set variables */
-       if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
-               tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
-               tx_beacon_cmd->tim_size = beacon[tim_idx + 1];
-       } else
-               IL_WARN("Unable to find TIM Element in beacon\n");
-}
-
-static unsigned int
-il4965_hw_get_beacon_cmd(struct il_priv *il, struct il_frame *frame)
-{
-       struct il_tx_beacon_cmd *tx_beacon_cmd;
-       u32 frame_size;
-       u32 rate_flags;
-       u32 rate;
-       /*
-        * We have to set up the TX command, the TX Beacon command, and the
-        * beacon contents.
-        */
-
-       lockdep_assert_held(&il->mutex);
-
-       if (!il->beacon_enabled) {
-               IL_ERR("Trying to build beacon without beaconing enabled\n");
-               return 0;
-       }
-
-       /* Initialize memory */
-       tx_beacon_cmd = &frame->u.beacon;
-       memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
-
-       /* Set up TX beacon contents */
-       frame_size =
-           il4965_fill_beacon_frame(il, tx_beacon_cmd->frame,
-                                    sizeof(frame->u) - sizeof(*tx_beacon_cmd));
-       if (WARN_ON_ONCE(frame_size > MAX_MPDU_SIZE))
-               return 0;
-       if (!frame_size)
-               return 0;
-
-       /* Set up TX command fields */
-       tx_beacon_cmd->tx.len = cpu_to_le16((u16) frame_size);
-       tx_beacon_cmd->tx.sta_id = il->hw_params.bcast_id;
-       tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
-       tx_beacon_cmd->tx.tx_flags =
-           TX_CMD_FLG_SEQ_CTL_MSK | TX_CMD_FLG_TSF_MSK |
-           TX_CMD_FLG_STA_RATE_MSK;
-
-       /* Set up TX beacon command fields */
-       il4965_set_beacon_tim(il, tx_beacon_cmd, (u8 *) tx_beacon_cmd->frame,
-                             frame_size);
-
-       /* Set up packet rate and flags */
-       rate = il_get_lowest_plcp(il);
-       il4965_toggle_tx_ant(il, &il->mgmt_tx_ant, il->hw_params.valid_tx_ant);
-       rate_flags = BIT(il->mgmt_tx_ant) << RATE_MCS_ANT_POS;
-       if ((rate >= IL_FIRST_CCK_RATE) && (rate <= IL_LAST_CCK_RATE))
-               rate_flags |= RATE_MCS_CCK_MSK;
-       tx_beacon_cmd->tx.rate_n_flags = cpu_to_le32(rate | rate_flags);
-
-       return sizeof(*tx_beacon_cmd) + frame_size;
-}
-
-int
-il4965_send_beacon_cmd(struct il_priv *il)
-{
-       struct il_frame *frame;
-       unsigned int frame_size;
-       int rc;
-
-       frame = il4965_get_free_frame(il);
-       if (!frame) {
-               IL_ERR("Could not obtain free frame buffer for beacon "
-                      "command.\n");
-               return -ENOMEM;
-       }
-
-       frame_size = il4965_hw_get_beacon_cmd(il, frame);
-       if (!frame_size) {
-               IL_ERR("Error configuring the beacon command\n");
-               il4965_free_frame(il, frame);
-               return -EINVAL;
-       }
-
-       rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size, &frame->u.cmd[0]);
-
-       il4965_free_frame(il, frame);
-
-       return rc;
-}
-
-static inline dma_addr_t
-il4965_tfd_tb_get_addr(struct il_tfd *tfd, u8 idx)
-{
-       struct il_tfd_tb *tb = &tfd->tbs[idx];
-
-       dma_addr_t addr = get_unaligned_le32(&tb->lo);
-       if (sizeof(dma_addr_t) > sizeof(u32))
-               addr |=
-                   ((dma_addr_t) (le16_to_cpu(tb->hi_n_len) & 0xF) << 16) <<
-                   16;
-
-       return addr;
-}
-
-static inline u16
-il4965_tfd_tb_get_len(struct il_tfd *tfd, u8 idx)
-{
-       struct il_tfd_tb *tb = &tfd->tbs[idx];
-
-       return le16_to_cpu(tb->hi_n_len) >> 4;
-}
-
-static inline void
-il4965_tfd_set_tb(struct il_tfd *tfd, u8 idx, dma_addr_t addr, u16 len)
-{
-       struct il_tfd_tb *tb = &tfd->tbs[idx];
-       u16 hi_n_len = len << 4;
-
-       put_unaligned_le32(addr, &tb->lo);
-       if (sizeof(dma_addr_t) > sizeof(u32))
-               hi_n_len |= ((addr >> 16) >> 16) & 0xF;
-
-       tb->hi_n_len = cpu_to_le16(hi_n_len);
-
-       tfd->num_tbs = idx + 1;
-}
-
-static inline u8
-il4965_tfd_get_num_tbs(struct il_tfd *tfd)
-{
-       return tfd->num_tbs & 0x1f;
-}
-
-/**
- * il4965_hw_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
- * @il - driver ilate data
- * @txq - tx queue
- *
- * Does NOT advance any TFD circular buffer read/write idxes
- * Does NOT free the TFD itself (which is within circular buffer)
- */
-void
-il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
-{
-       struct il_tfd *tfd_tmp = (struct il_tfd *)txq->tfds;
-       struct il_tfd *tfd;
-       struct pci_dev *dev = il->pci_dev;
-       int idx = txq->q.read_ptr;
-       int i;
-       int num_tbs;
-
-       tfd = &tfd_tmp[idx];
-
-       /* Sanity check on number of chunks */
-       num_tbs = il4965_tfd_get_num_tbs(tfd);
-
-       if (num_tbs >= IL_NUM_OF_TBS) {
-               IL_ERR("Too many chunks: %i\n", num_tbs);
-               /* @todo issue fatal error, it is quite serious situation */
-               return;
-       }
-
-       /* Unmap tx_cmd */
-       if (num_tbs)
-               pci_unmap_single(dev, dma_unmap_addr(&txq->meta[idx], mapping),
-                                dma_unmap_len(&txq->meta[idx], len),
-                                PCI_DMA_BIDIRECTIONAL);
-
-       /* Unmap chunks, if any. */
-       for (i = 1; i < num_tbs; i++)
-               pci_unmap_single(dev, il4965_tfd_tb_get_addr(tfd, i),
-                                il4965_tfd_tb_get_len(tfd, i),
-                                PCI_DMA_TODEVICE);
-
-       /* free SKB */
-       if (txq->skbs) {
-               struct sk_buff *skb = txq->skbs[txq->q.read_ptr];
-
-               /* can be called from irqs-disabled context */
-               if (skb) {
-                       dev_kfree_skb_any(skb);
-                       txq->skbs[txq->q.read_ptr] = NULL;
-               }
-       }
-}
-
-int
-il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
-                               dma_addr_t addr, u16 len, u8 reset, u8 pad)
-{
-       struct il_queue *q;
-       struct il_tfd *tfd, *tfd_tmp;
-       u32 num_tbs;
-
-       q = &txq->q;
-       tfd_tmp = (struct il_tfd *)txq->tfds;
-       tfd = &tfd_tmp[q->write_ptr];
-
-       if (reset)
-               memset(tfd, 0, sizeof(*tfd));
-
-       num_tbs = il4965_tfd_get_num_tbs(tfd);
-
-       /* Each TFD can point to a maximum 20 Tx buffers */
-       if (num_tbs >= IL_NUM_OF_TBS) {
-               IL_ERR("Error can not send more than %d chunks\n",
-                      IL_NUM_OF_TBS);
-               return -EINVAL;
-       }
-
-       BUG_ON(addr & ~DMA_BIT_MASK(36));
-       if (unlikely(addr & ~IL_TX_DMA_MASK))
-               IL_ERR("Unaligned address = %llx\n", (unsigned long long)addr);
-
-       il4965_tfd_set_tb(tfd, num_tbs, addr, len);
-
-       return 0;
-}
-
-/*
- * Tell nic where to find circular buffer of Tx Frame Descriptors for
- * given Tx queue, and enable the DMA channel used for that queue.
- *
- * 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
- * channels supported in hardware.
- */
-int
-il4965_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq)
-{
-       int txq_id = txq->q.id;
-
-       /* Circular buffer (TFD queue in DRAM) physical base address */
-       il_wr(il, FH49_MEM_CBBC_QUEUE(txq_id), txq->q.dma_addr >> 8);
-
-       return 0;
-}
-
-/******************************************************************************
- *
- * Generic RX handler implementations
- *
- ******************************************************************************/
-static void
-il4965_hdl_alive(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_alive_resp *palive;
-       struct delayed_work *pwork;
-
-       palive = &pkt->u.alive_frame;
-
-       D_INFO("Alive ucode status 0x%08X revision " "0x%01X 0x%01X\n",
-              palive->is_valid, palive->ver_type, palive->ver_subtype);
-
-       if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
-               D_INFO("Initialization Alive received.\n");
-               memcpy(&il->card_alive_init, &pkt->u.alive_frame,
-                      sizeof(struct il_init_alive_resp));
-               pwork = &il->init_alive_start;
-       } else {
-               D_INFO("Runtime Alive received.\n");
-               memcpy(&il->card_alive, &pkt->u.alive_frame,
-                      sizeof(struct il_alive_resp));
-               pwork = &il->alive_start;
-       }
-
-       /* We delay the ALIVE response by 5ms to
-        * give the HW RF Kill time to activate... */
-       if (palive->is_valid == UCODE_VALID_OK)
-               queue_delayed_work(il->workqueue, pwork, msecs_to_jiffies(5));
-       else
-               IL_WARN("uCode did not respond OK.\n");
-}
-
-/**
- * il4965_bg_stats_periodic - Timer callback to queue stats
- *
- * This callback is provided in order to send a stats request.
- *
- * This timer function is continually reset to execute within
- * 60 seconds since the last N_STATS was received.  We need to
- * ensure we receive the stats in order to update the temperature
- * used for calibrating the TXPOWER.
- */
-static void
-il4965_bg_stats_periodic(unsigned long data)
-{
-       struct il_priv *il = (struct il_priv *)data;
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       /* dont send host command if rf-kill is on */
-       if (!il_is_ready_rf(il))
-               return;
-
-       il_send_stats_request(il, CMD_ASYNC, false);
-}
-
-static void
-il4965_hdl_beacon(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il4965_beacon_notif *beacon =
-           (struct il4965_beacon_notif *)pkt->u.raw;
-#ifdef CONFIG_IWLEGACY_DEBUG
-       u8 rate = il4965_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
-
-       D_RX("beacon status %x retries %d iss %d tsf:0x%.8x%.8x rate %d\n",
-            le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
-            beacon->beacon_notify_hdr.failure_frame,
-            le32_to_cpu(beacon->ibss_mgr_status),
-            le32_to_cpu(beacon->high_tsf), le32_to_cpu(beacon->low_tsf), rate);
-#endif
-       il->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
-}
-
-static void
-il4965_perform_ct_kill_task(struct il_priv *il)
-{
-       unsigned long flags;
-
-       D_POWER("Stop all queues\n");
-
-       if (il->mac80211_registered)
-               ieee80211_stop_queues(il->hw);
-
-       _il_wr(il, CSR_UCODE_DRV_GP1_SET,
-              CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
-       _il_rd(il, CSR_UCODE_DRV_GP1);
-
-       spin_lock_irqsave(&il->reg_lock, flags);
-       if (likely(_il_grab_nic_access(il)))
-               _il_release_nic_access(il);
-       spin_unlock_irqrestore(&il->reg_lock, flags);
-}
-
-/* Handle notification from uCode that card's power state is changing
- * due to software, hardware, or critical temperature RFKILL */
-static void
-il4965_hdl_card_state(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
-       unsigned long status = il->status;
-
-       D_RF_KILL("Card state received: HW:%s SW:%s CT:%s\n",
-                 (flags & HW_CARD_DISABLED) ? "Kill" : "On",
-                 (flags & SW_CARD_DISABLED) ? "Kill" : "On",
-                 (flags & CT_CARD_DISABLED) ? "Reached" : "Not reached");
-
-       if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED | CT_CARD_DISABLED)) {
-
-               _il_wr(il, CSR_UCODE_DRV_GP1_SET,
-                      CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
-
-               il_wr(il, HBUS_TARG_MBX_C, HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
-
-               if (!(flags & RXON_CARD_DISABLED)) {
-                       _il_wr(il, CSR_UCODE_DRV_GP1_CLR,
-                              CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
-                       il_wr(il, HBUS_TARG_MBX_C,
-                             HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
-               }
-       }
-
-       if (flags & CT_CARD_DISABLED)
-               il4965_perform_ct_kill_task(il);
-
-       if (flags & HW_CARD_DISABLED)
-               set_bit(S_RFKILL, &il->status);
-       else
-               clear_bit(S_RFKILL, &il->status);
-
-       if (!(flags & RXON_CARD_DISABLED))
-               il_scan_cancel(il);
-
-       if ((test_bit(S_RFKILL, &status) !=
-            test_bit(S_RFKILL, &il->status)))
-               wiphy_rfkill_set_hw_state(il->hw->wiphy,
-                                         test_bit(S_RFKILL, &il->status));
-       else
-               wake_up(&il->wait_command_queue);
-}
-
-/**
- * il4965_setup_handlers - Initialize Rx handler callbacks
- *
- * Setup the RX handlers for each of the reply types sent from the uCode
- * to the host.
- *
- * This function chains into the hardware specific files for them to setup
- * any hardware specific handlers as well.
- */
-static void
-il4965_setup_handlers(struct il_priv *il)
-{
-       il->handlers[N_ALIVE] = il4965_hdl_alive;
-       il->handlers[N_ERROR] = il_hdl_error;
-       il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;
-       il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;
-       il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;
-       il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;
-       il->handlers[N_BEACON] = il4965_hdl_beacon;
-
-       /*
-        * The same handler is used for both the REPLY to a discrete
-        * stats request from the host as well as for the periodic
-        * stats notifications (after received beacons) from the uCode.
-        */
-       il->handlers[C_STATS] = il4965_hdl_c_stats;
-       il->handlers[N_STATS] = il4965_hdl_stats;
-
-       il_setup_rx_scan_handlers(il);
-
-       /* status change handler */
-       il->handlers[N_CARD_STATE] = il4965_hdl_card_state;
-
-       il->handlers[N_MISSED_BEACONS] = il4965_hdl_missed_beacon;
-       /* Rx handlers */
-       il->handlers[N_RX_PHY] = il4965_hdl_rx_phy;
-       il->handlers[N_RX_MPDU] = il4965_hdl_rx;
-       il->handlers[N_RX] = il4965_hdl_rx;
-       /* block ack */
-       il->handlers[N_COMPRESSED_BA] = il4965_hdl_compressed_ba;
-       /* Tx response */
-       il->handlers[C_TX] = il4965_hdl_tx;
-}
-
-/**
- * il4965_rx_handle - Main entry function for receiving responses from uCode
- *
- * Uses the il->handlers callback function array to invoke
- * the appropriate handlers, including command responses,
- * frame-received notifications, and other notifications.
- */
-void
-il4965_rx_handle(struct il_priv *il)
-{
-       struct il_rx_buf *rxb;
-       struct il_rx_pkt *pkt;
-       struct il_rx_queue *rxq = &il->rxq;
-       u32 r, i;
-       int reclaim;
-       unsigned long flags;
-       u8 fill_rx = 0;
-       u32 count = 8;
-       int total_empty;
-
-       /* uCode's read idx (stored in shared DRAM) indicates the last Rx
-        * buffer that the driver may process (last buffer filled by ucode). */
-       r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
-       i = rxq->read;
-
-       /* Rx interrupt, but nothing sent from uCode */
-       if (i == r)
-               D_RX("r = %d, i = %d\n", r, i);
-
-       /* calculate total frames need to be restock after handling RX */
-       total_empty = r - rxq->write_actual;
-       if (total_empty < 0)
-               total_empty += RX_QUEUE_SIZE;
-
-       if (total_empty > (RX_QUEUE_SIZE / 2))
-               fill_rx = 1;
-
-       while (i != r) {
-               int len;
-
-               rxb = rxq->queue[i];
-
-               /* If an RXB doesn't have a Rx queue slot associated with it,
-                * then a bug has been introduced in the queue refilling
-                * routines -- catch it here */
-               BUG_ON(rxb == NULL);
-
-               rxq->queue[i] = NULL;
-
-               pci_unmap_page(il->pci_dev, rxb->page_dma,
-                              PAGE_SIZE << il->hw_params.rx_page_order,
-                              PCI_DMA_FROMDEVICE);
-               pkt = rxb_addr(rxb);
-
-               len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
-               len += sizeof(u32);     /* account for status word */
-
-               reclaim = il_need_reclaim(il, pkt);
-
-               /* Based on type of command response or notification,
-                *   handle those that need handling via function in
-                *   handlers table.  See il4965_setup_handlers() */
-               if (il->handlers[pkt->hdr.cmd]) {
-                       D_RX("r = %d, i = %d, %s, 0x%02x\n", r, i,
-                            il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
-                       il->isr_stats.handlers[pkt->hdr.cmd]++;
-                       il->handlers[pkt->hdr.cmd] (il, rxb);
-               } else {
-                       /* No handling needed */
-                       D_RX("r %d i %d No handler needed for %s, 0x%02x\n", r,
-                            i, il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
-               }
-
-               /*
-                * XXX: After here, we should always check rxb->page
-                * against NULL before touching it or its virtual
-                * memory (pkt). Because some handler might have
-                * already taken or freed the pages.
-                */
-
-               if (reclaim) {
-                       /* Invoke any callbacks, transfer the buffer to caller,
-                        * and fire off the (possibly) blocking il_send_cmd()
-                        * as we reclaim the driver command queue */
-                       if (rxb->page)
-                               il_tx_cmd_complete(il, rxb);
-                       else
-                               IL_WARN("Claim null rxb?\n");
-               }
-
-               /* Reuse the page if possible. For notification packets and
-                * SKBs that fail to Rx correctly, add them back into the
-                * rx_free list for reuse later. */
-               spin_lock_irqsave(&rxq->lock, flags);
-               if (rxb->page != NULL) {
-                       rxb->page_dma =
-                           pci_map_page(il->pci_dev, rxb->page, 0,
-                                        PAGE_SIZE << il->hw_params.
-                                        rx_page_order, PCI_DMA_FROMDEVICE);
-
-                       if (unlikely(pci_dma_mapping_error(il->pci_dev,
-                                                          rxb->page_dma))) {
-                               __il_free_pages(il, rxb->page);
-                               rxb->page = NULL;
-                               list_add_tail(&rxb->list, &rxq->rx_used);
-                       } else {
-                               list_add_tail(&rxb->list, &rxq->rx_free);
-                               rxq->free_count++;
-                       }
-               } else
-                       list_add_tail(&rxb->list, &rxq->rx_used);
-
-               spin_unlock_irqrestore(&rxq->lock, flags);
-
-               i = (i + 1) & RX_QUEUE_MASK;
-               /* If there are a lot of unused frames,
-                * restock the Rx queue so ucode wont assert. */
-               if (fill_rx) {
-                       count++;
-                       if (count >= 8) {
-                               rxq->read = i;
-                               il4965_rx_replenish_now(il);
-                               count = 0;
-                       }
-               }
-       }
-
-       /* Backtrack one entry */
-       rxq->read = i;
-       if (fill_rx)
-               il4965_rx_replenish_now(il);
-       else
-               il4965_rx_queue_restock(il);
-}
-
-/* call this function to flush any scheduled tasklet */
-static inline void
-il4965_synchronize_irq(struct il_priv *il)
-{
-       /* wait to make sure we flush pending tasklet */
-       synchronize_irq(il->pci_dev->irq);
-       tasklet_kill(&il->irq_tasklet);
-}
-
-static void
-il4965_irq_tasklet(struct il_priv *il)
-{
-       u32 inta, handled = 0;
-       u32 inta_fh;
-       unsigned long flags;
-       u32 i;
-#ifdef CONFIG_IWLEGACY_DEBUG
-       u32 inta_mask;
-#endif
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Ack/clear/reset pending uCode interrupts.
-        * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
-        *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
-       inta = _il_rd(il, CSR_INT);
-       _il_wr(il, CSR_INT, inta);
-
-       /* Ack/clear/reset pending flow-handler (DMA) interrupts.
-        * Any new interrupts that happen after this, either while we're
-        * in this tasklet, or later, will show up in next ISR/tasklet. */
-       inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
-       _il_wr(il, CSR_FH_INT_STATUS, inta_fh);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (il_get_debug_level(il) & IL_DL_ISR) {
-               /* just for debug */
-               inta_mask = _il_rd(il, CSR_INT_MASK);
-               D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta,
-                     inta_mask, inta_fh);
-       }
-#endif
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       /* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
-        * atomic, make sure that inta covers all the interrupts that
-        * we've discovered, even if FH interrupt came in just after
-        * reading CSR_INT. */
-       if (inta_fh & CSR49_FH_INT_RX_MASK)
-               inta |= CSR_INT_BIT_FH_RX;
-       if (inta_fh & CSR49_FH_INT_TX_MASK)
-               inta |= CSR_INT_BIT_FH_TX;
-
-       /* Now service all interrupt bits discovered above. */
-       if (inta & CSR_INT_BIT_HW_ERR) {
-               IL_ERR("Hardware error detected.  Restarting.\n");
-
-               /* Tell the device to stop sending interrupts */
-               il_disable_interrupts(il);
-
-               il->isr_stats.hw++;
-               il_irq_handle_error(il);
-
-               handled |= CSR_INT_BIT_HW_ERR;
-
-               return;
-       }
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (il_get_debug_level(il) & (IL_DL_ISR)) {
-               /* NIC fires this, but we don't use it, redundant with WAKEUP */
-               if (inta & CSR_INT_BIT_SCD) {
-                       D_ISR("Scheduler finished to transmit "
-                             "the frame/frames.\n");
-                       il->isr_stats.sch++;
-               }
-
-               /* Alive notification via Rx interrupt will do the real work */
-               if (inta & CSR_INT_BIT_ALIVE) {
-                       D_ISR("Alive interrupt\n");
-                       il->isr_stats.alive++;
-               }
-       }
-#endif
-       /* Safely ignore these bits for debug checks below */
-       inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
-
-       /* HW RF KILL switch toggled */
-       if (inta & CSR_INT_BIT_RF_KILL) {
-               int hw_rf_kill = 0;
-
-               if (!(_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
-                       hw_rf_kill = 1;
-
-               IL_WARN("RF_KILL bit toggled to %s.\n",
-                       hw_rf_kill ? "disable radio" : "enable radio");
-
-               il->isr_stats.rfkill++;
-
-               /* driver only loads ucode once setting the interface up.
-                * the driver allows loading the ucode even if the radio
-                * is killed. Hence update the killswitch state here. The
-                * rfkill handler will care about restarting if needed.
-                */
-               if (hw_rf_kill) {
-                       set_bit(S_RFKILL, &il->status);
-               } else {
-                       clear_bit(S_RFKILL, &il->status);
-                       il_force_reset(il, true);
-               }
-               wiphy_rfkill_set_hw_state(il->hw->wiphy, hw_rf_kill);
-
-               handled |= CSR_INT_BIT_RF_KILL;
-       }
-
-       /* Chip got too hot and stopped itself */
-       if (inta & CSR_INT_BIT_CT_KILL) {
-               IL_ERR("Microcode CT kill error detected.\n");
-               il->isr_stats.ctkill++;
-               handled |= CSR_INT_BIT_CT_KILL;
-       }
-
-       /* Error detected by uCode */
-       if (inta & CSR_INT_BIT_SW_ERR) {
-               IL_ERR("Microcode SW error detected. " " Restarting 0x%X.\n",
-                      inta);
-               il->isr_stats.sw++;
-               il_irq_handle_error(il);
-               handled |= CSR_INT_BIT_SW_ERR;
-       }
-
-       /*
-        * uCode wakes up after power-down sleep.
-        * Tell device about any new tx or host commands enqueued,
-        * and about any Rx buffers made available while asleep.
-        */
-       if (inta & CSR_INT_BIT_WAKEUP) {
-               D_ISR("Wakeup interrupt\n");
-               il_rx_queue_update_write_ptr(il, &il->rxq);
-               for (i = 0; i < il->hw_params.max_txq_num; i++)
-                       il_txq_update_write_ptr(il, &il->txq[i]);
-               il->isr_stats.wakeup++;
-               handled |= CSR_INT_BIT_WAKEUP;
-       }
-
-       /* All uCode command responses, including Tx command responses,
-        * Rx "responses" (frame-received notification), and other
-        * notifications from uCode come through here*/
-       if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
-               il4965_rx_handle(il);
-               il->isr_stats.rx++;
-               handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
-       }
-
-       /* This "Tx" DMA channel is used only for loading uCode */
-       if (inta & CSR_INT_BIT_FH_TX) {
-               D_ISR("uCode load interrupt\n");
-               il->isr_stats.tx++;
-               handled |= CSR_INT_BIT_FH_TX;
-               /* Wake up uCode load routine, now that load is complete */
-               il->ucode_write_complete = 1;
-               wake_up(&il->wait_command_queue);
-       }
-
-       if (inta & ~handled) {
-               IL_ERR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
-               il->isr_stats.unhandled++;
-       }
-
-       if (inta & ~(il->inta_mask)) {
-               IL_WARN("Disabled INTA bits 0x%08x were pending\n",
-                       inta & ~il->inta_mask);
-               IL_WARN("   with FH49_INT = 0x%08x\n", inta_fh);
-       }
-
-       /* Re-enable all interrupts */
-       /* only Re-enable if disabled by irq */
-       if (test_bit(S_INT_ENABLED, &il->status))
-               il_enable_interrupts(il);
-       /* Re-enable RF_KILL if it occurred */
-       else if (handled & CSR_INT_BIT_RF_KILL)
-               il_enable_rfkill_int(il);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (il_get_debug_level(il) & (IL_DL_ISR)) {
-               inta = _il_rd(il, CSR_INT);
-               inta_mask = _il_rd(il, CSR_INT_MASK);
-               inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
-               D_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
-                     "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
-       }
-#endif
-}
-
-/*****************************************************************************
- *
- * sysfs attributes
- *
- *****************************************************************************/
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-
-/*
- * The following adds a new attribute to the sysfs representation
- * of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
- * used for controlling the debug level.
- *
- * See the level definitions in iwl for details.
- *
- * The debug_level being managed using sysfs below is a per device debug
- * level that is used instead of the global debug level if it (the per
- * device debug level) is set.
- */
-static ssize_t
-il4965_show_debug_level(struct device *d, struct device_attribute *attr,
-                       char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       return sprintf(buf, "0x%08X\n", il_get_debug_level(il));
-}
-
-static ssize_t
-il4965_store_debug_level(struct device *d, struct device_attribute *attr,
-                        const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       unsigned long val;
-       int ret;
-
-       ret = kstrtoul(buf, 0, &val);
-       if (ret)
-               IL_ERR("%s is not in hex or decimal form.\n", buf);
-       else
-               il->debug_level = val;
-
-       return strnlen(buf, count);
-}
-
-static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO, il4965_show_debug_level,
-                  il4965_store_debug_level);
-
-#endif /* CONFIG_IWLEGACY_DEBUG */
-
-static ssize_t
-il4965_show_temperature(struct device *d, struct device_attribute *attr,
-                       char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-
-       if (!il_is_alive(il))
-               return -EAGAIN;
-
-       return sprintf(buf, "%d\n", il->temperature);
-}
-
-static DEVICE_ATTR(temperature, S_IRUGO, il4965_show_temperature, NULL);
-
-static ssize_t
-il4965_show_tx_power(struct device *d, struct device_attribute *attr, char *buf)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-
-       if (!il_is_ready_rf(il))
-               return sprintf(buf, "off\n");
-       else
-               return sprintf(buf, "%d\n", il->tx_power_user_lmt);
-}
-
-static ssize_t
-il4965_store_tx_power(struct device *d, struct device_attribute *attr,
-                     const char *buf, size_t count)
-{
-       struct il_priv *il = dev_get_drvdata(d);
-       unsigned long val;
-       int ret;
-
-       ret = kstrtoul(buf, 10, &val);
-       if (ret)
-               IL_INFO("%s is not in decimal form.\n", buf);
-       else {
-               ret = il_set_tx_power(il, val, false);
-               if (ret)
-                       IL_ERR("failed setting tx power (0x%08x).\n", ret);
-               else
-                       ret = count;
-       }
-       return ret;
-}
-
-static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, il4965_show_tx_power,
-                  il4965_store_tx_power);
-
-static struct attribute *il_sysfs_entries[] = {
-       &dev_attr_temperature.attr,
-       &dev_attr_tx_power.attr,
-#ifdef CONFIG_IWLEGACY_DEBUG
-       &dev_attr_debug_level.attr,
-#endif
-       NULL
-};
-
-static struct attribute_group il_attribute_group = {
-       .name = NULL,           /* put in device directory */
-       .attrs = il_sysfs_entries,
-};
-
-/******************************************************************************
- *
- * uCode download functions
- *
- ******************************************************************************/
-
-static void
-il4965_dealloc_ucode_pci(struct il_priv *il)
-{
-       il_free_fw_desc(il->pci_dev, &il->ucode_code);
-       il_free_fw_desc(il->pci_dev, &il->ucode_data);
-       il_free_fw_desc(il->pci_dev, &il->ucode_data_backup);
-       il_free_fw_desc(il->pci_dev, &il->ucode_init);
-       il_free_fw_desc(il->pci_dev, &il->ucode_init_data);
-       il_free_fw_desc(il->pci_dev, &il->ucode_boot);
-}
-
-static void
-il4965_nic_start(struct il_priv *il)
-{
-       /* Remove all resets to allow NIC to operate */
-       _il_wr(il, CSR_RESET, 0);
-}
-
-static void il4965_ucode_callback(const struct firmware *ucode_raw,
-                                 void *context);
-static int il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length);
-
-static int __must_check
-il4965_request_firmware(struct il_priv *il, bool first)
-{
-       const char *name_pre = il->cfg->fw_name_pre;
-       char tag[8];
-
-       if (first) {
-               il->fw_idx = il->cfg->ucode_api_max;
-               sprintf(tag, "%d", il->fw_idx);
-       } else {
-               il->fw_idx--;
-               sprintf(tag, "%d", il->fw_idx);
-       }
-
-       if (il->fw_idx < il->cfg->ucode_api_min) {
-               IL_ERR("no suitable firmware found!\n");
-               return -ENOENT;
-       }
-
-       sprintf(il->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
-
-       D_INFO("attempting to load firmware '%s'\n", il->firmware_name);
-
-       return request_firmware_nowait(THIS_MODULE, 1, il->firmware_name,
-                                      &il->pci_dev->dev, GFP_KERNEL, il,
-                                      il4965_ucode_callback);
-}
-
-struct il4965_firmware_pieces {
-       const void *inst, *data, *init, *init_data, *boot;
-       size_t inst_size, data_size, init_size, init_data_size, boot_size;
-};
-
-static int
-il4965_load_firmware(struct il_priv *il, const struct firmware *ucode_raw,
-                    struct il4965_firmware_pieces *pieces)
-{
-       struct il_ucode_header *ucode = (void *)ucode_raw->data;
-       u32 api_ver, hdr_size;
-       const u8 *src;
-
-       il->ucode_ver = le32_to_cpu(ucode->ver);
-       api_ver = IL_UCODE_API(il->ucode_ver);
-
-       switch (api_ver) {
-       default:
-       case 0:
-       case 1:
-       case 2:
-               hdr_size = 24;
-               if (ucode_raw->size < hdr_size) {
-                       IL_ERR("File size too small!\n");
-                       return -EINVAL;
-               }
-               pieces->inst_size = le32_to_cpu(ucode->v1.inst_size);
-               pieces->data_size = le32_to_cpu(ucode->v1.data_size);
-               pieces->init_size = le32_to_cpu(ucode->v1.init_size);
-               pieces->init_data_size = le32_to_cpu(ucode->v1.init_data_size);
-               pieces->boot_size = le32_to_cpu(ucode->v1.boot_size);
-               src = ucode->v1.data;
-               break;
-       }
-
-       /* Verify size of file vs. image size info in file's header */
-       if (ucode_raw->size !=
-           hdr_size + pieces->inst_size + pieces->data_size +
-           pieces->init_size + pieces->init_data_size + pieces->boot_size) {
-
-               IL_ERR("uCode file size %d does not match expected size\n",
-                      (int)ucode_raw->size);
-               return -EINVAL;
-       }
-
-       pieces->inst = src;
-       src += pieces->inst_size;
-       pieces->data = src;
-       src += pieces->data_size;
-       pieces->init = src;
-       src += pieces->init_size;
-       pieces->init_data = src;
-       src += pieces->init_data_size;
-       pieces->boot = src;
-       src += pieces->boot_size;
-
-       return 0;
-}
-
-/**
- * il4965_ucode_callback - callback when firmware was loaded
- *
- * If loaded successfully, copies the firmware into buffers
- * for the card to fetch (via DMA).
- */
-static void
-il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
-{
-       struct il_priv *il = context;
-       struct il_ucode_header *ucode;
-       int err;
-       struct il4965_firmware_pieces pieces;
-       const unsigned int api_max = il->cfg->ucode_api_max;
-       const unsigned int api_min = il->cfg->ucode_api_min;
-       u32 api_ver;
-
-       u32 max_probe_length = 200;
-       u32 standard_phy_calibration_size =
-           IL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
-
-       memset(&pieces, 0, sizeof(pieces));
-
-       if (!ucode_raw) {
-               if (il->fw_idx <= il->cfg->ucode_api_max)
-                       IL_ERR("request for firmware file '%s' failed.\n",
-                              il->firmware_name);
-               goto try_again;
-       }
-
-       D_INFO("Loaded firmware file '%s' (%zd bytes).\n", il->firmware_name,
-              ucode_raw->size);
-
-       /* Make sure that we got at least the API version number */
-       if (ucode_raw->size < 4) {
-               IL_ERR("File size way too small!\n");
-               goto try_again;
-       }
-
-       /* Data from ucode file:  header followed by uCode images */
-       ucode = (struct il_ucode_header *)ucode_raw->data;
-
-       err = il4965_load_firmware(il, ucode_raw, &pieces);
-
-       if (err)
-               goto try_again;
-
-       api_ver = IL_UCODE_API(il->ucode_ver);
-
-       /*
-        * api_ver should match the api version forming part of the
-        * firmware filename ... but we don't check for that and only rely
-        * on the API version read from firmware header from here on forward
-        */
-       if (api_ver < api_min || api_ver > api_max) {
-               IL_ERR("Driver unable to support your firmware API. "
-                      "Driver supports v%u, firmware is v%u.\n", api_max,
-                      api_ver);
-               goto try_again;
-       }
-
-       if (api_ver != api_max)
-               IL_ERR("Firmware has old API version. Expected v%u, "
-                      "got v%u. New firmware can be obtained "
-                      "from http://www.intellinuxwireless.org.\n", api_max,
-                      api_ver);
-
-       IL_INFO("loaded firmware version %u.%u.%u.%u\n",
-               IL_UCODE_MAJOR(il->ucode_ver), IL_UCODE_MINOR(il->ucode_ver),
-               IL_UCODE_API(il->ucode_ver), IL_UCODE_SERIAL(il->ucode_ver));
-
-       snprintf(il->hw->wiphy->fw_version, sizeof(il->hw->wiphy->fw_version),
-                "%u.%u.%u.%u", IL_UCODE_MAJOR(il->ucode_ver),
-                IL_UCODE_MINOR(il->ucode_ver), IL_UCODE_API(il->ucode_ver),
-                IL_UCODE_SERIAL(il->ucode_ver));
-
-       /*
-        * For any of the failures below (before allocating pci memory)
-        * we will try to load a version with a smaller API -- maybe the
-        * user just got a corrupted version of the latest API.
-        */
-
-       D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver);
-       D_INFO("f/w package hdr runtime inst size = %Zd\n", pieces.inst_size);
-       D_INFO("f/w package hdr runtime data size = %Zd\n", pieces.data_size);
-       D_INFO("f/w package hdr init inst size = %Zd\n", pieces.init_size);
-       D_INFO("f/w package hdr init data size = %Zd\n", pieces.init_data_size);
-       D_INFO("f/w package hdr boot inst size = %Zd\n", pieces.boot_size);
-
-       /* Verify that uCode images will fit in card's SRAM */
-       if (pieces.inst_size > il->hw_params.max_inst_size) {
-               IL_ERR("uCode instr len %Zd too large to fit in\n",
-                      pieces.inst_size);
-               goto try_again;
-       }
-
-       if (pieces.data_size > il->hw_params.max_data_size) {
-               IL_ERR("uCode data len %Zd too large to fit in\n",
-                      pieces.data_size);
-               goto try_again;
-       }
-
-       if (pieces.init_size > il->hw_params.max_inst_size) {
-               IL_ERR("uCode init instr len %Zd too large to fit in\n",
-                      pieces.init_size);
-               goto try_again;
-       }
-
-       if (pieces.init_data_size > il->hw_params.max_data_size) {
-               IL_ERR("uCode init data len %Zd too large to fit in\n",
-                      pieces.init_data_size);
-               goto try_again;
-       }
-
-       if (pieces.boot_size > il->hw_params.max_bsm_size) {
-               IL_ERR("uCode boot instr len %Zd too large to fit in\n",
-                      pieces.boot_size);
-               goto try_again;
-       }
-
-       /* Allocate ucode buffers for card's bus-master loading ... */
-
-       /* Runtime instructions and 2 copies of data:
-        * 1) unmodified from disk
-        * 2) backup cache for save/restore during power-downs */
-       il->ucode_code.len = pieces.inst_size;
-       il_alloc_fw_desc(il->pci_dev, &il->ucode_code);
-
-       il->ucode_data.len = pieces.data_size;
-       il_alloc_fw_desc(il->pci_dev, &il->ucode_data);
-
-       il->ucode_data_backup.len = pieces.data_size;
-       il_alloc_fw_desc(il->pci_dev, &il->ucode_data_backup);
-
-       if (!il->ucode_code.v_addr || !il->ucode_data.v_addr ||
-           !il->ucode_data_backup.v_addr)
-               goto err_pci_alloc;
-
-       /* Initialization instructions and data */
-       if (pieces.init_size && pieces.init_data_size) {
-               il->ucode_init.len = pieces.init_size;
-               il_alloc_fw_desc(il->pci_dev, &il->ucode_init);
-
-               il->ucode_init_data.len = pieces.init_data_size;
-               il_alloc_fw_desc(il->pci_dev, &il->ucode_init_data);
-
-               if (!il->ucode_init.v_addr || !il->ucode_init_data.v_addr)
-                       goto err_pci_alloc;
-       }
-
-       /* Bootstrap (instructions only, no data) */
-       if (pieces.boot_size) {
-               il->ucode_boot.len = pieces.boot_size;
-               il_alloc_fw_desc(il->pci_dev, &il->ucode_boot);
-
-               if (!il->ucode_boot.v_addr)
-                       goto err_pci_alloc;
-       }
-
-       /* Now that we can no longer fail, copy information */
-
-       il->sta_key_max_num = STA_KEY_MAX_NUM;
-
-       /* Copy images into buffers for card's bus-master reads ... */
-
-       /* Runtime instructions (first block of data in file) */
-       D_INFO("Copying (but not loading) uCode instr len %Zd\n",
-              pieces.inst_size);
-       memcpy(il->ucode_code.v_addr, pieces.inst, pieces.inst_size);
-
-       D_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
-              il->ucode_code.v_addr, (u32) il->ucode_code.p_addr);
-
-       /*
-        * Runtime data
-        * NOTE:  Copy into backup buffer will be done in il_up()
-        */
-       D_INFO("Copying (but not loading) uCode data len %Zd\n",
-              pieces.data_size);
-       memcpy(il->ucode_data.v_addr, pieces.data, pieces.data_size);
-       memcpy(il->ucode_data_backup.v_addr, pieces.data, pieces.data_size);
-
-       /* Initialization instructions */
-       if (pieces.init_size) {
-               D_INFO("Copying (but not loading) init instr len %Zd\n",
-                      pieces.init_size);
-               memcpy(il->ucode_init.v_addr, pieces.init, pieces.init_size);
-       }
-
-       /* Initialization data */
-       if (pieces.init_data_size) {
-               D_INFO("Copying (but not loading) init data len %Zd\n",
-                      pieces.init_data_size);
-               memcpy(il->ucode_init_data.v_addr, pieces.init_data,
-                      pieces.init_data_size);
-       }
-
-       /* Bootstrap instructions */
-       D_INFO("Copying (but not loading) boot instr len %Zd\n",
-              pieces.boot_size);
-       memcpy(il->ucode_boot.v_addr, pieces.boot, pieces.boot_size);
-
-       /*
-        * figure out the offset of chain noise reset and gain commands
-        * base on the size of standard phy calibration commands table size
-        */
-       il->_4965.phy_calib_chain_noise_reset_cmd =
-           standard_phy_calibration_size;
-       il->_4965.phy_calib_chain_noise_gain_cmd =
-           standard_phy_calibration_size + 1;
-
-       /**************************************************
-        * This is still part of probe() in a sense...
-        *
-        * 9. Setup and register with mac80211 and debugfs
-        **************************************************/
-       err = il4965_mac_setup_register(il, max_probe_length);
-       if (err)
-               goto out_unbind;
-
-       err = il_dbgfs_register(il, DRV_NAME);
-       if (err)
-               IL_ERR("failed to create debugfs files. Ignoring error: %d\n",
-                      err);
-
-       err = sysfs_create_group(&il->pci_dev->dev.kobj, &il_attribute_group);
-       if (err) {
-               IL_ERR("failed to create sysfs device attributes\n");
-               goto out_unbind;
-       }
-
-       /* We have our copies now, allow OS release its copies */
-       release_firmware(ucode_raw);
-       complete(&il->_4965.firmware_loading_complete);
-       return;
-
-try_again:
-       /* try next, if any */
-       if (il4965_request_firmware(il, false))
-               goto out_unbind;
-       release_firmware(ucode_raw);
-       return;
-
-err_pci_alloc:
-       IL_ERR("failed to allocate pci memory\n");
-       il4965_dealloc_ucode_pci(il);
-out_unbind:
-       complete(&il->_4965.firmware_loading_complete);
-       device_release_driver(&il->pci_dev->dev);
-       release_firmware(ucode_raw);
-}
-
-static const char *const desc_lookup_text[] = {
-       "OK",
-       "FAIL",
-       "BAD_PARAM",
-       "BAD_CHECKSUM",
-       "NMI_INTERRUPT_WDG",
-       "SYSASSERT",
-       "FATAL_ERROR",
-       "BAD_COMMAND",
-       "HW_ERROR_TUNE_LOCK",
-       "HW_ERROR_TEMPERATURE",
-       "ILLEGAL_CHAN_FREQ",
-       "VCC_NOT_STBL",
-       "FH49_ERROR",
-       "NMI_INTERRUPT_HOST",
-       "NMI_INTERRUPT_ACTION_PT",
-       "NMI_INTERRUPT_UNKNOWN",
-       "UCODE_VERSION_MISMATCH",
-       "HW_ERROR_ABS_LOCK",
-       "HW_ERROR_CAL_LOCK_FAIL",
-       "NMI_INTERRUPT_INST_ACTION_PT",
-       "NMI_INTERRUPT_DATA_ACTION_PT",
-       "NMI_TRM_HW_ER",
-       "NMI_INTERRUPT_TRM",
-       "NMI_INTERRUPT_BREAK_POINT",
-       "DEBUG_0",
-       "DEBUG_1",
-       "DEBUG_2",
-       "DEBUG_3",
-};
-
-static struct {
-       char *name;
-       u8 num;
-} advanced_lookup[] = {
-       {
-       "NMI_INTERRUPT_WDG", 0x34}, {
-       "SYSASSERT", 0x35}, {
-       "UCODE_VERSION_MISMATCH", 0x37}, {
-       "BAD_COMMAND", 0x38}, {
-       "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C}, {
-       "FATAL_ERROR", 0x3D}, {
-       "NMI_TRM_HW_ERR", 0x46}, {
-       "NMI_INTERRUPT_TRM", 0x4C}, {
-       "NMI_INTERRUPT_BREAK_POINT", 0x54}, {
-       "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C}, {
-       "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64}, {
-       "NMI_INTERRUPT_HOST", 0x66}, {
-       "NMI_INTERRUPT_ACTION_PT", 0x7C}, {
-       "NMI_INTERRUPT_UNKNOWN", 0x84}, {
-       "NMI_INTERRUPT_INST_ACTION_PT", 0x86}, {
-"ADVANCED_SYSASSERT", 0},};
-
-static const char *
-il4965_desc_lookup(u32 num)
-{
-       int i;
-       int max = ARRAY_SIZE(desc_lookup_text);
-
-       if (num < max)
-               return desc_lookup_text[num];
-
-       max = ARRAY_SIZE(advanced_lookup) - 1;
-       for (i = 0; i < max; i++) {
-               if (advanced_lookup[i].num == num)
-                       break;
-       }
-       return advanced_lookup[i].name;
-}
-
-#define ERROR_START_OFFSET  (1 * sizeof(u32))
-#define ERROR_ELEM_SIZE     (7 * sizeof(u32))
-
-void
-il4965_dump_nic_error_log(struct il_priv *il)
-{
-       u32 data2, line;
-       u32 desc, time, count, base, data1;
-       u32 blink1, blink2, ilink1, ilink2;
-       u32 pc, hcmd;
-
-       if (il->ucode_type == UCODE_INIT)
-               base = le32_to_cpu(il->card_alive_init.error_event_table_ptr);
-       else
-               base = le32_to_cpu(il->card_alive.error_event_table_ptr);
-
-       if (!il->ops->is_valid_rtc_data_addr(base)) {
-               IL_ERR("Not valid error log pointer 0x%08X for %s uCode\n",
-                      base, (il->ucode_type == UCODE_INIT) ? "Init" : "RT");
-               return;
-       }
-
-       count = il_read_targ_mem(il, base);
-
-       if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
-               IL_ERR("Start IWL Error Log Dump:\n");
-               IL_ERR("Status: 0x%08lX, count: %d\n", il->status, count);
-       }
-
-       desc = il_read_targ_mem(il, base + 1 * sizeof(u32));
-       il->isr_stats.err_code = desc;
-       pc = il_read_targ_mem(il, base + 2 * sizeof(u32));
-       blink1 = il_read_targ_mem(il, base + 3 * sizeof(u32));
-       blink2 = il_read_targ_mem(il, base + 4 * sizeof(u32));
-       ilink1 = il_read_targ_mem(il, base + 5 * sizeof(u32));
-       ilink2 = il_read_targ_mem(il, base + 6 * sizeof(u32));
-       data1 = il_read_targ_mem(il, base + 7 * sizeof(u32));
-       data2 = il_read_targ_mem(il, base + 8 * sizeof(u32));
-       line = il_read_targ_mem(il, base + 9 * sizeof(u32));
-       time = il_read_targ_mem(il, base + 11 * sizeof(u32));
-       hcmd = il_read_targ_mem(il, base + 22 * sizeof(u32));
-
-       IL_ERR("Desc                                  Time       "
-              "data1      data2      line\n");
-       IL_ERR("%-28s (0x%04X) %010u 0x%08X 0x%08X %u\n",
-              il4965_desc_lookup(desc), desc, time, data1, data2, line);
-       IL_ERR("pc      blink1  blink2  ilink1  ilink2  hcmd\n");
-       IL_ERR("0x%05X 0x%05X 0x%05X 0x%05X 0x%05X 0x%05X\n", pc, blink1,
-              blink2, ilink1, ilink2, hcmd);
-}
-
-static void
-il4965_rf_kill_ct_config(struct il_priv *il)
-{
-       struct il_ct_kill_config cmd;
-       unsigned long flags;
-       int ret = 0;
-
-       spin_lock_irqsave(&il->lock, flags);
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR,
-              CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       cmd.critical_temperature_R =
-           cpu_to_le32(il->hw_params.ct_kill_threshold);
-
-       ret = il_send_cmd_pdu(il, C_CT_KILL_CONFIG, sizeof(cmd), &cmd);
-       if (ret)
-               IL_ERR("C_CT_KILL_CONFIG failed\n");
-       else
-               D_INFO("C_CT_KILL_CONFIG " "succeeded, "
-                      "critical temperature is %d\n",
-                      il->hw_params.ct_kill_threshold);
-}
-
-static const s8 default_queue_to_tx_fifo[] = {
-       IL_TX_FIFO_VO,
-       IL_TX_FIFO_VI,
-       IL_TX_FIFO_BE,
-       IL_TX_FIFO_BK,
-       IL49_CMD_FIFO_NUM,
-       IL_TX_FIFO_UNUSED,
-       IL_TX_FIFO_UNUSED,
-};
-
-#define IL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo))))
-
-static int
-il4965_alive_notify(struct il_priv *il)
-{
-       u32 a;
-       unsigned long flags;
-       int i, chan;
-       u32 reg_val;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Clear 4965's internal Tx Scheduler data base */
-       il->scd_base_addr = il_rd_prph(il, IL49_SCD_SRAM_BASE_ADDR);
-       a = il->scd_base_addr + IL49_SCD_CONTEXT_DATA_OFFSET;
-       for (; a < il->scd_base_addr + IL49_SCD_TX_STTS_BITMAP_OFFSET; a += 4)
-               il_write_targ_mem(il, a, 0);
-       for (; a < il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET; a += 4)
-               il_write_targ_mem(il, a, 0);
-       for (;
-            a <
-            il->scd_base_addr +
-            IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(il->hw_params.max_txq_num);
-            a += 4)
-               il_write_targ_mem(il, a, 0);
-
-       /* Tel 4965 where to find Tx byte count tables */
-       il_wr_prph(il, IL49_SCD_DRAM_BASE_ADDR, il->scd_bc_tbls.dma >> 10);
-
-       /* Enable DMA channel */
-       for (chan = 0; chan < FH49_TCSR_CHNL_NUM; chan++)
-               il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(chan),
-                     FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |
-                     FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE);
-
-       /* Update FH chicken bits */
-       reg_val = il_rd(il, FH49_TX_CHICKEN_BITS_REG);
-       il_wr(il, FH49_TX_CHICKEN_BITS_REG,
-             reg_val | FH49_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN);
-
-       /* Disable chain mode for all queues */
-       il_wr_prph(il, IL49_SCD_QUEUECHAIN_SEL, 0);
-
-       /* Initialize each Tx queue (including the command queue) */
-       for (i = 0; i < il->hw_params.max_txq_num; i++) {
-
-               /* TFD circular buffer read/write idxes */
-               il_wr_prph(il, IL49_SCD_QUEUE_RDPTR(i), 0);
-               il_wr(il, HBUS_TARG_WRPTR, 0 | (i << 8));
-
-               /* Max Tx Window size for Scheduler-ACK mode */
-               il_write_targ_mem(il,
-                                 il->scd_base_addr +
-                                 IL49_SCD_CONTEXT_QUEUE_OFFSET(i),
-                                 (SCD_WIN_SIZE <<
-                                  IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) &
-                                 IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
-
-               /* Frame limit */
-               il_write_targ_mem(il,
-                                 il->scd_base_addr +
-                                 IL49_SCD_CONTEXT_QUEUE_OFFSET(i) +
-                                 sizeof(u32),
-                                 (SCD_FRAME_LIMIT <<
-                                  IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
-                                 IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
-
-       }
-       il_wr_prph(il, IL49_SCD_INTERRUPT_MASK,
-                  (1 << il->hw_params.max_txq_num) - 1);
-
-       /* Activate all Tx DMA/FIFO channels */
-       il4965_txq_set_sched(il, IL_MASK(0, 6));
-
-       il4965_set_wr_ptrs(il, IL_DEFAULT_CMD_QUEUE_NUM, 0);
-
-       /* make sure all queue are not stopped */
-       memset(&il->queue_stopped[0], 0, sizeof(il->queue_stopped));
-       for (i = 0; i < 4; i++)
-               atomic_set(&il->queue_stop_count[i], 0);
-
-       /* reset to 0 to enable all the queue first */
-       il->txq_ctx_active_msk = 0;
-       /* Map each Tx/cmd queue to its corresponding fifo */
-       BUILD_BUG_ON(ARRAY_SIZE(default_queue_to_tx_fifo) != 7);
-
-       for (i = 0; i < ARRAY_SIZE(default_queue_to_tx_fifo); i++) {
-               int ac = default_queue_to_tx_fifo[i];
-
-               il_txq_ctx_activate(il, i);
-
-               if (ac == IL_TX_FIFO_UNUSED)
-                       continue;
-
-               il4965_tx_queue_set_status(il, &il->txq[i], ac, 0);
-       }
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       return 0;
-}
-
-/**
- * il4965_alive_start - called after N_ALIVE notification received
- *                   from protocol/runtime uCode (initialization uCode's
- *                   Alive gets handled by il_init_alive_start()).
- */
-static void
-il4965_alive_start(struct il_priv *il)
-{
-       int ret = 0;
-
-       D_INFO("Runtime Alive received.\n");
-
-       if (il->card_alive.is_valid != UCODE_VALID_OK) {
-               /* We had an error bringing up the hardware, so take it
-                * all the way back down so we can try again */
-               D_INFO("Alive failed.\n");
-               goto restart;
-       }
-
-       /* Initialize uCode has loaded Runtime uCode ... verify inst image.
-        * This is a paranoid check, because we would not have gotten the
-        * "runtime" alive if code weren't properly loaded.  */
-       if (il4965_verify_ucode(il)) {
-               /* Runtime instruction load was bad;
-                * take it all the way back down so we can try again */
-               D_INFO("Bad runtime uCode load.\n");
-               goto restart;
-       }
-
-       ret = il4965_alive_notify(il);
-       if (ret) {
-               IL_WARN("Could not complete ALIVE transition [ntf]: %d\n", ret);
-               goto restart;
-       }
-
-       /* After the ALIVE response, we can send host commands to the uCode */
-       set_bit(S_ALIVE, &il->status);
-
-       /* Enable watchdog to monitor the driver tx queues */
-       il_setup_watchdog(il);
-
-       if (il_is_rfkill(il))
-               return;
-
-       ieee80211_wake_queues(il->hw);
-
-       il->active_rate = RATES_MASK;
-
-       il_power_update_mode(il, true);
-       D_INFO("Updated power mode\n");
-
-       if (il_is_associated(il)) {
-               struct il_rxon_cmd *active_rxon =
-                   (struct il_rxon_cmd *)&il->active;
-               /* apply any changes in staging */
-               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
-               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-       } else {
-               /* Initialize our rx_config data */
-               il_connection_init_rx_config(il);
-
-               if (il->ops->set_rxon_chain)
-                       il->ops->set_rxon_chain(il);
-       }
-
-       /* Configure bluetooth coexistence if enabled */
-       il_send_bt_config(il);
-
-       il4965_reset_run_time_calib(il);
-
-       set_bit(S_READY, &il->status);
-
-       /* Configure the adapter for unassociated operation */
-       il_commit_rxon(il);
-
-       /* At this point, the NIC is initialized and operational */
-       il4965_rf_kill_ct_config(il);
-
-       D_INFO("ALIVE processing complete.\n");
-       wake_up(&il->wait_command_queue);
-
-       return;
-
-restart:
-       queue_work(il->workqueue, &il->restart);
-}
-
-static void il4965_cancel_deferred_work(struct il_priv *il);
-
-static void
-__il4965_down(struct il_priv *il)
-{
-       unsigned long flags;
-       int exit_pending;
-
-       D_INFO(DRV_NAME " is going down\n");
-
-       il_scan_cancel_timeout(il, 200);
-
-       exit_pending = test_and_set_bit(S_EXIT_PENDING, &il->status);
-
-       /* Stop TX queues watchdog. We need to have S_EXIT_PENDING bit set
-        * to prevent rearm timer */
-       del_timer_sync(&il->watchdog);
-
-       il_clear_ucode_stations(il);
-
-       /* FIXME: race conditions ? */
-       spin_lock_irq(&il->sta_lock);
-       /*
-        * Remove all key information that is not stored as part
-        * of station information since mac80211 may not have had
-        * a chance to remove all the keys. When device is
-        * reconfigured by mac80211 after an error all keys will
-        * be reconfigured.
-        */
-       memset(il->_4965.wep_keys, 0, sizeof(il->_4965.wep_keys));
-       il->_4965.key_mapping_keys = 0;
-       spin_unlock_irq(&il->sta_lock);
-
-       il_dealloc_bcast_stations(il);
-       il_clear_driver_stations(il);
-
-       /* Unblock any waiting calls */
-       wake_up_all(&il->wait_command_queue);
-
-       /* Wipe out the EXIT_PENDING status bit if we are not actually
-        * exiting the module */
-       if (!exit_pending)
-               clear_bit(S_EXIT_PENDING, &il->status);
-
-       /* stop and reset the on-board processor */
-       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
-
-       /* tell the device to stop sending interrupts */
-       spin_lock_irqsave(&il->lock, flags);
-       il_disable_interrupts(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-       il4965_synchronize_irq(il);
-
-       if (il->mac80211_registered)
-               ieee80211_stop_queues(il->hw);
-
-       /* If we have not previously called il_init() then
-        * clear all bits but the RF Kill bit and return */
-       if (!il_is_init(il)) {
-               il->status =
-                   test_bit(S_RFKILL, &il->status) << S_RFKILL |
-                   test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
-                   test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
-               goto exit;
-       }
-
-       /* ...otherwise clear out all the status bits but the RF Kill
-        * bit and continue taking the NIC down. */
-       il->status &=
-           test_bit(S_RFKILL, &il->status) << S_RFKILL |
-           test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
-           test_bit(S_FW_ERROR, &il->status) << S_FW_ERROR |
-           test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
-
-       /*
-        * We disabled and synchronized interrupt, and priv->mutex is taken, so
-        * here is the only thread which will program device registers, but
-        * still have lockdep assertions, so we are taking reg_lock.
-        */
-       spin_lock_irq(&il->reg_lock);
-       /* FIXME: il_grab_nic_access if rfkill is off ? */
-
-       il4965_txq_ctx_stop(il);
-       il4965_rxq_stop(il);
-       /* Power-down device's busmaster DMA clocks */
-       _il_wr_prph(il, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
-       udelay(5);
-       /* Make sure (redundant) we've released our request to stay awake */
-       _il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-       /* Stop the device, and put it in low power state */
-       _il_apm_stop(il);
-
-       spin_unlock_irq(&il->reg_lock);
-
-       il4965_txq_ctx_unmap(il);
-exit:
-       memset(&il->card_alive, 0, sizeof(struct il_alive_resp));
-
-       dev_kfree_skb(il->beacon_skb);
-       il->beacon_skb = NULL;
-
-       /* clear out any free frames */
-       il4965_clear_free_frames(il);
-}
-
-static void
-il4965_down(struct il_priv *il)
-{
-       mutex_lock(&il->mutex);
-       __il4965_down(il);
-       mutex_unlock(&il->mutex);
-
-       il4965_cancel_deferred_work(il);
-}
-
-
-static void
-il4965_set_hw_ready(struct il_priv *il)
-{
-       int ret;
-
-       il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                  CSR_HW_IF_CONFIG_REG_BIT_NIC_READY);
-
-       /* See if we got it */
-       ret = _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
-                          CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
-                          100);
-       if (ret >= 0)
-               il->hw_ready = true;
-
-       D_INFO("hardware %s ready\n", (il->hw_ready) ? "" : "not");
-}
-
-static void
-il4965_prepare_card_hw(struct il_priv *il)
-{
-       int ret;
-
-       il->hw_ready = false;
-
-       il4965_set_hw_ready(il);
-       if (il->hw_ready)
-               return;
-
-       /* If HW is not ready, prepare the conditions to check again */
-       il_set_bit(il, CSR_HW_IF_CONFIG_REG, CSR_HW_IF_CONFIG_REG_PREPARE);
-
-       ret =
-           _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
-                        ~CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE,
-                        CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE, 150000);
-
-       /* HW should be ready by now, check again. */
-       if (ret != -ETIMEDOUT)
-               il4965_set_hw_ready(il);
-}
-
-#define MAX_HW_RESTARTS 5
-
-static int
-__il4965_up(struct il_priv *il)
-{
-       int i;
-       int ret;
-
-       if (test_bit(S_EXIT_PENDING, &il->status)) {
-               IL_WARN("Exit pending; will not bring the NIC up\n");
-               return -EIO;
-       }
-
-       if (!il->ucode_data_backup.v_addr || !il->ucode_data.v_addr) {
-               IL_ERR("ucode not available for device bringup\n");
-               return -EIO;
-       }
-
-       ret = il4965_alloc_bcast_station(il);
-       if (ret) {
-               il_dealloc_bcast_stations(il);
-               return ret;
-       }
-
-       il4965_prepare_card_hw(il);
-       if (!il->hw_ready) {
-               IL_ERR("HW not ready\n");
-               return -EIO;
-       }
-
-       /* If platform's RF_KILL switch is NOT set to KILL */
-       if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
-               clear_bit(S_RFKILL, &il->status);
-       else {
-               set_bit(S_RFKILL, &il->status);
-               wiphy_rfkill_set_hw_state(il->hw->wiphy, true);
-
-               il_enable_rfkill_int(il);
-               IL_WARN("Radio disabled by HW RF Kill switch\n");
-               return 0;
-       }
-
-       _il_wr(il, CSR_INT, 0xFFFFFFFF);
-
-       /* must be initialised before il_hw_nic_init */
-       il->cmd_queue = IL_DEFAULT_CMD_QUEUE_NUM;
-
-       ret = il4965_hw_nic_init(il);
-       if (ret) {
-               IL_ERR("Unable to init nic\n");
-               return ret;
-       }
-
-       /* make sure rfkill handshake bits are cleared */
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
-
-       /* clear (again), then enable host interrupts */
-       _il_wr(il, CSR_INT, 0xFFFFFFFF);
-       il_enable_interrupts(il);
-
-       /* really make sure rfkill handshake bits are cleared */
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-       _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
-
-       /* Copy original ucode data image from disk into backup cache.
-        * This will be used to initialize the on-board processor's
-        * data SRAM for a clean start when the runtime program first loads. */
-       memcpy(il->ucode_data_backup.v_addr, il->ucode_data.v_addr,
-              il->ucode_data.len);
-
-       for (i = 0; i < MAX_HW_RESTARTS; i++) {
-
-               /* load bootstrap state machine,
-                * load bootstrap program into processor's memory,
-                * prepare to load the "initialize" uCode */
-               ret = il->ops->load_ucode(il);
-
-               if (ret) {
-                       IL_ERR("Unable to set up bootstrap uCode: %d\n", ret);
-                       continue;
-               }
-
-               /* start card; "initialize" will load runtime ucode */
-               il4965_nic_start(il);
-
-               D_INFO(DRV_NAME " is coming up\n");
-
-               return 0;
-       }
-
-       set_bit(S_EXIT_PENDING, &il->status);
-       __il4965_down(il);
-       clear_bit(S_EXIT_PENDING, &il->status);
-
-       /* tried to restart and config the device for as long as our
-        * patience could withstand */
-       IL_ERR("Unable to initialize device after %d attempts.\n", i);
-       return -EIO;
-}
-
-/*****************************************************************************
- *
- * Workqueue callbacks
- *
- *****************************************************************************/
-
-static void
-il4965_bg_init_alive_start(struct work_struct *data)
-{
-       struct il_priv *il =
-           container_of(data, struct il_priv, init_alive_start.work);
-
-       mutex_lock(&il->mutex);
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               goto out;
-
-       il->ops->init_alive_start(il);
-out:
-       mutex_unlock(&il->mutex);
-}
-
-static void
-il4965_bg_alive_start(struct work_struct *data)
-{
-       struct il_priv *il =
-           container_of(data, struct il_priv, alive_start.work);
-
-       mutex_lock(&il->mutex);
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               goto out;
-
-       il4965_alive_start(il);
-out:
-       mutex_unlock(&il->mutex);
-}
-
-static void
-il4965_bg_run_time_calib_work(struct work_struct *work)
-{
-       struct il_priv *il = container_of(work, struct il_priv,
-                                         run_time_calib_work);
-
-       mutex_lock(&il->mutex);
-
-       if (test_bit(S_EXIT_PENDING, &il->status) ||
-           test_bit(S_SCANNING, &il->status)) {
-               mutex_unlock(&il->mutex);
-               return;
-       }
-
-       if (il->start_calib) {
-               il4965_chain_noise_calibration(il, (void *)&il->_4965.stats);
-               il4965_sensitivity_calibration(il, (void *)&il->_4965.stats);
-       }
-
-       mutex_unlock(&il->mutex);
-}
-
-static void
-il4965_bg_restart(struct work_struct *data)
-{
-       struct il_priv *il = container_of(data, struct il_priv, restart);
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
-               mutex_lock(&il->mutex);
-               il->is_open = 0;
-
-               __il4965_down(il);
-
-               mutex_unlock(&il->mutex);
-               il4965_cancel_deferred_work(il);
-               ieee80211_restart_hw(il->hw);
-       } else {
-               il4965_down(il);
-
-               mutex_lock(&il->mutex);
-               if (test_bit(S_EXIT_PENDING, &il->status)) {
-                       mutex_unlock(&il->mutex);
-                       return;
-               }
-
-               __il4965_up(il);
-               mutex_unlock(&il->mutex);
-       }
-}
-
-static void
-il4965_bg_rx_replenish(struct work_struct *data)
-{
-       struct il_priv *il = container_of(data, struct il_priv, rx_replenish);
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       mutex_lock(&il->mutex);
-       il4965_rx_replenish(il);
-       mutex_unlock(&il->mutex);
-}
-
-/*****************************************************************************
- *
- * mac80211 entry point functions
- *
- *****************************************************************************/
-
-#define UCODE_READY_TIMEOUT    (4 * HZ)
-
-/*
- * Not a mac80211 entry point function, but it fits in with all the
- * other mac80211 functions grouped here.
- */
-static int
-il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length)
-{
-       int ret;
-       struct ieee80211_hw *hw = il->hw;
-
-       hw->rate_control_algorithm = "iwl-4965-rs";
-
-       /* Tell mac80211 our characteristics */
-       ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
-       ieee80211_hw_set(hw, SUPPORTS_PS);
-       ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
-       ieee80211_hw_set(hw, SPECTRUM_MGMT);
-       ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
-       ieee80211_hw_set(hw, SIGNAL_DBM);
-       ieee80211_hw_set(hw, AMPDU_AGGREGATION);
-       if (il->cfg->sku & IL_SKU_N)
-               hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS |
-                                      NL80211_FEATURE_STATIC_SMPS;
-
-       hw->sta_data_size = sizeof(struct il_station_priv);
-       hw->vif_data_size = sizeof(struct il_vif_priv);
-
-       hw->wiphy->interface_modes =
-           BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
-
-       hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
-       hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
-                                      REGULATORY_DISABLE_BEACON_HINTS;
-
-       /*
-        * For now, disable PS by default because it affects
-        * RX performance significantly.
-        */
-       hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
-
-       hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
-       /* we create the 802.11 header and a zero-length SSID element */
-       hw->wiphy->max_scan_ie_len = max_probe_length - 24 - 2;
-
-       /* Default value; 4 EDCA QOS priorities */
-       hw->queues = 4;
-
-       hw->max_listen_interval = IL_CONN_MAX_LISTEN_INTERVAL;
-
-       if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
-               il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                   &il->bands[IEEE80211_BAND_2GHZ];
-       if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
-               il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                   &il->bands[IEEE80211_BAND_5GHZ];
-
-       il_leds_init(il);
-
-       ret = ieee80211_register_hw(il->hw);
-       if (ret) {
-               IL_ERR("Failed to register hw (error %d)\n", ret);
-               return ret;
-       }
-       il->mac80211_registered = 1;
-
-       return 0;
-}
-
-int
-il4965_mac_start(struct ieee80211_hw *hw)
-{
-       struct il_priv *il = hw->priv;
-       int ret;
-
-       D_MAC80211("enter\n");
-
-       /* we should be verifying the device is ready to be opened */
-       mutex_lock(&il->mutex);
-       ret = __il4965_up(il);
-       mutex_unlock(&il->mutex);
-
-       if (ret)
-               return ret;
-
-       if (il_is_rfkill(il))
-               goto out;
-
-       D_INFO("Start UP work done.\n");
-
-       /* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
-        * mac80211 will not be run successfully. */
-       ret = wait_event_timeout(il->wait_command_queue,
-                                test_bit(S_READY, &il->status),
-                                UCODE_READY_TIMEOUT);
-       if (!ret) {
-               if (!test_bit(S_READY, &il->status)) {
-                       IL_ERR("START_ALIVE timeout after %dms.\n",
-                               jiffies_to_msecs(UCODE_READY_TIMEOUT));
-                       return -ETIMEDOUT;
-               }
-       }
-
-       il4965_led_enable(il);
-
-out:
-       il->is_open = 1;
-       D_MAC80211("leave\n");
-       return 0;
-}
-
-void
-il4965_mac_stop(struct ieee80211_hw *hw)
-{
-       struct il_priv *il = hw->priv;
-
-       D_MAC80211("enter\n");
-
-       if (!il->is_open)
-               return;
-
-       il->is_open = 0;
-
-       il4965_down(il);
-
-       flush_workqueue(il->workqueue);
-
-       /* User space software may expect getting rfkill changes
-        * even if interface is down */
-       _il_wr(il, CSR_INT, 0xFFFFFFFF);
-       il_enable_rfkill_int(il);
-
-       D_MAC80211("leave\n");
-}
-
-void
-il4965_mac_tx(struct ieee80211_hw *hw,
-             struct ieee80211_tx_control *control,
-             struct sk_buff *skb)
-{
-       struct il_priv *il = hw->priv;
-
-       D_MACDUMP("enter\n");
-
-       D_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
-            ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
-
-       if (il4965_tx_skb(il, control->sta, skb))
-               dev_kfree_skb_any(skb);
-
-       D_MACDUMP("leave\n");
-}
-
-void
-il4965_mac_update_tkip_key(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                          struct ieee80211_key_conf *keyconf,
-                          struct ieee80211_sta *sta, u32 iv32, u16 * phase1key)
-{
-       struct il_priv *il = hw->priv;
-
-       D_MAC80211("enter\n");
-
-       il4965_update_tkip_key(il, keyconf, sta, iv32, phase1key);
-
-       D_MAC80211("leave\n");
-}
-
-int
-il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
-                  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
-                  struct ieee80211_key_conf *key)
-{
-       struct il_priv *il = hw->priv;
-       int ret;
-       u8 sta_id;
-       bool is_default_wep_key = false;
-
-       D_MAC80211("enter\n");
-
-       if (il->cfg->mod_params->sw_crypto) {
-               D_MAC80211("leave - hwcrypto disabled\n");
-               return -EOPNOTSUPP;
-       }
-
-       /*
-        * To support IBSS RSN, don't program group keys in IBSS, the
-        * hardware will then not attempt to decrypt the frames.
-        */
-       if (vif->type == NL80211_IFTYPE_ADHOC &&
-           !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
-               D_MAC80211("leave - ad-hoc group key\n");
-               return -EOPNOTSUPP;
-       }
-
-       sta_id = il_sta_id_or_broadcast(il, sta);
-       if (sta_id == IL_INVALID_STATION)
-               return -EINVAL;
-
-       mutex_lock(&il->mutex);
-       il_scan_cancel_timeout(il, 100);
-
-       /*
-        * If we are getting WEP group key and we didn't receive any key mapping
-        * so far, we are in legacy wep mode (group key only), otherwise we are
-        * in 1X mode.
-        * In legacy wep mode, we use another host command to the uCode.
-        */
-       if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
-            key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
-               if (cmd == SET_KEY)
-                       is_default_wep_key = !il->_4965.key_mapping_keys;
-               else
-                       is_default_wep_key =
-                           (key->hw_key_idx == HW_KEY_DEFAULT);
-       }
-
-       switch (cmd) {
-       case SET_KEY:
-               if (is_default_wep_key)
-                       ret = il4965_set_default_wep_key(il, key);
-               else
-                       ret = il4965_set_dynamic_key(il, key, sta_id);
-
-               D_MAC80211("enable hwcrypto key\n");
-               break;
-       case DISABLE_KEY:
-               if (is_default_wep_key)
-                       ret = il4965_remove_default_wep_key(il, key);
-               else
-                       ret = il4965_remove_dynamic_key(il, key, sta_id);
-
-               D_MAC80211("disable hwcrypto key\n");
-               break;
-       default:
-               ret = -EINVAL;
-       }
-
-       mutex_unlock(&il->mutex);
-       D_MAC80211("leave\n");
-
-       return ret;
-}
-
-int
-il4965_mac_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                       enum ieee80211_ampdu_mlme_action action,
-                       struct ieee80211_sta *sta, u16 tid, u16 * ssn,
-                       u8 buf_size, bool amsdu)
-{
-       struct il_priv *il = hw->priv;
-       int ret = -EINVAL;
-
-       D_HT("A-MPDU action on addr %pM tid %d\n", sta->addr, tid);
-
-       if (!(il->cfg->sku & IL_SKU_N))
-               return -EACCES;
-
-       mutex_lock(&il->mutex);
-
-       switch (action) {
-       case IEEE80211_AMPDU_RX_START:
-               D_HT("start Rx\n");
-               ret = il4965_sta_rx_agg_start(il, sta, tid, *ssn);
-               break;
-       case IEEE80211_AMPDU_RX_STOP:
-               D_HT("stop Rx\n");
-               ret = il4965_sta_rx_agg_stop(il, sta, tid);
-               if (test_bit(S_EXIT_PENDING, &il->status))
-                       ret = 0;
-               break;
-       case IEEE80211_AMPDU_TX_START:
-               D_HT("start Tx\n");
-               ret = il4965_tx_agg_start(il, vif, sta, tid, ssn);
-               break;
-       case IEEE80211_AMPDU_TX_STOP_CONT:
-       case IEEE80211_AMPDU_TX_STOP_FLUSH:
-       case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
-               D_HT("stop Tx\n");
-               ret = il4965_tx_agg_stop(il, vif, sta, tid);
-               if (test_bit(S_EXIT_PENDING, &il->status))
-                       ret = 0;
-               break;
-       case IEEE80211_AMPDU_TX_OPERATIONAL:
-               ret = 0;
-               break;
-       }
-       mutex_unlock(&il->mutex);
-
-       return ret;
-}
-
-int
-il4965_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                  struct ieee80211_sta *sta)
-{
-       struct il_priv *il = hw->priv;
-       struct il_station_priv *sta_priv = (void *)sta->drv_priv;
-       bool is_ap = vif->type == NL80211_IFTYPE_STATION;
-       int ret;
-       u8 sta_id;
-
-       D_INFO("received request to add station %pM\n", sta->addr);
-       mutex_lock(&il->mutex);
-       D_INFO("proceeding to add station %pM\n", sta->addr);
-       sta_priv->common.sta_id = IL_INVALID_STATION;
-
-       atomic_set(&sta_priv->pending_frames, 0);
-
-       ret =
-           il_add_station_common(il, sta->addr, is_ap, sta, &sta_id);
-       if (ret) {
-               IL_ERR("Unable to add station %pM (%d)\n", sta->addr, ret);
-               /* Should we return success if return code is EEXIST ? */
-               mutex_unlock(&il->mutex);
-               return ret;
-       }
-
-       sta_priv->common.sta_id = sta_id;
-
-       /* Initialize rate scaling */
-       D_INFO("Initializing rate scaling for station %pM\n", sta->addr);
-       il4965_rs_rate_init(il, sta, sta_id);
-       mutex_unlock(&il->mutex);
-
-       return 0;
-}
-
-void
-il4965_mac_channel_switch(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                         struct ieee80211_channel_switch *ch_switch)
-{
-       struct il_priv *il = hw->priv;
-       const struct il_channel_info *ch_info;
-       struct ieee80211_conf *conf = &hw->conf;
-       struct ieee80211_channel *channel = ch_switch->chandef.chan;
-       struct il_ht_config *ht_conf = &il->current_ht_config;
-       u16 ch;
-
-       D_MAC80211("enter\n");
-
-       mutex_lock(&il->mutex);
-
-       if (il_is_rfkill(il))
-               goto out;
-
-       if (test_bit(S_EXIT_PENDING, &il->status) ||
-           test_bit(S_SCANNING, &il->status) ||
-           test_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
-               goto out;
-
-       if (!il_is_associated(il))
-               goto out;
-
-       if (!il->ops->set_channel_switch)
-               goto out;
-
-       ch = channel->hw_value;
-       if (le16_to_cpu(il->active.channel) == ch)
-               goto out;
-
-       ch_info = il_get_channel_info(il, channel->band, ch);
-       if (!il_is_channel_valid(ch_info)) {
-               D_MAC80211("invalid channel\n");
-               goto out;
-       }
-
-       spin_lock_irq(&il->lock);
-
-       il->current_ht_config.smps = conf->smps_mode;
-
-       /* Configure HT40 channels */
-       switch (cfg80211_get_chandef_type(&ch_switch->chandef)) {
-       case NL80211_CHAN_NO_HT:
-       case NL80211_CHAN_HT20:
-               il->ht.is_40mhz = false;
-               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
-               break;
-       case NL80211_CHAN_HT40MINUS:
-               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
-               il->ht.is_40mhz = true;
-               break;
-       case NL80211_CHAN_HT40PLUS:
-               il->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
-               il->ht.is_40mhz = true;
-               break;
-       }
-
-       if ((le16_to_cpu(il->staging.channel) != ch))
-               il->staging.flags = 0;
-
-       il_set_rxon_channel(il, channel);
-       il_set_rxon_ht(il, ht_conf);
-       il_set_flags_for_band(il, channel->band, il->vif);
-
-       spin_unlock_irq(&il->lock);
-
-       il_set_rate(il);
-       /*
-        * at this point, staging_rxon has the
-        * configuration for channel switch
-        */
-       set_bit(S_CHANNEL_SWITCH_PENDING, &il->status);
-       il->switch_channel = cpu_to_le16(ch);
-       if (il->ops->set_channel_switch(il, ch_switch)) {
-               clear_bit(S_CHANNEL_SWITCH_PENDING, &il->status);
-               il->switch_channel = 0;
-               ieee80211_chswitch_done(il->vif, false);
-       }
-
-out:
-       mutex_unlock(&il->mutex);
-       D_MAC80211("leave\n");
-}
-
-void
-il4965_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
-                       unsigned int *total_flags, u64 multicast)
-{
-       struct il_priv *il = hw->priv;
-       __le32 filter_or = 0, filter_nand = 0;
-
-#define CHK(test, flag)        do { \
-       if (*total_flags & (test))              \
-               filter_or |= (flag);            \
-       else                                    \
-               filter_nand |= (flag);          \
-       } while (0)
-
-       D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n", changed_flags,
-                  *total_flags);
-
-       CHK(FIF_OTHER_BSS, RXON_FILTER_PROMISC_MSK);
-       /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
-       CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
-       CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
-
-#undef CHK
-
-       mutex_lock(&il->mutex);
-
-       il->staging.filter_flags &= ~filter_nand;
-       il->staging.filter_flags |= filter_or;
-
-       /*
-        * Not committing directly because hardware can perform a scan,
-        * but we'll eventually commit the filter flags change anyway.
-        */
-
-       mutex_unlock(&il->mutex);
-
-       /*
-        * Receiving all multicast frames is always enabled by the
-        * default flags setup in il_connection_init_rx_config()
-        * since we currently do not support programming multicast
-        * filters into the device.
-        */
-       *total_flags &=
-           FIF_OTHER_BSS | FIF_ALLMULTI |
-           FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
-}
-
-/*****************************************************************************
- *
- * driver setup and teardown
- *
- *****************************************************************************/
-
-static void
-il4965_bg_txpower_work(struct work_struct *work)
-{
-       struct il_priv *il = container_of(work, struct il_priv,
-                                         txpower_work);
-
-       mutex_lock(&il->mutex);
-
-       /* If a scan happened to start before we got here
-        * then just return; the stats notification will
-        * kick off another scheduled work to compensate for
-        * any temperature delta we missed here. */
-       if (test_bit(S_EXIT_PENDING, &il->status) ||
-           test_bit(S_SCANNING, &il->status))
-               goto out;
-
-       /* Regardless of if we are associated, we must reconfigure the
-        * TX power since frames can be sent on non-radar channels while
-        * not associated */
-       il->ops->send_tx_power(il);
-
-       /* Update last_temperature to keep is_calib_needed from running
-        * when it isn't needed... */
-       il->last_temperature = il->temperature;
-out:
-       mutex_unlock(&il->mutex);
-}
-
-static void
-il4965_setup_deferred_work(struct il_priv *il)
-{
-       il->workqueue = create_singlethread_workqueue(DRV_NAME);
-
-       init_waitqueue_head(&il->wait_command_queue);
-
-       INIT_WORK(&il->restart, il4965_bg_restart);
-       INIT_WORK(&il->rx_replenish, il4965_bg_rx_replenish);
-       INIT_WORK(&il->run_time_calib_work, il4965_bg_run_time_calib_work);
-       INIT_DELAYED_WORK(&il->init_alive_start, il4965_bg_init_alive_start);
-       INIT_DELAYED_WORK(&il->alive_start, il4965_bg_alive_start);
-
-       il_setup_scan_deferred_work(il);
-
-       INIT_WORK(&il->txpower_work, il4965_bg_txpower_work);
-
-       setup_timer(&il->stats_periodic, il4965_bg_stats_periodic,
-                   (unsigned long)il);
-
-       setup_timer(&il->watchdog, il_bg_watchdog, (unsigned long)il);
-
-       tasklet_init(&il->irq_tasklet,
-                    (void (*)(unsigned long))il4965_irq_tasklet,
-                    (unsigned long)il);
-}
-
-static void
-il4965_cancel_deferred_work(struct il_priv *il)
-{
-       cancel_work_sync(&il->txpower_work);
-       cancel_delayed_work_sync(&il->init_alive_start);
-       cancel_delayed_work(&il->alive_start);
-       cancel_work_sync(&il->run_time_calib_work);
-
-       il_cancel_scan_deferred_work(il);
-
-       del_timer_sync(&il->stats_periodic);
-}
-
-static void
-il4965_init_hw_rates(struct il_priv *il, struct ieee80211_rate *rates)
-{
-       int i;
-
-       for (i = 0; i < RATE_COUNT_LEGACY; i++) {
-               rates[i].bitrate = il_rates[i].ieee * 5;
-               rates[i].hw_value = i;  /* Rate scaling will work on idxes */
-               rates[i].hw_value_short = i;
-               rates[i].flags = 0;
-               if ((i >= IL_FIRST_CCK_RATE) && (i <= IL_LAST_CCK_RATE)) {
-                       /*
-                        * If CCK != 1M then set short preamble rate flag.
-                        */
-                       rates[i].flags |=
-                           (il_rates[i].plcp ==
-                            RATE_1M_PLCP) ? 0 : IEEE80211_RATE_SHORT_PREAMBLE;
-               }
-       }
-}
-
-/*
- * Acquire il->lock before calling this function !
- */
-void
-il4965_set_wr_ptrs(struct il_priv *il, int txq_id, u32 idx)
-{
-       il_wr(il, HBUS_TARG_WRPTR, (idx & 0xff) | (txq_id << 8));
-       il_wr_prph(il, IL49_SCD_QUEUE_RDPTR(txq_id), idx);
-}
-
-void
-il4965_tx_queue_set_status(struct il_priv *il, struct il_tx_queue *txq,
-                          int tx_fifo_id, int scd_retry)
-{
-       int txq_id = txq->q.id;
-
-       /* Find out whether to activate Tx queue */
-       int active = test_bit(txq_id, &il->txq_ctx_active_msk) ? 1 : 0;
-
-       /* Set up and activate */
-       il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
-                  (active << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
-                  (tx_fifo_id << IL49_SCD_QUEUE_STTS_REG_POS_TXF) |
-                  (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_WSL) |
-                  (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACK) |
-                  IL49_SCD_QUEUE_STTS_REG_MSK);
-
-       txq->sched_retry = scd_retry;
-
-       D_INFO("%s %s Queue %d on AC %d\n", active ? "Activate" : "Deactivate",
-              scd_retry ? "BA" : "AC", txq_id, tx_fifo_id);
-}
-
-static const struct ieee80211_ops il4965_mac_ops = {
-       .tx = il4965_mac_tx,
-       .start = il4965_mac_start,
-       .stop = il4965_mac_stop,
-       .add_interface = il_mac_add_interface,
-       .remove_interface = il_mac_remove_interface,
-       .change_interface = il_mac_change_interface,
-       .config = il_mac_config,
-       .configure_filter = il4965_configure_filter,
-       .set_key = il4965_mac_set_key,
-       .update_tkip_key = il4965_mac_update_tkip_key,
-       .conf_tx = il_mac_conf_tx,
-       .reset_tsf = il_mac_reset_tsf,
-       .bss_info_changed = il_mac_bss_info_changed,
-       .ampdu_action = il4965_mac_ampdu_action,
-       .hw_scan = il_mac_hw_scan,
-       .sta_add = il4965_mac_sta_add,
-       .sta_remove = il_mac_sta_remove,
-       .channel_switch = il4965_mac_channel_switch,
-       .tx_last_beacon = il_mac_tx_last_beacon,
-       .flush = il_mac_flush,
-};
-
-static int
-il4965_init_drv(struct il_priv *il)
-{
-       int ret;
-
-       spin_lock_init(&il->sta_lock);
-       spin_lock_init(&il->hcmd_lock);
-
-       INIT_LIST_HEAD(&il->free_frames);
-
-       mutex_init(&il->mutex);
-
-       il->ieee_channels = NULL;
-       il->ieee_rates = NULL;
-       il->band = IEEE80211_BAND_2GHZ;
-
-       il->iw_mode = NL80211_IFTYPE_STATION;
-       il->current_ht_config.smps = IEEE80211_SMPS_STATIC;
-       il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
-
-       /* initialize force reset */
-       il->force_reset.reset_duration = IL_DELAY_NEXT_FORCE_FW_RELOAD;
-
-       /* Choose which receivers/antennas to use */
-       if (il->ops->set_rxon_chain)
-               il->ops->set_rxon_chain(il);
-
-       il_init_scan_params(il);
-
-       ret = il_init_channel_map(il);
-       if (ret) {
-               IL_ERR("initializing regulatory failed: %d\n", ret);
-               goto err;
-       }
-
-       ret = il_init_geos(il);
-       if (ret) {
-               IL_ERR("initializing geos failed: %d\n", ret);
-               goto err_free_channel_map;
-       }
-       il4965_init_hw_rates(il, il->ieee_rates);
-
-       return 0;
-
-err_free_channel_map:
-       il_free_channel_map(il);
-err:
-       return ret;
-}
-
-static void
-il4965_uninit_drv(struct il_priv *il)
-{
-       il_free_geos(il);
-       il_free_channel_map(il);
-       kfree(il->scan_cmd);
-}
-
-static void
-il4965_hw_detect(struct il_priv *il)
-{
-       il->hw_rev = _il_rd(il, CSR_HW_REV);
-       il->hw_wa_rev = _il_rd(il, CSR_HW_REV_WA_REG);
-       il->rev_id = il->pci_dev->revision;
-       D_INFO("HW Revision ID = 0x%X\n", il->rev_id);
-}
-
-static struct il_sensitivity_ranges il4965_sensitivity = {
-       .min_nrg_cck = 97,
-       .max_nrg_cck = 0,       /* not used, set to 0 */
-
-       .auto_corr_min_ofdm = 85,
-       .auto_corr_min_ofdm_mrc = 170,
-       .auto_corr_min_ofdm_x1 = 105,
-       .auto_corr_min_ofdm_mrc_x1 = 220,
-
-       .auto_corr_max_ofdm = 120,
-       .auto_corr_max_ofdm_mrc = 210,
-       .auto_corr_max_ofdm_x1 = 140,
-       .auto_corr_max_ofdm_mrc_x1 = 270,
-
-       .auto_corr_min_cck = 125,
-       .auto_corr_max_cck = 200,
-       .auto_corr_min_cck_mrc = 200,
-       .auto_corr_max_cck_mrc = 400,
-
-       .nrg_th_cck = 100,
-       .nrg_th_ofdm = 100,
-
-       .barker_corr_th_min = 190,
-       .barker_corr_th_min_mrc = 390,
-       .nrg_th_cca = 62,
-};
-
-static void
-il4965_set_hw_params(struct il_priv *il)
-{
-       il->hw_params.bcast_id = IL4965_BROADCAST_ID;
-       il->hw_params.max_rxq_size = RX_QUEUE_SIZE;
-       il->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
-       if (il->cfg->mod_params->amsdu_size_8K)
-               il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_8K);
-       else
-               il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_4K);
-
-       il->hw_params.max_beacon_itrvl = IL_MAX_UCODE_BEACON_INTERVAL;
-
-       if (il->cfg->mod_params->disable_11n)
-               il->cfg->sku &= ~IL_SKU_N;
-
-       if (il->cfg->mod_params->num_of_queues >= IL_MIN_NUM_QUEUES &&
-           il->cfg->mod_params->num_of_queues <= IL49_NUM_QUEUES)
-               il->cfg->num_of_queues =
-                   il->cfg->mod_params->num_of_queues;
-
-       il->hw_params.max_txq_num = il->cfg->num_of_queues;
-       il->hw_params.dma_chnl_num = FH49_TCSR_CHNL_NUM;
-       il->hw_params.scd_bc_tbls_size =
-           il->cfg->num_of_queues *
-           sizeof(struct il4965_scd_bc_tbl);
-
-       il->hw_params.tfd_size = sizeof(struct il_tfd);
-       il->hw_params.max_stations = IL4965_STATION_COUNT;
-       il->hw_params.max_data_size = IL49_RTC_DATA_SIZE;
-       il->hw_params.max_inst_size = IL49_RTC_INST_SIZE;
-       il->hw_params.max_bsm_size = BSM_SRAM_SIZE;
-       il->hw_params.ht40_channel = BIT(IEEE80211_BAND_5GHZ);
-
-       il->hw_params.rx_wrt_ptr_reg = FH49_RSCSR_CHNL0_WPTR;
-
-       il->hw_params.tx_chains_num = il4965_num_of_ant(il->cfg->valid_tx_ant);
-       il->hw_params.rx_chains_num = il4965_num_of_ant(il->cfg->valid_rx_ant);
-       il->hw_params.valid_tx_ant = il->cfg->valid_tx_ant;
-       il->hw_params.valid_rx_ant = il->cfg->valid_rx_ant;
-
-       il->hw_params.ct_kill_threshold =
-          CELSIUS_TO_KELVIN(CT_KILL_THRESHOLD_LEGACY);
-
-       il->hw_params.sens = &il4965_sensitivity;
-       il->hw_params.beacon_time_tsf_bits = IL4965_EXT_BEACON_TIME_POS;
-}
-
-static int
-il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
-{
-       int err = 0;
-       struct il_priv *il;
-       struct ieee80211_hw *hw;
-       struct il_cfg *cfg = (struct il_cfg *)(ent->driver_data);
-       unsigned long flags;
-       u16 pci_cmd;
-
-       /************************
-        * 1. Allocating HW data
-        ************************/
-
-       hw = ieee80211_alloc_hw(sizeof(struct il_priv), &il4965_mac_ops);
-       if (!hw) {
-               err = -ENOMEM;
-               goto out;
-       }
-       il = hw->priv;
-       il->hw = hw;
-       SET_IEEE80211_DEV(hw, &pdev->dev);
-
-       D_INFO("*** LOAD DRIVER ***\n");
-       il->cfg = cfg;
-       il->ops = &il4965_ops;
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       il->debugfs_ops = &il4965_debugfs_ops;
-#endif
-       il->pci_dev = pdev;
-       il->inta_mask = CSR_INI_SET_MASK;
-
-       /**************************
-        * 2. Initializing PCI bus
-        **************************/
-       pci_disable_link_state(pdev,
-                              PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
-                              PCIE_LINK_STATE_CLKPM);
-
-       if (pci_enable_device(pdev)) {
-               err = -ENODEV;
-               goto out_ieee80211_free_hw;
-       }
-
-       pci_set_master(pdev);
-
-       err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
-       if (!err)
-               err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
-       if (err) {
-               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
-               if (!err)
-                       err =
-                           pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
-               /* both attempts failed: */
-               if (err) {
-                       IL_WARN("No suitable DMA available.\n");
-                       goto out_pci_disable_device;
-               }
-       }
-
-       err = pci_request_regions(pdev, DRV_NAME);
-       if (err)
-               goto out_pci_disable_device;
-
-       pci_set_drvdata(pdev, il);
-
-       /***********************
-        * 3. Read REV register
-        ***********************/
-       il->hw_base = pci_ioremap_bar(pdev, 0);
-       if (!il->hw_base) {
-               err = -ENODEV;
-               goto out_pci_release_regions;
-       }
-
-       D_INFO("pci_resource_len = 0x%08llx\n",
-              (unsigned long long)pci_resource_len(pdev, 0));
-       D_INFO("pci_resource_base = %p\n", il->hw_base);
-
-       /* these spin locks will be used in apm_ops.init and EEPROM access
-        * we should init now
-        */
-       spin_lock_init(&il->reg_lock);
-       spin_lock_init(&il->lock);
-
-       /*
-        * stop and reset the on-board processor just in case it is in a
-        * strange state ... like being left stranded by a primary kernel
-        * and this is now the kdump kernel trying to start up
-        */
-       _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
-
-       il4965_hw_detect(il);
-       IL_INFO("Detected %s, REV=0x%X\n", il->cfg->name, il->hw_rev);
-
-       /* We disable the RETRY_TIMEOUT register (0x41) to keep
-        * PCI Tx retries from interfering with C3 CPU state */
-       pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
-
-       il4965_prepare_card_hw(il);
-       if (!il->hw_ready) {
-               IL_WARN("Failed, HW not ready\n");
-               err = -EIO;
-               goto out_iounmap;
-       }
-
-       /*****************
-        * 4. Read EEPROM
-        *****************/
-       /* Read the EEPROM */
-       err = il_eeprom_init(il);
-       if (err) {
-               IL_ERR("Unable to init EEPROM\n");
-               goto out_iounmap;
-       }
-       err = il4965_eeprom_check_version(il);
-       if (err)
-               goto out_free_eeprom;
-
-       /* extract MAC Address */
-       il4965_eeprom_get_mac(il, il->addresses[0].addr);
-       D_INFO("MAC address: %pM\n", il->addresses[0].addr);
-       il->hw->wiphy->addresses = il->addresses;
-       il->hw->wiphy->n_addresses = 1;
-
-       /************************
-        * 5. Setup HW constants
-        ************************/
-       il4965_set_hw_params(il);
-
-       /*******************
-        * 6. Setup il
-        *******************/
-
-       err = il4965_init_drv(il);
-       if (err)
-               goto out_free_eeprom;
-       /* At this point both hw and il are initialized. */
-
-       /********************
-        * 7. Setup services
-        ********************/
-       spin_lock_irqsave(&il->lock, flags);
-       il_disable_interrupts(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       pci_enable_msi(il->pci_dev);
-
-       err = request_irq(il->pci_dev->irq, il_isr, IRQF_SHARED, DRV_NAME, il);
-       if (err) {
-               IL_ERR("Error allocating IRQ %d\n", il->pci_dev->irq);
-               goto out_disable_msi;
-       }
-
-       il4965_setup_deferred_work(il);
-       il4965_setup_handlers(il);
-
-       /*********************************************
-        * 8. Enable interrupts and read RFKILL state
-        *********************************************/
-
-       /* enable rfkill interrupt: hw bug w/a */
-       pci_read_config_word(il->pci_dev, PCI_COMMAND, &pci_cmd);
-       if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
-               pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
-               pci_write_config_word(il->pci_dev, PCI_COMMAND, pci_cmd);
-       }
-
-       il_enable_rfkill_int(il);
-
-       /* If platform's RF_KILL switch is NOT set to KILL */
-       if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
-               clear_bit(S_RFKILL, &il->status);
-       else
-               set_bit(S_RFKILL, &il->status);
-
-       wiphy_rfkill_set_hw_state(il->hw->wiphy,
-                                 test_bit(S_RFKILL, &il->status));
-
-       il_power_initialize(il);
-
-       init_completion(&il->_4965.firmware_loading_complete);
-
-       err = il4965_request_firmware(il, true);
-       if (err)
-               goto out_destroy_workqueue;
-
-       return 0;
-
-out_destroy_workqueue:
-       destroy_workqueue(il->workqueue);
-       il->workqueue = NULL;
-       free_irq(il->pci_dev->irq, il);
-out_disable_msi:
-       pci_disable_msi(il->pci_dev);
-       il4965_uninit_drv(il);
-out_free_eeprom:
-       il_eeprom_free(il);
-out_iounmap:
-       iounmap(il->hw_base);
-out_pci_release_regions:
-       pci_release_regions(pdev);
-out_pci_disable_device:
-       pci_disable_device(pdev);
-out_ieee80211_free_hw:
-       ieee80211_free_hw(il->hw);
-out:
-       return err;
-}
-
-static void
-il4965_pci_remove(struct pci_dev *pdev)
-{
-       struct il_priv *il = pci_get_drvdata(pdev);
-       unsigned long flags;
-
-       if (!il)
-               return;
-
-       wait_for_completion(&il->_4965.firmware_loading_complete);
-
-       D_INFO("*** UNLOAD DRIVER ***\n");
-
-       il_dbgfs_unregister(il);
-       sysfs_remove_group(&pdev->dev.kobj, &il_attribute_group);
-
-       /* ieee80211_unregister_hw call wil cause il_mac_stop to
-        * to be called and il4965_down since we are removing the device
-        * we need to set S_EXIT_PENDING bit.
-        */
-       set_bit(S_EXIT_PENDING, &il->status);
-
-       il_leds_exit(il);
-
-       if (il->mac80211_registered) {
-               ieee80211_unregister_hw(il->hw);
-               il->mac80211_registered = 0;
-       } else {
-               il4965_down(il);
-       }
-
-       /*
-        * Make sure device is reset to low power before unloading driver.
-        * This may be redundant with il4965_down(), but there are paths to
-        * run il4965_down() without calling apm_ops.stop(), and there are
-        * paths to avoid running il4965_down() at all before leaving driver.
-        * This (inexpensive) call *makes sure* device is reset.
-        */
-       il_apm_stop(il);
-
-       /* make sure we flush any pending irq or
-        * tasklet for the driver
-        */
-       spin_lock_irqsave(&il->lock, flags);
-       il_disable_interrupts(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       il4965_synchronize_irq(il);
-
-       il4965_dealloc_ucode_pci(il);
-
-       if (il->rxq.bd)
-               il4965_rx_queue_free(il, &il->rxq);
-       il4965_hw_txq_ctx_free(il);
-
-       il_eeprom_free(il);
-
-       /*netif_stop_queue(dev); */
-       flush_workqueue(il->workqueue);
-
-       /* ieee80211_unregister_hw calls il_mac_stop, which flushes
-        * il->workqueue... so we can't take down the workqueue
-        * until now... */
-       destroy_workqueue(il->workqueue);
-       il->workqueue = NULL;
-
-       free_irq(il->pci_dev->irq, il);
-       pci_disable_msi(il->pci_dev);
-       iounmap(il->hw_base);
-       pci_release_regions(pdev);
-       pci_disable_device(pdev);
-
-       il4965_uninit_drv(il);
-
-       dev_kfree_skb(il->beacon_skb);
-
-       ieee80211_free_hw(il->hw);
-}
-
-/*
- * Activate/Deactivate Tx DMA/FIFO channels according tx fifos mask
- * must be called under il->lock and mac access
- */
-void
-il4965_txq_set_sched(struct il_priv *il, u32 mask)
-{
-       il_wr_prph(il, IL49_SCD_TXFACT, mask);
-}
-
-/*****************************************************************************
- *
- * driver and module entry point
- *
- *****************************************************************************/
-
-/* Hardware specific file defines the PCI IDs table for that hardware module */
-static const struct pci_device_id il4965_hw_card_ids[] = {
-       {IL_PCI_DEVICE(0x4229, PCI_ANY_ID, il4965_cfg)},
-       {IL_PCI_DEVICE(0x4230, PCI_ANY_ID, il4965_cfg)},
-       {0}
-};
-MODULE_DEVICE_TABLE(pci, il4965_hw_card_ids);
-
-static struct pci_driver il4965_driver = {
-       .name = DRV_NAME,
-       .id_table = il4965_hw_card_ids,
-       .probe = il4965_pci_probe,
-       .remove = il4965_pci_remove,
-       .driver.pm = IL_LEGACY_PM_OPS,
-};
-
-static int __init
-il4965_init(void)
-{
-
-       int ret;
-       pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
-       pr_info(DRV_COPYRIGHT "\n");
-
-       ret = il4965_rate_control_register();
-       if (ret) {
-               pr_err("Unable to register rate control algorithm: %d\n", ret);
-               return ret;
-       }
-
-       ret = pci_register_driver(&il4965_driver);
-       if (ret) {
-               pr_err("Unable to initialize PCI module\n");
-               goto error_register;
-       }
-
-       return ret;
-
-error_register:
-       il4965_rate_control_unregister();
-       return ret;
-}
-
-static void __exit
-il4965_exit(void)
-{
-       pci_unregister_driver(&il4965_driver);
-       il4965_rate_control_unregister();
-}
-
-module_exit(il4965_exit);
-module_init(il4965_init);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-module_param_named(debug, il_debug_level, uint, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "debug output mask");
-#endif
-
-module_param_named(swcrypto, il4965_mod_params.sw_crypto, int, S_IRUGO);
-MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
-module_param_named(queues_num, il4965_mod_params.num_of_queues, int, S_IRUGO);
-MODULE_PARM_DESC(queues_num, "number of hw queues.");
-module_param_named(11n_disable, il4965_mod_params.disable_11n, int, S_IRUGO);
-MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
-module_param_named(amsdu_size_8K, il4965_mod_params.amsdu_size_8K, int,
-                  S_IRUGO);
-MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size (default 0 [disabled])");
-module_param_named(fw_restart, il4965_mod_params.restart_fw, int, S_IRUGO);
-MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
diff --git a/drivers/net/wireless/iwlegacy/4965-rs.c b/drivers/net/wireless/iwlegacy/4965-rs.c
deleted file mode 100644 (file)
index bac60b2..0000000
+++ /dev/null
@@ -1,2835 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-#include <linux/kernel.h>
-#include <linux/skbuff.h>
-#include <linux/slab.h>
-#include <net/mac80211.h>
-
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/delay.h>
-
-#include <linux/workqueue.h>
-
-#include "common.h"
-#include "4965.h"
-
-#define IL4965_RS_NAME "iwl-4965-rs"
-
-#define NUM_TRY_BEFORE_ANT_TOGGLE 1
-#define IL_NUMBER_TRY      1
-#define IL_HT_NUMBER_TRY   3
-
-#define RATE_MAX_WINDOW                62      /* # tx in history win */
-#define RATE_MIN_FAILURE_TH            6       /* min failures to calc tpt */
-#define RATE_MIN_SUCCESS_TH            8       /* min successes to calc tpt */
-
-/* max allowed rate miss before sync LQ cmd */
-#define IL_MISSED_RATE_MAX             15
-/* max time to accum history 2 seconds */
-#define RATE_SCALE_FLUSH_INTVL   (3*HZ)
-
-static u8 rs_ht_to_legacy[] = {
-       RATE_6M_IDX, RATE_6M_IDX,
-       RATE_6M_IDX, RATE_6M_IDX,
-       RATE_6M_IDX,
-       RATE_6M_IDX, RATE_9M_IDX,
-       RATE_12M_IDX, RATE_18M_IDX,
-       RATE_24M_IDX, RATE_36M_IDX,
-       RATE_48M_IDX, RATE_54M_IDX
-};
-
-static const u8 ant_toggle_lookup[] = {
-       /*ANT_NONE -> */ ANT_NONE,
-       /*ANT_A    -> */ ANT_B,
-       /*ANT_B    -> */ ANT_C,
-       /*ANT_AB   -> */ ANT_BC,
-       /*ANT_C    -> */ ANT_A,
-       /*ANT_AC   -> */ ANT_AB,
-       /*ANT_BC   -> */ ANT_AC,
-       /*ANT_ABC  -> */ ANT_ABC,
-};
-
-#define IL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np)    \
-       [RATE_##r##M_IDX] = { RATE_##r##M_PLCP,      \
-                                   RATE_SISO_##s##M_PLCP, \
-                                   RATE_MIMO2_##s##M_PLCP,\
-                                   RATE_##r##M_IEEE,      \
-                                   RATE_##ip##M_IDX,    \
-                                   RATE_##in##M_IDX,    \
-                                   RATE_##rp##M_IDX,    \
-                                   RATE_##rn##M_IDX,    \
-                                   RATE_##pp##M_IDX,    \
-                                   RATE_##np##M_IDX }
-
-/*
- * Parameter order:
- *   rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
- *
- * If there isn't a valid next or previous rate then INV is used which
- * maps to RATE_INVALID
- *
- */
-const struct il_rate_info il_rates[RATE_COUNT] = {
-       IL_DECLARE_RATE_INFO(1, INV, INV, 2, INV, 2, INV, 2),   /*  1mbps */
-       IL_DECLARE_RATE_INFO(2, INV, 1, 5, 1, 5, 1, 5),         /*  2mbps */
-       IL_DECLARE_RATE_INFO(5, INV, 2, 6, 2, 11, 2, 11),       /*5.5mbps */
-       IL_DECLARE_RATE_INFO(11, INV, 9, 12, 9, 12, 5, 18),     /* 11mbps */
-       IL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11),         /*  6mbps */
-       IL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11),        /*  9mbps */
-       IL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18),   /* 12mbps */
-       IL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24),   /* 18mbps */
-       IL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36),   /* 24mbps */
-       IL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48),   /* 36mbps */
-       IL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54),   /* 48mbps */
-       IL_DECLARE_RATE_INFO(54, 54, 48, INV, 48, INV, 48, INV),/* 54mbps */
-       IL_DECLARE_RATE_INFO(60, 60, 48, INV, 48, INV, 48, INV),/* 60mbps */
-};
-
-static int
-il4965_hwrate_to_plcp_idx(u32 rate_n_flags)
-{
-       int idx = 0;
-
-       /* HT rate format */
-       if (rate_n_flags & RATE_MCS_HT_MSK) {
-               idx = (rate_n_flags & 0xff);
-
-               if (idx >= RATE_MIMO2_6M_PLCP)
-                       idx = idx - RATE_MIMO2_6M_PLCP;
-
-               idx += IL_FIRST_OFDM_RATE;
-               /* skip 9M not supported in ht */
-               if (idx >= RATE_9M_IDX)
-                       idx += 1;
-               if (idx >= IL_FIRST_OFDM_RATE && idx <= IL_LAST_OFDM_RATE)
-                       return idx;
-
-               /* legacy rate format, search for match in table */
-       } else {
-               for (idx = 0; idx < ARRAY_SIZE(il_rates); idx++)
-                       if (il_rates[idx].plcp == (rate_n_flags & 0xFF))
-                               return idx;
-       }
-
-       return -1;
-}
-
-static void il4965_rs_rate_scale_perform(struct il_priv *il,
-                                        struct sk_buff *skb,
-                                        struct ieee80211_sta *sta,
-                                        struct il_lq_sta *lq_sta);
-static void il4965_rs_fill_link_cmd(struct il_priv *il,
-                                   struct il_lq_sta *lq_sta, u32 rate_n_flags);
-static void il4965_rs_stay_in_table(struct il_lq_sta *lq_sta,
-                                   bool force_search);
-
-#ifdef CONFIG_MAC80211_DEBUGFS
-static void il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta,
-                                   u32 *rate_n_flags, int idx);
-#else
-static void
-il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta, u32 * rate_n_flags, int idx)
-{
-}
-#endif
-
-/**
- * The following tables contain the expected throughput metrics for all rates
- *
- *     1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 60 MBits
- *
- * where invalid entries are zeros.
- *
- * CCK rates are only valid in legacy table and will only be used in G
- * (2.4 GHz) band.
- */
-
-static s32 expected_tpt_legacy[RATE_COUNT] = {
-       7, 13, 35, 58, 40, 57, 72, 98, 121, 154, 177, 186, 0
-};
-
-static s32 expected_tpt_siso20MHz[4][RATE_COUNT] = {
-       {0, 0, 0, 0, 42, 0, 76, 102, 124, 158, 183, 193, 202},  /* Norm */
-       {0, 0, 0, 0, 46, 0, 82, 110, 132, 167, 192, 202, 210},  /* SGI */
-       {0, 0, 0, 0, 48, 0, 93, 135, 176, 251, 319, 351, 381},  /* AGG */
-       {0, 0, 0, 0, 53, 0, 102, 149, 193, 275, 348, 381, 413}, /* AGG+SGI */
-};
-
-static s32 expected_tpt_siso40MHz[4][RATE_COUNT] = {
-       {0, 0, 0, 0, 77, 0, 127, 160, 184, 220, 242, 250, 257}, /* Norm */
-       {0, 0, 0, 0, 83, 0, 135, 169, 193, 229, 250, 257, 264}, /* SGI */
-       {0, 0, 0, 0, 96, 0, 182, 259, 328, 451, 553, 598, 640}, /* AGG */
-       {0, 0, 0, 0, 106, 0, 199, 282, 357, 487, 593, 640, 683},        /* AGG+SGI */
-};
-
-static s32 expected_tpt_mimo2_20MHz[4][RATE_COUNT] = {
-       {0, 0, 0, 0, 74, 0, 123, 155, 179, 213, 235, 243, 250}, /* Norm */
-       {0, 0, 0, 0, 81, 0, 131, 164, 187, 221, 242, 250, 256}, /* SGI */
-       {0, 0, 0, 0, 92, 0, 175, 250, 317, 436, 534, 578, 619}, /* AGG */
-       {0, 0, 0, 0, 102, 0, 192, 273, 344, 470, 573, 619, 660},        /* AGG+SGI */
-};
-
-static s32 expected_tpt_mimo2_40MHz[4][RATE_COUNT] = {
-       {0, 0, 0, 0, 123, 0, 182, 214, 235, 264, 279, 285, 289},        /* Norm */
-       {0, 0, 0, 0, 131, 0, 191, 222, 242, 270, 284, 289, 293},        /* SGI */
-       {0, 0, 0, 0, 180, 0, 327, 446, 545, 708, 828, 878, 922},        /* AGG */
-       {0, 0, 0, 0, 197, 0, 355, 481, 584, 752, 872, 922, 966},        /* AGG+SGI */
-};
-
-/* mbps, mcs */
-static const struct il_rate_mcs_info il_rate_mcs[RATE_COUNT] = {
-       {"1", "BPSK DSSS"},
-       {"2", "QPSK DSSS"},
-       {"5.5", "BPSK CCK"},
-       {"11", "QPSK CCK"},
-       {"6", "BPSK 1/2"},
-       {"9", "BPSK 1/2"},
-       {"12", "QPSK 1/2"},
-       {"18", "QPSK 3/4"},
-       {"24", "16QAM 1/2"},
-       {"36", "16QAM 3/4"},
-       {"48", "64QAM 2/3"},
-       {"54", "64QAM 3/4"},
-       {"60", "64QAM 5/6"},
-};
-
-#define MCS_IDX_PER_STREAM     (8)
-
-static inline u8
-il4965_rs_extract_rate(u32 rate_n_flags)
-{
-       return (u8) (rate_n_flags & 0xFF);
-}
-
-static void
-il4965_rs_rate_scale_clear_win(struct il_rate_scale_data *win)
-{
-       win->data = 0;
-       win->success_counter = 0;
-       win->success_ratio = IL_INVALID_VALUE;
-       win->counter = 0;
-       win->average_tpt = IL_INVALID_VALUE;
-       win->stamp = 0;
-}
-
-static inline u8
-il4965_rs_is_valid_ant(u8 valid_antenna, u8 ant_type)
-{
-       return (ant_type & valid_antenna) == ant_type;
-}
-
-/*
- *     removes the old data from the stats. All data that is older than
- *     TID_MAX_TIME_DIFF, will be deleted.
- */
-static void
-il4965_rs_tl_rm_old_stats(struct il_traffic_load *tl, u32 curr_time)
-{
-       /* The oldest age we want to keep */
-       u32 oldest_time = curr_time - TID_MAX_TIME_DIFF;
-
-       while (tl->queue_count && tl->time_stamp < oldest_time) {
-               tl->total -= tl->packet_count[tl->head];
-               tl->packet_count[tl->head] = 0;
-               tl->time_stamp += TID_QUEUE_CELL_SPACING;
-               tl->queue_count--;
-               tl->head++;
-               if (tl->head >= TID_QUEUE_MAX_SIZE)
-                       tl->head = 0;
-       }
-}
-
-/*
- *     increment traffic load value for tid and also remove
- *     any old values if passed the certain time period
- */
-static u8
-il4965_rs_tl_add_packet(struct il_lq_sta *lq_data, struct ieee80211_hdr *hdr)
-{
-       u32 curr_time = jiffies_to_msecs(jiffies);
-       u32 time_diff;
-       s32 idx;
-       struct il_traffic_load *tl = NULL;
-       u8 tid;
-
-       if (ieee80211_is_data_qos(hdr->frame_control)) {
-               u8 *qc = ieee80211_get_qos_ctl(hdr);
-               tid = qc[0] & 0xf;
-       } else
-               return MAX_TID_COUNT;
-
-       if (unlikely(tid >= TID_MAX_LOAD_COUNT))
-               return MAX_TID_COUNT;
-
-       tl = &lq_data->load[tid];
-
-       curr_time -= curr_time % TID_ROUND_VALUE;
-
-       /* Happens only for the first packet. Initialize the data */
-       if (!(tl->queue_count)) {
-               tl->total = 1;
-               tl->time_stamp = curr_time;
-               tl->queue_count = 1;
-               tl->head = 0;
-               tl->packet_count[0] = 1;
-               return MAX_TID_COUNT;
-       }
-
-       time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
-       idx = time_diff / TID_QUEUE_CELL_SPACING;
-
-       /* The history is too long: remove data that is older than */
-       /* TID_MAX_TIME_DIFF */
-       if (idx >= TID_QUEUE_MAX_SIZE)
-               il4965_rs_tl_rm_old_stats(tl, curr_time);
-
-       idx = (tl->head + idx) % TID_QUEUE_MAX_SIZE;
-       tl->packet_count[idx] = tl->packet_count[idx] + 1;
-       tl->total = tl->total + 1;
-
-       if ((idx + 1) > tl->queue_count)
-               tl->queue_count = idx + 1;
-
-       return tid;
-}
-
-/*
-       get the traffic load value for tid
-*/
-static u32
-il4965_rs_tl_get_load(struct il_lq_sta *lq_data, u8 tid)
-{
-       u32 curr_time = jiffies_to_msecs(jiffies);
-       u32 time_diff;
-       s32 idx;
-       struct il_traffic_load *tl = NULL;
-
-       if (tid >= TID_MAX_LOAD_COUNT)
-               return 0;
-
-       tl = &(lq_data->load[tid]);
-
-       curr_time -= curr_time % TID_ROUND_VALUE;
-
-       if (!(tl->queue_count))
-               return 0;
-
-       time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
-       idx = time_diff / TID_QUEUE_CELL_SPACING;
-
-       /* The history is too long: remove data that is older than */
-       /* TID_MAX_TIME_DIFF */
-       if (idx >= TID_QUEUE_MAX_SIZE)
-               il4965_rs_tl_rm_old_stats(tl, curr_time);
-
-       return tl->total;
-}
-
-static int
-il4965_rs_tl_turn_on_agg_for_tid(struct il_priv *il, struct il_lq_sta *lq_data,
-                                u8 tid, struct ieee80211_sta *sta)
-{
-       int ret = -EAGAIN;
-       u32 load;
-
-       load = il4965_rs_tl_get_load(lq_data, tid);
-
-       if (load > IL_AGG_LOAD_THRESHOLD) {
-               D_HT("Starting Tx agg: STA: %pM tid: %d\n", sta->addr, tid);
-               ret = ieee80211_start_tx_ba_session(sta, tid, 5000);
-               if (ret == -EAGAIN) {
-                       /*
-                        * driver and mac80211 is out of sync
-                        * this might be cause by reloading firmware
-                        * stop the tx ba session here
-                        */
-                       IL_ERR("Fail start Tx agg on tid: %d\n", tid);
-                       ieee80211_stop_tx_ba_session(sta, tid);
-               }
-       } else
-               D_HT("Aggregation not enabled for tid %d because load = %u\n",
-                    tid, load);
-
-       return ret;
-}
-
-static void
-il4965_rs_tl_turn_on_agg(struct il_priv *il, u8 tid, struct il_lq_sta *lq_data,
-                        struct ieee80211_sta *sta)
-{
-       if (tid < TID_MAX_LOAD_COUNT)
-               il4965_rs_tl_turn_on_agg_for_tid(il, lq_data, tid, sta);
-       else
-               IL_ERR("tid exceeds max load count: %d/%d\n", tid,
-                      TID_MAX_LOAD_COUNT);
-}
-
-static inline int
-il4965_get_il4965_num_of_ant_from_rate(u32 rate_n_flags)
-{
-       return !!(rate_n_flags & RATE_MCS_ANT_A_MSK) +
-           !!(rate_n_flags & RATE_MCS_ANT_B_MSK) +
-           !!(rate_n_flags & RATE_MCS_ANT_C_MSK);
-}
-
-/*
- * Static function to get the expected throughput from an il_scale_tbl_info
- * that wraps a NULL pointer check
- */
-static s32
-il4965_get_expected_tpt(struct il_scale_tbl_info *tbl, int rs_idx)
-{
-       if (tbl->expected_tpt)
-               return tbl->expected_tpt[rs_idx];
-       return 0;
-}
-
-/**
- * il4965_rs_collect_tx_data - Update the success/failure sliding win
- *
- * We keep a sliding win of the last 62 packets transmitted
- * at this rate.  win->data contains the bitmask of successful
- * packets.
- */
-static int
-il4965_rs_collect_tx_data(struct il_scale_tbl_info *tbl, int scale_idx,
-                         int attempts, int successes)
-{
-       struct il_rate_scale_data *win = NULL;
-       static const u64 mask = (((u64) 1) << (RATE_MAX_WINDOW - 1));
-       s32 fail_count, tpt;
-
-       if (scale_idx < 0 || scale_idx >= RATE_COUNT)
-               return -EINVAL;
-
-       /* Select win for current tx bit rate */
-       win = &(tbl->win[scale_idx]);
-
-       /* Get expected throughput */
-       tpt = il4965_get_expected_tpt(tbl, scale_idx);
-
-       /*
-        * Keep track of only the latest 62 tx frame attempts in this rate's
-        * history win; anything older isn't really relevant any more.
-        * If we have filled up the sliding win, 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 (attempts > 0) {
-               if (win->counter >= RATE_MAX_WINDOW) {
-
-                       /* remove earliest */
-                       win->counter = RATE_MAX_WINDOW - 1;
-
-                       if (win->data & mask) {
-                               win->data &= ~mask;
-                               win->success_counter--;
-                       }
-               }
-
-               /* Increment frames-attempted counter */
-               win->counter++;
-
-               /* Shift bitmap by one frame to throw away oldest history */
-               win->data <<= 1;
-
-               /* Mark the most recent #successes attempts as successful */
-               if (successes > 0) {
-                       win->success_counter++;
-                       win->data |= 0x1;
-                       successes--;
-               }
-
-               attempts--;
-       }
-
-       /* Calculate current success ratio, avoid divide-by-0! */
-       if (win->counter > 0)
-               win->success_ratio =
-                   128 * (100 * win->success_counter) / win->counter;
-       else
-               win->success_ratio = IL_INVALID_VALUE;
-
-       fail_count = win->counter - win->success_counter;
-
-       /* Calculate average throughput, if we have enough history. */
-       if (fail_count >= RATE_MIN_FAILURE_TH ||
-           win->success_counter >= RATE_MIN_SUCCESS_TH)
-               win->average_tpt = (win->success_ratio * tpt + 64) / 128;
-       else
-               win->average_tpt = IL_INVALID_VALUE;
-
-       /* Tag this win as having been updated */
-       win->stamp = jiffies;
-
-       return 0;
-}
-
-/*
- * Fill uCode API rate_n_flags field, based on "search" or "active" table.
- */
-static u32
-il4965_rate_n_flags_from_tbl(struct il_priv *il, struct il_scale_tbl_info *tbl,
-                            int idx, u8 use_green)
-{
-       u32 rate_n_flags = 0;
-
-       if (is_legacy(tbl->lq_type)) {
-               rate_n_flags = il_rates[idx].plcp;
-               if (idx >= IL_FIRST_CCK_RATE && idx <= IL_LAST_CCK_RATE)
-                       rate_n_flags |= RATE_MCS_CCK_MSK;
-
-       } else if (is_Ht(tbl->lq_type)) {
-               if (idx > IL_LAST_OFDM_RATE) {
-                       IL_ERR("Invalid HT rate idx %d\n", idx);
-                       idx = IL_LAST_OFDM_RATE;
-               }
-               rate_n_flags = RATE_MCS_HT_MSK;
-
-               if (is_siso(tbl->lq_type))
-                       rate_n_flags |= il_rates[idx].plcp_siso;
-               else
-                       rate_n_flags |= il_rates[idx].plcp_mimo2;
-       } else {
-               IL_ERR("Invalid tbl->lq_type %d\n", tbl->lq_type);
-       }
-
-       rate_n_flags |=
-           ((tbl->ant_type << RATE_MCS_ANT_POS) & RATE_MCS_ANT_ABC_MSK);
-
-       if (is_Ht(tbl->lq_type)) {
-               if (tbl->is_ht40) {
-                       if (tbl->is_dup)
-                               rate_n_flags |= RATE_MCS_DUP_MSK;
-                       else
-                               rate_n_flags |= RATE_MCS_HT40_MSK;
-               }
-               if (tbl->is_SGI)
-                       rate_n_flags |= RATE_MCS_SGI_MSK;
-
-               if (use_green) {
-                       rate_n_flags |= RATE_MCS_GF_MSK;
-                       if (is_siso(tbl->lq_type) && tbl->is_SGI) {
-                               rate_n_flags &= ~RATE_MCS_SGI_MSK;
-                               IL_ERR("GF was set with SGI:SISO\n");
-                       }
-               }
-       }
-       return rate_n_flags;
-}
-
-/*
- * Interpret uCode API's rate_n_flags format,
- * fill "search" or "active" tx mode table.
- */
-static int
-il4965_rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
-                               enum ieee80211_band band,
-                               struct il_scale_tbl_info *tbl, int *rate_idx)
-{
-       u32 ant_msk = (rate_n_flags & RATE_MCS_ANT_ABC_MSK);
-       u8 il4965_num_of_ant =
-           il4965_get_il4965_num_of_ant_from_rate(rate_n_flags);
-       u8 mcs;
-
-       memset(tbl, 0, sizeof(struct il_scale_tbl_info));
-       *rate_idx = il4965_hwrate_to_plcp_idx(rate_n_flags);
-
-       if (*rate_idx == RATE_INVALID) {
-               *rate_idx = -1;
-               return -EINVAL;
-       }
-       tbl->is_SGI = 0;        /* default legacy setup */
-       tbl->is_ht40 = 0;
-       tbl->is_dup = 0;
-       tbl->ant_type = (ant_msk >> RATE_MCS_ANT_POS);
-       tbl->lq_type = LQ_NONE;
-       tbl->max_search = IL_MAX_SEARCH;
-
-       /* legacy rate format */
-       if (!(rate_n_flags & RATE_MCS_HT_MSK)) {
-               if (il4965_num_of_ant == 1) {
-                       if (band == IEEE80211_BAND_5GHZ)
-                               tbl->lq_type = LQ_A;
-                       else
-                               tbl->lq_type = LQ_G;
-               }
-               /* HT rate format */
-       } else {
-               if (rate_n_flags & RATE_MCS_SGI_MSK)
-                       tbl->is_SGI = 1;
-
-               if ((rate_n_flags & RATE_MCS_HT40_MSK) ||
-                   (rate_n_flags & RATE_MCS_DUP_MSK))
-                       tbl->is_ht40 = 1;
-
-               if (rate_n_flags & RATE_MCS_DUP_MSK)
-                       tbl->is_dup = 1;
-
-               mcs = il4965_rs_extract_rate(rate_n_flags);
-
-               /* SISO */
-               if (mcs <= RATE_SISO_60M_PLCP) {
-                       if (il4965_num_of_ant == 1)
-                               tbl->lq_type = LQ_SISO; /*else NONE */
-                       /* MIMO2 */
-               } else {
-                       if (il4965_num_of_ant == 2)
-                               tbl->lq_type = LQ_MIMO2;
-               }
-       }
-       return 0;
-}
-
-/* switch to another antenna/antennas and return 1 */
-/* if no other valid antenna found, return 0 */
-static int
-il4965_rs_toggle_antenna(u32 valid_ant, u32 *rate_n_flags,
-                        struct il_scale_tbl_info *tbl)
-{
-       u8 new_ant_type;
-
-       if (!tbl->ant_type || tbl->ant_type > ANT_ABC)
-               return 0;
-
-       if (!il4965_rs_is_valid_ant(valid_ant, tbl->ant_type))
-               return 0;
-
-       new_ant_type = ant_toggle_lookup[tbl->ant_type];
-
-       while (new_ant_type != tbl->ant_type &&
-              !il4965_rs_is_valid_ant(valid_ant, new_ant_type))
-               new_ant_type = ant_toggle_lookup[new_ant_type];
-
-       if (new_ant_type == tbl->ant_type)
-               return 0;
-
-       tbl->ant_type = new_ant_type;
-       *rate_n_flags &= ~RATE_MCS_ANT_ABC_MSK;
-       *rate_n_flags |= new_ant_type << RATE_MCS_ANT_POS;
-       return 1;
-}
-
-/**
- * Green-field mode is valid if the station supports it and
- * there are no non-GF stations present in the BSS.
- */
-static bool
-il4965_rs_use_green(struct il_priv *il, struct ieee80211_sta *sta)
-{
-       return (sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD) &&
-              !il->ht.non_gf_sta_present;
-}
-
-/**
- * il4965_rs_get_supported_rates - get the available rates
- *
- * if management frame or broadcast frame only return
- * basic available rates.
- *
- */
-static u16
-il4965_rs_get_supported_rates(struct il_lq_sta *lq_sta,
-                             struct ieee80211_hdr *hdr,
-                             enum il_table_type rate_type)
-{
-       if (is_legacy(rate_type)) {
-               return lq_sta->active_legacy_rate;
-       } else {
-               if (is_siso(rate_type))
-                       return lq_sta->active_siso_rate;
-               else
-                       return lq_sta->active_mimo2_rate;
-       }
-}
-
-static u16
-il4965_rs_get_adjacent_rate(struct il_priv *il, u8 idx, u16 rate_mask,
-                           int rate_type)
-{
-       u8 high = RATE_INVALID;
-       u8 low = RATE_INVALID;
-
-       /* 802.11A or ht walks to the next literal adjacent rate in
-        * the rate table */
-       if (is_a_band(rate_type) || !is_legacy(rate_type)) {
-               int i;
-               u32 mask;
-
-               /* Find the previous rate that is in the rate mask */
-               i = idx - 1;
-               for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
-                       if (rate_mask & mask) {
-                               low = i;
-                               break;
-                       }
-               }
-
-               /* Find the next rate that is in the rate mask */
-               i = idx + 1;
-               for (mask = (1 << i); i < RATE_COUNT; i++, mask <<= 1) {
-                       if (rate_mask & mask) {
-                               high = i;
-                               break;
-                       }
-               }
-
-               return (high << 8) | low;
-       }
-
-       low = idx;
-       while (low != RATE_INVALID) {
-               low = il_rates[low].prev_rs;
-               if (low == RATE_INVALID)
-                       break;
-               if (rate_mask & (1 << low))
-                       break;
-               D_RATE("Skipping masked lower rate: %d\n", low);
-       }
-
-       high = idx;
-       while (high != RATE_INVALID) {
-               high = il_rates[high].next_rs;
-               if (high == RATE_INVALID)
-                       break;
-               if (rate_mask & (1 << high))
-                       break;
-               D_RATE("Skipping masked higher rate: %d\n", high);
-       }
-
-       return (high << 8) | low;
-}
-
-static u32
-il4965_rs_get_lower_rate(struct il_lq_sta *lq_sta,
-                        struct il_scale_tbl_info *tbl, u8 scale_idx,
-                        u8 ht_possible)
-{
-       s32 low;
-       u16 rate_mask;
-       u16 high_low;
-       u8 switch_to_legacy = 0;
-       u8 is_green = lq_sta->is_green;
-       struct il_priv *il = lq_sta->drv;
-
-       /* check if we need to switch from HT to legacy rates.
-        * assumption is that mandatory rates (1Mbps or 6Mbps)
-        * are always supported (spec demand) */
-       if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_idx)) {
-               switch_to_legacy = 1;
-               scale_idx = rs_ht_to_legacy[scale_idx];
-               if (lq_sta->band == IEEE80211_BAND_5GHZ)
-                       tbl->lq_type = LQ_A;
-               else
-                       tbl->lq_type = LQ_G;
-
-               if (il4965_num_of_ant(tbl->ant_type) > 1)
-                       tbl->ant_type =
-                           il4965_first_antenna(il->hw_params.valid_tx_ant);
-
-               tbl->is_ht40 = 0;
-               tbl->is_SGI = 0;
-               tbl->max_search = IL_MAX_SEARCH;
-       }
-
-       rate_mask = il4965_rs_get_supported_rates(lq_sta, NULL, tbl->lq_type);
-
-       /* Mask with station rate restriction */
-       if (is_legacy(tbl->lq_type)) {
-               /* supp_rates has no CCK bits in A mode */
-               if (lq_sta->band == IEEE80211_BAND_5GHZ)
-                       rate_mask =
-                           (u16) (rate_mask &
-                                  (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
-               else
-                       rate_mask = (u16) (rate_mask & lq_sta->supp_rates);
-       }
-
-       /* If we switched from HT to legacy, check current rate */
-       if (switch_to_legacy && (rate_mask & (1 << scale_idx))) {
-               low = scale_idx;
-               goto out;
-       }
-
-       high_low =
-           il4965_rs_get_adjacent_rate(lq_sta->drv, scale_idx, rate_mask,
-                                       tbl->lq_type);
-       low = high_low & 0xff;
-
-       if (low == RATE_INVALID)
-               low = scale_idx;
-
-out:
-       return il4965_rate_n_flags_from_tbl(lq_sta->drv, tbl, low, is_green);
-}
-
-/*
- * Simple function to compare two rate scale table types
- */
-static bool
-il4965_table_type_matches(struct il_scale_tbl_info *a,
-                         struct il_scale_tbl_info *b)
-{
-       return (a->lq_type == b->lq_type && a->ant_type == b->ant_type &&
-               a->is_SGI == b->is_SGI);
-}
-
-/*
- * mac80211 sends us Tx status
- */
-static void
-il4965_rs_tx_status(void *il_r, struct ieee80211_supported_band *sband,
-                   struct ieee80211_sta *sta, void *il_sta,
-                   struct sk_buff *skb)
-{
-       int legacy_success;
-       int retries;
-       int rs_idx, mac_idx, i;
-       struct il_lq_sta *lq_sta = il_sta;
-       struct il_link_quality_cmd *table;
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-       struct il_priv *il = (struct il_priv *)il_r;
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-       enum mac80211_rate_control_flags mac_flags;
-       u32 tx_rate;
-       struct il_scale_tbl_info tbl_type;
-       struct il_scale_tbl_info *curr_tbl, *other_tbl, *tmp_tbl;
-
-       D_RATE("get frame ack response, update rate scale win\n");
-
-       /* Treat uninitialized rate scaling data same as non-existing. */
-       if (!lq_sta) {
-               D_RATE("Station rate scaling not created yet.\n");
-               return;
-       } else if (!lq_sta->drv) {
-               D_RATE("Rate scaling not initialized yet.\n");
-               return;
-       }
-
-       if (!ieee80211_is_data(hdr->frame_control) ||
-           (info->flags & IEEE80211_TX_CTL_NO_ACK))
-               return;
-
-       /* This packet was aggregated but doesn't carry status info */
-       if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
-           !(info->flags & IEEE80211_TX_STAT_AMPDU))
-               return;
-
-       /*
-        * Ignore this Tx frame response if its initial rate doesn't match
-        * that of latest Link Quality command.  There may be stragglers
-        * from a previous Link Quality command, but we're no longer interested
-        * in those; they're either from the "active" mode while we're trying
-        * to check "search" mode, or a prior "search" mode after we've moved
-        * to a new "search" mode (which might become the new "active" mode).
-        */
-       table = &lq_sta->lq;
-       tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
-       il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type, &rs_idx);
-       if (il->band == IEEE80211_BAND_5GHZ)
-               rs_idx -= IL_FIRST_OFDM_RATE;
-       mac_flags = info->status.rates[0].flags;
-       mac_idx = info->status.rates[0].idx;
-       /* For HT packets, map MCS to PLCP */
-       if (mac_flags & IEEE80211_TX_RC_MCS) {
-               mac_idx &= RATE_MCS_CODE_MSK;   /* Remove # of streams */
-               if (mac_idx >= (RATE_9M_IDX - IL_FIRST_OFDM_RATE))
-                       mac_idx++;
-               /*
-                * mac80211 HT idx is always zero-idxed; we need to move
-                * HT OFDM rates after CCK rates in 2.4 GHz band
-                */
-               if (il->band == IEEE80211_BAND_2GHZ)
-                       mac_idx += IL_FIRST_OFDM_RATE;
-       }
-       /* Here we actually compare this rate to the latest LQ command */
-       if (mac_idx < 0 ||
-           tbl_type.is_SGI != !!(mac_flags & IEEE80211_TX_RC_SHORT_GI) ||
-           tbl_type.is_ht40 != !!(mac_flags & IEEE80211_TX_RC_40_MHZ_WIDTH) ||
-           tbl_type.is_dup != !!(mac_flags & IEEE80211_TX_RC_DUP_DATA) ||
-           tbl_type.ant_type != info->status.antenna ||
-           !!(tx_rate & RATE_MCS_HT_MSK) != !!(mac_flags & IEEE80211_TX_RC_MCS)
-           || !!(tx_rate & RATE_MCS_GF_MSK) !=
-           !!(mac_flags & IEEE80211_TX_RC_GREEN_FIELD) || rs_idx != mac_idx) {
-               D_RATE("initial rate %d does not match %d (0x%x)\n", mac_idx,
-                      rs_idx, tx_rate);
-               /*
-                * Since rates mis-match, the last LQ command may have failed.
-                * After IL_MISSED_RATE_MAX mis-matches, resync the uCode with
-                * ... driver.
-                */
-               lq_sta->missed_rate_counter++;
-               if (lq_sta->missed_rate_counter > IL_MISSED_RATE_MAX) {
-                       lq_sta->missed_rate_counter = 0;
-                       il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
-               }
-               /* Regardless, ignore this status info for outdated rate */
-               return;
-       } else
-               /* Rate did match, so reset the missed_rate_counter */
-               lq_sta->missed_rate_counter = 0;
-
-       /* Figure out if rate scale algorithm is in active or search table */
-       if (il4965_table_type_matches
-           (&tbl_type, &(lq_sta->lq_info[lq_sta->active_tbl]))) {
-               curr_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-               other_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
-       } else
-           if (il4965_table_type_matches
-               (&tbl_type, &lq_sta->lq_info[1 - lq_sta->active_tbl])) {
-               curr_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
-               other_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-       } else {
-               D_RATE("Neither active nor search matches tx rate\n");
-               tmp_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-               D_RATE("active- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
-                      tmp_tbl->ant_type, tmp_tbl->is_SGI);
-               tmp_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
-               D_RATE("search- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
-                      tmp_tbl->ant_type, tmp_tbl->is_SGI);
-               D_RATE("actual- lq:%x, ant:%x, SGI:%d\n", tbl_type.lq_type,
-                      tbl_type.ant_type, tbl_type.is_SGI);
-               /*
-                * no matching table found, let's by-pass the data collection
-                * and continue to perform rate scale to find the rate table
-                */
-               il4965_rs_stay_in_table(lq_sta, true);
-               goto done;
-       }
-
-       /*
-        * Updating the frame history depends on whether packets were
-        * aggregated.
-        *
-        * For aggregation, all packets were transmitted at the same rate, the
-        * first idx into rate scale table.
-        */
-       if (info->flags & IEEE80211_TX_STAT_AMPDU) {
-               tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
-               il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type,
-                                               &rs_idx);
-               il4965_rs_collect_tx_data(curr_tbl, rs_idx,
-                                         info->status.ampdu_len,
-                                         info->status.ampdu_ack_len);
-
-               /* Update success/fail counts if not searching for new mode */
-               if (lq_sta->stay_in_tbl) {
-                       lq_sta->total_success += info->status.ampdu_ack_len;
-                       lq_sta->total_failed +=
-                           (info->status.ampdu_len -
-                            info->status.ampdu_ack_len);
-               }
-       } else {
-               /*
-                * For legacy, update frame history with for each Tx retry.
-                */
-               retries = info->status.rates[0].count - 1;
-               /* HW doesn't send more than 15 retries */
-               retries = min(retries, 15);
-
-               /* The last transmission may have been successful */
-               legacy_success = !!(info->flags & IEEE80211_TX_STAT_ACK);
-               /* Collect data for each rate used during failed TX attempts */
-               for (i = 0; i <= retries; ++i) {
-                       tx_rate = le32_to_cpu(table->rs_table[i].rate_n_flags);
-                       il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band,
-                                                       &tbl_type, &rs_idx);
-                       /*
-                        * Only collect stats if retried rate is in the same RS
-                        * table as active/search.
-                        */
-                       if (il4965_table_type_matches(&tbl_type, curr_tbl))
-                               tmp_tbl = curr_tbl;
-                       else if (il4965_table_type_matches
-                                (&tbl_type, other_tbl))
-                               tmp_tbl = other_tbl;
-                       else
-                               continue;
-                       il4965_rs_collect_tx_data(tmp_tbl, rs_idx, 1,
-                                                 i <
-                                                 retries ? 0 : legacy_success);
-               }
-
-               /* Update success/fail counts if not searching for new mode */
-               if (lq_sta->stay_in_tbl) {
-                       lq_sta->total_success += legacy_success;
-                       lq_sta->total_failed += retries + (1 - legacy_success);
-               }
-       }
-       /* The last TX rate is cached in lq_sta; it's set in if/else above */
-       lq_sta->last_rate_n_flags = tx_rate;
-done:
-       /* See if there's a better rate or modulation mode to try. */
-       if (sta->supp_rates[sband->band])
-               il4965_rs_rate_scale_perform(il, skb, sta, lq_sta);
-}
-
-/*
- * Begin a period of staying with a selected modulation mode.
- * Set "stay_in_tbl" flag to prevent any mode switches.
- * Set frame tx success limits according to legacy vs. high-throughput,
- * and reset overall (spanning all rates) tx success history stats.
- * These control how long we stay using same modulation mode before
- * searching for a new mode.
- */
-static void
-il4965_rs_set_stay_in_table(struct il_priv *il, u8 is_legacy,
-                           struct il_lq_sta *lq_sta)
-{
-       D_RATE("we are staying in the same table\n");
-       lq_sta->stay_in_tbl = 1;        /* only place this gets set */
-       if (is_legacy) {
-               lq_sta->table_count_limit = IL_LEGACY_TBL_COUNT;
-               lq_sta->max_failure_limit = IL_LEGACY_FAILURE_LIMIT;
-               lq_sta->max_success_limit = IL_LEGACY_SUCCESS_LIMIT;
-       } else {
-               lq_sta->table_count_limit = IL_NONE_LEGACY_TBL_COUNT;
-               lq_sta->max_failure_limit = IL_NONE_LEGACY_FAILURE_LIMIT;
-               lq_sta->max_success_limit = IL_NONE_LEGACY_SUCCESS_LIMIT;
-       }
-       lq_sta->table_count = 0;
-       lq_sta->total_failed = 0;
-       lq_sta->total_success = 0;
-       lq_sta->flush_timer = jiffies;
-       lq_sta->action_counter = 0;
-}
-
-/*
- * Find correct throughput table for given mode of modulation
- */
-static void
-il4965_rs_set_expected_tpt_table(struct il_lq_sta *lq_sta,
-                                struct il_scale_tbl_info *tbl)
-{
-       /* Used to choose among HT tables */
-       s32(*ht_tbl_pointer)[RATE_COUNT];
-
-       /* Check for invalid LQ type */
-       if (WARN_ON_ONCE(!is_legacy(tbl->lq_type) && !is_Ht(tbl->lq_type))) {
-               tbl->expected_tpt = expected_tpt_legacy;
-               return;
-       }
-
-       /* Legacy rates have only one table */
-       if (is_legacy(tbl->lq_type)) {
-               tbl->expected_tpt = expected_tpt_legacy;
-               return;
-       }
-
-       /* Choose among many HT tables depending on number of streams
-        * (SISO/MIMO2), channel width (20/40), SGI, and aggregation
-        * status */
-       if (is_siso(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
-               ht_tbl_pointer = expected_tpt_siso20MHz;
-       else if (is_siso(tbl->lq_type))
-               ht_tbl_pointer = expected_tpt_siso40MHz;
-       else if (is_mimo2(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
-               ht_tbl_pointer = expected_tpt_mimo2_20MHz;
-       else                    /* if (is_mimo2(tbl->lq_type)) <-- must be true */
-               ht_tbl_pointer = expected_tpt_mimo2_40MHz;
-
-       if (!tbl->is_SGI && !lq_sta->is_agg)    /* Normal */
-               tbl->expected_tpt = ht_tbl_pointer[0];
-       else if (tbl->is_SGI && !lq_sta->is_agg)        /* SGI */
-               tbl->expected_tpt = ht_tbl_pointer[1];
-       else if (!tbl->is_SGI && lq_sta->is_agg)        /* AGG */
-               tbl->expected_tpt = ht_tbl_pointer[2];
-       else                    /* AGG+SGI */
-               tbl->expected_tpt = ht_tbl_pointer[3];
-}
-
-/*
- * Find starting rate for new "search" high-throughput mode of modulation.
- * Goal is to find lowest expected rate (under perfect conditions) that is
- * above the current measured throughput of "active" mode, to give new mode
- * a fair chance to prove itself without too many challenges.
- *
- * This gets called when transitioning to more aggressive modulation
- * (i.e. legacy to SISO or MIMO, or SISO to MIMO), as well as less aggressive
- * (i.e. MIMO to SISO).  When moving to MIMO, bit rate will typically need
- * to decrease to match "active" throughput.  When moving from MIMO to SISO,
- * bit rate will typically need to increase, but not if performance was bad.
- */
-static s32
-il4965_rs_get_best_rate(struct il_priv *il, struct il_lq_sta *lq_sta,
-                       struct il_scale_tbl_info *tbl,  /* "search" */
-                       u16 rate_mask, s8 idx)
-{
-       /* "active" values */
-       struct il_scale_tbl_info *active_tbl =
-           &(lq_sta->lq_info[lq_sta->active_tbl]);
-       s32 active_sr = active_tbl->win[idx].success_ratio;
-       s32 active_tpt = active_tbl->expected_tpt[idx];
-
-       /* expected "search" throughput */
-       s32 *tpt_tbl = tbl->expected_tpt;
-
-       s32 new_rate, high, low, start_hi;
-       u16 high_low;
-       s8 rate = idx;
-
-       new_rate = high = low = start_hi = RATE_INVALID;
-
-       for (;;) {
-               high_low =
-                   il4965_rs_get_adjacent_rate(il, rate, rate_mask,
-                                               tbl->lq_type);
-
-               low = high_low & 0xff;
-               high = (high_low >> 8) & 0xff;
-
-               /*
-                * Lower the "search" bit rate, to give new "search" mode
-                * approximately the same throughput as "active" if:
-                *
-                * 1) "Active" mode has been working modestly well (but not
-                *    great), and expected "search" throughput (under perfect
-                *    conditions) at candidate rate is above the actual
-                *    measured "active" throughput (but less than expected
-                *    "active" throughput under perfect conditions).
-                * OR
-                * 2) "Active" mode has been working perfectly or very well
-                *    and expected "search" throughput (under perfect
-                *    conditions) at candidate rate is above expected
-                *    "active" throughput (under perfect conditions).
-                */
-               if ((100 * tpt_tbl[rate] > lq_sta->last_tpt &&
-                    (active_sr > RATE_DECREASE_TH && active_sr <= RATE_HIGH_TH
-                     && tpt_tbl[rate] <= active_tpt)) ||
-                   (active_sr >= RATE_SCALE_SWITCH &&
-                    tpt_tbl[rate] > active_tpt)) {
-
-                       /* (2nd or later pass)
-                        * If we've already tried to raise the rate, and are
-                        * now trying to lower it, use the higher rate. */
-                       if (start_hi != RATE_INVALID) {
-                               new_rate = start_hi;
-                               break;
-                       }
-
-                       new_rate = rate;
-
-                       /* Loop again with lower rate */
-                       if (low != RATE_INVALID)
-                               rate = low;
-
-                       /* Lower rate not available, use the original */
-                       else
-                               break;
-
-                       /* Else try to raise the "search" rate to match "active" */
-               } else {
-                       /* (2nd or later pass)
-                        * If we've already tried to lower the rate, and are
-                        * now trying to raise it, use the lower rate. */
-                       if (new_rate != RATE_INVALID)
-                               break;
-
-                       /* Loop again with higher rate */
-                       else if (high != RATE_INVALID) {
-                               start_hi = high;
-                               rate = high;
-
-                               /* Higher rate not available, use the original */
-                       } else {
-                               new_rate = rate;
-                               break;
-                       }
-               }
-       }
-
-       return new_rate;
-}
-
-/*
- * Set up search table for MIMO2
- */
-static int
-il4965_rs_switch_to_mimo2(struct il_priv *il, struct il_lq_sta *lq_sta,
-                         struct ieee80211_conf *conf,
-                         struct ieee80211_sta *sta,
-                         struct il_scale_tbl_info *tbl, int idx)
-{
-       u16 rate_mask;
-       s32 rate;
-       s8 is_green = lq_sta->is_green;
-
-       if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
-               return -1;
-
-       if (sta->smps_mode == IEEE80211_SMPS_STATIC)
-               return -1;
-
-       /* Need both Tx chains/antennas to support MIMO */
-       if (il->hw_params.tx_chains_num < 2)
-               return -1;
-
-       D_RATE("LQ: try to switch to MIMO2\n");
-
-       tbl->lq_type = LQ_MIMO2;
-       tbl->is_dup = lq_sta->is_dup;
-       tbl->action = 0;
-       tbl->max_search = IL_MAX_SEARCH;
-       rate_mask = lq_sta->active_mimo2_rate;
-
-       if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
-               tbl->is_ht40 = 1;
-       else
-               tbl->is_ht40 = 0;
-
-       il4965_rs_set_expected_tpt_table(lq_sta, tbl);
-
-       rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
-
-       D_RATE("LQ: MIMO2 best rate %d mask %X\n", rate, rate_mask);
-       if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
-               D_RATE("Can't switch with idx %d rate mask %x\n", rate,
-                      rate_mask);
-               return -1;
-       }
-       tbl->current_rate =
-           il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
-
-       D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
-              is_green);
-       return 0;
-}
-
-/*
- * Set up search table for SISO
- */
-static int
-il4965_rs_switch_to_siso(struct il_priv *il, struct il_lq_sta *lq_sta,
-                        struct ieee80211_conf *conf, struct ieee80211_sta *sta,
-                        struct il_scale_tbl_info *tbl, int idx)
-{
-       u16 rate_mask;
-       u8 is_green = lq_sta->is_green;
-       s32 rate;
-
-       if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
-               return -1;
-
-       D_RATE("LQ: try to switch to SISO\n");
-
-       tbl->is_dup = lq_sta->is_dup;
-       tbl->lq_type = LQ_SISO;
-       tbl->action = 0;
-       tbl->max_search = IL_MAX_SEARCH;
-       rate_mask = lq_sta->active_siso_rate;
-
-       if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
-               tbl->is_ht40 = 1;
-       else
-               tbl->is_ht40 = 0;
-
-       if (is_green)
-               tbl->is_SGI = 0;        /*11n spec: no SGI in SISO+Greenfield */
-
-       il4965_rs_set_expected_tpt_table(lq_sta, tbl);
-       rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
-
-       D_RATE("LQ: get best rate %d mask %X\n", rate, rate_mask);
-       if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
-               D_RATE("can not switch with idx %d rate mask %x\n", rate,
-                      rate_mask);
-               return -1;
-       }
-       tbl->current_rate =
-           il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
-       D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
-              is_green);
-       return 0;
-}
-
-/*
- * Try to switch to new modulation mode from legacy
- */
-static int
-il4965_rs_move_legacy_other(struct il_priv *il, struct il_lq_sta *lq_sta,
-                           struct ieee80211_conf *conf,
-                           struct ieee80211_sta *sta, int idx)
-{
-       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-       struct il_scale_tbl_info *search_tbl =
-           &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
-       struct il_rate_scale_data *win = &(tbl->win[idx]);
-       u32 sz =
-           (sizeof(struct il_scale_tbl_info) -
-            (sizeof(struct il_rate_scale_data) * RATE_COUNT));
-       u8 start_action;
-       u8 valid_tx_ant = il->hw_params.valid_tx_ant;
-       u8 tx_chains_num = il->hw_params.tx_chains_num;
-       int ret = 0;
-       u8 update_search_tbl_counter = 0;
-
-       tbl->action = IL_LEGACY_SWITCH_SISO;
-
-       start_action = tbl->action;
-       for (;;) {
-               lq_sta->action_counter++;
-               switch (tbl->action) {
-               case IL_LEGACY_SWITCH_ANTENNA1:
-               case IL_LEGACY_SWITCH_ANTENNA2:
-                       D_RATE("LQ: Legacy toggle Antenna\n");
-
-                       if ((tbl->action == IL_LEGACY_SWITCH_ANTENNA1 &&
-                            tx_chains_num <= 1) ||
-                           (tbl->action == IL_LEGACY_SWITCH_ANTENNA2 &&
-                            tx_chains_num <= 2))
-                               break;
-
-                       /* Don't change antenna if success has been great */
-                       if (win->success_ratio >= IL_RS_GOOD_RATIO)
-                               break;
-
-                       /* Set up search table to try other antenna */
-                       memcpy(search_tbl, tbl, sz);
-
-                       if (il4965_rs_toggle_antenna
-                           (valid_tx_ant, &search_tbl->current_rate,
-                            search_tbl)) {
-                               update_search_tbl_counter = 1;
-                               il4965_rs_set_expected_tpt_table(lq_sta,
-                                                                search_tbl);
-                               goto out;
-                       }
-                       break;
-               case IL_LEGACY_SWITCH_SISO:
-                       D_RATE("LQ: Legacy switch to SISO\n");
-
-                       /* Set up search table to try SISO */
-                       memcpy(search_tbl, tbl, sz);
-                       search_tbl->is_SGI = 0;
-                       ret =
-                           il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
-                                                    search_tbl, idx);
-                       if (!ret) {
-                               lq_sta->action_counter = 0;
-                               goto out;
-                       }
-
-                       break;
-               case IL_LEGACY_SWITCH_MIMO2_AB:
-               case IL_LEGACY_SWITCH_MIMO2_AC:
-               case IL_LEGACY_SWITCH_MIMO2_BC:
-                       D_RATE("LQ: Legacy switch to MIMO2\n");
-
-                       /* Set up search table to try MIMO */
-                       memcpy(search_tbl, tbl, sz);
-                       search_tbl->is_SGI = 0;
-
-                       if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AB)
-                               search_tbl->ant_type = ANT_AB;
-                       else if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AC)
-                               search_tbl->ant_type = ANT_AC;
-                       else
-                               search_tbl->ant_type = ANT_BC;
-
-                       if (!il4965_rs_is_valid_ant
-                           (valid_tx_ant, search_tbl->ant_type))
-                               break;
-
-                       ret =
-                           il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
-                                                     search_tbl, idx);
-                       if (!ret) {
-                               lq_sta->action_counter = 0;
-                               goto out;
-                       }
-                       break;
-               }
-               tbl->action++;
-               if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
-                       tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
-
-               if (tbl->action == start_action)
-                       break;
-
-       }
-       search_tbl->lq_type = LQ_NONE;
-       return 0;
-
-out:
-       lq_sta->search_better_tbl = 1;
-       tbl->action++;
-       if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
-               tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
-       if (update_search_tbl_counter)
-               search_tbl->action = tbl->action;
-       return 0;
-
-}
-
-/*
- * Try to switch to new modulation mode from SISO
- */
-static int
-il4965_rs_move_siso_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
-                            struct ieee80211_conf *conf,
-                            struct ieee80211_sta *sta, int idx)
-{
-       u8 is_green = lq_sta->is_green;
-       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-       struct il_scale_tbl_info *search_tbl =
-           &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
-       struct il_rate_scale_data *win = &(tbl->win[idx]);
-       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
-       u32 sz =
-           (sizeof(struct il_scale_tbl_info) -
-            (sizeof(struct il_rate_scale_data) * RATE_COUNT));
-       u8 start_action;
-       u8 valid_tx_ant = il->hw_params.valid_tx_ant;
-       u8 tx_chains_num = il->hw_params.tx_chains_num;
-       u8 update_search_tbl_counter = 0;
-       int ret;
-
-       start_action = tbl->action;
-
-       for (;;) {
-               lq_sta->action_counter++;
-               switch (tbl->action) {
-               case IL_SISO_SWITCH_ANTENNA1:
-               case IL_SISO_SWITCH_ANTENNA2:
-                       D_RATE("LQ: SISO toggle Antenna\n");
-                       if ((tbl->action == IL_SISO_SWITCH_ANTENNA1 &&
-                            tx_chains_num <= 1) ||
-                           (tbl->action == IL_SISO_SWITCH_ANTENNA2 &&
-                            tx_chains_num <= 2))
-                               break;
-
-                       if (win->success_ratio >= IL_RS_GOOD_RATIO)
-                               break;
-
-                       memcpy(search_tbl, tbl, sz);
-                       if (il4965_rs_toggle_antenna
-                           (valid_tx_ant, &search_tbl->current_rate,
-                            search_tbl)) {
-                               update_search_tbl_counter = 1;
-                               goto out;
-                       }
-                       break;
-               case IL_SISO_SWITCH_MIMO2_AB:
-               case IL_SISO_SWITCH_MIMO2_AC:
-               case IL_SISO_SWITCH_MIMO2_BC:
-                       D_RATE("LQ: SISO switch to MIMO2\n");
-                       memcpy(search_tbl, tbl, sz);
-                       search_tbl->is_SGI = 0;
-
-                       if (tbl->action == IL_SISO_SWITCH_MIMO2_AB)
-                               search_tbl->ant_type = ANT_AB;
-                       else if (tbl->action == IL_SISO_SWITCH_MIMO2_AC)
-                               search_tbl->ant_type = ANT_AC;
-                       else
-                               search_tbl->ant_type = ANT_BC;
-
-                       if (!il4965_rs_is_valid_ant
-                           (valid_tx_ant, search_tbl->ant_type))
-                               break;
-
-                       ret =
-                           il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
-                                                     search_tbl, idx);
-                       if (!ret)
-                               goto out;
-                       break;
-               case IL_SISO_SWITCH_GI:
-                       if (!tbl->is_ht40 &&
-                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
-                               break;
-                       if (tbl->is_ht40 &&
-                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
-                               break;
-
-                       D_RATE("LQ: SISO toggle SGI/NGI\n");
-
-                       memcpy(search_tbl, tbl, sz);
-                       if (is_green) {
-                               if (!tbl->is_SGI)
-                                       break;
-                               else
-                                       IL_ERR("SGI was set in GF+SISO\n");
-                       }
-                       search_tbl->is_SGI = !tbl->is_SGI;
-                       il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
-                       if (tbl->is_SGI) {
-                               s32 tpt = lq_sta->last_tpt / 100;
-                               if (tpt >= search_tbl->expected_tpt[idx])
-                                       break;
-                       }
-                       search_tbl->current_rate =
-                           il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
-                                                        is_green);
-                       update_search_tbl_counter = 1;
-                       goto out;
-               }
-               tbl->action++;
-               if (tbl->action > IL_SISO_SWITCH_GI)
-                       tbl->action = IL_SISO_SWITCH_ANTENNA1;
-
-               if (tbl->action == start_action)
-                       break;
-       }
-       search_tbl->lq_type = LQ_NONE;
-       return 0;
-
-out:
-       lq_sta->search_better_tbl = 1;
-       tbl->action++;
-       if (tbl->action > IL_SISO_SWITCH_GI)
-               tbl->action = IL_SISO_SWITCH_ANTENNA1;
-       if (update_search_tbl_counter)
-               search_tbl->action = tbl->action;
-
-       return 0;
-}
-
-/*
- * Try to switch to new modulation mode from MIMO2
- */
-static int
-il4965_rs_move_mimo2_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
-                             struct ieee80211_conf *conf,
-                             struct ieee80211_sta *sta, int idx)
-{
-       s8 is_green = lq_sta->is_green;
-       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-       struct il_scale_tbl_info *search_tbl =
-           &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
-       struct il_rate_scale_data *win = &(tbl->win[idx]);
-       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
-       u32 sz =
-           (sizeof(struct il_scale_tbl_info) -
-            (sizeof(struct il_rate_scale_data) * RATE_COUNT));
-       u8 start_action;
-       u8 valid_tx_ant = il->hw_params.valid_tx_ant;
-       u8 tx_chains_num = il->hw_params.tx_chains_num;
-       u8 update_search_tbl_counter = 0;
-       int ret;
-
-       start_action = tbl->action;
-       for (;;) {
-               lq_sta->action_counter++;
-               switch (tbl->action) {
-               case IL_MIMO2_SWITCH_ANTENNA1:
-               case IL_MIMO2_SWITCH_ANTENNA2:
-                       D_RATE("LQ: MIMO2 toggle Antennas\n");
-
-                       if (tx_chains_num <= 2)
-                               break;
-
-                       if (win->success_ratio >= IL_RS_GOOD_RATIO)
-                               break;
-
-                       memcpy(search_tbl, tbl, sz);
-                       if (il4965_rs_toggle_antenna
-                           (valid_tx_ant, &search_tbl->current_rate,
-                            search_tbl)) {
-                               update_search_tbl_counter = 1;
-                               goto out;
-                       }
-                       break;
-               case IL_MIMO2_SWITCH_SISO_A:
-               case IL_MIMO2_SWITCH_SISO_B:
-               case IL_MIMO2_SWITCH_SISO_C:
-                       D_RATE("LQ: MIMO2 switch to SISO\n");
-
-                       /* Set up new search table for SISO */
-                       memcpy(search_tbl, tbl, sz);
-
-                       if (tbl->action == IL_MIMO2_SWITCH_SISO_A)
-                               search_tbl->ant_type = ANT_A;
-                       else if (tbl->action == IL_MIMO2_SWITCH_SISO_B)
-                               search_tbl->ant_type = ANT_B;
-                       else
-                               search_tbl->ant_type = ANT_C;
-
-                       if (!il4965_rs_is_valid_ant
-                           (valid_tx_ant, search_tbl->ant_type))
-                               break;
-
-                       ret =
-                           il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
-                                                    search_tbl, idx);
-                       if (!ret)
-                               goto out;
-
-                       break;
-
-               case IL_MIMO2_SWITCH_GI:
-                       if (!tbl->is_ht40 &&
-                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
-                               break;
-                       if (tbl->is_ht40 &&
-                           !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
-                               break;
-
-                       D_RATE("LQ: MIMO2 toggle SGI/NGI\n");
-
-                       /* Set up new search table for MIMO2 */
-                       memcpy(search_tbl, tbl, sz);
-                       search_tbl->is_SGI = !tbl->is_SGI;
-                       il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
-                       /*
-                        * If active table already uses the fastest possible
-                        * modulation (dual stream with short guard interval),
-                        * and it's working well, there's no need to look
-                        * for a better type of modulation!
-                        */
-                       if (tbl->is_SGI) {
-                               s32 tpt = lq_sta->last_tpt / 100;
-                               if (tpt >= search_tbl->expected_tpt[idx])
-                                       break;
-                       }
-                       search_tbl->current_rate =
-                           il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
-                                                        is_green);
-                       update_search_tbl_counter = 1;
-                       goto out;
-
-               }
-               tbl->action++;
-               if (tbl->action > IL_MIMO2_SWITCH_GI)
-                       tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
-
-               if (tbl->action == start_action)
-                       break;
-       }
-       search_tbl->lq_type = LQ_NONE;
-       return 0;
-out:
-       lq_sta->search_better_tbl = 1;
-       tbl->action++;
-       if (tbl->action > IL_MIMO2_SWITCH_GI)
-               tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
-       if (update_search_tbl_counter)
-               search_tbl->action = tbl->action;
-
-       return 0;
-
-}
-
-/*
- * Check whether we should continue using same modulation mode, or
- * begin search for a new mode, based on:
- * 1) # tx successes or failures while using this mode
- * 2) # times calling this function
- * 3) elapsed time in this mode (not used, for now)
- */
-static void
-il4965_rs_stay_in_table(struct il_lq_sta *lq_sta, bool force_search)
-{
-       struct il_scale_tbl_info *tbl;
-       int i;
-       int active_tbl;
-       int flush_interval_passed = 0;
-       struct il_priv *il;
-
-       il = lq_sta->drv;
-       active_tbl = lq_sta->active_tbl;
-
-       tbl = &(lq_sta->lq_info[active_tbl]);
-
-       /* If we've been disallowing search, see if we should now allow it */
-       if (lq_sta->stay_in_tbl) {
-
-               /* Elapsed time using current modulation mode */
-               if (lq_sta->flush_timer)
-                       flush_interval_passed =
-                           time_after(jiffies,
-                                      (unsigned long)(lq_sta->flush_timer +
-                                                      RATE_SCALE_FLUSH_INTVL));
-
-               /*
-                * Check if we should allow search for new modulation mode.
-                * If many frames have failed or succeeded, or we've used
-                * this same modulation for a long time, allow search, and
-                * reset history stats that keep track of whether we should
-                * allow a new search.  Also (below) reset all bitmaps and
-                * stats in active history.
-                */
-               if (force_search ||
-                   lq_sta->total_failed > lq_sta->max_failure_limit ||
-                   lq_sta->total_success > lq_sta->max_success_limit ||
-                   (!lq_sta->search_better_tbl && lq_sta->flush_timer &&
-                    flush_interval_passed)) {
-                       D_RATE("LQ: stay is expired %d %d %d\n",
-                              lq_sta->total_failed, lq_sta->total_success,
-                              flush_interval_passed);
-
-                       /* Allow search for new mode */
-                       lq_sta->stay_in_tbl = 0;        /* only place reset */
-                       lq_sta->total_failed = 0;
-                       lq_sta->total_success = 0;
-                       lq_sta->flush_timer = 0;
-
-                       /*
-                        * Else if we've used this modulation mode enough repetitions
-                        * (regardless of elapsed time or success/failure), reset
-                        * history bitmaps and rate-specific stats for all rates in
-                        * active table.
-                        */
-               } else {
-                       lq_sta->table_count++;
-                       if (lq_sta->table_count >= lq_sta->table_count_limit) {
-                               lq_sta->table_count = 0;
-
-                               D_RATE("LQ: stay in table clear win\n");
-                               for (i = 0; i < RATE_COUNT; i++)
-                                       il4965_rs_rate_scale_clear_win(&
-                                                                      (tbl->
-                                                                       win
-                                                                       [i]));
-                       }
-               }
-
-               /* If transitioning to allow "search", reset all history
-                * bitmaps and stats in active table (this will become the new
-                * "search" table). */
-               if (!lq_sta->stay_in_tbl) {
-                       for (i = 0; i < RATE_COUNT; i++)
-                               il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
-               }
-       }
-}
-
-/*
- * setup rate table in uCode
- */
-static void
-il4965_rs_update_rate_tbl(struct il_priv *il, struct il_lq_sta *lq_sta,
-                         struct il_scale_tbl_info *tbl, int idx, u8 is_green)
-{
-       u32 rate;
-
-       /* Update uCode's rate table. */
-       rate = il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
-       il4965_rs_fill_link_cmd(il, lq_sta, rate);
-       il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
-}
-
-/*
- * Do rate scaling and search for new modulation mode.
- */
-static void
-il4965_rs_rate_scale_perform(struct il_priv *il, struct sk_buff *skb,
-                            struct ieee80211_sta *sta,
-                            struct il_lq_sta *lq_sta)
-{
-       struct ieee80211_hw *hw = il->hw;
-       struct ieee80211_conf *conf = &hw->conf;
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-       struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-       int low = RATE_INVALID;
-       int high = RATE_INVALID;
-       int idx;
-       int i;
-       struct il_rate_scale_data *win = NULL;
-       int current_tpt = IL_INVALID_VALUE;
-       int low_tpt = IL_INVALID_VALUE;
-       int high_tpt = IL_INVALID_VALUE;
-       u32 fail_count;
-       s8 scale_action = 0;
-       u16 rate_mask;
-       u8 update_lq = 0;
-       struct il_scale_tbl_info *tbl, *tbl1;
-       u16 rate_scale_idx_msk = 0;
-       u8 is_green = 0;
-       u8 active_tbl = 0;
-       u8 done_search = 0;
-       u16 high_low;
-       s32 sr;
-       u8 tid = MAX_TID_COUNT;
-       struct il_tid_data *tid_data;
-
-       D_RATE("rate scale calculate new rate for skb\n");
-
-       /* Send management frames and NO_ACK data using lowest rate. */
-       /* TODO: this could probably be improved.. */
-       if (!ieee80211_is_data(hdr->frame_control) ||
-           (info->flags & IEEE80211_TX_CTL_NO_ACK))
-               return;
-
-       lq_sta->supp_rates = sta->supp_rates[lq_sta->band];
-
-       tid = il4965_rs_tl_add_packet(lq_sta, hdr);
-       if (tid != MAX_TID_COUNT && (lq_sta->tx_agg_tid_en & (1 << tid))) {
-               tid_data = &il->stations[lq_sta->lq.sta_id].tid[tid];
-               if (tid_data->agg.state == IL_AGG_OFF)
-                       lq_sta->is_agg = 0;
-               else
-                       lq_sta->is_agg = 1;
-       } else
-               lq_sta->is_agg = 0;
-
-       /*
-        * Select rate-scale / modulation-mode table to work with in
-        * the rest of this function:  "search" if searching for better
-        * modulation mode, or "active" if doing rate scaling within a mode.
-        */
-       if (!lq_sta->search_better_tbl)
-               active_tbl = lq_sta->active_tbl;
-       else
-               active_tbl = 1 - lq_sta->active_tbl;
-
-       tbl = &(lq_sta->lq_info[active_tbl]);
-       if (is_legacy(tbl->lq_type))
-               lq_sta->is_green = 0;
-       else
-               lq_sta->is_green = il4965_rs_use_green(il, sta);
-       is_green = lq_sta->is_green;
-
-       /* current tx rate */
-       idx = lq_sta->last_txrate_idx;
-
-       D_RATE("Rate scale idx %d for type %d\n", idx, tbl->lq_type);
-
-       /* rates available for this association, and for modulation mode */
-       rate_mask = il4965_rs_get_supported_rates(lq_sta, hdr, tbl->lq_type);
-
-       D_RATE("mask 0x%04X\n", rate_mask);
-
-       /* mask with station rate restriction */
-       if (is_legacy(tbl->lq_type)) {
-               if (lq_sta->band == IEEE80211_BAND_5GHZ)
-                       /* supp_rates has no CCK bits in A mode */
-                       rate_scale_idx_msk =
-                           (u16) (rate_mask &
-                                  (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
-               else
-                       rate_scale_idx_msk =
-                           (u16) (rate_mask & lq_sta->supp_rates);
-
-       } else
-               rate_scale_idx_msk = rate_mask;
-
-       if (!rate_scale_idx_msk)
-               rate_scale_idx_msk = rate_mask;
-
-       if (!((1 << idx) & rate_scale_idx_msk)) {
-               IL_ERR("Current Rate is not valid\n");
-               if (lq_sta->search_better_tbl) {
-                       /* revert to active table if search table is not valid */
-                       tbl->lq_type = LQ_NONE;
-                       lq_sta->search_better_tbl = 0;
-                       tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-                       /* get "active" rate info */
-                       idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
-                       il4965_rs_update_rate_tbl(il, lq_sta, tbl, idx,
-                                                     is_green);
-               }
-               return;
-       }
-
-       /* Get expected throughput table and history win for current rate */
-       if (!tbl->expected_tpt) {
-               IL_ERR("tbl->expected_tpt is NULL\n");
-               return;
-       }
-
-       /* force user max rate if set by user */
-       if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < idx) {
-               idx = lq_sta->max_rate_idx;
-               update_lq = 1;
-               win = &(tbl->win[idx]);
-               goto lq_update;
-       }
-
-       win = &(tbl->win[idx]);
-
-       /*
-        * If there is not enough history to calculate actual average
-        * throughput, keep analyzing results of more tx frames, without
-        * changing rate or mode (bypass most of the rest of this function).
-        * Set up new rate table in uCode only if old rate is not supported
-        * in current association (use new rate found above).
-        */
-       fail_count = win->counter - win->success_counter;
-       if (fail_count < RATE_MIN_FAILURE_TH &&
-           win->success_counter < RATE_MIN_SUCCESS_TH) {
-               D_RATE("LQ: still below TH. succ=%d total=%d " "for idx %d\n",
-                      win->success_counter, win->counter, idx);
-
-               /* Can't calculate this yet; not enough history */
-               win->average_tpt = IL_INVALID_VALUE;
-
-               /* Should we stay with this modulation mode,
-                * or search for a new one? */
-               il4965_rs_stay_in_table(lq_sta, false);
-
-               goto out;
-       }
-       /* Else we have enough samples; calculate estimate of
-        * actual average throughput */
-       if (win->average_tpt !=
-           ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128)) {
-               IL_ERR("expected_tpt should have been calculated by now\n");
-               win->average_tpt =
-                   ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128);
-       }
-
-       /* If we are searching for better modulation mode, check success. */
-       if (lq_sta->search_better_tbl) {
-               /* If good success, continue using the "search" mode;
-                * no need to send new link quality command, since we're
-                * continuing to use the setup that we've been trying. */
-               if (win->average_tpt > lq_sta->last_tpt) {
-
-                       D_RATE("LQ: SWITCHING TO NEW TBL "
-                              "suc=%d cur-tpt=%d old-tpt=%d\n",
-                              win->success_ratio, win->average_tpt,
-                              lq_sta->last_tpt);
-
-                       if (!is_legacy(tbl->lq_type))
-                               lq_sta->enable_counter = 1;
-
-                       /* Swap tables; "search" becomes "active" */
-                       lq_sta->active_tbl = active_tbl;
-                       current_tpt = win->average_tpt;
-
-                       /* Else poor success; go back to mode in "active" table */
-               } else {
-
-                       D_RATE("LQ: GOING BACK TO THE OLD TBL "
-                              "suc=%d cur-tpt=%d old-tpt=%d\n",
-                              win->success_ratio, win->average_tpt,
-                              lq_sta->last_tpt);
-
-                       /* Nullify "search" table */
-                       tbl->lq_type = LQ_NONE;
-
-                       /* Revert to "active" table */
-                       active_tbl = lq_sta->active_tbl;
-                       tbl = &(lq_sta->lq_info[active_tbl]);
-
-                       /* Revert to "active" rate and throughput info */
-                       idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
-                       current_tpt = lq_sta->last_tpt;
-
-                       /* Need to set up a new rate table in uCode */
-                       update_lq = 1;
-               }
-
-               /* Either way, we've made a decision; modulation mode
-                * search is done, allow rate adjustment next time. */
-               lq_sta->search_better_tbl = 0;
-               done_search = 1;        /* Don't switch modes below! */
-               goto lq_update;
-       }
-
-       /* (Else) not in search of better modulation mode, try for better
-        * starting rate, while staying in this mode. */
-       high_low =
-           il4965_rs_get_adjacent_rate(il, idx, rate_scale_idx_msk,
-                                       tbl->lq_type);
-       low = high_low & 0xff;
-       high = (high_low >> 8) & 0xff;
-
-       /* If user set max rate, dont allow higher than user constrain */
-       if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < high)
-               high = RATE_INVALID;
-
-       sr = win->success_ratio;
-
-       /* Collect measured throughputs for current and adjacent rates */
-       current_tpt = win->average_tpt;
-       if (low != RATE_INVALID)
-               low_tpt = tbl->win[low].average_tpt;
-       if (high != RATE_INVALID)
-               high_tpt = tbl->win[high].average_tpt;
-
-       scale_action = 0;
-
-       /* Too many failures, decrease rate */
-       if (sr <= RATE_DECREASE_TH || current_tpt == 0) {
-               D_RATE("decrease rate because of low success_ratio\n");
-               scale_action = -1;
-
-               /* No throughput measured yet for adjacent rates; try increase. */
-       } else if (low_tpt == IL_INVALID_VALUE && high_tpt == IL_INVALID_VALUE) {
-
-               if (high != RATE_INVALID && sr >= RATE_INCREASE_TH)
-                       scale_action = 1;
-               else if (low != RATE_INVALID)
-                       scale_action = 0;
-       }
-
-       /* 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 != IL_INVALID_VALUE && high_tpt != IL_INVALID_VALUE &&
-                low_tpt < current_tpt && high_tpt < current_tpt)
-               scale_action = 0;
-
-       /* At least one adjacent rate's throughput is measured,
-        * and may have better performance. */
-       else {
-               /* Higher adjacent rate's throughput is measured */
-               if (high_tpt != IL_INVALID_VALUE) {
-                       /* Higher rate has better throughput */
-                       if (high_tpt > current_tpt && sr >= RATE_INCREASE_TH)
-                               scale_action = 1;
-                       else
-                               scale_action = 0;
-
-                       /* Lower adjacent rate's throughput is measured */
-               } else if (low_tpt != IL_INVALID_VALUE) {
-                       /* Lower rate has better throughput */
-                       if (low_tpt > current_tpt) {
-                               D_RATE("decrease rate because of low tpt\n");
-                               scale_action = -1;
-                       } else if (sr >= RATE_INCREASE_TH) {
-                               scale_action = 1;
-                       }
-               }
-       }
-
-       /* 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 != RATE_INVALID &&
-           (sr > RATE_HIGH_TH || current_tpt > 100 * tbl->expected_tpt[low]))
-               scale_action = 0;
-
-       switch (scale_action) {
-       case -1:
-               /* Decrease starting rate, update uCode's rate table */
-               if (low != RATE_INVALID) {
-                       update_lq = 1;
-                       idx = low;
-               }
-
-               break;
-       case 1:
-               /* Increase starting rate, update uCode's rate table */
-               if (high != RATE_INVALID) {
-                       update_lq = 1;
-                       idx = high;
-               }
-
-               break;
-       case 0:
-               /* No change */
-       default:
-               break;
-       }
-
-       D_RATE("choose rate scale idx %d action %d low %d " "high %d type %d\n",
-              idx, scale_action, low, high, tbl->lq_type);
-
-lq_update:
-       /* Replace uCode's rate table for the destination station. */
-       if (update_lq)
-               il4965_rs_update_rate_tbl(il, lq_sta, tbl, idx, is_green);
-
-       /* Should we stay with this modulation mode,
-        * or search for a new one? */
-       il4965_rs_stay_in_table(lq_sta, false);
-
-       /*
-        * Search for new modulation mode if we're:
-        * 1)  Not changing rates right now
-        * 2)  Not just finishing up a search
-        * 3)  Allowing a new search
-        */
-       if (!update_lq && !done_search && !lq_sta->stay_in_tbl && win->counter) {
-               /* Save current throughput to compare with "search" throughput */
-               lq_sta->last_tpt = current_tpt;
-
-               /* Select a new "search" modulation mode to try.
-                * If one is found, set up the new "search" table. */
-               if (is_legacy(tbl->lq_type))
-                       il4965_rs_move_legacy_other(il, lq_sta, conf, sta, idx);
-               else if (is_siso(tbl->lq_type))
-                       il4965_rs_move_siso_to_other(il, lq_sta, conf, sta,
-                                                    idx);
-               else            /* (is_mimo2(tbl->lq_type)) */
-                       il4965_rs_move_mimo2_to_other(il, lq_sta, conf, sta,
-                                                     idx);
-
-               /* If new "search" mode was selected, set up in uCode table */
-               if (lq_sta->search_better_tbl) {
-                       /* Access the "search" table, clear its history. */
-                       tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
-                       for (i = 0; i < RATE_COUNT; i++)
-                               il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
-
-                       /* Use new "search" start rate */
-                       idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
-
-                       D_RATE("Switch current  mcs: %X idx: %d\n",
-                              tbl->current_rate, idx);
-                       il4965_rs_fill_link_cmd(il, lq_sta, tbl->current_rate);
-                       il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
-               } else
-                       done_search = 1;
-       }
-
-       if (done_search && !lq_sta->stay_in_tbl) {
-               /* If the "active" (non-search) mode was legacy,
-                * and we've tried switching antennas,
-                * but we haven't been able to try HT modes (not available),
-                * stay with best antenna legacy modulation for a while
-                * before next round of mode comparisons. */
-               tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
-               if (is_legacy(tbl1->lq_type) && !conf_is_ht(conf) &&
-                   lq_sta->action_counter > tbl1->max_search) {
-                       D_RATE("LQ: STAY in legacy table\n");
-                       il4965_rs_set_stay_in_table(il, 1, lq_sta);
-               }
-
-               /* If we're in an HT mode, and all 3 mode switch actions
-                * have been tried and compared, stay in this best modulation
-                * mode for a while before next round of mode comparisons. */
-               if (lq_sta->enable_counter &&
-                   lq_sta->action_counter >= tbl1->max_search) {
-                       if (lq_sta->last_tpt > IL_AGG_TPT_THREHOLD &&
-                           (lq_sta->tx_agg_tid_en & (1 << tid)) &&
-                           tid != MAX_TID_COUNT) {
-                               tid_data =
-                                   &il->stations[lq_sta->lq.sta_id].tid[tid];
-                               if (tid_data->agg.state == IL_AGG_OFF) {
-                                       D_RATE("try to aggregate tid %d\n",
-                                              tid);
-                                       il4965_rs_tl_turn_on_agg(il, tid,
-                                                                lq_sta, sta);
-                               }
-                       }
-                       il4965_rs_set_stay_in_table(il, 0, lq_sta);
-               }
-       }
-
-out:
-       tbl->current_rate =
-           il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
-       i = idx;
-       lq_sta->last_txrate_idx = i;
-}
-
-/**
- * il4965_rs_initialize_lq - Initialize a station's hardware rate table
- *
- * The uCode's station table contains a table of fallback rates
- * for automatic fallback during transmission.
- *
- * NOTE: This sets up a default set of values.  These will be replaced later
- *       if the driver's iwl-4965-rs rate scaling algorithm is used, instead of
- *       rc80211_simple.
- *
- * NOTE: Run C_ADD_STA command to set up station table entry, before
- *       calling this function (which runs C_TX_LINK_QUALITY_CMD,
- *       which requires station table entry to exist).
- */
-static void
-il4965_rs_initialize_lq(struct il_priv *il, struct ieee80211_conf *conf,
-                       struct ieee80211_sta *sta, struct il_lq_sta *lq_sta)
-{
-       struct il_scale_tbl_info *tbl;
-       int rate_idx;
-       int i;
-       u32 rate;
-       u8 use_green;
-       u8 active_tbl = 0;
-       u8 valid_tx_ant;
-       struct il_station_priv *sta_priv;
-
-       if (!sta || !lq_sta)
-               return;
-
-       use_green = il4965_rs_use_green(il, sta);
-       sta_priv = (void *)sta->drv_priv;
-
-       i = lq_sta->last_txrate_idx;
-
-       valid_tx_ant = il->hw_params.valid_tx_ant;
-
-       if (!lq_sta->search_better_tbl)
-               active_tbl = lq_sta->active_tbl;
-       else
-               active_tbl = 1 - lq_sta->active_tbl;
-
-       tbl = &(lq_sta->lq_info[active_tbl]);
-
-       if (i < 0 || i >= RATE_COUNT)
-               i = 0;
-
-       rate = il_rates[i].plcp;
-       tbl->ant_type = il4965_first_antenna(valid_tx_ant);
-       rate |= tbl->ant_type << RATE_MCS_ANT_POS;
-
-       if (i >= IL_FIRST_CCK_RATE && i <= IL_LAST_CCK_RATE)
-               rate |= RATE_MCS_CCK_MSK;
-
-       il4965_rs_get_tbl_info_from_mcs(rate, il->band, tbl, &rate_idx);
-       if (!il4965_rs_is_valid_ant(valid_tx_ant, tbl->ant_type))
-               il4965_rs_toggle_antenna(valid_tx_ant, &rate, tbl);
-
-       rate = il4965_rate_n_flags_from_tbl(il, tbl, rate_idx, use_green);
-       tbl->current_rate = rate;
-       il4965_rs_set_expected_tpt_table(lq_sta, tbl);
-       il4965_rs_fill_link_cmd(NULL, lq_sta, rate);
-       il->stations[lq_sta->lq.sta_id].lq = &lq_sta->lq;
-       il_send_lq_cmd(il, &lq_sta->lq, CMD_SYNC, true);
-}
-
-static void
-il4965_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
-                  struct ieee80211_tx_rate_control *txrc)
-{
-
-       struct sk_buff *skb = txrc->skb;
-       struct ieee80211_supported_band *sband = txrc->sband;
-       struct il_priv *il __maybe_unused = (struct il_priv *)il_r;
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-       struct il_lq_sta *lq_sta = il_sta;
-       int rate_idx;
-
-       D_RATE("rate scale calculate new rate for skb\n");
-
-       /* Get max rate if user set max rate */
-       if (lq_sta) {
-               lq_sta->max_rate_idx = txrc->max_rate_idx;
-               if (sband->band == IEEE80211_BAND_5GHZ &&
-                   lq_sta->max_rate_idx != -1)
-                       lq_sta->max_rate_idx += IL_FIRST_OFDM_RATE;
-               if (lq_sta->max_rate_idx < 0 ||
-                   lq_sta->max_rate_idx >= RATE_COUNT)
-                       lq_sta->max_rate_idx = -1;
-       }
-
-       /* Treat uninitialized rate scaling data same as non-existing. */
-       if (lq_sta && !lq_sta->drv) {
-               D_RATE("Rate scaling not initialized yet.\n");
-               il_sta = NULL;
-       }
-
-       /* Send management frames and NO_ACK data using lowest rate. */
-       if (rate_control_send_low(sta, il_sta, txrc))
-               return;
-
-       if (!lq_sta)
-               return;
-
-       rate_idx = lq_sta->last_txrate_idx;
-
-       if (lq_sta->last_rate_n_flags & RATE_MCS_HT_MSK) {
-               rate_idx -= IL_FIRST_OFDM_RATE;
-               /* 6M and 9M shared same MCS idx */
-               rate_idx = (rate_idx > 0) ? (rate_idx - 1) : 0;
-               if (il4965_rs_extract_rate(lq_sta->last_rate_n_flags) >=
-                   RATE_MIMO2_6M_PLCP)
-                       rate_idx = rate_idx + MCS_IDX_PER_STREAM;
-               info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
-               if (lq_sta->last_rate_n_flags & RATE_MCS_SGI_MSK)
-                       info->control.rates[0].flags |=
-                           IEEE80211_TX_RC_SHORT_GI;
-               if (lq_sta->last_rate_n_flags & RATE_MCS_DUP_MSK)
-                       info->control.rates[0].flags |=
-                           IEEE80211_TX_RC_DUP_DATA;
-               if (lq_sta->last_rate_n_flags & RATE_MCS_HT40_MSK)
-                       info->control.rates[0].flags |=
-                           IEEE80211_TX_RC_40_MHZ_WIDTH;
-               if (lq_sta->last_rate_n_flags & RATE_MCS_GF_MSK)
-                       info->control.rates[0].flags |=
-                           IEEE80211_TX_RC_GREEN_FIELD;
-       } else {
-               /* Check for invalid rates */
-               if (rate_idx < 0 || rate_idx >= RATE_COUNT_LEGACY ||
-                   (sband->band == IEEE80211_BAND_5GHZ &&
-                    rate_idx < IL_FIRST_OFDM_RATE))
-                       rate_idx = rate_lowest_index(sband, sta);
-               /* On valid 5 GHz rate, adjust idx */
-               else if (sband->band == IEEE80211_BAND_5GHZ)
-                       rate_idx -= IL_FIRST_OFDM_RATE;
-               info->control.rates[0].flags = 0;
-       }
-       info->control.rates[0].idx = rate_idx;
-       info->control.rates[0].count = 1;
-}
-
-static void *
-il4965_rs_alloc_sta(void *il_rate, struct ieee80211_sta *sta, gfp_t gfp)
-{
-       struct il_station_priv *sta_priv =
-           (struct il_station_priv *)sta->drv_priv;
-       struct il_priv *il;
-
-       il = (struct il_priv *)il_rate;
-       D_RATE("create station rate scale win\n");
-
-       return &sta_priv->lq_sta;
-}
-
-/*
- * Called after adding a new station to initialize rate scaling
- */
-void
-il4965_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
-{
-       int i, j;
-       struct ieee80211_hw *hw = il->hw;
-       struct ieee80211_conf *conf = &il->hw->conf;
-       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
-       struct il_station_priv *sta_priv;
-       struct il_lq_sta *lq_sta;
-       struct ieee80211_supported_band *sband;
-
-       sta_priv = (struct il_station_priv *)sta->drv_priv;
-       lq_sta = &sta_priv->lq_sta;
-       sband = hw->wiphy->bands[conf->chandef.chan->band];
-
-       lq_sta->lq.sta_id = sta_id;
-
-       for (j = 0; j < LQ_SIZE; j++)
-               for (i = 0; i < RATE_COUNT; i++)
-                       il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
-                                                      win[i]);
-
-       lq_sta->flush_timer = 0;
-       lq_sta->supp_rates = sta->supp_rates[sband->band];
-       for (j = 0; j < LQ_SIZE; j++)
-               for (i = 0; i < RATE_COUNT; i++)
-                       il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
-                                                      win[i]);
-
-       D_RATE("LQ:" "*** rate scale station global init for station %d ***\n",
-              sta_id);
-       /* TODO: what is a good starting rate for STA? About middle? Maybe not
-        * the lowest or the highest rate.. Could consider using RSSI from
-        * previous packets? Need to have IEEE 802.1X auth succeed immediately
-        * after assoc.. */
-
-       lq_sta->is_dup = 0;
-       lq_sta->max_rate_idx = -1;
-       lq_sta->missed_rate_counter = IL_MISSED_RATE_MAX;
-       lq_sta->is_green = il4965_rs_use_green(il, sta);
-       lq_sta->active_legacy_rate = il->active_rate & ~(0x1000);
-       lq_sta->band = il->band;
-       /*
-        * active_siso_rate mask includes 9 MBits (bit 5), and CCK (bits 0-3),
-        * supp_rates[] does not; shift to convert format, force 9 MBits off.
-        */
-       lq_sta->active_siso_rate = ht_cap->mcs.rx_mask[0] << 1;
-       lq_sta->active_siso_rate |= ht_cap->mcs.rx_mask[0] & 0x1;
-       lq_sta->active_siso_rate &= ~((u16) 0x2);
-       lq_sta->active_siso_rate <<= IL_FIRST_OFDM_RATE;
-
-       /* Same here */
-       lq_sta->active_mimo2_rate = ht_cap->mcs.rx_mask[1] << 1;
-       lq_sta->active_mimo2_rate |= ht_cap->mcs.rx_mask[1] & 0x1;
-       lq_sta->active_mimo2_rate &= ~((u16) 0x2);
-       lq_sta->active_mimo2_rate <<= IL_FIRST_OFDM_RATE;
-
-       /* These values will be overridden later */
-       lq_sta->lq.general_params.single_stream_ant_msk =
-           il4965_first_antenna(il->hw_params.valid_tx_ant);
-       lq_sta->lq.general_params.dual_stream_ant_msk =
-           il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
-                                                              valid_tx_ant);
-       if (!lq_sta->lq.general_params.dual_stream_ant_msk) {
-               lq_sta->lq.general_params.dual_stream_ant_msk = ANT_AB;
-       } else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
-               lq_sta->lq.general_params.dual_stream_ant_msk =
-                   il->hw_params.valid_tx_ant;
-       }
-
-       /* as default allow aggregation for all tids */
-       lq_sta->tx_agg_tid_en = IL_AGG_ALL_TID;
-       lq_sta->drv = il;
-
-       /* Set last_txrate_idx to lowest rate */
-       lq_sta->last_txrate_idx = rate_lowest_index(sband, sta);
-       if (sband->band == IEEE80211_BAND_5GHZ)
-               lq_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
-       lq_sta->is_agg = 0;
-
-#ifdef CONFIG_MAC80211_DEBUGFS
-       lq_sta->dbg_fixed_rate = 0;
-#endif
-
-       il4965_rs_initialize_lq(il, conf, sta, lq_sta);
-}
-
-static void
-il4965_rs_fill_link_cmd(struct il_priv *il, struct il_lq_sta *lq_sta,
-                       u32 new_rate)
-{
-       struct il_scale_tbl_info tbl_type;
-       int idx = 0;
-       int rate_idx;
-       int repeat_rate = 0;
-       u8 ant_toggle_cnt = 0;
-       u8 use_ht_possible = 1;
-       u8 valid_tx_ant = 0;
-       struct il_link_quality_cmd *lq_cmd = &lq_sta->lq;
-
-       /* Override starting rate (idx 0) if needed for debug purposes */
-       il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
-
-       /* Interpret new_rate (rate_n_flags) */
-       il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band, &tbl_type,
-                                       &rate_idx);
-
-       /* How many times should we repeat the initial rate? */
-       if (is_legacy(tbl_type.lq_type)) {
-               ant_toggle_cnt = 1;
-               repeat_rate = IL_NUMBER_TRY;
-       } else {
-               repeat_rate = IL_HT_NUMBER_TRY;
-       }
-
-       lq_cmd->general_params.mimo_delimiter =
-           is_mimo(tbl_type.lq_type) ? 1 : 0;
-
-       /* Fill 1st table entry (idx 0) */
-       lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
-
-       if (il4965_num_of_ant(tbl_type.ant_type) == 1) {
-               lq_cmd->general_params.single_stream_ant_msk =
-                   tbl_type.ant_type;
-       } else if (il4965_num_of_ant(tbl_type.ant_type) == 2) {
-               lq_cmd->general_params.dual_stream_ant_msk = tbl_type.ant_type;
-       }
-       /* otherwise we don't modify the existing value */
-       idx++;
-       repeat_rate--;
-       if (il)
-               valid_tx_ant = il->hw_params.valid_tx_ant;
-
-       /* Fill rest of rate table */
-       while (idx < LINK_QUAL_MAX_RETRY_NUM) {
-               /* Repeat initial/next rate.
-                * For legacy IL_NUMBER_TRY == 1, this loop will not execute.
-                * For HT IL_HT_NUMBER_TRY == 3, this executes twice. */
-               while (repeat_rate > 0 && idx < LINK_QUAL_MAX_RETRY_NUM) {
-                       if (is_legacy(tbl_type.lq_type)) {
-                               if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
-                                       ant_toggle_cnt++;
-                               else if (il &&
-                                        il4965_rs_toggle_antenna(valid_tx_ant,
-                                                                 &new_rate,
-                                                                 &tbl_type))
-                                       ant_toggle_cnt = 1;
-                       }
-
-                       /* Override next rate if needed for debug purposes */
-                       il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
-
-                       /* Fill next table entry */
-                       lq_cmd->rs_table[idx].rate_n_flags =
-                           cpu_to_le32(new_rate);
-                       repeat_rate--;
-                       idx++;
-               }
-
-               il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band,
-                                               &tbl_type, &rate_idx);
-
-               /* Indicate to uCode which entries might be MIMO.
-                * If initial rate was MIMO, this will finally end up
-                * as (IL_HT_NUMBER_TRY * 2), after 2nd pass, otherwise 0. */
-               if (is_mimo(tbl_type.lq_type))
-                       lq_cmd->general_params.mimo_delimiter = idx;
-
-               /* Get next rate */
-               new_rate =
-                   il4965_rs_get_lower_rate(lq_sta, &tbl_type, rate_idx,
-                                            use_ht_possible);
-
-               /* How many times should we repeat the next rate? */
-               if (is_legacy(tbl_type.lq_type)) {
-                       if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
-                               ant_toggle_cnt++;
-                       else if (il &&
-                                il4965_rs_toggle_antenna(valid_tx_ant,
-                                                         &new_rate, &tbl_type))
-                               ant_toggle_cnt = 1;
-
-                       repeat_rate = IL_NUMBER_TRY;
-               } else {
-                       repeat_rate = IL_HT_NUMBER_TRY;
-               }
-
-               /* Don't allow HT rates after next pass.
-                * il4965_rs_get_lower_rate() will change type to LQ_A or LQ_G. */
-               use_ht_possible = 0;
-
-               /* Override next rate if needed for debug purposes */
-               il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
-
-               /* Fill next table entry */
-               lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
-
-               idx++;
-               repeat_rate--;
-       }
-
-       lq_cmd->agg_params.agg_frame_cnt_limit = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
-       lq_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
-
-       lq_cmd->agg_params.agg_time_limit =
-           cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
-}
-
-static void *
-il4965_rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
-{
-       return hw->priv;
-}
-
-/* rate scale requires free function to be implemented */
-static void
-il4965_rs_free(void *il_rate)
-{
-       return;
-}
-
-static void
-il4965_rs_free_sta(void *il_r, struct ieee80211_sta *sta, void *il_sta)
-{
-       struct il_priv *il __maybe_unused = il_r;
-
-       D_RATE("enter\n");
-       D_RATE("leave\n");
-}
-
-#ifdef CONFIG_MAC80211_DEBUGFS
-
-static void
-il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta, u32 * rate_n_flags, int idx)
-{
-       struct il_priv *il;
-       u8 valid_tx_ant;
-       u8 ant_sel_tx;
-
-       il = lq_sta->drv;
-       valid_tx_ant = il->hw_params.valid_tx_ant;
-       if (lq_sta->dbg_fixed_rate) {
-               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;
-                       D_RATE("Fixed rate ON\n");
-               } else {
-                       lq_sta->dbg_fixed_rate = 0;
-                       IL_ERR
-                           ("Invalid antenna selection 0x%X, Valid is 0x%X\n",
-                            ant_sel_tx, valid_tx_ant);
-                       D_RATE("Fixed rate OFF\n");
-               }
-       } else {
-               D_RATE("Fixed rate OFF\n");
-       }
-}
-
-static ssize_t
-il4965_rs_sta_dbgfs_scale_table_write(struct file *file,
-                                     const char __user *user_buf,
-                                     size_t count, loff_t *ppos)
-{
-       struct il_lq_sta *lq_sta = file->private_data;
-       struct il_priv *il;
-       char buf[64];
-       size_t buf_size;
-       u32 parsed_rate;
-
-       il = lq_sta->drv;
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-
-       if (sscanf(buf, "%x", &parsed_rate) == 1)
-               lq_sta->dbg_fixed_rate = parsed_rate;
-       else
-               lq_sta->dbg_fixed_rate = 0;
-
-       lq_sta->active_legacy_rate = 0x0FFF;    /* 1 - 54 MBits, includes CCK */
-       lq_sta->active_siso_rate = 0x1FD0;      /* 6 - 60 MBits, no 9, no CCK */
-       lq_sta->active_mimo2_rate = 0x1FD0;     /* 6 - 60 MBits, no 9, no CCK */
-
-       D_RATE("sta_id %d rate 0x%X\n", lq_sta->lq.sta_id,
-              lq_sta->dbg_fixed_rate);
-
-       if (lq_sta->dbg_fixed_rate) {
-               il4965_rs_fill_link_cmd(NULL, lq_sta, lq_sta->dbg_fixed_rate);
-               il_send_lq_cmd(lq_sta->drv, &lq_sta->lq, CMD_ASYNC, false);
-       }
-
-       return count;
-}
-
-static ssize_t
-il4965_rs_sta_dbgfs_scale_table_read(struct file *file, char __user *user_buf,
-                                    size_t count, loff_t *ppos)
-{
-       char *buff;
-       int desc = 0;
-       int i = 0;
-       int idx = 0;
-       ssize_t ret;
-
-       struct il_lq_sta *lq_sta = file->private_data;
-       struct il_priv *il;
-       struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
-
-       il = lq_sta->drv;
-       buff = kmalloc(1024, GFP_KERNEL);
-       if (!buff)
-               return -ENOMEM;
-
-       desc += sprintf(buff + desc, "sta_id %d\n", lq_sta->lq.sta_id);
-       desc +=
-           sprintf(buff + desc, "failed=%d success=%d rate=0%X\n",
-                   lq_sta->total_failed, lq_sta->total_success,
-                   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",
-                   (il->hw_params.valid_tx_ant & ANT_A) ? "ANT_A," : "",
-                   (il->hw_params.valid_tx_ant & ANT_B) ? "ANT_B," : "",
-                   (il->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" : "MIMO2");
-               desc +=
-                   sprintf(buff + desc, " %s",
-                           (tbl->is_ht40) ? "40MHz" : "20MHz");
-               desc +=
-                   sprintf(buff + desc, " %s %s %s\n",
-                           (tbl->is_SGI) ? "SGI" : "",
-                           (lq_sta->is_green) ? "GF enabled" : "",
-                           (lq_sta->is_agg) ? "AGG on" : "");
-       }
-       desc +=
-           sprintf(buff + desc, "last tx rate=0x%X\n",
-                   lq_sta->last_rate_n_flags);
-       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,
-                   lq_sta->lq.general_params.mimo_delimiter,
-                   lq_sta->lq.general_params.single_stream_ant_msk,
-                   lq_sta->lq.general_params.dual_stream_ant_msk);
-
-       desc +=
-           sprintf(buff + desc,
-                   "agg:"
-                   "time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
-                   le16_to_cpu(lq_sta->lq.agg_params.agg_time_limit),
-                   lq_sta->lq.agg_params.agg_dis_start_th,
-                   lq_sta->lq.agg_params.agg_frame_cnt_limit);
-
-       desc +=
-           sprintf(buff + desc,
-                   "Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
-                   lq_sta->lq.general_params.start_rate_idx[0],
-                   lq_sta->lq.general_params.start_rate_idx[1],
-                   lq_sta->lq.general_params.start_rate_idx[2],
-                   lq_sta->lq.general_params.start_rate_idx[3]);
-
-       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
-               idx =
-                   il4965_hwrate_to_plcp_idx(le32_to_cpu
-                                             (lq_sta->lq.rs_table[i].
-                                              rate_n_flags));
-               if (is_legacy(tbl->lq_type)) {
-                       desc +=
-                           sprintf(buff + desc, " rate[%d] 0x%X %smbps\n", i,
-                                   le32_to_cpu(lq_sta->lq.rs_table[i].
-                                               rate_n_flags),
-                                   il_rate_mcs[idx].mbps);
-               } else {
-                       desc +=
-                           sprintf(buff + desc, " rate[%d] 0x%X %smbps (%s)\n",
-                                   i,
-                                   le32_to_cpu(lq_sta->lq.rs_table[i].
-                                               rate_n_flags),
-                                   il_rate_mcs[idx].mbps,
-                                   il_rate_mcs[idx].mcs);
-               }
-       }
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
-       kfree(buff);
-       return ret;
-}
-
-static const struct file_operations rs_sta_dbgfs_scale_table_ops = {
-       .write = il4965_rs_sta_dbgfs_scale_table_write,
-       .read = il4965_rs_sta_dbgfs_scale_table_read,
-       .open = simple_open,
-       .llseek = default_llseek,
-};
-
-static ssize_t
-il4965_rs_sta_dbgfs_stats_table_read(struct file *file, char __user *user_buf,
-                                    size_t count, loff_t *ppos)
-{
-       char *buff;
-       int desc = 0;
-       int i, j;
-       ssize_t ret;
-
-       struct il_lq_sta *lq_sta = file->private_data;
-
-       buff = kmalloc(1024, GFP_KERNEL);
-       if (!buff)
-               return -ENOMEM;
-
-       for (i = 0; i < LQ_SIZE; i++) {
-               desc +=
-                   sprintf(buff + desc,
-                           "%s type=%d SGI=%d HT40=%d DUP=%d GF=%d\n"
-                           "rate=0x%X\n", lq_sta->active_tbl == i ? "*" : "x",
-                           lq_sta->lq_info[i].lq_type,
-                           lq_sta->lq_info[i].is_SGI,
-                           lq_sta->lq_info[i].is_ht40,
-                           lq_sta->lq_info[i].is_dup, lq_sta->is_green,
-                           lq_sta->lq_info[i].current_rate);
-               for (j = 0; j < RATE_COUNT; j++) {
-                       desc +=
-                           sprintf(buff + desc,
-                                   "counter=%d success=%d %%=%d\n",
-                                   lq_sta->lq_info[i].win[j].counter,
-                                   lq_sta->lq_info[i].win[j].success_counter,
-                                   lq_sta->lq_info[i].win[j].success_ratio);
-               }
-       }
-       ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
-       kfree(buff);
-       return ret;
-}
-
-static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
-       .read = il4965_rs_sta_dbgfs_stats_table_read,
-       .open = simple_open,
-       .llseek = default_llseek,
-};
-
-static ssize_t
-il4965_rs_sta_dbgfs_rate_scale_data_read(struct file *file,
-                                        char __user *user_buf, size_t count,
-                                        loff_t *ppos)
-{
-       char buff[120];
-       int desc = 0;
-       struct il_lq_sta *lq_sta = file->private_data;
-       struct il_scale_tbl_info *tbl = &lq_sta->lq_info[lq_sta->active_tbl];
-
-       if (is_Ht(tbl->lq_type))
-               desc +=
-                   sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
-                           tbl->expected_tpt[lq_sta->last_txrate_idx]);
-       else
-               desc +=
-                   sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
-                           il_rates[lq_sta->last_txrate_idx].ieee >> 1);
-
-       return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
-}
-
-static const struct file_operations rs_sta_dbgfs_rate_scale_data_ops = {
-       .read = il4965_rs_sta_dbgfs_rate_scale_data_read,
-       .open = simple_open,
-       .llseek = default_llseek,
-};
-
-static void
-il4965_rs_add_debugfs(void *il, void *il_sta, struct dentry *dir)
-{
-       struct il_lq_sta *lq_sta = il_sta;
-       lq_sta->rs_sta_dbgfs_scale_table_file =
-           debugfs_create_file("rate_scale_table", S_IRUSR | S_IWUSR, dir,
-                               lq_sta, &rs_sta_dbgfs_scale_table_ops);
-       lq_sta->rs_sta_dbgfs_stats_table_file =
-           debugfs_create_file("rate_stats_table", S_IRUSR, dir, lq_sta,
-                               &rs_sta_dbgfs_stats_table_ops);
-       lq_sta->rs_sta_dbgfs_rate_scale_data_file =
-           debugfs_create_file("rate_scale_data", S_IRUSR, dir, lq_sta,
-                               &rs_sta_dbgfs_rate_scale_data_ops);
-       lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file =
-           debugfs_create_u8("tx_agg_tid_enable", S_IRUSR | S_IWUSR, dir,
-                             &lq_sta->tx_agg_tid_en);
-
-}
-
-static void
-il4965_rs_remove_debugfs(void *il, void *il_sta)
-{
-       struct il_lq_sta *lq_sta = il_sta;
-       debugfs_remove(lq_sta->rs_sta_dbgfs_scale_table_file);
-       debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
-       debugfs_remove(lq_sta->rs_sta_dbgfs_rate_scale_data_file);
-       debugfs_remove(lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file);
-}
-#endif
-
-/*
- * Initialization of rate scaling information is done by driver after
- * the station is added. Since mac80211 calls this function before a
- * station is added we ignore it.
- */
-static void
-il4965_rs_rate_init_stub(void *il_r, struct ieee80211_supported_band *sband,
-                        struct cfg80211_chan_def *chandef,
-                        struct ieee80211_sta *sta, void *il_sta)
-{
-}
-
-static const struct rate_control_ops rs_4965_ops = {
-       .name = IL4965_RS_NAME,
-       .tx_status = il4965_rs_tx_status,
-       .get_rate = il4965_rs_get_rate,
-       .rate_init = il4965_rs_rate_init_stub,
-       .alloc = il4965_rs_alloc,
-       .free = il4965_rs_free,
-       .alloc_sta = il4965_rs_alloc_sta,
-       .free_sta = il4965_rs_free_sta,
-#ifdef CONFIG_MAC80211_DEBUGFS
-       .add_sta_debugfs = il4965_rs_add_debugfs,
-       .remove_sta_debugfs = il4965_rs_remove_debugfs,
-#endif
-};
-
-int
-il4965_rate_control_register(void)
-{
-       return ieee80211_rate_control_register(&rs_4965_ops);
-}
-
-void
-il4965_rate_control_unregister(void)
-{
-       ieee80211_rate_control_unregister(&rs_4965_ops);
-}
diff --git a/drivers/net/wireless/iwlegacy/4965.c b/drivers/net/wireless/iwlegacy/4965.c
deleted file mode 100644 (file)
index fe47db9..0000000
+++ /dev/null
@@ -1,1950 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/pci.h>
-#include <linux/dma-mapping.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/skbuff.h>
-#include <linux/netdevice.h>
-#include <net/mac80211.h>
-#include <linux/etherdevice.h>
-#include <asm/unaligned.h>
-
-#include "common.h"
-#include "4965.h"
-
-/**
- * il_verify_inst_sparse - verify runtime uCode image in card vs. host,
- *   using sample data 100 bytes apart.  If these sample points are good,
- *   it's a pretty good bet that everything between them is good, too.
- */
-static int
-il4965_verify_inst_sparse(struct il_priv *il, __le32 * image, u32 len)
-{
-       u32 val;
-       int ret = 0;
-       u32 errcnt = 0;
-       u32 i;
-
-       D_INFO("ucode inst image size is %u\n", len);
-
-       for (i = 0; i < len; i += 100, image += 100 / sizeof(u32)) {
-               /* read data comes through single port, auto-incr addr */
-               /* NOTE: Use the debugless read so we don't flood kernel log
-                * if IL_DL_IO is set */
-               il_wr(il, HBUS_TARG_MEM_RADDR, i + IL4965_RTC_INST_LOWER_BOUND);
-               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
-               if (val != le32_to_cpu(*image)) {
-                       ret = -EIO;
-                       errcnt++;
-                       if (errcnt >= 3)
-                               break;
-               }
-       }
-
-       return ret;
-}
-
-/**
- * il4965_verify_inst_full - verify runtime uCode image in card vs. host,
- *     looking at all data.
- */
-static int
-il4965_verify_inst_full(struct il_priv *il, __le32 * image, u32 len)
-{
-       u32 val;
-       u32 save_len = len;
-       int ret = 0;
-       u32 errcnt;
-
-       D_INFO("ucode inst image size is %u\n", len);
-
-       il_wr(il, HBUS_TARG_MEM_RADDR, IL4965_RTC_INST_LOWER_BOUND);
-
-       errcnt = 0;
-       for (; len > 0; len -= sizeof(u32), image++) {
-               /* read data comes through single port, auto-incr addr */
-               /* NOTE: Use the debugless read so we don't flood kernel log
-                * if IL_DL_IO is set */
-               val = _il_rd(il, HBUS_TARG_MEM_RDAT);
-               if (val != le32_to_cpu(*image)) {
-                       IL_ERR("uCode INST section is invalid at "
-                              "offset 0x%x, is 0x%x, s/b 0x%x\n",
-                              save_len - len, val, le32_to_cpu(*image));
-                       ret = -EIO;
-                       errcnt++;
-                       if (errcnt >= 20)
-                               break;
-               }
-       }
-
-       if (!errcnt)
-               D_INFO("ucode image in INSTRUCTION memory is good\n");
-
-       return ret;
-}
-
-/**
- * il4965_verify_ucode - determine which instruction image is in SRAM,
- *    and verify its contents
- */
-int
-il4965_verify_ucode(struct il_priv *il)
-{
-       __le32 *image;
-       u32 len;
-       int ret;
-
-       /* Try bootstrap */
-       image = (__le32 *) il->ucode_boot.v_addr;
-       len = il->ucode_boot.len;
-       ret = il4965_verify_inst_sparse(il, image, len);
-       if (!ret) {
-               D_INFO("Bootstrap uCode is good in inst SRAM\n");
-               return 0;
-       }
-
-       /* Try initialize */
-       image = (__le32 *) il->ucode_init.v_addr;
-       len = il->ucode_init.len;
-       ret = il4965_verify_inst_sparse(il, image, len);
-       if (!ret) {
-               D_INFO("Initialize uCode is good in inst SRAM\n");
-               return 0;
-       }
-
-       /* Try runtime/protocol */
-       image = (__le32 *) il->ucode_code.v_addr;
-       len = il->ucode_code.len;
-       ret = il4965_verify_inst_sparse(il, image, len);
-       if (!ret) {
-               D_INFO("Runtime uCode is good in inst SRAM\n");
-               return 0;
-       }
-
-       IL_ERR("NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");
-
-       /* Since nothing seems to match, show first several data entries in
-        * instruction SRAM, so maybe visual inspection will give a clue.
-        * Selection of bootstrap image (vs. other images) is arbitrary. */
-       image = (__le32 *) il->ucode_boot.v_addr;
-       len = il->ucode_boot.len;
-       ret = il4965_verify_inst_full(il, image, len);
-
-       return ret;
-}
-
-/******************************************************************************
- *
- * EEPROM related functions
- *
-******************************************************************************/
-
-/*
- * The device's EEPROM semaphore prevents conflicts between driver and uCode
- * when accessing the EEPROM; each access is a series of pulses to/from the
- * EEPROM chip, not a single event, so even reads could conflict if they
- * weren't arbitrated by the semaphore.
- */
-int
-il4965_eeprom_acquire_semaphore(struct il_priv *il)
-{
-       u16 count;
-       int ret;
-
-       for (count = 0; count < EEPROM_SEM_RETRY_LIMIT; count++) {
-               /* Request semaphore */
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
-
-               /* See if we got it */
-               ret =
-                   _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
-                                CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
-                                CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
-                                EEPROM_SEM_TIMEOUT);
-               if (ret >= 0)
-                       return ret;
-       }
-
-       return ret;
-}
-
-void
-il4965_eeprom_release_semaphore(struct il_priv *il)
-{
-       il_clear_bit(il, CSR_HW_IF_CONFIG_REG,
-                    CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM);
-
-}
-
-int
-il4965_eeprom_check_version(struct il_priv *il)
-{
-       u16 eeprom_ver;
-       u16 calib_ver;
-
-       eeprom_ver = il_eeprom_query16(il, EEPROM_VERSION);
-       calib_ver = il_eeprom_query16(il, EEPROM_4965_CALIB_VERSION_OFFSET);
-
-       if (eeprom_ver < il->cfg->eeprom_ver ||
-           calib_ver < il->cfg->eeprom_calib_ver)
-               goto err;
-
-       IL_INFO("device EEPROM VER=0x%x, CALIB=0x%x\n", eeprom_ver, calib_ver);
-
-       return 0;
-err:
-       IL_ERR("Unsupported (too old) EEPROM VER=0x%x < 0x%x "
-              "CALIB=0x%x < 0x%x\n", eeprom_ver, il->cfg->eeprom_ver,
-              calib_ver, il->cfg->eeprom_calib_ver);
-       return -EINVAL;
-
-}
-
-void
-il4965_eeprom_get_mac(const struct il_priv *il, u8 * mac)
-{
-       const u8 *addr = il_eeprom_query_addr(il,
-                                             EEPROM_MAC_ADDRESS);
-       memcpy(mac, addr, ETH_ALEN);
-}
-
-/* Send led command */
-static int
-il4965_send_led_cmd(struct il_priv *il, struct il_led_cmd *led_cmd)
-{
-       struct il_host_cmd cmd = {
-               .id = C_LEDS,
-               .len = sizeof(struct il_led_cmd),
-               .data = led_cmd,
-               .flags = CMD_ASYNC,
-               .callback = NULL,
-       };
-       u32 reg;
-
-       reg = _il_rd(il, CSR_LED_REG);
-       if (reg != (reg & CSR_LED_BSM_CTRL_MSK))
-               _il_wr(il, CSR_LED_REG, reg & CSR_LED_BSM_CTRL_MSK);
-
-       return il_send_cmd(il, &cmd);
-}
-
-/* Set led register off */
-void
-il4965_led_enable(struct il_priv *il)
-{
-       _il_wr(il, CSR_LED_REG, CSR_LED_REG_TRUN_ON);
-}
-
-static int il4965_send_tx_power(struct il_priv *il);
-static int il4965_hw_get_temperature(struct il_priv *il);
-
-/* Highest firmware API version supported */
-#define IL4965_UCODE_API_MAX 2
-
-/* Lowest firmware API version supported */
-#define IL4965_UCODE_API_MIN 2
-
-#define IL4965_FW_PRE "iwlwifi-4965-"
-#define _IL4965_MODULE_FIRMWARE(api) IL4965_FW_PRE #api ".ucode"
-#define IL4965_MODULE_FIRMWARE(api) _IL4965_MODULE_FIRMWARE(api)
-
-/* check contents of special bootstrap uCode SRAM */
-static int
-il4965_verify_bsm(struct il_priv *il)
-{
-       __le32 *image = il->ucode_boot.v_addr;
-       u32 len = il->ucode_boot.len;
-       u32 reg;
-       u32 val;
-
-       D_INFO("Begin verify bsm\n");
-
-       /* verify BSM SRAM contents */
-       val = il_rd_prph(il, BSM_WR_DWCOUNT_REG);
-       for (reg = BSM_SRAM_LOWER_BOUND; reg < BSM_SRAM_LOWER_BOUND + len;
-            reg += sizeof(u32), image++) {
-               val = il_rd_prph(il, reg);
-               if (val != le32_to_cpu(*image)) {
-                       IL_ERR("BSM uCode verification failed at "
-                              "addr 0x%08X+%u (of %u), is 0x%x, s/b 0x%x\n",
-                              BSM_SRAM_LOWER_BOUND, reg - BSM_SRAM_LOWER_BOUND,
-                              len, val, le32_to_cpu(*image));
-                       return -EIO;
-               }
-       }
-
-       D_INFO("BSM bootstrap uCode image OK\n");
-
-       return 0;
-}
-
-/**
- * il4965_load_bsm - Load bootstrap instructions
- *
- * BSM operation:
- *
- * The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
- * in special SRAM that does not power down during RFKILL.  When powering back
- * up after power-saving sleeps (or during initial uCode load), the BSM loads
- * the bootstrap program into the on-board processor, and starts it.
- *
- * The bootstrap program loads (via DMA) instructions and data for a new
- * program from host DRAM locations indicated by the host driver in the
- * BSM_DRAM_* registers.  Once the new program is loaded, it starts
- * automatically.
- *
- * When initializing the NIC, the host driver points the BSM to the
- * "initialize" uCode image.  This uCode sets up some internal data, then
- * notifies host via "initialize alive" that it is complete.
- *
- * The host then replaces the BSM_DRAM_* pointer values to point to the
- * normal runtime uCode instructions and a backup uCode data cache buffer
- * (filled initially with starting data values for the on-board processor),
- * then triggers the "initialize" uCode to load and launch the runtime uCode,
- * which begins normal operation.
- *
- * When doing a power-save shutdown, runtime uCode saves data SRAM into
- * the backup data cache in DRAM before SRAM is powered down.
- *
- * When powering back up, the BSM loads the bootstrap program.  This reloads
- * the runtime uCode instructions and the backup data cache into SRAM,
- * and re-launches the runtime uCode from where it left off.
- */
-static int
-il4965_load_bsm(struct il_priv *il)
-{
-       __le32 *image = il->ucode_boot.v_addr;
-       u32 len = il->ucode_boot.len;
-       dma_addr_t pinst;
-       dma_addr_t pdata;
-       u32 inst_len;
-       u32 data_len;
-       int i;
-       u32 done;
-       u32 reg_offset;
-       int ret;
-
-       D_INFO("Begin load bsm\n");
-
-       il->ucode_type = UCODE_RT;
-
-       /* make sure bootstrap program is no larger than BSM's SRAM size */
-       if (len > IL49_MAX_BSM_SIZE)
-               return -EINVAL;
-
-       /* Tell bootstrap uCode where to find the "Initialize" uCode
-        *   in host DRAM ... host DRAM physical address bits 35:4 for 4965.
-        * NOTE:  il_init_alive_start() will replace these values,
-        *        after the "initialize" uCode has run, to point to
-        *        runtime/protocol instructions and backup data cache.
-        */
-       pinst = il->ucode_init.p_addr >> 4;
-       pdata = il->ucode_init_data.p_addr >> 4;
-       inst_len = il->ucode_init.len;
-       data_len = il->ucode_init_data.len;
-
-       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
-       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
-       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
-       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
-
-       /* Fill BSM memory with bootstrap instructions */
-       for (reg_offset = BSM_SRAM_LOWER_BOUND;
-            reg_offset < BSM_SRAM_LOWER_BOUND + len;
-            reg_offset += sizeof(u32), image++)
-               _il_wr_prph(il, reg_offset, le32_to_cpu(*image));
-
-       ret = il4965_verify_bsm(il);
-       if (ret)
-               return ret;
-
-       /* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
-       il_wr_prph(il, BSM_WR_MEM_SRC_REG, 0x0);
-       il_wr_prph(il, BSM_WR_MEM_DST_REG, IL49_RTC_INST_LOWER_BOUND);
-       il_wr_prph(il, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
-
-       /* Load bootstrap code into instruction SRAM now,
-        *   to prepare to load "initialize" uCode */
-       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START);
-
-       /* Wait for load of bootstrap uCode to finish */
-       for (i = 0; i < 100; i++) {
-               done = il_rd_prph(il, BSM_WR_CTRL_REG);
-               if (!(done & BSM_WR_CTRL_REG_BIT_START))
-                       break;
-               udelay(10);
-       }
-       if (i < 100)
-               D_INFO("BSM write complete, poll %d iterations\n", i);
-       else {
-               IL_ERR("BSM write did not complete!\n");
-               return -EIO;
-       }
-
-       /* Enable future boot loads whenever power management unit triggers it
-        *   (e.g. when powering back up after power-save shutdown) */
-       il_wr_prph(il, BSM_WR_CTRL_REG, BSM_WR_CTRL_REG_BIT_START_EN);
-
-       return 0;
-}
-
-/**
- * il4965_set_ucode_ptrs - Set uCode address location
- *
- * Tell initialization uCode where to find runtime uCode.
- *
- * BSM registers initially contain pointers to initialization uCode.
- * We need to replace them to load runtime uCode inst and data,
- * and to save runtime data when powering down.
- */
-static int
-il4965_set_ucode_ptrs(struct il_priv *il)
-{
-       dma_addr_t pinst;
-       dma_addr_t pdata;
-       int ret = 0;
-
-       /* bits 35:4 for 4965 */
-       pinst = il->ucode_code.p_addr >> 4;
-       pdata = il->ucode_data_backup.p_addr >> 4;
-
-       /* Tell bootstrap uCode where to find image to load */
-       il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
-       il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
-       il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, il->ucode_data.len);
-
-       /* Inst byte count must be last to set up, bit 31 signals uCode
-        *   that all new ptr/size info is in place */
-       il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG,
-                  il->ucode_code.len | BSM_DRAM_INST_LOAD);
-       D_INFO("Runtime uCode pointers are set.\n");
-
-       return ret;
-}
-
-/**
- * il4965_init_alive_start - Called after N_ALIVE notification received
- *
- * Called after N_ALIVE notification received from "initialize" uCode.
- *
- * The 4965 "initialize" ALIVE reply contains calibration data for:
- *   Voltage, temperature, and MIMO tx gain correction, now stored in il
- *   (3945 does not contain this data).
- *
- * Tell "initialize" uCode to go ahead and load the runtime uCode.
-*/
-static void
-il4965_init_alive_start(struct il_priv *il)
-{
-       /* Bootstrap uCode has loaded initialize uCode ... verify inst image.
-        * This is a paranoid check, because we would not have gotten the
-        * "initialize" alive if code weren't properly loaded.  */
-       if (il4965_verify_ucode(il)) {
-               /* Runtime instruction load was bad;
-                * take it all the way back down so we can try again */
-               D_INFO("Bad \"initialize\" uCode load.\n");
-               goto restart;
-       }
-
-       /* Calculate temperature */
-       il->temperature = il4965_hw_get_temperature(il);
-
-       /* Send pointers to protocol/runtime uCode image ... init code will
-        * load and launch runtime uCode, which will send us another "Alive"
-        * notification. */
-       D_INFO("Initialization Alive received.\n");
-       if (il4965_set_ucode_ptrs(il)) {
-               /* Runtime instruction load won't happen;
-                * take it all the way back down so we can try again */
-               D_INFO("Couldn't set up uCode pointers.\n");
-               goto restart;
-       }
-       return;
-
-restart:
-       queue_work(il->workqueue, &il->restart);
-}
-
-static bool
-iw4965_is_ht40_channel(__le32 rxon_flags)
-{
-       int chan_mod =
-           le32_to_cpu(rxon_flags & RXON_FLG_CHANNEL_MODE_MSK) >>
-           RXON_FLG_CHANNEL_MODE_POS;
-       return (chan_mod == CHANNEL_MODE_PURE_40 ||
-               chan_mod == CHANNEL_MODE_MIXED);
-}
-
-void
-il4965_nic_config(struct il_priv *il)
-{
-       unsigned long flags;
-       u16 radio_cfg;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       radio_cfg = il_eeprom_query16(il, EEPROM_RADIO_CONFIG);
-
-       /* write radio config values to register */
-       if (EEPROM_RF_CFG_TYPE_MSK(radio_cfg) == EEPROM_4965_RF_CFG_TYPE_MAX)
-               il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                          EEPROM_RF_CFG_TYPE_MSK(radio_cfg) |
-                          EEPROM_RF_CFG_STEP_MSK(radio_cfg) |
-                          EEPROM_RF_CFG_DASH_MSK(radio_cfg));
-
-       /* set CSR_HW_CONFIG_REG for uCode use */
-       il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                  CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
-                  CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);
-
-       il->calib_info =
-           (struct il_eeprom_calib_info *)
-           il_eeprom_query_addr(il, EEPROM_4965_CALIB_TXPOWER_OFFSET);
-
-       spin_unlock_irqrestore(&il->lock, flags);
-}
-
-/* Reset differential Rx gains in NIC to prepare for chain noise calibration.
- * Called after every association, but this runs only once!
- *  ... once chain noise is calibrated the first time, it's good forever.  */
-static void
-il4965_chain_noise_reset(struct il_priv *il)
-{
-       struct il_chain_noise_data *data = &(il->chain_noise_data);
-
-       if (data->state == IL_CHAIN_NOISE_ALIVE && il_is_any_associated(il)) {
-               struct il_calib_diff_gain_cmd cmd;
-
-               /* clear data for chain noise calibration algorithm */
-               data->chain_noise_a = 0;
-               data->chain_noise_b = 0;
-               data->chain_noise_c = 0;
-               data->chain_signal_a = 0;
-               data->chain_signal_b = 0;
-               data->chain_signal_c = 0;
-               data->beacon_count = 0;
-
-               memset(&cmd, 0, sizeof(cmd));
-               cmd.hdr.op_code = IL_PHY_CALIBRATE_DIFF_GAIN_CMD;
-               cmd.diff_gain_a = 0;
-               cmd.diff_gain_b = 0;
-               cmd.diff_gain_c = 0;
-               if (il_send_cmd_pdu(il, C_PHY_CALIBRATION, sizeof(cmd), &cmd))
-                       IL_ERR("Could not send C_PHY_CALIBRATION\n");
-               data->state = IL_CHAIN_NOISE_ACCUMULATE;
-               D_CALIB("Run chain_noise_calibrate\n");
-       }
-}
-
-static s32
-il4965_math_div_round(s32 num, s32 denom, s32 * res)
-{
-       s32 sign = 1;
-
-       if (num < 0) {
-               sign = -sign;
-               num = -num;
-       }
-       if (denom < 0) {
-               sign = -sign;
-               denom = -denom;
-       }
-       *res = 1;
-       *res = ((num * 2 + denom) / (denom * 2)) * sign;
-
-       return 1;
-}
-
-/**
- * il4965_get_voltage_compensation - Power supply voltage comp for txpower
- *
- * Determines power supply voltage compensation for txpower calculations.
- * Returns number of 1/2-dB steps to subtract from gain table idx,
- * to compensate for difference between power supply voltage during
- * factory measurements, vs. current power supply voltage.
- *
- * Voltage indication is higher for lower voltage.
- * Lower voltage requires more gain (lower gain table idx).
- */
-static s32
-il4965_get_voltage_compensation(s32 eeprom_voltage, s32 current_voltage)
-{
-       s32 comp = 0;
-
-       if (TX_POWER_IL_ILLEGAL_VOLTAGE == eeprom_voltage ||
-           TX_POWER_IL_ILLEGAL_VOLTAGE == current_voltage)
-               return 0;
-
-       il4965_math_div_round(current_voltage - eeprom_voltage,
-                             TX_POWER_IL_VOLTAGE_CODES_PER_03V, &comp);
-
-       if (current_voltage > eeprom_voltage)
-               comp *= 2;
-       if ((comp < -2) || (comp > 2))
-               comp = 0;
-
-       return comp;
-}
-
-static s32
-il4965_get_tx_atten_grp(u16 channel)
-{
-       if (channel >= CALIB_IL_TX_ATTEN_GR5_FCH &&
-           channel <= CALIB_IL_TX_ATTEN_GR5_LCH)
-               return CALIB_CH_GROUP_5;
-
-       if (channel >= CALIB_IL_TX_ATTEN_GR1_FCH &&
-           channel <= CALIB_IL_TX_ATTEN_GR1_LCH)
-               return CALIB_CH_GROUP_1;
-
-       if (channel >= CALIB_IL_TX_ATTEN_GR2_FCH &&
-           channel <= CALIB_IL_TX_ATTEN_GR2_LCH)
-               return CALIB_CH_GROUP_2;
-
-       if (channel >= CALIB_IL_TX_ATTEN_GR3_FCH &&
-           channel <= CALIB_IL_TX_ATTEN_GR3_LCH)
-               return CALIB_CH_GROUP_3;
-
-       if (channel >= CALIB_IL_TX_ATTEN_GR4_FCH &&
-           channel <= CALIB_IL_TX_ATTEN_GR4_LCH)
-               return CALIB_CH_GROUP_4;
-
-       return -EINVAL;
-}
-
-static u32
-il4965_get_sub_band(const struct il_priv *il, u32 channel)
-{
-       s32 b = -1;
-
-       for (b = 0; b < EEPROM_TX_POWER_BANDS; b++) {
-               if (il->calib_info->band_info[b].ch_from == 0)
-                       continue;
-
-               if (channel >= il->calib_info->band_info[b].ch_from &&
-                   channel <= il->calib_info->band_info[b].ch_to)
-                       break;
-       }
-
-       return b;
-}
-
-static s32
-il4965_interpolate_value(s32 x, s32 x1, s32 y1, s32 x2, s32 y2)
-{
-       s32 val;
-
-       if (x2 == x1)
-               return y1;
-       else {
-               il4965_math_div_round((x2 - x) * (y1 - y2), (x2 - x1), &val);
-               return val + y2;
-       }
-}
-
-/**
- * il4965_interpolate_chan - Interpolate factory measurements for one channel
- *
- * Interpolates factory measurements from the two sample channels within a
- * sub-band, to apply to channel of interest.  Interpolation is proportional to
- * differences in channel frequencies, which is proportional to differences
- * in channel number.
- */
-static int
-il4965_interpolate_chan(struct il_priv *il, u32 channel,
-                       struct il_eeprom_calib_ch_info *chan_info)
-{
-       s32 s = -1;
-       u32 c;
-       u32 m;
-       const struct il_eeprom_calib_measure *m1;
-       const struct il_eeprom_calib_measure *m2;
-       struct il_eeprom_calib_measure *omeas;
-       u32 ch_i1;
-       u32 ch_i2;
-
-       s = il4965_get_sub_band(il, channel);
-       if (s >= EEPROM_TX_POWER_BANDS) {
-               IL_ERR("Tx Power can not find channel %d\n", channel);
-               return -1;
-       }
-
-       ch_i1 = il->calib_info->band_info[s].ch1.ch_num;
-       ch_i2 = il->calib_info->band_info[s].ch2.ch_num;
-       chan_info->ch_num = (u8) channel;
-
-       D_TXPOWER("channel %d subband %d factory cal ch %d & %d\n", channel, s,
-                 ch_i1, ch_i2);
-
-       for (c = 0; c < EEPROM_TX_POWER_TX_CHAINS; c++) {
-               for (m = 0; m < EEPROM_TX_POWER_MEASUREMENTS; m++) {
-                       m1 = &(il->calib_info->band_info[s].ch1.
-                              measurements[c][m]);
-                       m2 = &(il->calib_info->band_info[s].ch2.
-                              measurements[c][m]);
-                       omeas = &(chan_info->measurements[c][m]);
-
-                       omeas->actual_pow =
-                           (u8) il4965_interpolate_value(channel, ch_i1,
-                                                         m1->actual_pow, ch_i2,
-                                                         m2->actual_pow);
-                       omeas->gain_idx =
-                           (u8) il4965_interpolate_value(channel, ch_i1,
-                                                         m1->gain_idx, ch_i2,
-                                                         m2->gain_idx);
-                       omeas->temperature =
-                           (u8) il4965_interpolate_value(channel, ch_i1,
-                                                         m1->temperature,
-                                                         ch_i2,
-                                                         m2->temperature);
-                       omeas->pa_det =
-                           (s8) il4965_interpolate_value(channel, ch_i1,
-                                                         m1->pa_det, ch_i2,
-                                                         m2->pa_det);
-
-                       D_TXPOWER("chain %d meas %d AP1=%d AP2=%d AP=%d\n", c,
-                                 m, m1->actual_pow, m2->actual_pow,
-                                 omeas->actual_pow);
-                       D_TXPOWER("chain %d meas %d NI1=%d NI2=%d NI=%d\n", c,
-                                 m, m1->gain_idx, m2->gain_idx,
-                                 omeas->gain_idx);
-                       D_TXPOWER("chain %d meas %d PA1=%d PA2=%d PA=%d\n", c,
-                                 m, m1->pa_det, m2->pa_det, omeas->pa_det);
-                       D_TXPOWER("chain %d meas %d  T1=%d  T2=%d  T=%d\n", c,
-                                 m, m1->temperature, m2->temperature,
-                                 omeas->temperature);
-               }
-       }
-
-       return 0;
-}
-
-/* bit-rate-dependent table to prevent Tx distortion, in half-dB units,
- * for OFDM 6, 12, 18, 24, 36, 48, 54, 60 MBit, and CCK all rates. */
-static s32 back_off_table[] = {
-       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 20 MHz */
-       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 20 MHz */
-       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 40 MHz */
-       10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 40 MHz */
-       10                      /* CCK */
-};
-
-/* Thermal compensation values for txpower for various frequency ranges ...
- *   ratios from 3:1 to 4.5:1 of degrees (Celsius) per half-dB gain adjust */
-static struct il4965_txpower_comp_entry {
-       s32 degrees_per_05db_a;
-       s32 degrees_per_05db_a_denom;
-} tx_power_cmp_tble[CALIB_CH_GROUP_MAX] = {
-       {
-       9, 2},                  /* group 0 5.2, ch  34-43 */
-       {
-       4, 1},                  /* group 1 5.2, ch  44-70 */
-       {
-       4, 1},                  /* group 2 5.2, ch  71-124 */
-       {
-       4, 1},                  /* group 3 5.2, ch 125-200 */
-       {
-       3, 1}                   /* group 4 2.4, ch   all */
-};
-
-static s32
-get_min_power_idx(s32 rate_power_idx, u32 band)
-{
-       if (!band) {
-               if ((rate_power_idx & 7) <= 4)
-                       return MIN_TX_GAIN_IDX_52GHZ_EXT;
-       }
-       return MIN_TX_GAIN_IDX;
-}
-
-struct gain_entry {
-       u8 dsp;
-       u8 radio;
-};
-
-static const struct gain_entry gain_table[2][108] = {
-       /* 5.2GHz power gain idx table */
-       {
-        {123, 0x3F},           /* highest txpower */
-        {117, 0x3F},
-        {110, 0x3F},
-        {104, 0x3F},
-        {98, 0x3F},
-        {110, 0x3E},
-        {104, 0x3E},
-        {98, 0x3E},
-        {110, 0x3D},
-        {104, 0x3D},
-        {98, 0x3D},
-        {110, 0x3C},
-        {104, 0x3C},
-        {98, 0x3C},
-        {110, 0x3B},
-        {104, 0x3B},
-        {98, 0x3B},
-        {110, 0x3A},
-        {104, 0x3A},
-        {98, 0x3A},
-        {110, 0x39},
-        {104, 0x39},
-        {98, 0x39},
-        {110, 0x38},
-        {104, 0x38},
-        {98, 0x38},
-        {110, 0x37},
-        {104, 0x37},
-        {98, 0x37},
-        {110, 0x36},
-        {104, 0x36},
-        {98, 0x36},
-        {110, 0x35},
-        {104, 0x35},
-        {98, 0x35},
-        {110, 0x34},
-        {104, 0x34},
-        {98, 0x34},
-        {110, 0x33},
-        {104, 0x33},
-        {98, 0x33},
-        {110, 0x32},
-        {104, 0x32},
-        {98, 0x32},
-        {110, 0x31},
-        {104, 0x31},
-        {98, 0x31},
-        {110, 0x30},
-        {104, 0x30},
-        {98, 0x30},
-        {110, 0x25},
-        {104, 0x25},
-        {98, 0x25},
-        {110, 0x24},
-        {104, 0x24},
-        {98, 0x24},
-        {110, 0x23},
-        {104, 0x23},
-        {98, 0x23},
-        {110, 0x22},
-        {104, 0x18},
-        {98, 0x18},
-        {110, 0x17},
-        {104, 0x17},
-        {98, 0x17},
-        {110, 0x16},
-        {104, 0x16},
-        {98, 0x16},
-        {110, 0x15},
-        {104, 0x15},
-        {98, 0x15},
-        {110, 0x14},
-        {104, 0x14},
-        {98, 0x14},
-        {110, 0x13},
-        {104, 0x13},
-        {98, 0x13},
-        {110, 0x12},
-        {104, 0x08},
-        {98, 0x08},
-        {110, 0x07},
-        {104, 0x07},
-        {98, 0x07},
-        {110, 0x06},
-        {104, 0x06},
-        {98, 0x06},
-        {110, 0x05},
-        {104, 0x05},
-        {98, 0x05},
-        {110, 0x04},
-        {104, 0x04},
-        {98, 0x04},
-        {110, 0x03},
-        {104, 0x03},
-        {98, 0x03},
-        {110, 0x02},
-        {104, 0x02},
-        {98, 0x02},
-        {110, 0x01},
-        {104, 0x01},
-        {98, 0x01},
-        {110, 0x00},
-        {104, 0x00},
-        {98, 0x00},
-        {93, 0x00},
-        {88, 0x00},
-        {83, 0x00},
-        {78, 0x00},
-        },
-       /* 2.4GHz power gain idx table */
-       {
-        {110, 0x3f},           /* highest txpower */
-        {104, 0x3f},
-        {98, 0x3f},
-        {110, 0x3e},
-        {104, 0x3e},
-        {98, 0x3e},
-        {110, 0x3d},
-        {104, 0x3d},
-        {98, 0x3d},
-        {110, 0x3c},
-        {104, 0x3c},
-        {98, 0x3c},
-        {110, 0x3b},
-        {104, 0x3b},
-        {98, 0x3b},
-        {110, 0x3a},
-        {104, 0x3a},
-        {98, 0x3a},
-        {110, 0x39},
-        {104, 0x39},
-        {98, 0x39},
-        {110, 0x38},
-        {104, 0x38},
-        {98, 0x38},
-        {110, 0x37},
-        {104, 0x37},
-        {98, 0x37},
-        {110, 0x36},
-        {104, 0x36},
-        {98, 0x36},
-        {110, 0x35},
-        {104, 0x35},
-        {98, 0x35},
-        {110, 0x34},
-        {104, 0x34},
-        {98, 0x34},
-        {110, 0x33},
-        {104, 0x33},
-        {98, 0x33},
-        {110, 0x32},
-        {104, 0x32},
-        {98, 0x32},
-        {110, 0x31},
-        {104, 0x31},
-        {98, 0x31},
-        {110, 0x30},
-        {104, 0x30},
-        {98, 0x30},
-        {110, 0x6},
-        {104, 0x6},
-        {98, 0x6},
-        {110, 0x5},
-        {104, 0x5},
-        {98, 0x5},
-        {110, 0x4},
-        {104, 0x4},
-        {98, 0x4},
-        {110, 0x3},
-        {104, 0x3},
-        {98, 0x3},
-        {110, 0x2},
-        {104, 0x2},
-        {98, 0x2},
-        {110, 0x1},
-        {104, 0x1},
-        {98, 0x1},
-        {110, 0x0},
-        {104, 0x0},
-        {98, 0x0},
-        {97, 0},
-        {96, 0},
-        {95, 0},
-        {94, 0},
-        {93, 0},
-        {92, 0},
-        {91, 0},
-        {90, 0},
-        {89, 0},
-        {88, 0},
-        {87, 0},
-        {86, 0},
-        {85, 0},
-        {84, 0},
-        {83, 0},
-        {82, 0},
-        {81, 0},
-        {80, 0},
-        {79, 0},
-        {78, 0},
-        {77, 0},
-        {76, 0},
-        {75, 0},
-        {74, 0},
-        {73, 0},
-        {72, 0},
-        {71, 0},
-        {70, 0},
-        {69, 0},
-        {68, 0},
-        {67, 0},
-        {66, 0},
-        {65, 0},
-        {64, 0},
-        {63, 0},
-        {62, 0},
-        {61, 0},
-        {60, 0},
-        {59, 0},
-        }
-};
-
-static int
-il4965_fill_txpower_tbl(struct il_priv *il, u8 band, u16 channel, u8 is_ht40,
-                       u8 ctrl_chan_high,
-                       struct il4965_tx_power_db *tx_power_tbl)
-{
-       u8 saturation_power;
-       s32 target_power;
-       s32 user_target_power;
-       s32 power_limit;
-       s32 current_temp;
-       s32 reg_limit;
-       s32 current_regulatory;
-       s32 txatten_grp = CALIB_CH_GROUP_MAX;
-       int i;
-       int c;
-       const struct il_channel_info *ch_info = NULL;
-       struct il_eeprom_calib_ch_info ch_eeprom_info;
-       const struct il_eeprom_calib_measure *measurement;
-       s16 voltage;
-       s32 init_voltage;
-       s32 voltage_compensation;
-       s32 degrees_per_05db_num;
-       s32 degrees_per_05db_denom;
-       s32 factory_temp;
-       s32 temperature_comp[2];
-       s32 factory_gain_idx[2];
-       s32 factory_actual_pwr[2];
-       s32 power_idx;
-
-       /* tx_power_user_lmt is in dBm, convert to half-dBm (half-dB units
-        *   are used for idxing into txpower table) */
-       user_target_power = 2 * il->tx_power_user_lmt;
-
-       /* Get current (RXON) channel, band, width */
-       D_TXPOWER("chan %d band %d is_ht40 %d\n", channel, band, is_ht40);
-
-       ch_info = il_get_channel_info(il, il->band, channel);
-
-       if (!il_is_channel_valid(ch_info))
-               return -EINVAL;
-
-       /* get txatten group, used to select 1) thermal txpower adjustment
-        *   and 2) mimo txpower balance between Tx chains. */
-       txatten_grp = il4965_get_tx_atten_grp(channel);
-       if (txatten_grp < 0) {
-               IL_ERR("Can't find txatten group for channel %d.\n", channel);
-               return txatten_grp;
-       }
-
-       D_TXPOWER("channel %d belongs to txatten group %d\n", channel,
-                 txatten_grp);
-
-       if (is_ht40) {
-               if (ctrl_chan_high)
-                       channel -= 2;
-               else
-                       channel += 2;
-       }
-
-       /* hardware txpower limits ...
-        * saturation (clipping distortion) txpowers are in half-dBm */
-       if (band)
-               saturation_power = il->calib_info->saturation_power24;
-       else
-               saturation_power = il->calib_info->saturation_power52;
-
-       if (saturation_power < IL_TX_POWER_SATURATION_MIN ||
-           saturation_power > IL_TX_POWER_SATURATION_MAX) {
-               if (band)
-                       saturation_power = IL_TX_POWER_DEFAULT_SATURATION_24;
-               else
-                       saturation_power = IL_TX_POWER_DEFAULT_SATURATION_52;
-       }
-
-       /* regulatory txpower limits ... reg_limit values are in half-dBm,
-        *   max_power_avg values are in dBm, convert * 2 */
-       if (is_ht40)
-               reg_limit = ch_info->ht40_max_power_avg * 2;
-       else
-               reg_limit = ch_info->max_power_avg * 2;
-
-       if ((reg_limit < IL_TX_POWER_REGULATORY_MIN) ||
-           (reg_limit > IL_TX_POWER_REGULATORY_MAX)) {
-               if (band)
-                       reg_limit = IL_TX_POWER_DEFAULT_REGULATORY_24;
-               else
-                       reg_limit = IL_TX_POWER_DEFAULT_REGULATORY_52;
-       }
-
-       /* Interpolate txpower calibration values for this channel,
-        *   based on factory calibration tests on spaced channels. */
-       il4965_interpolate_chan(il, channel, &ch_eeprom_info);
-
-       /* calculate tx gain adjustment based on power supply voltage */
-       voltage = le16_to_cpu(il->calib_info->voltage);
-       init_voltage = (s32) le32_to_cpu(il->card_alive_init.voltage);
-       voltage_compensation =
-           il4965_get_voltage_compensation(voltage, init_voltage);
-
-       D_TXPOWER("curr volt %d eeprom volt %d volt comp %d\n", init_voltage,
-                 voltage, voltage_compensation);
-
-       /* get current temperature (Celsius) */
-       current_temp = max(il->temperature, IL_TX_POWER_TEMPERATURE_MIN);
-       current_temp = min(il->temperature, IL_TX_POWER_TEMPERATURE_MAX);
-       current_temp = KELVIN_TO_CELSIUS(current_temp);
-
-       /* select thermal txpower adjustment params, based on channel group
-        *   (same frequency group used for mimo txatten adjustment) */
-       degrees_per_05db_num =
-           tx_power_cmp_tble[txatten_grp].degrees_per_05db_a;
-       degrees_per_05db_denom =
-           tx_power_cmp_tble[txatten_grp].degrees_per_05db_a_denom;
-
-       /* get per-chain txpower values from factory measurements */
-       for (c = 0; c < 2; c++) {
-               measurement = &ch_eeprom_info.measurements[c][1];
-
-               /* txgain adjustment (in half-dB steps) based on difference
-                *   between factory and current temperature */
-               factory_temp = measurement->temperature;
-               il4965_math_div_round((current_temp -
-                                      factory_temp) * degrees_per_05db_denom,
-                                     degrees_per_05db_num,
-                                     &temperature_comp[c]);
-
-               factory_gain_idx[c] = measurement->gain_idx;
-               factory_actual_pwr[c] = measurement->actual_pow;
-
-               D_TXPOWER("chain = %d\n", c);
-               D_TXPOWER("fctry tmp %d, " "curr tmp %d, comp %d steps\n",
-                         factory_temp, current_temp, temperature_comp[c]);
-
-               D_TXPOWER("fctry idx %d, fctry pwr %d\n", factory_gain_idx[c],
-                         factory_actual_pwr[c]);
-       }
-
-       /* for each of 33 bit-rates (including 1 for CCK) */
-       for (i = 0; i < POWER_TBL_NUM_ENTRIES; i++) {
-               u8 is_mimo_rate;
-               union il4965_tx_power_dual_stream tx_power;
-
-               /* for mimo, reduce each chain's txpower by half
-                * (3dB, 6 steps), so total output power is regulatory
-                * compliant. */
-               if (i & 0x8) {
-                       current_regulatory =
-                           reg_limit -
-                           IL_TX_POWER_MIMO_REGULATORY_COMPENSATION;
-                       is_mimo_rate = 1;
-               } else {
-                       current_regulatory = reg_limit;
-                       is_mimo_rate = 0;
-               }
-
-               /* find txpower limit, either hardware or regulatory */
-               power_limit = saturation_power - back_off_table[i];
-               if (power_limit > current_regulatory)
-                       power_limit = current_regulatory;
-
-               /* reduce user's txpower request if necessary
-                * for this rate on this channel */
-               target_power = user_target_power;
-               if (target_power > power_limit)
-                       target_power = power_limit;
-
-               D_TXPOWER("rate %d sat %d reg %d usr %d tgt %d\n", i,
-                         saturation_power - back_off_table[i],
-                         current_regulatory, user_target_power, target_power);
-
-               /* for each of 2 Tx chains (radio transmitters) */
-               for (c = 0; c < 2; c++) {
-                       s32 atten_value;
-
-                       if (is_mimo_rate)
-                               atten_value =
-                                   (s32) le32_to_cpu(il->card_alive_init.
-                                                     tx_atten[txatten_grp][c]);
-                       else
-                               atten_value = 0;
-
-                       /* calculate idx; higher idx means lower txpower */
-                       power_idx =
-                           (u8) (factory_gain_idx[c] -
-                                 (target_power - factory_actual_pwr[c]) -
-                                 temperature_comp[c] - voltage_compensation +
-                                 atten_value);
-
-/*                     D_TXPOWER("calculated txpower idx %d\n",
-                                               power_idx); */
-
-                       if (power_idx < get_min_power_idx(i, band))
-                               power_idx = get_min_power_idx(i, band);
-
-                       /* adjust 5 GHz idx to support negative idxes */
-                       if (!band)
-                               power_idx += 9;
-
-                       /* CCK, rate 32, reduce txpower for CCK */
-                       if (i == POWER_TBL_CCK_ENTRY)
-                               power_idx +=
-                                   IL_TX_POWER_CCK_COMPENSATION_C_STEP;
-
-                       /* stay within the table! */
-                       if (power_idx > 107) {
-                               IL_WARN("txpower idx %d > 107\n", power_idx);
-                               power_idx = 107;
-                       }
-                       if (power_idx < 0) {
-                               IL_WARN("txpower idx %d < 0\n", power_idx);
-                               power_idx = 0;
-                       }
-
-                       /* fill txpower command for this rate/chain */
-                       tx_power.s.radio_tx_gain[c] =
-                           gain_table[band][power_idx].radio;
-                       tx_power.s.dsp_predis_atten[c] =
-                           gain_table[band][power_idx].dsp;
-
-                       D_TXPOWER("chain %d mimo %d idx %d "
-                                 "gain 0x%02x dsp %d\n", c, atten_value,
-                                 power_idx, tx_power.s.radio_tx_gain[c],
-                                 tx_power.s.dsp_predis_atten[c]);
-               }               /* for each chain */
-
-               tx_power_tbl->power_tbl[i].dw = cpu_to_le32(tx_power.dw);
-
-       }                       /* for each rate */
-
-       return 0;
-}
-
-/**
- * il4965_send_tx_power - Configure the TXPOWER level user limit
- *
- * Uses the active RXON for channel, band, and characteristics (ht40, high)
- * The power limit is taken from il->tx_power_user_lmt.
- */
-static int
-il4965_send_tx_power(struct il_priv *il)
-{
-       struct il4965_txpowertable_cmd cmd = { 0 };
-       int ret;
-       u8 band = 0;
-       bool is_ht40 = false;
-       u8 ctrl_chan_high = 0;
-
-       if (WARN_ONCE
-           (test_bit(S_SCAN_HW, &il->status),
-            "TX Power requested while scanning!\n"))
-               return -EAGAIN;
-
-       band = il->band == IEEE80211_BAND_2GHZ;
-
-       is_ht40 = iw4965_is_ht40_channel(il->active.flags);
-
-       if (is_ht40 && (il->active.flags & RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK))
-               ctrl_chan_high = 1;
-
-       cmd.band = band;
-       cmd.channel = il->active.channel;
-
-       ret =
-           il4965_fill_txpower_tbl(il, band, le16_to_cpu(il->active.channel),
-                                   is_ht40, ctrl_chan_high, &cmd.tx_power);
-       if (ret)
-               goto out;
-
-       ret = il_send_cmd_pdu(il, C_TX_PWR_TBL, sizeof(cmd), &cmd);
-
-out:
-       return ret;
-}
-
-static int
-il4965_send_rxon_assoc(struct il_priv *il)
-{
-       int ret = 0;
-       struct il4965_rxon_assoc_cmd rxon_assoc;
-       const struct il_rxon_cmd *rxon1 = &il->staging;
-       const struct il_rxon_cmd *rxon2 = &il->active;
-
-       if (rxon1->flags == rxon2->flags &&
-           rxon1->filter_flags == rxon2->filter_flags &&
-           rxon1->cck_basic_rates == rxon2->cck_basic_rates &&
-           rxon1->ofdm_ht_single_stream_basic_rates ==
-           rxon2->ofdm_ht_single_stream_basic_rates &&
-           rxon1->ofdm_ht_dual_stream_basic_rates ==
-           rxon2->ofdm_ht_dual_stream_basic_rates &&
-           rxon1->rx_chain == rxon2->rx_chain &&
-           rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates) {
-               D_INFO("Using current RXON_ASSOC.  Not resending.\n");
-               return 0;
-       }
-
-       rxon_assoc.flags = il->staging.flags;
-       rxon_assoc.filter_flags = il->staging.filter_flags;
-       rxon_assoc.ofdm_basic_rates = il->staging.ofdm_basic_rates;
-       rxon_assoc.cck_basic_rates = il->staging.cck_basic_rates;
-       rxon_assoc.reserved = 0;
-       rxon_assoc.ofdm_ht_single_stream_basic_rates =
-           il->staging.ofdm_ht_single_stream_basic_rates;
-       rxon_assoc.ofdm_ht_dual_stream_basic_rates =
-           il->staging.ofdm_ht_dual_stream_basic_rates;
-       rxon_assoc.rx_chain_select_flags = il->staging.rx_chain;
-
-       ret =
-           il_send_cmd_pdu_async(il, C_RXON_ASSOC, sizeof(rxon_assoc),
-                                 &rxon_assoc, NULL);
-
-       return ret;
-}
-
-static int
-il4965_commit_rxon(struct il_priv *il)
-{
-       /* cast away the const for active_rxon in this function */
-       struct il_rxon_cmd *active_rxon = (void *)&il->active;
-       int ret;
-       bool new_assoc = !!(il->staging.filter_flags & RXON_FILTER_ASSOC_MSK);
-
-       if (!il_is_alive(il))
-               return -EBUSY;
-
-       /* always get timestamp with Rx frame */
-       il->staging.flags |= RXON_FLG_TSF2HOST_MSK;
-
-       ret = il_check_rxon_cmd(il);
-       if (ret) {
-               IL_ERR("Invalid RXON configuration.  Not committing.\n");
-               return -EINVAL;
-       }
-
-       /*
-        * receive commit_rxon request
-        * abort any previous channel switch if still in process
-        */
-       if (test_bit(S_CHANNEL_SWITCH_PENDING, &il->status) &&
-           il->switch_channel != il->staging.channel) {
-               D_11H("abort channel switch on %d\n",
-                     le16_to_cpu(il->switch_channel));
-               il_chswitch_done(il, false);
-       }
-
-       /* If we don't need to send a full RXON, we can use
-        * il_rxon_assoc_cmd which is used to reconfigure filter
-        * and other flags for the current radio configuration. */
-       if (!il_full_rxon_required(il)) {
-               ret = il_send_rxon_assoc(il);
-               if (ret) {
-                       IL_ERR("Error setting RXON_ASSOC (%d)\n", ret);
-                       return ret;
-               }
-
-               memcpy(active_rxon, &il->staging, sizeof(*active_rxon));
-               il_print_rx_config_cmd(il);
-               /*
-                * We do not commit tx power settings while channel changing,
-                * do it now if tx power changed.
-                */
-               il_set_tx_power(il, il->tx_power_next, false);
-               return 0;
-       }
-
-       /* If we are currently associated and the new config requires
-        * 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 (il_is_associated(il) && new_assoc) {
-               D_INFO("Toggling associated bit on current RXON\n");
-               active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-
-               ret =
-                   il_send_cmd_pdu(il, C_RXON,
-                                   sizeof(struct il_rxon_cmd), active_rxon);
-
-               /* If the mask clearing failed then we set
-                * active_rxon back to what it was previously */
-               if (ret) {
-                       active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
-                       IL_ERR("Error clearing ASSOC_MSK (%d)\n", ret);
-                       return ret;
-               }
-               il_clear_ucode_stations(il);
-               il_restore_stations(il);
-               ret = il4965_restore_default_wep_keys(il);
-               if (ret) {
-                       IL_ERR("Failed to restore WEP keys (%d)\n", ret);
-                       return ret;
-               }
-       }
-
-       D_INFO("Sending RXON\n" "* with%s RXON_FILTER_ASSOC_MSK\n"
-              "* channel = %d\n" "* bssid = %pM\n", (new_assoc ? "" : "out"),
-              le16_to_cpu(il->staging.channel), il->staging.bssid_addr);
-
-       il_set_rxon_hwcrypto(il, !il->cfg->mod_params->sw_crypto);
-
-       /* Apply the new configuration
-        * RXON unassoc clears the station table in uCode so restoration of
-        * stations is needed after it (the RXON command) completes
-        */
-       if (!new_assoc) {
-               ret =
-                   il_send_cmd_pdu(il, C_RXON,
-                                   sizeof(struct il_rxon_cmd), &il->staging);
-               if (ret) {
-                       IL_ERR("Error setting new RXON (%d)\n", ret);
-                       return ret;
-               }
-               D_INFO("Return from !new_assoc RXON.\n");
-               memcpy(active_rxon, &il->staging, sizeof(*active_rxon));
-               il_clear_ucode_stations(il);
-               il_restore_stations(il);
-               ret = il4965_restore_default_wep_keys(il);
-               if (ret) {
-                       IL_ERR("Failed to restore WEP keys (%d)\n", ret);
-                       return ret;
-               }
-       }
-       if (new_assoc) {
-               il->start_calib = 0;
-               /* Apply the new configuration
-                * RXON assoc doesn't clear the station table in uCode,
-                */
-               ret =
-                   il_send_cmd_pdu(il, C_RXON,
-                                   sizeof(struct il_rxon_cmd), &il->staging);
-               if (ret) {
-                       IL_ERR("Error setting new RXON (%d)\n", ret);
-                       return ret;
-               }
-               memcpy(active_rxon, &il->staging, sizeof(*active_rxon));
-       }
-       il_print_rx_config_cmd(il);
-
-       il4965_init_sensitivity(il);
-
-       /* If we issue a new RXON command which required a tune then we must
-        * send a new TXPOWER command or we won't be able to Tx any frames */
-       ret = il_set_tx_power(il, il->tx_power_next, true);
-       if (ret) {
-               IL_ERR("Error sending TX power (%d)\n", ret);
-               return ret;
-       }
-
-       return 0;
-}
-
-static int
-il4965_hw_channel_switch(struct il_priv *il,
-                        struct ieee80211_channel_switch *ch_switch)
-{
-       int rc;
-       u8 band = 0;
-       bool is_ht40 = false;
-       u8 ctrl_chan_high = 0;
-       struct il4965_channel_switch_cmd cmd;
-       const struct il_channel_info *ch_info;
-       u32 switch_time_in_usec, ucode_switch_time;
-       u16 ch;
-       u32 tsf_low;
-       u8 switch_count;
-       u16 beacon_interval = le16_to_cpu(il->timing.beacon_interval);
-       struct ieee80211_vif *vif = il->vif;
-       band = (il->band == IEEE80211_BAND_2GHZ);
-
-       if (WARN_ON_ONCE(vif == NULL))
-               return -EIO;
-
-       is_ht40 = iw4965_is_ht40_channel(il->staging.flags);
-
-       if (is_ht40 && (il->staging.flags & RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK))
-               ctrl_chan_high = 1;
-
-       cmd.band = band;
-       cmd.expect_beacon = 0;
-       ch = ch_switch->chandef.chan->hw_value;
-       cmd.channel = cpu_to_le16(ch);
-       cmd.rxon_flags = il->staging.flags;
-       cmd.rxon_filter_flags = il->staging.filter_flags;
-       switch_count = ch_switch->count;
-       tsf_low = ch_switch->timestamp & 0x0ffffffff;
-       /*
-        * calculate the ucode channel switch time
-        * adding TSF as one of the factor for when to switch
-        */
-       if (il->ucode_beacon_time > tsf_low && beacon_interval) {
-               if (switch_count >
-                   ((il->ucode_beacon_time - tsf_low) / beacon_interval)) {
-                       switch_count -=
-                           (il->ucode_beacon_time - tsf_low) / beacon_interval;
-               } else
-                       switch_count = 0;
-       }
-       if (switch_count <= 1)
-               cmd.switch_time = cpu_to_le32(il->ucode_beacon_time);
-       else {
-               switch_time_in_usec =
-                   vif->bss_conf.beacon_int * switch_count * TIME_UNIT;
-               ucode_switch_time =
-                   il_usecs_to_beacons(il, switch_time_in_usec,
-                                       beacon_interval);
-               cmd.switch_time =
-                   il_add_beacon_time(il, il->ucode_beacon_time,
-                                      ucode_switch_time, beacon_interval);
-       }
-       D_11H("uCode time for the switch is 0x%x\n", cmd.switch_time);
-       ch_info = il_get_channel_info(il, il->band, ch);
-       if (ch_info)
-               cmd.expect_beacon = il_is_channel_radar(ch_info);
-       else {
-               IL_ERR("invalid channel switch from %u to %u\n",
-                      il->active.channel, ch);
-               return -EFAULT;
-       }
-
-       rc = il4965_fill_txpower_tbl(il, band, ch, is_ht40, ctrl_chan_high,
-                                    &cmd.tx_power);
-       if (rc) {
-               D_11H("error:%d  fill txpower_tbl\n", rc);
-               return rc;
-       }
-
-       return il_send_cmd_pdu(il, C_CHANNEL_SWITCH, sizeof(cmd), &cmd);
-}
-
-/**
- * il4965_txq_update_byte_cnt_tbl - Set up entry in Tx byte-count array
- */
-static void
-il4965_txq_update_byte_cnt_tbl(struct il_priv *il, struct il_tx_queue *txq,
-                              u16 byte_cnt)
-{
-       struct il4965_scd_bc_tbl *scd_bc_tbl = il->scd_bc_tbls.addr;
-       int txq_id = txq->q.id;
-       int write_ptr = txq->q.write_ptr;
-       int len = byte_cnt + IL_TX_CRC_SIZE + IL_TX_DELIMITER_SIZE;
-       __le16 bc_ent;
-
-       WARN_ON(len > 0xFFF || write_ptr >= TFD_QUEUE_SIZE_MAX);
-
-       bc_ent = cpu_to_le16(len & 0xFFF);
-       /* Set up byte count within first 256 entries */
-       scd_bc_tbl[txq_id].tfd_offset[write_ptr] = bc_ent;
-
-       /* If within first 64 entries, duplicate at end */
-       if (write_ptr < TFD_QUEUE_SIZE_BC_DUP)
-               scd_bc_tbl[txq_id].tfd_offset[TFD_QUEUE_SIZE_MAX + write_ptr] =
-                   bc_ent;
-}
-
-/**
- * il4965_hw_get_temperature - return the calibrated temperature (in Kelvin)
- * @stats: Provides the temperature reading from the uCode
- *
- * A return of <0 indicates bogus data in the stats
- */
-static int
-il4965_hw_get_temperature(struct il_priv *il)
-{
-       s32 temperature;
-       s32 vt;
-       s32 R1, R2, R3;
-       u32 R4;
-
-       if (test_bit(S_TEMPERATURE, &il->status) &&
-           (il->_4965.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK)) {
-               D_TEMP("Running HT40 temperature calibration\n");
-               R1 = (s32) le32_to_cpu(il->card_alive_init.therm_r1[1]);
-               R2 = (s32) le32_to_cpu(il->card_alive_init.therm_r2[1]);
-               R3 = (s32) le32_to_cpu(il->card_alive_init.therm_r3[1]);
-               R4 = le32_to_cpu(il->card_alive_init.therm_r4[1]);
-       } else {
-               D_TEMP("Running temperature calibration\n");
-               R1 = (s32) le32_to_cpu(il->card_alive_init.therm_r1[0]);
-               R2 = (s32) le32_to_cpu(il->card_alive_init.therm_r2[0]);
-               R3 = (s32) le32_to_cpu(il->card_alive_init.therm_r3[0]);
-               R4 = le32_to_cpu(il->card_alive_init.therm_r4[0]);
-       }
-
-       /*
-        * Temperature is only 23 bits, so sign extend out to 32.
-        *
-        * NOTE If we haven't received a stats notification yet
-        * with an updated temperature, use R4 provided to us in the
-        * "initialize" ALIVE response.
-        */
-       if (!test_bit(S_TEMPERATURE, &il->status))
-               vt = sign_extend32(R4, 23);
-       else
-               vt = sign_extend32(le32_to_cpu
-                                  (il->_4965.stats.general.common.temperature),
-                                  23);
-
-       D_TEMP("Calib values R[1-3]: %d %d %d R4: %d\n", R1, R2, R3, vt);
-
-       if (R3 == R1) {
-               IL_ERR("Calibration conflict R1 == R3\n");
-               return -1;
-       }
-
-       /* Calculate temperature in degrees Kelvin, adjust by 97%.
-        * Add offset to center the adjustment around 0 degrees Centigrade. */
-       temperature = TEMPERATURE_CALIB_A_VAL * (vt - R2);
-       temperature /= (R3 - R1);
-       temperature =
-           (temperature * 97) / 100 + TEMPERATURE_CALIB_KELVIN_OFFSET;
-
-       D_TEMP("Calibrated temperature: %dK, %dC\n", temperature,
-              KELVIN_TO_CELSIUS(temperature));
-
-       return temperature;
-}
-
-/* Adjust Txpower only if temperature variance is greater than threshold. */
-#define IL_TEMPERATURE_THRESHOLD   3
-
-/**
- * il4965_is_temp_calib_needed - determines if new calibration is needed
- *
- * If the temperature changed has changed sufficiently, then a recalibration
- * is needed.
- *
- * Assumes caller will replace il->last_temperature once calibration
- * executed.
- */
-static int
-il4965_is_temp_calib_needed(struct il_priv *il)
-{
-       int temp_diff;
-
-       if (!test_bit(S_STATS, &il->status)) {
-               D_TEMP("Temperature not updated -- no stats.\n");
-               return 0;
-       }
-
-       temp_diff = il->temperature - il->last_temperature;
-
-       /* get absolute value */
-       if (temp_diff < 0) {
-               D_POWER("Getting cooler, delta %d\n", temp_diff);
-               temp_diff = -temp_diff;
-       } else if (temp_diff == 0)
-               D_POWER("Temperature unchanged\n");
-       else
-               D_POWER("Getting warmer, delta %d\n", temp_diff);
-
-       if (temp_diff < IL_TEMPERATURE_THRESHOLD) {
-               D_POWER(" => thermal txpower calib not needed\n");
-               return 0;
-       }
-
-       D_POWER(" => thermal txpower calib needed\n");
-
-       return 1;
-}
-
-void
-il4965_temperature_calib(struct il_priv *il)
-{
-       s32 temp;
-
-       temp = il4965_hw_get_temperature(il);
-       if (IL_TX_POWER_TEMPERATURE_OUT_OF_RANGE(temp))
-               return;
-
-       if (il->temperature != temp) {
-               if (il->temperature)
-                       D_TEMP("Temperature changed " "from %dC to %dC\n",
-                              KELVIN_TO_CELSIUS(il->temperature),
-                              KELVIN_TO_CELSIUS(temp));
-               else
-                       D_TEMP("Temperature " "initialized to %dC\n",
-                              KELVIN_TO_CELSIUS(temp));
-       }
-
-       il->temperature = temp;
-       set_bit(S_TEMPERATURE, &il->status);
-
-       if (!il->disable_tx_power_cal &&
-           unlikely(!test_bit(S_SCANNING, &il->status)) &&
-           il4965_is_temp_calib_needed(il))
-               queue_work(il->workqueue, &il->txpower_work);
-}
-
-static u16
-il4965_get_hcmd_size(u8 cmd_id, u16 len)
-{
-       switch (cmd_id) {
-       case C_RXON:
-               return (u16) sizeof(struct il4965_rxon_cmd);
-       default:
-               return len;
-       }
-}
-
-static u16
-il4965_build_addsta_hcmd(const struct il_addsta_cmd *cmd, u8 * data)
-{
-       struct il4965_addsta_cmd *addsta = (struct il4965_addsta_cmd *)data;
-       addsta->mode = cmd->mode;
-       memcpy(&addsta->sta, &cmd->sta, sizeof(struct sta_id_modify));
-       memcpy(&addsta->key, &cmd->key, sizeof(struct il4965_keyinfo));
-       addsta->station_flags = cmd->station_flags;
-       addsta->station_flags_msk = cmd->station_flags_msk;
-       addsta->tid_disable_tx = cmd->tid_disable_tx;
-       addsta->add_immediate_ba_tid = cmd->add_immediate_ba_tid;
-       addsta->remove_immediate_ba_tid = cmd->remove_immediate_ba_tid;
-       addsta->add_immediate_ba_ssn = cmd->add_immediate_ba_ssn;
-       addsta->sleep_tx_count = cmd->sleep_tx_count;
-       addsta->reserved1 = cpu_to_le16(0);
-       addsta->reserved2 = cpu_to_le16(0);
-
-       return (u16) sizeof(struct il4965_addsta_cmd);
-}
-
-static void
-il4965_post_scan(struct il_priv *il)
-{
-       /*
-        * Since setting the RXON may have been deferred while
-        * performing the scan, fire one off if needed
-        */
-       if (memcmp(&il->staging, &il->active, sizeof(il->staging)))
-               il_commit_rxon(il);
-}
-
-static void
-il4965_post_associate(struct il_priv *il)
-{
-       struct ieee80211_vif *vif = il->vif;
-       int ret = 0;
-
-       if (!vif || !il->is_open)
-               return;
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       il_scan_cancel_timeout(il, 200);
-
-       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-       il_commit_rxon(il);
-
-       ret = il_send_rxon_timing(il);
-       if (ret)
-               IL_WARN("RXON timing - " "Attempting to continue.\n");
-
-       il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
-
-       il_set_rxon_ht(il, &il->current_ht_config);
-
-       if (il->ops->set_rxon_chain)
-               il->ops->set_rxon_chain(il);
-
-       il->staging.assoc_id = cpu_to_le16(vif->bss_conf.aid);
-
-       D_ASSOC("assoc id %d beacon interval %d\n", vif->bss_conf.aid,
-               vif->bss_conf.beacon_int);
-
-       if (vif->bss_conf.use_short_preamble)
-               il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
-       else
-               il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
-
-       if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
-               if (vif->bss_conf.use_short_slot)
-                       il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
-               else
-                       il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
-       }
-
-       il_commit_rxon(il);
-
-       D_ASSOC("Associated as %d to: %pM\n", vif->bss_conf.aid,
-               il->active.bssid_addr);
-
-       switch (vif->type) {
-       case NL80211_IFTYPE_STATION:
-               break;
-       case NL80211_IFTYPE_ADHOC:
-               il4965_send_beacon_cmd(il);
-               break;
-       default:
-               IL_ERR("%s Should not be called in %d mode\n", __func__,
-                      vif->type);
-               break;
-       }
-
-       /* the chain noise calibration will enabled PM upon completion
-        * If chain noise has already been run, then we need to enable
-        * power management here */
-       if (il->chain_noise_data.state == IL_CHAIN_NOISE_DONE)
-               il_power_update_mode(il, false);
-
-       /* Enable Rx differential gain and sensitivity calibrations */
-       il4965_chain_noise_reset(il);
-       il->start_calib = 1;
-}
-
-static void
-il4965_config_ap(struct il_priv *il)
-{
-       struct ieee80211_vif *vif = il->vif;
-       int ret = 0;
-
-       lockdep_assert_held(&il->mutex);
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       /* The following should be done only at AP bring up */
-       if (!il_is_associated(il)) {
-
-               /* RXON - unassoc (to set timing command) */
-               il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-               il_commit_rxon(il);
-
-               /* RXON Timing */
-               ret = il_send_rxon_timing(il);
-               if (ret)
-                       IL_WARN("RXON timing failed - "
-                               "Attempting to continue.\n");
-
-               /* AP has all antennas */
-               il->chain_noise_data.active_chains = il->hw_params.valid_rx_ant;
-               il_set_rxon_ht(il, &il->current_ht_config);
-               if (il->ops->set_rxon_chain)
-                       il->ops->set_rxon_chain(il);
-
-               il->staging.assoc_id = 0;
-
-               if (vif->bss_conf.use_short_preamble)
-                       il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
-               else
-                       il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
-
-               if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
-                       if (vif->bss_conf.use_short_slot)
-                               il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
-                       else
-                               il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
-               }
-               /* need to send beacon cmd before committing assoc RXON! */
-               il4965_send_beacon_cmd(il);
-               /* restore RXON assoc */
-               il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
-               il_commit_rxon(il);
-       }
-       il4965_send_beacon_cmd(il);
-}
-
-const struct il_ops il4965_ops = {
-       .txq_update_byte_cnt_tbl = il4965_txq_update_byte_cnt_tbl,
-       .txq_attach_buf_to_tfd = il4965_hw_txq_attach_buf_to_tfd,
-       .txq_free_tfd = il4965_hw_txq_free_tfd,
-       .txq_init = il4965_hw_tx_queue_init,
-       .is_valid_rtc_data_addr = il4965_hw_valid_rtc_data_addr,
-       .init_alive_start = il4965_init_alive_start,
-       .load_ucode = il4965_load_bsm,
-       .dump_nic_error_log = il4965_dump_nic_error_log,
-       .dump_fh = il4965_dump_fh,
-       .set_channel_switch = il4965_hw_channel_switch,
-       .apm_init = il_apm_init,
-       .send_tx_power = il4965_send_tx_power,
-       .update_chain_flags = il4965_update_chain_flags,
-       .eeprom_acquire_semaphore = il4965_eeprom_acquire_semaphore,
-       .eeprom_release_semaphore = il4965_eeprom_release_semaphore,
-
-       .rxon_assoc = il4965_send_rxon_assoc,
-       .commit_rxon = il4965_commit_rxon,
-       .set_rxon_chain = il4965_set_rxon_chain,
-
-       .get_hcmd_size = il4965_get_hcmd_size,
-       .build_addsta_hcmd = il4965_build_addsta_hcmd,
-       .request_scan = il4965_request_scan,
-       .post_scan = il4965_post_scan,
-
-       .post_associate = il4965_post_associate,
-       .config_ap = il4965_config_ap,
-       .manage_ibss_station = il4965_manage_ibss_station,
-       .update_bcast_stations = il4965_update_bcast_stations,
-
-       .send_led_cmd = il4965_send_led_cmd,
-};
-
-struct il_cfg il4965_cfg = {
-       .name = "Intel(R) Wireless WiFi Link 4965AGN",
-       .fw_name_pre = IL4965_FW_PRE,
-       .ucode_api_max = IL4965_UCODE_API_MAX,
-       .ucode_api_min = IL4965_UCODE_API_MIN,
-       .sku = IL_SKU_A | IL_SKU_G | IL_SKU_N,
-       .valid_tx_ant = ANT_AB,
-       .valid_rx_ant = ANT_ABC,
-       .eeprom_ver = EEPROM_4965_EEPROM_VERSION,
-       .eeprom_calib_ver = EEPROM_4965_TX_POWER_VERSION,
-       .mod_params = &il4965_mod_params,
-       .led_mode = IL_LED_BLINK,
-       /*
-        * Force use of chains B and C for scan RX on 5 GHz band
-        * because the device has off-channel reception on chain A.
-        */
-       .scan_rx_antennas[IEEE80211_BAND_5GHZ] = ANT_BC,
-
-       .eeprom_size = IL4965_EEPROM_IMG_SIZE,
-       .num_of_queues = IL49_NUM_QUEUES,
-       .num_of_ampdu_queues = IL49_NUM_AMPDU_QUEUES,
-       .pll_cfg_val = 0,
-       .set_l0s = true,
-       .use_bsm = true,
-       .led_compensation = 61,
-       .chain_noise_num_beacons = IL4965_CAL_NUM_BEACONS,
-       .wd_timeout = IL_DEF_WD_TIMEOUT,
-       .temperature_kelvin = true,
-       .ucode_tracing = true,
-       .sensitivity_calib_by_driver = true,
-       .chain_noise_calib_by_driver = true,
-
-       .regulatory_bands = {
-               EEPROM_REGULATORY_BAND_1_CHANNELS,
-               EEPROM_REGULATORY_BAND_2_CHANNELS,
-               EEPROM_REGULATORY_BAND_3_CHANNELS,
-               EEPROM_REGULATORY_BAND_4_CHANNELS,
-               EEPROM_REGULATORY_BAND_5_CHANNELS,
-               EEPROM_4965_REGULATORY_BAND_24_HT40_CHANNELS,
-               EEPROM_4965_REGULATORY_BAND_52_HT40_CHANNELS
-       },
-
-};
-
-/* Module firmware */
-MODULE_FIRMWARE(IL4965_MODULE_FIRMWARE(IL4965_UCODE_API_MAX));
diff --git a/drivers/net/wireless/iwlegacy/4965.h b/drivers/net/wireless/iwlegacy/4965.h
deleted file mode 100644 (file)
index 8ab8706..0000000
+++ /dev/null
@@ -1,1285 +0,0 @@
-/******************************************************************************
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#ifndef __il_4965_h__
-#define __il_4965_h__
-
-struct il_rx_queue;
-struct il_rx_buf;
-struct il_rx_pkt;
-struct il_tx_queue;
-struct il_rxon_context;
-
-/* configuration for the _4965 devices */
-extern struct il_cfg il4965_cfg;
-extern const struct il_ops il4965_ops;
-
-extern struct il_mod_params il4965_mod_params;
-
-/* tx queue */
-void il4965_free_tfds_in_queue(struct il_priv *il, int sta_id, int tid,
-                              int freed);
-
-/* RXON */
-void il4965_set_rxon_chain(struct il_priv *il);
-
-/* uCode */
-int il4965_verify_ucode(struct il_priv *il);
-
-/* lib */
-void il4965_check_abort_status(struct il_priv *il, u8 frame_count, u32 status);
-
-void il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq);
-int il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq);
-int il4965_hw_nic_init(struct il_priv *il);
-int il4965_dump_fh(struct il_priv *il, char **buf, bool display);
-
-void il4965_nic_config(struct il_priv *il);
-
-/* rx */
-void il4965_rx_queue_restock(struct il_priv *il);
-void il4965_rx_replenish(struct il_priv *il);
-void il4965_rx_replenish_now(struct il_priv *il);
-void il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq);
-int il4965_rxq_stop(struct il_priv *il);
-int il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band);
-void il4965_rx_handle(struct il_priv *il);
-
-/* tx */
-void il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq);
-int il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
-                                   dma_addr_t addr, u16 len, u8 reset, u8 pad);
-int il4965_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq);
-void il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
-                                struct ieee80211_tx_info *info);
-int il4965_tx_skb(struct il_priv *il,
-                 struct ieee80211_sta *sta,
-                 struct sk_buff *skb);
-int il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
-                       struct ieee80211_sta *sta, u16 tid, u16 * ssn);
-int il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
-                      struct ieee80211_sta *sta, u16 tid);
-int il4965_txq_check_empty(struct il_priv *il, int sta_id, u8 tid, int txq_id);
-int il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx);
-void il4965_hw_txq_ctx_free(struct il_priv *il);
-int il4965_txq_ctx_alloc(struct il_priv *il);
-void il4965_txq_ctx_reset(struct il_priv *il);
-void il4965_txq_ctx_stop(struct il_priv *il);
-void il4965_txq_set_sched(struct il_priv *il, u32 mask);
-
-/*
- * Acquire il->lock before calling this function !
- */
-void il4965_set_wr_ptrs(struct il_priv *il, int txq_id, u32 idx);
-/**
- * il4965_tx_queue_set_status - (optionally) start Tx/Cmd queue
- * @tx_fifo_id: Tx DMA/FIFO channel (range 0-7) that the queue will feed
- * @scd_retry: (1) Indicates queue will be used in aggregation mode
- *
- * NOTE:  Acquire il->lock before calling this function !
- */
-void il4965_tx_queue_set_status(struct il_priv *il, struct il_tx_queue *txq,
-                               int tx_fifo_id, int scd_retry);
-
-/* scan */
-int il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif);
-
-/* station mgmt */
-int il4965_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
-                              bool add);
-
-/* hcmd */
-int il4965_send_beacon_cmd(struct il_priv *il);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-const char *il4965_get_tx_fail_reason(u32 status);
-#else
-static inline const char *
-il4965_get_tx_fail_reason(u32 status)
-{
-       return "";
-}
-#endif
-
-/* station management */
-int il4965_alloc_bcast_station(struct il_priv *il);
-int il4965_add_bssid_station(struct il_priv *il, const u8 *addr, u8 *sta_id_r);
-int il4965_remove_default_wep_key(struct il_priv *il,
-                                 struct ieee80211_key_conf *key);
-int il4965_set_default_wep_key(struct il_priv *il,
-                              struct ieee80211_key_conf *key);
-int il4965_restore_default_wep_keys(struct il_priv *il);
-int il4965_set_dynamic_key(struct il_priv *il,
-                          struct ieee80211_key_conf *key, u8 sta_id);
-int il4965_remove_dynamic_key(struct il_priv *il,
-                             struct ieee80211_key_conf *key, u8 sta_id);
-void il4965_update_tkip_key(struct il_priv *il,
-                           struct ieee80211_key_conf *keyconf,
-                           struct ieee80211_sta *sta, u32 iv32,
-                           u16 *phase1key);
-int il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid);
-int il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta,
-                           int tid, u16 ssn);
-int il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta,
-                          int tid);
-void il4965_sta_modify_sleep_tx_count(struct il_priv *il, int sta_id, int cnt);
-int il4965_update_bcast_stations(struct il_priv *il);
-
-/* rate */
-static inline u8
-il4965_hw_get_rate(__le32 rate_n_flags)
-{
-       return le32_to_cpu(rate_n_flags) & 0xFF;
-}
-
-/* eeprom */
-void il4965_eeprom_get_mac(const struct il_priv *il, u8 * mac);
-int il4965_eeprom_acquire_semaphore(struct il_priv *il);
-void il4965_eeprom_release_semaphore(struct il_priv *il);
-int il4965_eeprom_check_version(struct il_priv *il);
-
-/* mac80211 handlers (for 4965) */
-void il4965_mac_tx(struct ieee80211_hw *hw,
-                  struct ieee80211_tx_control *control,
-                  struct sk_buff *skb);
-int il4965_mac_start(struct ieee80211_hw *hw);
-void il4965_mac_stop(struct ieee80211_hw *hw);
-void il4965_configure_filter(struct ieee80211_hw *hw,
-                            unsigned int changed_flags,
-                            unsigned int *total_flags, u64 multicast);
-int il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
-                      struct ieee80211_vif *vif, struct ieee80211_sta *sta,
-                      struct ieee80211_key_conf *key);
-void il4965_mac_update_tkip_key(struct ieee80211_hw *hw,
-                               struct ieee80211_vif *vif,
-                               struct ieee80211_key_conf *keyconf,
-                               struct ieee80211_sta *sta, u32 iv32,
-                               u16 *phase1key);
-int il4965_mac_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                           enum ieee80211_ampdu_mlme_action action,
-                           struct ieee80211_sta *sta, u16 tid, u16 * ssn,
-                           u8 buf_size, bool amsdu);
-int il4965_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                      struct ieee80211_sta *sta);
-void
-il4965_mac_channel_switch(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                         struct ieee80211_channel_switch *ch_switch);
-
-void il4965_led_enable(struct il_priv *il);
-
-/* EEPROM */
-#define IL4965_EEPROM_IMG_SIZE                 1024
-
-/*
- * uCode queue management definitions ...
- * The first queue used for block-ack aggregation is #7 (4965 only).
- * All block-ack aggregation queues should map to Tx DMA/FIFO channel 7.
- */
-#define IL49_FIRST_AMPDU_QUEUE 7
-
-/* Sizes and addresses for instruction and data memory (SRAM) in
- * 4965's embedded processor.  Driver access is via HBUS_TARG_MEM_* regs. */
-#define IL49_RTC_INST_LOWER_BOUND              (0x000000)
-#define IL49_RTC_INST_UPPER_BOUND              (0x018000)
-
-#define IL49_RTC_DATA_LOWER_BOUND              (0x800000)
-#define IL49_RTC_DATA_UPPER_BOUND              (0x80A000)
-
-#define IL49_RTC_INST_SIZE  (IL49_RTC_INST_UPPER_BOUND - \
-                               IL49_RTC_INST_LOWER_BOUND)
-#define IL49_RTC_DATA_SIZE  (IL49_RTC_DATA_UPPER_BOUND - \
-                               IL49_RTC_DATA_LOWER_BOUND)
-
-#define IL49_MAX_INST_SIZE IL49_RTC_INST_SIZE
-#define IL49_MAX_DATA_SIZE IL49_RTC_DATA_SIZE
-
-/* Size of uCode instruction memory in bootstrap state machine */
-#define IL49_MAX_BSM_SIZE BSM_SRAM_SIZE
-
-static inline int
-il4965_hw_valid_rtc_data_addr(u32 addr)
-{
-       return (addr >= IL49_RTC_DATA_LOWER_BOUND &&
-               addr < IL49_RTC_DATA_UPPER_BOUND);
-}
-
-/********************* START TEMPERATURE *************************************/
-
-/**
- * 4965 temperature calculation.
- *
- * The driver must calculate the device temperature before calculating
- * a txpower setting (amplifier gain is temperature dependent).  The
- * calculation uses 4 measurements, 3 of which (R1, R2, R3) are calibration
- * values used for the life of the driver, and one of which (R4) is the
- * real-time temperature indicator.
- *
- * uCode provides all 4 values to the driver via the "initialize alive"
- * notification (see struct il4965_init_alive_resp).  After the runtime uCode
- * image loads, uCode updates the R4 value via stats notifications
- * (see N_STATS), which occur after each received beacon
- * when associated, or can be requested via C_STATS.
- *
- * NOTE:  uCode provides the R4 value as a 23-bit signed value.  Driver
- *        must sign-extend to 32 bits before applying formula below.
- *
- * Formula:
- *
- * degrees Kelvin = ((97 * 259 * (R4 - R2) / (R3 - R1)) / 100) + 8
- *
- * NOTE:  The basic formula is 259 * (R4-R2) / (R3-R1).  The 97/100 is
- * an additional correction, which should be centered around 0 degrees
- * Celsius (273 degrees Kelvin).  The 8 (3 percent of 273) compensates for
- * centering the 97/100 correction around 0 degrees K.
- *
- * Add 273 to Kelvin value to find degrees Celsius, for comparing current
- * temperature with factory-measured temperatures when calculating txpower
- * settings.
- */
-#define TEMPERATURE_CALIB_KELVIN_OFFSET 8
-#define TEMPERATURE_CALIB_A_VAL 259
-
-/* Limit range of calculated temperature to be between these Kelvin values */
-#define IL_TX_POWER_TEMPERATURE_MIN  (263)
-#define IL_TX_POWER_TEMPERATURE_MAX  (410)
-
-#define IL_TX_POWER_TEMPERATURE_OUT_OF_RANGE(t) \
-       ((t) < IL_TX_POWER_TEMPERATURE_MIN || \
-        (t) > IL_TX_POWER_TEMPERATURE_MAX)
-
-void il4965_temperature_calib(struct il_priv *il);
-/********************* END TEMPERATURE ***************************************/
-
-/********************* START TXPOWER *****************************************/
-
-/**
- * 4965 txpower calculations rely on information from three sources:
- *
- *     1) EEPROM
- *     2) "initialize" alive notification
- *     3) stats notifications
- *
- * EEPROM data consists of:
- *
- * 1)  Regulatory information (max txpower and channel usage flags) is provided
- *     separately for each channel that can possibly supported by 4965.
- *     40 MHz wide (.11n HT40) channels are listed separately from 20 MHz
- *     (legacy) channels.
- *
- *     See struct il4965_eeprom_channel for format, and struct il4965_eeprom
- *     for locations in EEPROM.
- *
- * 2)  Factory txpower calibration information is provided separately for
- *     sub-bands of contiguous channels.  2.4GHz has just one sub-band,
- *     but 5 GHz has several sub-bands.
- *
- *     In addition, per-band (2.4 and 5 Ghz) saturation txpowers are provided.
- *
- *     See struct il4965_eeprom_calib_info (and the tree of structures
- *     contained within it) for format, and struct il4965_eeprom for
- *     locations in EEPROM.
- *
- * "Initialization alive" notification (see struct il4965_init_alive_resp)
- * consists of:
- *
- * 1)  Temperature calculation parameters.
- *
- * 2)  Power supply voltage measurement.
- *
- * 3)  Tx gain compensation to balance 2 transmitters for MIMO use.
- *
- * Statistics notifications deliver:
- *
- * 1)  Current values for temperature param R4.
- */
-
-/**
- * To calculate a txpower setting for a given desired target txpower, channel,
- * modulation bit rate, and transmitter chain (4965 has 2 transmitters to
- * support MIMO and transmit diversity), driver must do the following:
- *
- * 1)  Compare desired txpower vs. (EEPROM) regulatory limit for this channel.
- *     Do not exceed regulatory limit; reduce target txpower if necessary.
- *
- *     If setting up txpowers for MIMO rates (rate idxes 8-15, 24-31),
- *     2 transmitters will be used simultaneously; driver must reduce the
- *     regulatory limit by 3 dB (half-power) for each transmitter, so the
- *     combined total output of the 2 transmitters is within regulatory limits.
- *
- *
- * 2)  Compare target txpower vs. (EEPROM) saturation txpower *reduced by
- *     backoff for this bit rate*.  Do not exceed (saturation - backoff[rate]);
- *     reduce target txpower if necessary.
- *
- *     Backoff values below are in 1/2 dB units (equivalent to steps in
- *     txpower gain tables):
- *
- *     OFDM 6 - 36 MBit:  10 steps (5 dB)
- *     OFDM 48 MBit:      15 steps (7.5 dB)
- *     OFDM 54 MBit:      17 steps (8.5 dB)
- *     OFDM 60 MBit:      20 steps (10 dB)
- *     CCK all rates:     10 steps (5 dB)
- *
- *     Backoff values apply to saturation txpower on a per-transmitter basis;
- *     when using MIMO (2 transmitters), each transmitter uses the same
- *     saturation level provided in EEPROM, and the same backoff values;
- *     no reduction (such as with regulatory txpower limits) is required.
- *
- *     Saturation and Backoff values apply equally to 20 Mhz (legacy) channel
- *     widths and 40 Mhz (.11n HT40) channel widths; there is no separate
- *     factory measurement for ht40 channels.
- *
- *     The result of this step is the final target txpower.  The rest of
- *     the steps figure out the proper settings for the device to achieve
- *     that target txpower.
- *
- *
- * 3)  Determine (EEPROM) calibration sub band for the target channel, by
- *     comparing against first and last channels in each sub band
- *     (see struct il4965_eeprom_calib_subband_info).
- *
- *
- * 4)  Linearly interpolate (EEPROM) factory calibration measurement sets,
- *     referencing the 2 factory-measured (sample) channels within the sub band.
- *
- *     Interpolation is based on difference between target channel's frequency
- *     and the sample channels' frequencies.  Since channel numbers are based
- *     on frequency (5 MHz between each channel number), this is equivalent
- *     to interpolating based on channel number differences.
- *
- *     Note that the sample channels may or may not be the channels at the
- *     edges of the sub band.  The target channel may be "outside" of the
- *     span of the sampled channels.
- *
- *     Driver may choose the pair (for 2 Tx chains) of measurements (see
- *     struct il4965_eeprom_calib_ch_info) for which the actual measured
- *     txpower comes closest to the desired txpower.  Usually, though,
- *     the middle set of measurements is closest to the regulatory limits,
- *     and is therefore a good choice for all txpower calculations (this
- *     assumes that high accuracy is needed for maximizing legal txpower,
- *     while lower txpower configurations do not need as much accuracy).
- *
- *     Driver should interpolate both members of the chosen measurement pair,
- *     i.e. for both Tx chains (radio transmitters), unless the driver knows
- *     that only one of the chains will be used (e.g. only one tx antenna
- *     connected, but this should be unusual).  The rate scaling algorithm
- *     switches antennas to find best performance, so both Tx chains will
- *     be used (although only one at a time) even for non-MIMO transmissions.
- *
- *     Driver should interpolate factory values for temperature, gain table
- *     idx, and actual power.  The power amplifier detector values are
- *     not used by the driver.
- *
- *     Sanity check:  If the target channel happens to be one of the sample
- *     channels, the results should agree with the sample channel's
- *     measurements!
- *
- *
- * 5)  Find difference between desired txpower and (interpolated)
- *     factory-measured txpower.  Using (interpolated) factory gain table idx
- *     (shown elsewhere) as a starting point, adjust this idx lower to
- *     increase txpower, or higher to decrease txpower, until the target
- *     txpower is reached.  Each step in the gain table is 1/2 dB.
- *
- *     For example, if factory measured txpower is 16 dBm, and target txpower
- *     is 13 dBm, add 6 steps to the factory gain idx to reduce txpower
- *     by 3 dB.
- *
- *
- * 6)  Find difference between current device temperature and (interpolated)
- *     factory-measured temperature for sub-band.  Factory values are in
- *     degrees Celsius.  To calculate current temperature, see comments for
- *     "4965 temperature calculation".
- *
- *     If current temperature is higher than factory temperature, driver must
- *     increase gain (lower gain table idx), and vice verse.
- *
- *     Temperature affects gain differently for different channels:
- *
- *     2.4 GHz all channels:  3.5 degrees per half-dB step
- *     5 GHz channels 34-43:  4.5 degrees per half-dB step
- *     5 GHz channels >= 44:  4.0 degrees per half-dB step
- *
- *     NOTE:  Temperature can increase rapidly when transmitting, especially
- *            with heavy traffic at high txpowers.  Driver should update
- *            temperature calculations often under these conditions to
- *            maintain strong txpower in the face of rising temperature.
- *
- *
- * 7)  Find difference between current power supply voltage indicator
- *     (from "initialize alive") and factory-measured power supply voltage
- *     indicator (EEPROM).
- *
- *     If the current voltage is higher (indicator is lower) than factory
- *     voltage, gain should be reduced (gain table idx increased) by:
- *
- *     (eeprom - current) / 7
- *
- *     If the current voltage is lower (indicator is higher) than factory
- *     voltage, gain should be increased (gain table idx decreased) by:
- *
- *     2 * (current - eeprom) / 7
- *
- *     If number of idx steps in either direction turns out to be > 2,
- *     something is wrong ... just use 0.
- *
- *     NOTE:  Voltage compensation is independent of band/channel.
- *
- *     NOTE:  "Initialize" uCode measures current voltage, which is assumed
- *            to be constant after this initial measurement.  Voltage
- *            compensation for txpower (number of steps in gain table)
- *            may be calculated once and used until the next uCode bootload.
- *
- *
- * 8)  If setting up txpowers for MIMO rates (rate idxes 8-15, 24-31),
- *     adjust txpower for each transmitter chain, so txpower is balanced
- *     between the two chains.  There are 5 pairs of tx_atten[group][chain]
- *     values in "initialize alive", one pair for each of 5 channel ranges:
- *
- *     Group 0:  5 GHz channel 34-43
- *     Group 1:  5 GHz channel 44-70
- *     Group 2:  5 GHz channel 71-124
- *     Group 3:  5 GHz channel 125-200
- *     Group 4:  2.4 GHz all channels
- *
- *     Add the tx_atten[group][chain] value to the idx for the target chain.
- *     The values are signed, but are in pairs of 0 and a non-negative number,
- *     so as to reduce gain (if necessary) of the "hotter" channel.  This
- *     avoids any need to double-check for regulatory compliance after
- *     this step.
- *
- *
- * 9)  If setting up for a CCK rate, lower the gain by adding a CCK compensation
- *     value to the idx:
- *
- *     Hardware rev B:  9 steps (4.5 dB)
- *     Hardware rev C:  5 steps (2.5 dB)
- *
- *     Hardware rev for 4965 can be determined by reading CSR_HW_REV_WA_REG,
- *     bits [3:2], 1 = B, 2 = C.
- *
- *     NOTE:  This compensation is in addition to any saturation backoff that
- *            might have been applied in an earlier step.
- *
- *
- * 10) Select the gain table, based on band (2.4 vs 5 GHz).
- *
- *     Limit the adjusted idx to stay within the table!
- *
- *
- * 11) Read gain table entries for DSP and radio gain, place into appropriate
- *     location(s) in command (struct il4965_txpowertable_cmd).
- */
-
-/**
- * When MIMO is used (2 transmitters operating simultaneously), driver should
- * limit each transmitter to deliver a max of 3 dB below the regulatory limit
- * for the device.  That is, use half power for each transmitter, so total
- * txpower is within regulatory limits.
- *
- * The value "6" represents number of steps in gain table to reduce power 3 dB.
- * Each step is 1/2 dB.
- */
-#define IL_TX_POWER_MIMO_REGULATORY_COMPENSATION (6)
-
-/**
- * CCK gain compensation.
- *
- * When calculating txpowers for CCK, after making sure that the target power
- * is within regulatory and saturation limits, driver must additionally
- * back off gain by adding these values to the gain table idx.
- *
- * Hardware rev for 4965 can be determined by reading CSR_HW_REV_WA_REG,
- * bits [3:2], 1 = B, 2 = C.
- */
-#define IL_TX_POWER_CCK_COMPENSATION_B_STEP (9)
-#define IL_TX_POWER_CCK_COMPENSATION_C_STEP (5)
-
-/*
- * 4965 power supply voltage compensation for txpower
- */
-#define TX_POWER_IL_VOLTAGE_CODES_PER_03V   (7)
-
-/**
- * Gain tables.
- *
- * The following tables contain pair of values for setting txpower, i.e.
- * gain settings for the output of the device's digital signal processor (DSP),
- * and for the analog gain structure of the transmitter.
- *
- * Each entry in the gain tables represents a step of 1/2 dB.  Note that these
- * are *relative* steps, not indications of absolute output power.  Output
- * power varies with temperature, voltage, and channel frequency, and also
- * requires consideration of average power (to satisfy regulatory constraints),
- * and peak power (to avoid distortion of the output signal).
- *
- * Each entry contains two values:
- * 1)  DSP gain (or sometimes called DSP attenuation).  This is a fine-grained
- *     linear value that multiplies the output of the digital signal processor,
- *     before being sent to the analog radio.
- * 2)  Radio gain.  This sets the analog gain of the radio Tx path.
- *     It is a coarser setting, and behaves in a logarithmic (dB) fashion.
- *
- * EEPROM contains factory calibration data for txpower.  This maps actual
- * measured txpower levels to gain settings in the "well known" tables
- * below ("well-known" means here that both factory calibration *and* the
- * driver work with the same table).
- *
- * There are separate tables for 2.4 GHz and 5 GHz bands.  The 5 GHz table
- * has an extension (into negative idxes), in case the driver needs to
- * boost power setting for high device temperatures (higher than would be
- * present during factory calibration).  A 5 Ghz EEPROM idx of "40"
- * corresponds to the 49th entry in the table used by the driver.
- */
-#define MIN_TX_GAIN_IDX                (0)     /* highest gain, lowest idx, 2.4 */
-#define MIN_TX_GAIN_IDX_52GHZ_EXT      (-9)    /* highest gain, lowest idx, 5 */
-
-/**
- * 2.4 GHz gain table
- *
- * Index    Dsp gain   Radio gain
- *   0        110         0x3f      (highest gain)
- *   1        104         0x3f
- *   2         98         0x3f
- *   3        110         0x3e
- *   4        104         0x3e
- *   5         98         0x3e
- *   6        110         0x3d
- *   7        104         0x3d
- *   8         98         0x3d
- *   9        110         0x3c
- *  10        104         0x3c
- *  11         98         0x3c
- *  12        110         0x3b
- *  13        104         0x3b
- *  14         98         0x3b
- *  15        110         0x3a
- *  16        104         0x3a
- *  17         98         0x3a
- *  18        110         0x39
- *  19        104         0x39
- *  20         98         0x39
- *  21        110         0x38
- *  22        104         0x38
- *  23         98         0x38
- *  24        110         0x37
- *  25        104         0x37
- *  26         98         0x37
- *  27        110         0x36
- *  28        104         0x36
- *  29         98         0x36
- *  30        110         0x35
- *  31        104         0x35
- *  32         98         0x35
- *  33        110         0x34
- *  34        104         0x34
- *  35         98         0x34
- *  36        110         0x33
- *  37        104         0x33
- *  38         98         0x33
- *  39        110         0x32
- *  40        104         0x32
- *  41         98         0x32
- *  42        110         0x31
- *  43        104         0x31
- *  44         98         0x31
- *  45        110         0x30
- *  46        104         0x30
- *  47         98         0x30
- *  48        110          0x6
- *  49        104          0x6
- *  50         98          0x6
- *  51        110          0x5
- *  52        104          0x5
- *  53         98          0x5
- *  54        110          0x4
- *  55        104          0x4
- *  56         98          0x4
- *  57        110          0x3
- *  58        104          0x3
- *  59         98          0x3
- *  60        110          0x2
- *  61        104          0x2
- *  62         98          0x2
- *  63        110          0x1
- *  64        104          0x1
- *  65         98          0x1
- *  66        110          0x0
- *  67        104          0x0
- *  68         98          0x0
- *  69         97            0
- *  70         96            0
- *  71         95            0
- *  72         94            0
- *  73         93            0
- *  74         92            0
- *  75         91            0
- *  76         90            0
- *  77         89            0
- *  78         88            0
- *  79         87            0
- *  80         86            0
- *  81         85            0
- *  82         84            0
- *  83         83            0
- *  84         82            0
- *  85         81            0
- *  86         80            0
- *  87         79            0
- *  88         78            0
- *  89         77            0
- *  90         76            0
- *  91         75            0
- *  92         74            0
- *  93         73            0
- *  94         72            0
- *  95         71            0
- *  96         70            0
- *  97         69            0
- *  98         68            0
- */
-
-/**
- * 5 GHz gain table
- *
- * Index    Dsp gain   Radio gain
- *  -9               123         0x3F      (highest gain)
- *  -8               117         0x3F
- *  -7        110         0x3F
- *  -6        104         0x3F
- *  -5         98         0x3F
- *  -4        110         0x3E
- *  -3        104         0x3E
- *  -2         98         0x3E
- *  -1        110         0x3D
- *   0        104         0x3D
- *   1         98         0x3D
- *   2        110         0x3C
- *   3        104         0x3C
- *   4         98         0x3C
- *   5        110         0x3B
- *   6        104         0x3B
- *   7         98         0x3B
- *   8        110         0x3A
- *   9        104         0x3A
- *  10         98         0x3A
- *  11        110         0x39
- *  12        104         0x39
- *  13         98         0x39
- *  14        110         0x38
- *  15        104         0x38
- *  16         98         0x38
- *  17        110         0x37
- *  18        104         0x37
- *  19         98         0x37
- *  20        110         0x36
- *  21        104         0x36
- *  22         98         0x36
- *  23        110         0x35
- *  24        104         0x35
- *  25         98         0x35
- *  26        110         0x34
- *  27        104         0x34
- *  28         98         0x34
- *  29        110         0x33
- *  30        104         0x33
- *  31         98         0x33
- *  32        110         0x32
- *  33        104         0x32
- *  34         98         0x32
- *  35        110         0x31
- *  36        104         0x31
- *  37         98         0x31
- *  38        110         0x30
- *  39        104         0x30
- *  40         98         0x30
- *  41        110         0x25
- *  42        104         0x25
- *  43         98         0x25
- *  44        110         0x24
- *  45        104         0x24
- *  46         98         0x24
- *  47        110         0x23
- *  48        104         0x23
- *  49         98         0x23
- *  50        110         0x22
- *  51        104         0x18
- *  52         98         0x18
- *  53        110         0x17
- *  54        104         0x17
- *  55         98         0x17
- *  56        110         0x16
- *  57        104         0x16
- *  58         98         0x16
- *  59        110         0x15
- *  60        104         0x15
- *  61         98         0x15
- *  62        110         0x14
- *  63        104         0x14
- *  64         98         0x14
- *  65        110         0x13
- *  66        104         0x13
- *  67         98         0x13
- *  68        110         0x12
- *  69        104         0x08
- *  70         98         0x08
- *  71        110         0x07
- *  72        104         0x07
- *  73         98         0x07
- *  74        110         0x06
- *  75        104         0x06
- *  76         98         0x06
- *  77        110         0x05
- *  78        104         0x05
- *  79         98         0x05
- *  80        110         0x04
- *  81        104         0x04
- *  82         98         0x04
- *  83        110         0x03
- *  84        104         0x03
- *  85         98         0x03
- *  86        110         0x02
- *  87        104         0x02
- *  88         98         0x02
- *  89        110         0x01
- *  90        104         0x01
- *  91         98         0x01
- *  92        110         0x00
- *  93        104         0x00
- *  94         98         0x00
- *  95         93         0x00
- *  96         88         0x00
- *  97         83         0x00
- *  98         78         0x00
- */
-
-/**
- * Sanity checks and default values for EEPROM regulatory levels.
- * If EEPROM values fall outside MIN/MAX range, use default values.
- *
- * Regulatory limits refer to the maximum average txpower allowed by
- * regulatory agencies in the geographies in which the device is meant
- * to be operated.  These limits are SKU-specific (i.e. geography-specific),
- * and channel-specific; each channel has an individual regulatory limit
- * listed in the EEPROM.
- *
- * Units are in half-dBm (i.e. "34" means 17 dBm).
- */
-#define IL_TX_POWER_DEFAULT_REGULATORY_24   (34)
-#define IL_TX_POWER_DEFAULT_REGULATORY_52   (34)
-#define IL_TX_POWER_REGULATORY_MIN          (0)
-#define IL_TX_POWER_REGULATORY_MAX          (34)
-
-/**
- * Sanity checks and default values for EEPROM saturation levels.
- * If EEPROM values fall outside MIN/MAX range, use default values.
- *
- * Saturation is the highest level that the output power amplifier can produce
- * without significant clipping distortion.  This is a "peak" power level.
- * Different types of modulation (i.e. various "rates", and OFDM vs. CCK)
- * require differing amounts of backoff, relative to their average power output,
- * in order to avoid clipping distortion.
- *
- * Driver must make sure that it is violating neither the saturation limit,
- * nor the regulatory limit, when calculating Tx power settings for various
- * rates.
- *
- * Units are in half-dBm (i.e. "38" means 19 dBm).
- */
-#define IL_TX_POWER_DEFAULT_SATURATION_24   (38)
-#define IL_TX_POWER_DEFAULT_SATURATION_52   (38)
-#define IL_TX_POWER_SATURATION_MIN          (20)
-#define IL_TX_POWER_SATURATION_MAX          (50)
-
-/**
- * Channel groups used for Tx Attenuation calibration (MIMO tx channel balance)
- * and thermal Txpower calibration.
- *
- * When calculating txpower, driver must compensate for current device
- * temperature; higher temperature requires higher gain.  Driver must calculate
- * current temperature (see "4965 temperature calculation"), then compare vs.
- * factory calibration temperature in EEPROM; if current temperature is higher
- * than factory temperature, driver must *increase* gain by proportions shown
- * in table below.  If current temperature is lower than factory, driver must
- * *decrease* gain.
- *
- * Different frequency ranges require different compensation, as shown below.
- */
-/* Group 0, 5.2 GHz ch 34-43:  4.5 degrees per 1/2 dB. */
-#define CALIB_IL_TX_ATTEN_GR1_FCH 34
-#define CALIB_IL_TX_ATTEN_GR1_LCH 43
-
-/* Group 1, 5.3 GHz ch 44-70:  4.0 degrees per 1/2 dB. */
-#define CALIB_IL_TX_ATTEN_GR2_FCH 44
-#define CALIB_IL_TX_ATTEN_GR2_LCH 70
-
-/* Group 2, 5.5 GHz ch 71-124:  4.0 degrees per 1/2 dB. */
-#define CALIB_IL_TX_ATTEN_GR3_FCH 71
-#define CALIB_IL_TX_ATTEN_GR3_LCH 124
-
-/* Group 3, 5.7 GHz ch 125-200:  4.0 degrees per 1/2 dB. */
-#define CALIB_IL_TX_ATTEN_GR4_FCH 125
-#define CALIB_IL_TX_ATTEN_GR4_LCH 200
-
-/* Group 4, 2.4 GHz all channels:  3.5 degrees per 1/2 dB. */
-#define CALIB_IL_TX_ATTEN_GR5_FCH 1
-#define CALIB_IL_TX_ATTEN_GR5_LCH 20
-
-enum {
-       CALIB_CH_GROUP_1 = 0,
-       CALIB_CH_GROUP_2 = 1,
-       CALIB_CH_GROUP_3 = 2,
-       CALIB_CH_GROUP_4 = 3,
-       CALIB_CH_GROUP_5 = 4,
-       CALIB_CH_GROUP_MAX
-};
-
-/********************* END TXPOWER *****************************************/
-
-/**
- * Tx/Rx Queues
- *
- * Most communication between driver and 4965 is via queues of data buffers.
- * For example, all commands that the driver issues to device's embedded
- * controller (uCode) are via the command queue (one of the Tx queues).  All
- * uCode command responses/replies/notifications, including Rx frames, are
- * conveyed from uCode to driver via the Rx queue.
- *
- * Most support for these queues, including handshake support, resides in
- * structures in host DRAM, shared between the driver and the device.  When
- * allocating this memory, the driver must make sure that data written by
- * the host CPU updates DRAM immediately (and does not get "stuck" in CPU's
- * cache memory), so DRAM and cache are consistent, and the device can
- * immediately see changes made by the driver.
- *
- * 4965 supports up to 16 DRAM-based Tx queues, and services these queues via
- * up to 7 DMA channels (FIFOs).  Each Tx queue is supported by a circular array
- * in DRAM containing 256 Transmit Frame Descriptors (TFDs).
- */
-#define IL49_NUM_FIFOS 7
-#define IL49_CMD_FIFO_NUM      4
-#define IL49_NUM_QUEUES        16
-#define IL49_NUM_AMPDU_QUEUES  8
-
-/**
- * struct il4965_schedq_bc_tbl
- *
- * Byte Count table
- *
- * Each Tx queue uses a byte-count table containing 320 entries:
- * one 16-bit entry for each of 256 TFDs, plus an additional 64 entries that
- * duplicate the first 64 entries (to avoid wrap-around within a Tx win;
- * max Tx win is 64 TFDs).
- *
- * When driver sets up a new TFD, it must also enter the total byte count
- * of the frame to be transmitted into the corresponding entry in the byte
- * count table for the chosen Tx queue.  If the TFD idx is 0-63, the driver
- * must duplicate the byte count entry in corresponding idx 256-319.
- *
- * padding puts each byte count table on a 1024-byte boundary;
- * 4965 assumes tables are separated by 1024 bytes.
- */
-struct il4965_scd_bc_tbl {
-       __le16 tfd_offset[TFD_QUEUE_BC_SIZE];
-       u8 pad[1024 - (TFD_QUEUE_BC_SIZE) * sizeof(__le16)];
-} __packed;
-
-#define IL4965_RTC_INST_LOWER_BOUND            (0x000000)
-
-/* RSSI to dBm */
-#define IL4965_RSSI_OFFSET     44
-
-/* PCI registers */
-#define PCI_CFG_RETRY_TIMEOUT  0x041
-
-#define IL4965_DEFAULT_TX_RETRY  15
-
-/* EEPROM */
-#define IL4965_FIRST_AMPDU_QUEUE       10
-
-/* Calibration */
-void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp);
-void il4965_sensitivity_calibration(struct il_priv *il, void *resp);
-void il4965_init_sensitivity(struct il_priv *il);
-void il4965_reset_run_time_calib(struct il_priv *il);
-
-/* Debug */
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-extern const struct il_debugfs_ops il4965_debugfs_ops;
-#endif
-
-/****************************/
-/* Flow Handler Definitions */
-/****************************/
-
-/**
- * This I/O area is directly read/writable by driver (e.g. Linux uses writel())
- * Addresses are offsets from device's PCI hardware base address.
- */
-#define FH49_MEM_LOWER_BOUND                   (0x1000)
-#define FH49_MEM_UPPER_BOUND                   (0x2000)
-
-/**
- * Keep-Warm (KW) buffer base address.
- *
- * Driver must allocate a 4KByte buffer that is used by 4965 for keeping the
- * host DRAM powered on (via dummy accesses to DRAM) to maintain low-latency
- * DRAM access when 4965 is Txing or Rxing.  The dummy accesses prevent host
- * from going into a power-savings mode that would cause higher DRAM latency,
- * and possible data over/under-runs, before all Tx/Rx is complete.
- *
- * Driver loads FH49_KW_MEM_ADDR_REG with the physical address (bits 35:4)
- * of the buffer, which must be 4K aligned.  Once this is set up, the 4965
- * automatically invokes keep-warm accesses when normal accesses might not
- * be sufficient to maintain fast DRAM response.
- *
- * Bit fields:
- *  31-0:  Keep-warm buffer physical base address [35:4], must be 4K aligned
- */
-#define FH49_KW_MEM_ADDR_REG                (FH49_MEM_LOWER_BOUND + 0x97C)
-
-/**
- * TFD Circular Buffers Base (CBBC) addresses
- *
- * 4965 has 16 base pointer registers, one for each of 16 host-DRAM-resident
- * circular buffers (CBs/queues) containing Transmit Frame Descriptors (TFDs)
- * (see struct il_tfd_frame).  These 16 pointer registers are offset by 0x04
- * bytes from one another.  Each TFD circular buffer in DRAM must be 256-byte
- * aligned (address bits 0-7 must be 0).
- *
- * Bit fields in each pointer register:
- *  27-0: TFD CB physical base address [35:8], must be 256-byte aligned
- */
-#define FH49_MEM_CBBC_LOWER_BOUND          (FH49_MEM_LOWER_BOUND + 0x9D0)
-#define FH49_MEM_CBBC_UPPER_BOUND          (FH49_MEM_LOWER_BOUND + 0xA10)
-
-/* Find TFD CB base pointer for given queue (range 0-15). */
-#define FH49_MEM_CBBC_QUEUE(x)  (FH49_MEM_CBBC_LOWER_BOUND + (x) * 0x4)
-
-/**
- * Rx SRAM Control and Status Registers (RSCSR)
- *
- * These registers provide handshake between driver and 4965 for the Rx queue
- * (this queue handles *all* command responses, notifications, Rx data, etc.
- * sent from 4965 uCode to host driver).  Unlike Tx, there is only one Rx
- * queue, and only one Rx DMA/FIFO channel.  Also unlike Tx, which can
- * concatenate up to 20 DRAM buffers to form a Tx frame, each Receive Buffer
- * Descriptor (RBD) points to only one Rx Buffer (RB); there is a 1:1
- * mapping between RBDs and RBs.
- *
- * Driver must allocate host DRAM memory for the following, and set the
- * physical address of each into 4965 registers:
- *
- * 1)  Receive Buffer Descriptor (RBD) circular buffer (CB), typically with 256
- *     entries (although any power of 2, up to 4096, is selectable by driver).
- *     Each entry (1 dword) points to a receive buffer (RB) of consistent size
- *     (typically 4K, although 8K or 16K are also selectable by driver).
- *     Driver sets up RB size and number of RBDs in the CB via Rx config
- *     register FH49_MEM_RCSR_CHNL0_CONFIG_REG.
- *
- *     Bit fields within one RBD:
- *     27-0:  Receive Buffer physical address bits [35:8], 256-byte aligned
- *
- *     Driver sets physical address [35:8] of base of RBD circular buffer
- *     into FH49_RSCSR_CHNL0_RBDCB_BASE_REG [27:0].
- *
- * 2)  Rx status buffer, 8 bytes, in which 4965 indicates which Rx Buffers
- *     (RBs) have been filled, via a "write pointer", actually the idx of
- *     the RB's corresponding RBD within the circular buffer.  Driver sets
- *     physical address [35:4] into FH49_RSCSR_CHNL0_STTS_WPTR_REG [31:0].
- *
- *     Bit fields in lower dword of Rx status buffer (upper dword not used
- *     by driver; see struct il4965_shared, val0):
- *     31-12:  Not used by driver
- *     11- 0:  Index of last filled Rx buffer descriptor
- *             (4965 writes, driver reads this value)
- *
- * As the driver prepares Receive Buffers (RBs) for 4965 to fill, driver must
- * enter pointers to these RBs into contiguous RBD circular buffer entries,
- * and update the 4965's "write" idx register,
- * FH49_RSCSR_CHNL0_RBDCB_WPTR_REG.
- *
- * This "write" idx corresponds to the *next* RBD that the driver will make
- * available, i.e. one RBD past the tail of the ready-to-fill RBDs within
- * the circular buffer.  This value should initially be 0 (before preparing any
- * RBs), should be 8 after preparing the first 8 RBs (for example), and must
- * wrap back to 0 at the end of the circular buffer (but don't wrap before
- * "read" idx has advanced past 1!  See below).
- * NOTE:  4965 EXPECTS THE WRITE IDX TO BE INCREMENTED IN MULTIPLES OF 8.
- *
- * As the 4965 fills RBs (referenced from contiguous RBDs within the circular
- * buffer), it updates the Rx status buffer in host DRAM, 2) described above,
- * to tell the driver the idx of the latest filled RBD.  The driver must
- * read this "read" idx from DRAM after receiving an Rx interrupt from 4965.
- *
- * The driver must also internally keep track of a third idx, which is the
- * next RBD to process.  When receiving an Rx interrupt, driver should process
- * all filled but unprocessed RBs up to, but not including, the RB
- * corresponding to the "read" idx.  For example, if "read" idx becomes "1",
- * driver may process the RB pointed to by RBD 0.  Depending on volume of
- * traffic, there may be many RBs to process.
- *
- * If read idx == write idx, 4965 thinks there is no room to put new data.
- * Due to this, the maximum number of filled RBs is 255, instead of 256.  To
- * be safe, make sure that there is a gap of at least 2 RBDs between "write"
- * and "read" idxes; that is, make sure that there are no more than 254
- * buffers waiting to be filled.
- */
-#define FH49_MEM_RSCSR_LOWER_BOUND     (FH49_MEM_LOWER_BOUND + 0xBC0)
-#define FH49_MEM_RSCSR_UPPER_BOUND     (FH49_MEM_LOWER_BOUND + 0xC00)
-#define FH49_MEM_RSCSR_CHNL0           (FH49_MEM_RSCSR_LOWER_BOUND)
-
-/**
- * Physical base address of 8-byte Rx Status buffer.
- * Bit fields:
- *  31-0: Rx status buffer physical base address [35:4], must 16-byte aligned.
- */
-#define FH49_RSCSR_CHNL0_STTS_WPTR_REG (FH49_MEM_RSCSR_CHNL0)
-
-/**
- * Physical base address of Rx Buffer Descriptor Circular Buffer.
- * Bit fields:
- *  27-0:  RBD CD physical base address [35:8], must be 256-byte aligned.
- */
-#define FH49_RSCSR_CHNL0_RBDCB_BASE_REG        (FH49_MEM_RSCSR_CHNL0 + 0x004)
-
-/**
- * Rx write pointer (idx, really!).
- * Bit fields:
- *  11-0:  Index of driver's most recent prepared-to-be-filled RBD, + 1.
- *         NOTE:  For 256-entry circular buffer, use only bits [7:0].
- */
-#define FH49_RSCSR_CHNL0_RBDCB_WPTR_REG        (FH49_MEM_RSCSR_CHNL0 + 0x008)
-#define FH49_RSCSR_CHNL0_WPTR        (FH49_RSCSR_CHNL0_RBDCB_WPTR_REG)
-
-/**
- * Rx Config/Status Registers (RCSR)
- * Rx Config Reg for channel 0 (only channel used)
- *
- * Driver must initialize FH49_MEM_RCSR_CHNL0_CONFIG_REG as follows for
- * normal operation (see bit fields).
- *
- * Clearing FH49_MEM_RCSR_CHNL0_CONFIG_REG to 0 turns off Rx DMA.
- * Driver should poll FH49_MEM_RSSR_RX_STATUS_REG      for
- * FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE (bit 24) before continuing.
- *
- * Bit fields:
- * 31-30: Rx DMA channel enable: '00' off/pause, '01' pause at end of frame,
- *        '10' operate normally
- * 29-24: reserved
- * 23-20: # RBDs in circular buffer = 2^value; use "8" for 256 RBDs (normal),
- *        min "5" for 32 RBDs, max "12" for 4096 RBDs.
- * 19-18: reserved
- * 17-16: size of each receive buffer; '00' 4K (normal), '01' 8K,
- *        '10' 12K, '11' 16K.
- * 15-14: reserved
- * 13-12: IRQ destination; '00' none, '01' host driver (normal operation)
- * 11- 4: timeout for closing Rx buffer and interrupting host (units 32 usec)
- *        typical value 0x10 (about 1/2 msec)
- *  3- 0: reserved
- */
-#define FH49_MEM_RCSR_LOWER_BOUND      (FH49_MEM_LOWER_BOUND + 0xC00)
-#define FH49_MEM_RCSR_UPPER_BOUND      (FH49_MEM_LOWER_BOUND + 0xCC0)
-#define FH49_MEM_RCSR_CHNL0            (FH49_MEM_RCSR_LOWER_BOUND)
-
-#define FH49_MEM_RCSR_CHNL0_CONFIG_REG (FH49_MEM_RCSR_CHNL0)
-
-#define FH49_RCSR_CHNL0_RX_CONFIG_RB_TIMEOUT_MSK (0x00000FF0)  /* bits 4-11 */
-#define FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_MSK   (0x00001000)  /* bits 12 */
-#define FH49_RCSR_CHNL0_RX_CONFIG_SINGLE_FRAME_MSK (0x00008000)        /* bit 15 */
-#define FH49_RCSR_CHNL0_RX_CONFIG_RB_SIZE_MSK   (0x00030000)   /* bits 16-17 */
-#define FH49_RCSR_CHNL0_RX_CONFIG_RBDBC_SIZE_MSK (0x00F00000)  /* bits 20-23 */
-#define FH49_RCSR_CHNL0_RX_CONFIG_DMA_CHNL_EN_MSK (0xC0000000) /* bits 30-31 */
-
-#define FH49_RCSR_RX_CONFIG_RBDCB_SIZE_POS     (20)
-#define FH49_RCSR_RX_CONFIG_REG_IRQ_RBTH_POS   (4)
-#define RX_RB_TIMEOUT  (0x10)
-
-#define FH49_RCSR_RX_CONFIG_CHNL_EN_PAUSE_VAL         (0x00000000)
-#define FH49_RCSR_RX_CONFIG_CHNL_EN_PAUSE_EOF_VAL     (0x40000000)
-#define FH49_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL        (0x80000000)
-
-#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_4K    (0x00000000)
-#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_8K    (0x00010000)
-#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_12K   (0x00020000)
-#define FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_16K   (0x00030000)
-
-#define FH49_RCSR_CHNL0_RX_IGNORE_RXF_EMPTY              (0x00000004)
-#define FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_NO_INT_VAL    (0x00000000)
-#define FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL  (0x00001000)
-
-/**
- * Rx Shared Status Registers (RSSR)
- *
- * After stopping Rx DMA channel (writing 0 to
- * FH49_MEM_RCSR_CHNL0_CONFIG_REG), driver must poll
- * FH49_MEM_RSSR_RX_STATUS_REG until Rx channel is idle.
- *
- * Bit fields:
- *  24:  1 = Channel 0 is idle
- *
- * FH49_MEM_RSSR_SHARED_CTRL_REG and FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV
- * contain default values that should not be altered by the driver.
- */
-#define FH49_MEM_RSSR_LOWER_BOUND           (FH49_MEM_LOWER_BOUND + 0xC40)
-#define FH49_MEM_RSSR_UPPER_BOUND           (FH49_MEM_LOWER_BOUND + 0xD00)
-
-#define FH49_MEM_RSSR_SHARED_CTRL_REG       (FH49_MEM_RSSR_LOWER_BOUND)
-#define FH49_MEM_RSSR_RX_STATUS_REG    (FH49_MEM_RSSR_LOWER_BOUND + 0x004)
-#define FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV\
-                                       (FH49_MEM_RSSR_LOWER_BOUND + 0x008)
-
-#define FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE    (0x01000000)
-
-#define FH49_MEM_TFDIB_REG1_ADDR_BITSHIFT      28
-
-/* TFDB  Area - TFDs buffer table */
-#define FH49_MEM_TFDIB_DRAM_ADDR_LSB_MSK      (0xFFFFFFFF)
-#define FH49_TFDIB_LOWER_BOUND       (FH49_MEM_LOWER_BOUND + 0x900)
-#define FH49_TFDIB_UPPER_BOUND       (FH49_MEM_LOWER_BOUND + 0x958)
-#define FH49_TFDIB_CTRL0_REG(_chnl)  (FH49_TFDIB_LOWER_BOUND + 0x8 * (_chnl))
-#define FH49_TFDIB_CTRL1_REG(_chnl)  (FH49_TFDIB_LOWER_BOUND + 0x8 * (_chnl) + 0x4)
-
-/**
- * Transmit DMA Channel Control/Status Registers (TCSR)
- *
- * 4965 has one configuration register for each of 8 Tx DMA/FIFO channels
- * supported in hardware (don't confuse these with the 16 Tx queues in DRAM,
- * which feed the DMA/FIFO channels); config regs are separated by 0x20 bytes.
- *
- * To use a Tx DMA channel, driver must initialize its
- * FH49_TCSR_CHNL_TX_CONFIG_REG(chnl) with:
- *
- * FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |
- * FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL
- *
- * All other bits should be 0.
- *
- * Bit fields:
- * 31-30: Tx DMA channel enable: '00' off/pause, '01' pause at end of frame,
- *        '10' operate normally
- * 29- 4: Reserved, set to "0"
- *     3: Enable internal DMA requests (1, normal operation), disable (0)
- *  2- 0: Reserved, set to "0"
- */
-#define FH49_TCSR_LOWER_BOUND  (FH49_MEM_LOWER_BOUND + 0xD00)
-#define FH49_TCSR_UPPER_BOUND  (FH49_MEM_LOWER_BOUND + 0xE60)
-
-/* Find Control/Status reg for given Tx DMA/FIFO channel */
-#define FH49_TCSR_CHNL_NUM                            (7)
-#define FH50_TCSR_CHNL_NUM                            (8)
-
-/* TCSR: tx_config register values */
-#define FH49_TCSR_CHNL_TX_CONFIG_REG(_chnl)    \
-               (FH49_TCSR_LOWER_BOUND + 0x20 * (_chnl))
-#define FH49_TCSR_CHNL_TX_CREDIT_REG(_chnl)    \
-               (FH49_TCSR_LOWER_BOUND + 0x20 * (_chnl) + 0x4)
-#define FH49_TCSR_CHNL_TX_BUF_STS_REG(_chnl)   \
-               (FH49_TCSR_LOWER_BOUND + 0x20 * (_chnl) + 0x8)
-
-#define FH49_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_TXF               (0x00000000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_DRV               (0x00000001)
-
-#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_DISABLE (0x00000000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE  (0x00000008)
-
-#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_NOINT    (0x00000000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_ENDTFD   (0x00100000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_IFTFD    (0x00200000)
-
-#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_NOINT     (0x00000000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_ENDTFD    (0x00400000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_IFTFD     (0x00800000)
-
-#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_PAUSE     (0x00000000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_PAUSE_EOF (0x40000000)
-#define FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE    (0x80000000)
-
-#define FH49_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_EMPTY   (0x00000000)
-#define FH49_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_WAIT    (0x00002000)
-#define FH49_TCSR_CHNL_TX_BUF_STS_REG_VAL_TFDB_VALID   (0x00000003)
-
-#define FH49_TCSR_CHNL_TX_BUF_STS_REG_POS_TB_NUM               (20)
-#define FH49_TCSR_CHNL_TX_BUF_STS_REG_POS_TB_IDX               (12)
-
-/**
- * Tx Shared Status Registers (TSSR)
- *
- * After stopping Tx DMA channel (writing 0 to
- * FH49_TCSR_CHNL_TX_CONFIG_REG(chnl)), driver must poll
- * FH49_TSSR_TX_STATUS_REG until selected Tx channel is idle
- * (channel's buffers empty | no pending requests).
- *
- * Bit fields:
- * 31-24:  1 = Channel buffers empty (channel 7:0)
- * 23-16:  1 = No pending requests (channel 7:0)
- */
-#define FH49_TSSR_LOWER_BOUND          (FH49_MEM_LOWER_BOUND + 0xEA0)
-#define FH49_TSSR_UPPER_BOUND          (FH49_MEM_LOWER_BOUND + 0xEC0)
-
-#define FH49_TSSR_TX_STATUS_REG                (FH49_TSSR_LOWER_BOUND + 0x010)
-
-/**
- * Bit fields for TSSR(Tx Shared Status & Control) error status register:
- * 31:  Indicates an address error when accessed to internal memory
- *     uCode/driver must write "1" in order to clear this flag
- * 30:  Indicates that Host did not send the expected number of dwords to FH
- *     uCode/driver must write "1" in order to clear this flag
- * 16-9:Each status bit is for one channel. Indicates that an (Error) ActDMA
- *     command was received from the scheduler while the TRB was already full
- *     with previous command
- *     uCode/driver must write "1" in order to clear this flag
- * 7-0: Each status bit indicates a channel's TxCredit error. When an error
- *     bit is set, it indicates that the FH has received a full indication
- *     from the RTC TxFIFO and the current value of the TxCredit counter was
- *     not equal to zero. This mean that the credit mechanism was not
- *     synchronized to the TxFIFO status
- *     uCode/driver must write "1" in order to clear this flag
- */
-#define FH49_TSSR_TX_ERROR_REG         (FH49_TSSR_LOWER_BOUND + 0x018)
-
-#define FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(_chnl) ((1 << (_chnl)) << 16)
-
-/* Tx service channels */
-#define FH49_SRVC_CHNL         (9)
-#define FH49_SRVC_LOWER_BOUND  (FH49_MEM_LOWER_BOUND + 0x9C8)
-#define FH49_SRVC_UPPER_BOUND  (FH49_MEM_LOWER_BOUND + 0x9D0)
-#define FH49_SRVC_CHNL_SRAM_ADDR_REG(_chnl) \
-               (FH49_SRVC_LOWER_BOUND + ((_chnl) - 9) * 0x4)
-
-#define FH49_TX_CHICKEN_BITS_REG       (FH49_MEM_LOWER_BOUND + 0xE98)
-/* Instruct FH to increment the retry count of a packet when
- * it is brought from the memory to TX-FIFO
- */
-#define FH49_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN (0x00000002)
-
-/* Keep Warm Size */
-#define IL_KW_SIZE 0x1000      /* 4k */
-
-#endif /* __il_4965_h__ */
diff --git a/drivers/net/wireless/iwlegacy/Kconfig b/drivers/net/wireless/iwlegacy/Kconfig
deleted file mode 100644 (file)
index fb91972..0000000
+++ /dev/null
@@ -1,100 +0,0 @@
-config IWLEGACY
-       tristate
-       select FW_LOADER
-       select NEW_LEDS
-       select LEDS_CLASS
-       select LEDS_TRIGGERS
-       select MAC80211_LEDS
-
-config IWL4965
-       tristate "Intel Wireless WiFi 4965AGN (iwl4965)"
-       depends on PCI && MAC80211
-       select IWLEGACY
-       ---help---
-         This option enables support for
-
-         Select to build the driver supporting the:
-
-         Intel Wireless WiFi Link 4965AGN
-
-         This driver uses the kernel's mac80211 subsystem.
-
-         In order to use this driver, you will need a microcode (uCode)
-         image for it. You can obtain the microcode from:
-
-                 <http://intellinuxwireless.org/>.
-
-         The microcode is typically installed in /lib/firmware. You can
-         look in the hotplug script /etc/hotplug/firmware.agent to
-         determine which directory FIRMWARE_DIR is set to when the script
-         runs.
-
-         If you want to compile the driver as a module ( = code which can be
-         inserted in and removed from the running kernel whenever you want),
-         say M here and read <file:Documentation/kbuild/modules.txt>.  The
-         module will be called iwl4965.
-
-config IWL3945
-       tristate "Intel PRO/Wireless 3945ABG/BG Network Connection (iwl3945)"
-       depends on PCI && MAC80211
-       select IWLEGACY
-       ---help---
-         Select to build the driver supporting the:
-
-         Intel PRO/Wireless 3945ABG/BG Network Connection
-
-         This driver uses the kernel's mac80211 subsystem.
-
-         In order to use this driver, you will need a microcode (uCode)
-         image for it. You can obtain the microcode from:
-
-                 <http://intellinuxwireless.org/>.
-
-         The microcode is typically installed in /lib/firmware. You can
-         look in the hotplug script /etc/hotplug/firmware.agent to
-         determine which directory FIRMWARE_DIR is set to when the script
-         runs.
-
-         If you want to compile the driver as a module ( = code which can be
-         inserted in and removed from the running kernel whenever you want),
-         say M here and read <file:Documentation/kbuild/modules.txt>.  The
-         module will be called iwl3945.
-
-menu "iwl3945 / iwl4965 Debugging Options"
-       depends on IWLEGACY
-
-config IWLEGACY_DEBUG
-       bool "Enable full debugging output in iwlegacy (iwl 3945/4965) drivers"
-       depends on IWLEGACY
-       ---help---
-         This option will enable debug tracing output for the iwlegacy
-         drivers.
-
-         This will result in the kernel module being ~100k larger.  You can
-         control which debug output is sent to the kernel log by setting the
-         value in
-
-               /sys/class/net/wlan0/device/debug_level
-
-         This entry will only exist if this option is enabled.
-
-         To set a value, simply echo an 8-byte hex value to the same file:
-
-                 % echo 0x43fff > /sys/class/net/wlan0/device/debug_level
-
-         You can find the list of debug mask values in:
-                 drivers/net/wireless/iwlegacy/common.h
-
-         If this is your first time using this driver, you should say Y here
-         as the debug information can assist others in helping you resolve
-         any problems you may encounter.
-
-config IWLEGACY_DEBUGFS
-        bool "iwlegacy (iwl 3945/4965) debugfs support"
-        depends on IWLEGACY && MAC80211_DEBUGFS
-        ---help---
-         Enable creation of debugfs files for the iwlegacy drivers. This
-         is a low-impact option that allows getting insight into the
-         driver's state at runtime.
-
-endmenu
diff --git a/drivers/net/wireless/iwlegacy/Makefile b/drivers/net/wireless/iwlegacy/Makefile
deleted file mode 100644 (file)
index c985a01..0000000
+++ /dev/null
@@ -1,17 +0,0 @@
-obj-$(CONFIG_IWLEGACY) += iwlegacy.o
-iwlegacy-objs          := common.o
-iwlegacy-$(CONFIG_IWLEGACY_DEBUGFS) += debug.o
-
-iwlegacy-objs += $(iwlegacy-m)
-
-# 4965
-obj-$(CONFIG_IWL4965)  += iwl4965.o
-iwl4965-objs           := 4965.o 4965-mac.o 4965-rs.o 4965-calib.o
-iwl4965-$(CONFIG_IWLEGACY_DEBUGFS) += 4965-debug.o
-
-# 3945
-obj-$(CONFIG_IWL3945)  += iwl3945.o
-iwl3945-objs           := 3945-mac.o 3945.o 3945-rs.o
-iwl3945-$(CONFIG_IWLEGACY_DEBUGFS) += 3945-debug.o
-
-ccflags-y += -D__CHECK_ENDIAN__
diff --git a/drivers/net/wireless/iwlegacy/commands.h b/drivers/net/wireless/iwlegacy/commands.h
deleted file mode 100644 (file)
index dd74413..0000000
+++ /dev/null
@@ -1,3370 +0,0 @@
-/******************************************************************************
- *
- * This file is provided under a dual BSD/GPLv2 license.  When using or
- * redistributing this file, you may do so under either license.
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- * BSD LICENSE
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *  * Neither the name Intel Corporation nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *****************************************************************************/
-
-#ifndef __il_commands_h__
-#define __il_commands_h__
-
-#include <linux/ieee80211.h>
-
-struct il_priv;
-
-/* uCode version contains 4 values: Major/Minor/API/Serial */
-#define IL_UCODE_MAJOR(ver)    (((ver) & 0xFF000000) >> 24)
-#define IL_UCODE_MINOR(ver)    (((ver) & 0x00FF0000) >> 16)
-#define IL_UCODE_API(ver)      (((ver) & 0x0000FF00) >> 8)
-#define IL_UCODE_SERIAL(ver)   ((ver) & 0x000000FF)
-
-/* Tx rates */
-#define IL_CCK_RATES   4
-#define IL_OFDM_RATES  8
-#define IL_MAX_RATES   (IL_CCK_RATES + IL_OFDM_RATES)
-
-enum {
-       N_ALIVE = 0x1,
-       N_ERROR = 0x2,
-
-       /* RXON and QOS commands */
-       C_RXON = 0x10,
-       C_RXON_ASSOC = 0x11,
-       C_QOS_PARAM = 0x13,
-       C_RXON_TIMING = 0x14,
-
-       /* Multi-Station support */
-       C_ADD_STA = 0x18,
-       C_REM_STA = 0x19,
-
-       /* Security */
-       C_WEPKEY = 0x20,
-
-       /* RX, TX, LEDs */
-       N_3945_RX = 0x1b,       /* 3945 only */
-       C_TX = 0x1c,
-       C_RATE_SCALE = 0x47,    /* 3945 only */
-       C_LEDS = 0x48,
-       C_TX_LINK_QUALITY_CMD = 0x4e,   /* for 4965 */
-
-       /* 802.11h related */
-       C_CHANNEL_SWITCH = 0x72,
-       N_CHANNEL_SWITCH = 0x73,
-       C_SPECTRUM_MEASUREMENT = 0x74,
-       N_SPECTRUM_MEASUREMENT = 0x75,
-
-       /* Power Management */
-       C_POWER_TBL = 0x77,
-       N_PM_SLEEP = 0x7A,
-       N_PM_DEBUG_STATS = 0x7B,
-
-       /* Scan commands and notifications */
-       C_SCAN = 0x80,
-       C_SCAN_ABORT = 0x81,
-       N_SCAN_START = 0x82,
-       N_SCAN_RESULTS = 0x83,
-       N_SCAN_COMPLETE = 0x84,
-
-       /* IBSS/AP commands */
-       N_BEACON = 0x90,
-       C_TX_BEACON = 0x91,
-
-       /* Miscellaneous commands */
-       C_TX_PWR_TBL = 0x97,
-
-       /* Bluetooth device coexistence config command */
-       C_BT_CONFIG = 0x9b,
-
-       /* Statistics */
-       C_STATS = 0x9c,
-       N_STATS = 0x9d,
-
-       /* RF-KILL commands and notifications */
-       N_CARD_STATE = 0xa1,
-
-       /* Missed beacons notification */
-       N_MISSED_BEACONS = 0xa2,
-
-       C_CT_KILL_CONFIG = 0xa4,
-       C_SENSITIVITY = 0xa8,
-       C_PHY_CALIBRATION = 0xb0,
-       N_RX_PHY = 0xc0,
-       N_RX_MPDU = 0xc1,
-       N_RX = 0xc3,
-       N_COMPRESSED_BA = 0xc5,
-
-       IL_CN_MAX = 0xff
-};
-
-/******************************************************************************
- * (0)
- * Commonly used structures and definitions:
- * Command header, rate_n_flags, txpower
- *
- *****************************************************************************/
-
-/* il_cmd_header flags value */
-#define IL_CMD_FAILED_MSK 0x40
-
-#define SEQ_TO_QUEUE(s)        (((s) >> 8) & 0x1f)
-#define QUEUE_TO_SEQ(q)        (((q) & 0x1f) << 8)
-#define SEQ_TO_IDX(s)  ((s) & 0xff)
-#define IDX_TO_SEQ(i)  ((i) & 0xff)
-#define SEQ_HUGE_FRAME cpu_to_le16(0x4000)
-#define SEQ_RX_FRAME   cpu_to_le16(0x8000)
-
-/**
- * struct il_cmd_header
- *
- * This header format appears in the beginning of each command sent from the
- * driver, and each response/notification received from uCode.
- */
-struct il_cmd_header {
-       u8 cmd;                 /* Command ID:  C_RXON, etc. */
-       u8 flags;               /* 0:5 reserved, 6 abort, 7 internal */
-       /*
-        * The driver sets up the sequence number to values of its choosing.
-        * uCode does not use this value, but passes it back to the driver
-        * when sending the response to each driver-originated command, so
-        * the driver can match the response to the command.  Since the values
-        * don't get used by uCode, the driver may set up an arbitrary format.
-        *
-        * There is one exception:  uCode sets bit 15 when it originates
-        * the response/notification, i.e. when the response/notification
-        * is not a direct response to a command sent by the driver.  For
-        * example, uCode issues N_3945_RX when it sends a received frame
-        * to the driver; it is not a direct response to any driver command.
-        *
-        * The Linux driver uses the following format:
-        *
-        *  0:7         tfd idx - position within TX queue
-        *  8:12        TX queue id
-        *  13          reserved
-        *  14          huge - driver sets this to indicate command is in the
-        *              'huge' storage at the end of the command buffers
-        *  15          unsolicited RX or uCode-originated notification
-        */
-       __le16 sequence;
-
-       /* command or response/notification data follows immediately */
-       u8 data[0];
-} __packed;
-
-/**
- * struct il3945_tx_power
- *
- * Used in C_TX_PWR_TBL, C_SCAN, C_CHANNEL_SWITCH
- *
- * Each entry contains two values:
- * 1)  DSP gain (or sometimes called DSP attenuation).  This is a fine-grained
- *     linear value that multiplies the output of the digital signal processor,
- *     before being sent to the analog radio.
- * 2)  Radio gain.  This sets the analog gain of the radio Tx path.
- *     It is a coarser setting, and behaves in a logarithmic (dB) fashion.
- *
- * Driver obtains values from struct il3945_tx_power power_gain_table[][].
- */
-struct il3945_tx_power {
-       u8 tx_gain;             /* gain for analog radio */
-       u8 dsp_atten;           /* gain for DSP */
-} __packed;
-
-/**
- * struct il3945_power_per_rate
- *
- * Used in C_TX_PWR_TBL, C_CHANNEL_SWITCH
- */
-struct il3945_power_per_rate {
-       u8 rate;                /* plcp */
-       struct il3945_tx_power tpc;
-       u8 reserved;
-} __packed;
-
-/**
- * iwl4965 rate_n_flags bit fields
- *
- * rate_n_flags format is used in following iwl4965 commands:
- *  N_RX (response only)
- *  N_RX_MPDU (response only)
- *  C_TX (both command and response)
- *  C_TX_LINK_QUALITY_CMD
- *
- * High-throughput (HT) rate format for bits 7:0 (bit 8 must be "1"):
- *  2-0:  0)   6 Mbps
- *        1)  12 Mbps
- *        2)  18 Mbps
- *        3)  24 Mbps
- *        4)  36 Mbps
- *        5)  48 Mbps
- *        6)  54 Mbps
- *        7)  60 Mbps
- *
- *  4-3:  0)  Single stream (SISO)
- *        1)  Dual stream (MIMO)
- *        2)  Triple stream (MIMO)
- *
- *    5:  Value of 0x20 in bits 7:0 indicates 6 Mbps HT40 duplicate data
- *
- * Legacy OFDM rate format for bits 7:0 (bit 8 must be "0", bit 9 "0"):
- *  3-0:  0xD)   6 Mbps
- *        0xF)   9 Mbps
- *        0x5)  12 Mbps
- *        0x7)  18 Mbps
- *        0x9)  24 Mbps
- *        0xB)  36 Mbps
- *        0x1)  48 Mbps
- *        0x3)  54 Mbps
- *
- * Legacy CCK rate format for bits 7:0 (bit 8 must be "0", bit 9 "1"):
- *  6-0:   10)  1 Mbps
- *         20)  2 Mbps
- *         55)  5.5 Mbps
- *        110)  11 Mbps
- */
-#define RATE_MCS_CODE_MSK 0x7
-#define RATE_MCS_SPATIAL_POS 3
-#define RATE_MCS_SPATIAL_MSK 0x18
-#define RATE_MCS_HT_DUP_POS 5
-#define RATE_MCS_HT_DUP_MSK 0x20
-
-/* Bit 8: (1) HT format, (0) legacy format in bits 7:0 */
-#define RATE_MCS_FLAGS_POS 8
-#define RATE_MCS_HT_POS 8
-#define RATE_MCS_HT_MSK 0x100
-
-/* Bit 9: (1) CCK, (0) OFDM.  HT (bit 8) must be "0" for this bit to be valid */
-#define RATE_MCS_CCK_POS 9
-#define RATE_MCS_CCK_MSK 0x200
-
-/* Bit 10: (1) Use Green Field preamble */
-#define RATE_MCS_GF_POS 10
-#define RATE_MCS_GF_MSK 0x400
-
-/* Bit 11: (1) Use 40Mhz HT40 chnl width, (0) use 20 MHz legacy chnl width */
-#define RATE_MCS_HT40_POS 11
-#define RATE_MCS_HT40_MSK 0x800
-
-/* Bit 12: (1) Duplicate data on both 20MHz chnls. HT40 (bit 11) must be set. */
-#define RATE_MCS_DUP_POS 12
-#define RATE_MCS_DUP_MSK 0x1000
-
-/* Bit 13: (1) Short guard interval (0.4 usec), (0) normal GI (0.8 usec) */
-#define RATE_MCS_SGI_POS 13
-#define RATE_MCS_SGI_MSK 0x2000
-
-/**
- * rate_n_flags Tx antenna masks
- * 4965 has 2 transmitters
- * bit14:16
- */
-#define RATE_MCS_ANT_POS       14
-#define RATE_MCS_ANT_A_MSK     0x04000
-#define RATE_MCS_ANT_B_MSK     0x08000
-#define RATE_MCS_ANT_C_MSK     0x10000
-#define RATE_MCS_ANT_AB_MSK    (RATE_MCS_ANT_A_MSK | RATE_MCS_ANT_B_MSK)
-#define RATE_MCS_ANT_ABC_MSK   (RATE_MCS_ANT_AB_MSK | RATE_MCS_ANT_C_MSK)
-#define RATE_ANT_NUM 3
-
-#define POWER_TBL_NUM_ENTRIES                  33
-#define POWER_TBL_NUM_HT_OFDM_ENTRIES          32
-#define POWER_TBL_CCK_ENTRY                    32
-
-#define IL_PWR_NUM_HT_OFDM_ENTRIES             24
-#define IL_PWR_CCK_ENTRIES                     2
-
-/**
- * union il4965_tx_power_dual_stream
- *
- * Host format used for C_TX_PWR_TBL, C_CHANNEL_SWITCH
- * Use __le32 version (struct tx_power_dual_stream) when building command.
- *
- * Driver provides radio gain and DSP attenuation settings to device in pairs,
- * one value for each transmitter chain.  The first value is for transmitter A,
- * second for transmitter B.
- *
- * For SISO bit rates, both values in a pair should be identical.
- * For MIMO rates, one value may be different from the other,
- * in order to balance the Tx output between the two transmitters.
- *
- * See more details in doc for TXPOWER in 4965.h.
- */
-union il4965_tx_power_dual_stream {
-       struct {
-               u8 radio_tx_gain[2];
-               u8 dsp_predis_atten[2];
-       } s;
-       u32 dw;
-};
-
-/**
- * struct tx_power_dual_stream
- *
- * Table entries in C_TX_PWR_TBL, C_CHANNEL_SWITCH
- *
- * Same format as il_tx_power_dual_stream, but __le32
- */
-struct tx_power_dual_stream {
-       __le32 dw;
-} __packed;
-
-/**
- * struct il4965_tx_power_db
- *
- * Entire table within C_TX_PWR_TBL, C_CHANNEL_SWITCH
- */
-struct il4965_tx_power_db {
-       struct tx_power_dual_stream power_tbl[POWER_TBL_NUM_ENTRIES];
-} __packed;
-
-/******************************************************************************
- * (0a)
- * Alive and Error Commands & Responses:
- *
- *****************************************************************************/
-
-#define UCODE_VALID_OK cpu_to_le32(0x1)
-#define INITIALIZE_SUBTYPE    (9)
-
-/*
- * ("Initialize") N_ALIVE = 0x1 (response only, not a command)
- *
- * uCode issues this "initialize alive" notification once the initialization
- * uCode image has completed its work, and is ready to load the runtime image.
- * This is the *first* "alive" notification that the driver will receive after
- * rebooting uCode; the "initialize" alive is indicated by subtype field == 9.
- *
- * See comments documenting "BSM" (bootstrap state machine).
- *
- * For 4965, this notification contains important calibration data for
- * calculating txpower settings:
- *
- * 1)  Power supply voltage indication.  The voltage sensor outputs higher
- *     values for lower voltage, and vice verse.
- *
- * 2)  Temperature measurement parameters, for each of two channel widths
- *     (20 MHz and 40 MHz) supported by the radios.  Temperature sensing
- *     is done via one of the receiver chains, and channel width influences
- *     the results.
- *
- * 3)  Tx gain compensation to balance 4965's 2 Tx chains for MIMO operation,
- *     for each of 5 frequency ranges.
- */
-struct il_init_alive_resp {
-       u8 ucode_minor;
-       u8 ucode_major;
-       __le16 reserved1;
-       u8 sw_rev[8];
-       u8 ver_type;
-       u8 ver_subtype;         /* "9" for initialize alive */
-       __le16 reserved2;
-       __le32 log_event_table_ptr;
-       __le32 error_event_table_ptr;
-       __le32 timestamp;
-       __le32 is_valid;
-
-       /* calibration values from "initialize" uCode */
-       __le32 voltage;         /* signed, higher value is lower voltage */
-       __le32 therm_r1[2];     /* signed, 1st for normal, 2nd for HT40 */
-       __le32 therm_r2[2];     /* signed */
-       __le32 therm_r3[2];     /* signed */
-       __le32 therm_r4[2];     /* signed */
-       __le32 tx_atten[5][2];  /* signed MIMO gain comp, 5 freq groups,
-                                * 2 Tx chains */
-} __packed;
-
-/**
- * N_ALIVE = 0x1 (response only, not a command)
- *
- * uCode issues this "alive" notification once the runtime image is ready
- * to receive commands from the driver.  This is the *second* "alive"
- * notification that the driver will receive after rebooting uCode;
- * this "alive" is indicated by subtype field != 9.
- *
- * See comments documenting "BSM" (bootstrap state machine).
- *
- * This response includes two pointers to structures within the device's
- * data SRAM (access via HBUS_TARG_MEM_* regs) that are useful for debugging:
- *
- * 1)  log_event_table_ptr indicates base of the event log.  This traces
- *     a 256-entry history of uCode execution within a circular buffer.
- *     Its header format is:
- *
- *     __le32 log_size;     log capacity (in number of entries)
- *     __le32 type;         (1) timestamp with each entry, (0) no timestamp
- *     __le32 wraps;        # times uCode has wrapped to top of circular buffer
- *      __le32 write_idx;  next circular buffer entry that uCode would fill
- *
- *     The header is followed by the circular buffer of log entries.  Entries
- *     with timestamps have the following format:
- *
- *     __le32 event_id;     range 0 - 1500
- *     __le32 timestamp;    low 32 bits of TSF (of network, if associated)
- *     __le32 data;         event_id-specific data value
- *
- *     Entries without timestamps contain only event_id and data.
- *
- *
- * 2)  error_event_table_ptr indicates base of the error log.  This contains
- *     information about any uCode error that occurs.  For 4965, the format
- *     of the error log is:
- *
- *     __le32 valid;        (nonzero) valid, (0) log is empty
- *     __le32 error_id;     type of error
- *     __le32 pc;           program counter
- *     __le32 blink1;       branch link
- *     __le32 blink2;       branch link
- *     __le32 ilink1;       interrupt link
- *     __le32 ilink2;       interrupt link
- *     __le32 data1;        error-specific data
- *     __le32 data2;        error-specific data
- *     __le32 line;         source code line of error
- *     __le32 bcon_time;    beacon timer
- *     __le32 tsf_low;      network timestamp function timer
- *     __le32 tsf_hi;       network timestamp function timer
- *     __le32 gp1;          GP1 timer register
- *     __le32 gp2;          GP2 timer register
- *     __le32 gp3;          GP3 timer register
- *     __le32 ucode_ver;    uCode version
- *     __le32 hw_ver;       HW Silicon version
- *     __le32 brd_ver;      HW board version
- *     __le32 log_pc;       log program counter
- *     __le32 frame_ptr;    frame pointer
- *     __le32 stack_ptr;    stack pointer
- *     __le32 hcmd;         last host command
- *     __le32 isr0;         isr status register LMPM_NIC_ISR0: rxtx_flag
- *     __le32 isr1;         isr status register LMPM_NIC_ISR1: host_flag
- *     __le32 isr2;         isr status register LMPM_NIC_ISR2: enc_flag
- *     __le32 isr3;         isr status register LMPM_NIC_ISR3: time_flag
- *     __le32 isr4;         isr status register LMPM_NIC_ISR4: wico interrupt
- *     __le32 isr_pref;     isr status register LMPM_NIC_PREF_STAT
- *     __le32 wait_event;   wait event() caller address
- *     __le32 l2p_control;  L2pControlField
- *     __le32 l2p_duration; L2pDurationField
- *     __le32 l2p_mhvalid;  L2pMhValidBits
- *     __le32 l2p_addr_match; L2pAddrMatchStat
- *     __le32 lmpm_pmg_sel; indicate which clocks are turned on (LMPM_PMG_SEL)
- *     __le32 u_timestamp;  indicate when the date and time of the compilation
- *     __le32 reserved;
- *
- * The Linux driver can print both logs to the system log when a uCode error
- * occurs.
- */
-struct il_alive_resp {
-       u8 ucode_minor;
-       u8 ucode_major;
-       __le16 reserved1;
-       u8 sw_rev[8];
-       u8 ver_type;
-       u8 ver_subtype;         /* not "9" for runtime alive */
-       __le16 reserved2;
-       __le32 log_event_table_ptr;     /* SRAM address for event log */
-       __le32 error_event_table_ptr;   /* SRAM address for error log */
-       __le32 timestamp;
-       __le32 is_valid;
-} __packed;
-
-/*
- * N_ERROR = 0x2 (response only, not a command)
- */
-struct il_error_resp {
-       __le32 error_type;
-       u8 cmd_id;
-       u8 reserved1;
-       __le16 bad_cmd_seq_num;
-       __le32 error_info;
-       __le64 timestamp;
-} __packed;
-
-/******************************************************************************
- * (1)
- * RXON Commands & Responses:
- *
- *****************************************************************************/
-
-/*
- * Rx config defines & structure
- */
-/* rx_config device types  */
-enum {
-       RXON_DEV_TYPE_AP = 1,
-       RXON_DEV_TYPE_ESS = 3,
-       RXON_DEV_TYPE_IBSS = 4,
-       RXON_DEV_TYPE_SNIFFER = 6,
-};
-
-#define RXON_RX_CHAIN_DRIVER_FORCE_MSK         cpu_to_le16(0x1 << 0)
-#define RXON_RX_CHAIN_DRIVER_FORCE_POS         (0)
-#define RXON_RX_CHAIN_VALID_MSK                        cpu_to_le16(0x7 << 1)
-#define RXON_RX_CHAIN_VALID_POS                        (1)
-#define RXON_RX_CHAIN_FORCE_SEL_MSK            cpu_to_le16(0x7 << 4)
-#define RXON_RX_CHAIN_FORCE_SEL_POS            (4)
-#define RXON_RX_CHAIN_FORCE_MIMO_SEL_MSK       cpu_to_le16(0x7 << 7)
-#define RXON_RX_CHAIN_FORCE_MIMO_SEL_POS       (7)
-#define RXON_RX_CHAIN_CNT_MSK                  cpu_to_le16(0x3 << 10)
-#define RXON_RX_CHAIN_CNT_POS                  (10)
-#define RXON_RX_CHAIN_MIMO_CNT_MSK             cpu_to_le16(0x3 << 12)
-#define RXON_RX_CHAIN_MIMO_CNT_POS             (12)
-#define RXON_RX_CHAIN_MIMO_FORCE_MSK           cpu_to_le16(0x1 << 14)
-#define RXON_RX_CHAIN_MIMO_FORCE_POS           (14)
-
-/* rx_config flags */
-/* band & modulation selection */
-#define RXON_FLG_BAND_24G_MSK           cpu_to_le32(1 << 0)
-#define RXON_FLG_CCK_MSK                cpu_to_le32(1 << 1)
-/* auto detection enable */
-#define RXON_FLG_AUTO_DETECT_MSK        cpu_to_le32(1 << 2)
-/* TGg protection when tx */
-#define RXON_FLG_TGG_PROTECT_MSK        cpu_to_le32(1 << 3)
-/* cck short slot & preamble */
-#define RXON_FLG_SHORT_SLOT_MSK          cpu_to_le32(1 << 4)
-#define RXON_FLG_SHORT_PREAMBLE_MSK     cpu_to_le32(1 << 5)
-/* antenna selection */
-#define RXON_FLG_DIS_DIV_MSK            cpu_to_le32(1 << 7)
-#define RXON_FLG_ANT_SEL_MSK            cpu_to_le32(0x0f00)
-#define RXON_FLG_ANT_A_MSK              cpu_to_le32(1 << 8)
-#define RXON_FLG_ANT_B_MSK              cpu_to_le32(1 << 9)
-/* radar detection enable */
-#define RXON_FLG_RADAR_DETECT_MSK       cpu_to_le32(1 << 12)
-#define RXON_FLG_TGJ_NARROW_BAND_MSK    cpu_to_le32(1 << 13)
-/* rx response to host with 8-byte TSF
-* (according to ON_AIR deassertion) */
-#define RXON_FLG_TSF2HOST_MSK           cpu_to_le32(1 << 15)
-
-/* HT flags */
-#define RXON_FLG_CTRL_CHANNEL_LOC_POS          (22)
-#define RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK       cpu_to_le32(0x1 << 22)
-
-#define RXON_FLG_HT_OPERATING_MODE_POS         (23)
-
-#define RXON_FLG_HT_PROT_MSK                   cpu_to_le32(0x1 << 23)
-#define RXON_FLG_HT40_PROT_MSK                 cpu_to_le32(0x2 << 23)
-
-#define RXON_FLG_CHANNEL_MODE_POS              (25)
-#define RXON_FLG_CHANNEL_MODE_MSK              cpu_to_le32(0x3 << 25)
-
-/* channel mode */
-enum {
-       CHANNEL_MODE_LEGACY = 0,
-       CHANNEL_MODE_PURE_40 = 1,
-       CHANNEL_MODE_MIXED = 2,
-       CHANNEL_MODE_RESERVED = 3,
-};
-#define RXON_FLG_CHANNEL_MODE_LEGACY                   \
-       cpu_to_le32(CHANNEL_MODE_LEGACY << RXON_FLG_CHANNEL_MODE_POS)
-#define RXON_FLG_CHANNEL_MODE_PURE_40                  \
-       cpu_to_le32(CHANNEL_MODE_PURE_40 << RXON_FLG_CHANNEL_MODE_POS)
-#define RXON_FLG_CHANNEL_MODE_MIXED                    \
-       cpu_to_le32(CHANNEL_MODE_MIXED << RXON_FLG_CHANNEL_MODE_POS)
-
-/* CTS to self (if spec allows) flag */
-#define RXON_FLG_SELF_CTS_EN                   cpu_to_le32(0x1<<30)
-
-/* rx_config filter flags */
-/* accept all data frames */
-#define RXON_FILTER_PROMISC_MSK         cpu_to_le32(1 << 0)
-/* pass control & management to host */
-#define RXON_FILTER_CTL2HOST_MSK        cpu_to_le32(1 << 1)
-/* accept multi-cast */
-#define RXON_FILTER_ACCEPT_GRP_MSK      cpu_to_le32(1 << 2)
-/* don't decrypt uni-cast frames */
-#define RXON_FILTER_DIS_DECRYPT_MSK     cpu_to_le32(1 << 3)
-/* don't decrypt multi-cast frames */
-#define RXON_FILTER_DIS_GRP_DECRYPT_MSK cpu_to_le32(1 << 4)
-/* STA is associated */
-#define RXON_FILTER_ASSOC_MSK           cpu_to_le32(1 << 5)
-/* transfer to host non bssid beacons in associated state */
-#define RXON_FILTER_BCON_AWARE_MSK      cpu_to_le32(1 << 6)
-
-/**
- * C_RXON = 0x10 (command, has simple generic response)
- *
- * RXON tunes the radio tuner to a service channel, and sets up a number
- * of parameters that are used primarily for Rx, but also for Tx operations.
- *
- * NOTE:  When tuning to a new channel, driver must set the
- *        RXON_FILTER_ASSOC_MSK to 0.  This will clear station-dependent
- *        info within the device, including the station tables, tx retry
- *        rate tables, and txpower tables.  Driver must build a new station
- *        table and txpower table before transmitting anything on the RXON
- *        channel.
- *
- * NOTE:  All RXONs wipe clean the internal txpower table.  Driver must
- *        issue a new C_TX_PWR_TBL after each C_RXON (0x10),
- *        regardless of whether RXON_FILTER_ASSOC_MSK is set.
- */
-
-struct il3945_rxon_cmd {
-       u8 node_addr[6];
-       __le16 reserved1;
-       u8 bssid_addr[6];
-       __le16 reserved2;
-       u8 wlap_bssid_addr[6];
-       __le16 reserved3;
-       u8 dev_type;
-       u8 air_propagation;
-       __le16 reserved4;
-       u8 ofdm_basic_rates;
-       u8 cck_basic_rates;
-       __le16 assoc_id;
-       __le32 flags;
-       __le32 filter_flags;
-       __le16 channel;
-       __le16 reserved5;
-} __packed;
-
-struct il4965_rxon_cmd {
-       u8 node_addr[6];
-       __le16 reserved1;
-       u8 bssid_addr[6];
-       __le16 reserved2;
-       u8 wlap_bssid_addr[6];
-       __le16 reserved3;
-       u8 dev_type;
-       u8 air_propagation;
-       __le16 rx_chain;
-       u8 ofdm_basic_rates;
-       u8 cck_basic_rates;
-       __le16 assoc_id;
-       __le32 flags;
-       __le32 filter_flags;
-       __le16 channel;
-       u8 ofdm_ht_single_stream_basic_rates;
-       u8 ofdm_ht_dual_stream_basic_rates;
-} __packed;
-
-/* Create a common rxon cmd which will be typecast into the 3945 or 4965
- * specific rxon cmd, depending on where it is called from.
- */
-struct il_rxon_cmd {
-       u8 node_addr[6];
-       __le16 reserved1;
-       u8 bssid_addr[6];
-       __le16 reserved2;
-       u8 wlap_bssid_addr[6];
-       __le16 reserved3;
-       u8 dev_type;
-       u8 air_propagation;
-       __le16 rx_chain;
-       u8 ofdm_basic_rates;
-       u8 cck_basic_rates;
-       __le16 assoc_id;
-       __le32 flags;
-       __le32 filter_flags;
-       __le16 channel;
-       u8 ofdm_ht_single_stream_basic_rates;
-       u8 ofdm_ht_dual_stream_basic_rates;
-       u8 reserved4;
-       u8 reserved5;
-} __packed;
-
-/*
- * C_RXON_ASSOC = 0x11 (command, has simple generic response)
- */
-struct il3945_rxon_assoc_cmd {
-       __le32 flags;
-       __le32 filter_flags;
-       u8 ofdm_basic_rates;
-       u8 cck_basic_rates;
-       __le16 reserved;
-} __packed;
-
-struct il4965_rxon_assoc_cmd {
-       __le32 flags;
-       __le32 filter_flags;
-       u8 ofdm_basic_rates;
-       u8 cck_basic_rates;
-       u8 ofdm_ht_single_stream_basic_rates;
-       u8 ofdm_ht_dual_stream_basic_rates;
-       __le16 rx_chain_select_flags;
-       __le16 reserved;
-} __packed;
-
-#define IL_CONN_MAX_LISTEN_INTERVAL    10
-#define IL_MAX_UCODE_BEACON_INTERVAL   4       /* 4096 */
-#define IL39_MAX_UCODE_BEACON_INTERVAL 1       /* 1024 */
-
-/*
- * C_RXON_TIMING = 0x14 (command, has simple generic response)
- */
-struct il_rxon_time_cmd {
-       __le64 timestamp;
-       __le16 beacon_interval;
-       __le16 atim_win;
-       __le32 beacon_init_val;
-       __le16 listen_interval;
-       u8 dtim_period;
-       u8 delta_cp_bss_tbtts;
-} __packed;
-
-/*
- * C_CHANNEL_SWITCH = 0x72 (command, has simple generic response)
- */
-struct il3945_channel_switch_cmd {
-       u8 band;
-       u8 expect_beacon;
-       __le16 channel;
-       __le32 rxon_flags;
-       __le32 rxon_filter_flags;
-       __le32 switch_time;
-       struct il3945_power_per_rate power[IL_MAX_RATES];
-} __packed;
-
-struct il4965_channel_switch_cmd {
-       u8 band;
-       u8 expect_beacon;
-       __le16 channel;
-       __le32 rxon_flags;
-       __le32 rxon_filter_flags;
-       __le32 switch_time;
-       struct il4965_tx_power_db tx_power;
-} __packed;
-
-/*
- * N_CHANNEL_SWITCH = 0x73 (notification only, not a command)
- */
-struct il_csa_notification {
-       __le16 band;
-       __le16 channel;
-       __le32 status;          /* 0 - OK, 1 - fail */
-} __packed;
-
-/******************************************************************************
- * (2)
- * Quality-of-Service (QOS) Commands & Responses:
- *
- *****************************************************************************/
-
-/**
- * struct il_ac_qos -- QOS timing params for C_QOS_PARAM
- * One for each of 4 EDCA access categories in struct il_qosparam_cmd
- *
- * @cw_min: Contention win, start value in numbers of slots.
- *          Should be a power-of-2, minus 1.  Device's default is 0x0f.
- * @cw_max: Contention win, max value in numbers of slots.
- *          Should be a power-of-2, minus 1.  Device's default is 0x3f.
- * @aifsn:  Number of slots in Arbitration Interframe Space (before
- *          performing random backoff timing prior to Tx).  Device default 1.
- * @edca_txop:  Length of Tx opportunity, in uSecs.  Device default is 0.
- *
- * Device will automatically increase contention win by (2*CW) + 1 for each
- * transmission retry.  Device uses cw_max as a bit mask, ANDed with new CW
- * value, to cap the CW value.
- */
-struct il_ac_qos {
-       __le16 cw_min;
-       __le16 cw_max;
-       u8 aifsn;
-       u8 reserved1;
-       __le16 edca_txop;
-} __packed;
-
-/* QoS flags defines */
-#define QOS_PARAM_FLG_UPDATE_EDCA_MSK  cpu_to_le32(0x01)
-#define QOS_PARAM_FLG_TGN_MSK          cpu_to_le32(0x02)
-#define QOS_PARAM_FLG_TXOP_TYPE_MSK    cpu_to_le32(0x10)
-
-/* Number of Access Categories (AC) (EDCA), queues 0..3 */
-#define AC_NUM                4
-
-/*
- * C_QOS_PARAM = 0x13 (command, has simple generic response)
- *
- * This command sets up timings for each of the 4 prioritized EDCA Tx FIFOs
- * 0: Background, 1: Best Effort, 2: Video, 3: Voice.
- */
-struct il_qosparam_cmd {
-       __le32 qos_flags;
-       struct il_ac_qos ac[AC_NUM];
-} __packed;
-
-/******************************************************************************
- * (3)
- * Add/Modify Stations Commands & Responses:
- *
- *****************************************************************************/
-/*
- * Multi station support
- */
-
-/* Special, dedicated locations within device's station table */
-#define        IL_AP_ID                0
-#define        IL_STA_ID               2
-#define        IL3945_BROADCAST_ID     24
-#define IL3945_STATION_COUNT   25
-#define IL4965_BROADCAST_ID    31
-#define        IL4965_STATION_COUNT    32
-
-#define        IL_STATION_COUNT        32      /* MAX(3945,4965) */
-#define        IL_INVALID_STATION      255
-
-#define STA_FLG_TX_RATE_MSK            cpu_to_le32(1 << 2)
-#define STA_FLG_PWR_SAVE_MSK           cpu_to_le32(1 << 8)
-#define STA_FLG_RTS_MIMO_PROT_MSK      cpu_to_le32(1 << 17)
-#define STA_FLG_AGG_MPDU_8US_MSK       cpu_to_le32(1 << 18)
-#define STA_FLG_MAX_AGG_SIZE_POS       (19)
-#define STA_FLG_MAX_AGG_SIZE_MSK       cpu_to_le32(3 << 19)
-#define STA_FLG_HT40_EN_MSK            cpu_to_le32(1 << 21)
-#define STA_FLG_MIMO_DIS_MSK           cpu_to_le32(1 << 22)
-#define STA_FLG_AGG_MPDU_DENSITY_POS   (23)
-#define STA_FLG_AGG_MPDU_DENSITY_MSK   cpu_to_le32(7 << 23)
-
-/* Use in mode field.  1: modify existing entry, 0: add new station entry */
-#define STA_CONTROL_MODIFY_MSK         0x01
-
-/* key flags __le16*/
-#define STA_KEY_FLG_ENCRYPT_MSK        cpu_to_le16(0x0007)
-#define STA_KEY_FLG_NO_ENC     cpu_to_le16(0x0000)
-#define STA_KEY_FLG_WEP                cpu_to_le16(0x0001)
-#define STA_KEY_FLG_CCMP       cpu_to_le16(0x0002)
-#define STA_KEY_FLG_TKIP       cpu_to_le16(0x0003)
-
-#define STA_KEY_FLG_KEYID_POS  8
-#define STA_KEY_FLG_INVALID    cpu_to_le16(0x0800)
-/* wep key is either from global key (0) or from station info array (1) */
-#define STA_KEY_FLG_MAP_KEY_MSK        cpu_to_le16(0x0008)
-
-/* wep key in STA: 5-bytes (0) or 13-bytes (1) */
-#define STA_KEY_FLG_KEY_SIZE_MSK       cpu_to_le16(0x1000)
-#define STA_KEY_MULTICAST_MSK          cpu_to_le16(0x4000)
-#define STA_KEY_MAX_NUM                8
-
-/* Flags indicate whether to modify vs. don't change various station params */
-#define        STA_MODIFY_KEY_MASK             0x01
-#define        STA_MODIFY_TID_DISABLE_TX       0x02
-#define        STA_MODIFY_TX_RATE_MSK          0x04
-#define STA_MODIFY_ADDBA_TID_MSK       0x08
-#define STA_MODIFY_DELBA_TID_MSK       0x10
-#define STA_MODIFY_SLEEP_TX_COUNT_MSK  0x20
-
-/* Receiver address (actually, Rx station's idx into station table),
- * combined with Traffic ID (QOS priority), in format used by Tx Scheduler */
-#define BUILD_RAxTID(sta_id, tid)      (((sta_id) << 4) + (tid))
-
-struct il4965_keyinfo {
-       __le16 key_flags;
-       u8 tkip_rx_tsc_byte2;   /* TSC[2] for key mix ph1 detection */
-       u8 reserved1;
-       __le16 tkip_rx_ttak[5]; /* 10-byte unicast TKIP TTAK */
-       u8 key_offset;
-       u8 reserved2;
-       u8 key[16];             /* 16-byte unicast decryption key */
-} __packed;
-
-/**
- * struct sta_id_modify
- * @addr[ETH_ALEN]: station's MAC address
- * @sta_id: idx of station in uCode's station table
- * @modify_mask: STA_MODIFY_*, 1: modify, 0: don't change
- *
- * Driver selects unused table idx when adding new station,
- * or the idx to a pre-existing station entry when modifying that station.
- * Some idxes have special purposes (IL_AP_ID, idx 0, is for AP).
- *
- * modify_mask flags select which parameters to modify vs. leave alone.
- */
-struct sta_id_modify {
-       u8 addr[ETH_ALEN];
-       __le16 reserved1;
-       u8 sta_id;
-       u8 modify_mask;
-       __le16 reserved2;
-} __packed;
-
-/*
- * C_ADD_STA = 0x18 (command)
- *
- * The device contains an internal table of per-station information,
- * with info on security keys, aggregation parameters, and Tx rates for
- * initial Tx attempt and any retries (4965 devices uses
- * C_TX_LINK_QUALITY_CMD,
- * 3945 uses C_RATE_SCALE to set up rate tables).
- *
- * C_ADD_STA sets up the table entry for one station, either creating
- * a new entry, or modifying a pre-existing one.
- *
- * NOTE:  RXON command (without "associated" bit set) wipes the station table
- *        clean.  Moving into RF_KILL state does this also.  Driver must set up
- *        new station table before transmitting anything on the RXON channel
- *        (except active scans or active measurements; those commands carry
- *        their own txpower/rate setup data).
- *
- *        When getting started on a new channel, driver must set up the
- *        IL_BROADCAST_ID entry (last entry in the table).  For a client
- *        station in a BSS, once an AP is selected, driver sets up the AP STA
- *        in the IL_AP_ID entry (1st entry in the table).  BROADCAST and AP
- *        are all that are needed for a BSS client station.  If the device is
- *        used as AP, or in an IBSS network, driver must set up station table
- *        entries for all STAs in network, starting with idx IL_STA_ID.
- */
-
-struct il3945_addsta_cmd {
-       u8 mode;                /* 1: modify existing, 0: add new station */
-       u8 reserved[3];
-       struct sta_id_modify sta;
-       struct il4965_keyinfo key;
-       __le32 station_flags;   /* STA_FLG_* */
-       __le32 station_flags_msk;       /* STA_FLG_* */
-
-       /* bit field to disable (1) or enable (0) Tx for Traffic ID (TID)
-        * corresponding to bit (e.g. bit 5 controls TID 5).
-        * Set modify_mask bit STA_MODIFY_TID_DISABLE_TX to use this field. */
-       __le16 tid_disable_tx;
-
-       __le16 rate_n_flags;
-
-       /* TID for which to add block-ack support.
-        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
-       u8 add_immediate_ba_tid;
-
-       /* TID for which to remove block-ack support.
-        * Set modify_mask bit STA_MODIFY_DELBA_TID_MSK to use this field. */
-       u8 remove_immediate_ba_tid;
-
-       /* Starting Sequence Number for added block-ack support.
-        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
-       __le16 add_immediate_ba_ssn;
-} __packed;
-
-struct il4965_addsta_cmd {
-       u8 mode;                /* 1: modify existing, 0: add new station */
-       u8 reserved[3];
-       struct sta_id_modify sta;
-       struct il4965_keyinfo key;
-       __le32 station_flags;   /* STA_FLG_* */
-       __le32 station_flags_msk;       /* STA_FLG_* */
-
-       /* bit field to disable (1) or enable (0) Tx for Traffic ID (TID)
-        * corresponding to bit (e.g. bit 5 controls TID 5).
-        * Set modify_mask bit STA_MODIFY_TID_DISABLE_TX to use this field. */
-       __le16 tid_disable_tx;
-
-       __le16 reserved1;
-
-       /* TID for which to add block-ack support.
-        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
-       u8 add_immediate_ba_tid;
-
-       /* TID for which to remove block-ack support.
-        * Set modify_mask bit STA_MODIFY_DELBA_TID_MSK to use this field. */
-       u8 remove_immediate_ba_tid;
-
-       /* Starting Sequence Number for added block-ack support.
-        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
-       __le16 add_immediate_ba_ssn;
-
-       /*
-        * Number of packets OK to transmit to station even though
-        * it is asleep -- used to synchronise PS-poll and u-APSD
-        * responses while ucode keeps track of STA sleep state.
-        */
-       __le16 sleep_tx_count;
-
-       __le16 reserved2;
-} __packed;
-
-/* Wrapper struct for 3945 and 4965 addsta_cmd structures */
-struct il_addsta_cmd {
-       u8 mode;                /* 1: modify existing, 0: add new station */
-       u8 reserved[3];
-       struct sta_id_modify sta;
-       struct il4965_keyinfo key;
-       __le32 station_flags;   /* STA_FLG_* */
-       __le32 station_flags_msk;       /* STA_FLG_* */
-
-       /* bit field to disable (1) or enable (0) Tx for Traffic ID (TID)
-        * corresponding to bit (e.g. bit 5 controls TID 5).
-        * Set modify_mask bit STA_MODIFY_TID_DISABLE_TX to use this field. */
-       __le16 tid_disable_tx;
-
-       __le16 rate_n_flags;    /* 3945 only */
-
-       /* TID for which to add block-ack support.
-        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
-       u8 add_immediate_ba_tid;
-
-       /* TID for which to remove block-ack support.
-        * Set modify_mask bit STA_MODIFY_DELBA_TID_MSK to use this field. */
-       u8 remove_immediate_ba_tid;
-
-       /* Starting Sequence Number for added block-ack support.
-        * Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
-       __le16 add_immediate_ba_ssn;
-
-       /*
-        * Number of packets OK to transmit to station even though
-        * it is asleep -- used to synchronise PS-poll and u-APSD
-        * responses while ucode keeps track of STA sleep state.
-        */
-       __le16 sleep_tx_count;
-
-       __le16 reserved2;
-} __packed;
-
-#define ADD_STA_SUCCESS_MSK            0x1
-#define ADD_STA_NO_ROOM_IN_TBL 0x2
-#define ADD_STA_NO_BLOCK_ACK_RESOURCE  0x4
-#define ADD_STA_MODIFY_NON_EXIST_STA   0x8
-/*
- * C_ADD_STA = 0x18 (response)
- */
-struct il_add_sta_resp {
-       u8 status;              /* ADD_STA_* */
-} __packed;
-
-#define REM_STA_SUCCESS_MSK              0x1
-/*
- *  C_REM_STA = 0x19 (response)
- */
-struct il_rem_sta_resp {
-       u8 status;
-} __packed;
-
-/*
- *  C_REM_STA = 0x19 (command)
- */
-struct il_rem_sta_cmd {
-       u8 num_sta;             /* number of removed stations */
-       u8 reserved[3];
-       u8 addr[ETH_ALEN];      /* MAC addr of the first station */
-       u8 reserved2[2];
-} __packed;
-
-#define IL_TX_FIFO_BK_MSK              cpu_to_le32(BIT(0))
-#define IL_TX_FIFO_BE_MSK              cpu_to_le32(BIT(1))
-#define IL_TX_FIFO_VI_MSK              cpu_to_le32(BIT(2))
-#define IL_TX_FIFO_VO_MSK              cpu_to_le32(BIT(3))
-#define IL_AGG_TX_QUEUE_MSK            cpu_to_le32(0xffc00)
-
-#define IL_DROP_SINGLE         0
-#define IL_DROP_SELECTED       1
-#define IL_DROP_ALL            2
-
-/*
- * REPLY_WEP_KEY = 0x20
- */
-struct il_wep_key {
-       u8 key_idx;
-       u8 key_offset;
-       u8 reserved1[2];
-       u8 key_size;
-       u8 reserved2[3];
-       u8 key[16];
-} __packed;
-
-struct il_wep_cmd {
-       u8 num_keys;
-       u8 global_key_type;
-       u8 flags;
-       u8 reserved;
-       struct il_wep_key key[0];
-} __packed;
-
-#define WEP_KEY_WEP_TYPE 1
-#define WEP_KEYS_MAX 4
-#define WEP_INVALID_OFFSET 0xff
-#define WEP_KEY_LEN_64 5
-#define WEP_KEY_LEN_128 13
-
-/******************************************************************************
- * (4)
- * Rx Responses:
- *
- *****************************************************************************/
-
-#define RX_RES_STATUS_NO_CRC32_ERROR   cpu_to_le32(1 << 0)
-#define RX_RES_STATUS_NO_RXE_OVERFLOW  cpu_to_le32(1 << 1)
-
-#define RX_RES_PHY_FLAGS_BAND_24_MSK   cpu_to_le16(1 << 0)
-#define RX_RES_PHY_FLAGS_MOD_CCK_MSK           cpu_to_le16(1 << 1)
-#define RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK    cpu_to_le16(1 << 2)
-#define RX_RES_PHY_FLAGS_NARROW_BAND_MSK       cpu_to_le16(1 << 3)
-#define RX_RES_PHY_FLAGS_ANTENNA_MSK           0x70
-#define RX_RES_PHY_FLAGS_ANTENNA_POS           4
-#define RX_RES_PHY_FLAGS_AGG_MSK       cpu_to_le16(1 << 7)
-
-#define RX_RES_STATUS_SEC_TYPE_MSK     (0x7 << 8)
-#define RX_RES_STATUS_SEC_TYPE_NONE    (0x0 << 8)
-#define RX_RES_STATUS_SEC_TYPE_WEP     (0x1 << 8)
-#define RX_RES_STATUS_SEC_TYPE_CCMP    (0x2 << 8)
-#define RX_RES_STATUS_SEC_TYPE_TKIP    (0x3 << 8)
-#define        RX_RES_STATUS_SEC_TYPE_ERR      (0x7 << 8)
-
-#define RX_RES_STATUS_STATION_FOUND    (1<<6)
-#define RX_RES_STATUS_NO_STATION_INFO_MISMATCH (1<<7)
-
-#define RX_RES_STATUS_DECRYPT_TYPE_MSK (0x3 << 11)
-#define RX_RES_STATUS_NOT_DECRYPT      (0x0 << 11)
-#define RX_RES_STATUS_DECRYPT_OK       (0x3 << 11)
-#define RX_RES_STATUS_BAD_ICV_MIC      (0x1 << 11)
-#define RX_RES_STATUS_BAD_KEY_TTAK     (0x2 << 11)
-
-#define RX_MPDU_RES_STATUS_ICV_OK      (0x20)
-#define RX_MPDU_RES_STATUS_MIC_OK      (0x40)
-#define RX_MPDU_RES_STATUS_TTAK_OK     (1 << 7)
-#define RX_MPDU_RES_STATUS_DEC_DONE_MSK        (0x800)
-
-struct il3945_rx_frame_stats {
-       u8 phy_count;
-       u8 id;
-       u8 rssi;
-       u8 agc;
-       __le16 sig_avg;
-       __le16 noise_diff;
-       u8 payload[0];
-} __packed;
-
-struct il3945_rx_frame_hdr {
-       __le16 channel;
-       __le16 phy_flags;
-       u8 reserved1;
-       u8 rate;
-       __le16 len;
-       u8 payload[0];
-} __packed;
-
-struct il3945_rx_frame_end {
-       __le32 status;
-       __le64 timestamp;
-       __le32 beacon_timestamp;
-} __packed;
-
-/*
- * N_3945_RX = 0x1b (response only, not a command)
- *
- * NOTE:  DO NOT dereference from casts to this structure
- * It is provided only for calculating minimum data set size.
- * The actual offsets of the hdr and end are dynamic based on
- * stats.phy_count
- */
-struct il3945_rx_frame {
-       struct il3945_rx_frame_stats stats;
-       struct il3945_rx_frame_hdr hdr;
-       struct il3945_rx_frame_end end;
-} __packed;
-
-#define IL39_RX_FRAME_SIZE     (4 + sizeof(struct il3945_rx_frame))
-
-/* Fixed (non-configurable) rx data from phy */
-
-#define IL49_RX_RES_PHY_CNT 14
-#define IL49_RX_PHY_FLAGS_ANTENNAE_OFFSET      (4)
-#define IL49_RX_PHY_FLAGS_ANTENNAE_MASK        (0x70)
-#define IL49_AGC_DB_MASK                       (0x3f80)        /* MASK(7,13) */
-#define IL49_AGC_DB_POS                        (7)
-struct il4965_rx_non_cfg_phy {
-       __le16 ant_selection;   /* ant A bit 4, ant B bit 5, ant C bit 6 */
-       __le16 agc_info;        /* agc code 0:6, agc dB 7:13, reserved 14:15 */
-       u8 rssi_info[6];        /* we use even entries, 0/2/4 for A/B/C rssi */
-       u8 pad[0];
-} __packed;
-
-/*
- * N_RX = 0xc3 (response only, not a command)
- * Used only for legacy (non 11n) frames.
- */
-struct il_rx_phy_res {
-       u8 non_cfg_phy_cnt;     /* non configurable DSP phy data byte count */
-       u8 cfg_phy_cnt;         /* configurable DSP phy data byte count */
-       u8 stat_id;             /* configurable DSP phy data set ID */
-       u8 reserved1;
-       __le64 timestamp;       /* TSF at on air rise */
-       __le32 beacon_time_stamp;       /* beacon at on-air rise */
-       __le16 phy_flags;       /* general phy flags: band, modulation, ... */
-       __le16 channel;         /* channel number */
-       u8 non_cfg_phy_buf[32]; /* for various implementations of non_cfg_phy */
-       __le32 rate_n_flags;    /* RATE_MCS_* */
-       __le16 byte_count;      /* frame's byte-count */
-       __le16 frame_time;      /* frame's time on the air */
-} __packed;
-
-struct il_rx_mpdu_res_start {
-       __le16 byte_count;
-       __le16 reserved;
-} __packed;
-
-/******************************************************************************
- * (5)
- * Tx Commands & Responses:
- *
- * Driver must place each C_TX command into one of the prioritized Tx
- * queues in host DRAM, shared between driver and device (see comments for
- * SCD registers and Tx/Rx Queues).  When the device's Tx scheduler and uCode
- * are preparing to transmit, the device pulls the Tx command over the PCI
- * bus via one of the device's Tx DMA channels, to fill an internal FIFO
- * from which data will be transmitted.
- *
- * uCode handles all timing and protocol related to control frames
- * (RTS/CTS/ACK), based on flags in the Tx command.  uCode and Tx scheduler
- * handle reception of block-acks; uCode updates the host driver via
- * N_COMPRESSED_BA.
- *
- * uCode handles retrying Tx when an ACK is expected but not received.
- * This includes trying lower data rates than the one requested in the Tx
- * command, as set up by the C_RATE_SCALE (for 3945) or
- * C_TX_LINK_QUALITY_CMD (4965).
- *
- * Driver sets up transmit power for various rates via C_TX_PWR_TBL.
- * This command must be executed after every RXON command, before Tx can occur.
- *****************************************************************************/
-
-/* C_TX Tx flags field */
-
-/*
- * 1: Use Request-To-Send protocol before this frame.
- * Mutually exclusive vs. TX_CMD_FLG_CTS_MSK.
- */
-#define TX_CMD_FLG_RTS_MSK cpu_to_le32(1 << 1)
-
-/*
- * 1: Transmit Clear-To-Send to self before this frame.
- * Driver should set this for AUTH/DEAUTH/ASSOC-REQ/REASSOC mgmnt frames.
- * Mutually exclusive vs. TX_CMD_FLG_RTS_MSK.
- */
-#define TX_CMD_FLG_CTS_MSK cpu_to_le32(1 << 2)
-
-/* 1: Expect ACK from receiving station
- * 0: Don't expect ACK (MAC header's duration field s/b 0)
- * Set this for unicast frames, but not broadcast/multicast. */
-#define TX_CMD_FLG_ACK_MSK cpu_to_le32(1 << 3)
-
-/* For 4965 devices:
- * 1: Use rate scale table (see C_TX_LINK_QUALITY_CMD).
- *    Tx command's initial_rate_idx indicates first rate to try;
- *    uCode walks through table for additional Tx attempts.
- * 0: Use Tx rate/MCS from Tx command's rate_n_flags field.
- *    This rate will be used for all Tx attempts; it will not be scaled. */
-#define TX_CMD_FLG_STA_RATE_MSK cpu_to_le32(1 << 4)
-
-/* 1: Expect immediate block-ack.
- * Set when Txing a block-ack request frame.  Also set TX_CMD_FLG_ACK_MSK. */
-#define TX_CMD_FLG_IMM_BA_RSP_MASK  cpu_to_le32(1 << 6)
-
-/*
- * 1: Frame requires full Tx-Op protection.
- * Set this if either RTS or CTS Tx Flag gets set.
- */
-#define TX_CMD_FLG_FULL_TXOP_PROT_MSK cpu_to_le32(1 << 7)
-
-/* Tx antenna selection field; used only for 3945, reserved (0) for 4965 devices.
- * Set field to "0" to allow 3945 uCode to select antenna (normal usage). */
-#define TX_CMD_FLG_ANT_SEL_MSK cpu_to_le32(0xf00)
-#define TX_CMD_FLG_ANT_A_MSK cpu_to_le32(1 << 8)
-#define TX_CMD_FLG_ANT_B_MSK cpu_to_le32(1 << 9)
-
-/* 1: uCode overrides sequence control field in MAC header.
- * 0: Driver provides sequence control field in MAC header.
- * Set this for management frames, non-QOS data frames, non-unicast frames,
- * and also in Tx command embedded in C_SCAN for active scans. */
-#define TX_CMD_FLG_SEQ_CTL_MSK cpu_to_le32(1 << 13)
-
-/* 1: This frame is non-last MPDU; more fragments are coming.
- * 0: Last fragment, or not using fragmentation. */
-#define TX_CMD_FLG_MORE_FRAG_MSK cpu_to_le32(1 << 14)
-
-/* 1: uCode calculates and inserts Timestamp Function (TSF) in outgoing frame.
- * 0: No TSF required in outgoing frame.
- * Set this for transmitting beacons and probe responses. */
-#define TX_CMD_FLG_TSF_MSK cpu_to_le32(1 << 16)
-
-/* 1: Driver inserted 2 bytes pad after the MAC header, for (required) dword
- *    alignment of frame's payload data field.
- * 0: No pad
- * Set this for MAC headers with 26 or 30 bytes, i.e. those with QOS or ADDR4
- * field (but not both).  Driver must align frame data (i.e. data following
- * MAC header) to DWORD boundary. */
-#define TX_CMD_FLG_MH_PAD_MSK cpu_to_le32(1 << 20)
-
-/* accelerate aggregation support
- * 0 - no CCMP encryption; 1 - CCMP encryption */
-#define TX_CMD_FLG_AGG_CCMP_MSK cpu_to_le32(1 << 22)
-
-/* HCCA-AP - disable duration overwriting. */
-#define TX_CMD_FLG_DUR_MSK cpu_to_le32(1 << 25)
-
-/*
- * TX command security control
- */
-#define TX_CMD_SEC_WEP         0x01
-#define TX_CMD_SEC_CCM         0x02
-#define TX_CMD_SEC_TKIP                0x03
-#define TX_CMD_SEC_MSK         0x03
-#define TX_CMD_SEC_SHIFT       6
-#define TX_CMD_SEC_KEY128      0x08
-
-/*
- * C_TX = 0x1c (command)
- */
-
-struct il3945_tx_cmd {
-       /*
-        * MPDU byte count:
-        * MAC header (24/26/30/32 bytes) + 2 bytes pad if 26/30 header size,
-        * + 8 byte IV for CCM or TKIP (not used for WEP)
-        * + Data payload
-        * + 8-byte MIC (not used for CCM/WEP)
-        * NOTE:  Does not include Tx command bytes, post-MAC pad bytes,
-        *        MIC (CCM) 8 bytes, ICV (WEP/TKIP/CKIP) 4 bytes, CRC 4 bytes.i
-        * Range: 14-2342 bytes.
-        */
-       __le16 len;
-
-       /*
-        * MPDU or MSDU byte count for next frame.
-        * Used for fragmentation and bursting, but not 11n aggregation.
-        * Same as "len", but for next frame.  Set to 0 if not applicable.
-        */
-       __le16 next_frame_len;
-
-       __le32 tx_flags;        /* TX_CMD_FLG_* */
-
-       u8 rate;
-
-       /* Index of recipient station in uCode's station table */
-       u8 sta_id;
-       u8 tid_tspec;
-       u8 sec_ctl;
-       u8 key[16];
-       union {
-               u8 byte[8];
-               __le16 word[4];
-               __le32 dw[2];
-       } tkip_mic;
-       __le32 next_frame_info;
-       union {
-               __le32 life_time;
-               __le32 attempt;
-       } stop_time;
-       u8 supp_rates[2];
-       u8 rts_retry_limit;     /*byte 50 */
-       u8 data_retry_limit;    /*byte 51 */
-       union {
-               __le16 pm_frame_timeout;
-               __le16 attempt_duration;
-       } timeout;
-
-       /*
-        * Duration of EDCA burst Tx Opportunity, in 32-usec units.
-        * Set this if txop time is not specified by HCCA protocol (e.g. by AP).
-        */
-       __le16 driver_txop;
-
-       /*
-        * MAC header goes here, followed by 2 bytes padding if MAC header
-        * length is 26 or 30 bytes, followed by payload data
-        */
-       u8 payload[0];
-       struct ieee80211_hdr hdr[0];
-} __packed;
-
-/*
- * C_TX = 0x1c (response)
- */
-struct il3945_tx_resp {
-       u8 failure_rts;
-       u8 failure_frame;
-       u8 bt_kill_count;
-       u8 rate;
-       __le32 wireless_media_time;
-       __le32 status;          /* TX status */
-} __packed;
-
-/*
- * 4965 uCode updates these Tx attempt count values in host DRAM.
- * Used for managing Tx retries when expecting block-acks.
- * Driver should set these fields to 0.
- */
-struct il_dram_scratch {
-       u8 try_cnt;             /* Tx attempts */
-       u8 bt_kill_cnt;         /* Tx attempts blocked by Bluetooth device */
-       __le16 reserved;
-} __packed;
-
-struct il_tx_cmd {
-       /*
-        * MPDU byte count:
-        * MAC header (24/26/30/32 bytes) + 2 bytes pad if 26/30 header size,
-        * + 8 byte IV for CCM or TKIP (not used for WEP)
-        * + Data payload
-        * + 8-byte MIC (not used for CCM/WEP)
-        * NOTE:  Does not include Tx command bytes, post-MAC pad bytes,
-        *        MIC (CCM) 8 bytes, ICV (WEP/TKIP/CKIP) 4 bytes, CRC 4 bytes.i
-        * Range: 14-2342 bytes.
-        */
-       __le16 len;
-
-       /*
-        * MPDU or MSDU byte count for next frame.
-        * Used for fragmentation and bursting, but not 11n aggregation.
-        * Same as "len", but for next frame.  Set to 0 if not applicable.
-        */
-       __le16 next_frame_len;
-
-       __le32 tx_flags;        /* TX_CMD_FLG_* */
-
-       /* uCode may modify this field of the Tx command (in host DRAM!).
-        * Driver must also set dram_lsb_ptr and dram_msb_ptr in this cmd. */
-       struct il_dram_scratch scratch;
-
-       /* Rate for *all* Tx attempts, if TX_CMD_FLG_STA_RATE_MSK is cleared. */
-       __le32 rate_n_flags;    /* RATE_MCS_* */
-
-       /* Index of destination station in uCode's station table */
-       u8 sta_id;
-
-       /* Type of security encryption:  CCM or TKIP */
-       u8 sec_ctl;             /* TX_CMD_SEC_* */
-
-       /*
-        * Index into rate table (see C_TX_LINK_QUALITY_CMD) for initial
-        * Tx attempt, if TX_CMD_FLG_STA_RATE_MSK is set.  Normally "0" for
-        * data frames, this field may be used to selectively reduce initial
-        * rate (via non-0 value) for special frames (e.g. management), while
-        * still supporting rate scaling for all frames.
-        */
-       u8 initial_rate_idx;
-       u8 reserved;
-       u8 key[16];
-       __le16 next_frame_flags;
-       __le16 reserved2;
-       union {
-               __le32 life_time;
-               __le32 attempt;
-       } stop_time;
-
-       /* Host DRAM physical address pointer to "scratch" in this command.
-        * Must be dword aligned.  "0" in dram_lsb_ptr disables usage. */
-       __le32 dram_lsb_ptr;
-       u8 dram_msb_ptr;
-
-       u8 rts_retry_limit;     /*byte 50 */
-       u8 data_retry_limit;    /*byte 51 */
-       u8 tid_tspec;
-       union {
-               __le16 pm_frame_timeout;
-               __le16 attempt_duration;
-       } timeout;
-
-       /*
-        * Duration of EDCA burst Tx Opportunity, in 32-usec units.
-        * Set this if txop time is not specified by HCCA protocol (e.g. by AP).
-        */
-       __le16 driver_txop;
-
-       /*
-        * MAC header goes here, followed by 2 bytes padding if MAC header
-        * length is 26 or 30 bytes, followed by payload data
-        */
-       u8 payload[0];
-       struct ieee80211_hdr hdr[0];
-} __packed;
-
-/* TX command response is sent after *3945* transmission attempts.
- *
- * NOTES:
- *
- * TX_STATUS_FAIL_NEXT_FRAG
- *
- * If the fragment flag in the MAC header for the frame being transmitted
- * is set and there is insufficient time to transmit the next frame, the
- * TX status will be returned with 'TX_STATUS_FAIL_NEXT_FRAG'.
- *
- * TX_STATUS_FIFO_UNDERRUN
- *
- * Indicates the host did not provide bytes to the FIFO fast enough while
- * a TX was in progress.
- *
- * TX_STATUS_FAIL_MGMNT_ABORT
- *
- * This status is only possible if the ABORT ON MGMT RX parameter was
- * set to true with the TX command.
- *
- * If the MSB of the status parameter is set then an abort sequence is
- * required.  This sequence consists of the host activating the TX Abort
- * control line, and then waiting for the TX Abort command response.  This
- * indicates that a the device is no longer in a transmit state, and that the
- * command FIFO has been cleared.  The host must then deactivate the TX Abort
- * control line.  Receiving is still allowed in this case.
- */
-enum {
-       TX_3945_STATUS_SUCCESS = 0x01,
-       TX_3945_STATUS_DIRECT_DONE = 0x02,
-       TX_3945_STATUS_FAIL_SHORT_LIMIT = 0x82,
-       TX_3945_STATUS_FAIL_LONG_LIMIT = 0x83,
-       TX_3945_STATUS_FAIL_FIFO_UNDERRUN = 0x84,
-       TX_3945_STATUS_FAIL_MGMNT_ABORT = 0x85,
-       TX_3945_STATUS_FAIL_NEXT_FRAG = 0x86,
-       TX_3945_STATUS_FAIL_LIFE_EXPIRE = 0x87,
-       TX_3945_STATUS_FAIL_DEST_PS = 0x88,
-       TX_3945_STATUS_FAIL_ABORTED = 0x89,
-       TX_3945_STATUS_FAIL_BT_RETRY = 0x8a,
-       TX_3945_STATUS_FAIL_STA_INVALID = 0x8b,
-       TX_3945_STATUS_FAIL_FRAG_DROPPED = 0x8c,
-       TX_3945_STATUS_FAIL_TID_DISABLE = 0x8d,
-       TX_3945_STATUS_FAIL_FRAME_FLUSHED = 0x8e,
-       TX_3945_STATUS_FAIL_INSUFFICIENT_CF_POLL = 0x8f,
-       TX_3945_STATUS_FAIL_TX_LOCKED = 0x90,
-       TX_3945_STATUS_FAIL_NO_BEACON_ON_RADAR = 0x91,
-};
-
-/*
- * TX command response is sent after *4965* transmission attempts.
- *
- * both postpone and abort status are expected behavior from uCode. there is
- * no special operation required from driver; except for RFKILL_FLUSH,
- * which required tx flush host command to flush all the tx frames in queues
- */
-enum {
-       TX_STATUS_SUCCESS = 0x01,
-       TX_STATUS_DIRECT_DONE = 0x02,
-       /* postpone TX */
-       TX_STATUS_POSTPONE_DELAY = 0x40,
-       TX_STATUS_POSTPONE_FEW_BYTES = 0x41,
-       TX_STATUS_POSTPONE_QUIET_PERIOD = 0x43,
-       TX_STATUS_POSTPONE_CALC_TTAK = 0x44,
-       /* abort TX */
-       TX_STATUS_FAIL_INTERNAL_CROSSED_RETRY = 0x81,
-       TX_STATUS_FAIL_SHORT_LIMIT = 0x82,
-       TX_STATUS_FAIL_LONG_LIMIT = 0x83,
-       TX_STATUS_FAIL_FIFO_UNDERRUN = 0x84,
-       TX_STATUS_FAIL_DRAIN_FLOW = 0x85,
-       TX_STATUS_FAIL_RFKILL_FLUSH = 0x86,
-       TX_STATUS_FAIL_LIFE_EXPIRE = 0x87,
-       TX_STATUS_FAIL_DEST_PS = 0x88,
-       TX_STATUS_FAIL_HOST_ABORTED = 0x89,
-       TX_STATUS_FAIL_BT_RETRY = 0x8a,
-       TX_STATUS_FAIL_STA_INVALID = 0x8b,
-       TX_STATUS_FAIL_FRAG_DROPPED = 0x8c,
-       TX_STATUS_FAIL_TID_DISABLE = 0x8d,
-       TX_STATUS_FAIL_FIFO_FLUSHED = 0x8e,
-       TX_STATUS_FAIL_INSUFFICIENT_CF_POLL = 0x8f,
-       TX_STATUS_FAIL_PASSIVE_NO_RX = 0x90,
-       TX_STATUS_FAIL_NO_BEACON_ON_RADAR = 0x91,
-};
-
-#define        TX_PACKET_MODE_REGULAR          0x0000
-#define        TX_PACKET_MODE_BURST_SEQ        0x0100
-#define        TX_PACKET_MODE_BURST_FIRST      0x0200
-
-enum {
-       TX_POWER_PA_NOT_ACTIVE = 0x0,
-};
-
-enum {
-       TX_STATUS_MSK = 0x000000ff,     /* bits 0:7 */
-       TX_STATUS_DELAY_MSK = 0x00000040,
-       TX_STATUS_ABORT_MSK = 0x00000080,
-       TX_PACKET_MODE_MSK = 0x0000ff00,        /* bits 8:15 */
-       TX_FIFO_NUMBER_MSK = 0x00070000,        /* bits 16:18 */
-       TX_RESERVED = 0x00780000,       /* bits 19:22 */
-       TX_POWER_PA_DETECT_MSK = 0x7f800000,    /* bits 23:30 */
-       TX_ABORT_REQUIRED_MSK = 0x80000000,     /* bits 31:31 */
-};
-
-/* *******************************
- * TX aggregation status
- ******************************* */
-
-enum {
-       AGG_TX_STATE_TRANSMITTED = 0x00,
-       AGG_TX_STATE_UNDERRUN_MSK = 0x01,
-       AGG_TX_STATE_FEW_BYTES_MSK = 0x04,
-       AGG_TX_STATE_ABORT_MSK = 0x08,
-       AGG_TX_STATE_LAST_SENT_TTL_MSK = 0x10,
-       AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK = 0x20,
-       AGG_TX_STATE_SCD_QUERY_MSK = 0x80,
-       AGG_TX_STATE_TEST_BAD_CRC32_MSK = 0x100,
-       AGG_TX_STATE_RESPONSE_MSK = 0x1ff,
-       AGG_TX_STATE_DUMP_TX_MSK = 0x200,
-       AGG_TX_STATE_DELAY_TX_MSK = 0x400
-};
-
-#define AGG_TX_STATUS_MSK      0x00000fff      /* bits 0:11 */
-#define AGG_TX_TRY_MSK         0x0000f000      /* bits 12:15 */
-
-#define AGG_TX_STATE_LAST_SENT_MSK  (AGG_TX_STATE_LAST_SENT_TTL_MSK | \
-                                    AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK)
-
-/* # tx attempts for first frame in aggregation */
-#define AGG_TX_STATE_TRY_CNT_POS 12
-#define AGG_TX_STATE_TRY_CNT_MSK 0xf000
-
-/* Command ID and sequence number of Tx command for this frame */
-#define AGG_TX_STATE_SEQ_NUM_POS 16
-#define AGG_TX_STATE_SEQ_NUM_MSK 0xffff0000
-
-/*
- * C_TX = 0x1c (response)
- *
- * This response may be in one of two slightly different formats, indicated
- * by the frame_count field:
- *
- * 1)  No aggregation (frame_count == 1).  This reports Tx results for
- *     a single frame.  Multiple attempts, at various bit rates, may have
- *     been made for this frame.
- *
- * 2)  Aggregation (frame_count > 1).  This reports Tx results for
- *     2 or more frames that used block-acknowledge.  All frames were
- *     transmitted at same rate.  Rate scaling may have been used if first
- *     frame in this new agg block failed in previous agg block(s).
- *
- *     Note that, for aggregation, ACK (block-ack) status is not delivered here;
- *     block-ack has not been received by the time the 4965 device records
- *     this status.
- *     This status relates to reasons the tx might have been blocked or aborted
- *     within the sending station (this 4965 device), rather than whether it was
- *     received successfully by the destination station.
- */
-struct agg_tx_status {
-       __le16 status;
-       __le16 sequence;
-} __packed;
-
-struct il4965_tx_resp {
-       u8 frame_count;         /* 1 no aggregation, >1 aggregation */
-       u8 bt_kill_count;       /* # blocked by bluetooth (unused for agg) */
-       u8 failure_rts;         /* # failures due to unsuccessful RTS */
-       u8 failure_frame;       /* # failures due to no ACK (unused for agg) */
-
-       /* For non-agg:  Rate at which frame was successful.
-        * For agg:  Rate at which all frames were transmitted. */
-       __le32 rate_n_flags;    /* RATE_MCS_*  */
-
-       /* For non-agg:  RTS + CTS + frame tx attempts time + ACK.
-        * For agg:  RTS + CTS + aggregation tx time + block-ack time. */
-       __le16 wireless_media_time;     /* uSecs */
-
-       __le16 reserved;
-       __le32 pa_power1;       /* RF power amplifier measurement (not used) */
-       __le32 pa_power2;
-
-       /*
-        * For non-agg:  frame status TX_STATUS_*
-        * For agg:  status of 1st frame, AGG_TX_STATE_*; other frame status
-        *           fields follow this one, up to frame_count.
-        *           Bit fields:
-        *           11- 0:  AGG_TX_STATE_* status code
-        *           15-12:  Retry count for 1st frame in aggregation (retries
-        *                   occur if tx failed for this frame when it was a
-        *                   member of a previous aggregation block).  If rate
-        *                   scaling is used, retry count indicates the rate
-        *                   table entry used for all frames in the new agg.
-        *           31-16:  Sequence # for this frame's Tx cmd (not SSN!)
-        */
-       union {
-               __le32 status;
-               struct agg_tx_status agg_status[0];     /* for each agg frame */
-       } u;
-} __packed;
-
-/*
- * N_COMPRESSED_BA = 0xc5 (response only, not a command)
- *
- * Reports Block-Acknowledge from recipient station
- */
-struct il_compressed_ba_resp {
-       __le32 sta_addr_lo32;
-       __le16 sta_addr_hi16;
-       __le16 reserved;
-
-       /* Index of recipient (BA-sending) station in uCode's station table */
-       u8 sta_id;
-       u8 tid;
-       __le16 seq_ctl;
-       __le64 bitmap;
-       __le16 scd_flow;
-       __le16 scd_ssn;
-} __packed;
-
-/*
- * C_TX_PWR_TBL = 0x97 (command, has simple generic response)
- *
- * See details under "TXPOWER" in 4965.h.
- */
-
-struct il3945_txpowertable_cmd {
-       u8 band;                /* 0: 5 GHz, 1: 2.4 GHz */
-       u8 reserved;
-       __le16 channel;
-       struct il3945_power_per_rate power[IL_MAX_RATES];
-} __packed;
-
-struct il4965_txpowertable_cmd {
-       u8 band;                /* 0: 5 GHz, 1: 2.4 GHz */
-       u8 reserved;
-       __le16 channel;
-       struct il4965_tx_power_db tx_power;
-} __packed;
-
-/**
- * struct il3945_rate_scaling_cmd - Rate Scaling Command & Response
- *
- * C_RATE_SCALE = 0x47 (command, has simple generic response)
- *
- * NOTE: The table of rates passed to the uCode via the
- * RATE_SCALE command sets up the corresponding order of
- * rates used for all related commands, including rate
- * masks, etc.
- *
- * For example, if you set 9MB (PLCP 0x0f) as the first
- * rate in the rate table, the bit mask for that rate
- * when passed through ofdm_basic_rates on the C_RXON
- * command would be bit 0 (1 << 0)
- */
-struct il3945_rate_scaling_info {
-       __le16 rate_n_flags;
-       u8 try_cnt;
-       u8 next_rate_idx;
-} __packed;
-
-struct il3945_rate_scaling_cmd {
-       u8 table_id;
-       u8 reserved[3];
-       struct il3945_rate_scaling_info table[IL_MAX_RATES];
-} __packed;
-
-/*RS_NEW_API: only TLC_RTS remains and moved to bit 0 */
-#define  LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK   (1 << 0)
-
-/* # of EDCA prioritized tx fifos */
-#define  LINK_QUAL_AC_NUM AC_NUM
-
-/* # entries in rate scale table to support Tx retries */
-#define  LINK_QUAL_MAX_RETRY_NUM 16
-
-/* Tx antenna selection values */
-#define  LINK_QUAL_ANT_A_MSK (1 << 0)
-#define  LINK_QUAL_ANT_B_MSK (1 << 1)
-#define  LINK_QUAL_ANT_MSK   (LINK_QUAL_ANT_A_MSK|LINK_QUAL_ANT_B_MSK)
-
-/**
- * struct il_link_qual_general_params
- *
- * Used in C_TX_LINK_QUALITY_CMD
- */
-struct il_link_qual_general_params {
-       u8 flags;
-
-       /* No entries at or above this (driver chosen) idx contain MIMO */
-       u8 mimo_delimiter;
-
-       /* Best single antenna to use for single stream (legacy, SISO). */
-       u8 single_stream_ant_msk;       /* LINK_QUAL_ANT_* */
-
-       /* Best antennas to use for MIMO (unused for 4965, assumes both). */
-       u8 dual_stream_ant_msk; /* LINK_QUAL_ANT_* */
-
-       /*
-        * If driver needs to use different initial rates for different
-        * EDCA QOS access categories (as implemented by tx fifos 0-3),
-        * this table will set that up, by indicating the idxes in the
-        * rs_table[LINK_QUAL_MAX_RETRY_NUM] rate table at which to start.
-        * Otherwise, driver should set all entries to 0.
-        *
-        * Entry usage:
-        * 0 = Background, 1 = Best Effort (normal), 2 = Video, 3 = Voice
-        * TX FIFOs above 3 use same value (typically 0) as TX FIFO 3.
-        */
-       u8 start_rate_idx[LINK_QUAL_AC_NUM];
-} __packed;
-
-#define LINK_QUAL_AGG_TIME_LIMIT_DEF   (4000)  /* 4 milliseconds */
-#define LINK_QUAL_AGG_TIME_LIMIT_MAX   (8000)
-#define LINK_QUAL_AGG_TIME_LIMIT_MIN   (100)
-
-#define LINK_QUAL_AGG_DISABLE_START_DEF        (3)
-#define LINK_QUAL_AGG_DISABLE_START_MAX        (255)
-#define LINK_QUAL_AGG_DISABLE_START_MIN        (0)
-
-#define LINK_QUAL_AGG_FRAME_LIMIT_DEF  (31)
-#define LINK_QUAL_AGG_FRAME_LIMIT_MAX  (63)
-#define LINK_QUAL_AGG_FRAME_LIMIT_MIN  (0)
-
-/**
- * struct il_link_qual_agg_params
- *
- * Used in C_TX_LINK_QUALITY_CMD
- */
-struct il_link_qual_agg_params {
-
-       /*
-        *Maximum number of uSec in aggregation.
-        * default set to 4000 (4 milliseconds) if not configured in .cfg
-        */
-       __le16 agg_time_limit;
-
-       /*
-        * Number of Tx retries allowed for a frame, before that frame will
-        * no longer be considered for the start of an aggregation sequence
-        * (scheduler will then try to tx it as single frame).
-        * Driver should set this to 3.
-        */
-       u8 agg_dis_start_th;
-
-       /*
-        * Maximum number of frames in aggregation.
-        * 0 = no limit (default).  1 = no aggregation.
-        * Other values = max # frames in aggregation.
-        */
-       u8 agg_frame_cnt_limit;
-
-       __le32 reserved;
-} __packed;
-
-/*
- * C_TX_LINK_QUALITY_CMD = 0x4e (command, has simple generic response)
- *
- * For 4965 devices only; 3945 uses C_RATE_SCALE.
- *
- * Each station in the 4965 device's internal station table has its own table
- * of 16
- * Tx rates and modulation modes (e.g. legacy/SISO/MIMO) for retrying Tx when
- * an ACK is not received.  This command replaces the entire table for
- * one station.
- *
- * NOTE:  Station must already be in 4965 device's station table.
- *       Use C_ADD_STA.
- *
- * The rate scaling procedures described below work well.  Of course, other
- * procedures are possible, and may work better for particular environments.
- *
- *
- * FILLING THE RATE TBL
- *
- * Given a particular initial rate and mode, as determined by the rate
- * scaling algorithm described below, the Linux driver uses the following
- * formula to fill the rs_table[LINK_QUAL_MAX_RETRY_NUM] rate table in the
- * Link Quality command:
- *
- *
- * 1)  If using High-throughput (HT) (SISO or MIMO) initial rate:
- *     a) Use this same initial rate for first 3 entries.
- *     b) Find next lower available rate using same mode (SISO or MIMO),
- *        use for next 3 entries.  If no lower rate available, switch to
- *        legacy mode (no HT40 channel, no MIMO, no short guard interval).
- *     c) If using MIMO, set command's mimo_delimiter to number of entries
- *        using MIMO (3 or 6).
- *     d) After trying 2 HT rates, switch to legacy mode (no HT40 channel,
- *        no MIMO, no short guard interval), at the next lower bit rate
- *        (e.g. if second HT bit rate was 54, try 48 legacy), and follow
- *        legacy procedure for remaining table entries.
- *
- * 2)  If using legacy initial rate:
- *     a) Use the initial rate for only one entry.
- *     b) For each following entry, reduce the rate to next lower available
- *        rate, until reaching the lowest available rate.
- *     c) When reducing rate, also switch antenna selection.
- *     d) Once lowest available rate is reached, repeat this rate until
- *        rate table is filled (16 entries), switching antenna each entry.
- *
- *
- * ACCUMULATING HISTORY
- *
- * The rate scaling algorithm for 4965 devices, as implemented in Linux driver,
- * uses two sets of frame Tx success history:  One for the current/active
- * modulation mode, and one for a speculative/search mode that is being
- * attempted. If the speculative mode turns out to be more effective (i.e.
- * actual transfer rate is better), then the driver continues to use the
- * speculative mode as the new current active mode.
- *
- * Each history set contains, separately for each possible rate, data for a
- * sliding win of the 62 most recent tx attempts at that rate.  The data
- * includes a shifting bitmap of success(1)/failure(0), and sums of successful
- * and attempted frames, from which the driver can additionally calculate a
- * success ratio (success / attempted) and number of failures
- * (attempted - success), and control the size of the win (attempted).
- * The driver uses the bit map to remove successes from the success sum, as
- * the oldest tx attempts fall out of the win.
- *
- * When the 4965 device makes multiple tx attempts for a given frame, each
- * attempt might be at a different rate, and have different modulation
- * characteristics (e.g. antenna, fat channel, short guard interval), as set
- * up in the rate scaling table in the Link Quality command.  The driver must
- * determine which rate table entry was used for each tx attempt, to determine
- * which rate-specific history to update, and record only those attempts that
- * match the modulation characteristics of the history set.
- *
- * When using block-ack (aggregation), all frames are transmitted at the same
- * rate, since there is no per-attempt acknowledgment from the destination
- * station.  The Tx response struct il_tx_resp indicates the Tx rate in
- * rate_n_flags field.  After receiving a block-ack, the driver can update
- * history for the entire block all at once.
- *
- *
- * FINDING BEST STARTING RATE:
- *
- * When working with a selected initial modulation mode (see below), the
- * driver attempts to find a best initial rate.  The initial rate is the
- * first entry in the Link Quality command's rate table.
- *
- * 1)  Calculate actual throughput (success ratio * expected throughput, see
- *     table below) for current initial rate.  Do this only if enough frames
- *     have been attempted to make the value meaningful:  at least 6 failed
- *     tx attempts, or at least 8 successes.  If not enough, don't try rate
- *     scaling yet.
- *
- * 2)  Find available rates adjacent to current initial rate.  Available means:
- *     a)  supported by hardware &&
- *     b)  supported by association &&
- *     c)  within any constraints selected by user
- *
- * 3)  Gather measured throughputs for adjacent rates.  These might not have
- *     enough history to calculate a throughput.  That's okay, we might try
- *     using one of them anyway!
- *
- * 4)  Try decreasing rate if, for current rate:
- *     a)  success ratio is < 15% ||
- *     b)  lower adjacent rate has better measured throughput ||
- *     c)  higher adjacent rate has worse throughput, and lower is unmeasured
- *
- *     As a sanity check, if decrease was determined above, leave rate
- *     unchanged if:
- *     a)  lower rate unavailable
- *     b)  success ratio at current rate > 85% (very good)
- *     c)  current measured throughput is better than expected throughput
- *         of lower rate (under perfect 100% tx conditions, see table below)
- *
- * 5)  Try increasing rate if, for current rate:
- *     a)  success ratio is < 15% ||
- *     b)  both adjacent rates' throughputs are unmeasured (try it!) ||
- *     b)  higher adjacent rate has better measured throughput ||
- *     c)  lower adjacent rate has worse throughput, and higher is unmeasured
- *
- *     As a sanity check, if increase was determined above, leave rate
- *     unchanged if:
- *     a)  success ratio at current rate < 70%.  This is not particularly
- *         good performance; higher rate is sure to have poorer success.
- *
- * 6)  Re-evaluate the rate after each tx frame.  If working with block-
- *     acknowledge, history and stats may be calculated for the entire
- *     block (including prior history that fits within the history wins),
- *     before re-evaluation.
- *
- * FINDING BEST STARTING MODULATION MODE:
- *
- * After working with a modulation mode for a "while" (and doing rate scaling),
- * the driver searches for a new initial mode in an attempt to improve
- * throughput.  The "while" is measured by numbers of attempted frames:
- *
- * For legacy mode, search for new mode after:
- *   480 successful frames, or 160 failed frames
- * For high-throughput modes (SISO or MIMO), search for new mode after:
- *   4500 successful frames, or 400 failed frames
- *
- * Mode switch possibilities are (3 for each mode):
- *
- * For legacy:
- *   Change antenna, try SISO (if HT association), try MIMO (if HT association)
- * For SISO:
- *   Change antenna, try MIMO, try shortened guard interval (SGI)
- * For MIMO:
- *   Try SISO antenna A, SISO antenna B, try shortened guard interval (SGI)
- *
- * When trying a new mode, use the same bit rate as the old/current mode when
- * trying antenna switches and shortened guard interval.  When switching to
- * SISO from MIMO or legacy, or to MIMO from SISO or legacy, use a rate
- * for which the expected throughput (under perfect conditions) is about the
- * same or slightly better than the actual measured throughput delivered by
- * the old/current mode.
- *
- * Actual throughput can be estimated by multiplying the expected throughput
- * by the success ratio (successful / attempted tx frames).  Frame size is
- * not considered in this calculation; it assumes that frame size will average
- * out to be fairly consistent over several samples.  The following are
- * metric values for expected throughput assuming 100% success ratio.
- * Only G band has support for CCK rates:
- *
- *           RATE:  1    2    5   11    6   9   12   18   24   36   48   54   60
- *
- *              G:  7   13   35   58   40  57   72   98  121  154  177  186  186
- *              A:  0    0    0    0   40  57   72   98  121  154  177  186  186
- *     SISO 20MHz:  0    0    0    0   42  42   76  102  124  159  183  193  202
- * SGI SISO 20MHz:  0    0    0    0   46  46   82  110  132  168  192  202  211
- *     MIMO 20MHz:  0    0    0    0   74  74  123  155  179  214  236  244  251
- * SGI MIMO 20MHz:  0    0    0    0   81  81  131  164  188  222  243  251  257
- *     SISO 40MHz:  0    0    0    0   77  77  127  160  184  220  242  250  257
- * SGI SISO 40MHz:  0    0    0    0   83  83  135  169  193  229  250  257  264
- *     MIMO 40MHz:  0    0    0    0  123 123  182  214  235  264  279  285  289
- * SGI MIMO 40MHz:  0    0    0    0  131 131  191  222  242  270  284  289  293
- *
- * After the new mode has been tried for a short while (minimum of 6 failed
- * frames or 8 successful frames), compare success ratio and actual throughput
- * estimate of the new mode with the old.  If either is better with the new
- * mode, continue to use the new mode.
- *
- * Continue comparing modes until all 3 possibilities have been tried.
- * If moving from legacy to HT, try all 3 possibilities from the new HT
- * mode.  After trying all 3, a best mode is found.  Continue to use this mode
- * for the longer "while" described above (e.g. 480 successful frames for
- * legacy), and then repeat the search process.
- *
- */
-struct il_link_quality_cmd {
-
-       /* Index of destination/recipient station in uCode's station table */
-       u8 sta_id;
-       u8 reserved1;
-       __le16 control;         /* not used */
-       struct il_link_qual_general_params general_params;
-       struct il_link_qual_agg_params agg_params;
-
-       /*
-        * Rate info; when using rate-scaling, Tx command's initial_rate_idx
-        * specifies 1st Tx rate attempted, via idx into this table.
-        * 4965 devices works its way through table when retrying Tx.
-        */
-       struct {
-               __le32 rate_n_flags;    /* RATE_MCS_*, RATE_* */
-       } rs_table[LINK_QUAL_MAX_RETRY_NUM];
-       __le32 reserved2;
-} __packed;
-
-/*
- * BT configuration enable flags:
- *   bit 0 - 1: BT channel announcement enabled
- *           0: disable
- *   bit 1 - 1: priority of BT device enabled
- *           0: disable
- */
-#define BT_COEX_DISABLE (0x0)
-#define BT_ENABLE_CHANNEL_ANNOUNCE BIT(0)
-#define BT_ENABLE_PRIORITY        BIT(1)
-
-#define BT_COEX_ENABLE  (BT_ENABLE_CHANNEL_ANNOUNCE | BT_ENABLE_PRIORITY)
-
-#define BT_LEAD_TIME_DEF (0x1E)
-
-#define BT_MAX_KILL_DEF (0x5)
-
-/*
- * C_BT_CONFIG = 0x9b (command, has simple generic response)
- *
- * 3945 and 4965 devices support hardware handshake with Bluetooth device on
- * same platform.  Bluetooth device alerts wireless device when it will Tx;
- * wireless device can delay or kill its own Tx to accommodate.
- */
-struct il_bt_cmd {
-       u8 flags;
-       u8 lead_time;
-       u8 max_kill;
-       u8 reserved;
-       __le32 kill_ack_mask;
-       __le32 kill_cts_mask;
-} __packed;
-
-/******************************************************************************
- * (6)
- * Spectrum Management (802.11h) Commands, Responses, Notifications:
- *
- *****************************************************************************/
-
-/*
- * Spectrum Management
- */
-#define MEASUREMENT_FILTER_FLAG (RXON_FILTER_PROMISC_MSK         | \
-                                RXON_FILTER_CTL2HOST_MSK        | \
-                                RXON_FILTER_ACCEPT_GRP_MSK      | \
-                                RXON_FILTER_DIS_DECRYPT_MSK     | \
-                                RXON_FILTER_DIS_GRP_DECRYPT_MSK | \
-                                RXON_FILTER_ASSOC_MSK           | \
-                                RXON_FILTER_BCON_AWARE_MSK)
-
-struct il_measure_channel {
-       __le32 duration;        /* measurement duration in extended beacon
-                                * format */
-       u8 channel;             /* channel to measure */
-       u8 type;                /* see enum il_measure_type */
-       __le16 reserved;
-} __packed;
-
-/*
- * C_SPECTRUM_MEASUREMENT = 0x74 (command)
- */
-struct il_spectrum_cmd {
-       __le16 len;             /* number of bytes starting from token */
-       u8 token;               /* token id */
-       u8 id;                  /* measurement id -- 0 or 1 */
-       u8 origin;              /* 0 = TGh, 1 = other, 2 = TGk */
-       u8 periodic;            /* 1 = periodic */
-       __le16 path_loss_timeout;
-       __le32 start_time;      /* start time in extended beacon format */
-       __le32 reserved2;
-       __le32 flags;           /* rxon flags */
-       __le32 filter_flags;    /* rxon filter flags */
-       __le16 channel_count;   /* minimum 1, maximum 10 */
-       __le16 reserved3;
-       struct il_measure_channel channels[10];
-} __packed;
-
-/*
- * C_SPECTRUM_MEASUREMENT = 0x74 (response)
- */
-struct il_spectrum_resp {
-       u8 token;
-       u8 id;                  /* id of the prior command replaced, or 0xff */
-       __le16 status;          /* 0 - command will be handled
-                                * 1 - cannot handle (conflicts with another
-                                *     measurement) */
-} __packed;
-
-enum il_measurement_state {
-       IL_MEASUREMENT_START = 0,
-       IL_MEASUREMENT_STOP = 1,
-};
-
-enum il_measurement_status {
-       IL_MEASUREMENT_OK = 0,
-       IL_MEASUREMENT_CONCURRENT = 1,
-       IL_MEASUREMENT_CSA_CONFLICT = 2,
-       IL_MEASUREMENT_TGH_CONFLICT = 3,
-       /* 4-5 reserved */
-       IL_MEASUREMENT_STOPPED = 6,
-       IL_MEASUREMENT_TIMEOUT = 7,
-       IL_MEASUREMENT_PERIODIC_FAILED = 8,
-};
-
-#define NUM_ELEMENTS_IN_HISTOGRAM 8
-
-struct il_measurement_histogram {
-       __le32 ofdm[NUM_ELEMENTS_IN_HISTOGRAM]; /* in 0.8usec counts */
-       __le32 cck[NUM_ELEMENTS_IN_HISTOGRAM];  /* in 1usec counts */
-} __packed;
-
-/* clear channel availability counters */
-struct il_measurement_cca_counters {
-       __le32 ofdm;
-       __le32 cck;
-} __packed;
-
-enum il_measure_type {
-       IL_MEASURE_BASIC = (1 << 0),
-       IL_MEASURE_CHANNEL_LOAD = (1 << 1),
-       IL_MEASURE_HISTOGRAM_RPI = (1 << 2),
-       IL_MEASURE_HISTOGRAM_NOISE = (1 << 3),
-       IL_MEASURE_FRAME = (1 << 4),
-       /* bits 5:6 are reserved */
-       IL_MEASURE_IDLE = (1 << 7),
-};
-
-/*
- * N_SPECTRUM_MEASUREMENT = 0x75 (notification only, not a command)
- */
-struct il_spectrum_notification {
-       u8 id;                  /* measurement id -- 0 or 1 */
-       u8 token;
-       u8 channel_idx;         /* idx in measurement channel list */
-       u8 state;               /* 0 - start, 1 - stop */
-       __le32 start_time;      /* lower 32-bits of TSF */
-       u8 band;                /* 0 - 5.2GHz, 1 - 2.4GHz */
-       u8 channel;
-       u8 type;                /* see enum il_measurement_type */
-       u8 reserved1;
-       /* NOTE:  cca_ofdm, cca_cck, basic_type, and histogram are only only
-        * valid if applicable for measurement type requested. */
-       __le32 cca_ofdm;        /* cca fraction time in 40Mhz clock periods */
-       __le32 cca_cck;         /* cca fraction time in 44Mhz clock periods */
-       __le32 cca_time;        /* channel load time in usecs */
-       u8 basic_type;          /* 0 - bss, 1 - ofdm preamble, 2 -
-                                * unidentified */
-       u8 reserved2[3];
-       struct il_measurement_histogram histogram;
-       __le32 stop_time;       /* lower 32-bits of TSF */
-       __le32 status;          /* see il_measurement_status */
-} __packed;
-
-/******************************************************************************
- * (7)
- * Power Management Commands, Responses, Notifications:
- *
- *****************************************************************************/
-
-/**
- * struct il_powertable_cmd - Power Table Command
- * @flags: See below:
- *
- * C_POWER_TBL = 0x77 (command, has simple generic response)
- *
- * PM allow:
- *   bit 0 - '0' Driver not allow power management
- *           '1' Driver allow PM (use rest of parameters)
- *
- * uCode send sleep notifications:
- *   bit 1 - '0' Don't send sleep notification
- *           '1' send sleep notification (SEND_PM_NOTIFICATION)
- *
- * Sleep over DTIM
- *   bit 2 - '0' PM have to walk up every DTIM
- *           '1' PM could sleep over DTIM till listen Interval.
- *
- * PCI power managed
- *   bit 3 - '0' (PCI_CFG_LINK_CTRL & 0x1)
- *           '1' !(PCI_CFG_LINK_CTRL & 0x1)
- *
- * Fast PD
- *   bit 4 - '1' Put radio to sleep when receiving frame for others
- *
- * Force sleep Modes
- *   bit 31/30- '00' use both mac/xtal sleeps
- *              '01' force Mac sleep
- *              '10' force xtal sleep
- *              '11' Illegal set
- *
- * NOTE: if sleep_interval[SLEEP_INTRVL_TBL_SIZE-1] > DTIM period then
- * ucode assume sleep over DTIM is allowed and we don't need to wake up
- * for every DTIM.
- */
-#define IL_POWER_VEC_SIZE 5
-
-#define IL_POWER_DRIVER_ALLOW_SLEEP_MSK                cpu_to_le16(BIT(0))
-#define IL_POWER_SLEEP_OVER_DTIM_MSK           cpu_to_le16(BIT(2))
-#define IL_POWER_PCI_PM_MSK                    cpu_to_le16(BIT(3))
-
-struct il3945_powertable_cmd {
-       __le16 flags;
-       u8 reserved[2];
-       __le32 rx_data_timeout;
-       __le32 tx_data_timeout;
-       __le32 sleep_interval[IL_POWER_VEC_SIZE];
-} __packed;
-
-struct il_powertable_cmd {
-       __le16 flags;
-       u8 keep_alive_seconds;  /* 3945 reserved */
-       u8 debug_flags;         /* 3945 reserved */
-       __le32 rx_data_timeout;
-       __le32 tx_data_timeout;
-       __le32 sleep_interval[IL_POWER_VEC_SIZE];
-       __le32 keep_alive_beacons;
-} __packed;
-
-/*
- * N_PM_SLEEP = 0x7A (notification only, not a command)
- * all devices identical.
- */
-struct il_sleep_notification {
-       u8 pm_sleep_mode;
-       u8 pm_wakeup_src;
-       __le16 reserved;
-       __le32 sleep_time;
-       __le32 tsf_low;
-       __le32 bcon_timer;
-} __packed;
-
-/* Sleep states.  all devices identical. */
-enum {
-       IL_PM_NO_SLEEP = 0,
-       IL_PM_SLP_MAC = 1,
-       IL_PM_SLP_FULL_MAC_UNASSOCIATE = 2,
-       IL_PM_SLP_FULL_MAC_CARD_STATE = 3,
-       IL_PM_SLP_PHY = 4,
-       IL_PM_SLP_REPENT = 5,
-       IL_PM_WAKEUP_BY_TIMER = 6,
-       IL_PM_WAKEUP_BY_DRIVER = 7,
-       IL_PM_WAKEUP_BY_RFKILL = 8,
-       /* 3 reserved */
-       IL_PM_NUM_OF_MODES = 12,
-};
-
-/*
- * N_CARD_STATE = 0xa1 (notification only, not a command)
- */
-struct il_card_state_notif {
-       __le32 flags;
-} __packed;
-
-#define HW_CARD_DISABLED   0x01
-#define SW_CARD_DISABLED   0x02
-#define CT_CARD_DISABLED   0x04
-#define RXON_CARD_DISABLED 0x10
-
-struct il_ct_kill_config {
-       __le32 reserved;
-       __le32 critical_temperature_M;
-       __le32 critical_temperature_R;
-} __packed;
-
-/******************************************************************************
- * (8)
- * Scan Commands, Responses, Notifications:
- *
- *****************************************************************************/
-
-#define SCAN_CHANNEL_TYPE_PASSIVE cpu_to_le32(0)
-#define SCAN_CHANNEL_TYPE_ACTIVE  cpu_to_le32(1)
-
-/**
- * struct il_scan_channel - entry in C_SCAN channel table
- *
- * One for each channel in the scan list.
- * Each channel can independently select:
- * 1)  SSID for directed active scans
- * 2)  Txpower setting (for rate specified within Tx command)
- * 3)  How long to stay on-channel (behavior may be modified by quiet_time,
- *     quiet_plcp_th, good_CRC_th)
- *
- * To avoid uCode errors, make sure the following are true (see comments
- * under struct il_scan_cmd about max_out_time and quiet_time):
- * 1)  If using passive_dwell (i.e. passive_dwell != 0):
- *     active_dwell <= passive_dwell (< max_out_time if max_out_time != 0)
- * 2)  quiet_time <= active_dwell
- * 3)  If restricting off-channel time (i.e. max_out_time !=0):
- *     passive_dwell < max_out_time
- *     active_dwell < max_out_time
- */
-struct il3945_scan_channel {
-       /*
-        * type is defined as:
-        * 0:0 1 = active, 0 = passive
-        * 1:4 SSID direct bit map; if a bit is set, then corresponding
-        *     SSID IE is transmitted in probe request.
-        * 5:7 reserved
-        */
-       u8 type;
-       u8 channel;             /* band is selected by il3945_scan_cmd "flags" field */
-       struct il3945_tx_power tpc;
-       __le16 active_dwell;    /* in 1024-uSec TU (time units), typ 5-50 */
-       __le16 passive_dwell;   /* in 1024-uSec TU (time units), typ 20-500 */
-} __packed;
-
-/* set number of direct probes u8 type */
-#define IL39_SCAN_PROBE_MASK(n) ((BIT(n) | (BIT(n) - BIT(1))))
-
-struct il_scan_channel {
-       /*
-        * type is defined as:
-        * 0:0 1 = active, 0 = passive
-        * 1:20 SSID direct bit map; if a bit is set, then corresponding
-        *     SSID IE is transmitted in probe request.
-        * 21:31 reserved
-        */
-       __le32 type;
-       __le16 channel;         /* band is selected by il_scan_cmd "flags" field */
-       u8 tx_gain;             /* gain for analog radio */
-       u8 dsp_atten;           /* gain for DSP */
-       __le16 active_dwell;    /* in 1024-uSec TU (time units), typ 5-50 */
-       __le16 passive_dwell;   /* in 1024-uSec TU (time units), typ 20-500 */
-} __packed;
-
-/* set number of direct probes __le32 type */
-#define IL_SCAN_PROBE_MASK(n)  cpu_to_le32((BIT(n) | (BIT(n) - BIT(1))))
-
-/**
- * struct il_ssid_ie - directed scan network information element
- *
- * Up to 20 of these may appear in C_SCAN (Note: Only 4 are in
- * 3945 SCAN api), selected by "type" bit field in struct il_scan_channel;
- * each channel may select different ssids from among the 20 (4) entries.
- * SSID IEs get transmitted in reverse order of entry.
- */
-struct il_ssid_ie {
-       u8 id;
-       u8 len;
-       u8 ssid[32];
-} __packed;
-
-#define PROBE_OPTION_MAX_3945          4
-#define PROBE_OPTION_MAX               20
-#define TX_CMD_LIFE_TIME_INFINITE      cpu_to_le32(0xFFFFFFFF)
-#define IL_GOOD_CRC_TH_DISABLED        0
-#define IL_GOOD_CRC_TH_DEFAULT         cpu_to_le16(1)
-#define IL_GOOD_CRC_TH_NEVER           cpu_to_le16(0xffff)
-#define IL_MAX_SCAN_SIZE 1024
-#define IL_MAX_CMD_SIZE 4096
-
-/*
- * C_SCAN = 0x80 (command)
- *
- * The hardware scan command is very powerful; the driver can set it up to
- * maintain (relatively) normal network traffic while doing a scan in the
- * background.  The max_out_time and suspend_time control the ratio of how
- * long the device stays on an associated network channel ("service channel")
- * vs. how long it's away from the service channel, i.e. tuned to other channels
- * for scanning.
- *
- * max_out_time is the max time off-channel (in usec), and suspend_time
- * is how long (in "extended beacon" format) that the scan is "suspended"
- * after returning to the service channel.  That is, suspend_time is the
- * time that we stay on the service channel, doing normal work, between
- * scan segments.  The driver may set these parameters differently to support
- * scanning when associated vs. not associated, and light vs. heavy traffic
- * loads when associated.
- *
- * After receiving this command, the device's scan engine does the following;
- *
- * 1)  Sends SCAN_START notification to driver
- * 2)  Checks to see if it has time to do scan for one channel
- * 3)  Sends NULL packet, with power-save (PS) bit set to 1,
- *     to tell AP that we're going off-channel
- * 4)  Tunes to first channel in scan list, does active or passive scan
- * 5)  Sends SCAN_RESULT notification to driver
- * 6)  Checks to see if it has time to do scan on *next* channel in list
- * 7)  Repeats 4-6 until it no longer has time to scan the next channel
- *     before max_out_time expires
- * 8)  Returns to service channel
- * 9)  Sends NULL packet with PS=0 to tell AP that we're back
- * 10) Stays on service channel until suspend_time expires
- * 11) Repeats entire process 2-10 until list is complete
- * 12) Sends SCAN_COMPLETE notification
- *
- * For fast, efficient scans, the scan command also has support for staying on
- * a channel for just a short time, if doing active scanning and getting no
- * responses to the transmitted probe request.  This time is controlled by
- * quiet_time, and the number of received packets below which a channel is
- * considered "quiet" is controlled by quiet_plcp_threshold.
- *
- * For active scanning on channels that have regulatory restrictions against
- * blindly transmitting, the scan can listen before transmitting, to make sure
- * that there is already legitimate activity on the channel.  If enough
- * packets are cleanly received on the channel (controlled by good_CRC_th,
- * typical value 1), the scan engine starts transmitting probe requests.
- *
- * Driver must use separate scan commands for 2.4 vs. 5 GHz bands.
- *
- * To avoid uCode errors, see timing restrictions described under
- * struct il_scan_channel.
- */
-
-struct il3945_scan_cmd {
-       __le16 len;
-       u8 reserved0;
-       u8 channel_count;       /* # channels in channel list */
-       __le16 quiet_time;      /* dwell only this # millisecs on quiet channel
-                                * (only for active scan) */
-       __le16 quiet_plcp_th;   /* quiet chnl is < this # pkts (typ. 1) */
-       __le16 good_CRC_th;     /* passive -> active promotion threshold */
-       __le16 reserved1;
-       __le32 max_out_time;    /* max usec to be away from associated (service)
-                                * channel */
-       __le32 suspend_time;    /* pause scan this long (in "extended beacon
-                                * format") when returning to service channel:
-                                * 3945; 31:24 # beacons, 19:0 additional usec,
-                                * 4965; 31:22 # beacons, 21:0 additional usec.
-                                */
-       __le32 flags;           /* RXON_FLG_* */
-       __le32 filter_flags;    /* RXON_FILTER_* */
-
-       /* For active scans (set to all-0s for passive scans).
-        * Does not include payload.  Must specify Tx rate; no rate scaling. */
-       struct il3945_tx_cmd tx_cmd;
-
-       /* For directed active scans (set to all-0s otherwise) */
-       struct il_ssid_ie direct_scan[PROBE_OPTION_MAX_3945];
-
-       /*
-        * Probe request frame, followed by channel list.
-        *
-        * Size of probe request frame is specified by byte count in tx_cmd.
-        * Channel list follows immediately after probe request frame.
-        * Number of channels in list is specified by channel_count.
-        * Each channel in list is of type:
-        *
-        * struct il3945_scan_channel channels[0];
-        *
-        * NOTE:  Only one band of channels can be scanned per pass.  You
-        * must not mix 2.4GHz channels and 5.2GHz channels, and you must wait
-        * for one scan to complete (i.e. receive N_SCAN_COMPLETE)
-        * before requesting another scan.
-        */
-       u8 data[0];
-} __packed;
-
-struct il_scan_cmd {
-       __le16 len;
-       u8 reserved0;
-       u8 channel_count;       /* # channels in channel list */
-       __le16 quiet_time;      /* dwell only this # millisecs on quiet channel
-                                * (only for active scan) */
-       __le16 quiet_plcp_th;   /* quiet chnl is < this # pkts (typ. 1) */
-       __le16 good_CRC_th;     /* passive -> active promotion threshold */
-       __le16 rx_chain;        /* RXON_RX_CHAIN_* */
-       __le32 max_out_time;    /* max usec to be away from associated (service)
-                                * channel */
-       __le32 suspend_time;    /* pause scan this long (in "extended beacon
-                                * format") when returning to service chnl:
-                                * 3945; 31:24 # beacons, 19:0 additional usec,
-                                * 4965; 31:22 # beacons, 21:0 additional usec.
-                                */
-       __le32 flags;           /* RXON_FLG_* */
-       __le32 filter_flags;    /* RXON_FILTER_* */
-
-       /* For active scans (set to all-0s for passive scans).
-        * Does not include payload.  Must specify Tx rate; no rate scaling. */
-       struct il_tx_cmd tx_cmd;
-
-       /* For directed active scans (set to all-0s otherwise) */
-       struct il_ssid_ie direct_scan[PROBE_OPTION_MAX];
-
-       /*
-        * Probe request frame, followed by channel list.
-        *
-        * Size of probe request frame is specified by byte count in tx_cmd.
-        * Channel list follows immediately after probe request frame.
-        * Number of channels in list is specified by channel_count.
-        * Each channel in list is of type:
-        *
-        * struct il_scan_channel channels[0];
-        *
-        * NOTE:  Only one band of channels can be scanned per pass.  You
-        * must not mix 2.4GHz channels and 5.2GHz channels, and you must wait
-        * for one scan to complete (i.e. receive N_SCAN_COMPLETE)
-        * before requesting another scan.
-        */
-       u8 data[0];
-} __packed;
-
-/* Can abort will notify by complete notification with abort status. */
-#define CAN_ABORT_STATUS       cpu_to_le32(0x1)
-/* complete notification statuses */
-#define ABORT_STATUS            0x2
-
-/*
- * C_SCAN = 0x80 (response)
- */
-struct il_scanreq_notification {
-       __le32 status;          /* 1: okay, 2: cannot fulfill request */
-} __packed;
-
-/*
- * N_SCAN_START = 0x82 (notification only, not a command)
- */
-struct il_scanstart_notification {
-       __le32 tsf_low;
-       __le32 tsf_high;
-       __le32 beacon_timer;
-       u8 channel;
-       u8 band;
-       u8 reserved[2];
-       __le32 status;
-} __packed;
-
-#define  SCAN_OWNER_STATUS 0x1
-#define  MEASURE_OWNER_STATUS 0x2
-
-#define IL_PROBE_STATUS_OK             0
-#define IL_PROBE_STATUS_TX_FAILED      BIT(0)
-/* error statuses combined with TX_FAILED */
-#define IL_PROBE_STATUS_FAIL_TTL       BIT(1)
-#define IL_PROBE_STATUS_FAIL_BT        BIT(2)
-
-#define NUMBER_OF_STATS 1      /* first __le32 is good CRC */
-/*
- * N_SCAN_RESULTS = 0x83 (notification only, not a command)
- */
-struct il_scanresults_notification {
-       u8 channel;
-       u8 band;
-       u8 probe_status;
-       u8 num_probe_not_sent;  /* not enough time to send */
-       __le32 tsf_low;
-       __le32 tsf_high;
-       __le32 stats[NUMBER_OF_STATS];
-} __packed;
-
-/*
- * N_SCAN_COMPLETE = 0x84 (notification only, not a command)
- */
-struct il_scancomplete_notification {
-       u8 scanned_channels;
-       u8 status;
-       u8 last_channel;
-       __le32 tsf_low;
-       __le32 tsf_high;
-} __packed;
-
-/******************************************************************************
- * (9)
- * IBSS/AP Commands and Notifications:
- *
- *****************************************************************************/
-
-enum il_ibss_manager {
-       IL_NOT_IBSS_MANAGER = 0,
-       IL_IBSS_MANAGER = 1,
-};
-
-/*
- * N_BEACON = 0x90 (notification only, not a command)
- */
-
-struct il3945_beacon_notif {
-       struct il3945_tx_resp beacon_notify_hdr;
-       __le32 low_tsf;
-       __le32 high_tsf;
-       __le32 ibss_mgr_status;
-} __packed;
-
-struct il4965_beacon_notif {
-       struct il4965_tx_resp beacon_notify_hdr;
-       __le32 low_tsf;
-       __le32 high_tsf;
-       __le32 ibss_mgr_status;
-} __packed;
-
-/*
- * C_TX_BEACON= 0x91 (command, has simple generic response)
- */
-
-struct il3945_tx_beacon_cmd {
-       struct il3945_tx_cmd tx;
-       __le16 tim_idx;
-       u8 tim_size;
-       u8 reserved1;
-       struct ieee80211_hdr frame[0];  /* beacon frame */
-} __packed;
-
-struct il_tx_beacon_cmd {
-       struct il_tx_cmd tx;
-       __le16 tim_idx;
-       u8 tim_size;
-       u8 reserved1;
-       struct ieee80211_hdr frame[0];  /* beacon frame */
-} __packed;
-
-/******************************************************************************
- * (10)
- * Statistics Commands and Notifications:
- *
- *****************************************************************************/
-
-#define IL_TEMP_CONVERT 260
-
-#define SUP_RATE_11A_MAX_NUM_CHANNELS  8
-#define SUP_RATE_11B_MAX_NUM_CHANNELS  4
-#define SUP_RATE_11G_MAX_NUM_CHANNELS  12
-
-/* Used for passing to driver number of successes and failures per rate */
-struct rate_histogram {
-       union {
-               __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
-               __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
-               __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
-       } success;
-       union {
-               __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
-               __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
-               __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
-       } failed;
-} __packed;
-
-/* stats command response */
-
-struct iwl39_stats_rx_phy {
-       __le32 ina_cnt;
-       __le32 fina_cnt;
-       __le32 plcp_err;
-       __le32 crc32_err;
-       __le32 overrun_err;
-       __le32 early_overrun_err;
-       __le32 crc32_good;
-       __le32 false_alarm_cnt;
-       __le32 fina_sync_err_cnt;
-       __le32 sfd_timeout;
-       __le32 fina_timeout;
-       __le32 unresponded_rts;
-       __le32 rxe_frame_limit_overrun;
-       __le32 sent_ack_cnt;
-       __le32 sent_cts_cnt;
-} __packed;
-
-struct iwl39_stats_rx_non_phy {
-       __le32 bogus_cts;       /* CTS received when not expecting CTS */
-       __le32 bogus_ack;       /* ACK received when not expecting ACK */
-       __le32 non_bssid_frames;        /* number of frames with BSSID that
-                                        * doesn't belong to the STA BSSID */
-       __le32 filtered_frames; /* count frames that were dumped in the
-                                * filtering process */
-       __le32 non_channel_beacons;     /* beacons with our bss id but not on
-                                        * our serving channel */
-} __packed;
-
-struct iwl39_stats_rx {
-       struct iwl39_stats_rx_phy ofdm;
-       struct iwl39_stats_rx_phy cck;
-       struct iwl39_stats_rx_non_phy general;
-} __packed;
-
-struct iwl39_stats_tx {
-       __le32 preamble_cnt;
-       __le32 rx_detected_cnt;
-       __le32 bt_prio_defer_cnt;
-       __le32 bt_prio_kill_cnt;
-       __le32 few_bytes_cnt;
-       __le32 cts_timeout;
-       __le32 ack_timeout;
-       __le32 expected_ack_cnt;
-       __le32 actual_ack_cnt;
-} __packed;
-
-struct stats_dbg {
-       __le32 burst_check;
-       __le32 burst_count;
-       __le32 wait_for_silence_timeout_cnt;
-       __le32 reserved[3];
-} __packed;
-
-struct iwl39_stats_div {
-       __le32 tx_on_a;
-       __le32 tx_on_b;
-       __le32 exec_time;
-       __le32 probe_time;
-} __packed;
-
-struct iwl39_stats_general {
-       __le32 temperature;
-       struct stats_dbg dbg;
-       __le32 sleep_time;
-       __le32 slots_out;
-       __le32 slots_idle;
-       __le32 ttl_timestamp;
-       struct iwl39_stats_div div;
-} __packed;
-
-struct stats_rx_phy {
-       __le32 ina_cnt;
-       __le32 fina_cnt;
-       __le32 plcp_err;
-       __le32 crc32_err;
-       __le32 overrun_err;
-       __le32 early_overrun_err;
-       __le32 crc32_good;
-       __le32 false_alarm_cnt;
-       __le32 fina_sync_err_cnt;
-       __le32 sfd_timeout;
-       __le32 fina_timeout;
-       __le32 unresponded_rts;
-       __le32 rxe_frame_limit_overrun;
-       __le32 sent_ack_cnt;
-       __le32 sent_cts_cnt;
-       __le32 sent_ba_rsp_cnt;
-       __le32 dsp_self_kill;
-       __le32 mh_format_err;
-       __le32 re_acq_main_rssi_sum;
-       __le32 reserved3;
-} __packed;
-
-struct stats_rx_ht_phy {
-       __le32 plcp_err;
-       __le32 overrun_err;
-       __le32 early_overrun_err;
-       __le32 crc32_good;
-       __le32 crc32_err;
-       __le32 mh_format_err;
-       __le32 agg_crc32_good;
-       __le32 agg_mpdu_cnt;
-       __le32 agg_cnt;
-       __le32 unsupport_mcs;
-} __packed;
-
-#define INTERFERENCE_DATA_AVAILABLE      cpu_to_le32(1)
-
-struct stats_rx_non_phy {
-       __le32 bogus_cts;       /* CTS received when not expecting CTS */
-       __le32 bogus_ack;       /* ACK received when not expecting ACK */
-       __le32 non_bssid_frames;        /* number of frames with BSSID that
-                                        * doesn't belong to the STA BSSID */
-       __le32 filtered_frames; /* count frames that were dumped in the
-                                * filtering process */
-       __le32 non_channel_beacons;     /* beacons with our bss id but not on
-                                        * our serving channel */
-       __le32 channel_beacons; /* beacons with our bss id and in our
-                                * serving channel */
-       __le32 num_missed_bcon; /* number of missed beacons */
-       __le32 adc_rx_saturation_time;  /* count in 0.8us units the time the
-                                        * ADC was in saturation */
-       __le32 ina_detection_search_time;       /* total time (in 0.8us) searched
-                                                * for INA */
-       __le32 beacon_silence_rssi_a;   /* RSSI silence after beacon frame */
-       __le32 beacon_silence_rssi_b;   /* RSSI silence after beacon frame */
-       __le32 beacon_silence_rssi_c;   /* RSSI silence after beacon frame */
-       __le32 interference_data_flag;  /* flag for interference data
-                                        * availability. 1 when data is
-                                        * available. */
-       __le32 channel_load;    /* counts RX Enable time in uSec */
-       __le32 dsp_false_alarms;        /* DSP false alarm (both OFDM
-                                        * and CCK) counter */
-       __le32 beacon_rssi_a;
-       __le32 beacon_rssi_b;
-       __le32 beacon_rssi_c;
-       __le32 beacon_energy_a;
-       __le32 beacon_energy_b;
-       __le32 beacon_energy_c;
-} __packed;
-
-struct stats_rx {
-       struct stats_rx_phy ofdm;
-       struct stats_rx_phy cck;
-       struct stats_rx_non_phy general;
-       struct stats_rx_ht_phy ofdm_ht;
-} __packed;
-
-/**
- * struct stats_tx_power - current tx power
- *
- * @ant_a: current tx power on chain a in 1/2 dB step
- * @ant_b: current tx power on chain b in 1/2 dB step
- * @ant_c: current tx power on chain c in 1/2 dB step
- */
-struct stats_tx_power {
-       u8 ant_a;
-       u8 ant_b;
-       u8 ant_c;
-       u8 reserved;
-} __packed;
-
-struct stats_tx_non_phy_agg {
-       __le32 ba_timeout;
-       __le32 ba_reschedule_frames;
-       __le32 scd_query_agg_frame_cnt;
-       __le32 scd_query_no_agg;
-       __le32 scd_query_agg;
-       __le32 scd_query_mismatch;
-       __le32 frame_not_ready;
-       __le32 underrun;
-       __le32 bt_prio_kill;
-       __le32 rx_ba_rsp_cnt;
-} __packed;
-
-struct stats_tx {
-       __le32 preamble_cnt;
-       __le32 rx_detected_cnt;
-       __le32 bt_prio_defer_cnt;
-       __le32 bt_prio_kill_cnt;
-       __le32 few_bytes_cnt;
-       __le32 cts_timeout;
-       __le32 ack_timeout;
-       __le32 expected_ack_cnt;
-       __le32 actual_ack_cnt;
-       __le32 dump_msdu_cnt;
-       __le32 burst_abort_next_frame_mismatch_cnt;
-       __le32 burst_abort_missing_next_frame_cnt;
-       __le32 cts_timeout_collision;
-       __le32 ack_or_ba_timeout_collision;
-       struct stats_tx_non_phy_agg agg;
-
-       __le32 reserved1;
-} __packed;
-
-struct stats_div {
-       __le32 tx_on_a;
-       __le32 tx_on_b;
-       __le32 exec_time;
-       __le32 probe_time;
-       __le32 reserved1;
-       __le32 reserved2;
-} __packed;
-
-struct stats_general_common {
-       __le32 temperature;     /* radio temperature */
-       struct stats_dbg dbg;
-       __le32 sleep_time;
-       __le32 slots_out;
-       __le32 slots_idle;
-       __le32 ttl_timestamp;
-       struct stats_div div;
-       __le32 rx_enable_counter;
-       /*
-        * num_of_sos_states:
-        *  count the number of times we have to re-tune
-        *  in order to get out of bad PHY status
-        */
-       __le32 num_of_sos_states;
-} __packed;
-
-struct stats_general {
-       struct stats_general_common common;
-       __le32 reserved2;
-       __le32 reserved3;
-} __packed;
-
-#define UCODE_STATS_CLEAR_MSK          (0x1 << 0)
-#define UCODE_STATS_FREQUENCY_MSK              (0x1 << 1)
-#define UCODE_STATS_NARROW_BAND_MSK    (0x1 << 2)
-
-/*
- * C_STATS = 0x9c,
- * all devices identical.
- *
- * This command triggers an immediate response containing uCode stats.
- * The response is in the same format as N_STATS 0x9d, below.
- *
- * If the CLEAR_STATS configuration flag is set, uCode will clear its
- * internal copy of the stats (counters) after issuing the response.
- * This flag does not affect N_STATSs after beacons (see below).
- *
- * If the DISABLE_NOTIF configuration flag is set, uCode will not issue
- * N_STATSs after received beacons (see below).  This flag
- * does not affect the response to the C_STATS 0x9c itself.
- */
-#define IL_STATS_CONF_CLEAR_STATS cpu_to_le32(0x1)     /* see above */
-#define IL_STATS_CONF_DISABLE_NOTIF cpu_to_le32(0x2)   /* see above */
-struct il_stats_cmd {
-       __le32 configuration_flags;     /* IL_STATS_CONF_* */
-} __packed;
-
-/*
- * N_STATS = 0x9d (notification only, not a command)
- *
- * By default, uCode issues this notification after receiving a beacon
- * while associated.  To disable this behavior, set DISABLE_NOTIF flag in the
- * C_STATS 0x9c, above.
- *
- * Statistics counters continue to increment beacon after beacon, but are
- * cleared when changing channels or when driver issues C_STATS
- * 0x9c with CLEAR_STATS bit set (see above).
- *
- * uCode also issues this notification during scans.  uCode clears stats
- * appropriately so that each notification contains stats for only the
- * one channel that has just been scanned.
- */
-#define STATS_REPLY_FLG_BAND_24G_MSK         cpu_to_le32(0x2)
-#define STATS_REPLY_FLG_HT40_MODE_MSK        cpu_to_le32(0x8)
-
-struct il3945_notif_stats {
-       __le32 flag;
-       struct iwl39_stats_rx rx;
-       struct iwl39_stats_tx tx;
-       struct iwl39_stats_general general;
-} __packed;
-
-struct il_notif_stats {
-       __le32 flag;
-       struct stats_rx rx;
-       struct stats_tx tx;
-       struct stats_general general;
-} __packed;
-
-/*
- * N_MISSED_BEACONS = 0xa2 (notification only, not a command)
- *
- * uCode send N_MISSED_BEACONS to driver when detect beacon missed
- * in regardless of how many missed beacons, which mean when driver receive the
- * notification, inside the command, it can find all the beacons information
- * which include number of total missed beacons, number of consecutive missed
- * beacons, number of beacons received and number of beacons expected to
- * receive.
- *
- * If uCode detected consecutive_missed_beacons > 5, it will reset the radio
- * in order to bring the radio/PHY back to working state; which has no relation
- * to when driver will perform sensitivity calibration.
- *
- * Driver should set it own missed_beacon_threshold to decide when to perform
- * sensitivity calibration based on number of consecutive missed beacons in
- * order to improve overall performance, especially in noisy environment.
- *
- */
-
-#define IL_MISSED_BEACON_THRESHOLD_MIN (1)
-#define IL_MISSED_BEACON_THRESHOLD_DEF (5)
-#define IL_MISSED_BEACON_THRESHOLD_MAX IL_MISSED_BEACON_THRESHOLD_DEF
-
-struct il_missed_beacon_notif {
-       __le32 consecutive_missed_beacons;
-       __le32 total_missed_becons;
-       __le32 num_expected_beacons;
-       __le32 num_recvd_beacons;
-} __packed;
-
-/******************************************************************************
- * (11)
- * Rx Calibration Commands:
- *
- * With the uCode used for open source drivers, most Tx calibration (except
- * for Tx Power) and most Rx calibration is done by uCode during the
- * "initialize" phase of uCode boot.  Driver must calibrate only:
- *
- * 1)  Tx power (depends on temperature), described elsewhere
- * 2)  Receiver gain balance (optimize MIMO, and detect disconnected antennas)
- * 3)  Receiver sensitivity (to optimize signal detection)
- *
- *****************************************************************************/
-
-/**
- * C_SENSITIVITY = 0xa8 (command, has simple generic response)
- *
- * This command sets up the Rx signal detector for a sensitivity level that
- * is high enough to lock onto all signals within the associated network,
- * but low enough to ignore signals that are below a certain threshold, so as
- * not to have too many "false alarms".  False alarms are signals that the
- * Rx DSP tries to lock onto, but then discards after determining that they
- * are noise.
- *
- * The optimum number of false alarms is between 5 and 50 per 200 TUs
- * (200 * 1024 uSecs, i.e. 204.8 milliseconds) of actual Rx time (i.e.
- * time listening, not transmitting).  Driver must adjust sensitivity so that
- * the ratio of actual false alarms to actual Rx time falls within this range.
- *
- * While associated, uCode delivers N_STATSs after each
- * received beacon.  These provide information to the driver to analyze the
- * sensitivity.  Don't analyze stats that come in from scanning, or any
- * other non-associated-network source.  Pertinent stats include:
- *
- * From "general" stats (struct stats_rx_non_phy):
- *
- * (beacon_energy_[abc] & 0x0FF00) >> 8 (unsigned, higher value is lower level)
- *   Measure of energy of desired signal.  Used for establishing a level
- *   below which the device does not detect signals.
- *
- * (beacon_silence_rssi_[abc] & 0x0FF00) >> 8 (unsigned, units in dB)
- *   Measure of background noise in silent period after beacon.
- *
- * channel_load
- *   uSecs of actual Rx time during beacon period (varies according to
- *   how much time was spent transmitting).
- *
- * From "cck" and "ofdm" stats (struct stats_rx_phy), separately:
- *
- * false_alarm_cnt
- *   Signal locks abandoned early (before phy-level header).
- *
- * plcp_err
- *   Signal locks abandoned late (during phy-level header).
- *
- * NOTE:  Both false_alarm_cnt and plcp_err increment monotonically from
- *        beacon to beacon, i.e. each value is an accumulation of all errors
- *        before and including the latest beacon.  Values will wrap around to 0
- *        after counting up to 2^32 - 1.  Driver must differentiate vs.
- *        previous beacon's values to determine # false alarms in the current
- *        beacon period.
- *
- * Total number of false alarms = false_alarms + plcp_errs
- *
- * For OFDM, adjust the following table entries in struct il_sensitivity_cmd
- * (notice that the start points for OFDM are at or close to settings for
- * maximum sensitivity):
- *
- *                                             START  /  MIN  /  MAX
- *   HD_AUTO_CORR32_X1_TH_ADD_MIN_IDX          90   /   85  /  120
- *   HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_IDX     170   /  170  /  210
- *   HD_AUTO_CORR32_X4_TH_ADD_MIN_IDX         105   /  105  /  140
- *   HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_IDX     220   /  220  /  270
- *
- *   If actual rate of OFDM false alarms (+ plcp_errors) is too high
- *   (greater than 50 for each 204.8 msecs listening), reduce sensitivity
- *   by *adding* 1 to all 4 of the table entries above, up to the max for
- *   each entry.  Conversely, if false alarm rate is too low (less than 5
- *   for each 204.8 msecs listening), *subtract* 1 from each entry to
- *   increase sensitivity.
- *
- * For CCK sensitivity, keep track of the following:
- *
- *   1).  20-beacon history of maximum background noise, indicated by
- *        (beacon_silence_rssi_[abc] & 0x0FF00), units in dB, across the
- *        3 receivers.  For any given beacon, the "silence reference" is
- *        the maximum of last 60 samples (20 beacons * 3 receivers).
- *
- *   2).  10-beacon history of strongest signal level, as indicated
- *        by (beacon_energy_[abc] & 0x0FF00) >> 8, across the 3 receivers,
- *        i.e. the strength of the signal through the best receiver at the
- *        moment.  These measurements are "upside down", with lower values
- *        for stronger signals, so max energy will be *minimum* value.
- *
- *        Then for any given beacon, the driver must determine the *weakest*
- *        of the strongest signals; this is the minimum level that needs to be
- *        successfully detected, when using the best receiver at the moment.
- *        "Max cck energy" is the maximum (higher value means lower energy!)
- *        of the last 10 minima.  Once this is determined, driver must add
- *        a little margin by adding "6" to it.
- *
- *   3).  Number of consecutive beacon periods with too few false alarms.
- *        Reset this to 0 at the first beacon period that falls within the
- *        "good" range (5 to 50 false alarms per 204.8 milliseconds rx).
- *
- * Then, adjust the following CCK table entries in struct il_sensitivity_cmd
- * (notice that the start points for CCK are at maximum sensitivity):
- *
- *                                             START  /  MIN  /  MAX
- *   HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX         125   /  125  /  200
- *   HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX     200   /  200  /  400
- *   HD_MIN_ENERGY_CCK_DET_IDX                100   /    0  /  100
- *
- *   If actual rate of CCK false alarms (+ plcp_errors) is too high
- *   (greater than 50 for each 204.8 msecs listening), method for reducing
- *   sensitivity is:
- *
- *   1)  *Add* 3 to value in HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX,
- *       up to max 400.
- *
- *   2)  If current value in HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX is < 160,
- *       sensitivity has been reduced a significant amount; bring it up to
- *       a moderate 161.  Otherwise, *add* 3, up to max 200.
- *
- *   3)  a)  If current value in HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX is > 160,
- *       sensitivity has been reduced only a moderate or small amount;
- *       *subtract* 2 from value in HD_MIN_ENERGY_CCK_DET_IDX,
- *       down to min 0.  Otherwise (if gain has been significantly reduced),
- *       don't change the HD_MIN_ENERGY_CCK_DET_IDX value.
- *
- *       b)  Save a snapshot of the "silence reference".
- *
- *   If actual rate of CCK false alarms (+ plcp_errors) is too low
- *   (less than 5 for each 204.8 msecs listening), method for increasing
- *   sensitivity is used only if:
- *
- *   1a)  Previous beacon did not have too many false alarms
- *   1b)  AND difference between previous "silence reference" and current
- *        "silence reference" (prev - current) is 2 or more,
- *   OR 2)  100 or more consecutive beacon periods have had rate of
- *          less than 5 false alarms per 204.8 milliseconds rx time.
- *
- *   Method for increasing sensitivity:
- *
- *   1)  *Subtract* 3 from value in HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX,
- *       down to min 125.
- *
- *   2)  *Subtract* 3 from value in HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX,
- *       down to min 200.
- *
- *   3)  *Add* 2 to value in HD_MIN_ENERGY_CCK_DET_IDX, up to max 100.
- *
- *   If actual rate of CCK false alarms (+ plcp_errors) is within good range
- *   (between 5 and 50 for each 204.8 msecs listening):
- *
- *   1)  Save a snapshot of the silence reference.
- *
- *   2)  If previous beacon had too many CCK false alarms (+ plcp_errors),
- *       give some extra margin to energy threshold by *subtracting* 8
- *       from value in HD_MIN_ENERGY_CCK_DET_IDX.
- *
- *   For all cases (too few, too many, good range), make sure that the CCK
- *   detection threshold (energy) is below the energy level for robust
- *   detection over the past 10 beacon periods, the "Max cck energy".
- *   Lower values mean higher energy; this means making sure that the value
- *   in HD_MIN_ENERGY_CCK_DET_IDX is at or *above* "Max cck energy".
- *
- */
-
-/*
- * Table entries in C_SENSITIVITY (struct il_sensitivity_cmd)
- */
-#define HD_TBL_SIZE  (11)      /* number of entries */
-#define HD_MIN_ENERGY_CCK_DET_IDX                 (0)  /* table idxes */
-#define HD_MIN_ENERGY_OFDM_DET_IDX                (1)
-#define HD_AUTO_CORR32_X1_TH_ADD_MIN_IDX          (2)
-#define HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_IDX      (3)
-#define HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX      (4)
-#define HD_AUTO_CORR32_X4_TH_ADD_MIN_IDX          (5)
-#define HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_IDX      (6)
-#define HD_BARKER_CORR_TH_ADD_MIN_IDX             (7)
-#define HD_BARKER_CORR_TH_ADD_MIN_MRC_IDX         (8)
-#define HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX          (9)
-#define HD_OFDM_ENERGY_TH_IN_IDX                  (10)
-
-/* Control field in struct il_sensitivity_cmd */
-#define C_SENSITIVITY_CONTROL_DEFAULT_TBL      cpu_to_le16(0)
-#define C_SENSITIVITY_CONTROL_WORK_TBL cpu_to_le16(1)
-
-/**
- * struct il_sensitivity_cmd
- * @control:  (1) updates working table, (0) updates default table
- * @table:  energy threshold values, use HD_* as idx into table
- *
- * Always use "1" in "control" to update uCode's working table and DSP.
- */
-struct il_sensitivity_cmd {
-       __le16 control;         /* always use "1" */
-       __le16 table[HD_TBL_SIZE];      /* use HD_* as idx */
-} __packed;
-
-/**
- * C_PHY_CALIBRATION = 0xb0 (command, has simple generic response)
- *
- * This command sets the relative gains of 4965 device's 3 radio receiver chains.
- *
- * After the first association, driver should accumulate signal and noise
- * stats from the N_STATSs that follow the first 20
- * beacons from the associated network (don't collect stats that come
- * in from scanning, or any other non-network source).
- *
- * DISCONNECTED ANTENNA:
- *
- * Driver should determine which antennas are actually connected, by comparing
- * average beacon signal levels for the 3 Rx chains.  Accumulate (add) the
- * following values over 20 beacons, one accumulator for each of the chains
- * a/b/c, from struct stats_rx_non_phy:
- *
- * beacon_rssi_[abc] & 0x0FF (unsigned, units in dB)
- *
- * Find the strongest signal from among a/b/c.  Compare the other two to the
- * strongest.  If any signal is more than 15 dB (times 20, unless you
- * divide the accumulated values by 20) below the strongest, the driver
- * considers that antenna to be disconnected, and should not try to use that
- * antenna/chain for Rx or Tx.  If both A and B seem to be disconnected,
- * driver should declare the stronger one as connected, and attempt to use it
- * (A and B are the only 2 Tx chains!).
- *
- *
- * RX BALANCE:
- *
- * Driver should balance the 3 receivers (but just the ones that are connected
- * to antennas, see above) for gain, by comparing the average signal levels
- * detected during the silence after each beacon (background noise).
- * Accumulate (add) the following values over 20 beacons, one accumulator for
- * each of the chains a/b/c, from struct stats_rx_non_phy:
- *
- * beacon_silence_rssi_[abc] & 0x0FF (unsigned, units in dB)
- *
- * Find the weakest background noise level from among a/b/c.  This Rx chain
- * will be the reference, with 0 gain adjustment.  Attenuate other channels by
- * finding noise difference:
- *
- * (accum_noise[i] - accum_noise[reference]) / 30
- *
- * The "30" adjusts the dB in the 20 accumulated samples to units of 1.5 dB.
- * For use in diff_gain_[abc] fields of struct il_calibration_cmd, the
- * driver should limit the difference results to a range of 0-3 (0-4.5 dB),
- * and set bit 2 to indicate "reduce gain".  The value for the reference
- * (weakest) chain should be "0".
- *
- * diff_gain_[abc] bit fields:
- *   2: (1) reduce gain, (0) increase gain
- * 1-0: amount of gain, units of 1.5 dB
- */
-
-/* Phy calibration command for series */
-/* The default calibrate table size if not specified by firmware */
-#define IL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE     18
-enum {
-       IL_PHY_CALIBRATE_DIFF_GAIN_CMD = 7,
-       IL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE = 19,
-};
-
-#define IL_MAX_PHY_CALIBRATE_TBL_SIZE          (253)
-
-struct il_calib_hdr {
-       u8 op_code;
-       u8 first_group;
-       u8 groups_num;
-       u8 data_valid;
-} __packed;
-
-/* IL_PHY_CALIBRATE_DIFF_GAIN_CMD (7) */
-struct il_calib_diff_gain_cmd {
-       struct il_calib_hdr hdr;
-       s8 diff_gain_a;         /* see above */
-       s8 diff_gain_b;
-       s8 diff_gain_c;
-       u8 reserved1;
-} __packed;
-
-/******************************************************************************
- * (12)
- * Miscellaneous Commands:
- *
- *****************************************************************************/
-
-/*
- * LEDs Command & Response
- * C_LEDS = 0x48 (command, has simple generic response)
- *
- * For each of 3 possible LEDs (Activity/Link/Tech, selected by "id" field),
- * this command turns it on or off, or sets up a periodic blinking cycle.
- */
-struct il_led_cmd {
-       __le32 interval;        /* "interval" in uSec */
-       u8 id;                  /* 1: Activity, 2: Link, 3: Tech */
-       u8 off;                 /* # intervals off while blinking;
-                                * "0", with >0 "on" value, turns LED on */
-       u8 on;                  /* # intervals on while blinking;
-                                * "0", regardless of "off", turns LED off */
-       u8 reserved;
-} __packed;
-
-/******************************************************************************
- * (13)
- * Union of all expected notifications/responses:
- *
- *****************************************************************************/
-
-#define IL_RX_FRAME_SIZE_MSK   0x00003fff
-
-struct il_rx_pkt {
-       /*
-        * The first 4 bytes of the RX frame header contain both the RX frame
-        * size and some flags.
-        * Bit fields:
-        * 31:    flag flush RB request
-        * 30:    flag ignore TC (terminal counter) request
-        * 29:    flag fast IRQ request
-        * 28-14: Reserved
-        * 13-00: RX frame size
-        */
-       __le32 len_n_flags;
-       struct il_cmd_header hdr;
-       union {
-               struct il3945_rx_frame rx_frame;
-               struct il3945_tx_resp tx_resp;
-               struct il3945_beacon_notif beacon_status;
-
-               struct il_alive_resp alive_frame;
-               struct il_spectrum_notification spectrum_notif;
-               struct il_csa_notification csa_notif;
-               struct il_error_resp err_resp;
-               struct il_card_state_notif card_state_notif;
-               struct il_add_sta_resp add_sta;
-               struct il_rem_sta_resp rem_sta;
-               struct il_sleep_notification sleep_notif;
-               struct il_spectrum_resp spectrum;
-               struct il_notif_stats stats;
-               struct il_compressed_ba_resp compressed_ba;
-               struct il_missed_beacon_notif missed_beacon;
-               __le32 status;
-               u8 raw[0];
-       } u;
-} __packed;
-
-#endif /* __il_commands_h__ */
diff --git a/drivers/net/wireless/iwlegacy/common.c b/drivers/net/wireless/iwlegacy/common.c
deleted file mode 100644 (file)
index 8871145..0000000
+++ /dev/null
@@ -1,5586 +0,0 @@
-/******************************************************************************
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *****************************************************************************/
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/etherdevice.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/types.h>
-#include <linux/lockdep.h>
-#include <linux/pci.h>
-#include <linux/dma-mapping.h>
-#include <linux/delay.h>
-#include <linux/skbuff.h>
-#include <net/mac80211.h>
-
-#include "common.h"
-
-int
-_il_poll_bit(struct il_priv *il, u32 addr, u32 bits, u32 mask, int timeout)
-{
-       const int interval = 10; /* microseconds */
-       int t = 0;
-
-       do {
-               if ((_il_rd(il, addr) & mask) == (bits & mask))
-                       return t;
-               udelay(interval);
-               t += interval;
-       } while (t < timeout);
-
-       return -ETIMEDOUT;
-}
-EXPORT_SYMBOL(_il_poll_bit);
-
-void
-il_set_bit(struct il_priv *p, u32 r, u32 m)
-{
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&p->reg_lock, reg_flags);
-       _il_set_bit(p, r, m);
-       spin_unlock_irqrestore(&p->reg_lock, reg_flags);
-}
-EXPORT_SYMBOL(il_set_bit);
-
-void
-il_clear_bit(struct il_priv *p, u32 r, u32 m)
-{
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&p->reg_lock, reg_flags);
-       _il_clear_bit(p, r, m);
-       spin_unlock_irqrestore(&p->reg_lock, reg_flags);
-}
-EXPORT_SYMBOL(il_clear_bit);
-
-bool
-_il_grab_nic_access(struct il_priv *il)
-{
-       int ret;
-       u32 val;
-
-       /* this bit wakes up the NIC */
-       _il_set_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-
-       /*
-        * These bits say the device is running, and should keep running for
-        * at least a short while (at least as long as MAC_ACCESS_REQ stays 1),
-        * but they do not indicate that embedded SRAM is restored yet;
-        * 3945 and 4965 have volatile SRAM, and must save/restore contents
-        * to/from host DRAM when sleeping/waking for power-saving.
-        * Each direction takes approximately 1/4 millisecond; with this
-        * overhead, it's a good idea to grab and hold MAC_ACCESS_REQUEST if a
-        * series of register accesses are expected (e.g. reading Event Log),
-        * to keep device from sleeping.
-        *
-        * CSR_UCODE_DRV_GP1 register bit MAC_SLEEP == 0 indicates that
-        * SRAM is okay/restored.  We don't check that here because this call
-        * is just for hardware register access; but GP1 MAC_SLEEP check is a
-        * good idea before accessing 3945/4965 SRAM (e.g. reading Event Log).
-        *
-        */
-       ret =
-           _il_poll_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN,
-                        (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
-                         CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 15000);
-       if (unlikely(ret < 0)) {
-               val = _il_rd(il, CSR_GP_CNTRL);
-               WARN_ONCE(1, "Timeout waiting for ucode processor access "
-                            "(CSR_GP_CNTRL 0x%08x)\n", val);
-               _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_FORCE_NMI);
-               return false;
-       }
-
-       return true;
-}
-EXPORT_SYMBOL_GPL(_il_grab_nic_access);
-
-int
-il_poll_bit(struct il_priv *il, u32 addr, u32 mask, int timeout)
-{
-       const int interval = 10; /* microseconds */
-       int t = 0;
-
-       do {
-               if ((il_rd(il, addr) & mask) == mask)
-                       return t;
-               udelay(interval);
-               t += interval;
-       } while (t < timeout);
-
-       return -ETIMEDOUT;
-}
-EXPORT_SYMBOL(il_poll_bit);
-
-u32
-il_rd_prph(struct il_priv *il, u32 reg)
-{
-       unsigned long reg_flags;
-       u32 val;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       _il_grab_nic_access(il);
-       val = _il_rd_prph(il, reg);
-       _il_release_nic_access(il);
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-       return val;
-}
-EXPORT_SYMBOL(il_rd_prph);
-
-void
-il_wr_prph(struct il_priv *il, u32 addr, u32 val)
-{
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       if (likely(_il_grab_nic_access(il))) {
-               _il_wr_prph(il, addr, val);
-               _il_release_nic_access(il);
-       }
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-}
-EXPORT_SYMBOL(il_wr_prph);
-
-u32
-il_read_targ_mem(struct il_priv *il, u32 addr)
-{
-       unsigned long reg_flags;
-       u32 value;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       _il_grab_nic_access(il);
-
-       _il_wr(il, HBUS_TARG_MEM_RADDR, addr);
-       value = _il_rd(il, HBUS_TARG_MEM_RDAT);
-
-       _il_release_nic_access(il);
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-       return value;
-}
-EXPORT_SYMBOL(il_read_targ_mem);
-
-void
-il_write_targ_mem(struct il_priv *il, u32 addr, u32 val)
-{
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       if (likely(_il_grab_nic_access(il))) {
-               _il_wr(il, HBUS_TARG_MEM_WADDR, addr);
-               _il_wr(il, HBUS_TARG_MEM_WDAT, val);
-               _il_release_nic_access(il);
-       }
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-}
-EXPORT_SYMBOL(il_write_targ_mem);
-
-const char *
-il_get_cmd_string(u8 cmd)
-{
-       switch (cmd) {
-               IL_CMD(N_ALIVE);
-               IL_CMD(N_ERROR);
-               IL_CMD(C_RXON);
-               IL_CMD(C_RXON_ASSOC);
-               IL_CMD(C_QOS_PARAM);
-               IL_CMD(C_RXON_TIMING);
-               IL_CMD(C_ADD_STA);
-               IL_CMD(C_REM_STA);
-               IL_CMD(C_WEPKEY);
-               IL_CMD(N_3945_RX);
-               IL_CMD(C_TX);
-               IL_CMD(C_RATE_SCALE);
-               IL_CMD(C_LEDS);
-               IL_CMD(C_TX_LINK_QUALITY_CMD);
-               IL_CMD(C_CHANNEL_SWITCH);
-               IL_CMD(N_CHANNEL_SWITCH);
-               IL_CMD(C_SPECTRUM_MEASUREMENT);
-               IL_CMD(N_SPECTRUM_MEASUREMENT);
-               IL_CMD(C_POWER_TBL);
-               IL_CMD(N_PM_SLEEP);
-               IL_CMD(N_PM_DEBUG_STATS);
-               IL_CMD(C_SCAN);
-               IL_CMD(C_SCAN_ABORT);
-               IL_CMD(N_SCAN_START);
-               IL_CMD(N_SCAN_RESULTS);
-               IL_CMD(N_SCAN_COMPLETE);
-               IL_CMD(N_BEACON);
-               IL_CMD(C_TX_BEACON);
-               IL_CMD(C_TX_PWR_TBL);
-               IL_CMD(C_BT_CONFIG);
-               IL_CMD(C_STATS);
-               IL_CMD(N_STATS);
-               IL_CMD(N_CARD_STATE);
-               IL_CMD(N_MISSED_BEACONS);
-               IL_CMD(C_CT_KILL_CONFIG);
-               IL_CMD(C_SENSITIVITY);
-               IL_CMD(C_PHY_CALIBRATION);
-               IL_CMD(N_RX_PHY);
-               IL_CMD(N_RX_MPDU);
-               IL_CMD(N_RX);
-               IL_CMD(N_COMPRESSED_BA);
-       default:
-               return "UNKNOWN";
-
-       }
-}
-EXPORT_SYMBOL(il_get_cmd_string);
-
-#define HOST_COMPLETE_TIMEOUT (HZ / 2)
-
-static void
-il_generic_cmd_callback(struct il_priv *il, struct il_device_cmd *cmd,
-                       struct il_rx_pkt *pkt)
-{
-       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
-               IL_ERR("Bad return from %s (0x%08X)\n",
-                      il_get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
-               return;
-       }
-#ifdef CONFIG_IWLEGACY_DEBUG
-       switch (cmd->hdr.cmd) {
-       case C_TX_LINK_QUALITY_CMD:
-       case C_SENSITIVITY:
-               D_HC_DUMP("back from %s (0x%08X)\n",
-                         il_get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
-               break;
-       default:
-               D_HC("back from %s (0x%08X)\n", il_get_cmd_string(cmd->hdr.cmd),
-                    pkt->hdr.flags);
-       }
-#endif
-}
-
-static int
-il_send_cmd_async(struct il_priv *il, struct il_host_cmd *cmd)
-{
-       int ret;
-
-       BUG_ON(!(cmd->flags & CMD_ASYNC));
-
-       /* An asynchronous command can not expect an SKB to be set. */
-       BUG_ON(cmd->flags & CMD_WANT_SKB);
-
-       /* Assign a generic callback if one is not provided */
-       if (!cmd->callback)
-               cmd->callback = il_generic_cmd_callback;
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return -EBUSY;
-
-       ret = il_enqueue_hcmd(il, cmd);
-       if (ret < 0) {
-               IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
-                      il_get_cmd_string(cmd->id), ret);
-               return ret;
-       }
-       return 0;
-}
-
-int
-il_send_cmd_sync(struct il_priv *il, struct il_host_cmd *cmd)
-{
-       int cmd_idx;
-       int ret;
-
-       lockdep_assert_held(&il->mutex);
-
-       BUG_ON(cmd->flags & CMD_ASYNC);
-
-       /* A synchronous command can not have a callback set. */
-       BUG_ON(cmd->callback);
-
-       D_INFO("Attempting to send sync command %s\n",
-              il_get_cmd_string(cmd->id));
-
-       set_bit(S_HCMD_ACTIVE, &il->status);
-       D_INFO("Setting HCMD_ACTIVE for command %s\n",
-              il_get_cmd_string(cmd->id));
-
-       cmd_idx = il_enqueue_hcmd(il, cmd);
-       if (cmd_idx < 0) {
-               ret = cmd_idx;
-               IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
-                      il_get_cmd_string(cmd->id), ret);
-               goto out;
-       }
-
-       ret = wait_event_timeout(il->wait_command_queue,
-                                !test_bit(S_HCMD_ACTIVE, &il->status),
-                                HOST_COMPLETE_TIMEOUT);
-       if (!ret) {
-               if (test_bit(S_HCMD_ACTIVE, &il->status)) {
-                       IL_ERR("Error sending %s: time out after %dms.\n",
-                              il_get_cmd_string(cmd->id),
-                              jiffies_to_msecs(HOST_COMPLETE_TIMEOUT));
-
-                       clear_bit(S_HCMD_ACTIVE, &il->status);
-                       D_INFO("Clearing HCMD_ACTIVE for command %s\n",
-                              il_get_cmd_string(cmd->id));
-                       ret = -ETIMEDOUT;
-                       goto cancel;
-               }
-       }
-
-       if (test_bit(S_RFKILL, &il->status)) {
-               IL_ERR("Command %s aborted: RF KILL Switch\n",
-                      il_get_cmd_string(cmd->id));
-               ret = -ECANCELED;
-               goto fail;
-       }
-       if (test_bit(S_FW_ERROR, &il->status)) {
-               IL_ERR("Command %s failed: FW Error\n",
-                      il_get_cmd_string(cmd->id));
-               ret = -EIO;
-               goto fail;
-       }
-       if ((cmd->flags & CMD_WANT_SKB) && !cmd->reply_page) {
-               IL_ERR("Error: Response NULL in '%s'\n",
-                      il_get_cmd_string(cmd->id));
-               ret = -EIO;
-               goto cancel;
-       }
-
-       ret = 0;
-       goto out;
-
-cancel:
-       if (cmd->flags & CMD_WANT_SKB) {
-               /*
-                * Cancel the CMD_WANT_SKB flag for the cmd in the
-                * TX cmd queue. Otherwise in case the cmd comes
-                * in later, it will possibly set an invalid
-                * address (cmd->meta.source).
-                */
-               il->txq[il->cmd_queue].meta[cmd_idx].flags &= ~CMD_WANT_SKB;
-       }
-fail:
-       if (cmd->reply_page) {
-               il_free_pages(il, cmd->reply_page);
-               cmd->reply_page = 0;
-       }
-out:
-       return ret;
-}
-EXPORT_SYMBOL(il_send_cmd_sync);
-
-int
-il_send_cmd(struct il_priv *il, struct il_host_cmd *cmd)
-{
-       if (cmd->flags & CMD_ASYNC)
-               return il_send_cmd_async(il, cmd);
-
-       return il_send_cmd_sync(il, cmd);
-}
-EXPORT_SYMBOL(il_send_cmd);
-
-int
-il_send_cmd_pdu(struct il_priv *il, u8 id, u16 len, const void *data)
-{
-       struct il_host_cmd cmd = {
-               .id = id,
-               .len = len,
-               .data = data,
-       };
-
-       return il_send_cmd_sync(il, &cmd);
-}
-EXPORT_SYMBOL(il_send_cmd_pdu);
-
-int
-il_send_cmd_pdu_async(struct il_priv *il, u8 id, u16 len, const void *data,
-                     void (*callback) (struct il_priv *il,
-                                       struct il_device_cmd *cmd,
-                                       struct il_rx_pkt *pkt))
-{
-       struct il_host_cmd cmd = {
-               .id = id,
-               .len = len,
-               .data = data,
-       };
-
-       cmd.flags |= CMD_ASYNC;
-       cmd.callback = callback;
-
-       return il_send_cmd_async(il, &cmd);
-}
-EXPORT_SYMBOL(il_send_cmd_pdu_async);
-
-/* default: IL_LED_BLINK(0) using blinking idx table */
-static int led_mode;
-module_param(led_mode, int, S_IRUGO);
-MODULE_PARM_DESC(led_mode,
-                "0=system default, " "1=On(RF On)/Off(RF Off), 2=blinking");
-
-/* Throughput          OFF time(ms)    ON time (ms)
- *     >300                    25              25
- *     >200 to 300             40              40
- *     >100 to 200             55              55
- *     >70 to 100              65              65
- *     >50 to 70               75              75
- *     >20 to 50               85              85
- *     >10 to 20               95              95
- *     >5 to 10                110             110
- *     >1 to 5                 130             130
- *     >0 to 1                 167             167
- *     <=0                                     SOLID ON
- */
-static const struct ieee80211_tpt_blink il_blink[] = {
-       {.throughput = 0,               .blink_time = 334},
-       {.throughput = 1 * 1024 - 1,    .blink_time = 260},
-       {.throughput = 5 * 1024 - 1,    .blink_time = 220},
-       {.throughput = 10 * 1024 - 1,   .blink_time = 190},
-       {.throughput = 20 * 1024 - 1,   .blink_time = 170},
-       {.throughput = 50 * 1024 - 1,   .blink_time = 150},
-       {.throughput = 70 * 1024 - 1,   .blink_time = 130},
-       {.throughput = 100 * 1024 - 1,  .blink_time = 110},
-       {.throughput = 200 * 1024 - 1,  .blink_time = 80},
-       {.throughput = 300 * 1024 - 1,  .blink_time = 50},
-};
-
-/*
- * Adjust led blink rate to compensate on a MAC Clock difference on every HW
- * Led blink rate analysis showed an average deviation of 0% on 3945,
- * 5% on 4965 HW.
- * Need to compensate on the led on/off time per HW according to the deviation
- * to achieve the desired led frequency
- * The calculation is: (100-averageDeviation)/100 * blinkTime
- * For code efficiency the calculation will be:
- *     compensation = (100 - averageDeviation) * 64 / 100
- *     NewBlinkTime = (compensation * BlinkTime) / 64
- */
-static inline u8
-il_blink_compensation(struct il_priv *il, u8 time, u16 compensation)
-{
-       if (!compensation) {
-               IL_ERR("undefined blink compensation: "
-                      "use pre-defined blinking time\n");
-               return time;
-       }
-
-       return (u8) ((time * compensation) >> 6);
-}
-
-/* Set led pattern command */
-static int
-il_led_cmd(struct il_priv *il, unsigned long on, unsigned long off)
-{
-       struct il_led_cmd led_cmd = {
-               .id = IL_LED_LINK,
-               .interval = IL_DEF_LED_INTRVL
-       };
-       int ret;
-
-       if (!test_bit(S_READY, &il->status))
-               return -EBUSY;
-
-       if (il->blink_on == on && il->blink_off == off)
-               return 0;
-
-       if (off == 0) {
-               /* led is SOLID_ON */
-               on = IL_LED_SOLID;
-       }
-
-       D_LED("Led blink time compensation=%u\n",
-             il->cfg->led_compensation);
-       led_cmd.on =
-           il_blink_compensation(il, on,
-                                 il->cfg->led_compensation);
-       led_cmd.off =
-           il_blink_compensation(il, off,
-                                 il->cfg->led_compensation);
-
-       ret = il->ops->send_led_cmd(il, &led_cmd);
-       if (!ret) {
-               il->blink_on = on;
-               il->blink_off = off;
-       }
-       return ret;
-}
-
-static void
-il_led_brightness_set(struct led_classdev *led_cdev,
-                     enum led_brightness brightness)
-{
-       struct il_priv *il = container_of(led_cdev, struct il_priv, led);
-       unsigned long on = 0;
-
-       if (brightness > 0)
-               on = IL_LED_SOLID;
-
-       il_led_cmd(il, on, 0);
-}
-
-static int
-il_led_blink_set(struct led_classdev *led_cdev, unsigned long *delay_on,
-                unsigned long *delay_off)
-{
-       struct il_priv *il = container_of(led_cdev, struct il_priv, led);
-
-       return il_led_cmd(il, *delay_on, *delay_off);
-}
-
-void
-il_leds_init(struct il_priv *il)
-{
-       int mode = led_mode;
-       int ret;
-
-       if (mode == IL_LED_DEFAULT)
-               mode = il->cfg->led_mode;
-
-       il->led.name =
-           kasprintf(GFP_KERNEL, "%s-led", wiphy_name(il->hw->wiphy));
-       il->led.brightness_set = il_led_brightness_set;
-       il->led.blink_set = il_led_blink_set;
-       il->led.max_brightness = 1;
-
-       switch (mode) {
-       case IL_LED_DEFAULT:
-               WARN_ON(1);
-               break;
-       case IL_LED_BLINK:
-               il->led.default_trigger =
-                   ieee80211_create_tpt_led_trigger(il->hw,
-                                                    IEEE80211_TPT_LEDTRIG_FL_CONNECTED,
-                                                    il_blink,
-                                                    ARRAY_SIZE(il_blink));
-               break;
-       case IL_LED_RF_STATE:
-               il->led.default_trigger = ieee80211_get_radio_led_name(il->hw);
-               break;
-       }
-
-       ret = led_classdev_register(&il->pci_dev->dev, &il->led);
-       if (ret) {
-               kfree(il->led.name);
-               return;
-       }
-
-       il->led_registered = true;
-}
-EXPORT_SYMBOL(il_leds_init);
-
-void
-il_leds_exit(struct il_priv *il)
-{
-       if (!il->led_registered)
-               return;
-
-       led_classdev_unregister(&il->led);
-       kfree(il->led.name);
-}
-EXPORT_SYMBOL(il_leds_exit);
-
-/************************** EEPROM BANDS ****************************
- *
- * The il_eeprom_band definitions below provide the mapping from the
- * EEPROM contents to the specific channel number supported for each
- * band.
- *
- * For example, il_priv->eeprom.band_3_channels[4] from the band_3
- * definition below maps to physical channel 42 in the 5.2GHz spectrum.
- * The specific geography and calibration information for that channel
- * is contained in the eeprom map itself.
- *
- * During init, we copy the eeprom information and channel map
- * information into il->channel_info_24/52 and il->channel_map_24/52
- *
- * channel_map_24/52 provides the idx in the channel_info array for a
- * given channel.  We have to have two separate maps as there is channel
- * overlap with the 2.4GHz and 5.2GHz spectrum as seen in band_1 and
- * band_2
- *
- * A value of 0xff stored in the channel_map indicates that the channel
- * is not supported by the hardware at all.
- *
- * A value of 0xfe in the channel_map indicates that the channel is not
- * valid for Tx with the current hardware.  This means that
- * while the system can tune and receive on a given channel, it may not
- * be able to associate or transmit any frames on that
- * channel.  There is no corresponding channel information for that
- * entry.
- *
- *********************************************************************/
-
-/* 2.4 GHz */
-const u8 il_eeprom_band_1[14] = {
-       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
-};
-
-/* 5.2 GHz bands */
-static const u8 il_eeprom_band_2[] = { /* 4915-5080MHz */
-       183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
-};
-
-static const u8 il_eeprom_band_3[] = { /* 5170-5320MHz */
-       34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
-};
-
-static const u8 il_eeprom_band_4[] = { /* 5500-5700MHz */
-       100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
-};
-
-static const u8 il_eeprom_band_5[] = { /* 5725-5825MHz */
-       145, 149, 153, 157, 161, 165
-};
-
-static const u8 il_eeprom_band_6[] = { /* 2.4 ht40 channel */
-       1, 2, 3, 4, 5, 6, 7
-};
-
-static const u8 il_eeprom_band_7[] = { /* 5.2 ht40 channel */
-       36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157
-};
-
-/******************************************************************************
- *
- * EEPROM related functions
- *
-******************************************************************************/
-
-static int
-il_eeprom_verify_signature(struct il_priv *il)
-{
-       u32 gp = _il_rd(il, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
-       int ret = 0;
-
-       D_EEPROM("EEPROM signature=0x%08x\n", gp);
-       switch (gp) {
-       case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K:
-       case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K:
-               break;
-       default:
-               IL_ERR("bad EEPROM signature," "EEPROM_GP=0x%08x\n", gp);
-               ret = -ENOENT;
-               break;
-       }
-       return ret;
-}
-
-const u8 *
-il_eeprom_query_addr(const struct il_priv *il, size_t offset)
-{
-       BUG_ON(offset >= il->cfg->eeprom_size);
-       return &il->eeprom[offset];
-}
-EXPORT_SYMBOL(il_eeprom_query_addr);
-
-u16
-il_eeprom_query16(const struct il_priv *il, size_t offset)
-{
-       if (!il->eeprom)
-               return 0;
-       return (u16) il->eeprom[offset] | ((u16) il->eeprom[offset + 1] << 8);
-}
-EXPORT_SYMBOL(il_eeprom_query16);
-
-/**
- * il_eeprom_init - read EEPROM contents
- *
- * Load the EEPROM contents from adapter into il->eeprom
- *
- * NOTE:  This routine uses the non-debug IO access functions.
- */
-int
-il_eeprom_init(struct il_priv *il)
-{
-       __le16 *e;
-       u32 gp = _il_rd(il, CSR_EEPROM_GP);
-       int sz;
-       int ret;
-       u16 addr;
-
-       /* allocate eeprom */
-       sz = il->cfg->eeprom_size;
-       D_EEPROM("NVM size = %d\n", sz);
-       il->eeprom = kzalloc(sz, GFP_KERNEL);
-       if (!il->eeprom) {
-               ret = -ENOMEM;
-               goto alloc_err;
-       }
-       e = (__le16 *) il->eeprom;
-
-       il->ops->apm_init(il);
-
-       ret = il_eeprom_verify_signature(il);
-       if (ret < 0) {
-               IL_ERR("EEPROM not found, EEPROM_GP=0x%08x\n", gp);
-               ret = -ENOENT;
-               goto err;
-       }
-
-       /* Make sure driver (instead of uCode) is allowed to read EEPROM */
-       ret = il->ops->eeprom_acquire_semaphore(il);
-       if (ret < 0) {
-               IL_ERR("Failed to acquire EEPROM semaphore.\n");
-               ret = -ENOENT;
-               goto err;
-       }
-
-       /* eeprom is an array of 16bit values */
-       for (addr = 0; addr < sz; addr += sizeof(u16)) {
-               u32 r;
-
-               _il_wr(il, CSR_EEPROM_REG,
-                      CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
-
-               ret =
-                   _il_poll_bit(il, CSR_EEPROM_REG,
-                                CSR_EEPROM_REG_READ_VALID_MSK,
-                                CSR_EEPROM_REG_READ_VALID_MSK,
-                                IL_EEPROM_ACCESS_TIMEOUT);
-               if (ret < 0) {
-                       IL_ERR("Time out reading EEPROM[%d]\n", addr);
-                       goto done;
-               }
-               r = _il_rd(il, CSR_EEPROM_REG);
-               e[addr / 2] = cpu_to_le16(r >> 16);
-       }
-
-       D_EEPROM("NVM Type: %s, version: 0x%x\n", "EEPROM",
-                il_eeprom_query16(il, EEPROM_VERSION));
-
-       ret = 0;
-done:
-       il->ops->eeprom_release_semaphore(il);
-
-err:
-       if (ret)
-               il_eeprom_free(il);
-       /* Reset chip to save power until we load uCode during "up". */
-       il_apm_stop(il);
-alloc_err:
-       return ret;
-}
-EXPORT_SYMBOL(il_eeprom_init);
-
-void
-il_eeprom_free(struct il_priv *il)
-{
-       kfree(il->eeprom);
-       il->eeprom = NULL;
-}
-EXPORT_SYMBOL(il_eeprom_free);
-
-static void
-il_init_band_reference(const struct il_priv *il, int eep_band,
-                      int *eeprom_ch_count,
-                      const struct il_eeprom_channel **eeprom_ch_info,
-                      const u8 **eeprom_ch_idx)
-{
-       u32 offset = il->cfg->regulatory_bands[eep_band - 1];
-
-       switch (eep_band) {
-       case 1:         /* 2.4GHz band */
-               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_1);
-               *eeprom_ch_info =
-                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
-                                                                    offset);
-               *eeprom_ch_idx = il_eeprom_band_1;
-               break;
-       case 2:         /* 4.9GHz band */
-               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_2);
-               *eeprom_ch_info =
-                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
-                                                                    offset);
-               *eeprom_ch_idx = il_eeprom_band_2;
-               break;
-       case 3:         /* 5.2GHz band */
-               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_3);
-               *eeprom_ch_info =
-                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
-                                                                    offset);
-               *eeprom_ch_idx = il_eeprom_band_3;
-               break;
-       case 4:         /* 5.5GHz band */
-               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_4);
-               *eeprom_ch_info =
-                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
-                                                                    offset);
-               *eeprom_ch_idx = il_eeprom_band_4;
-               break;
-       case 5:         /* 5.7GHz band */
-               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_5);
-               *eeprom_ch_info =
-                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
-                                                                    offset);
-               *eeprom_ch_idx = il_eeprom_band_5;
-               break;
-       case 6:         /* 2.4GHz ht40 channels */
-               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_6);
-               *eeprom_ch_info =
-                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
-                                                                    offset);
-               *eeprom_ch_idx = il_eeprom_band_6;
-               break;
-       case 7:         /* 5 GHz ht40 channels */
-               *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_7);
-               *eeprom_ch_info =
-                   (struct il_eeprom_channel *)il_eeprom_query_addr(il,
-                                                                    offset);
-               *eeprom_ch_idx = il_eeprom_band_7;
-               break;
-       default:
-               BUG();
-       }
-}
-
-#define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
-                           ? # x " " : "")
-/**
- * il_mod_ht40_chan_info - Copy ht40 channel info into driver's il.
- *
- * Does not set up a command, or touch hardware.
- */
-static int
-il_mod_ht40_chan_info(struct il_priv *il, enum ieee80211_band band, u16 channel,
-                     const struct il_eeprom_channel *eeprom_ch,
-                     u8 clear_ht40_extension_channel)
-{
-       struct il_channel_info *ch_info;
-
-       ch_info =
-           (struct il_channel_info *)il_get_channel_info(il, band, channel);
-
-       if (!il_is_channel_valid(ch_info))
-               return -1;
-
-       D_EEPROM("HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
-                " Ad-Hoc %ssupported\n", ch_info->channel,
-                il_is_channel_a_band(ch_info) ? "5.2" : "2.4",
-                CHECK_AND_PRINT(IBSS), CHECK_AND_PRINT(ACTIVE),
-                CHECK_AND_PRINT(RADAR), CHECK_AND_PRINT(WIDE),
-                CHECK_AND_PRINT(DFS), eeprom_ch->flags,
-                eeprom_ch->max_power_avg,
-                ((eeprom_ch->flags & EEPROM_CHANNEL_IBSS) &&
-                 !(eeprom_ch->flags & EEPROM_CHANNEL_RADAR)) ? "" : "not ");
-
-       ch_info->ht40_eeprom = *eeprom_ch;
-       ch_info->ht40_max_power_avg = eeprom_ch->max_power_avg;
-       ch_info->ht40_flags = eeprom_ch->flags;
-       if (eeprom_ch->flags & EEPROM_CHANNEL_VALID)
-               ch_info->ht40_extension_channel &=
-                   ~clear_ht40_extension_channel;
-
-       return 0;
-}
-
-#define CHECK_AND_PRINT_I(x) ((eeprom_ch_info[ch].flags & EEPROM_CHANNEL_##x) \
-                           ? # x " " : "")
-
-/**
- * il_init_channel_map - Set up driver's info for all possible channels
- */
-int
-il_init_channel_map(struct il_priv *il)
-{
-       int eeprom_ch_count = 0;
-       const u8 *eeprom_ch_idx = NULL;
-       const struct il_eeprom_channel *eeprom_ch_info = NULL;
-       int band, ch;
-       struct il_channel_info *ch_info;
-
-       if (il->channel_count) {
-               D_EEPROM("Channel map already initialized.\n");
-               return 0;
-       }
-
-       D_EEPROM("Initializing regulatory info from EEPROM\n");
-
-       il->channel_count =
-           ARRAY_SIZE(il_eeprom_band_1) + ARRAY_SIZE(il_eeprom_band_2) +
-           ARRAY_SIZE(il_eeprom_band_3) + ARRAY_SIZE(il_eeprom_band_4) +
-           ARRAY_SIZE(il_eeprom_band_5);
-
-       D_EEPROM("Parsing data for %d channels.\n", il->channel_count);
-
-       il->channel_info =
-           kzalloc(sizeof(struct il_channel_info) * il->channel_count,
-                   GFP_KERNEL);
-       if (!il->channel_info) {
-               IL_ERR("Could not allocate channel_info\n");
-               il->channel_count = 0;
-               return -ENOMEM;
-       }
-
-       ch_info = il->channel_info;
-
-       /* Loop through the 5 EEPROM bands adding them in order to the
-        * channel map we maintain (that contains additional information than
-        * what just in the EEPROM) */
-       for (band = 1; band <= 5; band++) {
-
-               il_init_band_reference(il, band, &eeprom_ch_count,
-                                      &eeprom_ch_info, &eeprom_ch_idx);
-
-               /* Loop through each band adding each of the channels */
-               for (ch = 0; ch < eeprom_ch_count; ch++) {
-                       ch_info->channel = eeprom_ch_idx[ch];
-                       ch_info->band =
-                           (band ==
-                            1) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
-
-                       /* permanently store EEPROM's channel regulatory flags
-                        *   and max power in channel info database. */
-                       ch_info->eeprom = eeprom_ch_info[ch];
-
-                       /* Copy the run-time flags so they are there even on
-                        * invalid channels */
-                       ch_info->flags = eeprom_ch_info[ch].flags;
-                       /* First write that ht40 is not enabled, and then enable
-                        * one by one */
-                       ch_info->ht40_extension_channel =
-                           IEEE80211_CHAN_NO_HT40;
-
-                       if (!(il_is_channel_valid(ch_info))) {
-                               D_EEPROM("Ch. %d Flags %x [%sGHz] - "
-                                        "No traffic\n", ch_info->channel,
-                                        ch_info->flags,
-                                        il_is_channel_a_band(ch_info) ? "5.2" :
-                                        "2.4");
-                               ch_info++;
-                               continue;
-                       }
-
-                       /* Initialize regulatory-based run-time data */
-                       ch_info->max_power_avg = ch_info->curr_txpow =
-                           eeprom_ch_info[ch].max_power_avg;
-                       ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
-                       ch_info->min_power = 0;
-
-                       D_EEPROM("Ch. %d [%sGHz] " "%s%s%s%s%s%s(0x%02x %ddBm):"
-                                " Ad-Hoc %ssupported\n", ch_info->channel,
-                                il_is_channel_a_band(ch_info) ? "5.2" : "2.4",
-                                CHECK_AND_PRINT_I(VALID),
-                                CHECK_AND_PRINT_I(IBSS),
-                                CHECK_AND_PRINT_I(ACTIVE),
-                                CHECK_AND_PRINT_I(RADAR),
-                                CHECK_AND_PRINT_I(WIDE),
-                                CHECK_AND_PRINT_I(DFS),
-                                eeprom_ch_info[ch].flags,
-                                eeprom_ch_info[ch].max_power_avg,
-                                ((eeprom_ch_info[ch].
-                                  flags & EEPROM_CHANNEL_IBSS) &&
-                                 !(eeprom_ch_info[ch].
-                                   flags & EEPROM_CHANNEL_RADAR)) ? "" :
-                                "not ");
-
-                       ch_info++;
-               }
-       }
-
-       /* Check if we do have HT40 channels */
-       if (il->cfg->regulatory_bands[5] == EEPROM_REGULATORY_BAND_NO_HT40 &&
-           il->cfg->regulatory_bands[6] == EEPROM_REGULATORY_BAND_NO_HT40)
-               return 0;
-
-       /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
-       for (band = 6; band <= 7; band++) {
-               enum ieee80211_band ieeeband;
-
-               il_init_band_reference(il, band, &eeprom_ch_count,
-                                      &eeprom_ch_info, &eeprom_ch_idx);
-
-               /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
-               ieeeband =
-                   (band == 6) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
-
-               /* Loop through each band adding each of the channels */
-               for (ch = 0; ch < eeprom_ch_count; ch++) {
-                       /* Set up driver's info for lower half */
-                       il_mod_ht40_chan_info(il, ieeeband, eeprom_ch_idx[ch],
-                                             &eeprom_ch_info[ch],
-                                             IEEE80211_CHAN_NO_HT40PLUS);
-
-                       /* Set up driver's info for upper half */
-                       il_mod_ht40_chan_info(il, ieeeband,
-                                             eeprom_ch_idx[ch] + 4,
-                                             &eeprom_ch_info[ch],
-                                             IEEE80211_CHAN_NO_HT40MINUS);
-               }
-       }
-
-       return 0;
-}
-EXPORT_SYMBOL(il_init_channel_map);
-
-/*
- * il_free_channel_map - undo allocations in il_init_channel_map
- */
-void
-il_free_channel_map(struct il_priv *il)
-{
-       kfree(il->channel_info);
-       il->channel_count = 0;
-}
-EXPORT_SYMBOL(il_free_channel_map);
-
-/**
- * il_get_channel_info - Find driver's ilate channel info
- *
- * Based on band and channel number.
- */
-const struct il_channel_info *
-il_get_channel_info(const struct il_priv *il, enum ieee80211_band band,
-                   u16 channel)
-{
-       int i;
-
-       switch (band) {
-       case IEEE80211_BAND_5GHZ:
-               for (i = 14; i < il->channel_count; i++) {
-                       if (il->channel_info[i].channel == channel)
-                               return &il->channel_info[i];
-               }
-               break;
-       case IEEE80211_BAND_2GHZ:
-               if (channel >= 1 && channel <= 14)
-                       return &il->channel_info[channel - 1];
-               break;
-       default:
-               BUG();
-       }
-
-       return NULL;
-}
-EXPORT_SYMBOL(il_get_channel_info);
-
-/*
- * Setting power level allows the card to go to sleep when not busy.
- *
- * We calculate a sleep command based on the required latency, which
- * we get from mac80211.
- */
-
-#define SLP_VEC(X0, X1, X2, X3, X4) { \
-               cpu_to_le32(X0), \
-               cpu_to_le32(X1), \
-               cpu_to_le32(X2), \
-               cpu_to_le32(X3), \
-               cpu_to_le32(X4)  \
-}
-
-static void
-il_build_powertable_cmd(struct il_priv *il, struct il_powertable_cmd *cmd)
-{
-       const __le32 interval[3][IL_POWER_VEC_SIZE] = {
-               SLP_VEC(2, 2, 4, 6, 0xFF),
-               SLP_VEC(2, 4, 7, 10, 10),
-               SLP_VEC(4, 7, 10, 10, 0xFF)
-       };
-       int i, dtim_period, no_dtim;
-       u32 max_sleep;
-       bool skip;
-
-       memset(cmd, 0, sizeof(*cmd));
-
-       if (il->power_data.pci_pm)
-               cmd->flags |= IL_POWER_PCI_PM_MSK;
-
-       /* if no Power Save, we are done */
-       if (il->power_data.ps_disabled)
-               return;
-
-       cmd->flags = IL_POWER_DRIVER_ALLOW_SLEEP_MSK;
-       cmd->keep_alive_seconds = 0;
-       cmd->debug_flags = 0;
-       cmd->rx_data_timeout = cpu_to_le32(25 * 1024);
-       cmd->tx_data_timeout = cpu_to_le32(25 * 1024);
-       cmd->keep_alive_beacons = 0;
-
-       dtim_period = il->vif ? il->vif->bss_conf.dtim_period : 0;
-
-       if (dtim_period <= 2) {
-               memcpy(cmd->sleep_interval, interval[0], sizeof(interval[0]));
-               no_dtim = 2;
-       } else if (dtim_period <= 10) {
-               memcpy(cmd->sleep_interval, interval[1], sizeof(interval[1]));
-               no_dtim = 2;
-       } else {
-               memcpy(cmd->sleep_interval, interval[2], sizeof(interval[2]));
-               no_dtim = 0;
-       }
-
-       if (dtim_period == 0) {
-               dtim_period = 1;
-               skip = false;
-       } else {
-               skip = !!no_dtim;
-       }
-
-       if (skip) {
-               __le32 tmp = cmd->sleep_interval[IL_POWER_VEC_SIZE - 1];
-
-               max_sleep = le32_to_cpu(tmp);
-               if (max_sleep == 0xFF)
-                       max_sleep = dtim_period * (skip + 1);
-               else if (max_sleep >  dtim_period)
-                       max_sleep = (max_sleep / dtim_period) * dtim_period;
-               cmd->flags |= IL_POWER_SLEEP_OVER_DTIM_MSK;
-       } else {
-               max_sleep = dtim_period;
-               cmd->flags &= ~IL_POWER_SLEEP_OVER_DTIM_MSK;
-       }
-
-       for (i = 0; i < IL_POWER_VEC_SIZE; i++)
-               if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep)
-                       cmd->sleep_interval[i] = cpu_to_le32(max_sleep);
-}
-
-static int
-il_set_power(struct il_priv *il, struct il_powertable_cmd *cmd)
-{
-       D_POWER("Sending power/sleep command\n");
-       D_POWER("Flags value = 0x%08X\n", cmd->flags);
-       D_POWER("Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
-       D_POWER("Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
-       D_POWER("Sleep interval vector = { %d , %d , %d , %d , %d }\n",
-               le32_to_cpu(cmd->sleep_interval[0]),
-               le32_to_cpu(cmd->sleep_interval[1]),
-               le32_to_cpu(cmd->sleep_interval[2]),
-               le32_to_cpu(cmd->sleep_interval[3]),
-               le32_to_cpu(cmd->sleep_interval[4]));
-
-       return il_send_cmd_pdu(il, C_POWER_TBL,
-                              sizeof(struct il_powertable_cmd), cmd);
-}
-
-static int
-il_power_set_mode(struct il_priv *il, struct il_powertable_cmd *cmd, bool force)
-{
-       int ret;
-       bool update_chains;
-
-       lockdep_assert_held(&il->mutex);
-
-       /* Don't update the RX chain when chain noise calibration is running */
-       update_chains = il->chain_noise_data.state == IL_CHAIN_NOISE_DONE ||
-           il->chain_noise_data.state == IL_CHAIN_NOISE_ALIVE;
-
-       if (!memcmp(&il->power_data.sleep_cmd, cmd, sizeof(*cmd)) && !force)
-               return 0;
-
-       if (!il_is_ready_rf(il))
-               return -EIO;
-
-       /* scan complete use sleep_power_next, need to be updated */
-       memcpy(&il->power_data.sleep_cmd_next, cmd, sizeof(*cmd));
-       if (test_bit(S_SCANNING, &il->status) && !force) {
-               D_INFO("Defer power set mode while scanning\n");
-               return 0;
-       }
-
-       if (cmd->flags & IL_POWER_DRIVER_ALLOW_SLEEP_MSK)
-               set_bit(S_POWER_PMI, &il->status);
-
-       ret = il_set_power(il, cmd);
-       if (!ret) {
-               if (!(cmd->flags & IL_POWER_DRIVER_ALLOW_SLEEP_MSK))
-                       clear_bit(S_POWER_PMI, &il->status);
-
-               if (il->ops->update_chain_flags && update_chains)
-                       il->ops->update_chain_flags(il);
-               else if (il->ops->update_chain_flags)
-                       D_POWER("Cannot update the power, chain noise "
-                               "calibration running: %d\n",
-                               il->chain_noise_data.state);
-
-               memcpy(&il->power_data.sleep_cmd, cmd, sizeof(*cmd));
-       } else
-               IL_ERR("set power fail, ret = %d", ret);
-
-       return ret;
-}
-
-int
-il_power_update_mode(struct il_priv *il, bool force)
-{
-       struct il_powertable_cmd cmd;
-
-       il_build_powertable_cmd(il, &cmd);
-
-       return il_power_set_mode(il, &cmd, force);
-}
-EXPORT_SYMBOL(il_power_update_mode);
-
-/* initialize to default */
-void
-il_power_initialize(struct il_priv *il)
-{
-       u16 lctl;
-
-       pcie_capability_read_word(il->pci_dev, PCI_EXP_LNKCTL, &lctl);
-       il->power_data.pci_pm = !(lctl & PCI_EXP_LNKCTL_ASPM_L0S);
-
-       il->power_data.debug_sleep_level_override = -1;
-
-       memset(&il->power_data.sleep_cmd, 0, sizeof(il->power_data.sleep_cmd));
-}
-EXPORT_SYMBOL(il_power_initialize);
-
-/* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
- * sending probe req.  This should be set long enough to hear probe responses
- * from more than one AP.  */
-#define IL_ACTIVE_DWELL_TIME_24    (30)        /* all times in msec */
-#define IL_ACTIVE_DWELL_TIME_52    (20)
-
-#define IL_ACTIVE_DWELL_FACTOR_24GHZ (3)
-#define IL_ACTIVE_DWELL_FACTOR_52GHZ (2)
-
-/* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
- * Must be set longer than active dwell time.
- * For the most reliable scan, set > AP beacon interval (typically 100msec). */
-#define IL_PASSIVE_DWELL_TIME_24   (20)        /* all times in msec */
-#define IL_PASSIVE_DWELL_TIME_52   (10)
-#define IL_PASSIVE_DWELL_BASE      (100)
-#define IL_CHANNEL_TUNE_TIME       5
-
-static int
-il_send_scan_abort(struct il_priv *il)
-{
-       int ret;
-       struct il_rx_pkt *pkt;
-       struct il_host_cmd cmd = {
-               .id = C_SCAN_ABORT,
-               .flags = CMD_WANT_SKB,
-       };
-
-       /* Exit instantly with error when device is not ready
-        * to receive scan abort command or it does not perform
-        * hardware scan currently */
-       if (!test_bit(S_READY, &il->status) ||
-           !test_bit(S_GEO_CONFIGURED, &il->status) ||
-           !test_bit(S_SCAN_HW, &il->status) ||
-           test_bit(S_FW_ERROR, &il->status) ||
-           test_bit(S_EXIT_PENDING, &il->status))
-               return -EIO;
-
-       ret = il_send_cmd_sync(il, &cmd);
-       if (ret)
-               return ret;
-
-       pkt = (struct il_rx_pkt *)cmd.reply_page;
-       if (pkt->u.status != CAN_ABORT_STATUS) {
-               /* The scan abort will return 1 for success or
-                * 2 for "failure".  A failure condition can be
-                * due to simply not being in an active scan which
-                * can occur if we send the scan abort before we
-                * the microcode has notified us that a scan is
-                * completed. */
-               D_SCAN("SCAN_ABORT ret %d.\n", pkt->u.status);
-               ret = -EIO;
-       }
-
-       il_free_pages(il, cmd.reply_page);
-       return ret;
-}
-
-static void
-il_complete_scan(struct il_priv *il, bool aborted)
-{
-       /* check if scan was requested from mac80211 */
-       if (il->scan_request) {
-               D_SCAN("Complete scan in mac80211\n");
-               ieee80211_scan_completed(il->hw, aborted);
-       }
-
-       il->scan_vif = NULL;
-       il->scan_request = NULL;
-}
-
-void
-il_force_scan_end(struct il_priv *il)
-{
-       lockdep_assert_held(&il->mutex);
-
-       if (!test_bit(S_SCANNING, &il->status)) {
-               D_SCAN("Forcing scan end while not scanning\n");
-               return;
-       }
-
-       D_SCAN("Forcing scan end\n");
-       clear_bit(S_SCANNING, &il->status);
-       clear_bit(S_SCAN_HW, &il->status);
-       clear_bit(S_SCAN_ABORTING, &il->status);
-       il_complete_scan(il, true);
-}
-
-static void
-il_do_scan_abort(struct il_priv *il)
-{
-       int ret;
-
-       lockdep_assert_held(&il->mutex);
-
-       if (!test_bit(S_SCANNING, &il->status)) {
-               D_SCAN("Not performing scan to abort\n");
-               return;
-       }
-
-       if (test_and_set_bit(S_SCAN_ABORTING, &il->status)) {
-               D_SCAN("Scan abort in progress\n");
-               return;
-       }
-
-       ret = il_send_scan_abort(il);
-       if (ret) {
-               D_SCAN("Send scan abort failed %d\n", ret);
-               il_force_scan_end(il);
-       } else
-               D_SCAN("Successfully send scan abort\n");
-}
-
-/**
- * il_scan_cancel - Cancel any currently executing HW scan
- */
-int
-il_scan_cancel(struct il_priv *il)
-{
-       D_SCAN("Queuing abort scan\n");
-       queue_work(il->workqueue, &il->abort_scan);
-       return 0;
-}
-EXPORT_SYMBOL(il_scan_cancel);
-
-/**
- * il_scan_cancel_timeout - Cancel any currently executing HW scan
- * @ms: amount of time to wait (in milliseconds) for scan to abort
- *
- */
-int
-il_scan_cancel_timeout(struct il_priv *il, unsigned long ms)
-{
-       unsigned long timeout = jiffies + msecs_to_jiffies(ms);
-
-       lockdep_assert_held(&il->mutex);
-
-       D_SCAN("Scan cancel timeout\n");
-
-       il_do_scan_abort(il);
-
-       while (time_before_eq(jiffies, timeout)) {
-               if (!test_bit(S_SCAN_HW, &il->status))
-                       break;
-               msleep(20);
-       }
-
-       return test_bit(S_SCAN_HW, &il->status);
-}
-EXPORT_SYMBOL(il_scan_cancel_timeout);
-
-/* Service response to C_SCAN (0x80) */
-static void
-il_hdl_scan(struct il_priv *il, struct il_rx_buf *rxb)
-{
-#ifdef CONFIG_IWLEGACY_DEBUG
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_scanreq_notification *notif =
-           (struct il_scanreq_notification *)pkt->u.raw;
-
-       D_SCAN("Scan request status = 0x%x\n", notif->status);
-#endif
-}
-
-/* Service N_SCAN_START (0x82) */
-static void
-il_hdl_scan_start(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_scanstart_notification *notif =
-           (struct il_scanstart_notification *)pkt->u.raw;
-       il->scan_start_tsf = le32_to_cpu(notif->tsf_low);
-       D_SCAN("Scan start: " "%d [802.11%s] "
-              "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n", notif->channel,
-              notif->band ? "bg" : "a", le32_to_cpu(notif->tsf_high),
-              le32_to_cpu(notif->tsf_low), notif->status, notif->beacon_timer);
-}
-
-/* Service N_SCAN_RESULTS (0x83) */
-static void
-il_hdl_scan_results(struct il_priv *il, struct il_rx_buf *rxb)
-{
-#ifdef CONFIG_IWLEGACY_DEBUG
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_scanresults_notification *notif =
-           (struct il_scanresults_notification *)pkt->u.raw;
-
-       D_SCAN("Scan ch.res: " "%d [802.11%s] " "(TSF: 0x%08X:%08X) - %d "
-              "elapsed=%lu usec\n", notif->channel, notif->band ? "bg" : "a",
-              le32_to_cpu(notif->tsf_high), le32_to_cpu(notif->tsf_low),
-              le32_to_cpu(notif->stats[0]),
-              le32_to_cpu(notif->tsf_low) - il->scan_start_tsf);
-#endif
-}
-
-/* Service N_SCAN_COMPLETE (0x84) */
-static void
-il_hdl_scan_complete(struct il_priv *il, struct il_rx_buf *rxb)
-{
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
-#endif
-
-       D_SCAN("Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
-              scan_notif->scanned_channels, scan_notif->tsf_low,
-              scan_notif->tsf_high, scan_notif->status);
-
-       /* The HW is no longer scanning */
-       clear_bit(S_SCAN_HW, &il->status);
-
-       D_SCAN("Scan on %sGHz took %dms\n",
-              (il->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
-              jiffies_to_msecs(jiffies - il->scan_start));
-
-       queue_work(il->workqueue, &il->scan_completed);
-}
-
-void
-il_setup_rx_scan_handlers(struct il_priv *il)
-{
-       /* scan handlers */
-       il->handlers[C_SCAN] = il_hdl_scan;
-       il->handlers[N_SCAN_START] = il_hdl_scan_start;
-       il->handlers[N_SCAN_RESULTS] = il_hdl_scan_results;
-       il->handlers[N_SCAN_COMPLETE] = il_hdl_scan_complete;
-}
-EXPORT_SYMBOL(il_setup_rx_scan_handlers);
-
-u16
-il_get_active_dwell_time(struct il_priv *il, enum ieee80211_band band,
-                        u8 n_probes)
-{
-       if (band == IEEE80211_BAND_5GHZ)
-               return IL_ACTIVE_DWELL_TIME_52 +
-                   IL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
-       else
-               return IL_ACTIVE_DWELL_TIME_24 +
-                   IL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
-}
-EXPORT_SYMBOL(il_get_active_dwell_time);
-
-u16
-il_get_passive_dwell_time(struct il_priv *il, enum ieee80211_band band,
-                         struct ieee80211_vif *vif)
-{
-       u16 value;
-
-       u16 passive =
-           (band ==
-            IEEE80211_BAND_2GHZ) ? IL_PASSIVE_DWELL_BASE +
-           IL_PASSIVE_DWELL_TIME_24 : IL_PASSIVE_DWELL_BASE +
-           IL_PASSIVE_DWELL_TIME_52;
-
-       if (il_is_any_associated(il)) {
-               /*
-                * If we're associated, we clamp the maximum passive
-                * dwell time to be 98% of the smallest beacon interval
-                * (minus 2 * channel tune time)
-                */
-               value = il->vif ? il->vif->bss_conf.beacon_int : 0;
-               if (value > IL_PASSIVE_DWELL_BASE || !value)
-                       value = IL_PASSIVE_DWELL_BASE;
-               value = (value * 98) / 100 - IL_CHANNEL_TUNE_TIME * 2;
-               passive = min(value, passive);
-       }
-
-       return passive;
-}
-EXPORT_SYMBOL(il_get_passive_dwell_time);
-
-void
-il_init_scan_params(struct il_priv *il)
-{
-       u8 ant_idx = fls(il->hw_params.valid_tx_ant) - 1;
-       if (!il->scan_tx_ant[IEEE80211_BAND_5GHZ])
-               il->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
-       if (!il->scan_tx_ant[IEEE80211_BAND_2GHZ])
-               il->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
-}
-EXPORT_SYMBOL(il_init_scan_params);
-
-static int
-il_scan_initiate(struct il_priv *il, struct ieee80211_vif *vif)
-{
-       int ret;
-
-       lockdep_assert_held(&il->mutex);
-
-       cancel_delayed_work(&il->scan_check);
-
-       if (!il_is_ready_rf(il)) {
-               IL_WARN("Request scan called when driver not ready.\n");
-               return -EIO;
-       }
-
-       if (test_bit(S_SCAN_HW, &il->status)) {
-               D_SCAN("Multiple concurrent scan requests in parallel.\n");
-               return -EBUSY;
-       }
-
-       if (test_bit(S_SCAN_ABORTING, &il->status)) {
-               D_SCAN("Scan request while abort pending.\n");
-               return -EBUSY;
-       }
-
-       D_SCAN("Starting scan...\n");
-
-       set_bit(S_SCANNING, &il->status);
-       il->scan_start = jiffies;
-
-       ret = il->ops->request_scan(il, vif);
-       if (ret) {
-               clear_bit(S_SCANNING, &il->status);
-               return ret;
-       }
-
-       queue_delayed_work(il->workqueue, &il->scan_check,
-                          IL_SCAN_CHECK_WATCHDOG);
-
-       return 0;
-}
-
-int
-il_mac_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-              struct ieee80211_scan_request *hw_req)
-{
-       struct cfg80211_scan_request *req = &hw_req->req;
-       struct il_priv *il = hw->priv;
-       int ret;
-
-       if (req->n_channels == 0) {
-               IL_ERR("Can not scan on no channels.\n");
-               return -EINVAL;
-       }
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter\n");
-
-       if (test_bit(S_SCANNING, &il->status)) {
-               D_SCAN("Scan already in progress.\n");
-               ret = -EAGAIN;
-               goto out_unlock;
-       }
-
-       /* mac80211 will only ask for one band at a time */
-       il->scan_request = req;
-       il->scan_vif = vif;
-       il->scan_band = req->channels[0]->band;
-
-       ret = il_scan_initiate(il, vif);
-
-out_unlock:
-       D_MAC80211("leave ret %d\n", ret);
-       mutex_unlock(&il->mutex);
-
-       return ret;
-}
-EXPORT_SYMBOL(il_mac_hw_scan);
-
-static void
-il_bg_scan_check(struct work_struct *data)
-{
-       struct il_priv *il =
-           container_of(data, struct il_priv, scan_check.work);
-
-       D_SCAN("Scan check work\n");
-
-       /* Since we are here firmware does not finish scan and
-        * most likely is in bad shape, so we don't bother to
-        * send abort command, just force scan complete to mac80211 */
-       mutex_lock(&il->mutex);
-       il_force_scan_end(il);
-       mutex_unlock(&il->mutex);
-}
-
-/**
- * il_fill_probe_req - fill in all required fields and IE for probe request
- */
-
-u16
-il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
-                 const u8 *ta, const u8 *ies, int ie_len, int left)
-{
-       int len = 0;
-       u8 *pos = NULL;
-
-       /* Make sure there is enough space for the probe request,
-        * two mandatory IEs and the data */
-       left -= 24;
-       if (left < 0)
-               return 0;
-
-       frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
-       eth_broadcast_addr(frame->da);
-       memcpy(frame->sa, ta, ETH_ALEN);
-       eth_broadcast_addr(frame->bssid);
-       frame->seq_ctrl = 0;
-
-       len += 24;
-
-       /* ...next IE... */
-       pos = &frame->u.probe_req.variable[0];
-
-       /* fill in our indirect SSID IE */
-       left -= 2;
-       if (left < 0)
-               return 0;
-       *pos++ = WLAN_EID_SSID;
-       *pos++ = 0;
-
-       len += 2;
-
-       if (WARN_ON(left < ie_len))
-               return len;
-
-       if (ies && ie_len) {
-               memcpy(pos, ies, ie_len);
-               len += ie_len;
-       }
-
-       return (u16) len;
-}
-EXPORT_SYMBOL(il_fill_probe_req);
-
-static void
-il_bg_abort_scan(struct work_struct *work)
-{
-       struct il_priv *il = container_of(work, struct il_priv, abort_scan);
-
-       D_SCAN("Abort scan work\n");
-
-       /* We keep scan_check work queued in case when firmware will not
-        * report back scan completed notification */
-       mutex_lock(&il->mutex);
-       il_scan_cancel_timeout(il, 200);
-       mutex_unlock(&il->mutex);
-}
-
-static void
-il_bg_scan_completed(struct work_struct *work)
-{
-       struct il_priv *il = container_of(work, struct il_priv, scan_completed);
-       bool aborted;
-
-       D_SCAN("Completed scan.\n");
-
-       cancel_delayed_work(&il->scan_check);
-
-       mutex_lock(&il->mutex);
-
-       aborted = test_and_clear_bit(S_SCAN_ABORTING, &il->status);
-       if (aborted)
-               D_SCAN("Aborted scan completed.\n");
-
-       if (!test_and_clear_bit(S_SCANNING, &il->status)) {
-               D_SCAN("Scan already completed.\n");
-               goto out_settings;
-       }
-
-       il_complete_scan(il, aborted);
-
-out_settings:
-       /* Can we still talk to firmware ? */
-       if (!il_is_ready_rf(il))
-               goto out;
-
-       /*
-        * We do not commit power settings while scan is pending,
-        * do it now if the settings changed.
-        */
-       il_power_set_mode(il, &il->power_data.sleep_cmd_next, false);
-       il_set_tx_power(il, il->tx_power_next, false);
-
-       il->ops->post_scan(il);
-
-out:
-       mutex_unlock(&il->mutex);
-}
-
-void
-il_setup_scan_deferred_work(struct il_priv *il)
-{
-       INIT_WORK(&il->scan_completed, il_bg_scan_completed);
-       INIT_WORK(&il->abort_scan, il_bg_abort_scan);
-       INIT_DELAYED_WORK(&il->scan_check, il_bg_scan_check);
-}
-EXPORT_SYMBOL(il_setup_scan_deferred_work);
-
-void
-il_cancel_scan_deferred_work(struct il_priv *il)
-{
-       cancel_work_sync(&il->abort_scan);
-       cancel_work_sync(&il->scan_completed);
-
-       if (cancel_delayed_work_sync(&il->scan_check)) {
-               mutex_lock(&il->mutex);
-               il_force_scan_end(il);
-               mutex_unlock(&il->mutex);
-       }
-}
-EXPORT_SYMBOL(il_cancel_scan_deferred_work);
-
-/* il->sta_lock must be held */
-static void
-il_sta_ucode_activate(struct il_priv *il, u8 sta_id)
-{
-
-       if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE))
-               IL_ERR("ACTIVATE a non DRIVER active station id %u addr %pM\n",
-                      sta_id, il->stations[sta_id].sta.sta.addr);
-
-       if (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) {
-               D_ASSOC("STA id %u addr %pM already present"
-                       " in uCode (according to driver)\n", sta_id,
-                       il->stations[sta_id].sta.sta.addr);
-       } else {
-               il->stations[sta_id].used |= IL_STA_UCODE_ACTIVE;
-               D_ASSOC("Added STA id %u addr %pM to uCode\n", sta_id,
-                       il->stations[sta_id].sta.sta.addr);
-       }
-}
-
-static int
-il_process_add_sta_resp(struct il_priv *il, struct il_addsta_cmd *addsta,
-                       struct il_rx_pkt *pkt, bool sync)
-{
-       u8 sta_id = addsta->sta.sta_id;
-       unsigned long flags;
-       int ret = -EIO;
-
-       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
-               IL_ERR("Bad return from C_ADD_STA (0x%08X)\n", pkt->hdr.flags);
-               return ret;
-       }
-
-       D_INFO("Processing response for adding station %u\n", sta_id);
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-
-       switch (pkt->u.add_sta.status) {
-       case ADD_STA_SUCCESS_MSK:
-               D_INFO("C_ADD_STA PASSED\n");
-               il_sta_ucode_activate(il, sta_id);
-               ret = 0;
-               break;
-       case ADD_STA_NO_ROOM_IN_TBL:
-               IL_ERR("Adding station %d failed, no room in table.\n", sta_id);
-               break;
-       case ADD_STA_NO_BLOCK_ACK_RESOURCE:
-               IL_ERR("Adding station %d failed, no block ack resource.\n",
-                      sta_id);
-               break;
-       case ADD_STA_MODIFY_NON_EXIST_STA:
-               IL_ERR("Attempting to modify non-existing station %d\n",
-                      sta_id);
-               break;
-       default:
-               D_ASSOC("Received C_ADD_STA:(0x%08X)\n", pkt->u.add_sta.status);
-               break;
-       }
-
-       D_INFO("%s station id %u addr %pM\n",
-              il->stations[sta_id].sta.mode ==
-              STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", sta_id,
-              il->stations[sta_id].sta.sta.addr);
-
-       /*
-        * XXX: The MAC address in the command buffer is often changed from
-        * the original sent to the device. That is, the MAC address
-        * written to the command buffer often is not the same MAC address
-        * read from the command buffer when the command returns. This
-        * issue has not yet been resolved and this debugging is left to
-        * observe the problem.
-        */
-       D_INFO("%s station according to cmd buffer %pM\n",
-              il->stations[sta_id].sta.mode ==
-              STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", addsta->sta.addr);
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return ret;
-}
-
-static void
-il_add_sta_callback(struct il_priv *il, struct il_device_cmd *cmd,
-                   struct il_rx_pkt *pkt)
-{
-       struct il_addsta_cmd *addsta = (struct il_addsta_cmd *)cmd->cmd.payload;
-
-       il_process_add_sta_resp(il, addsta, pkt, false);
-
-}
-
-int
-il_send_add_sta(struct il_priv *il, struct il_addsta_cmd *sta, u8 flags)
-{
-       struct il_rx_pkt *pkt = NULL;
-       int ret = 0;
-       u8 data[sizeof(*sta)];
-       struct il_host_cmd cmd = {
-               .id = C_ADD_STA,
-               .flags = flags,
-               .data = data,
-       };
-       u8 sta_id __maybe_unused = sta->sta.sta_id;
-
-       D_INFO("Adding sta %u (%pM) %ssynchronously\n", sta_id, sta->sta.addr,
-              flags & CMD_ASYNC ? "a" : "");
-
-       if (flags & CMD_ASYNC)
-               cmd.callback = il_add_sta_callback;
-       else {
-               cmd.flags |= CMD_WANT_SKB;
-               might_sleep();
-       }
-
-       cmd.len = il->ops->build_addsta_hcmd(sta, data);
-       ret = il_send_cmd(il, &cmd);
-
-       if (ret || (flags & CMD_ASYNC))
-               return ret;
-
-       if (ret == 0) {
-               pkt = (struct il_rx_pkt *)cmd.reply_page;
-               ret = il_process_add_sta_resp(il, sta, pkt, true);
-       }
-       il_free_pages(il, cmd.reply_page);
-
-       return ret;
-}
-EXPORT_SYMBOL(il_send_add_sta);
-
-static void
-il_set_ht_add_station(struct il_priv *il, u8 idx, struct ieee80211_sta *sta)
-{
-       struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->ht_cap;
-       __le32 sta_flags;
-
-       if (!sta || !sta_ht_inf->ht_supported)
-               goto done;
-
-       D_ASSOC("spatial multiplexing power save mode: %s\n",
-               (sta->smps_mode == IEEE80211_SMPS_STATIC) ? "static" :
-               (sta->smps_mode == IEEE80211_SMPS_DYNAMIC) ? "dynamic" :
-               "disabled");
-
-       sta_flags = il->stations[idx].sta.station_flags;
-
-       sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK);
-
-       switch (sta->smps_mode) {
-       case IEEE80211_SMPS_STATIC:
-               sta_flags |= STA_FLG_MIMO_DIS_MSK;
-               break;
-       case IEEE80211_SMPS_DYNAMIC:
-               sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK;
-               break;
-       case IEEE80211_SMPS_OFF:
-               break;
-       default:
-               IL_WARN("Invalid MIMO PS mode %d\n", sta->smps_mode);
-               break;
-       }
-
-       sta_flags |=
-           cpu_to_le32((u32) sta_ht_inf->
-                       ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);
-
-       sta_flags |=
-           cpu_to_le32((u32) sta_ht_inf->
-                       ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);
-
-       if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
-               sta_flags |= STA_FLG_HT40_EN_MSK;
-       else
-               sta_flags &= ~STA_FLG_HT40_EN_MSK;
-
-       il->stations[idx].sta.station_flags = sta_flags;
-done:
-       return;
-}
-
-/**
- * il_prep_station - Prepare station information for addition
- *
- * should be called with sta_lock held
- */
-u8
-il_prep_station(struct il_priv *il, const u8 *addr, bool is_ap,
-               struct ieee80211_sta *sta)
-{
-       struct il_station_entry *station;
-       int i;
-       u8 sta_id = IL_INVALID_STATION;
-       u16 rate;
-
-       if (is_ap)
-               sta_id = IL_AP_ID;
-       else if (is_broadcast_ether_addr(addr))
-               sta_id = il->hw_params.bcast_id;
-       else
-               for (i = IL_STA_ID; i < il->hw_params.max_stations; i++) {
-                       if (ether_addr_equal(il->stations[i].sta.sta.addr,
-                                            addr)) {
-                               sta_id = i;
-                               break;
-                       }
-
-                       if (!il->stations[i].used &&
-                           sta_id == IL_INVALID_STATION)
-                               sta_id = i;
-               }
-
-       /*
-        * These two conditions have the same outcome, but keep them
-        * separate
-        */
-       if (unlikely(sta_id == IL_INVALID_STATION))
-               return sta_id;
-
-       /*
-        * uCode is not able to deal with multiple requests to add a
-        * station. Keep track if one is in progress so that we do not send
-        * another.
-        */
-       if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) {
-               D_INFO("STA %d already in process of being added.\n", sta_id);
-               return sta_id;
-       }
-
-       if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) &&
-           (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) &&
-           ether_addr_equal(il->stations[sta_id].sta.sta.addr, addr)) {
-               D_ASSOC("STA %d (%pM) already added, not adding again.\n",
-                       sta_id, addr);
-               return sta_id;
-       }
-
-       station = &il->stations[sta_id];
-       station->used = IL_STA_DRIVER_ACTIVE;
-       D_ASSOC("Add STA to driver ID %d: %pM\n", sta_id, addr);
-       il->num_stations++;
-
-       /* Set up the C_ADD_STA command to send to device */
-       memset(&station->sta, 0, sizeof(struct il_addsta_cmd));
-       memcpy(station->sta.sta.addr, addr, ETH_ALEN);
-       station->sta.mode = 0;
-       station->sta.sta.sta_id = sta_id;
-       station->sta.station_flags = 0;
-
-       /*
-        * OK to call unconditionally, since local stations (IBSS BSSID
-        * STA and broadcast STA) pass in a NULL sta, and mac80211
-        * doesn't allow HT IBSS.
-        */
-       il_set_ht_add_station(il, sta_id, sta);
-
-       /* 3945 only */
-       rate = (il->band == IEEE80211_BAND_5GHZ) ? RATE_6M_PLCP : RATE_1M_PLCP;
-       /* Turn on both antennas for the station... */
-       station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK);
-
-       return sta_id;
-
-}
-EXPORT_SYMBOL_GPL(il_prep_station);
-
-#define STA_WAIT_TIMEOUT (HZ/2)
-
-/**
- * il_add_station_common -
- */
-int
-il_add_station_common(struct il_priv *il, const u8 *addr, bool is_ap,
-                     struct ieee80211_sta *sta, u8 *sta_id_r)
-{
-       unsigned long flags_spin;
-       int ret = 0;
-       u8 sta_id;
-       struct il_addsta_cmd sta_cmd;
-
-       *sta_id_r = 0;
-       spin_lock_irqsave(&il->sta_lock, flags_spin);
-       sta_id = il_prep_station(il, addr, is_ap, sta);
-       if (sta_id == IL_INVALID_STATION) {
-               IL_ERR("Unable to prepare station %pM for addition\n", addr);
-               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-               return -EINVAL;
-       }
-
-       /*
-        * uCode is not able to deal with multiple requests to add a
-        * station. Keep track if one is in progress so that we do not send
-        * another.
-        */
-       if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) {
-               D_INFO("STA %d already in process of being added.\n", sta_id);
-               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-               return -EEXIST;
-       }
-
-       if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) &&
-           (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) {
-               D_ASSOC("STA %d (%pM) already added, not adding again.\n",
-                       sta_id, addr);
-               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-               return -EEXIST;
-       }
-
-       il->stations[sta_id].used |= IL_STA_UCODE_INPROGRESS;
-       memcpy(&sta_cmd, &il->stations[sta_id].sta,
-              sizeof(struct il_addsta_cmd));
-       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-
-       /* Add station to device's station table */
-       ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-       if (ret) {
-               spin_lock_irqsave(&il->sta_lock, flags_spin);
-               IL_ERR("Adding station %pM failed.\n",
-                      il->stations[sta_id].sta.sta.addr);
-               il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE;
-               il->stations[sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
-               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-       }
-       *sta_id_r = sta_id;
-       return ret;
-}
-EXPORT_SYMBOL(il_add_station_common);
-
-/**
- * il_sta_ucode_deactivate - deactivate ucode status for a station
- *
- * il->sta_lock must be held
- */
-static void
-il_sta_ucode_deactivate(struct il_priv *il, u8 sta_id)
-{
-       /* Ucode must be active and driver must be non active */
-       if ((il->stations[sta_id].
-            used & (IL_STA_UCODE_ACTIVE | IL_STA_DRIVER_ACTIVE)) !=
-           IL_STA_UCODE_ACTIVE)
-               IL_ERR("removed non active STA %u\n", sta_id);
-
-       il->stations[sta_id].used &= ~IL_STA_UCODE_ACTIVE;
-
-       memset(&il->stations[sta_id], 0, sizeof(struct il_station_entry));
-       D_ASSOC("Removed STA %u\n", sta_id);
-}
-
-static int
-il_send_remove_station(struct il_priv *il, const u8 * addr, int sta_id,
-                      bool temporary)
-{
-       struct il_rx_pkt *pkt;
-       int ret;
-
-       unsigned long flags_spin;
-       struct il_rem_sta_cmd rm_sta_cmd;
-
-       struct il_host_cmd cmd = {
-               .id = C_REM_STA,
-               .len = sizeof(struct il_rem_sta_cmd),
-               .flags = CMD_SYNC,
-               .data = &rm_sta_cmd,
-       };
-
-       memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
-       rm_sta_cmd.num_sta = 1;
-       memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN);
-
-       cmd.flags |= CMD_WANT_SKB;
-
-       ret = il_send_cmd(il, &cmd);
-
-       if (ret)
-               return ret;
-
-       pkt = (struct il_rx_pkt *)cmd.reply_page;
-       if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
-               IL_ERR("Bad return from C_REM_STA (0x%08X)\n", pkt->hdr.flags);
-               ret = -EIO;
-       }
-
-       if (!ret) {
-               switch (pkt->u.rem_sta.status) {
-               case REM_STA_SUCCESS_MSK:
-                       if (!temporary) {
-                               spin_lock_irqsave(&il->sta_lock, flags_spin);
-                               il_sta_ucode_deactivate(il, sta_id);
-                               spin_unlock_irqrestore(&il->sta_lock,
-                                                      flags_spin);
-                       }
-                       D_ASSOC("C_REM_STA PASSED\n");
-                       break;
-               default:
-                       ret = -EIO;
-                       IL_ERR("C_REM_STA failed\n");
-                       break;
-               }
-       }
-       il_free_pages(il, cmd.reply_page);
-
-       return ret;
-}
-
-/**
- * il_remove_station - Remove driver's knowledge of station.
- */
-int
-il_remove_station(struct il_priv *il, const u8 sta_id, const u8 * addr)
-{
-       unsigned long flags;
-
-       if (!il_is_ready(il)) {
-               D_INFO("Unable to remove station %pM, device not ready.\n",
-                      addr);
-               /*
-                * It is typical for stations to be removed when we are
-                * going down. Return success since device will be down
-                * soon anyway
-                */
-               return 0;
-       }
-
-       D_ASSOC("Removing STA from driver:%d  %pM\n", sta_id, addr);
-
-       if (WARN_ON(sta_id == IL_INVALID_STATION))
-               return -EINVAL;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-
-       if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE)) {
-               D_INFO("Removing %pM but non DRIVER active\n", addr);
-               goto out_err;
-       }
-
-       if (!(il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) {
-               D_INFO("Removing %pM but non UCODE active\n", addr);
-               goto out_err;
-       }
-
-       if (il->stations[sta_id].used & IL_STA_LOCAL) {
-               kfree(il->stations[sta_id].lq);
-               il->stations[sta_id].lq = NULL;
-       }
-
-       il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE;
-
-       il->num_stations--;
-
-       BUG_ON(il->num_stations < 0);
-
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-
-       return il_send_remove_station(il, addr, sta_id, false);
-out_err:
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-       return -EINVAL;
-}
-EXPORT_SYMBOL_GPL(il_remove_station);
-
-/**
- * il_clear_ucode_stations - clear ucode station table bits
- *
- * This function clears all the bits in the driver indicating
- * which stations are active in the ucode. Call when something
- * other than explicit station management would cause this in
- * the ucode, e.g. unassociated RXON.
- */
-void
-il_clear_ucode_stations(struct il_priv *il)
-{
-       int i;
-       unsigned long flags_spin;
-       bool cleared = false;
-
-       D_INFO("Clearing ucode stations in driver\n");
-
-       spin_lock_irqsave(&il->sta_lock, flags_spin);
-       for (i = 0; i < il->hw_params.max_stations; i++) {
-               if (il->stations[i].used & IL_STA_UCODE_ACTIVE) {
-                       D_INFO("Clearing ucode active for station %d\n", i);
-                       il->stations[i].used &= ~IL_STA_UCODE_ACTIVE;
-                       cleared = true;
-               }
-       }
-       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-
-       if (!cleared)
-               D_INFO("No active stations found to be cleared\n");
-}
-EXPORT_SYMBOL(il_clear_ucode_stations);
-
-/**
- * il_restore_stations() - Restore driver known stations to device
- *
- * All stations considered active by driver, but not present in ucode, is
- * restored.
- *
- * Function sleeps.
- */
-void
-il_restore_stations(struct il_priv *il)
-{
-       struct il_addsta_cmd sta_cmd;
-       struct il_link_quality_cmd lq;
-       unsigned long flags_spin;
-       int i;
-       bool found = false;
-       int ret;
-       bool send_lq;
-
-       if (!il_is_ready(il)) {
-               D_INFO("Not ready yet, not restoring any stations.\n");
-               return;
-       }
-
-       D_ASSOC("Restoring all known stations ... start.\n");
-       spin_lock_irqsave(&il->sta_lock, flags_spin);
-       for (i = 0; i < il->hw_params.max_stations; i++) {
-               if ((il->stations[i].used & IL_STA_DRIVER_ACTIVE) &&
-                   !(il->stations[i].used & IL_STA_UCODE_ACTIVE)) {
-                       D_ASSOC("Restoring sta %pM\n",
-                               il->stations[i].sta.sta.addr);
-                       il->stations[i].sta.mode = 0;
-                       il->stations[i].used |= IL_STA_UCODE_INPROGRESS;
-                       found = true;
-               }
-       }
-
-       for (i = 0; i < il->hw_params.max_stations; i++) {
-               if ((il->stations[i].used & IL_STA_UCODE_INPROGRESS)) {
-                       memcpy(&sta_cmd, &il->stations[i].sta,
-                              sizeof(struct il_addsta_cmd));
-                       send_lq = false;
-                       if (il->stations[i].lq) {
-                               memcpy(&lq, il->stations[i].lq,
-                                      sizeof(struct il_link_quality_cmd));
-                               send_lq = true;
-                       }
-                       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-                       ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC);
-                       if (ret) {
-                               spin_lock_irqsave(&il->sta_lock, flags_spin);
-                               IL_ERR("Adding station %pM failed.\n",
-                                      il->stations[i].sta.sta.addr);
-                               il->stations[i].used &= ~IL_STA_DRIVER_ACTIVE;
-                               il->stations[i].used &=
-                                   ~IL_STA_UCODE_INPROGRESS;
-                               spin_unlock_irqrestore(&il->sta_lock,
-                                                      flags_spin);
-                       }
-                       /*
-                        * Rate scaling has already been initialized, send
-                        * current LQ command
-                        */
-                       if (send_lq)
-                               il_send_lq_cmd(il, &lq, CMD_SYNC, true);
-                       spin_lock_irqsave(&il->sta_lock, flags_spin);
-                       il->stations[i].used &= ~IL_STA_UCODE_INPROGRESS;
-               }
-       }
-
-       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-       if (!found)
-               D_INFO("Restoring all known stations"
-                      " .... no stations to be restored.\n");
-       else
-               D_INFO("Restoring all known stations" " .... complete.\n");
-}
-EXPORT_SYMBOL(il_restore_stations);
-
-int
-il_get_free_ucode_key_idx(struct il_priv *il)
-{
-       int i;
-
-       for (i = 0; i < il->sta_key_max_num; i++)
-               if (!test_and_set_bit(i, &il->ucode_key_table))
-                       return i;
-
-       return WEP_INVALID_OFFSET;
-}
-EXPORT_SYMBOL(il_get_free_ucode_key_idx);
-
-void
-il_dealloc_bcast_stations(struct il_priv *il)
-{
-       unsigned long flags;
-       int i;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       for (i = 0; i < il->hw_params.max_stations; i++) {
-               if (!(il->stations[i].used & IL_STA_BCAST))
-                       continue;
-
-               il->stations[i].used &= ~IL_STA_UCODE_ACTIVE;
-               il->num_stations--;
-               BUG_ON(il->num_stations < 0);
-               kfree(il->stations[i].lq);
-               il->stations[i].lq = NULL;
-       }
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-}
-EXPORT_SYMBOL_GPL(il_dealloc_bcast_stations);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-static void
-il_dump_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq)
-{
-       int i;
-       D_RATE("lq station id 0x%x\n", lq->sta_id);
-       D_RATE("lq ant 0x%X 0x%X\n", lq->general_params.single_stream_ant_msk,
-              lq->general_params.dual_stream_ant_msk);
-
-       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
-               D_RATE("lq idx %d 0x%X\n", i, lq->rs_table[i].rate_n_flags);
-}
-#else
-static inline void
-il_dump_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq)
-{
-}
-#endif
-
-/**
- * il_is_lq_table_valid() - Test one aspect of LQ cmd for validity
- *
- * It sometimes happens when a HT rate has been in use and we
- * loose connectivity with AP then mac80211 will first tell us that the
- * current channel is not HT anymore before removing the station. In such a
- * scenario the RXON flags will be updated to indicate we are not
- * communicating HT anymore, but the LQ command may still contain HT rates.
- * Test for this to prevent driver from sending LQ command between the time
- * RXON flags are updated and when LQ command is updated.
- */
-static bool
-il_is_lq_table_valid(struct il_priv *il, struct il_link_quality_cmd *lq)
-{
-       int i;
-
-       if (il->ht.enabled)
-               return true;
-
-       D_INFO("Channel %u is not an HT channel\n", il->active.channel);
-       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
-               if (le32_to_cpu(lq->rs_table[i].rate_n_flags) & RATE_MCS_HT_MSK) {
-                       D_INFO("idx %d of LQ expects HT channel\n", i);
-                       return false;
-               }
-       }
-       return true;
-}
-
-/**
- * il_send_lq_cmd() - Send link quality command
- * @init: This command is sent as part of station initialization right
- *        after station has been added.
- *
- * The link quality command is sent as the last step of station creation.
- * This is the special case in which init is set and we call a callback in
- * this case to clear the state indicating that station creation is in
- * progress.
- */
-int
-il_send_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq,
-              u8 flags, bool init)
-{
-       int ret = 0;
-       unsigned long flags_spin;
-
-       struct il_host_cmd cmd = {
-               .id = C_TX_LINK_QUALITY_CMD,
-               .len = sizeof(struct il_link_quality_cmd),
-               .flags = flags,
-               .data = lq,
-       };
-
-       if (WARN_ON(lq->sta_id == IL_INVALID_STATION))
-               return -EINVAL;
-
-       spin_lock_irqsave(&il->sta_lock, flags_spin);
-       if (!(il->stations[lq->sta_id].used & IL_STA_DRIVER_ACTIVE)) {
-               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-               return -EINVAL;
-       }
-       spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-
-       il_dump_lq_cmd(il, lq);
-       BUG_ON(init && (cmd.flags & CMD_ASYNC));
-
-       if (il_is_lq_table_valid(il, lq))
-               ret = il_send_cmd(il, &cmd);
-       else
-               ret = -EINVAL;
-
-       if (cmd.flags & CMD_ASYNC)
-               return ret;
-
-       if (init) {
-               D_INFO("init LQ command complete,"
-                      " clearing sta addition status for sta %d\n",
-                      lq->sta_id);
-               spin_lock_irqsave(&il->sta_lock, flags_spin);
-               il->stations[lq->sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
-               spin_unlock_irqrestore(&il->sta_lock, flags_spin);
-       }
-       return ret;
-}
-EXPORT_SYMBOL(il_send_lq_cmd);
-
-int
-il_mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                 struct ieee80211_sta *sta)
-{
-       struct il_priv *il = hw->priv;
-       struct il_station_priv_common *sta_common = (void *)sta->drv_priv;
-       int ret;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter station %pM\n", sta->addr);
-
-       ret = il_remove_station(il, sta_common->sta_id, sta->addr);
-       if (ret)
-               IL_ERR("Error removing station %pM\n", sta->addr);
-
-       D_MAC80211("leave ret %d\n", ret);
-       mutex_unlock(&il->mutex);
-
-       return ret;
-}
-EXPORT_SYMBOL(il_mac_sta_remove);
-
-/************************** RX-FUNCTIONS ****************************/
-/*
- * Rx theory of operation
- *
- * Driver allocates a circular buffer of Receive Buffer Descriptors (RBDs),
- * each of which point to Receive Buffers to be filled by the NIC.  These get
- * used not only for Rx frames, but for any command response or notification
- * from the NIC.  The driver and NIC manage the Rx buffers by means
- * of idxes into the circular buffer.
- *
- * Rx Queue Indexes
- * The host/firmware share two idx registers for managing the Rx buffers.
- *
- * The READ idx maps to the first position that the firmware may be writing
- * to -- the driver can read up to (but not including) this position and get
- * good data.
- * The READ idx is managed by the firmware once the card is enabled.
- *
- * The WRITE idx maps to the last position the driver has read from -- the
- * position preceding WRITE is the last slot the firmware can place a packet.
- *
- * The queue is empty (no good data) if WRITE = READ - 1, and is full if
- * WRITE = READ.
- *
- * During initialization, the host sets up the READ queue position to the first
- * IDX position, and WRITE to the last (READ - 1 wrapped)
- *
- * When the firmware places a packet in a buffer, it will advance the READ idx
- * and fire the RX interrupt.  The driver can then query the READ idx and
- * process as many packets as possible, moving the WRITE idx forward as it
- * resets the Rx queue buffers with new memory.
- *
- * The management in the driver is as follows:
- * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free.  When
- *   iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
- *   to replenish the iwl->rxq->rx_free.
- * + In il_rx_replenish (scheduled) if 'processed' != 'read' then the
- *   iwl->rxq is replenished and the READ IDX is updated (updating the
- *   'processed' and 'read' driver idxes as well)
- * + A received packet is processed and handed to the kernel network stack,
- *   detached from the iwl->rxq.  The driver 'processed' idx is updated.
- * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
- *   list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
- *   IDX is not incremented and iwl->status(RX_STALLED) is set.  If there
- *   were enough free buffers and RX_STALLED is set it is cleared.
- *
- *
- * Driver sequence:
- *
- * il_rx_queue_alloc()   Allocates rx_free
- * il_rx_replenish()     Replenishes rx_free list from rx_used, and calls
- *                            il_rx_queue_restock
- * il_rx_queue_restock() Moves available buffers from rx_free into Rx
- *                            queue, updates firmware pointers, and updates
- *                            the WRITE idx.  If insufficient rx_free buffers
- *                            are available, schedules il_rx_replenish
- *
- * -- enable interrupts --
- * ISR - il_rx()         Detach il_rx_bufs from pool up to the
- *                            READ IDX, detaching the SKB from the pool.
- *                            Moves the packet buffer from queue to rx_used.
- *                            Calls il_rx_queue_restock to refill any empty
- *                            slots.
- * ...
- *
- */
-
-/**
- * il_rx_queue_space - Return number of free slots available in queue.
- */
-int
-il_rx_queue_space(const struct il_rx_queue *q)
-{
-       int s = q->read - q->write;
-       if (s <= 0)
-               s += RX_QUEUE_SIZE;
-       /* keep some buffer to not confuse full and empty queue */
-       s -= 2;
-       if (s < 0)
-               s = 0;
-       return s;
-}
-EXPORT_SYMBOL(il_rx_queue_space);
-
-/**
- * il_rx_queue_update_write_ptr - Update the write pointer for the RX queue
- */
-void
-il_rx_queue_update_write_ptr(struct il_priv *il, struct il_rx_queue *q)
-{
-       unsigned long flags;
-       u32 rx_wrt_ptr_reg = il->hw_params.rx_wrt_ptr_reg;
-       u32 reg;
-
-       spin_lock_irqsave(&q->lock, flags);
-
-       if (q->need_update == 0)
-               goto exit_unlock;
-
-       /* If power-saving is in use, make sure device is awake */
-       if (test_bit(S_POWER_PMI, &il->status)) {
-               reg = _il_rd(il, CSR_UCODE_DRV_GP1);
-
-               if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
-                       D_INFO("Rx queue requesting wakeup," " GP1 = 0x%x\n",
-                              reg);
-                       il_set_bit(il, CSR_GP_CNTRL,
-                                  CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-                       goto exit_unlock;
-               }
-
-               q->write_actual = (q->write & ~0x7);
-               il_wr(il, rx_wrt_ptr_reg, q->write_actual);
-
-               /* Else device is assumed to be awake */
-       } else {
-               /* Device expects a multiple of 8 */
-               q->write_actual = (q->write & ~0x7);
-               il_wr(il, rx_wrt_ptr_reg, q->write_actual);
-       }
-
-       q->need_update = 0;
-
-exit_unlock:
-       spin_unlock_irqrestore(&q->lock, flags);
-}
-EXPORT_SYMBOL(il_rx_queue_update_write_ptr);
-
-int
-il_rx_queue_alloc(struct il_priv *il)
-{
-       struct il_rx_queue *rxq = &il->rxq;
-       struct device *dev = &il->pci_dev->dev;
-       int i;
-
-       spin_lock_init(&rxq->lock);
-       INIT_LIST_HEAD(&rxq->rx_free);
-       INIT_LIST_HEAD(&rxq->rx_used);
-
-       /* Alloc the circular buffer of Read Buffer Descriptors (RBDs) */
-       rxq->bd = dma_alloc_coherent(dev, 4 * RX_QUEUE_SIZE, &rxq->bd_dma,
-                                    GFP_KERNEL);
-       if (!rxq->bd)
-               goto err_bd;
-
-       rxq->rb_stts = dma_alloc_coherent(dev, sizeof(struct il_rb_status),
-                                         &rxq->rb_stts_dma, GFP_KERNEL);
-       if (!rxq->rb_stts)
-               goto err_rb;
-
-       /* Fill the rx_used queue with _all_ of the Rx buffers */
-       for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
-               list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
-
-       /* Set us so that we have processed and used all buffers, but have
-        * not restocked the Rx queue with fresh buffers */
-       rxq->read = rxq->write = 0;
-       rxq->write_actual = 0;
-       rxq->free_count = 0;
-       rxq->need_update = 0;
-       return 0;
-
-err_rb:
-       dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
-                         rxq->bd_dma);
-err_bd:
-       return -ENOMEM;
-}
-EXPORT_SYMBOL(il_rx_queue_alloc);
-
-void
-il_hdl_spectrum_measurement(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_spectrum_notification *report = &(pkt->u.spectrum_notif);
-
-       if (!report->state) {
-               D_11H("Spectrum Measure Notification: Start\n");
-               return;
-       }
-
-       memcpy(&il->measure_report, report, sizeof(*report));
-       il->measurement_status |= MEASUREMENT_READY;
-}
-EXPORT_SYMBOL(il_hdl_spectrum_measurement);
-
-/*
- * returns non-zero if packet should be dropped
- */
-int
-il_set_decrypted_flag(struct il_priv *il, struct ieee80211_hdr *hdr,
-                     u32 decrypt_res, struct ieee80211_rx_status *stats)
-{
-       u16 fc = le16_to_cpu(hdr->frame_control);
-
-       /*
-        * All contexts have the same setting here due to it being
-        * a module parameter, so OK to check any context.
-        */
-       if (il->active.filter_flags & RXON_FILTER_DIS_DECRYPT_MSK)
-               return 0;
-
-       if (!(fc & IEEE80211_FCTL_PROTECTED))
-               return 0;
-
-       D_RX("decrypt_res:0x%x\n", decrypt_res);
-       switch (decrypt_res & RX_RES_STATUS_SEC_TYPE_MSK) {
-       case RX_RES_STATUS_SEC_TYPE_TKIP:
-               /* The uCode has got a bad phase 1 Key, pushes the packet.
-                * Decryption will be done in SW. */
-               if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
-                   RX_RES_STATUS_BAD_KEY_TTAK)
-                       break;
-
-       case RX_RES_STATUS_SEC_TYPE_WEP:
-               if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
-                   RX_RES_STATUS_BAD_ICV_MIC) {
-                       /* bad ICV, the packet is destroyed since the
-                        * decryption is inplace, drop it */
-                       D_RX("Packet destroyed\n");
-                       return -1;
-               }
-       case RX_RES_STATUS_SEC_TYPE_CCMP:
-               if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
-                   RX_RES_STATUS_DECRYPT_OK) {
-                       D_RX("hw decrypt successfully!!!\n");
-                       stats->flag |= RX_FLAG_DECRYPTED;
-               }
-               break;
-
-       default:
-               break;
-       }
-       return 0;
-}
-EXPORT_SYMBOL(il_set_decrypted_flag);
-
-/**
- * il_txq_update_write_ptr - Send new write idx to hardware
- */
-void
-il_txq_update_write_ptr(struct il_priv *il, struct il_tx_queue *txq)
-{
-       u32 reg = 0;
-       int txq_id = txq->q.id;
-
-       if (txq->need_update == 0)
-               return;
-
-       /* if we're trying to save power */
-       if (test_bit(S_POWER_PMI, &il->status)) {
-               /* wake up nic if it's powered down ...
-                * uCode will wake up, and interrupt us again, so next
-                * time we'll skip this part. */
-               reg = _il_rd(il, CSR_UCODE_DRV_GP1);
-
-               if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
-                       D_INFO("Tx queue %d requesting wakeup," " GP1 = 0x%x\n",
-                              txq_id, reg);
-                       il_set_bit(il, CSR_GP_CNTRL,
-                                  CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-                       return;
-               }
-
-               il_wr(il, HBUS_TARG_WRPTR, txq->q.write_ptr | (txq_id << 8));
-
-               /*
-                * else not in power-save mode,
-                * uCode will never sleep when we're
-                * trying to tx (during RFKILL, we're not trying to tx).
-                */
-       } else
-               _il_wr(il, HBUS_TARG_WRPTR, txq->q.write_ptr | (txq_id << 8));
-       txq->need_update = 0;
-}
-EXPORT_SYMBOL(il_txq_update_write_ptr);
-
-/**
- * il_tx_queue_unmap -  Unmap any remaining DMA mappings and free skb's
- */
-void
-il_tx_queue_unmap(struct il_priv *il, int txq_id)
-{
-       struct il_tx_queue *txq = &il->txq[txq_id];
-       struct il_queue *q = &txq->q;
-
-       if (q->n_bd == 0)
-               return;
-
-       while (q->write_ptr != q->read_ptr) {
-               il->ops->txq_free_tfd(il, txq);
-               q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd);
-       }
-}
-EXPORT_SYMBOL(il_tx_queue_unmap);
-
-/**
- * il_tx_queue_free - Deallocate DMA queue.
- * @txq: Transmit queue to deallocate.
- *
- * Empty queue by removing and destroying all BD's.
- * Free all buffers.
- * 0-fill, but do not free "txq" descriptor structure.
- */
-void
-il_tx_queue_free(struct il_priv *il, int txq_id)
-{
-       struct il_tx_queue *txq = &il->txq[txq_id];
-       struct device *dev = &il->pci_dev->dev;
-       int i;
-
-       il_tx_queue_unmap(il, txq_id);
-
-       /* De-alloc array of command/tx buffers */
-       for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
-               kfree(txq->cmd[i]);
-
-       /* De-alloc circular buffer of TFDs */
-       if (txq->q.n_bd)
-               dma_free_coherent(dev, il->hw_params.tfd_size * txq->q.n_bd,
-                                 txq->tfds, txq->q.dma_addr);
-
-       /* De-alloc array of per-TFD driver data */
-       kfree(txq->skbs);
-       txq->skbs = NULL;
-
-       /* deallocate arrays */
-       kfree(txq->cmd);
-       kfree(txq->meta);
-       txq->cmd = NULL;
-       txq->meta = NULL;
-
-       /* 0-fill queue descriptor structure */
-       memset(txq, 0, sizeof(*txq));
-}
-EXPORT_SYMBOL(il_tx_queue_free);
-
-/**
- * il_cmd_queue_unmap - Unmap any remaining DMA mappings from command queue
- */
-void
-il_cmd_queue_unmap(struct il_priv *il)
-{
-       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
-       struct il_queue *q = &txq->q;
-       int i;
-
-       if (q->n_bd == 0)
-               return;
-
-       while (q->read_ptr != q->write_ptr) {
-               i = il_get_cmd_idx(q, q->read_ptr, 0);
-
-               if (txq->meta[i].flags & CMD_MAPPED) {
-                       pci_unmap_single(il->pci_dev,
-                                        dma_unmap_addr(&txq->meta[i], mapping),
-                                        dma_unmap_len(&txq->meta[i], len),
-                                        PCI_DMA_BIDIRECTIONAL);
-                       txq->meta[i].flags = 0;
-               }
-
-               q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd);
-       }
-
-       i = q->n_win;
-       if (txq->meta[i].flags & CMD_MAPPED) {
-               pci_unmap_single(il->pci_dev,
-                                dma_unmap_addr(&txq->meta[i], mapping),
-                                dma_unmap_len(&txq->meta[i], len),
-                                PCI_DMA_BIDIRECTIONAL);
-               txq->meta[i].flags = 0;
-       }
-}
-EXPORT_SYMBOL(il_cmd_queue_unmap);
-
-/**
- * il_cmd_queue_free - Deallocate DMA queue.
- * @txq: Transmit queue to deallocate.
- *
- * Empty queue by removing and destroying all BD's.
- * Free all buffers.
- * 0-fill, but do not free "txq" descriptor structure.
- */
-void
-il_cmd_queue_free(struct il_priv *il)
-{
-       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
-       struct device *dev = &il->pci_dev->dev;
-       int i;
-
-       il_cmd_queue_unmap(il);
-
-       /* De-alloc array of command/tx buffers */
-       for (i = 0; i <= TFD_CMD_SLOTS; i++)
-               kfree(txq->cmd[i]);
-
-       /* De-alloc circular buffer of TFDs */
-       if (txq->q.n_bd)
-               dma_free_coherent(dev, il->hw_params.tfd_size * txq->q.n_bd,
-                                 txq->tfds, txq->q.dma_addr);
-
-       /* deallocate arrays */
-       kfree(txq->cmd);
-       kfree(txq->meta);
-       txq->cmd = NULL;
-       txq->meta = NULL;
-
-       /* 0-fill queue descriptor structure */
-       memset(txq, 0, sizeof(*txq));
-}
-EXPORT_SYMBOL(il_cmd_queue_free);
-
-/*************** DMA-QUEUE-GENERAL-FUNCTIONS  *****
- * DMA services
- *
- * Theory of operation
- *
- * A Tx or Rx queue resides in host DRAM, and is comprised of a circular buffer
- * of buffer descriptors, each of which points to one or more data buffers for
- * the device to read from or fill.  Driver and device exchange status of each
- * queue via "read" and "write" pointers.  Driver keeps minimum of 2 empty
- * entries in each circular buffer, to protect against confusing empty and full
- * queue states.
- *
- * The device reads or writes the data in the queues via the device's several
- * DMA/FIFO channels.  Each queue is mapped to a single DMA channel.
- *
- * For Tx queue, there are low mark and high mark limits. If, after queuing
- * the packet for Tx, free space become < low mark, Tx queue stopped. When
- * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
- * Tx queue resumed.
- *
- * See more detailed info in 4965.h.
- ***************************************************/
-
-int
-il_queue_space(const struct il_queue *q)
-{
-       int s = q->read_ptr - q->write_ptr;
-
-       if (q->read_ptr > q->write_ptr)
-               s -= q->n_bd;
-
-       if (s <= 0)
-               s += q->n_win;
-       /* keep some reserve to not confuse empty and full situations */
-       s -= 2;
-       if (s < 0)
-               s = 0;
-       return s;
-}
-EXPORT_SYMBOL(il_queue_space);
-
-
-/**
- * il_queue_init - Initialize queue's high/low-water and read/write idxes
- */
-static int
-il_queue_init(struct il_priv *il, struct il_queue *q, int slots, u32 id)
-{
-       /*
-        * TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
-        * il_queue_inc_wrap and il_queue_dec_wrap are broken.
-        */
-       BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
-       /* FIXME: remove q->n_bd */
-       q->n_bd = TFD_QUEUE_SIZE_MAX;
-
-       q->n_win = slots;
-       q->id = id;
-
-       /* slots_must be power-of-two size, otherwise
-        * il_get_cmd_idx is broken. */
-       BUG_ON(!is_power_of_2(slots));
-
-       q->low_mark = q->n_win / 4;
-       if (q->low_mark < 4)
-               q->low_mark = 4;
-
-       q->high_mark = q->n_win / 8;
-       if (q->high_mark < 2)
-               q->high_mark = 2;
-
-       q->write_ptr = q->read_ptr = 0;
-
-       return 0;
-}
-
-/**
- * il_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
- */
-static int
-il_tx_queue_alloc(struct il_priv *il, struct il_tx_queue *txq, u32 id)
-{
-       struct device *dev = &il->pci_dev->dev;
-       size_t tfd_sz = il->hw_params.tfd_size * TFD_QUEUE_SIZE_MAX;
-
-       /* Driver ilate data, only for Tx (not command) queues,
-        * not shared with device. */
-       if (id != il->cmd_queue) {
-               txq->skbs = kcalloc(TFD_QUEUE_SIZE_MAX,
-                                   sizeof(struct sk_buff *),
-                                   GFP_KERNEL);
-               if (!txq->skbs) {
-                       IL_ERR("Fail to alloc skbs\n");
-                       goto error;
-               }
-       } else
-               txq->skbs = NULL;
-
-       /* Circular buffer of transmit frame descriptors (TFDs),
-        * shared with device */
-       txq->tfds =
-           dma_alloc_coherent(dev, tfd_sz, &txq->q.dma_addr, GFP_KERNEL);
-       if (!txq->tfds)
-               goto error;
-
-       txq->q.id = id;
-
-       return 0;
-
-error:
-       kfree(txq->skbs);
-       txq->skbs = NULL;
-
-       return -ENOMEM;
-}
-
-/**
- * il_tx_queue_init - Allocate and initialize one tx/cmd queue
- */
-int
-il_tx_queue_init(struct il_priv *il, u32 txq_id)
-{
-       int i, len, ret;
-       int slots, actual_slots;
-       struct il_tx_queue *txq = &il->txq[txq_id];
-
-       /*
-        * Alloc buffer array for commands (Tx or other types of commands).
-        * For the command queue (#4/#9), allocate command space + one big
-        * command for scan, since scan command is very huge; the system will
-        * not have two scans at the same time, so only one is needed.
-        * For normal Tx queues (all other queues), no super-size command
-        * space is needed.
-        */
-       if (txq_id == il->cmd_queue) {
-               slots = TFD_CMD_SLOTS;
-               actual_slots = slots + 1;
-       } else {
-               slots = TFD_TX_CMD_SLOTS;
-               actual_slots = slots;
-       }
-
-       txq->meta =
-           kzalloc(sizeof(struct il_cmd_meta) * actual_slots, GFP_KERNEL);
-       txq->cmd =
-           kzalloc(sizeof(struct il_device_cmd *) * actual_slots, GFP_KERNEL);
-
-       if (!txq->meta || !txq->cmd)
-               goto out_free_arrays;
-
-       len = sizeof(struct il_device_cmd);
-       for (i = 0; i < actual_slots; i++) {
-               /* only happens for cmd queue */
-               if (i == slots)
-                       len = IL_MAX_CMD_SIZE;
-
-               txq->cmd[i] = kmalloc(len, GFP_KERNEL);
-               if (!txq->cmd[i])
-                       goto err;
-       }
-
-       /* Alloc driver data array and TFD circular buffer */
-       ret = il_tx_queue_alloc(il, txq, txq_id);
-       if (ret)
-               goto err;
-
-       txq->need_update = 0;
-
-       /*
-        * For the default queues 0-3, set up the swq_id
-        * already -- all others need to get one later
-        * (if they need one at all).
-        */
-       if (txq_id < 4)
-               il_set_swq_id(txq, txq_id, txq_id);
-
-       /* Initialize queue's high/low-water marks, and head/tail idxes */
-       il_queue_init(il, &txq->q, slots, txq_id);
-
-       /* Tell device where to find queue */
-       il->ops->txq_init(il, txq);
-
-       return 0;
-err:
-       for (i = 0; i < actual_slots; i++)
-               kfree(txq->cmd[i]);
-out_free_arrays:
-       kfree(txq->meta);
-       kfree(txq->cmd);
-
-       return -ENOMEM;
-}
-EXPORT_SYMBOL(il_tx_queue_init);
-
-void
-il_tx_queue_reset(struct il_priv *il, u32 txq_id)
-{
-       int slots, actual_slots;
-       struct il_tx_queue *txq = &il->txq[txq_id];
-
-       if (txq_id == il->cmd_queue) {
-               slots = TFD_CMD_SLOTS;
-               actual_slots = TFD_CMD_SLOTS + 1;
-       } else {
-               slots = TFD_TX_CMD_SLOTS;
-               actual_slots = TFD_TX_CMD_SLOTS;
-       }
-
-       memset(txq->meta, 0, sizeof(struct il_cmd_meta) * actual_slots);
-       txq->need_update = 0;
-
-       /* Initialize queue's high/low-water marks, and head/tail idxes */
-       il_queue_init(il, &txq->q, slots, txq_id);
-
-       /* Tell device where to find queue */
-       il->ops->txq_init(il, txq);
-}
-EXPORT_SYMBOL(il_tx_queue_reset);
-
-/*************** HOST COMMAND QUEUE FUNCTIONS   *****/
-
-/**
- * il_enqueue_hcmd - enqueue a uCode command
- * @il: device ilate data point
- * @cmd: a point to the ucode command structure
- *
- * The function returns < 0 values to indicate the operation is
- * failed. On success, it turns the idx (> 0) of command in the
- * command queue.
- */
-int
-il_enqueue_hcmd(struct il_priv *il, struct il_host_cmd *cmd)
-{
-       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
-       struct il_queue *q = &txq->q;
-       struct il_device_cmd *out_cmd;
-       struct il_cmd_meta *out_meta;
-       dma_addr_t phys_addr;
-       unsigned long flags;
-       int len;
-       u32 idx;
-       u16 fix_size;
-
-       cmd->len = il->ops->get_hcmd_size(cmd->id, cmd->len);
-       fix_size = (u16) (cmd->len + sizeof(out_cmd->hdr));
-
-       /* If any of the command structures end up being larger than
-        * the TFD_MAX_PAYLOAD_SIZE, and it sent as a 'small' command then
-        * we will need to increase the size of the TFD entries
-        * Also, check to see if command buffer should not exceed the size
-        * of device_cmd and max_cmd_size. */
-       BUG_ON((fix_size > TFD_MAX_PAYLOAD_SIZE) &&
-              !(cmd->flags & CMD_SIZE_HUGE));
-       BUG_ON(fix_size > IL_MAX_CMD_SIZE);
-
-       if (il_is_rfkill(il) || il_is_ctkill(il)) {
-               IL_WARN("Not sending command - %s KILL\n",
-                       il_is_rfkill(il) ? "RF" : "CT");
-               return -EIO;
-       }
-
-       spin_lock_irqsave(&il->hcmd_lock, flags);
-
-       if (il_queue_space(q) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {
-               spin_unlock_irqrestore(&il->hcmd_lock, flags);
-
-               IL_ERR("Restarting adapter due to command queue full\n");
-               queue_work(il->workqueue, &il->restart);
-               return -ENOSPC;
-       }
-
-       idx = il_get_cmd_idx(q, q->write_ptr, cmd->flags & CMD_SIZE_HUGE);
-       out_cmd = txq->cmd[idx];
-       out_meta = &txq->meta[idx];
-
-       if (WARN_ON(out_meta->flags & CMD_MAPPED)) {
-               spin_unlock_irqrestore(&il->hcmd_lock, flags);
-               return -ENOSPC;
-       }
-
-       memset(out_meta, 0, sizeof(*out_meta)); /* re-initialize to NULL */
-       out_meta->flags = cmd->flags | CMD_MAPPED;
-       if (cmd->flags & CMD_WANT_SKB)
-               out_meta->source = cmd;
-       if (cmd->flags & CMD_ASYNC)
-               out_meta->callback = cmd->callback;
-
-       out_cmd->hdr.cmd = cmd->id;
-       memcpy(&out_cmd->cmd.payload, cmd->data, cmd->len);
-
-       /* At this point, the out_cmd now has all of the incoming cmd
-        * information */
-
-       out_cmd->hdr.flags = 0;
-       out_cmd->hdr.sequence =
-           cpu_to_le16(QUEUE_TO_SEQ(il->cmd_queue) | IDX_TO_SEQ(q->write_ptr));
-       if (cmd->flags & CMD_SIZE_HUGE)
-               out_cmd->hdr.sequence |= SEQ_HUGE_FRAME;
-       len = sizeof(struct il_device_cmd);
-       if (idx == TFD_CMD_SLOTS)
-               len = IL_MAX_CMD_SIZE;
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       switch (out_cmd->hdr.cmd) {
-       case C_TX_LINK_QUALITY_CMD:
-       case C_SENSITIVITY:
-               D_HC_DUMP("Sending command %s (#%x), seq: 0x%04X, "
-                         "%d bytes at %d[%d]:%d\n",
-                         il_get_cmd_string(out_cmd->hdr.cmd), out_cmd->hdr.cmd,
-                         le16_to_cpu(out_cmd->hdr.sequence), fix_size,
-                         q->write_ptr, idx, il->cmd_queue);
-               break;
-       default:
-               D_HC("Sending command %s (#%x), seq: 0x%04X, "
-                    "%d bytes at %d[%d]:%d\n",
-                    il_get_cmd_string(out_cmd->hdr.cmd), out_cmd->hdr.cmd,
-                    le16_to_cpu(out_cmd->hdr.sequence), fix_size, q->write_ptr,
-                    idx, il->cmd_queue);
-       }
-#endif
-
-       phys_addr =
-           pci_map_single(il->pci_dev, &out_cmd->hdr, fix_size,
-                          PCI_DMA_BIDIRECTIONAL);
-       if (unlikely(pci_dma_mapping_error(il->pci_dev, phys_addr))) {
-               idx = -ENOMEM;
-               goto out;
-       }
-       dma_unmap_addr_set(out_meta, mapping, phys_addr);
-       dma_unmap_len_set(out_meta, len, fix_size);
-
-       txq->need_update = 1;
-
-       if (il->ops->txq_update_byte_cnt_tbl)
-               /* Set up entry in queue's byte count circular buffer */
-               il->ops->txq_update_byte_cnt_tbl(il, txq, 0);
-
-       il->ops->txq_attach_buf_to_tfd(il, txq, phys_addr, fix_size, 1,
-                                           U32_PAD(cmd->len));
-
-       /* Increment and update queue's write idx */
-       q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
-       il_txq_update_write_ptr(il, txq);
-
-out:
-       spin_unlock_irqrestore(&il->hcmd_lock, flags);
-       return idx;
-}
-
-/**
- * il_hcmd_queue_reclaim - Reclaim TX command queue entries already Tx'd
- *
- * When FW advances 'R' idx, all entries between old and new 'R' idx
- * need to be reclaimed. As result, some free space forms.  If there is
- * enough free space (> low mark), wake the stack that feeds us.
- */
-static void
-il_hcmd_queue_reclaim(struct il_priv *il, int txq_id, int idx, int cmd_idx)
-{
-       struct il_tx_queue *txq = &il->txq[txq_id];
-       struct il_queue *q = &txq->q;
-       int nfreed = 0;
-
-       if (idx >= q->n_bd || il_queue_used(q, idx) == 0) {
-               IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
-                      "is out of range [0-%d] %d %d.\n", txq_id, idx, q->n_bd,
-                      q->write_ptr, q->read_ptr);
-               return;
-       }
-
-       for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
-            q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
-
-               if (nfreed++ > 0) {
-                       IL_ERR("HCMD skipped: idx (%d) %d %d\n", idx,
-                              q->write_ptr, q->read_ptr);
-                       queue_work(il->workqueue, &il->restart);
-               }
-
-       }
-}
-
-/**
- * il_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
- */
-void
-il_tx_cmd_complete(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       u16 sequence = le16_to_cpu(pkt->hdr.sequence);
-       int txq_id = SEQ_TO_QUEUE(sequence);
-       int idx = SEQ_TO_IDX(sequence);
-       int cmd_idx;
-       bool huge = !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
-       struct il_device_cmd *cmd;
-       struct il_cmd_meta *meta;
-       struct il_tx_queue *txq = &il->txq[il->cmd_queue];
-       unsigned long flags;
-
-       /* If a Tx command is being handled and it isn't in the actual
-        * command queue then there a command routing bug has been introduced
-        * in the queue management code. */
-       if (WARN
-           (txq_id != il->cmd_queue,
-            "wrong command queue %d (should be %d), sequence 0x%X readp=%d writep=%d\n",
-            txq_id, il->cmd_queue, sequence, il->txq[il->cmd_queue].q.read_ptr,
-            il->txq[il->cmd_queue].q.write_ptr)) {
-               il_print_hex_error(il, pkt, 32);
-               return;
-       }
-
-       cmd_idx = il_get_cmd_idx(&txq->q, idx, huge);
-       cmd = txq->cmd[cmd_idx];
-       meta = &txq->meta[cmd_idx];
-
-       txq->time_stamp = jiffies;
-
-       pci_unmap_single(il->pci_dev, dma_unmap_addr(meta, mapping),
-                        dma_unmap_len(meta, len), PCI_DMA_BIDIRECTIONAL);
-
-       /* Input error checking is done when commands are added to queue. */
-       if (meta->flags & CMD_WANT_SKB) {
-               meta->source->reply_page = (unsigned long)rxb_addr(rxb);
-               rxb->page = NULL;
-       } else if (meta->callback)
-               meta->callback(il, cmd, pkt);
-
-       spin_lock_irqsave(&il->hcmd_lock, flags);
-
-       il_hcmd_queue_reclaim(il, txq_id, idx, cmd_idx);
-
-       if (!(meta->flags & CMD_ASYNC)) {
-               clear_bit(S_HCMD_ACTIVE, &il->status);
-               D_INFO("Clearing HCMD_ACTIVE for command %s\n",
-                      il_get_cmd_string(cmd->hdr.cmd));
-               wake_up(&il->wait_command_queue);
-       }
-
-       /* Mark as unmapped */
-       meta->flags = 0;
-
-       spin_unlock_irqrestore(&il->hcmd_lock, flags);
-}
-EXPORT_SYMBOL(il_tx_cmd_complete);
-
-MODULE_DESCRIPTION("iwl-legacy: common functions for 3945 and 4965");
-MODULE_VERSION(IWLWIFI_VERSION);
-MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
-MODULE_LICENSE("GPL");
-
-/*
- * set bt_coex_active to true, uCode will do kill/defer
- * every time the priority line is asserted (BT is sending signals on the
- * priority line in the PCIx).
- * set bt_coex_active to false, uCode will ignore the BT activity and
- * perform the normal operation
- *
- * User might experience transmit issue on some platform due to WiFi/BT
- * co-exist problem. The possible behaviors are:
- *   Able to scan and finding all the available AP
- *   Not able to associate with any AP
- * On those platforms, WiFi communication can be restored by set
- * "bt_coex_active" module parameter to "false"
- *
- * default: bt_coex_active = true (BT_COEX_ENABLE)
- */
-static bool bt_coex_active = true;
-module_param(bt_coex_active, bool, S_IRUGO);
-MODULE_PARM_DESC(bt_coex_active, "enable wifi/bluetooth co-exist");
-
-u32 il_debug_level;
-EXPORT_SYMBOL(il_debug_level);
-
-const u8 il_bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-EXPORT_SYMBOL(il_bcast_addr);
-
-#define MAX_BIT_RATE_40_MHZ 150        /* Mbps */
-#define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
-static void
-il_init_ht_hw_capab(const struct il_priv *il,
-                   struct ieee80211_sta_ht_cap *ht_info,
-                   enum ieee80211_band band)
-{
-       u16 max_bit_rate = 0;
-       u8 rx_chains_num = il->hw_params.rx_chains_num;
-       u8 tx_chains_num = il->hw_params.tx_chains_num;
-
-       ht_info->cap = 0;
-       memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
-
-       ht_info->ht_supported = true;
-
-       ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
-       max_bit_rate = MAX_BIT_RATE_20_MHZ;
-       if (il->hw_params.ht40_channel & BIT(band)) {
-               ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
-               ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
-               ht_info->mcs.rx_mask[4] = 0x01;
-               max_bit_rate = MAX_BIT_RATE_40_MHZ;
-       }
-
-       if (il->cfg->mod_params->amsdu_size_8K)
-               ht_info->cap |= IEEE80211_HT_CAP_MAX_AMSDU;
-
-       ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
-       ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
-
-       ht_info->mcs.rx_mask[0] = 0xFF;
-       if (rx_chains_num >= 2)
-               ht_info->mcs.rx_mask[1] = 0xFF;
-       if (rx_chains_num >= 3)
-               ht_info->mcs.rx_mask[2] = 0xFF;
-
-       /* Highest supported Rx data rate */
-       max_bit_rate *= rx_chains_num;
-       WARN_ON(max_bit_rate & ~IEEE80211_HT_MCS_RX_HIGHEST_MASK);
-       ht_info->mcs.rx_highest = cpu_to_le16(max_bit_rate);
-
-       /* Tx MCS capabilities */
-       ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
-       if (tx_chains_num != rx_chains_num) {
-               ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
-               ht_info->mcs.tx_params |=
-                   ((tx_chains_num -
-                     1) << IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
-       }
-}
-
-/**
- * il_init_geos - Initialize mac80211's geo/channel info based from eeprom
- */
-int
-il_init_geos(struct il_priv *il)
-{
-       struct il_channel_info *ch;
-       struct ieee80211_supported_band *sband;
-       struct ieee80211_channel *channels;
-       struct ieee80211_channel *geo_ch;
-       struct ieee80211_rate *rates;
-       int i = 0;
-       s8 max_tx_power = 0;
-
-       if (il->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
-           il->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
-               D_INFO("Geography modes already initialized.\n");
-               set_bit(S_GEO_CONFIGURED, &il->status);
-               return 0;
-       }
-
-       channels =
-           kzalloc(sizeof(struct ieee80211_channel) * il->channel_count,
-                   GFP_KERNEL);
-       if (!channels)
-               return -ENOMEM;
-
-       rates =
-           kzalloc((sizeof(struct ieee80211_rate) * RATE_COUNT_LEGACY),
-                   GFP_KERNEL);
-       if (!rates) {
-               kfree(channels);
-               return -ENOMEM;
-       }
-
-       /* 5.2GHz channels start after the 2.4GHz channels */
-       sband = &il->bands[IEEE80211_BAND_5GHZ];
-       sband->channels = &channels[ARRAY_SIZE(il_eeprom_band_1)];
-       /* just OFDM */
-       sband->bitrates = &rates[IL_FIRST_OFDM_RATE];
-       sband->n_bitrates = RATE_COUNT_LEGACY - IL_FIRST_OFDM_RATE;
-
-       if (il->cfg->sku & IL_SKU_N)
-               il_init_ht_hw_capab(il, &sband->ht_cap, IEEE80211_BAND_5GHZ);
-
-       sband = &il->bands[IEEE80211_BAND_2GHZ];
-       sband->channels = channels;
-       /* OFDM & CCK */
-       sband->bitrates = rates;
-       sband->n_bitrates = RATE_COUNT_LEGACY;
-
-       if (il->cfg->sku & IL_SKU_N)
-               il_init_ht_hw_capab(il, &sband->ht_cap, IEEE80211_BAND_2GHZ);
-
-       il->ieee_channels = channels;
-       il->ieee_rates = rates;
-
-       for (i = 0; i < il->channel_count; i++) {
-               ch = &il->channel_info[i];
-
-               if (!il_is_channel_valid(ch))
-                       continue;
-
-               sband = &il->bands[ch->band];
-
-               geo_ch = &sband->channels[sband->n_channels++];
-
-               geo_ch->center_freq =
-                   ieee80211_channel_to_frequency(ch->channel, ch->band);
-               geo_ch->max_power = ch->max_power_avg;
-               geo_ch->max_antenna_gain = 0xff;
-               geo_ch->hw_value = ch->channel;
-
-               if (il_is_channel_valid(ch)) {
-                       if (!(ch->flags & EEPROM_CHANNEL_IBSS))
-                               geo_ch->flags |= IEEE80211_CHAN_NO_IR;
-
-                       if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
-                               geo_ch->flags |= IEEE80211_CHAN_NO_IR;
-
-                       if (ch->flags & EEPROM_CHANNEL_RADAR)
-                               geo_ch->flags |= IEEE80211_CHAN_RADAR;
-
-                       geo_ch->flags |= ch->ht40_extension_channel;
-
-                       if (ch->max_power_avg > max_tx_power)
-                               max_tx_power = ch->max_power_avg;
-               } else {
-                       geo_ch->flags |= IEEE80211_CHAN_DISABLED;
-               }
-
-               D_INFO("Channel %d Freq=%d[%sGHz] %s flag=0x%X\n", ch->channel,
-                      geo_ch->center_freq,
-                      il_is_channel_a_band(ch) ? "5.2" : "2.4",
-                      geo_ch->
-                      flags & IEEE80211_CHAN_DISABLED ? "restricted" : "valid",
-                      geo_ch->flags);
-       }
-
-       il->tx_power_device_lmt = max_tx_power;
-       il->tx_power_user_lmt = max_tx_power;
-       il->tx_power_next = max_tx_power;
-
-       if (il->bands[IEEE80211_BAND_5GHZ].n_channels == 0 &&
-           (il->cfg->sku & IL_SKU_A)) {
-               IL_INFO("Incorrectly detected BG card as ABG. "
-                       "Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
-                       il->pci_dev->device, il->pci_dev->subsystem_device);
-               il->cfg->sku &= ~IL_SKU_A;
-       }
-
-       IL_INFO("Tunable channels: %d 802.11bg, %d 802.11a channels\n",
-               il->bands[IEEE80211_BAND_2GHZ].n_channels,
-               il->bands[IEEE80211_BAND_5GHZ].n_channels);
-
-       set_bit(S_GEO_CONFIGURED, &il->status);
-
-       return 0;
-}
-EXPORT_SYMBOL(il_init_geos);
-
-/*
- * il_free_geos - undo allocations in il_init_geos
- */
-void
-il_free_geos(struct il_priv *il)
-{
-       kfree(il->ieee_channels);
-       kfree(il->ieee_rates);
-       clear_bit(S_GEO_CONFIGURED, &il->status);
-}
-EXPORT_SYMBOL(il_free_geos);
-
-static bool
-il_is_channel_extension(struct il_priv *il, enum ieee80211_band band,
-                       u16 channel, u8 extension_chan_offset)
-{
-       const struct il_channel_info *ch_info;
-
-       ch_info = il_get_channel_info(il, band, channel);
-       if (!il_is_channel_valid(ch_info))
-               return false;
-
-       if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE)
-               return !(ch_info->
-                        ht40_extension_channel & IEEE80211_CHAN_NO_HT40PLUS);
-       else if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW)
-               return !(ch_info->
-                        ht40_extension_channel & IEEE80211_CHAN_NO_HT40MINUS);
-
-       return false;
-}
-
-bool
-il_is_ht40_tx_allowed(struct il_priv *il, struct ieee80211_sta_ht_cap *ht_cap)
-{
-       if (!il->ht.enabled || !il->ht.is_40mhz)
-               return false;
-
-       /*
-        * We do not check for IEEE80211_HT_CAP_SUP_WIDTH_20_40
-        * the bit will not set if it is pure 40MHz case
-        */
-       if (ht_cap && !ht_cap->ht_supported)
-               return false;
-
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       if (il->disable_ht40)
-               return false;
-#endif
-
-       return il_is_channel_extension(il, il->band,
-                                      le16_to_cpu(il->staging.channel),
-                                      il->ht.extension_chan_offset);
-}
-EXPORT_SYMBOL(il_is_ht40_tx_allowed);
-
-static u16
-il_adjust_beacon_interval(u16 beacon_val, u16 max_beacon_val)
-{
-       u16 new_val;
-       u16 beacon_factor;
-
-       /*
-        * If mac80211 hasn't given us a beacon interval, program
-        * the default into the device.
-        */
-       if (!beacon_val)
-               return DEFAULT_BEACON_INTERVAL;
-
-       /*
-        * If the beacon interval we obtained from the peer
-        * is too large, we'll have to wake up more often
-        * (and in IBSS case, we'll beacon too much)
-        *
-        * For example, if max_beacon_val is 4096, and the
-        * requested beacon interval is 7000, we'll have to
-        * use 3500 to be able to wake up on the beacons.
-        *
-        * This could badly influence beacon detection stats.
-        */
-
-       beacon_factor = (beacon_val + max_beacon_val) / max_beacon_val;
-       new_val = beacon_val / beacon_factor;
-
-       if (!new_val)
-               new_val = max_beacon_val;
-
-       return new_val;
-}
-
-int
-il_send_rxon_timing(struct il_priv *il)
-{
-       u64 tsf;
-       s32 interval_tm, rem;
-       struct ieee80211_conf *conf = NULL;
-       u16 beacon_int;
-       struct ieee80211_vif *vif = il->vif;
-
-       conf = &il->hw->conf;
-
-       lockdep_assert_held(&il->mutex);
-
-       memset(&il->timing, 0, sizeof(struct il_rxon_time_cmd));
-
-       il->timing.timestamp = cpu_to_le64(il->timestamp);
-       il->timing.listen_interval = cpu_to_le16(conf->listen_interval);
-
-       beacon_int = vif ? vif->bss_conf.beacon_int : 0;
-
-       /*
-        * TODO: For IBSS we need to get atim_win from mac80211,
-        *       for now just always use 0
-        */
-       il->timing.atim_win = 0;
-
-       beacon_int =
-           il_adjust_beacon_interval(beacon_int,
-                                     il->hw_params.max_beacon_itrvl *
-                                     TIME_UNIT);
-       il->timing.beacon_interval = cpu_to_le16(beacon_int);
-
-       tsf = il->timestamp;    /* tsf is modifed by do_div: copy it */
-       interval_tm = beacon_int * TIME_UNIT;
-       rem = do_div(tsf, interval_tm);
-       il->timing.beacon_init_val = cpu_to_le32(interval_tm - rem);
-
-       il->timing.dtim_period = vif ? (vif->bss_conf.dtim_period ? : 1) : 1;
-
-       D_ASSOC("beacon interval %d beacon timer %d beacon tim %d\n",
-               le16_to_cpu(il->timing.beacon_interval),
-               le32_to_cpu(il->timing.beacon_init_val),
-               le16_to_cpu(il->timing.atim_win));
-
-       return il_send_cmd_pdu(il, C_RXON_TIMING, sizeof(il->timing),
-                              &il->timing);
-}
-EXPORT_SYMBOL(il_send_rxon_timing);
-
-void
-il_set_rxon_hwcrypto(struct il_priv *il, int hw_decrypt)
-{
-       struct il_rxon_cmd *rxon = &il->staging;
-
-       if (hw_decrypt)
-               rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
-       else
-               rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
-
-}
-EXPORT_SYMBOL(il_set_rxon_hwcrypto);
-
-/* validate RXON structure is valid */
-int
-il_check_rxon_cmd(struct il_priv *il)
-{
-       struct il_rxon_cmd *rxon = &il->staging;
-       bool error = false;
-
-       if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
-               if (rxon->flags & RXON_FLG_TGJ_NARROW_BAND_MSK) {
-                       IL_WARN("check 2.4G: wrong narrow\n");
-                       error = true;
-               }
-               if (rxon->flags & RXON_FLG_RADAR_DETECT_MSK) {
-                       IL_WARN("check 2.4G: wrong radar\n");
-                       error = true;
-               }
-       } else {
-               if (!(rxon->flags & RXON_FLG_SHORT_SLOT_MSK)) {
-                       IL_WARN("check 5.2G: not short slot!\n");
-                       error = true;
-               }
-               if (rxon->flags & RXON_FLG_CCK_MSK) {
-                       IL_WARN("check 5.2G: CCK!\n");
-                       error = true;
-               }
-       }
-       if ((rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1) {
-               IL_WARN("mac/bssid mcast!\n");
-               error = true;
-       }
-
-       /* make sure basic rates 6Mbps and 1Mbps are supported */
-       if ((rxon->ofdm_basic_rates & RATE_6M_MASK) == 0 &&
-           (rxon->cck_basic_rates & RATE_1M_MASK) == 0) {
-               IL_WARN("neither 1 nor 6 are basic\n");
-               error = true;
-       }
-
-       if (le16_to_cpu(rxon->assoc_id) > 2007) {
-               IL_WARN("aid > 2007\n");
-               error = true;
-       }
-
-       if ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK)) ==
-           (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK)) {
-               IL_WARN("CCK and short slot\n");
-               error = true;
-       }
-
-       if ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK)) ==
-           (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK)) {
-               IL_WARN("CCK and auto detect");
-               error = true;
-       }
-
-       if ((rxon->
-            flags & (RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK)) ==
-           RXON_FLG_TGG_PROTECT_MSK) {
-               IL_WARN("TGg but no auto-detect\n");
-               error = true;
-       }
-
-       if (error)
-               IL_WARN("Tuning to channel %d\n", le16_to_cpu(rxon->channel));
-
-       if (error) {
-               IL_ERR("Invalid RXON\n");
-               return -EINVAL;
-       }
-       return 0;
-}
-EXPORT_SYMBOL(il_check_rxon_cmd);
-
-/**
- * il_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
- * @il: staging_rxon is compared to active_rxon
- *
- * If the RXON structure is changing enough to require a new tune,
- * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
- * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
- */
-int
-il_full_rxon_required(struct il_priv *il)
-{
-       const struct il_rxon_cmd *staging = &il->staging;
-       const struct il_rxon_cmd *active = &il->active;
-
-#define CHK(cond)                                                      \
-       if ((cond)) {                                                   \
-               D_INFO("need full RXON - " #cond "\n"); \
-               return 1;                                               \
-       }
-
-#define CHK_NEQ(c1, c2)                                                \
-       if ((c1) != (c2)) {                                     \
-               D_INFO("need full RXON - "      \
-                              #c1 " != " #c2 " - %d != %d\n",  \
-                              (c1), (c2));                     \
-               return 1;                                       \
-       }
-
-       /* These items are only settable from the full RXON command */
-       CHK(!il_is_associated(il));
-       CHK(!ether_addr_equal_64bits(staging->bssid_addr, active->bssid_addr));
-       CHK(!ether_addr_equal_64bits(staging->node_addr, active->node_addr));
-       CHK(!ether_addr_equal_64bits(staging->wlap_bssid_addr,
-                                    active->wlap_bssid_addr));
-       CHK_NEQ(staging->dev_type, active->dev_type);
-       CHK_NEQ(staging->channel, active->channel);
-       CHK_NEQ(staging->air_propagation, active->air_propagation);
-       CHK_NEQ(staging->ofdm_ht_single_stream_basic_rates,
-               active->ofdm_ht_single_stream_basic_rates);
-       CHK_NEQ(staging->ofdm_ht_dual_stream_basic_rates,
-               active->ofdm_ht_dual_stream_basic_rates);
-       CHK_NEQ(staging->assoc_id, active->assoc_id);
-
-       /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
-        * be updated with the RXON_ASSOC command -- however only some
-        * flag transitions are allowed using RXON_ASSOC */
-
-       /* Check if we are not switching bands */
-       CHK_NEQ(staging->flags & RXON_FLG_BAND_24G_MSK,
-               active->flags & RXON_FLG_BAND_24G_MSK);
-
-       /* Check if we are switching association toggle */
-       CHK_NEQ(staging->filter_flags & RXON_FILTER_ASSOC_MSK,
-               active->filter_flags & RXON_FILTER_ASSOC_MSK);
-
-#undef CHK
-#undef CHK_NEQ
-
-       return 0;
-}
-EXPORT_SYMBOL(il_full_rxon_required);
-
-u8
-il_get_lowest_plcp(struct il_priv *il)
-{
-       /*
-        * Assign the lowest rate -- should really get this from
-        * the beacon skb from mac80211.
-        */
-       if (il->staging.flags & RXON_FLG_BAND_24G_MSK)
-               return RATE_1M_PLCP;
-       else
-               return RATE_6M_PLCP;
-}
-EXPORT_SYMBOL(il_get_lowest_plcp);
-
-static void
-_il_set_rxon_ht(struct il_priv *il, struct il_ht_config *ht_conf)
-{
-       struct il_rxon_cmd *rxon = &il->staging;
-
-       if (!il->ht.enabled) {
-               rxon->flags &=
-                   ~(RXON_FLG_CHANNEL_MODE_MSK |
-                     RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK | RXON_FLG_HT40_PROT_MSK
-                     | RXON_FLG_HT_PROT_MSK);
-               return;
-       }
-
-       rxon->flags |=
-           cpu_to_le32(il->ht.protection << RXON_FLG_HT_OPERATING_MODE_POS);
-
-       /* Set up channel bandwidth:
-        * 20 MHz only, 20/40 mixed or pure 40 if ht40 ok */
-       /* clear the HT channel mode before set the mode */
-       rxon->flags &=
-           ~(RXON_FLG_CHANNEL_MODE_MSK | RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
-       if (il_is_ht40_tx_allowed(il, NULL)) {
-               /* pure ht40 */
-               if (il->ht.protection == IEEE80211_HT_OP_MODE_PROTECTION_20MHZ) {
-                       rxon->flags |= RXON_FLG_CHANNEL_MODE_PURE_40;
-                       /* Note: control channel is opposite of extension channel */
-                       switch (il->ht.extension_chan_offset) {
-                       case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
-                               rxon->flags &=
-                                   ~RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
-                               break;
-                       case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
-                               rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
-                               break;
-                       }
-               } else {
-                       /* Note: control channel is opposite of extension channel */
-                       switch (il->ht.extension_chan_offset) {
-                       case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
-                               rxon->flags &=
-                                   ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
-                               rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
-                               break;
-                       case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
-                               rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
-                               rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
-                               break;
-                       case IEEE80211_HT_PARAM_CHA_SEC_NONE:
-                       default:
-                               /* channel location only valid if in Mixed mode */
-                               IL_ERR("invalid extension channel offset\n");
-                               break;
-                       }
-               }
-       } else {
-               rxon->flags |= RXON_FLG_CHANNEL_MODE_LEGACY;
-       }
-
-       if (il->ops->set_rxon_chain)
-               il->ops->set_rxon_chain(il);
-
-       D_ASSOC("rxon flags 0x%X operation mode :0x%X "
-               "extension channel offset 0x%x\n", le32_to_cpu(rxon->flags),
-               il->ht.protection, il->ht.extension_chan_offset);
-}
-
-void
-il_set_rxon_ht(struct il_priv *il, struct il_ht_config *ht_conf)
-{
-       _il_set_rxon_ht(il, ht_conf);
-}
-EXPORT_SYMBOL(il_set_rxon_ht);
-
-/* Return valid, unused, channel for a passive scan to reset the RF */
-u8
-il_get_single_channel_number(struct il_priv *il, enum ieee80211_band band)
-{
-       const struct il_channel_info *ch_info;
-       int i;
-       u8 channel = 0;
-       u8 min, max;
-
-       if (band == IEEE80211_BAND_5GHZ) {
-               min = 14;
-               max = il->channel_count;
-       } else {
-               min = 0;
-               max = 14;
-       }
-
-       for (i = min; i < max; i++) {
-               channel = il->channel_info[i].channel;
-               if (channel == le16_to_cpu(il->staging.channel))
-                       continue;
-
-               ch_info = il_get_channel_info(il, band, channel);
-               if (il_is_channel_valid(ch_info))
-                       break;
-       }
-
-       return channel;
-}
-EXPORT_SYMBOL(il_get_single_channel_number);
-
-/**
- * il_set_rxon_channel - Set the band and channel values in staging RXON
- * @ch: requested channel as a pointer to struct ieee80211_channel
-
- * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
- * in the staging RXON flag structure based on the ch->band
- */
-int
-il_set_rxon_channel(struct il_priv *il, struct ieee80211_channel *ch)
-{
-       enum ieee80211_band band = ch->band;
-       u16 channel = ch->hw_value;
-
-       if (le16_to_cpu(il->staging.channel) == channel && il->band == band)
-               return 0;
-
-       il->staging.channel = cpu_to_le16(channel);
-       if (band == IEEE80211_BAND_5GHZ)
-               il->staging.flags &= ~RXON_FLG_BAND_24G_MSK;
-       else
-               il->staging.flags |= RXON_FLG_BAND_24G_MSK;
-
-       il->band = band;
-
-       D_INFO("Staging channel set to %d [%d]\n", channel, band);
-
-       return 0;
-}
-EXPORT_SYMBOL(il_set_rxon_channel);
-
-void
-il_set_flags_for_band(struct il_priv *il, enum ieee80211_band band,
-                     struct ieee80211_vif *vif)
-{
-       if (band == IEEE80211_BAND_5GHZ) {
-               il->staging.flags &=
-                   ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK |
-                     RXON_FLG_CCK_MSK);
-               il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
-       } else {
-               /* Copied from il_post_associate() */
-               if (vif && vif->bss_conf.use_short_slot)
-                       il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
-               else
-                       il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
-
-               il->staging.flags |= RXON_FLG_BAND_24G_MSK;
-               il->staging.flags |= RXON_FLG_AUTO_DETECT_MSK;
-               il->staging.flags &= ~RXON_FLG_CCK_MSK;
-       }
-}
-EXPORT_SYMBOL(il_set_flags_for_band);
-
-/*
- * initialize rxon structure with default values from eeprom
- */
-void
-il_connection_init_rx_config(struct il_priv *il)
-{
-       const struct il_channel_info *ch_info;
-
-       memset(&il->staging, 0, sizeof(il->staging));
-
-       switch (il->iw_mode) {
-       case NL80211_IFTYPE_UNSPECIFIED:
-               il->staging.dev_type = RXON_DEV_TYPE_ESS;
-               break;
-       case NL80211_IFTYPE_STATION:
-               il->staging.dev_type = RXON_DEV_TYPE_ESS;
-               il->staging.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
-               break;
-       case NL80211_IFTYPE_ADHOC:
-               il->staging.dev_type = RXON_DEV_TYPE_IBSS;
-               il->staging.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
-               il->staging.filter_flags =
-                   RXON_FILTER_BCON_AWARE_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
-               break;
-       default:
-               IL_ERR("Unsupported interface type %d\n", il->vif->type);
-               return;
-       }
-
-#if 0
-       /* TODO:  Figure out when short_preamble would be set and cache from
-        * that */
-       if (!hw_to_local(il->hw)->short_preamble)
-               il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
-       else
-               il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
-#endif
-
-       ch_info =
-           il_get_channel_info(il, il->band, le16_to_cpu(il->active.channel));
-
-       if (!ch_info)
-               ch_info = &il->channel_info[0];
-
-       il->staging.channel = cpu_to_le16(ch_info->channel);
-       il->band = ch_info->band;
-
-       il_set_flags_for_band(il, il->band, il->vif);
-
-       il->staging.ofdm_basic_rates =
-           (IL_OFDM_RATES_MASK >> IL_FIRST_OFDM_RATE) & 0xFF;
-       il->staging.cck_basic_rates =
-           (IL_CCK_RATES_MASK >> IL_FIRST_CCK_RATE) & 0xF;
-
-       /* clear both MIX and PURE40 mode flag */
-       il->staging.flags &=
-           ~(RXON_FLG_CHANNEL_MODE_MIXED | RXON_FLG_CHANNEL_MODE_PURE_40);
-       if (il->vif)
-               memcpy(il->staging.node_addr, il->vif->addr, ETH_ALEN);
-
-       il->staging.ofdm_ht_single_stream_basic_rates = 0xff;
-       il->staging.ofdm_ht_dual_stream_basic_rates = 0xff;
-}
-EXPORT_SYMBOL(il_connection_init_rx_config);
-
-void
-il_set_rate(struct il_priv *il)
-{
-       const struct ieee80211_supported_band *hw = NULL;
-       struct ieee80211_rate *rate;
-       int i;
-
-       hw = il_get_hw_mode(il, il->band);
-       if (!hw) {
-               IL_ERR("Failed to set rate: unable to get hw mode\n");
-               return;
-       }
-
-       il->active_rate = 0;
-
-       for (i = 0; i < hw->n_bitrates; i++) {
-               rate = &(hw->bitrates[i]);
-               if (rate->hw_value < RATE_COUNT_LEGACY)
-                       il->active_rate |= (1 << rate->hw_value);
-       }
-
-       D_RATE("Set active_rate = %0x\n", il->active_rate);
-
-       il->staging.cck_basic_rates =
-           (IL_CCK_BASIC_RATES_MASK >> IL_FIRST_CCK_RATE) & 0xF;
-
-       il->staging.ofdm_basic_rates =
-           (IL_OFDM_BASIC_RATES_MASK >> IL_FIRST_OFDM_RATE) & 0xFF;
-}
-EXPORT_SYMBOL(il_set_rate);
-
-void
-il_chswitch_done(struct il_priv *il, bool is_success)
-{
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       if (test_and_clear_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
-               ieee80211_chswitch_done(il->vif, is_success);
-}
-EXPORT_SYMBOL(il_chswitch_done);
-
-void
-il_hdl_csa(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_csa_notification *csa = &(pkt->u.csa_notif);
-       struct il_rxon_cmd *rxon = (void *)&il->active;
-
-       if (!test_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
-               return;
-
-       if (!le32_to_cpu(csa->status) && csa->channel == il->switch_channel) {
-               rxon->channel = csa->channel;
-               il->staging.channel = csa->channel;
-               D_11H("CSA notif: channel %d\n", le16_to_cpu(csa->channel));
-               il_chswitch_done(il, true);
-       } else {
-               IL_ERR("CSA notif (fail) : channel %d\n",
-                      le16_to_cpu(csa->channel));
-               il_chswitch_done(il, false);
-       }
-}
-EXPORT_SYMBOL(il_hdl_csa);
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-void
-il_print_rx_config_cmd(struct il_priv *il)
-{
-       struct il_rxon_cmd *rxon = &il->staging;
-
-       D_RADIO("RX CONFIG:\n");
-       il_print_hex_dump(il, IL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
-       D_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
-       D_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
-       D_RADIO("u32 filter_flags: 0x%08x\n", le32_to_cpu(rxon->filter_flags));
-       D_RADIO("u8 dev_type: 0x%x\n", rxon->dev_type);
-       D_RADIO("u8 ofdm_basic_rates: 0x%02x\n", rxon->ofdm_basic_rates);
-       D_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
-       D_RADIO("u8[6] node_addr: %pM\n", rxon->node_addr);
-       D_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
-       D_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
-}
-EXPORT_SYMBOL(il_print_rx_config_cmd);
-#endif
-/**
- * il_irq_handle_error - called for HW or SW error interrupt from card
- */
-void
-il_irq_handle_error(struct il_priv *il)
-{
-       /* Set the FW error flag -- cleared on il_down */
-       set_bit(S_FW_ERROR, &il->status);
-
-       /* Cancel currently queued command. */
-       clear_bit(S_HCMD_ACTIVE, &il->status);
-
-       IL_ERR("Loaded firmware version: %s\n", il->hw->wiphy->fw_version);
-
-       il->ops->dump_nic_error_log(il);
-       if (il->ops->dump_fh)
-               il->ops->dump_fh(il, NULL, false);
-#ifdef CONFIG_IWLEGACY_DEBUG
-       if (il_get_debug_level(il) & IL_DL_FW_ERRORS)
-               il_print_rx_config_cmd(il);
-#endif
-
-       wake_up(&il->wait_command_queue);
-
-       /* Keep the restart process from trying to send host
-        * commands by clearing the INIT status bit */
-       clear_bit(S_READY, &il->status);
-
-       if (!test_bit(S_EXIT_PENDING, &il->status)) {
-               IL_DBG(IL_DL_FW_ERRORS,
-                      "Restarting adapter due to uCode error.\n");
-
-               if (il->cfg->mod_params->restart_fw)
-                       queue_work(il->workqueue, &il->restart);
-       }
-}
-EXPORT_SYMBOL(il_irq_handle_error);
-
-static int
-_il_apm_stop_master(struct il_priv *il)
-{
-       int ret = 0;
-
-       /* stop device's busmaster DMA activity */
-       _il_set_bit(il, CSR_RESET, CSR_RESET_REG_FLAG_STOP_MASTER);
-
-       ret =
-           _il_poll_bit(il, CSR_RESET, CSR_RESET_REG_FLAG_MASTER_DISABLED,
-                        CSR_RESET_REG_FLAG_MASTER_DISABLED, 100);
-       if (ret < 0)
-               IL_WARN("Master Disable Timed Out, 100 usec\n");
-
-       D_INFO("stop master\n");
-
-       return ret;
-}
-
-void
-_il_apm_stop(struct il_priv *il)
-{
-       lockdep_assert_held(&il->reg_lock);
-
-       D_INFO("Stop card, put in low power state\n");
-
-       /* Stop device's DMA activity */
-       _il_apm_stop_master(il);
-
-       /* Reset the entire device */
-       _il_set_bit(il, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);
-
-       udelay(10);
-
-       /*
-        * Clear "initialization complete" bit to move adapter from
-        * D0A* (powered-up Active) --> D0U* (Uninitialized) state.
-        */
-       _il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
-}
-EXPORT_SYMBOL(_il_apm_stop);
-
-void
-il_apm_stop(struct il_priv *il)
-{
-       unsigned long flags;
-
-       spin_lock_irqsave(&il->reg_lock, flags);
-       _il_apm_stop(il);
-       spin_unlock_irqrestore(&il->reg_lock, flags);
-}
-EXPORT_SYMBOL(il_apm_stop);
-
-/*
- * Start up NIC's basic functionality after it has been reset
- * (e.g. after platform boot, or shutdown via il_apm_stop())
- * NOTE:  This does not load uCode nor start the embedded processor
- */
-int
-il_apm_init(struct il_priv *il)
-{
-       int ret = 0;
-       u16 lctl;
-
-       D_INFO("Init card's basic functions\n");
-
-       /*
-        * Use "set_bit" below rather than "write", to preserve any hardware
-        * bits already set by default after reset.
-        */
-
-       /* Disable L0S exit timer (platform NMI Work/Around) */
-       il_set_bit(il, CSR_GIO_CHICKEN_BITS,
-                  CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
-
-       /*
-        * Disable L0s without affecting L1;
-        *  don't wait for ICH L0s (ICH bug W/A)
-        */
-       il_set_bit(il, CSR_GIO_CHICKEN_BITS,
-                  CSR_GIO_CHICKEN_BITS_REG_BIT_L1A_NO_L0S_RX);
-
-       /* Set FH wait threshold to maximum (HW error during stress W/A) */
-       il_set_bit(il, CSR_DBG_HPET_MEM_REG, CSR_DBG_HPET_MEM_REG_VAL);
-
-       /*
-        * Enable HAP INTA (interrupt from management bus) to
-        * wake device's PCI Express link L1a -> L0s
-        * NOTE:  This is no-op for 3945 (non-existent bit)
-        */
-       il_set_bit(il, CSR_HW_IF_CONFIG_REG,
-                  CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A);
-
-       /*
-        * HW bug W/A for instability in PCIe bus L0->L0S->L1 transition.
-        * Check if BIOS (or OS) enabled L1-ASPM on this device.
-        * If so (likely), disable L0S, so device moves directly L0->L1;
-        *    costs negligible amount of power savings.
-        * If not (unlikely), enable L0S, so there is at least some
-        *    power savings, even without L1.
-        */
-       if (il->cfg->set_l0s) {
-               pcie_capability_read_word(il->pci_dev, PCI_EXP_LNKCTL, &lctl);
-               if (lctl & PCI_EXP_LNKCTL_ASPM_L1) {
-                       /* L1-ASPM enabled; disable(!) L0S  */
-                       il_set_bit(il, CSR_GIO_REG,
-                                  CSR_GIO_REG_VAL_L0S_ENABLED);
-                       D_POWER("L1 Enabled; Disabling L0S\n");
-               } else {
-                       /* L1-ASPM disabled; enable(!) L0S */
-                       il_clear_bit(il, CSR_GIO_REG,
-                                    CSR_GIO_REG_VAL_L0S_ENABLED);
-                       D_POWER("L1 Disabled; Enabling L0S\n");
-               }
-       }
-
-       /* Configure analog phase-lock-loop before activating to D0A */
-       if (il->cfg->pll_cfg_val)
-               il_set_bit(il, CSR_ANA_PLL_CFG,
-                          il->cfg->pll_cfg_val);
-
-       /*
-        * Set "initialization complete" bit to move adapter from
-        * D0U* --> D0A* (powered-up active) state.
-        */
-       il_set_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
-
-       /*
-        * Wait for clock stabilization; once stabilized, access to
-        * device-internal resources is supported, e.g. il_wr_prph()
-        * and accesses to uCode SRAM.
-        */
-       ret =
-           _il_poll_bit(il, CSR_GP_CNTRL,
-                        CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
-                        CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
-       if (ret < 0) {
-               D_INFO("Failed to init the card\n");
-               goto out;
-       }
-
-       /*
-        * Enable DMA and BSM (if used) clocks, wait for them to stabilize.
-        * BSM (Boostrap State Machine) is only in 3945 and 4965.
-        *
-        * Write to "CLK_EN_REG"; "1" bits enable clocks, while "0" bits
-        * do not disable clocks.  This preserves any hardware bits already
-        * set by default in "CLK_CTRL_REG" after reset.
-        */
-       if (il->cfg->use_bsm)
-               il_wr_prph(il, APMG_CLK_EN_REG,
-                          APMG_CLK_VAL_DMA_CLK_RQT | APMG_CLK_VAL_BSM_CLK_RQT);
-       else
-               il_wr_prph(il, APMG_CLK_EN_REG, APMG_CLK_VAL_DMA_CLK_RQT);
-       udelay(20);
-
-       /* Disable L1-Active */
-       il_set_bits_prph(il, APMG_PCIDEV_STT_REG,
-                        APMG_PCIDEV_STT_VAL_L1_ACT_DIS);
-
-out:
-       return ret;
-}
-EXPORT_SYMBOL(il_apm_init);
-
-int
-il_set_tx_power(struct il_priv *il, s8 tx_power, bool force)
-{
-       int ret;
-       s8 prev_tx_power;
-       bool defer;
-
-       lockdep_assert_held(&il->mutex);
-
-       if (il->tx_power_user_lmt == tx_power && !force)
-               return 0;
-
-       if (!il->ops->send_tx_power)
-               return -EOPNOTSUPP;
-
-       /* 0 dBm mean 1 milliwatt */
-       if (tx_power < 0) {
-               IL_WARN("Requested user TXPOWER %d below 1 mW.\n", tx_power);
-               return -EINVAL;
-       }
-
-       if (tx_power > il->tx_power_device_lmt) {
-               IL_WARN("Requested user TXPOWER %d above upper limit %d.\n",
-                       tx_power, il->tx_power_device_lmt);
-               return -EINVAL;
-       }
-
-       if (!il_is_ready_rf(il))
-               return -EIO;
-
-       /* scan complete and commit_rxon use tx_power_next value,
-        * it always need to be updated for newest request */
-       il->tx_power_next = tx_power;
-
-       /* do not set tx power when scanning or channel changing */
-       defer = test_bit(S_SCANNING, &il->status) ||
-           memcmp(&il->active, &il->staging, sizeof(il->staging));
-       if (defer && !force) {
-               D_INFO("Deferring tx power set\n");
-               return 0;
-       }
-
-       prev_tx_power = il->tx_power_user_lmt;
-       il->tx_power_user_lmt = tx_power;
-
-       ret = il->ops->send_tx_power(il);
-
-       /* if fail to set tx_power, restore the orig. tx power */
-       if (ret) {
-               il->tx_power_user_lmt = prev_tx_power;
-               il->tx_power_next = prev_tx_power;
-       }
-       return ret;
-}
-EXPORT_SYMBOL(il_set_tx_power);
-
-void
-il_send_bt_config(struct il_priv *il)
-{
-       struct il_bt_cmd bt_cmd = {
-               .lead_time = BT_LEAD_TIME_DEF,
-               .max_kill = BT_MAX_KILL_DEF,
-               .kill_ack_mask = 0,
-               .kill_cts_mask = 0,
-       };
-
-       if (!bt_coex_active)
-               bt_cmd.flags = BT_COEX_DISABLE;
-       else
-               bt_cmd.flags = BT_COEX_ENABLE;
-
-       D_INFO("BT coex %s\n",
-              (bt_cmd.flags == BT_COEX_DISABLE) ? "disable" : "active");
-
-       if (il_send_cmd_pdu(il, C_BT_CONFIG, sizeof(struct il_bt_cmd), &bt_cmd))
-               IL_ERR("failed to send BT Coex Config\n");
-}
-EXPORT_SYMBOL(il_send_bt_config);
-
-int
-il_send_stats_request(struct il_priv *il, u8 flags, bool clear)
-{
-       struct il_stats_cmd stats_cmd = {
-               .configuration_flags = clear ? IL_STATS_CONF_CLEAR_STATS : 0,
-       };
-
-       if (flags & CMD_ASYNC)
-               return il_send_cmd_pdu_async(il, C_STATS, sizeof(struct il_stats_cmd),
-                                            &stats_cmd, NULL);
-       else
-               return il_send_cmd_pdu(il, C_STATS, sizeof(struct il_stats_cmd),
-                                      &stats_cmd);
-}
-EXPORT_SYMBOL(il_send_stats_request);
-
-void
-il_hdl_pm_sleep(struct il_priv *il, struct il_rx_buf *rxb)
-{
-#ifdef CONFIG_IWLEGACY_DEBUG
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       struct il_sleep_notification *sleep = &(pkt->u.sleep_notif);
-       D_RX("sleep mode: %d, src: %d\n",
-            sleep->pm_sleep_mode, sleep->pm_wakeup_src);
-#endif
-}
-EXPORT_SYMBOL(il_hdl_pm_sleep);
-
-void
-il_hdl_pm_debug_stats(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-       u32 len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
-       D_RADIO("Dumping %d bytes of unhandled notification for %s:\n", len,
-               il_get_cmd_string(pkt->hdr.cmd));
-       il_print_hex_dump(il, IL_DL_RADIO, pkt->u.raw, len);
-}
-EXPORT_SYMBOL(il_hdl_pm_debug_stats);
-
-void
-il_hdl_error(struct il_priv *il, struct il_rx_buf *rxb)
-{
-       struct il_rx_pkt *pkt = rxb_addr(rxb);
-
-       IL_ERR("Error Reply type 0x%08X cmd %s (0x%02X) "
-              "seq 0x%04X ser 0x%08X\n",
-              le32_to_cpu(pkt->u.err_resp.error_type),
-              il_get_cmd_string(pkt->u.err_resp.cmd_id),
-              pkt->u.err_resp.cmd_id,
-              le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
-              le32_to_cpu(pkt->u.err_resp.error_info));
-}
-EXPORT_SYMBOL(il_hdl_error);
-
-void
-il_clear_isr_stats(struct il_priv *il)
-{
-       memset(&il->isr_stats, 0, sizeof(il->isr_stats));
-}
-
-int
-il_mac_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue,
-              const struct ieee80211_tx_queue_params *params)
-{
-       struct il_priv *il = hw->priv;
-       unsigned long flags;
-       int q;
-
-       D_MAC80211("enter\n");
-
-       if (!il_is_ready_rf(il)) {
-               D_MAC80211("leave - RF not ready\n");
-               return -EIO;
-       }
-
-       if (queue >= AC_NUM) {
-               D_MAC80211("leave - queue >= AC_NUM %d\n", queue);
-               return 0;
-       }
-
-       q = AC_NUM - 1 - queue;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       il->qos_data.def_qos_parm.ac[q].cw_min =
-           cpu_to_le16(params->cw_min);
-       il->qos_data.def_qos_parm.ac[q].cw_max =
-           cpu_to_le16(params->cw_max);
-       il->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
-       il->qos_data.def_qos_parm.ac[q].edca_txop =
-           cpu_to_le16((params->txop * 32));
-
-       il->qos_data.def_qos_parm.ac[q].reserved1 = 0;
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       D_MAC80211("leave\n");
-       return 0;
-}
-EXPORT_SYMBOL(il_mac_conf_tx);
-
-int
-il_mac_tx_last_beacon(struct ieee80211_hw *hw)
-{
-       struct il_priv *il = hw->priv;
-       int ret;
-
-       D_MAC80211("enter\n");
-
-       ret = (il->ibss_manager == IL_IBSS_MANAGER);
-
-       D_MAC80211("leave ret %d\n", ret);
-       return ret;
-}
-EXPORT_SYMBOL_GPL(il_mac_tx_last_beacon);
-
-static int
-il_set_mode(struct il_priv *il)
-{
-       il_connection_init_rx_config(il);
-
-       if (il->ops->set_rxon_chain)
-               il->ops->set_rxon_chain(il);
-
-       return il_commit_rxon(il);
-}
-
-int
-il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
-{
-       struct il_priv *il = hw->priv;
-       int err;
-       bool reset;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
-
-       if (!il_is_ready_rf(il)) {
-               IL_WARN("Try to add interface when device not ready\n");
-               err = -EINVAL;
-               goto out;
-       }
-
-       /*
-        * We do not support multiple virtual interfaces, but on hardware reset
-        * we have to add the same interface again.
-        */
-       reset = (il->vif == vif);
-       if (il->vif && !reset) {
-               err = -EOPNOTSUPP;
-               goto out;
-       }
-
-       il->vif = vif;
-       il->iw_mode = vif->type;
-
-       err = il_set_mode(il);
-       if (err) {
-               IL_WARN("Fail to set mode %d\n", vif->type);
-               if (!reset) {
-                       il->vif = NULL;
-                       il->iw_mode = NL80211_IFTYPE_STATION;
-               }
-       }
-
-out:
-       D_MAC80211("leave err %d\n", err);
-       mutex_unlock(&il->mutex);
-
-       return err;
-}
-EXPORT_SYMBOL(il_mac_add_interface);
-
-static void
-il_teardown_interface(struct il_priv *il, struct ieee80211_vif *vif)
-{
-       lockdep_assert_held(&il->mutex);
-
-       if (il->scan_vif == vif) {
-               il_scan_cancel_timeout(il, 200);
-               il_force_scan_end(il);
-       }
-
-       il_set_mode(il);
-}
-
-void
-il_mac_remove_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
-{
-       struct il_priv *il = hw->priv;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
-
-       WARN_ON(il->vif != vif);
-       il->vif = NULL;
-       il->iw_mode = NL80211_IFTYPE_UNSPECIFIED;
-       il_teardown_interface(il, vif);
-       eth_zero_addr(il->bssid);
-
-       D_MAC80211("leave\n");
-       mutex_unlock(&il->mutex);
-}
-EXPORT_SYMBOL(il_mac_remove_interface);
-
-int
-il_alloc_txq_mem(struct il_priv *il)
-{
-       if (!il->txq)
-               il->txq =
-                   kzalloc(sizeof(struct il_tx_queue) *
-                           il->cfg->num_of_queues, GFP_KERNEL);
-       if (!il->txq) {
-               IL_ERR("Not enough memory for txq\n");
-               return -ENOMEM;
-       }
-       return 0;
-}
-EXPORT_SYMBOL(il_alloc_txq_mem);
-
-void
-il_free_txq_mem(struct il_priv *il)
-{
-       kfree(il->txq);
-       il->txq = NULL;
-}
-EXPORT_SYMBOL(il_free_txq_mem);
-
-int
-il_force_reset(struct il_priv *il, bool external)
-{
-       struct il_force_reset *force_reset;
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return -EINVAL;
-
-       force_reset = &il->force_reset;
-       force_reset->reset_request_count++;
-       if (!external) {
-               if (force_reset->last_force_reset_jiffies &&
-                   time_after(force_reset->last_force_reset_jiffies +
-                              force_reset->reset_duration, jiffies)) {
-                       D_INFO("force reset rejected\n");
-                       force_reset->reset_reject_count++;
-                       return -EAGAIN;
-               }
-       }
-       force_reset->reset_success_count++;
-       force_reset->last_force_reset_jiffies = jiffies;
-
-       /*
-        * if the request is from external(ex: debugfs),
-        * then always perform the request in regardless the module
-        * parameter setting
-        * if the request is from internal (uCode error or driver
-        * detect failure), then fw_restart module parameter
-        * need to be check before performing firmware reload
-        */
-
-       if (!external && !il->cfg->mod_params->restart_fw) {
-               D_INFO("Cancel firmware reload based on "
-                      "module parameter setting\n");
-               return 0;
-       }
-
-       IL_ERR("On demand firmware reload\n");
-
-       /* Set the FW error flag -- cleared on il_down */
-       set_bit(S_FW_ERROR, &il->status);
-       wake_up(&il->wait_command_queue);
-       /*
-        * Keep the restart process from trying to send host
-        * commands by clearing the INIT status bit
-        */
-       clear_bit(S_READY, &il->status);
-       queue_work(il->workqueue, &il->restart);
-
-       return 0;
-}
-EXPORT_SYMBOL(il_force_reset);
-
-int
-il_mac_change_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                       enum nl80211_iftype newtype, bool newp2p)
-{
-       struct il_priv *il = hw->priv;
-       int err;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter: type %d, addr %pM newtype %d newp2p %d\n",
-                   vif->type, vif->addr, newtype, newp2p);
-
-       if (newp2p) {
-               err = -EOPNOTSUPP;
-               goto out;
-       }
-
-       if (!il->vif || !il_is_ready_rf(il)) {
-               /*
-                * Huh? But wait ... this can maybe happen when
-                * we're in the middle of a firmware restart!
-                */
-               err = -EBUSY;
-               goto out;
-       }
-
-       /* success */
-       vif->type = newtype;
-       vif->p2p = false;
-       il->iw_mode = newtype;
-       il_teardown_interface(il, vif);
-       err = 0;
-
-out:
-       D_MAC80211("leave err %d\n", err);
-       mutex_unlock(&il->mutex);
-
-       return err;
-}
-EXPORT_SYMBOL(il_mac_change_interface);
-
-void il_mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                 u32 queues, bool drop)
-{
-       struct il_priv *il = hw->priv;
-       unsigned long timeout = jiffies + msecs_to_jiffies(500);
-       int i;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter\n");
-
-       if (il->txq == NULL)
-               goto out;
-
-       for (i = 0; i < il->hw_params.max_txq_num; i++) {
-               struct il_queue *q;
-
-               if (i == il->cmd_queue)
-                       continue;
-
-               q = &il->txq[i].q;
-               if (q->read_ptr == q->write_ptr)
-                       continue;
-
-               if (time_after(jiffies, timeout)) {
-                       IL_ERR("Failed to flush queue %d\n", q->id);
-                       break;
-               }
-
-               msleep(20);
-       }
-out:
-       D_MAC80211("leave\n");
-       mutex_unlock(&il->mutex);
-}
-EXPORT_SYMBOL(il_mac_flush);
-
-/*
- * On every watchdog tick we check (latest) time stamp. If it does not
- * change during timeout period and queue is not empty we reset firmware.
- */
-static int
-il_check_stuck_queue(struct il_priv *il, int cnt)
-{
-       struct il_tx_queue *txq = &il->txq[cnt];
-       struct il_queue *q = &txq->q;
-       unsigned long timeout;
-       unsigned long now = jiffies;
-       int ret;
-
-       if (q->read_ptr == q->write_ptr) {
-               txq->time_stamp = now;
-               return 0;
-       }
-
-       timeout =
-           txq->time_stamp +
-           msecs_to_jiffies(il->cfg->wd_timeout);
-
-       if (time_after(now, timeout)) {
-               IL_ERR("Queue %d stuck for %u ms.\n", q->id,
-                      jiffies_to_msecs(now - txq->time_stamp));
-               ret = il_force_reset(il, false);
-               return (ret == -EAGAIN) ? 0 : 1;
-       }
-
-       return 0;
-}
-
-/*
- * Making watchdog tick be a quarter of timeout assure we will
- * discover the queue hung between timeout and 1.25*timeout
- */
-#define IL_WD_TICK(timeout) ((timeout) / 4)
-
-/*
- * Watchdog timer callback, we check each tx queue for stuck, if if hung
- * we reset the firmware. If everything is fine just rearm the timer.
- */
-void
-il_bg_watchdog(unsigned long data)
-{
-       struct il_priv *il = (struct il_priv *)data;
-       int cnt;
-       unsigned long timeout;
-
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       timeout = il->cfg->wd_timeout;
-       if (timeout == 0)
-               return;
-
-       /* monitor and check for stuck cmd queue */
-       if (il_check_stuck_queue(il, il->cmd_queue))
-               return;
-
-       /* monitor and check for other stuck queues */
-       for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
-               /* skip as we already checked the command queue */
-               if (cnt == il->cmd_queue)
-                       continue;
-               if (il_check_stuck_queue(il, cnt))
-                       return;
-       }
-
-       mod_timer(&il->watchdog,
-                 jiffies + msecs_to_jiffies(IL_WD_TICK(timeout)));
-}
-EXPORT_SYMBOL(il_bg_watchdog);
-
-void
-il_setup_watchdog(struct il_priv *il)
-{
-       unsigned int timeout = il->cfg->wd_timeout;
-
-       if (timeout)
-               mod_timer(&il->watchdog,
-                         jiffies + msecs_to_jiffies(IL_WD_TICK(timeout)));
-       else
-               del_timer(&il->watchdog);
-}
-EXPORT_SYMBOL(il_setup_watchdog);
-
-/*
- * extended beacon time format
- * time in usec will be changed into a 32-bit value in extended:internal format
- * the extended part is the beacon counts
- * the internal part is the time in usec within one beacon interval
- */
-u32
-il_usecs_to_beacons(struct il_priv *il, u32 usec, u32 beacon_interval)
-{
-       u32 quot;
-       u32 rem;
-       u32 interval = beacon_interval * TIME_UNIT;
-
-       if (!interval || !usec)
-               return 0;
-
-       quot =
-           (usec /
-            interval) & (il_beacon_time_mask_high(il,
-                                                  il->hw_params.
-                                                  beacon_time_tsf_bits) >> il->
-                         hw_params.beacon_time_tsf_bits);
-       rem =
-           (usec % interval) & il_beacon_time_mask_low(il,
-                                                       il->hw_params.
-                                                       beacon_time_tsf_bits);
-
-       return (quot << il->hw_params.beacon_time_tsf_bits) + rem;
-}
-EXPORT_SYMBOL(il_usecs_to_beacons);
-
-/* base is usually what we get from ucode with each received frame,
- * the same as HW timer counter counting down
- */
-__le32
-il_add_beacon_time(struct il_priv *il, u32 base, u32 addon,
-                  u32 beacon_interval)
-{
-       u32 base_low = base & il_beacon_time_mask_low(il,
-                                                     il->hw_params.
-                                                     beacon_time_tsf_bits);
-       u32 addon_low = addon & il_beacon_time_mask_low(il,
-                                                       il->hw_params.
-                                                       beacon_time_tsf_bits);
-       u32 interval = beacon_interval * TIME_UNIT;
-       u32 res = (base & il_beacon_time_mask_high(il,
-                                                  il->hw_params.
-                                                  beacon_time_tsf_bits)) +
-           (addon & il_beacon_time_mask_high(il,
-                                             il->hw_params.
-                                             beacon_time_tsf_bits));
-
-       if (base_low > addon_low)
-               res += base_low - addon_low;
-       else if (base_low < addon_low) {
-               res += interval + base_low - addon_low;
-               res += (1 << il->hw_params.beacon_time_tsf_bits);
-       } else
-               res += (1 << il->hw_params.beacon_time_tsf_bits);
-
-       return cpu_to_le32(res);
-}
-EXPORT_SYMBOL(il_add_beacon_time);
-
-#ifdef CONFIG_PM_SLEEP
-
-static int
-il_pci_suspend(struct device *device)
-{
-       struct pci_dev *pdev = to_pci_dev(device);
-       struct il_priv *il = pci_get_drvdata(pdev);
-
-       /*
-        * This function is called when system goes into suspend state
-        * mac80211 will call il_mac_stop() from the mac80211 suspend function
-        * first but since il_mac_stop() has no knowledge of who the caller is,
-        * it will not call apm_ops.stop() to stop the DMA operation.
-        * Calling apm_ops.stop here to make sure we stop the DMA.
-        */
-       il_apm_stop(il);
-
-       return 0;
-}
-
-static int
-il_pci_resume(struct device *device)
-{
-       struct pci_dev *pdev = to_pci_dev(device);
-       struct il_priv *il = pci_get_drvdata(pdev);
-       bool hw_rfkill = false;
-
-       /*
-        * We disable the RETRY_TIMEOUT register (0x41) to keep
-        * PCI Tx retries from interfering with C3 CPU state.
-        */
-       pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
-
-       il_enable_interrupts(il);
-
-       if (!(_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
-               hw_rfkill = true;
-
-       if (hw_rfkill)
-               set_bit(S_RFKILL, &il->status);
-       else
-               clear_bit(S_RFKILL, &il->status);
-
-       wiphy_rfkill_set_hw_state(il->hw->wiphy, hw_rfkill);
-
-       return 0;
-}
-
-SIMPLE_DEV_PM_OPS(il_pm_ops, il_pci_suspend, il_pci_resume);
-EXPORT_SYMBOL(il_pm_ops);
-
-#endif /* CONFIG_PM_SLEEP */
-
-static void
-il_update_qos(struct il_priv *il)
-{
-       if (test_bit(S_EXIT_PENDING, &il->status))
-               return;
-
-       il->qos_data.def_qos_parm.qos_flags = 0;
-
-       if (il->qos_data.qos_active)
-               il->qos_data.def_qos_parm.qos_flags |=
-                   QOS_PARAM_FLG_UPDATE_EDCA_MSK;
-
-       if (il->ht.enabled)
-               il->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;
-
-       D_QOS("send QoS cmd with Qos active=%d FLAGS=0x%X\n",
-             il->qos_data.qos_active, il->qos_data.def_qos_parm.qos_flags);
-
-       il_send_cmd_pdu_async(il, C_QOS_PARAM, sizeof(struct il_qosparam_cmd),
-                             &il->qos_data.def_qos_parm, NULL);
-}
-
-/**
- * il_mac_config - mac80211 config callback
- */
-int
-il_mac_config(struct ieee80211_hw *hw, u32 changed)
-{
-       struct il_priv *il = hw->priv;
-       const struct il_channel_info *ch_info;
-       struct ieee80211_conf *conf = &hw->conf;
-       struct ieee80211_channel *channel = conf->chandef.chan;
-       struct il_ht_config *ht_conf = &il->current_ht_config;
-       unsigned long flags = 0;
-       int ret = 0;
-       u16 ch;
-       int scan_active = 0;
-       bool ht_changed = false;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter: channel %d changed 0x%X\n", channel->hw_value,
-                  changed);
-
-       if (unlikely(test_bit(S_SCANNING, &il->status))) {
-               scan_active = 1;
-               D_MAC80211("scan active\n");
-       }
-
-       if (changed &
-           (IEEE80211_CONF_CHANGE_SMPS | IEEE80211_CONF_CHANGE_CHANNEL)) {
-               /* mac80211 uses static for non-HT which is what we want */
-               il->current_ht_config.smps = conf->smps_mode;
-
-               /*
-                * Recalculate chain counts.
-                *
-                * If monitor mode is enabled then mac80211 will
-                * set up the SM PS mode to OFF if an HT channel is
-                * configured.
-                */
-               if (il->ops->set_rxon_chain)
-                       il->ops->set_rxon_chain(il);
-       }
-
-       /* during scanning mac80211 will delay channel setting until
-        * scan finish with changed = 0
-        */
-       if (!changed || (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
-
-               if (scan_active)
-                       goto set_ch_out;
-
-               ch = channel->hw_value;
-               ch_info = il_get_channel_info(il, channel->band, ch);
-               if (!il_is_channel_valid(ch_info)) {
-                       D_MAC80211("leave - invalid channel\n");
-                       ret = -EINVAL;
-                       goto set_ch_out;
-               }
-
-               if (il->iw_mode == NL80211_IFTYPE_ADHOC &&
-                   !il_is_channel_ibss(ch_info)) {
-                       D_MAC80211("leave - not IBSS channel\n");
-                       ret = -EINVAL;
-                       goto set_ch_out;
-               }
-
-               spin_lock_irqsave(&il->lock, flags);
-
-               /* Configure HT40 channels */
-               if (il->ht.enabled != conf_is_ht(conf)) {
-                       il->ht.enabled = conf_is_ht(conf);
-                       ht_changed = true;
-               }
-               if (il->ht.enabled) {
-                       if (conf_is_ht40_minus(conf)) {
-                               il->ht.extension_chan_offset =
-                                   IEEE80211_HT_PARAM_CHA_SEC_BELOW;
-                               il->ht.is_40mhz = true;
-                       } else if (conf_is_ht40_plus(conf)) {
-                               il->ht.extension_chan_offset =
-                                   IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
-                               il->ht.is_40mhz = true;
-                       } else {
-                               il->ht.extension_chan_offset =
-                                   IEEE80211_HT_PARAM_CHA_SEC_NONE;
-                               il->ht.is_40mhz = false;
-                       }
-               } else
-                       il->ht.is_40mhz = false;
-
-               /*
-                * Default to no protection. Protection mode will
-                * later be set from BSS config in il_ht_conf
-                */
-               il->ht.protection = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
-
-               /* if we are switching from ht to 2.4 clear flags
-                * from any ht related info since 2.4 does not
-                * support ht */
-               if ((le16_to_cpu(il->staging.channel) != ch))
-                       il->staging.flags = 0;
-
-               il_set_rxon_channel(il, channel);
-               il_set_rxon_ht(il, ht_conf);
-
-               il_set_flags_for_band(il, channel->band, il->vif);
-
-               spin_unlock_irqrestore(&il->lock, flags);
-
-               if (il->ops->update_bcast_stations)
-                       ret = il->ops->update_bcast_stations(il);
-
-set_ch_out:
-               /* The list of supported rates and rate mask can be different
-                * for each band; since the band may have changed, reset
-                * the rate mask to what mac80211 lists */
-               il_set_rate(il);
-       }
-
-       if (changed & (IEEE80211_CONF_CHANGE_PS | IEEE80211_CONF_CHANGE_IDLE)) {
-               il->power_data.ps_disabled = !(conf->flags & IEEE80211_CONF_PS);
-               ret = il_power_update_mode(il, false);
-               if (ret)
-                       D_MAC80211("Error setting sleep level\n");
-       }
-
-       if (changed & IEEE80211_CONF_CHANGE_POWER) {
-               D_MAC80211("TX Power old=%d new=%d\n", il->tx_power_user_lmt,
-                          conf->power_level);
-
-               il_set_tx_power(il, conf->power_level, false);
-       }
-
-       if (!il_is_ready(il)) {
-               D_MAC80211("leave - not ready\n");
-               goto out;
-       }
-
-       if (scan_active)
-               goto out;
-
-       if (memcmp(&il->active, &il->staging, sizeof(il->staging)))
-               il_commit_rxon(il);
-       else
-               D_INFO("Not re-sending same RXON configuration.\n");
-       if (ht_changed)
-               il_update_qos(il);
-
-out:
-       D_MAC80211("leave ret %d\n", ret);
-       mutex_unlock(&il->mutex);
-
-       return ret;
-}
-EXPORT_SYMBOL(il_mac_config);
-
-void
-il_mac_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
-{
-       struct il_priv *il = hw->priv;
-       unsigned long flags;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       memset(&il->current_ht_config, 0, sizeof(struct il_ht_config));
-
-       /* new association get rid of ibss beacon skb */
-       if (il->beacon_skb)
-               dev_kfree_skb(il->beacon_skb);
-       il->beacon_skb = NULL;
-       il->timestamp = 0;
-
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       il_scan_cancel_timeout(il, 100);
-       if (!il_is_ready_rf(il)) {
-               D_MAC80211("leave - not ready\n");
-               mutex_unlock(&il->mutex);
-               return;
-       }
-
-       /* we are restarting association process */
-       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-       il_commit_rxon(il);
-
-       il_set_rate(il);
-
-       D_MAC80211("leave\n");
-       mutex_unlock(&il->mutex);
-}
-EXPORT_SYMBOL(il_mac_reset_tsf);
-
-static void
-il_ht_conf(struct il_priv *il, struct ieee80211_vif *vif)
-{
-       struct il_ht_config *ht_conf = &il->current_ht_config;
-       struct ieee80211_sta *sta;
-       struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
-
-       D_ASSOC("enter:\n");
-
-       if (!il->ht.enabled)
-               return;
-
-       il->ht.protection =
-           bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
-       il->ht.non_gf_sta_present =
-           !!(bss_conf->
-              ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
-
-       ht_conf->single_chain_sufficient = false;
-
-       switch (vif->type) {
-       case NL80211_IFTYPE_STATION:
-               rcu_read_lock();
-               sta = ieee80211_find_sta(vif, bss_conf->bssid);
-               if (sta) {
-                       struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
-                       int maxstreams;
-
-                       maxstreams =
-                           (ht_cap->mcs.
-                            tx_params & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
-                           >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
-                       maxstreams += 1;
-
-                       if (ht_cap->mcs.rx_mask[1] == 0 &&
-                           ht_cap->mcs.rx_mask[2] == 0)
-                               ht_conf->single_chain_sufficient = true;
-                       if (maxstreams <= 1)
-                               ht_conf->single_chain_sufficient = true;
-               } else {
-                       /*
-                        * If at all, this can only happen through a race
-                        * when the AP disconnects us while we're still
-                        * setting up the connection, in that case mac80211
-                        * will soon tell us about that.
-                        */
-                       ht_conf->single_chain_sufficient = true;
-               }
-               rcu_read_unlock();
-               break;
-       case NL80211_IFTYPE_ADHOC:
-               ht_conf->single_chain_sufficient = true;
-               break;
-       default:
-               break;
-       }
-
-       D_ASSOC("leave\n");
-}
-
-static inline void
-il_set_no_assoc(struct il_priv *il, struct ieee80211_vif *vif)
-{
-       /*
-        * inform the ucode that there is no longer an
-        * association and that no more packets should be
-        * sent
-        */
-       il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-       il->staging.assoc_id = 0;
-       il_commit_rxon(il);
-}
-
-static void
-il_beacon_update(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
-{
-       struct il_priv *il = hw->priv;
-       unsigned long flags;
-       __le64 timestamp;
-       struct sk_buff *skb = ieee80211_beacon_get(hw, vif);
-
-       if (!skb)
-               return;
-
-       D_MAC80211("enter\n");
-
-       lockdep_assert_held(&il->mutex);
-
-       if (!il->beacon_enabled) {
-               IL_ERR("update beacon with no beaconing enabled\n");
-               dev_kfree_skb(skb);
-               return;
-       }
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       if (il->beacon_skb)
-               dev_kfree_skb(il->beacon_skb);
-
-       il->beacon_skb = skb;
-
-       timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
-       il->timestamp = le64_to_cpu(timestamp);
-
-       D_MAC80211("leave\n");
-       spin_unlock_irqrestore(&il->lock, flags);
-
-       if (!il_is_ready_rf(il)) {
-               D_MAC80211("leave - RF not ready\n");
-               return;
-       }
-
-       il->ops->post_associate(il);
-}
-
-void
-il_mac_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                       struct ieee80211_bss_conf *bss_conf, u32 changes)
-{
-       struct il_priv *il = hw->priv;
-       int ret;
-
-       mutex_lock(&il->mutex);
-       D_MAC80211("enter: changes 0x%x\n", changes);
-
-       if (!il_is_alive(il)) {
-               D_MAC80211("leave - not alive\n");
-               mutex_unlock(&il->mutex);
-               return;
-       }
-
-       if (changes & BSS_CHANGED_QOS) {
-               unsigned long flags;
-
-               spin_lock_irqsave(&il->lock, flags);
-               il->qos_data.qos_active = bss_conf->qos;
-               il_update_qos(il);
-               spin_unlock_irqrestore(&il->lock, flags);
-       }
-
-       if (changes & BSS_CHANGED_BEACON_ENABLED) {
-               /* FIXME: can we remove beacon_enabled ? */
-               if (vif->bss_conf.enable_beacon)
-                       il->beacon_enabled = true;
-               else
-                       il->beacon_enabled = false;
-       }
-
-       if (changes & BSS_CHANGED_BSSID) {
-               D_MAC80211("BSSID %pM\n", bss_conf->bssid);
-
-               /*
-                * On passive channel we wait with blocked queues to see if
-                * there is traffic on that channel. If no frame will be
-                * received (what is very unlikely since scan detects AP on
-                * that channel, but theoretically possible), mac80211 associate
-                * procedure will time out and mac80211 will call us with NULL
-                * bssid. We have to unblock queues on such condition.
-                */
-               if (is_zero_ether_addr(bss_conf->bssid))
-                       il_wake_queues_by_reason(il, IL_STOP_REASON_PASSIVE);
-
-               /*
-                * If there is currently a HW scan going on in the background,
-                * then we need to cancel it, otherwise sometimes we are not
-                * able to authenticate (FIXME: why ?)
-                */
-               if (il_scan_cancel_timeout(il, 100)) {
-                       D_MAC80211("leave - scan abort failed\n");
-                       mutex_unlock(&il->mutex);
-                       return;
-               }
-
-               /* mac80211 only sets assoc when in STATION mode */
-               memcpy(il->staging.bssid_addr, bss_conf->bssid, ETH_ALEN);
-
-               /* FIXME: currently needed in a few places */
-               memcpy(il->bssid, bss_conf->bssid, ETH_ALEN);
-       }
-
-       /*
-        * This needs to be after setting the BSSID in case
-        * mac80211 decides to do both changes at once because
-        * it will invoke post_associate.
-        */
-       if (vif->type == NL80211_IFTYPE_ADHOC && (changes & BSS_CHANGED_BEACON))
-               il_beacon_update(hw, vif);
-
-       if (changes & BSS_CHANGED_ERP_PREAMBLE) {
-               D_MAC80211("ERP_PREAMBLE %d\n", bss_conf->use_short_preamble);
-               if (bss_conf->use_short_preamble)
-                       il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
-               else
-                       il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
-       }
-
-       if (changes & BSS_CHANGED_ERP_CTS_PROT) {
-               D_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
-               if (bss_conf->use_cts_prot && il->band != IEEE80211_BAND_5GHZ)
-                       il->staging.flags |= RXON_FLG_TGG_PROTECT_MSK;
-               else
-                       il->staging.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
-               if (bss_conf->use_cts_prot)
-                       il->staging.flags |= RXON_FLG_SELF_CTS_EN;
-               else
-                       il->staging.flags &= ~RXON_FLG_SELF_CTS_EN;
-       }
-
-       if (changes & BSS_CHANGED_BASIC_RATES) {
-               /* XXX use this information
-                *
-                * To do that, remove code from il_set_rate() and put something
-                * like this here:
-                *
-                if (A-band)
-                il->staging.ofdm_basic_rates =
-                bss_conf->basic_rates;
-                else
-                il->staging.ofdm_basic_rates =
-                bss_conf->basic_rates >> 4;
-                il->staging.cck_basic_rates =
-                bss_conf->basic_rates & 0xF;
-                */
-       }
-
-       if (changes & BSS_CHANGED_HT) {
-               il_ht_conf(il, vif);
-
-               if (il->ops->set_rxon_chain)
-                       il->ops->set_rxon_chain(il);
-       }
-
-       if (changes & BSS_CHANGED_ASSOC) {
-               D_MAC80211("ASSOC %d\n", bss_conf->assoc);
-               if (bss_conf->assoc) {
-                       il->timestamp = bss_conf->sync_tsf;
-
-                       if (!il_is_rfkill(il))
-                               il->ops->post_associate(il);
-               } else
-                       il_set_no_assoc(il, vif);
-       }
-
-       if (changes && il_is_associated(il) && bss_conf->aid) {
-               D_MAC80211("Changes (%#x) while associated\n", changes);
-               ret = il_send_rxon_assoc(il);
-               if (!ret) {
-                       /* Sync active_rxon with latest change. */
-                       memcpy((void *)&il->active, &il->staging,
-                              sizeof(struct il_rxon_cmd));
-               }
-       }
-
-       if (changes & BSS_CHANGED_BEACON_ENABLED) {
-               if (vif->bss_conf.enable_beacon) {
-                       memcpy(il->staging.bssid_addr, bss_conf->bssid,
-                              ETH_ALEN);
-                       memcpy(il->bssid, bss_conf->bssid, ETH_ALEN);
-                       il->ops->config_ap(il);
-               } else
-                       il_set_no_assoc(il, vif);
-       }
-
-       if (changes & BSS_CHANGED_IBSS) {
-               ret = il->ops->manage_ibss_station(il, vif,
-                                                  bss_conf->ibss_joined);
-               if (ret)
-                       IL_ERR("failed to %s IBSS station %pM\n",
-                              bss_conf->ibss_joined ? "add" : "remove",
-                              bss_conf->bssid);
-       }
-
-       D_MAC80211("leave\n");
-       mutex_unlock(&il->mutex);
-}
-EXPORT_SYMBOL(il_mac_bss_info_changed);
-
-irqreturn_t
-il_isr(int irq, void *data)
-{
-       struct il_priv *il = data;
-       u32 inta, inta_mask;
-       u32 inta_fh;
-       unsigned long flags;
-       if (!il)
-               return IRQ_NONE;
-
-       spin_lock_irqsave(&il->lock, flags);
-
-       /* Disable (but don't clear!) interrupts here to avoid
-        *    back-to-back ISRs and sporadic interrupts from our NIC.
-        * If we have something to service, the tasklet will re-enable ints.
-        * If we *don't* have something, we'll re-enable before leaving here. */
-       inta_mask = _il_rd(il, CSR_INT_MASK);   /* just for debug */
-       _il_wr(il, CSR_INT_MASK, 0x00000000);
-
-       /* Discover which interrupts are active/pending */
-       inta = _il_rd(il, CSR_INT);
-       inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
-
-       /* Ignore interrupt if there's nothing in NIC to service.
-        * This may be due to IRQ shared with another device,
-        * or due to sporadic interrupts thrown from our NIC. */
-       if (!inta && !inta_fh) {
-               D_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
-               goto none;
-       }
-
-       if (inta == 0xFFFFFFFF || (inta & 0xFFFFFFF0) == 0xa5a5a5a0) {
-               /* Hardware disappeared. It might have already raised
-                * an interrupt */
-               IL_WARN("HARDWARE GONE?? INTA == 0x%08x\n", inta);
-               goto unplugged;
-       }
-
-       D_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta, inta_mask,
-             inta_fh);
-
-       inta &= ~CSR_INT_BIT_SCD;
-
-       /* il_irq_tasklet() will service interrupts and re-enable them */
-       if (likely(inta || inta_fh))
-               tasklet_schedule(&il->irq_tasklet);
-
-unplugged:
-       spin_unlock_irqrestore(&il->lock, flags);
-       return IRQ_HANDLED;
-
-none:
-       /* re-enable interrupts here since we don't have anything to service. */
-       /* only Re-enable if disabled by irq */
-       if (test_bit(S_INT_ENABLED, &il->status))
-               il_enable_interrupts(il);
-       spin_unlock_irqrestore(&il->lock, flags);
-       return IRQ_NONE;
-}
-EXPORT_SYMBOL(il_isr);
-
-/*
- *  il_tx_cmd_protection: Set rts/cts. 3945 and 4965 only share this
- *  function.
- */
-void
-il_tx_cmd_protection(struct il_priv *il, struct ieee80211_tx_info *info,
-                    __le16 fc, __le32 *tx_flags)
-{
-       if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) {
-               *tx_flags |= TX_CMD_FLG_RTS_MSK;
-               *tx_flags &= ~TX_CMD_FLG_CTS_MSK;
-               *tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
-
-               if (!ieee80211_is_mgmt(fc))
-                       return;
-
-               switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
-               case cpu_to_le16(IEEE80211_STYPE_AUTH):
-               case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
-               case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
-               case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
-                       *tx_flags &= ~TX_CMD_FLG_RTS_MSK;
-                       *tx_flags |= TX_CMD_FLG_CTS_MSK;
-                       break;
-               }
-       } else if (info->control.rates[0].
-                  flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
-               *tx_flags &= ~TX_CMD_FLG_RTS_MSK;
-               *tx_flags |= TX_CMD_FLG_CTS_MSK;
-               *tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
-       }
-}
-EXPORT_SYMBOL(il_tx_cmd_protection);
diff --git a/drivers/net/wireless/iwlegacy/common.h b/drivers/net/wireless/iwlegacy/common.h
deleted file mode 100644 (file)
index ce52cf1..0000000
+++ /dev/null
@@ -1,3084 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-#ifndef __il_core_h__
-#define __il_core_h__
-
-#include <linux/interrupt.h>
-#include <linux/pci.h>         /* for struct pci_device_id */
-#include <linux/kernel.h>
-#include <linux/leds.h>
-#include <linux/wait.h>
-#include <linux/io.h>
-#include <net/mac80211.h>
-#include <net/ieee80211_radiotap.h>
-
-#include "commands.h"
-#include "csr.h"
-#include "prph.h"
-
-struct il_host_cmd;
-struct il_cmd;
-struct il_tx_queue;
-
-#define IL_ERR(f, a...) dev_err(&il->pci_dev->dev, f, ## a)
-#define IL_WARN(f, a...) dev_warn(&il->pci_dev->dev, f, ## a)
-#define IL_INFO(f, a...) dev_info(&il->pci_dev->dev, f, ## a)
-
-#define RX_QUEUE_SIZE                         256
-#define RX_QUEUE_MASK                         255
-#define RX_QUEUE_SIZE_LOG                     8
-
-/*
- * RX related structures and functions
- */
-#define RX_FREE_BUFFERS 64
-#define RX_LOW_WATERMARK 8
-
-#define U32_PAD(n)             ((4-(n))&0x3)
-
-/* CT-KILL constants */
-#define CT_KILL_THRESHOLD_LEGACY   110 /* in Celsius */
-
-/* Default noise level to report when noise measurement is not available.
- *   This may be because we're:
- *   1)  Not associated (4965, no beacon stats being sent to driver)
- *   2)  Scanning (noise measurement does not apply to associated channel)
- *   3)  Receiving CCK (3945 delivers noise info only for OFDM frames)
- * Use default noise value of -127 ... this is below the range of measurable
- *   Rx dBm for either 3945 or 4965, so it can indicate "unmeasurable" to user.
- *   Also, -127 works better than 0 when averaging frames with/without
- *   noise info (e.g. averaging might be done in app); measured dBm values are
- *   always negative ... using a negative value as the default keeps all
- *   averages within an s8's (used in some apps) range of negative values. */
-#define IL_NOISE_MEAS_NOT_AVAILABLE (-127)
-
-/*
- * RTS threshold here is total size [2347] minus 4 FCS bytes
- * Per spec:
- *   a value of 0 means RTS on all data/management packets
- *   a value > max MSDU size means no RTS
- * else RTS for data/management frames where MPDU is larger
- *   than RTS value.
- */
-#define DEFAULT_RTS_THRESHOLD     2347U
-#define MIN_RTS_THRESHOLD         0U
-#define MAX_RTS_THRESHOLD         2347U
-#define MAX_MSDU_SIZE            2304U
-#define MAX_MPDU_SIZE            2346U
-#define DEFAULT_BEACON_INTERVAL   100U
-#define        DEFAULT_SHORT_RETRY_LIMIT 7U
-#define        DEFAULT_LONG_RETRY_LIMIT  4U
-
-struct il_rx_buf {
-       dma_addr_t page_dma;
-       struct page *page;
-       struct list_head list;
-};
-
-#define rxb_addr(r) page_address(r->page)
-
-/* defined below */
-struct il_device_cmd;
-
-struct il_cmd_meta {
-       /* only for SYNC commands, iff the reply skb is wanted */
-       struct il_host_cmd *source;
-       /*
-        * only for ASYNC commands
-        * (which is somewhat stupid -- look at common.c for instance
-        * which duplicates a bunch of code because the callback isn't
-        * invoked for SYNC commands, if it were and its result passed
-        * through it would be simpler...)
-        */
-       void (*callback) (struct il_priv *il, struct il_device_cmd *cmd,
-                         struct il_rx_pkt *pkt);
-
-       /* The CMD_SIZE_HUGE flag bit indicates that the command
-        * structure is stored at the end of the shared queue memory. */
-       u32 flags;
-
-        DEFINE_DMA_UNMAP_ADDR(mapping);
-        DEFINE_DMA_UNMAP_LEN(len);
-};
-
-/*
- * Generic queue structure
- *
- * Contains common data for Rx and Tx queues
- */
-struct il_queue {
-       int n_bd;               /* number of BDs in this queue */
-       int write_ptr;          /* 1-st empty entry (idx) host_w */
-       int read_ptr;           /* last used entry (idx) host_r */
-       /* use for monitoring and recovering the stuck queue */
-       dma_addr_t dma_addr;    /* physical addr for BD's */
-       int n_win;              /* safe queue win */
-       u32 id;
-       int low_mark;           /* low watermark, resume queue if free
-                                * space more than this */
-       int high_mark;          /* high watermark, stop queue if free
-                                * space less than this */
-};
-
-/**
- * struct il_tx_queue - Tx Queue for DMA
- * @q: generic Rx/Tx queue descriptor
- * @bd: base of circular buffer of TFDs
- * @cmd: array of command/TX buffer pointers
- * @meta: array of meta data for each command/tx buffer
- * @dma_addr_cmd: physical address of cmd/tx buffer array
- * @skbs: array of per-TFD socket buffer pointers
- * @time_stamp: time (in jiffies) of last read_ptr change
- * @need_update: indicates need to update read/write idx
- * @sched_retry: indicates queue is high-throughput aggregation (HT AGG) enabled
- *
- * A Tx queue consists of circular buffer of BDs (a.k.a. TFDs, transmit frame
- * descriptors) and required locking structures.
- */
-#define TFD_TX_CMD_SLOTS 256
-#define TFD_CMD_SLOTS 32
-
-struct il_tx_queue {
-       struct il_queue q;
-       void *tfds;
-       struct il_device_cmd **cmd;
-       struct il_cmd_meta *meta;
-       struct sk_buff **skbs;
-       unsigned long time_stamp;
-       u8 need_update;
-       u8 sched_retry;
-       u8 active;
-       u8 swq_id;
-};
-
-/*
- * EEPROM access time values:
- *
- * Driver initiates EEPROM read by writing byte address << 1 to CSR_EEPROM_REG.
- * Driver then polls CSR_EEPROM_REG for CSR_EEPROM_REG_READ_VALID_MSK (0x1).
- * When polling, wait 10 uSec between polling loops, up to a maximum 5000 uSec.
- * Driver reads 16-bit value from bits 31-16 of CSR_EEPROM_REG.
- */
-#define IL_EEPROM_ACCESS_TIMEOUT       5000    /* uSec */
-
-#define IL_EEPROM_SEM_TIMEOUT          10      /* microseconds */
-#define IL_EEPROM_SEM_RETRY_LIMIT      1000    /* number of attempts (not time) */
-
-/*
- * Regulatory channel usage flags in EEPROM struct il4965_eeprom_channel.flags.
- *
- * IBSS and/or AP operation is allowed *only* on those channels with
- * (VALID && IBSS && ACTIVE && !RADAR).  This restriction is in place because
- * RADAR detection is not supported by the 4965 driver, but is a
- * requirement for establishing a new network for legal operation on channels
- * requiring RADAR detection or restricting ACTIVE scanning.
- *
- * NOTE:  "WIDE" flag does not indicate anything about "HT40" 40 MHz channels.
- *        It only indicates that 20 MHz channel use is supported; HT40 channel
- *        usage is indicated by a separate set of regulatory flags for each
- *        HT40 channel pair.
- *
- * NOTE:  Using a channel inappropriately will result in a uCode error!
- */
-#define IL_NUM_TX_CALIB_GROUPS 5
-enum {
-       EEPROM_CHANNEL_VALID = (1 << 0),        /* usable for this SKU/geo */
-       EEPROM_CHANNEL_IBSS = (1 << 1), /* usable as an IBSS channel */
-       /* Bit 2 Reserved */
-       EEPROM_CHANNEL_ACTIVE = (1 << 3),       /* active scanning allowed */
-       EEPROM_CHANNEL_RADAR = (1 << 4),        /* radar detection required */
-       EEPROM_CHANNEL_WIDE = (1 << 5), /* 20 MHz channel okay */
-       /* Bit 6 Reserved (was Narrow Channel) */
-       EEPROM_CHANNEL_DFS = (1 << 7),  /* dynamic freq selection candidate */
-};
-
-/* SKU Capabilities */
-/* 3945 only */
-#define EEPROM_SKU_CAP_SW_RF_KILL_ENABLE                (1 << 0)
-#define EEPROM_SKU_CAP_HW_RF_KILL_ENABLE                (1 << 1)
-
-/* *regulatory* channel data format in eeprom, one for each channel.
- * There are separate entries for HT40 (40 MHz) vs. normal (20 MHz) channels. */
-struct il_eeprom_channel {
-       u8 flags;               /* EEPROM_CHANNEL_* flags copied from EEPROM */
-       s8 max_power_avg;       /* max power (dBm) on this chnl, limit 31 */
-} __packed;
-
-/* 3945 Specific */
-#define EEPROM_3945_EEPROM_VERSION     (0x2f)
-
-/* 4965 has two radio transmitters (and 3 radio receivers) */
-#define EEPROM_TX_POWER_TX_CHAINS      (2)
-
-/* 4965 has room for up to 8 sets of txpower calibration data */
-#define EEPROM_TX_POWER_BANDS          (8)
-
-/* 4965 factory calibration measures txpower gain settings for
- * each of 3 target output levels */
-#define EEPROM_TX_POWER_MEASUREMENTS   (3)
-
-/* 4965 Specific */
-/* 4965 driver does not work with txpower calibration version < 5 */
-#define EEPROM_4965_TX_POWER_VERSION    (5)
-#define EEPROM_4965_EEPROM_VERSION     (0x2f)
-#define EEPROM_4965_CALIB_VERSION_OFFSET       (2*0xB6)        /* 2 bytes */
-#define EEPROM_4965_CALIB_TXPOWER_OFFSET       (2*0xE8)        /* 48  bytes */
-#define EEPROM_4965_BOARD_REVISION             (2*0x4F)        /* 2 bytes */
-#define EEPROM_4965_BOARD_PBA                  (2*0x56+1)      /* 9 bytes */
-
-/* 2.4 GHz */
-extern const u8 il_eeprom_band_1[14];
-
-/*
- * factory calibration data for one txpower level, on one channel,
- * measured on one of the 2 tx chains (radio transmitter and associated
- * antenna).  EEPROM contains:
- *
- * 1)  Temperature (degrees Celsius) of device when measurement was made.
- *
- * 2)  Gain table idx used to achieve the target measurement power.
- *     This refers to the "well-known" gain tables (see 4965.h).
- *
- * 3)  Actual measured output power, in half-dBm ("34" = 17 dBm).
- *
- * 4)  RF power amplifier detector level measurement (not used).
- */
-struct il_eeprom_calib_measure {
-       u8 temperature;         /* Device temperature (Celsius) */
-       u8 gain_idx;            /* Index into gain table */
-       u8 actual_pow;          /* Measured RF output power, half-dBm */
-       s8 pa_det;              /* Power amp detector level (not used) */
-} __packed;
-
-/*
- * measurement set for one channel.  EEPROM contains:
- *
- * 1)  Channel number measured
- *
- * 2)  Measurements for each of 3 power levels for each of 2 radio transmitters
- *     (a.k.a. "tx chains") (6 measurements altogether)
- */
-struct il_eeprom_calib_ch_info {
-       u8 ch_num;
-       struct il_eeprom_calib_measure
-           measurements[EEPROM_TX_POWER_TX_CHAINS]
-           [EEPROM_TX_POWER_MEASUREMENTS];
-} __packed;
-
-/*
- * txpower subband info.
- *
- * For each frequency subband, EEPROM contains the following:
- *
- * 1)  First and last channels within range of the subband.  "0" values
- *     indicate that this sample set is not being used.
- *
- * 2)  Sample measurement sets for 2 channels close to the range endpoints.
- */
-struct il_eeprom_calib_subband_info {
-       u8 ch_from;             /* channel number of lowest channel in subband */
-       u8 ch_to;               /* channel number of highest channel in subband */
-       struct il_eeprom_calib_ch_info ch1;
-       struct il_eeprom_calib_ch_info ch2;
-} __packed;
-
-/*
- * txpower calibration info.  EEPROM contains:
- *
- * 1)  Factory-measured saturation power levels (maximum levels at which
- *     tx power amplifier can output a signal without too much distortion).
- *     There is one level for 2.4 GHz band and one for 5 GHz band.  These
- *     values apply to all channels within each of the bands.
- *
- * 2)  Factory-measured power supply voltage level.  This is assumed to be
- *     constant (i.e. same value applies to all channels/bands) while the
- *     factory measurements are being made.
- *
- * 3)  Up to 8 sets of factory-measured txpower calibration values.
- *     These are for different frequency ranges, since txpower gain
- *     characteristics of the analog radio circuitry vary with frequency.
- *
- *     Not all sets need to be filled with data;
- *     struct il_eeprom_calib_subband_info contains range of channels
- *     (0 if unused) for each set of data.
- */
-struct il_eeprom_calib_info {
-       u8 saturation_power24;  /* half-dBm (e.g. "34" = 17 dBm) */
-       u8 saturation_power52;  /* half-dBm */
-       __le16 voltage;         /* signed */
-       struct il_eeprom_calib_subband_info band_info[EEPROM_TX_POWER_BANDS];
-} __packed;
-
-/* General */
-#define EEPROM_DEVICE_ID                    (2*0x08)   /* 2 bytes */
-#define EEPROM_MAC_ADDRESS                  (2*0x15)   /* 6  bytes */
-#define EEPROM_BOARD_REVISION               (2*0x35)   /* 2  bytes */
-#define EEPROM_BOARD_PBA_NUMBER             (2*0x3B+1) /* 9  bytes */
-#define EEPROM_VERSION                      (2*0x44)   /* 2  bytes */
-#define EEPROM_SKU_CAP                      (2*0x45)   /* 2  bytes */
-#define EEPROM_OEM_MODE                     (2*0x46)   /* 2  bytes */
-#define EEPROM_WOWLAN_MODE                  (2*0x47)   /* 2  bytes */
-#define EEPROM_RADIO_CONFIG                 (2*0x48)   /* 2  bytes */
-#define EEPROM_NUM_MAC_ADDRESS              (2*0x4C)   /* 2  bytes */
-
-/* The following masks are to be applied on EEPROM_RADIO_CONFIG */
-#define EEPROM_RF_CFG_TYPE_MSK(x)   (x & 0x3)  /* bits 0-1   */
-#define EEPROM_RF_CFG_STEP_MSK(x)   ((x >> 2)  & 0x3)  /* bits 2-3   */
-#define EEPROM_RF_CFG_DASH_MSK(x)   ((x >> 4)  & 0x3)  /* bits 4-5   */
-#define EEPROM_RF_CFG_PNUM_MSK(x)   ((x >> 6)  & 0x3)  /* bits 6-7   */
-#define EEPROM_RF_CFG_TX_ANT_MSK(x) ((x >> 8)  & 0xF)  /* bits 8-11  */
-#define EEPROM_RF_CFG_RX_ANT_MSK(x) ((x >> 12) & 0xF)  /* bits 12-15 */
-
-#define EEPROM_3945_RF_CFG_TYPE_MAX  0x0
-#define EEPROM_4965_RF_CFG_TYPE_MAX  0x1
-
-/*
- * Per-channel regulatory data.
- *
- * Each channel that *might* be supported by iwl has a fixed location
- * in EEPROM containing EEPROM_CHANNEL_* usage flags (LSB) and max regulatory
- * txpower (MSB).
- *
- * Entries immediately below are for 20 MHz channel width.  HT40 (40 MHz)
- * channels (only for 4965, not supported by 3945) appear later in the EEPROM.
- *
- * 2.4 GHz channels 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
- */
-#define EEPROM_REGULATORY_SKU_ID            (2*0x60)   /* 4  bytes */
-#define EEPROM_REGULATORY_BAND_1            (2*0x62)   /* 2  bytes */
-#define EEPROM_REGULATORY_BAND_1_CHANNELS   (2*0x63)   /* 28 bytes */
-
-/*
- * 4.9 GHz channels 183, 184, 185, 187, 188, 189, 192, 196,
- * 5.0 GHz channels 7, 8, 11, 12, 16
- * (4915-5080MHz) (none of these is ever supported)
- */
-#define EEPROM_REGULATORY_BAND_2            (2*0x71)   /* 2  bytes */
-#define EEPROM_REGULATORY_BAND_2_CHANNELS   (2*0x72)   /* 26 bytes */
-
-/*
- * 5.2 GHz channels 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
- * (5170-5320MHz)
- */
-#define EEPROM_REGULATORY_BAND_3            (2*0x7F)   /* 2  bytes */
-#define EEPROM_REGULATORY_BAND_3_CHANNELS   (2*0x80)   /* 24 bytes */
-
-/*
- * 5.5 GHz channels 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
- * (5500-5700MHz)
- */
-#define EEPROM_REGULATORY_BAND_4            (2*0x8C)   /* 2  bytes */
-#define EEPROM_REGULATORY_BAND_4_CHANNELS   (2*0x8D)   /* 22 bytes */
-
-/*
- * 5.7 GHz channels 145, 149, 153, 157, 161, 165
- * (5725-5825MHz)
- */
-#define EEPROM_REGULATORY_BAND_5            (2*0x98)   /* 2  bytes */
-#define EEPROM_REGULATORY_BAND_5_CHANNELS   (2*0x99)   /* 12 bytes */
-
-/*
- * 2.4 GHz HT40 channels 1 (5), 2 (6), 3 (7), 4 (8), 5 (9), 6 (10), 7 (11)
- *
- * The channel listed is the center of the lower 20 MHz half of the channel.
- * The overall center frequency is actually 2 channels (10 MHz) above that,
- * and the upper half of each HT40 channel is centered 4 channels (20 MHz) away
- * from the lower half; e.g. the upper half of HT40 channel 1 is channel 5,
- * and the overall HT40 channel width centers on channel 3.
- *
- * NOTE:  The RXON command uses 20 MHz channel numbers to specify the
- *        control channel to which to tune.  RXON also specifies whether the
- *        control channel is the upper or lower half of a HT40 channel.
- *
- * NOTE:  4965 does not support HT40 channels on 2.4 GHz.
- */
-#define EEPROM_4965_REGULATORY_BAND_24_HT40_CHANNELS (2*0xA0)  /* 14 bytes */
-
-/*
- * 5.2 GHz HT40 channels 36 (40), 44 (48), 52 (56), 60 (64),
- * 100 (104), 108 (112), 116 (120), 124 (128), 132 (136), 149 (153), 157 (161)
- */
-#define EEPROM_4965_REGULATORY_BAND_52_HT40_CHANNELS (2*0xA8)  /* 22 bytes */
-
-#define EEPROM_REGULATORY_BAND_NO_HT40                 (0)
-
-int il_eeprom_init(struct il_priv *il);
-void il_eeprom_free(struct il_priv *il);
-const u8 *il_eeprom_query_addr(const struct il_priv *il, size_t offset);
-u16 il_eeprom_query16(const struct il_priv *il, size_t offset);
-int il_init_channel_map(struct il_priv *il);
-void il_free_channel_map(struct il_priv *il);
-const struct il_channel_info *il_get_channel_info(const struct il_priv *il,
-                                                 enum ieee80211_band band,
-                                                 u16 channel);
-
-#define IL_NUM_SCAN_RATES         (2)
-
-struct il4965_channel_tgd_info {
-       u8 type;
-       s8 max_power;
-};
-
-struct il4965_channel_tgh_info {
-       s64 last_radar_time;
-};
-
-#define IL4965_MAX_RATE (33)
-
-struct il3945_clip_group {
-       /* maximum power level to prevent clipping for each rate, derived by
-        *   us from this band's saturation power in EEPROM */
-       const s8 clip_powers[IL_MAX_RATES];
-};
-
-/* current Tx power values to use, one for each rate for each channel.
- * requested power is limited by:
- * -- regulatory EEPROM limits for this channel
- * -- hardware capabilities (clip-powers)
- * -- spectrum management
- * -- user preference (e.g. iwconfig)
- * when requested power is set, base power idx must also be set. */
-struct il3945_channel_power_info {
-       struct il3945_tx_power tpc;     /* actual radio and DSP gain settings */
-       s8 power_table_idx;     /* actual (compenst'd) idx into gain table */
-       s8 base_power_idx;      /* gain idx for power at factory temp. */
-       s8 requested_power;     /* power (dBm) requested for this chnl/rate */
-};
-
-/* current scan Tx power values to use, one for each scan rate for each
- * channel. */
-struct il3945_scan_power_info {
-       struct il3945_tx_power tpc;     /* actual radio and DSP gain settings */
-       s8 power_table_idx;     /* actual (compenst'd) idx into gain table */
-       s8 requested_power;     /* scan pwr (dBm) requested for chnl/rate */
-};
-
-/*
- * One for each channel, holds all channel setup data
- * Some of the fields (e.g. eeprom and flags/max_power_avg) are redundant
- *     with one another!
- */
-struct il_channel_info {
-       struct il4965_channel_tgd_info tgd;
-       struct il4965_channel_tgh_info tgh;
-       struct il_eeprom_channel eeprom;        /* EEPROM regulatory limit */
-       struct il_eeprom_channel ht40_eeprom;   /* EEPROM regulatory limit for
-                                                * HT40 channel */
-
-       u8 channel;             /* channel number */
-       u8 flags;               /* flags copied from EEPROM */
-       s8 max_power_avg;       /* (dBm) regul. eeprom, normal Tx, any rate */
-       s8 curr_txpow;          /* (dBm) regulatory/spectrum/user (not h/w) limit */
-       s8 min_power;           /* always 0 */
-       s8 scan_power;          /* (dBm) regul. eeprom, direct scans, any rate */
-
-       u8 group_idx;           /* 0-4, maps channel to group1/2/3/4/5 */
-       u8 band_idx;            /* 0-4, maps channel to band1/2/3/4/5 */
-       enum ieee80211_band band;
-
-       /* HT40 channel info */
-       s8 ht40_max_power_avg;  /* (dBm) regul. eeprom, normal Tx, any rate */
-       u8 ht40_flags;          /* flags copied from EEPROM */
-       u8 ht40_extension_channel;      /* HT_IE_EXT_CHANNEL_* */
-
-       /* Radio/DSP gain settings for each "normal" data Tx rate.
-        * These include, in addition to RF and DSP gain, a few fields for
-        *   remembering/modifying gain settings (idxes). */
-       struct il3945_channel_power_info power_info[IL4965_MAX_RATE];
-
-       /* Radio/DSP gain settings for each scan rate, for directed scans. */
-       struct il3945_scan_power_info scan_pwr_info[IL_NUM_SCAN_RATES];
-};
-
-#define IL_TX_FIFO_BK          0       /* shared */
-#define IL_TX_FIFO_BE          1
-#define IL_TX_FIFO_VI          2       /* shared */
-#define IL_TX_FIFO_VO          3
-#define IL_TX_FIFO_UNUSED      -1
-
-/* Minimum number of queues. MAX_NUM is defined in hw specific files.
- * Set the minimum to accommodate the 4 standard TX queues, 1 command
- * queue, 2 (unused) HCCA queues, and 4 HT queues (one for each AC) */
-#define IL_MIN_NUM_QUEUES      10
-
-#define IL_DEFAULT_CMD_QUEUE_NUM       4
-
-#define IEEE80211_DATA_LEN              2304
-#define IEEE80211_4ADDR_LEN             30
-#define IEEE80211_HLEN                  (IEEE80211_4ADDR_LEN)
-#define IEEE80211_FRAME_LEN             (IEEE80211_DATA_LEN + IEEE80211_HLEN)
-
-struct il_frame {
-       union {
-               struct ieee80211_hdr frame;
-               struct il_tx_beacon_cmd beacon;
-               u8 raw[IEEE80211_FRAME_LEN];
-               u8 cmd[360];
-       } u;
-       struct list_head list;
-};
-
-enum {
-       CMD_SYNC = 0,
-       CMD_SIZE_NORMAL = 0,
-       CMD_NO_SKB = 0,
-       CMD_SIZE_HUGE = (1 << 0),
-       CMD_ASYNC = (1 << 1),
-       CMD_WANT_SKB = (1 << 2),
-       CMD_MAPPED = (1 << 3),
-};
-
-#define DEF_CMD_PAYLOAD_SIZE 320
-
-/**
- * struct il_device_cmd
- *
- * For allocation of the command and tx queues, this establishes the overall
- * size of the largest command we send to uCode, except for a scan command
- * (which is relatively huge; space is allocated separately).
- */
-struct il_device_cmd {
-       struct il_cmd_header hdr;       /* uCode API */
-       union {
-               u32 flags;
-               u8 val8;
-               u16 val16;
-               u32 val32;
-               struct il_tx_cmd tx;
-               u8 payload[DEF_CMD_PAYLOAD_SIZE];
-       } __packed cmd;
-} __packed;
-
-#define TFD_MAX_PAYLOAD_SIZE (sizeof(struct il_device_cmd))
-
-struct il_host_cmd {
-       const void *data;
-       unsigned long reply_page;
-       void (*callback) (struct il_priv *il, struct il_device_cmd *cmd,
-                         struct il_rx_pkt *pkt);
-       u32 flags;
-       u16 len;
-       u8 id;
-};
-
-#define SUP_RATE_11A_MAX_NUM_CHANNELS  8
-#define SUP_RATE_11B_MAX_NUM_CHANNELS  4
-#define SUP_RATE_11G_MAX_NUM_CHANNELS  12
-
-/**
- * struct il_rx_queue - Rx queue
- * @bd: driver's pointer to buffer of receive buffer descriptors (rbd)
- * @bd_dma: bus address of buffer of receive buffer descriptors (rbd)
- * @read: Shared idx to newest available Rx buffer
- * @write: Shared idx to oldest written Rx packet
- * @free_count: Number of pre-allocated buffers in rx_free
- * @rx_free: list of free SKBs for use
- * @rx_used: List of Rx buffers with no SKB
- * @need_update: flag to indicate we need to update read/write idx
- * @rb_stts: driver's pointer to receive buffer status
- * @rb_stts_dma: bus address of receive buffer status
- *
- * NOTE:  rx_free and rx_used are used as a FIFO for il_rx_bufs
- */
-struct il_rx_queue {
-       __le32 *bd;
-       dma_addr_t bd_dma;
-       struct il_rx_buf pool[RX_QUEUE_SIZE + RX_FREE_BUFFERS];
-       struct il_rx_buf *queue[RX_QUEUE_SIZE];
-       u32 read;
-       u32 write;
-       u32 free_count;
-       u32 write_actual;
-       struct list_head rx_free;
-       struct list_head rx_used;
-       int need_update;
-       struct il_rb_status *rb_stts;
-       dma_addr_t rb_stts_dma;
-       spinlock_t lock;
-};
-
-#define IL_SUPPORTED_RATES_IE_LEN         8
-
-#define MAX_TID_COUNT        9
-
-#define IL_INVALID_RATE     0xFF
-#define IL_INVALID_VALUE    -1
-
-/**
- * struct il_ht_agg -- aggregation status while waiting for block-ack
- * @txq_id: Tx queue used for Tx attempt
- * @frame_count: # frames attempted by Tx command
- * @wait_for_ba: Expect block-ack before next Tx reply
- * @start_idx: Index of 1st Transmit Frame Descriptor (TFD) in Tx win
- * @bitmap0: Low order bitmap, one bit for each frame pending ACK in Tx win
- * @bitmap1: High order, one bit for each frame pending ACK in Tx win
- * @rate_n_flags: Rate at which Tx was attempted
- *
- * If C_TX indicates that aggregation was attempted, driver must wait
- * for block ack (N_COMPRESSED_BA).  This struct stores tx reply info
- * until block ack arrives.
- */
-struct il_ht_agg {
-       u16 txq_id;
-       u16 frame_count;
-       u16 wait_for_ba;
-       u16 start_idx;
-       u64 bitmap;
-       u32 rate_n_flags;
-#define IL_AGG_OFF 0
-#define IL_AGG_ON 1
-#define IL_EMPTYING_HW_QUEUE_ADDBA 2
-#define IL_EMPTYING_HW_QUEUE_DELBA 3
-       u8 state;
-};
-
-struct il_tid_data {
-       u16 seq_number;         /* 4965 only */
-       u16 tfds_in_queue;
-       struct il_ht_agg agg;
-};
-
-struct il_hw_key {
-       u32 cipher;
-       int keylen;
-       u8 keyidx;
-       u8 key[32];
-};
-
-union il_ht_rate_supp {
-       u16 rates;
-       struct {
-               u8 siso_rate;
-               u8 mimo_rate;
-       };
-};
-
-#define CFG_HT_RX_AMPDU_FACTOR_8K   (0x0)
-#define CFG_HT_RX_AMPDU_FACTOR_16K  (0x1)
-#define CFG_HT_RX_AMPDU_FACTOR_32K  (0x2)
-#define CFG_HT_RX_AMPDU_FACTOR_64K  (0x3)
-#define CFG_HT_RX_AMPDU_FACTOR_DEF  CFG_HT_RX_AMPDU_FACTOR_64K
-#define CFG_HT_RX_AMPDU_FACTOR_MAX  CFG_HT_RX_AMPDU_FACTOR_64K
-#define CFG_HT_RX_AMPDU_FACTOR_MIN  CFG_HT_RX_AMPDU_FACTOR_8K
-
-/*
- * Maximal MPDU density for TX aggregation
- * 4 - 2us density
- * 5 - 4us density
- * 6 - 8us density
- * 7 - 16us density
- */
-#define CFG_HT_MPDU_DENSITY_2USEC   (0x4)
-#define CFG_HT_MPDU_DENSITY_4USEC   (0x5)
-#define CFG_HT_MPDU_DENSITY_8USEC   (0x6)
-#define CFG_HT_MPDU_DENSITY_16USEC  (0x7)
-#define CFG_HT_MPDU_DENSITY_DEF CFG_HT_MPDU_DENSITY_4USEC
-#define CFG_HT_MPDU_DENSITY_MAX CFG_HT_MPDU_DENSITY_16USEC
-#define CFG_HT_MPDU_DENSITY_MIN     (0x1)
-
-struct il_ht_config {
-       bool single_chain_sufficient;
-       enum ieee80211_smps_mode smps;  /* current smps mode */
-};
-
-/* QoS structures */
-struct il_qos_info {
-       int qos_active;
-       struct il_qosparam_cmd def_qos_parm;
-};
-
-/*
- * Structure should be accessed with sta_lock held. When station addition
- * is in progress (IL_STA_UCODE_INPROGRESS) it is possible to access only
- * the commands (il_addsta_cmd and il_link_quality_cmd) without
- * sta_lock held.
- */
-struct il_station_entry {
-       struct il_addsta_cmd sta;
-       struct il_tid_data tid[MAX_TID_COUNT];
-       u8 used;
-       struct il_hw_key keyinfo;
-       struct il_link_quality_cmd *lq;
-};
-
-struct il_station_priv_common {
-       u8 sta_id;
-};
-
-/**
- * struct il_vif_priv - driver's ilate per-interface information
- *
- * When mac80211 allocates a virtual interface, it can allocate
- * space for us to put data into.
- */
-struct il_vif_priv {
-       u8 ibss_bssid_sta_id;
-};
-
-/* one for each uCode image (inst/data, boot/init/runtime) */
-struct fw_desc {
-       void *v_addr;           /* access by driver */
-       dma_addr_t p_addr;      /* access by card's busmaster DMA */
-       u32 len;                /* bytes */
-};
-
-/* uCode file layout */
-struct il_ucode_header {
-       __le32 ver;             /* major/minor/API/serial */
-       struct {
-               __le32 inst_size;       /* bytes of runtime code */
-               __le32 data_size;       /* bytes of runtime data */
-               __le32 init_size;       /* bytes of init code */
-               __le32 init_data_size;  /* bytes of init data */
-               __le32 boot_size;       /* bytes of bootstrap code */
-               u8 data[0];     /* in same order as sizes */
-       } v1;
-};
-
-struct il4965_ibss_seq {
-       u8 mac[ETH_ALEN];
-       u16 seq_num;
-       u16 frag_num;
-       unsigned long packet_time;
-       struct list_head list;
-};
-
-struct il_sensitivity_ranges {
-       u16 min_nrg_cck;
-       u16 max_nrg_cck;
-
-       u16 nrg_th_cck;
-       u16 nrg_th_ofdm;
-
-       u16 auto_corr_min_ofdm;
-       u16 auto_corr_min_ofdm_mrc;
-       u16 auto_corr_min_ofdm_x1;
-       u16 auto_corr_min_ofdm_mrc_x1;
-
-       u16 auto_corr_max_ofdm;
-       u16 auto_corr_max_ofdm_mrc;
-       u16 auto_corr_max_ofdm_x1;
-       u16 auto_corr_max_ofdm_mrc_x1;
-
-       u16 auto_corr_max_cck;
-       u16 auto_corr_max_cck_mrc;
-       u16 auto_corr_min_cck;
-       u16 auto_corr_min_cck_mrc;
-
-       u16 barker_corr_th_min;
-       u16 barker_corr_th_min_mrc;
-       u16 nrg_th_cca;
-};
-
-#define KELVIN_TO_CELSIUS(x) ((x)-273)
-#define CELSIUS_TO_KELVIN(x) ((x)+273)
-
-/**
- * struct il_hw_params
- * @bcast_id: f/w broadcast station ID
- * @max_txq_num: Max # Tx queues supported
- * @dma_chnl_num: Number of Tx DMA/FIFO channels
- * @scd_bc_tbls_size: size of scheduler byte count tables
- * @tfd_size: TFD size
- * @tx/rx_chains_num: Number of TX/RX chains
- * @valid_tx/rx_ant: usable antennas
- * @max_rxq_size: Max # Rx frames in Rx queue (must be power-of-2)
- * @max_rxq_log: Log-base-2 of max_rxq_size
- * @rx_page_order: Rx buffer page order
- * @rx_wrt_ptr_reg: FH{39}_RSCSR_CHNL0_WPTR
- * @max_stations:
- * @ht40_channel: is 40MHz width possible in band 2.4
- * BIT(IEEE80211_BAND_5GHZ) BIT(IEEE80211_BAND_5GHZ)
- * @sw_crypto: 0 for hw, 1 for sw
- * @max_xxx_size: for ucode uses
- * @ct_kill_threshold: temperature threshold
- * @beacon_time_tsf_bits: number of valid tsf bits for beacon time
- * @struct il_sensitivity_ranges: range of sensitivity values
- */
-struct il_hw_params {
-       u8 bcast_id;
-       u8 max_txq_num;
-       u8 dma_chnl_num;
-       u16 scd_bc_tbls_size;
-       u32 tfd_size;
-       u8 tx_chains_num;
-       u8 rx_chains_num;
-       u8 valid_tx_ant;
-       u8 valid_rx_ant;
-       u16 max_rxq_size;
-       u16 max_rxq_log;
-       u32 rx_page_order;
-       u32 rx_wrt_ptr_reg;
-       u8 max_stations;
-       u8 ht40_channel;
-       u8 max_beacon_itrvl;    /* in 1024 ms */
-       u32 max_inst_size;
-       u32 max_data_size;
-       u32 max_bsm_size;
-       u32 ct_kill_threshold;  /* value in hw-dependent units */
-       u16 beacon_time_tsf_bits;
-       const struct il_sensitivity_ranges *sens;
-};
-
-/******************************************************************************
- *
- * Functions implemented in core module which are forward declared here
- * for use by iwl-[4-5].c
- *
- * NOTE:  The implementation of these functions are not hardware specific
- * which is why they are in the core module files.
- *
- * Naming convention --
- * il_         <-- Is part of iwlwifi
- * iwlXXXX_     <-- Hardware specific (implemented in iwl-XXXX.c for XXXX)
- * il4965_bg_      <-- Called from work queue context
- * il4965_mac_     <-- mac80211 callback
- *
- ****************************************************************************/
-void il4965_update_chain_flags(struct il_priv *il);
-extern const u8 il_bcast_addr[ETH_ALEN];
-int il_queue_space(const struct il_queue *q);
-static inline int
-il_queue_used(const struct il_queue *q, int i)
-{
-       return q->write_ptr >= q->read_ptr ? (i >= q->read_ptr &&
-                                             i < q->write_ptr) : !(i <
-                                                                   q->read_ptr
-                                                                   && i >=
-                                                                   q->
-                                                                   write_ptr);
-}
-
-static inline u8
-il_get_cmd_idx(struct il_queue *q, u32 idx, int is_huge)
-{
-       /*
-        * This is for init calibration result and scan command which
-        * required buffer > TFD_MAX_PAYLOAD_SIZE,
-        * the big buffer at end of command array
-        */
-       if (is_huge)
-               return q->n_win;        /* must be power of 2 */
-
-       /* Otherwise, use normal size buffers */
-       return idx & (q->n_win - 1);
-}
-
-struct il_dma_ptr {
-       dma_addr_t dma;
-       void *addr;
-       size_t size;
-};
-
-#define IL_OPERATION_MODE_AUTO     0
-#define IL_OPERATION_MODE_HT_ONLY  1
-#define IL_OPERATION_MODE_MIXED    2
-#define IL_OPERATION_MODE_20MHZ    3
-
-#define IL_TX_CRC_SIZE 4
-#define IL_TX_DELIMITER_SIZE 4
-
-#define TX_POWER_IL_ILLEGAL_VOLTAGE -10000
-
-/* Sensitivity and chain noise calibration */
-#define INITIALIZATION_VALUE           0xFFFF
-#define IL4965_CAL_NUM_BEACONS         20
-#define IL_CAL_NUM_BEACONS             16
-#define MAXIMUM_ALLOWED_PATHLOSS       15
-
-#define CHAIN_NOISE_MAX_DELTA_GAIN_CODE 3
-
-#define MAX_FA_OFDM  50
-#define MIN_FA_OFDM  5
-#define MAX_FA_CCK   50
-#define MIN_FA_CCK   5
-
-#define AUTO_CORR_STEP_OFDM       1
-
-#define AUTO_CORR_STEP_CCK     3
-#define AUTO_CORR_MAX_TH_CCK   160
-
-#define NRG_DIFF               2
-#define NRG_STEP_CCK           2
-#define NRG_MARGIN             8
-#define MAX_NUMBER_CCK_NO_FA 100
-
-#define AUTO_CORR_CCK_MIN_VAL_DEF    (125)
-
-#define CHAIN_A             0
-#define CHAIN_B             1
-#define CHAIN_C             2
-#define CHAIN_NOISE_DELTA_GAIN_INIT_VAL 4
-#define ALL_BAND_FILTER                        0xFF00
-#define IN_BAND_FILTER                 0xFF
-#define MIN_AVERAGE_NOISE_MAX_VALUE    0xFFFFFFFF
-
-#define NRG_NUM_PREV_STAT_L     20
-#define NUM_RX_CHAINS           3
-
-enum il4965_false_alarm_state {
-       IL_FA_TOO_MANY = 0,
-       IL_FA_TOO_FEW = 1,
-       IL_FA_GOOD_RANGE = 2,
-};
-
-enum il4965_chain_noise_state {
-       IL_CHAIN_NOISE_ALIVE = 0,       /* must be 0 */
-       IL_CHAIN_NOISE_ACCUMULATE,
-       IL_CHAIN_NOISE_CALIBRATED,
-       IL_CHAIN_NOISE_DONE,
-};
-
-enum ucode_type {
-       UCODE_NONE = 0,
-       UCODE_INIT,
-       UCODE_RT
-};
-
-/* Sensitivity calib data */
-struct il_sensitivity_data {
-       u32 auto_corr_ofdm;
-       u32 auto_corr_ofdm_mrc;
-       u32 auto_corr_ofdm_x1;
-       u32 auto_corr_ofdm_mrc_x1;
-       u32 auto_corr_cck;
-       u32 auto_corr_cck_mrc;
-
-       u32 last_bad_plcp_cnt_ofdm;
-       u32 last_fa_cnt_ofdm;
-       u32 last_bad_plcp_cnt_cck;
-       u32 last_fa_cnt_cck;
-
-       u32 nrg_curr_state;
-       u32 nrg_prev_state;
-       u32 nrg_value[10];
-       u8 nrg_silence_rssi[NRG_NUM_PREV_STAT_L];
-       u32 nrg_silence_ref;
-       u32 nrg_energy_idx;
-       u32 nrg_silence_idx;
-       u32 nrg_th_cck;
-       s32 nrg_auto_corr_silence_diff;
-       u32 num_in_cck_no_fa;
-       u32 nrg_th_ofdm;
-
-       u16 barker_corr_th_min;
-       u16 barker_corr_th_min_mrc;
-       u16 nrg_th_cca;
-};
-
-/* Chain noise (differential Rx gain) calib data */
-struct il_chain_noise_data {
-       u32 active_chains;
-       u32 chain_noise_a;
-       u32 chain_noise_b;
-       u32 chain_noise_c;
-       u32 chain_signal_a;
-       u32 chain_signal_b;
-       u32 chain_signal_c;
-       u16 beacon_count;
-       u8 disconn_array[NUM_RX_CHAINS];
-       u8 delta_gain_code[NUM_RX_CHAINS];
-       u8 radio_write;
-       u8 state;
-};
-
-#define        EEPROM_SEM_TIMEOUT 10   /* milliseconds */
-#define EEPROM_SEM_RETRY_LIMIT 1000    /* number of attempts (not time) */
-
-#define IL_TRAFFIC_ENTRIES     (256)
-#define IL_TRAFFIC_ENTRY_SIZE  (64)
-
-enum {
-       MEASUREMENT_READY = (1 << 0),
-       MEASUREMENT_ACTIVE = (1 << 1),
-};
-
-/* interrupt stats */
-struct isr_stats {
-       u32 hw;
-       u32 sw;
-       u32 err_code;
-       u32 sch;
-       u32 alive;
-       u32 rfkill;
-       u32 ctkill;
-       u32 wakeup;
-       u32 rx;
-       u32 handlers[IL_CN_MAX];
-       u32 tx;
-       u32 unhandled;
-};
-
-/* management stats */
-enum il_mgmt_stats {
-       MANAGEMENT_ASSOC_REQ = 0,
-       MANAGEMENT_ASSOC_RESP,
-       MANAGEMENT_REASSOC_REQ,
-       MANAGEMENT_REASSOC_RESP,
-       MANAGEMENT_PROBE_REQ,
-       MANAGEMENT_PROBE_RESP,
-       MANAGEMENT_BEACON,
-       MANAGEMENT_ATIM,
-       MANAGEMENT_DISASSOC,
-       MANAGEMENT_AUTH,
-       MANAGEMENT_DEAUTH,
-       MANAGEMENT_ACTION,
-       MANAGEMENT_MAX,
-};
-/* control stats */
-enum il_ctrl_stats {
-       CONTROL_BACK_REQ = 0,
-       CONTROL_BACK,
-       CONTROL_PSPOLL,
-       CONTROL_RTS,
-       CONTROL_CTS,
-       CONTROL_ACK,
-       CONTROL_CFEND,
-       CONTROL_CFENDACK,
-       CONTROL_MAX,
-};
-
-struct traffic_stats {
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       u32 mgmt[MANAGEMENT_MAX];
-       u32 ctrl[CONTROL_MAX];
-       u32 data_cnt;
-       u64 data_bytes;
-#endif
-};
-
-/*
- * host interrupt timeout value
- * used with setting interrupt coalescing timer
- * the CSR_INT_COALESCING is an 8 bit register in 32-usec unit
- *
- * default interrupt coalescing timer is 64 x 32 = 2048 usecs
- * default interrupt coalescing calibration timer is 16 x 32 = 512 usecs
- */
-#define IL_HOST_INT_TIMEOUT_MAX        (0xFF)
-#define IL_HOST_INT_TIMEOUT_DEF        (0x40)
-#define IL_HOST_INT_TIMEOUT_MIN        (0x0)
-#define IL_HOST_INT_CALIB_TIMEOUT_MAX  (0xFF)
-#define IL_HOST_INT_CALIB_TIMEOUT_DEF  (0x10)
-#define IL_HOST_INT_CALIB_TIMEOUT_MIN  (0x0)
-
-#define IL_DELAY_NEXT_FORCE_FW_RELOAD (HZ*5)
-
-/* TX queue watchdog timeouts in mSecs */
-#define IL_DEF_WD_TIMEOUT      (2000)
-#define IL_LONG_WD_TIMEOUT     (10000)
-#define IL_MAX_WD_TIMEOUT      (120000)
-
-struct il_force_reset {
-       int reset_request_count;
-       int reset_success_count;
-       int reset_reject_count;
-       unsigned long reset_duration;
-       unsigned long last_force_reset_jiffies;
-};
-
-/* extend beacon time format bit shifting  */
-/*
- * for _3945 devices
- * bits 31:24 - extended
- * bits 23:0  - interval
- */
-#define IL3945_EXT_BEACON_TIME_POS     24
-/*
- * for _4965 devices
- * bits 31:22 - extended
- * bits 21:0  - interval
- */
-#define IL4965_EXT_BEACON_TIME_POS     22
-
-struct il_rxon_context {
-       struct ieee80211_vif *vif;
-};
-
-struct il_power_mgr {
-       struct il_powertable_cmd sleep_cmd;
-       struct il_powertable_cmd sleep_cmd_next;
-       int debug_sleep_level_override;
-       bool pci_pm;
-       bool ps_disabled;
-};
-
-struct il_priv {
-       struct ieee80211_hw *hw;
-       struct ieee80211_channel *ieee_channels;
-       struct ieee80211_rate *ieee_rates;
-
-       struct il_cfg *cfg;
-       const struct il_ops *ops;
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       const struct il_debugfs_ops *debugfs_ops;
-#endif
-
-       /* temporary frame storage list */
-       struct list_head free_frames;
-       int frames_count;
-
-       enum ieee80211_band band;
-       int alloc_rxb_page;
-
-       void (*handlers[IL_CN_MAX]) (struct il_priv *il,
-                                    struct il_rx_buf *rxb);
-
-       struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
-
-       /* spectrum measurement report caching */
-       struct il_spectrum_notification measure_report;
-       u8 measurement_status;
-
-       /* ucode beacon time */
-       u32 ucode_beacon_time;
-       int missed_beacon_threshold;
-
-       /* track IBSS manager (last beacon) status */
-       u32 ibss_manager;
-
-       /* force reset */
-       struct il_force_reset force_reset;
-
-       /* we allocate array of il_channel_info for NIC's valid channels.
-        *    Access via channel # using indirect idx array */
-       struct il_channel_info *channel_info;   /* channel info array */
-       u8 channel_count;       /* # of channels */
-
-       /* thermal calibration */
-       s32 temperature;        /* degrees Kelvin */
-       s32 last_temperature;
-
-       /* Scan related variables */
-       unsigned long scan_start;
-       unsigned long scan_start_tsf;
-       void *scan_cmd;
-       enum ieee80211_band scan_band;
-       struct cfg80211_scan_request *scan_request;
-       struct ieee80211_vif *scan_vif;
-       u8 scan_tx_ant[IEEE80211_NUM_BANDS];
-       u8 mgmt_tx_ant;
-
-       /* spinlock */
-       spinlock_t lock;        /* protect general shared data */
-       spinlock_t hcmd_lock;   /* protect hcmd */
-       spinlock_t reg_lock;    /* protect hw register access */
-       struct mutex mutex;
-
-       /* basic pci-network driver stuff */
-       struct pci_dev *pci_dev;
-
-       /* pci hardware address support */
-       void __iomem *hw_base;
-       u32 hw_rev;
-       u32 hw_wa_rev;
-       u8 rev_id;
-
-       /* command queue number */
-       u8 cmd_queue;
-
-       /* max number of station keys */
-       u8 sta_key_max_num;
-
-       /* EEPROM MAC addresses */
-       struct mac_address addresses[1];
-
-       /* uCode images, save to reload in case of failure */
-       int fw_idx;             /* firmware we're trying to load */
-       u32 ucode_ver;          /* version of ucode, copy of
-                                  il_ucode.ver */
-       struct fw_desc ucode_code;      /* runtime inst */
-       struct fw_desc ucode_data;      /* runtime data original */
-       struct fw_desc ucode_data_backup;       /* runtime data save/restore */
-       struct fw_desc ucode_init;      /* initialization inst */
-       struct fw_desc ucode_init_data; /* initialization data */
-       struct fw_desc ucode_boot;      /* bootstrap inst */
-       enum ucode_type ucode_type;
-       u8 ucode_write_complete;        /* the image write is complete */
-       char firmware_name[25];
-
-       struct ieee80211_vif *vif;
-
-       struct il_qos_info qos_data;
-
-       struct {
-               bool enabled;
-               bool is_40mhz;
-               bool non_gf_sta_present;
-               u8 protection;
-               u8 extension_chan_offset;
-       } ht;
-
-       /*
-        * We declare this const so it can only be
-        * changed via explicit cast within the
-        * routines that actually update the physical
-        * hardware.
-        */
-       const struct il_rxon_cmd active;
-       struct il_rxon_cmd staging;
-
-       struct il_rxon_time_cmd timing;
-
-       __le16 switch_channel;
-
-       /* 1st responses from initialize and runtime uCode images.
-        * _4965's initialize alive response contains some calibration data. */
-       struct il_init_alive_resp card_alive_init;
-       struct il_alive_resp card_alive;
-
-       u16 active_rate;
-
-       u8 start_calib;
-       struct il_sensitivity_data sensitivity_data;
-       struct il_chain_noise_data chain_noise_data;
-       __le16 sensitivity_tbl[HD_TBL_SIZE];
-
-       struct il_ht_config current_ht_config;
-
-       /* Rate scaling data */
-       u8 retry_rate;
-
-       wait_queue_head_t wait_command_queue;
-
-       int activity_timer_active;
-
-       /* Rx and Tx DMA processing queues */
-       struct il_rx_queue rxq;
-       struct il_tx_queue *txq;
-       unsigned long txq_ctx_active_msk;
-       struct il_dma_ptr kw;   /* keep warm address */
-       struct il_dma_ptr scd_bc_tbls;
-
-       u32 scd_base_addr;      /* scheduler sram base address */
-
-       unsigned long status;
-
-       /* counts mgmt, ctl, and data packets */
-       struct traffic_stats tx_stats;
-       struct traffic_stats rx_stats;
-
-       /* counts interrupts */
-       struct isr_stats isr_stats;
-
-       struct il_power_mgr power_data;
-
-       /* context information */
-       u8 bssid[ETH_ALEN];     /* used only on 3945 but filled by core */
-
-       /* station table variables */
-
-       /* Note: if lock and sta_lock are needed, lock must be acquired first */
-       spinlock_t sta_lock;
-       int num_stations;
-       struct il_station_entry stations[IL_STATION_COUNT];
-       unsigned long ucode_key_table;
-
-       /* queue refcounts */
-#define IL_MAX_HW_QUEUES       32
-       unsigned long queue_stopped[BITS_TO_LONGS(IL_MAX_HW_QUEUES)];
-#define IL_STOP_REASON_PASSIVE 0
-       unsigned long stop_reason;
-       /* for each AC */
-       atomic_t queue_stop_count[4];
-
-       /* Indication if ieee80211_ops->open has been called */
-       u8 is_open;
-
-       u8 mac80211_registered;
-
-       /* eeprom -- this is in the card's little endian byte order */
-       u8 *eeprom;
-       struct il_eeprom_calib_info *calib_info;
-
-       enum nl80211_iftype iw_mode;
-
-       /* Last Rx'd beacon timestamp */
-       u64 timestamp;
-
-       union {
-#if defined(CONFIG_IWL3945) || defined(CONFIG_IWL3945_MODULE)
-               struct {
-                       void *shared_virt;
-                       dma_addr_t shared_phys;
-
-                       struct delayed_work thermal_periodic;
-                       struct delayed_work rfkill_poll;
-
-                       struct il3945_notif_stats stats;
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-                       struct il3945_notif_stats accum_stats;
-                       struct il3945_notif_stats delta_stats;
-                       struct il3945_notif_stats max_delta;
-#endif
-
-                       u32 sta_supp_rates;
-                       int last_rx_rssi;       /* From Rx packet stats */
-
-                       /* Rx'd packet timing information */
-                       u32 last_beacon_time;
-                       u64 last_tsf;
-
-                       /*
-                        * each calibration channel group in the
-                        * EEPROM has a derived clip setting for
-                        * each rate.
-                        */
-                       const struct il3945_clip_group clip_groups[5];
-
-               } _3945;
-#endif
-#if defined(CONFIG_IWL4965) || defined(CONFIG_IWL4965_MODULE)
-               struct {
-                       struct il_rx_phy_res last_phy_res;
-                       bool last_phy_res_valid;
-                       u32 ampdu_ref;
-
-                       struct completion firmware_loading_complete;
-
-                       /*
-                        * chain noise reset and gain commands are the
-                        * two extra calibration commands follows the standard
-                        * phy calibration commands
-                        */
-                       u8 phy_calib_chain_noise_reset_cmd;
-                       u8 phy_calib_chain_noise_gain_cmd;
-
-                       u8 key_mapping_keys;
-                       struct il_wep_key wep_keys[WEP_KEYS_MAX];
-
-                       struct il_notif_stats stats;
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-                       struct il_notif_stats accum_stats;
-                       struct il_notif_stats delta_stats;
-                       struct il_notif_stats max_delta;
-#endif
-
-               } _4965;
-#endif
-       };
-
-       struct il_hw_params hw_params;
-
-       u32 inta_mask;
-
-       struct workqueue_struct *workqueue;
-
-       struct work_struct restart;
-       struct work_struct scan_completed;
-       struct work_struct rx_replenish;
-       struct work_struct abort_scan;
-
-       bool beacon_enabled;
-       struct sk_buff *beacon_skb;
-
-       struct work_struct tx_flush;
-
-       struct tasklet_struct irq_tasklet;
-
-       struct delayed_work init_alive_start;
-       struct delayed_work alive_start;
-       struct delayed_work scan_check;
-
-       /* TX Power */
-       s8 tx_power_user_lmt;
-       s8 tx_power_device_lmt;
-       s8 tx_power_next;
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-       /* debugging info */
-       u32 debug_level;        /* per device debugging will override global
-                                  il_debug_level if set */
-#endif                         /* CONFIG_IWLEGACY_DEBUG */
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-       /* debugfs */
-       u16 tx_traffic_idx;
-       u16 rx_traffic_idx;
-       u8 *tx_traffic;
-       u8 *rx_traffic;
-       struct dentry *debugfs_dir;
-       u32 dbgfs_sram_offset, dbgfs_sram_len;
-       bool disable_ht40;
-#endif                         /* CONFIG_IWLEGACY_DEBUGFS */
-
-       struct work_struct txpower_work;
-       bool disable_sens_cal;
-       bool disable_chain_noise_cal;
-       bool disable_tx_power_cal;
-       struct work_struct run_time_calib_work;
-       struct timer_list stats_periodic;
-       struct timer_list watchdog;
-       bool hw_ready;
-
-       struct led_classdev led;
-       unsigned long blink_on, blink_off;
-       bool led_registered;
-};                             /*il_priv */
-
-static inline void
-il_txq_ctx_activate(struct il_priv *il, int txq_id)
-{
-       set_bit(txq_id, &il->txq_ctx_active_msk);
-}
-
-static inline void
-il_txq_ctx_deactivate(struct il_priv *il, int txq_id)
-{
-       clear_bit(txq_id, &il->txq_ctx_active_msk);
-}
-
-static inline int
-il_is_associated(struct il_priv *il)
-{
-       return (il->active.filter_flags & RXON_FILTER_ASSOC_MSK) ? 1 : 0;
-}
-
-static inline int
-il_is_any_associated(struct il_priv *il)
-{
-       return il_is_associated(il);
-}
-
-static inline int
-il_is_channel_valid(const struct il_channel_info *ch_info)
-{
-       if (ch_info == NULL)
-               return 0;
-       return (ch_info->flags & EEPROM_CHANNEL_VALID) ? 1 : 0;
-}
-
-static inline int
-il_is_channel_radar(const struct il_channel_info *ch_info)
-{
-       return (ch_info->flags & EEPROM_CHANNEL_RADAR) ? 1 : 0;
-}
-
-static inline u8
-il_is_channel_a_band(const struct il_channel_info *ch_info)
-{
-       return ch_info->band == IEEE80211_BAND_5GHZ;
-}
-
-static inline int
-il_is_channel_passive(const struct il_channel_info *ch)
-{
-       return (!(ch->flags & EEPROM_CHANNEL_ACTIVE)) ? 1 : 0;
-}
-
-static inline int
-il_is_channel_ibss(const struct il_channel_info *ch)
-{
-       return (ch->flags & EEPROM_CHANNEL_IBSS) ? 1 : 0;
-}
-
-static inline void
-__il_free_pages(struct il_priv *il, struct page *page)
-{
-       __free_pages(page, il->hw_params.rx_page_order);
-       il->alloc_rxb_page--;
-}
-
-static inline void
-il_free_pages(struct il_priv *il, unsigned long page)
-{
-       free_pages(page, il->hw_params.rx_page_order);
-       il->alloc_rxb_page--;
-}
-
-#define IWLWIFI_VERSION "in-tree:"
-#define DRV_COPYRIGHT  "Copyright(c) 2003-2011 Intel Corporation"
-#define DRV_AUTHOR     "<ilw@linux.intel.com>"
-
-#define IL_PCI_DEVICE(dev, subdev, cfg) \
-       .vendor = PCI_VENDOR_ID_INTEL,  .device = (dev), \
-       .subvendor = PCI_ANY_ID, .subdevice = (subdev), \
-       .driver_data = (kernel_ulong_t)&(cfg)
-
-#define TIME_UNIT              1024
-
-#define IL_SKU_G       0x1
-#define IL_SKU_A       0x2
-#define IL_SKU_N       0x8
-
-#define IL_CMD(x) case x: return #x
-
-/* Size of one Rx buffer in host DRAM */
-#define IL_RX_BUF_SIZE_3K (3 * 1000)   /* 3945 only */
-#define IL_RX_BUF_SIZE_4K (4 * 1024)
-#define IL_RX_BUF_SIZE_8K (8 * 1024)
-
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-struct il_debugfs_ops {
-       ssize_t(*rx_stats_read) (struct file *file, char __user *user_buf,
-                                size_t count, loff_t *ppos);
-       ssize_t(*tx_stats_read) (struct file *file, char __user *user_buf,
-                                size_t count, loff_t *ppos);
-       ssize_t(*general_stats_read) (struct file *file,
-                                     char __user *user_buf, size_t count,
-                                     loff_t *ppos);
-};
-#endif
-
-struct il_ops {
-       /* Handling TX */
-       void (*txq_update_byte_cnt_tbl) (struct il_priv *il,
-                                        struct il_tx_queue *txq,
-                                        u16 byte_cnt);
-       int (*txq_attach_buf_to_tfd) (struct il_priv *il,
-                                     struct il_tx_queue *txq, dma_addr_t addr,
-                                     u16 len, u8 reset, u8 pad);
-       void (*txq_free_tfd) (struct il_priv *il, struct il_tx_queue *txq);
-       int (*txq_init) (struct il_priv *il, struct il_tx_queue *txq);
-       /* alive notification after init uCode load */
-       void (*init_alive_start) (struct il_priv *il);
-       /* check validity of rtc data address */
-       int (*is_valid_rtc_data_addr) (u32 addr);
-       /* 1st ucode load */
-       int (*load_ucode) (struct il_priv *il);
-
-       void (*dump_nic_error_log) (struct il_priv *il);
-       int (*dump_fh) (struct il_priv *il, char **buf, bool display);
-       int (*set_channel_switch) (struct il_priv *il,
-                                  struct ieee80211_channel_switch *ch_switch);
-       /* power management */
-       int (*apm_init) (struct il_priv *il);
-
-       /* tx power */
-       int (*send_tx_power) (struct il_priv *il);
-       void (*update_chain_flags) (struct il_priv *il);
-
-       /* eeprom operations */
-       int (*eeprom_acquire_semaphore) (struct il_priv *il);
-       void (*eeprom_release_semaphore) (struct il_priv *il);
-
-       int (*rxon_assoc) (struct il_priv *il);
-       int (*commit_rxon) (struct il_priv *il);
-       void (*set_rxon_chain) (struct il_priv *il);
-
-       u16(*get_hcmd_size) (u8 cmd_id, u16 len);
-       u16(*build_addsta_hcmd) (const struct il_addsta_cmd *cmd, u8 *data);
-
-       int (*request_scan) (struct il_priv *il, struct ieee80211_vif *vif);
-       void (*post_scan) (struct il_priv *il);
-       void (*post_associate) (struct il_priv *il);
-       void (*config_ap) (struct il_priv *il);
-       /* station management */
-       int (*update_bcast_stations) (struct il_priv *il);
-       int (*manage_ibss_station) (struct il_priv *il,
-                                   struct ieee80211_vif *vif, bool add);
-
-       int (*send_led_cmd) (struct il_priv *il, struct il_led_cmd *led_cmd);
-};
-
-struct il_mod_params {
-       int sw_crypto;          /* def: 0 = using hardware encryption */
-       int disable_hw_scan;    /* def: 0 = use h/w scan */
-       int num_of_queues;      /* def: HW dependent */
-       int disable_11n;        /* def: 0 = 11n capabilities enabled */
-       int amsdu_size_8K;      /* def: 0 = disable 8K amsdu size */
-       int antenna;            /* def: 0 = both antennas (use diversity) */
-       int restart_fw;         /* def: 1 = restart firmware */
-};
-
-#define IL_LED_SOLID 11
-#define IL_DEF_LED_INTRVL cpu_to_le32(1000)
-
-#define IL_LED_ACTIVITY       (0<<1)
-#define IL_LED_LINK           (1<<1)
-
-/*
- * LED mode
- *    IL_LED_DEFAULT:  use device default
- *    IL_LED_RF_STATE: turn LED on/off based on RF state
- *                     LED ON  = RF ON
- *                     LED OFF = RF OFF
- *    IL_LED_BLINK:    adjust led blink rate based on blink table
- */
-enum il_led_mode {
-       IL_LED_DEFAULT,
-       IL_LED_RF_STATE,
-       IL_LED_BLINK,
-};
-
-void il_leds_init(struct il_priv *il);
-void il_leds_exit(struct il_priv *il);
-
-/**
- * struct il_cfg
- * @fw_name_pre: Firmware filename prefix. The api version and extension
- *     (.ucode) will be added to filename before loading from disk. The
- *     filename is constructed as fw_name_pre<api>.ucode.
- * @ucode_api_max: Highest version of uCode API supported by driver.
- * @ucode_api_min: Lowest version of uCode API supported by driver.
- * @scan_antennas: available antenna for scan operation
- * @led_mode: 0=blinking, 1=On(RF On)/Off(RF Off)
- *
- * We enable the driver to be backward compatible wrt API version. The
- * driver specifies which APIs it supports (with @ucode_api_max being the
- * highest and @ucode_api_min the lowest). Firmware will only be loaded if
- * it has a supported API version. The firmware's API version will be
- * stored in @il_priv, enabling the driver to make runtime changes based
- * on firmware version used.
- *
- * For example,
- * if (IL_UCODE_API(il->ucode_ver) >= 2) {
- *     Driver interacts with Firmware API version >= 2.
- * } else {
- *     Driver interacts with Firmware API version 1.
- * }
- *
- * The ideal usage of this infrastructure is to treat a new ucode API
- * release as a new hardware revision. That is, through utilizing the
- * il_hcmd_utils_ops etc. we accommodate different command structures
- * and flows between hardware versions as well as their API
- * versions.
- *
- */
-struct il_cfg {
-       /* params specific to an individual device within a device family */
-       const char *name;
-       const char *fw_name_pre;
-       const unsigned int ucode_api_max;
-       const unsigned int ucode_api_min;
-       u8 valid_tx_ant;
-       u8 valid_rx_ant;
-       unsigned int sku;
-       u16 eeprom_ver;
-       u16 eeprom_calib_ver;
-       /* module based parameters which can be set from modprobe cmd */
-       const struct il_mod_params *mod_params;
-       /* params not likely to change within a device family */
-       struct il_base_params *base_params;
-       /* params likely to change within a device family */
-       u8 scan_rx_antennas[IEEE80211_NUM_BANDS];
-       enum il_led_mode led_mode;
-
-       int eeprom_size;
-       int num_of_queues;              /* def: HW dependent */
-       int num_of_ampdu_queues;        /* def: HW dependent */
-       /* for il_apm_init() */
-       u32 pll_cfg_val;
-       bool set_l0s;
-       bool use_bsm;
-
-       u16 led_compensation;
-       int chain_noise_num_beacons;
-       unsigned int wd_timeout;
-       bool temperature_kelvin;
-       const bool ucode_tracing;
-       const bool sensitivity_calib_by_driver;
-       const bool chain_noise_calib_by_driver;
-
-       const u32 regulatory_bands[7];
-};
-
-/***************************
- *   L i b                 *
- ***************************/
-
-int il_mac_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                  u16 queue, const struct ieee80211_tx_queue_params *params);
-int il_mac_tx_last_beacon(struct ieee80211_hw *hw);
-
-void il_set_rxon_hwcrypto(struct il_priv *il, int hw_decrypt);
-int il_check_rxon_cmd(struct il_priv *il);
-int il_full_rxon_required(struct il_priv *il);
-int il_set_rxon_channel(struct il_priv *il, struct ieee80211_channel *ch);
-void il_set_flags_for_band(struct il_priv *il, enum ieee80211_band band,
-                          struct ieee80211_vif *vif);
-u8 il_get_single_channel_number(struct il_priv *il, enum ieee80211_band band);
-void il_set_rxon_ht(struct il_priv *il, struct il_ht_config *ht_conf);
-bool il_is_ht40_tx_allowed(struct il_priv *il,
-                          struct ieee80211_sta_ht_cap *ht_cap);
-void il_connection_init_rx_config(struct il_priv *il);
-void il_set_rate(struct il_priv *il);
-int il_set_decrypted_flag(struct il_priv *il, struct ieee80211_hdr *hdr,
-                         u32 decrypt_res, struct ieee80211_rx_status *stats);
-void il_irq_handle_error(struct il_priv *il);
-int il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
-void il_mac_remove_interface(struct ieee80211_hw *hw,
-                            struct ieee80211_vif *vif);
-int il_mac_change_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                           enum nl80211_iftype newtype, bool newp2p);
-void il_mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                 u32 queues, bool drop);
-int il_alloc_txq_mem(struct il_priv *il);
-void il_free_txq_mem(struct il_priv *il);
-
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-void il_update_stats(struct il_priv *il, bool is_tx, __le16 fc, u16 len);
-#else
-static inline void
-il_update_stats(struct il_priv *il, bool is_tx, __le16 fc, u16 len)
-{
-}
-#endif
-
-/*****************************************************
- * Handlers
- ***************************************************/
-void il_hdl_pm_sleep(struct il_priv *il, struct il_rx_buf *rxb);
-void il_hdl_pm_debug_stats(struct il_priv *il, struct il_rx_buf *rxb);
-void il_hdl_error(struct il_priv *il, struct il_rx_buf *rxb);
-void il_hdl_csa(struct il_priv *il, struct il_rx_buf *rxb);
-
-/*****************************************************
-* RX
-******************************************************/
-void il_cmd_queue_unmap(struct il_priv *il);
-void il_cmd_queue_free(struct il_priv *il);
-int il_rx_queue_alloc(struct il_priv *il);
-void il_rx_queue_update_write_ptr(struct il_priv *il, struct il_rx_queue *q);
-int il_rx_queue_space(const struct il_rx_queue *q);
-void il_tx_cmd_complete(struct il_priv *il, struct il_rx_buf *rxb);
-
-void il_hdl_spectrum_measurement(struct il_priv *il, struct il_rx_buf *rxb);
-void il_recover_from_stats(struct il_priv *il, struct il_rx_pkt *pkt);
-void il_chswitch_done(struct il_priv *il, bool is_success);
-
-/*****************************************************
-* TX
-******************************************************/
-void il_txq_update_write_ptr(struct il_priv *il, struct il_tx_queue *txq);
-int il_tx_queue_init(struct il_priv *il, u32 txq_id);
-void il_tx_queue_reset(struct il_priv *il, u32 txq_id);
-void il_tx_queue_unmap(struct il_priv *il, int txq_id);
-void il_tx_queue_free(struct il_priv *il, int txq_id);
-void il_setup_watchdog(struct il_priv *il);
-/*****************************************************
- * TX power
- ****************************************************/
-int il_set_tx_power(struct il_priv *il, s8 tx_power, bool force);
-
-/*******************************************************************************
- * Rate
- ******************************************************************************/
-
-u8 il_get_lowest_plcp(struct il_priv *il);
-
-/*******************************************************************************
- * Scanning
- ******************************************************************************/
-void il_init_scan_params(struct il_priv *il);
-int il_scan_cancel(struct il_priv *il);
-int il_scan_cancel_timeout(struct il_priv *il, unsigned long ms);
-void il_force_scan_end(struct il_priv *il);
-int il_mac_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                  struct ieee80211_scan_request *hw_req);
-void il_internal_short_hw_scan(struct il_priv *il);
-int il_force_reset(struct il_priv *il, bool external);
-u16 il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
-                     const u8 *ta, const u8 *ie, int ie_len, int left);
-void il_setup_rx_scan_handlers(struct il_priv *il);
-u16 il_get_active_dwell_time(struct il_priv *il, enum ieee80211_band band,
-                            u8 n_probes);
-u16 il_get_passive_dwell_time(struct il_priv *il, enum ieee80211_band band,
-                             struct ieee80211_vif *vif);
-void il_setup_scan_deferred_work(struct il_priv *il);
-void il_cancel_scan_deferred_work(struct il_priv *il);
-
-/* For faster active scanning, scan will move to the next channel if fewer than
- * PLCP_QUIET_THRESH packets are heard on this channel within
- * ACTIVE_QUIET_TIME after sending probe request.  This shortens the dwell
- * time if it's a quiet channel (nothing responded to our probe, and there's
- * no other traffic).
- * Disable "quiet" feature by setting PLCP_QUIET_THRESH to 0. */
-#define IL_ACTIVE_QUIET_TIME       cpu_to_le16(10)     /* msec */
-#define IL_PLCP_QUIET_THRESH       cpu_to_le16(1)      /* packets */
-
-#define IL_SCAN_CHECK_WATCHDOG         (HZ * 7)
-
-/*****************************************************
- *   S e n d i n g     H o s t     C o m m a n d s   *
- *****************************************************/
-
-const char *il_get_cmd_string(u8 cmd);
-int __must_check il_send_cmd_sync(struct il_priv *il, struct il_host_cmd *cmd);
-int il_send_cmd(struct il_priv *il, struct il_host_cmd *cmd);
-int __must_check il_send_cmd_pdu(struct il_priv *il, u8 id, u16 len,
-                                const void *data);
-int il_send_cmd_pdu_async(struct il_priv *il, u8 id, u16 len, const void *data,
-                         void (*callback) (struct il_priv *il,
-                                           struct il_device_cmd *cmd,
-                                           struct il_rx_pkt *pkt));
-
-int il_enqueue_hcmd(struct il_priv *il, struct il_host_cmd *cmd);
-
-/*****************************************************
- * PCI                                              *
- *****************************************************/
-
-void il_bg_watchdog(unsigned long data);
-u32 il_usecs_to_beacons(struct il_priv *il, u32 usec, u32 beacon_interval);
-__le32 il_add_beacon_time(struct il_priv *il, u32 base, u32 addon,
-                         u32 beacon_interval);
-
-#ifdef CONFIG_PM_SLEEP
-extern const struct dev_pm_ops il_pm_ops;
-
-#define IL_LEGACY_PM_OPS       (&il_pm_ops)
-
-#else /* !CONFIG_PM_SLEEP */
-
-#define IL_LEGACY_PM_OPS       NULL
-
-#endif /* !CONFIG_PM_SLEEP */
-
-/*****************************************************
-*  Error Handling Debugging
-******************************************************/
-void il4965_dump_nic_error_log(struct il_priv *il);
-#ifdef CONFIG_IWLEGACY_DEBUG
-void il_print_rx_config_cmd(struct il_priv *il);
-#else
-static inline void
-il_print_rx_config_cmd(struct il_priv *il)
-{
-}
-#endif
-
-void il_clear_isr_stats(struct il_priv *il);
-
-/*****************************************************
-*  GEOS
-******************************************************/
-int il_init_geos(struct il_priv *il);
-void il_free_geos(struct il_priv *il);
-
-/*************** DRIVER STATUS FUNCTIONS   *****/
-
-#define S_HCMD_ACTIVE  0       /* host command in progress */
-/* 1 is unused (used to be S_HCMD_SYNC_ACTIVE) */
-#define S_INT_ENABLED  2
-#define S_RFKILL       3
-#define S_CT_KILL              4
-#define S_INIT         5
-#define S_ALIVE                6
-#define S_READY                7
-#define S_TEMPERATURE  8
-#define S_GEO_CONFIGURED       9
-#define S_EXIT_PENDING 10
-#define S_STATS                12
-#define S_SCANNING             13
-#define S_SCAN_ABORTING        14
-#define S_SCAN_HW              15
-#define S_POWER_PMI    16
-#define S_FW_ERROR             17
-#define S_CHANNEL_SWITCH_PENDING 18
-
-static inline int
-il_is_ready(struct il_priv *il)
-{
-       /* The adapter is 'ready' if READY and GEO_CONFIGURED bits are
-        * set but EXIT_PENDING is not */
-       return test_bit(S_READY, &il->status) &&
-           test_bit(S_GEO_CONFIGURED, &il->status) &&
-           !test_bit(S_EXIT_PENDING, &il->status);
-}
-
-static inline int
-il_is_alive(struct il_priv *il)
-{
-       return test_bit(S_ALIVE, &il->status);
-}
-
-static inline int
-il_is_init(struct il_priv *il)
-{
-       return test_bit(S_INIT, &il->status);
-}
-
-static inline int
-il_is_rfkill(struct il_priv *il)
-{
-       return test_bit(S_RFKILL, &il->status);
-}
-
-static inline int
-il_is_ctkill(struct il_priv *il)
-{
-       return test_bit(S_CT_KILL, &il->status);
-}
-
-static inline int
-il_is_ready_rf(struct il_priv *il)
-{
-
-       if (il_is_rfkill(il))
-               return 0;
-
-       return il_is_ready(il);
-}
-
-void il_send_bt_config(struct il_priv *il);
-int il_send_stats_request(struct il_priv *il, u8 flags, bool clear);
-void il_apm_stop(struct il_priv *il);
-void _il_apm_stop(struct il_priv *il);
-
-int il_apm_init(struct il_priv *il);
-
-int il_send_rxon_timing(struct il_priv *il);
-
-static inline int
-il_send_rxon_assoc(struct il_priv *il)
-{
-       return il->ops->rxon_assoc(il);
-}
-
-static inline int
-il_commit_rxon(struct il_priv *il)
-{
-       return il->ops->commit_rxon(il);
-}
-
-static inline const struct ieee80211_supported_band *
-il_get_hw_mode(struct il_priv *il, enum ieee80211_band band)
-{
-       return il->hw->wiphy->bands[band];
-}
-
-/* mac80211 handlers */
-int il_mac_config(struct ieee80211_hw *hw, u32 changed);
-void il_mac_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
-void il_mac_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                            struct ieee80211_bss_conf *bss_conf, u32 changes);
-void il_tx_cmd_protection(struct il_priv *il, struct ieee80211_tx_info *info,
-                         __le16 fc, __le32 *tx_flags);
-
-irqreturn_t il_isr(int irq, void *data);
-
-void il_set_bit(struct il_priv *p, u32 r, u32 m);
-void il_clear_bit(struct il_priv *p, u32 r, u32 m);
-bool _il_grab_nic_access(struct il_priv *il);
-int _il_poll_bit(struct il_priv *il, u32 addr, u32 bits, u32 mask, int timeout);
-int il_poll_bit(struct il_priv *il, u32 addr, u32 mask, int timeout);
-u32 il_rd_prph(struct il_priv *il, u32 reg);
-void il_wr_prph(struct il_priv *il, u32 addr, u32 val);
-u32 il_read_targ_mem(struct il_priv *il, u32 addr);
-void il_write_targ_mem(struct il_priv *il, u32 addr, u32 val);
-
-static inline bool il_need_reclaim(struct il_priv *il, struct il_rx_pkt *pkt)
-{
-       /* Reclaim a command buffer only if this packet is a response
-        * to a (driver-originated) command. If the packet (e.g. Rx frame)
-        * originated from uCode, there is no command buffer to reclaim.
-        * Ucode should set SEQ_RX_FRAME bit if ucode-originated, but
-        * apparently a few don't get set; catch them here.
-        */
-       return !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
-              pkt->hdr.cmd != N_STATS && pkt->hdr.cmd != C_TX &&
-              pkt->hdr.cmd != N_RX_PHY && pkt->hdr.cmd != N_RX &&
-              pkt->hdr.cmd != N_RX_MPDU && pkt->hdr.cmd != N_COMPRESSED_BA;
-}
-
-static inline void
-_il_write8(struct il_priv *il, u32 ofs, u8 val)
-{
-       writeb(val, il->hw_base + ofs);
-}
-#define il_write8(il, ofs, val) _il_write8(il, ofs, val)
-
-static inline void
-_il_wr(struct il_priv *il, u32 ofs, u32 val)
-{
-       writel(val, il->hw_base + ofs);
-}
-
-static inline u32
-_il_rd(struct il_priv *il, u32 ofs)
-{
-       return readl(il->hw_base + ofs);
-}
-
-static inline void
-_il_clear_bit(struct il_priv *il, u32 reg, u32 mask)
-{
-       _il_wr(il, reg, _il_rd(il, reg) & ~mask);
-}
-
-static inline void
-_il_set_bit(struct il_priv *il, u32 reg, u32 mask)
-{
-       _il_wr(il, reg, _il_rd(il, reg) | mask);
-}
-
-static inline void
-_il_release_nic_access(struct il_priv *il)
-{
-       _il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-       /*
-        * In above we are reading CSR_GP_CNTRL register, what will flush any
-        * previous writes, but still want write, which clear MAC_ACCESS_REQ
-        * bit, be performed on PCI bus before any other writes scheduled on
-        * different CPUs (after we drop reg_lock).
-        */
-       mmiowb();
-}
-
-static inline u32
-il_rd(struct il_priv *il, u32 reg)
-{
-       u32 value;
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       _il_grab_nic_access(il);
-       value = _il_rd(il, reg);
-       _il_release_nic_access(il);
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-       return value;
-}
-
-static inline void
-il_wr(struct il_priv *il, u32 reg, u32 value)
-{
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       if (likely(_il_grab_nic_access(il))) {
-               _il_wr(il, reg, value);
-               _il_release_nic_access(il);
-       }
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-}
-
-static inline u32
-_il_rd_prph(struct il_priv *il, u32 reg)
-{
-       _il_wr(il, HBUS_TARG_PRPH_RADDR, reg | (3 << 24));
-       return _il_rd(il, HBUS_TARG_PRPH_RDAT);
-}
-
-static inline void
-_il_wr_prph(struct il_priv *il, u32 addr, u32 val)
-{
-       _il_wr(il, HBUS_TARG_PRPH_WADDR, ((addr & 0x0000FFFF) | (3 << 24)));
-       _il_wr(il, HBUS_TARG_PRPH_WDAT, val);
-}
-
-static inline void
-il_set_bits_prph(struct il_priv *il, u32 reg, u32 mask)
-{
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       if (likely(_il_grab_nic_access(il))) {
-               _il_wr_prph(il, reg, (_il_rd_prph(il, reg) | mask));
-               _il_release_nic_access(il);
-       }
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-}
-
-static inline void
-il_set_bits_mask_prph(struct il_priv *il, u32 reg, u32 bits, u32 mask)
-{
-       unsigned long reg_flags;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       if (likely(_il_grab_nic_access(il))) {
-               _il_wr_prph(il, reg, ((_il_rd_prph(il, reg) & mask) | bits));
-               _il_release_nic_access(il);
-       }
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-}
-
-static inline void
-il_clear_bits_prph(struct il_priv *il, u32 reg, u32 mask)
-{
-       unsigned long reg_flags;
-       u32 val;
-
-       spin_lock_irqsave(&il->reg_lock, reg_flags);
-       if (likely(_il_grab_nic_access(il))) {
-               val = _il_rd_prph(il, reg);
-               _il_wr_prph(il, reg, (val & ~mask));
-               _il_release_nic_access(il);
-       }
-       spin_unlock_irqrestore(&il->reg_lock, reg_flags);
-}
-
-#define HW_KEY_DYNAMIC 0
-#define HW_KEY_DEFAULT 1
-
-#define IL_STA_DRIVER_ACTIVE BIT(0)    /* driver entry is active */
-#define IL_STA_UCODE_ACTIVE  BIT(1)    /* ucode entry is active */
-#define IL_STA_UCODE_INPROGRESS  BIT(2)        /* ucode entry is in process of
-                                          being activated */
-#define IL_STA_LOCAL BIT(3)    /* station state not directed by mac80211;
-                                  (this is for the IBSS BSSID stations) */
-#define IL_STA_BCAST BIT(4)    /* this station is the special bcast station */
-
-void il_restore_stations(struct il_priv *il);
-void il_clear_ucode_stations(struct il_priv *il);
-void il_dealloc_bcast_stations(struct il_priv *il);
-int il_get_free_ucode_key_idx(struct il_priv *il);
-int il_send_add_sta(struct il_priv *il, struct il_addsta_cmd *sta, u8 flags);
-int il_add_station_common(struct il_priv *il, const u8 *addr, bool is_ap,
-                         struct ieee80211_sta *sta, u8 *sta_id_r);
-int il_remove_station(struct il_priv *il, const u8 sta_id, const u8 * addr);
-int il_mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                     struct ieee80211_sta *sta);
-
-u8 il_prep_station(struct il_priv *il, const u8 *addr, bool is_ap,
-                  struct ieee80211_sta *sta);
-
-int il_send_lq_cmd(struct il_priv *il, struct il_link_quality_cmd *lq,
-                  u8 flags, bool init);
-
-/**
- * il_clear_driver_stations - clear knowledge of all stations from driver
- * @il: iwl il struct
- *
- * This is called during il_down() to make sure that in the case
- * we're coming there from a hardware restart mac80211 will be
- * able to reconfigure stations -- if we're getting there in the
- * normal down flow then the stations will already be cleared.
- */
-static inline void
-il_clear_driver_stations(struct il_priv *il)
-{
-       unsigned long flags;
-
-       spin_lock_irqsave(&il->sta_lock, flags);
-       memset(il->stations, 0, sizeof(il->stations));
-       il->num_stations = 0;
-       il->ucode_key_table = 0;
-       spin_unlock_irqrestore(&il->sta_lock, flags);
-}
-
-static inline int
-il_sta_id(struct ieee80211_sta *sta)
-{
-       if (WARN_ON(!sta))
-               return IL_INVALID_STATION;
-
-       return ((struct il_station_priv_common *)sta->drv_priv)->sta_id;
-}
-
-/**
- * il_sta_id_or_broadcast - return sta_id or broadcast sta
- * @il: iwl il
- * @context: the current context
- * @sta: mac80211 station
- *
- * In certain circumstances mac80211 passes a station pointer
- * that may be %NULL, for example during TX or key setup. In
- * that case, we need to use the broadcast station, so this
- * inline wraps that pattern.
- */
-static inline int
-il_sta_id_or_broadcast(struct il_priv *il, struct ieee80211_sta *sta)
-{
-       int sta_id;
-
-       if (!sta)
-               return il->hw_params.bcast_id;
-
-       sta_id = il_sta_id(sta);
-
-       /*
-        * mac80211 should not be passing a partially
-        * initialised station!
-        */
-       WARN_ON(sta_id == IL_INVALID_STATION);
-
-       return sta_id;
-}
-
-/**
- * il_queue_inc_wrap - increment queue idx, wrap back to beginning
- * @idx -- current idx
- * @n_bd -- total number of entries in queue (must be power of 2)
- */
-static inline int
-il_queue_inc_wrap(int idx, int n_bd)
-{
-       return ++idx & (n_bd - 1);
-}
-
-/**
- * il_queue_dec_wrap - decrement queue idx, wrap back to end
- * @idx -- current idx
- * @n_bd -- total number of entries in queue (must be power of 2)
- */
-static inline int
-il_queue_dec_wrap(int idx, int n_bd)
-{
-       return --idx & (n_bd - 1);
-}
-
-/* TODO: Move fw_desc functions to iwl-pci.ko */
-static inline void
-il_free_fw_desc(struct pci_dev *pci_dev, struct fw_desc *desc)
-{
-       if (desc->v_addr)
-               dma_free_coherent(&pci_dev->dev, desc->len, desc->v_addr,
-                                 desc->p_addr);
-       desc->v_addr = NULL;
-       desc->len = 0;
-}
-
-static inline int
-il_alloc_fw_desc(struct pci_dev *pci_dev, struct fw_desc *desc)
-{
-       if (!desc->len) {
-               desc->v_addr = NULL;
-               return -EINVAL;
-       }
-
-       desc->v_addr = dma_alloc_coherent(&pci_dev->dev, desc->len,
-                                         &desc->p_addr, GFP_KERNEL);
-       return (desc->v_addr != NULL) ? 0 : -ENOMEM;
-}
-
-/*
- * we have 8 bits used like this:
- *
- * 7 6 5 4 3 2 1 0
- * | | | | | | | |
- * | | | | | | +-+-------- AC queue (0-3)
- * | | | | | |
- * | +-+-+-+-+------------ HW queue ID
- * |
- * +---------------------- unused
- */
-static inline void
-il_set_swq_id(struct il_tx_queue *txq, u8 ac, u8 hwq)
-{
-       BUG_ON(ac > 3);         /* only have 2 bits */
-       BUG_ON(hwq > 31);       /* only use 5 bits */
-
-       txq->swq_id = (hwq << 2) | ac;
-}
-
-static inline void
-_il_wake_queue(struct il_priv *il, u8 ac)
-{
-       if (atomic_dec_return(&il->queue_stop_count[ac]) <= 0)
-               ieee80211_wake_queue(il->hw, ac);
-}
-
-static inline void
-_il_stop_queue(struct il_priv *il, u8 ac)
-{
-       if (atomic_inc_return(&il->queue_stop_count[ac]) > 0)
-               ieee80211_stop_queue(il->hw, ac);
-}
-static inline void
-il_wake_queue(struct il_priv *il, struct il_tx_queue *txq)
-{
-       u8 queue = txq->swq_id;
-       u8 ac = queue & 3;
-       u8 hwq = (queue >> 2) & 0x1f;
-
-       if (test_and_clear_bit(hwq, il->queue_stopped))
-               _il_wake_queue(il, ac);
-}
-
-static inline void
-il_stop_queue(struct il_priv *il, struct il_tx_queue *txq)
-{
-       u8 queue = txq->swq_id;
-       u8 ac = queue & 3;
-       u8 hwq = (queue >> 2) & 0x1f;
-
-       if (!test_and_set_bit(hwq, il->queue_stopped))
-               _il_stop_queue(il, ac);
-}
-
-static inline void
-il_wake_queues_by_reason(struct il_priv *il, int reason)
-{
-       u8 ac;
-
-       if (test_and_clear_bit(reason, &il->stop_reason))
-               for (ac = 0; ac < 4; ac++)
-                       _il_wake_queue(il, ac);
-}
-
-static inline void
-il_stop_queues_by_reason(struct il_priv *il, int reason)
-{
-       u8 ac;
-
-       if (!test_and_set_bit(reason, &il->stop_reason))
-               for (ac = 0; ac < 4; ac++)
-                       _il_stop_queue(il, ac);
-}
-
-#ifdef ieee80211_stop_queue
-#undef ieee80211_stop_queue
-#endif
-
-#define ieee80211_stop_queue DO_NOT_USE_ieee80211_stop_queue
-
-#ifdef ieee80211_wake_queue
-#undef ieee80211_wake_queue
-#endif
-
-#define ieee80211_wake_queue DO_NOT_USE_ieee80211_wake_queue
-
-static inline void
-il_disable_interrupts(struct il_priv *il)
-{
-       clear_bit(S_INT_ENABLED, &il->status);
-
-       /* disable interrupts from uCode/NIC to host */
-       _il_wr(il, CSR_INT_MASK, 0x00000000);
-
-       /* acknowledge/clear/reset any interrupts still pending
-        * from uCode or flow handler (Rx/Tx DMA) */
-       _il_wr(il, CSR_INT, 0xffffffff);
-       _il_wr(il, CSR_FH_INT_STATUS, 0xffffffff);
-}
-
-static inline void
-il_enable_rfkill_int(struct il_priv *il)
-{
-       _il_wr(il, CSR_INT_MASK, CSR_INT_BIT_RF_KILL);
-}
-
-static inline void
-il_enable_interrupts(struct il_priv *il)
-{
-       set_bit(S_INT_ENABLED, &il->status);
-       _il_wr(il, CSR_INT_MASK, il->inta_mask);
-}
-
-/**
- * il_beacon_time_mask_low - mask of lower 32 bit of beacon time
- * @il -- pointer to il_priv data structure
- * @tsf_bits -- number of bits need to shift for masking)
- */
-static inline u32
-il_beacon_time_mask_low(struct il_priv *il, u16 tsf_bits)
-{
-       return (1 << tsf_bits) - 1;
-}
-
-/**
- * il_beacon_time_mask_high - mask of higher 32 bit of beacon time
- * @il -- pointer to il_priv data structure
- * @tsf_bits -- number of bits need to shift for masking)
- */
-static inline u32
-il_beacon_time_mask_high(struct il_priv *il, u16 tsf_bits)
-{
-       return ((1 << (32 - tsf_bits)) - 1) << tsf_bits;
-}
-
-/**
- * struct il_rb_status - reseve buffer status host memory mapped FH registers
- *
- * @closed_rb_num [0:11] - Indicates the idx of the RB which was closed
- * @closed_fr_num [0:11] - Indicates the idx of the RX Frame which was closed
- * @finished_rb_num [0:11] - Indicates the idx of the current RB
- *                          in which the last frame was written to
- * @finished_fr_num [0:11] - Indicates the idx of the RX Frame
- *                          which was transferred
- */
-struct il_rb_status {
-       __le16 closed_rb_num;
-       __le16 closed_fr_num;
-       __le16 finished_rb_num;
-       __le16 finished_fr_nam;
-       __le32 __unused;        /* 3945 only */
-} __packed;
-
-#define TFD_QUEUE_SIZE_MAX      256
-#define TFD_QUEUE_SIZE_BC_DUP  64
-#define TFD_QUEUE_BC_SIZE      (TFD_QUEUE_SIZE_MAX + TFD_QUEUE_SIZE_BC_DUP)
-#define IL_TX_DMA_MASK         DMA_BIT_MASK(36)
-#define IL_NUM_OF_TBS          20
-
-static inline u8
-il_get_dma_hi_addr(dma_addr_t addr)
-{
-       return (sizeof(addr) > sizeof(u32) ? (addr >> 16) >> 16 : 0) & 0xF;
-}
-
-/**
- * struct il_tfd_tb transmit buffer descriptor within transmit frame descriptor
- *
- * This structure contains dma address and length of transmission address
- *
- * @lo: low [31:0] portion of the dma address of TX buffer every even is
- *     unaligned on 16 bit boundary
- * @hi_n_len: 0-3 [35:32] portion of dma
- *           4-15 length of the tx buffer
- */
-struct il_tfd_tb {
-       __le32 lo;
-       __le16 hi_n_len;
-} __packed;
-
-/**
- * struct il_tfd
- *
- * Transmit Frame Descriptor (TFD)
- *
- * @ __reserved1[3] reserved
- * @ num_tbs 0-4 number of active tbs
- *          5   reserved
- *          6-7 padding (not used)
- * @ tbs[20]   transmit frame buffer descriptors
- * @ __pad     padding
- *
- * Each Tx queue uses a circular buffer of 256 TFDs stored in host DRAM.
- * Both driver and device share these circular buffers, each of which must be
- * contiguous 256 TFDs x 128 bytes-per-TFD = 32 KBytes
- *
- * Driver must indicate the physical address of the base of each
- * circular buffer via the FH49_MEM_CBBC_QUEUE registers.
- *
- * Each TFD contains pointer/size information for up to 20 data buffers
- * in host DRAM.  These buffers collectively contain the (one) frame described
- * by the TFD.  Each buffer must be a single contiguous block of memory within
- * itself, but buffers may be scattered in host DRAM.  Each buffer has max size
- * of (4K - 4).  The concatenates all of a TFD's buffers into a single
- * Tx frame, up to 8 KBytes in size.
- *
- * A maximum of 255 (not 256!) TFDs may be on a queue waiting for Tx.
- */
-struct il_tfd {
-       u8 __reserved1[3];
-       u8 num_tbs;
-       struct il_tfd_tb tbs[IL_NUM_OF_TBS];
-       __le32 __pad;
-} __packed;
-/* PCI registers */
-#define PCI_CFG_RETRY_TIMEOUT  0x041
-
-struct il_rate_info {
-       u8 plcp;                /* uCode API:  RATE_6M_PLCP, etc. */
-       u8 plcp_siso;           /* uCode API:  RATE_SISO_6M_PLCP, etc. */
-       u8 plcp_mimo2;          /* uCode API:  RATE_MIMO2_6M_PLCP, etc. */
-       u8 ieee;                /* MAC header:  RATE_6M_IEEE, etc. */
-       u8 prev_ieee;           /* previous rate in IEEE speeds */
-       u8 next_ieee;           /* next rate in IEEE speeds */
-       u8 prev_rs;             /* previous rate used in rs algo */
-       u8 next_rs;             /* next rate used in rs algo */
-       u8 prev_rs_tgg;         /* previous rate used in TGG rs algo */
-       u8 next_rs_tgg;         /* next rate used in TGG rs algo */
-};
-
-struct il3945_rate_info {
-       u8 plcp;                /* uCode API:  RATE_6M_PLCP, etc. */
-       u8 ieee;                /* MAC header:  RATE_6M_IEEE, etc. */
-       u8 prev_ieee;           /* previous rate in IEEE speeds */
-       u8 next_ieee;           /* next rate in IEEE speeds */
-       u8 prev_rs;             /* previous rate used in rs algo */
-       u8 next_rs;             /* next rate used in rs algo */
-       u8 prev_rs_tgg;         /* previous rate used in TGG rs algo */
-       u8 next_rs_tgg;         /* next rate used in TGG rs algo */
-       u8 table_rs_idx;        /* idx in rate scale table cmd */
-       u8 prev_table_rs;       /* prev in rate table cmd */
-};
-
-/*
- * These serve as idxes into
- * struct il_rate_info il_rates[RATE_COUNT];
- */
-enum {
-       RATE_1M_IDX = 0,
-       RATE_2M_IDX,
-       RATE_5M_IDX,
-       RATE_11M_IDX,
-       RATE_6M_IDX,
-       RATE_9M_IDX,
-       RATE_12M_IDX,
-       RATE_18M_IDX,
-       RATE_24M_IDX,
-       RATE_36M_IDX,
-       RATE_48M_IDX,
-       RATE_54M_IDX,
-       RATE_60M_IDX,
-       RATE_COUNT,
-       RATE_COUNT_LEGACY = RATE_COUNT - 1,     /* Excluding 60M */
-       RATE_COUNT_3945 = RATE_COUNT - 1,
-       RATE_INVM_IDX = RATE_COUNT,
-       RATE_INVALID = RATE_COUNT,
-};
-
-enum {
-       RATE_6M_IDX_TBL = 0,
-       RATE_9M_IDX_TBL,
-       RATE_12M_IDX_TBL,
-       RATE_18M_IDX_TBL,
-       RATE_24M_IDX_TBL,
-       RATE_36M_IDX_TBL,
-       RATE_48M_IDX_TBL,
-       RATE_54M_IDX_TBL,
-       RATE_1M_IDX_TBL,
-       RATE_2M_IDX_TBL,
-       RATE_5M_IDX_TBL,
-       RATE_11M_IDX_TBL,
-       RATE_INVM_IDX_TBL = RATE_INVM_IDX - 1,
-};
-
-enum {
-       IL_FIRST_OFDM_RATE = RATE_6M_IDX,
-       IL39_LAST_OFDM_RATE = RATE_54M_IDX,
-       IL_LAST_OFDM_RATE = RATE_60M_IDX,
-       IL_FIRST_CCK_RATE = RATE_1M_IDX,
-       IL_LAST_CCK_RATE = RATE_11M_IDX,
-};
-
-/* #define vs. enum to keep from defaulting to 'large integer' */
-#define        RATE_6M_MASK   (1 << RATE_6M_IDX)
-#define        RATE_9M_MASK   (1 << RATE_9M_IDX)
-#define        RATE_12M_MASK  (1 << RATE_12M_IDX)
-#define        RATE_18M_MASK  (1 << RATE_18M_IDX)
-#define        RATE_24M_MASK  (1 << RATE_24M_IDX)
-#define        RATE_36M_MASK  (1 << RATE_36M_IDX)
-#define        RATE_48M_MASK  (1 << RATE_48M_IDX)
-#define        RATE_54M_MASK  (1 << RATE_54M_IDX)
-#define RATE_60M_MASK  (1 << RATE_60M_IDX)
-#define        RATE_1M_MASK   (1 << RATE_1M_IDX)
-#define        RATE_2M_MASK   (1 << RATE_2M_IDX)
-#define        RATE_5M_MASK   (1 << RATE_5M_IDX)
-#define        RATE_11M_MASK  (1 << RATE_11M_IDX)
-
-/* uCode API values for legacy bit rates, both OFDM and CCK */
-enum {
-       RATE_6M_PLCP = 13,
-       RATE_9M_PLCP = 15,
-       RATE_12M_PLCP = 5,
-       RATE_18M_PLCP = 7,
-       RATE_24M_PLCP = 9,
-       RATE_36M_PLCP = 11,
-       RATE_48M_PLCP = 1,
-       RATE_54M_PLCP = 3,
-       RATE_60M_PLCP = 3,      /*FIXME:RS:should be removed */
-       RATE_1M_PLCP = 10,
-       RATE_2M_PLCP = 20,
-       RATE_5M_PLCP = 55,
-       RATE_11M_PLCP = 110,
-       /*FIXME:RS:add RATE_LEGACY_INVM_PLCP = 0, */
-};
-
-/* uCode API values for OFDM high-throughput (HT) bit rates */
-enum {
-       RATE_SISO_6M_PLCP = 0,
-       RATE_SISO_12M_PLCP = 1,
-       RATE_SISO_18M_PLCP = 2,
-       RATE_SISO_24M_PLCP = 3,
-       RATE_SISO_36M_PLCP = 4,
-       RATE_SISO_48M_PLCP = 5,
-       RATE_SISO_54M_PLCP = 6,
-       RATE_SISO_60M_PLCP = 7,
-       RATE_MIMO2_6M_PLCP = 0x8,
-       RATE_MIMO2_12M_PLCP = 0x9,
-       RATE_MIMO2_18M_PLCP = 0xa,
-       RATE_MIMO2_24M_PLCP = 0xb,
-       RATE_MIMO2_36M_PLCP = 0xc,
-       RATE_MIMO2_48M_PLCP = 0xd,
-       RATE_MIMO2_54M_PLCP = 0xe,
-       RATE_MIMO2_60M_PLCP = 0xf,
-       RATE_SISO_INVM_PLCP,
-       RATE_MIMO2_INVM_PLCP = RATE_SISO_INVM_PLCP,
-};
-
-/* MAC header values for bit rates */
-enum {
-       RATE_6M_IEEE = 12,
-       RATE_9M_IEEE = 18,
-       RATE_12M_IEEE = 24,
-       RATE_18M_IEEE = 36,
-       RATE_24M_IEEE = 48,
-       RATE_36M_IEEE = 72,
-       RATE_48M_IEEE = 96,
-       RATE_54M_IEEE = 108,
-       RATE_60M_IEEE = 120,
-       RATE_1M_IEEE = 2,
-       RATE_2M_IEEE = 4,
-       RATE_5M_IEEE = 11,
-       RATE_11M_IEEE = 22,
-};
-
-#define IL_CCK_BASIC_RATES_MASK    \
-       (RATE_1M_MASK          | \
-       RATE_2M_MASK)
-
-#define IL_CCK_RATES_MASK          \
-       (IL_CCK_BASIC_RATES_MASK  | \
-       RATE_5M_MASK          | \
-       RATE_11M_MASK)
-
-#define IL_OFDM_BASIC_RATES_MASK   \
-       (RATE_6M_MASK         | \
-       RATE_12M_MASK         | \
-       RATE_24M_MASK)
-
-#define IL_OFDM_RATES_MASK         \
-       (IL_OFDM_BASIC_RATES_MASK | \
-       RATE_9M_MASK          | \
-       RATE_18M_MASK         | \
-       RATE_36M_MASK         | \
-       RATE_48M_MASK         | \
-       RATE_54M_MASK)
-
-#define IL_BASIC_RATES_MASK         \
-       (IL_OFDM_BASIC_RATES_MASK | \
-        IL_CCK_BASIC_RATES_MASK)
-
-#define RATES_MASK ((1 << RATE_COUNT) - 1)
-#define RATES_MASK_3945 ((1 << RATE_COUNT_3945) - 1)
-
-#define IL_INVALID_VALUE    -1
-
-#define IL_MIN_RSSI_VAL                 -100
-#define IL_MAX_RSSI_VAL                    0
-
-/* These values specify how many Tx frame attempts before
- * searching for a new modulation mode */
-#define IL_LEGACY_FAILURE_LIMIT        160
-#define IL_LEGACY_SUCCESS_LIMIT        480
-#define IL_LEGACY_TBL_COUNT            160
-
-#define IL_NONE_LEGACY_FAILURE_LIMIT   400
-#define IL_NONE_LEGACY_SUCCESS_LIMIT   4500
-#define IL_NONE_LEGACY_TBL_COUNT       1500
-
-/* Success ratio (ACKed / attempted tx frames) values (perfect is 128 * 100) */
-#define IL_RS_GOOD_RATIO               12800   /* 100% */
-#define RATE_SCALE_SWITCH              10880   /*  85% */
-#define RATE_HIGH_TH           10880   /*  85% */
-#define RATE_INCREASE_TH               6400    /*  50% */
-#define RATE_DECREASE_TH               1920    /*  15% */
-
-/* possible actions when in legacy mode */
-#define IL_LEGACY_SWITCH_ANTENNA1      0
-#define IL_LEGACY_SWITCH_ANTENNA2      1
-#define IL_LEGACY_SWITCH_SISO          2
-#define IL_LEGACY_SWITCH_MIMO2_AB      3
-#define IL_LEGACY_SWITCH_MIMO2_AC      4
-#define IL_LEGACY_SWITCH_MIMO2_BC      5
-
-/* possible actions when in siso mode */
-#define IL_SISO_SWITCH_ANTENNA1        0
-#define IL_SISO_SWITCH_ANTENNA2        1
-#define IL_SISO_SWITCH_MIMO2_AB        2
-#define IL_SISO_SWITCH_MIMO2_AC        3
-#define IL_SISO_SWITCH_MIMO2_BC        4
-#define IL_SISO_SWITCH_GI              5
-
-/* possible actions when in mimo mode */
-#define IL_MIMO2_SWITCH_ANTENNA1       0
-#define IL_MIMO2_SWITCH_ANTENNA2       1
-#define IL_MIMO2_SWITCH_SISO_A         2
-#define IL_MIMO2_SWITCH_SISO_B         3
-#define IL_MIMO2_SWITCH_SISO_C         4
-#define IL_MIMO2_SWITCH_GI             5
-
-#define IL_MAX_SEARCH IL_MIMO2_SWITCH_GI
-
-#define IL_ACTION_LIMIT                3       /* # possible actions */
-
-#define LQ_SIZE                2       /* 2 mode tables:  "Active" and "Search" */
-
-/* load per tid defines for A-MPDU activation */
-#define IL_AGG_TPT_THREHOLD    0
-#define IL_AGG_LOAD_THRESHOLD  10
-#define IL_AGG_ALL_TID         0xff
-#define TID_QUEUE_CELL_SPACING 50      /*mS */
-#define TID_QUEUE_MAX_SIZE     20
-#define TID_ROUND_VALUE                5       /* mS */
-#define TID_MAX_LOAD_COUNT     8
-
-#define TID_MAX_TIME_DIFF ((TID_QUEUE_MAX_SIZE - 1) * TID_QUEUE_CELL_SPACING)
-#define TIME_WRAP_AROUND(x, y) (((y) > (x)) ? (y) - (x) : (0-(x)) + (y))
-
-extern const struct il_rate_info il_rates[RATE_COUNT];
-
-enum il_table_type {
-       LQ_NONE,
-       LQ_G,                   /* legacy types */
-       LQ_A,
-       LQ_SISO,                /* high-throughput types */
-       LQ_MIMO2,
-       LQ_MAX,
-};
-
-#define is_legacy(tbl) ((tbl) == LQ_G || (tbl) == LQ_A)
-#define is_siso(tbl) ((tbl) == LQ_SISO)
-#define is_mimo2(tbl) ((tbl) == LQ_MIMO2)
-#define is_mimo(tbl) (is_mimo2(tbl))
-#define is_Ht(tbl) (is_siso(tbl) || is_mimo(tbl))
-#define is_a_band(tbl) ((tbl) == LQ_A)
-#define is_g_and(tbl) ((tbl) == LQ_G)
-
-#define        ANT_NONE        0x0
-#define        ANT_A           BIT(0)
-#define        ANT_B           BIT(1)
-#define        ANT_AB          (ANT_A | ANT_B)
-#define ANT_C          BIT(2)
-#define        ANT_AC          (ANT_A | ANT_C)
-#define ANT_BC         (ANT_B | ANT_C)
-#define ANT_ABC                (ANT_AB | ANT_C)
-
-#define IL_MAX_MCS_DISPLAY_SIZE        12
-
-struct il_rate_mcs_info {
-       char mbps[IL_MAX_MCS_DISPLAY_SIZE];
-       char mcs[IL_MAX_MCS_DISPLAY_SIZE];
-};
-
-/**
- * struct il_rate_scale_data -- tx success history for one rate
- */
-struct il_rate_scale_data {
-       u64 data;               /* bitmap of successful frames */
-       s32 success_counter;    /* number of frames successful */
-       s32 success_ratio;      /* per-cent * 128  */
-       s32 counter;            /* number of frames attempted */
-       s32 average_tpt;        /* success ratio * expected throughput */
-       unsigned long stamp;
-};
-
-/**
- * struct il_scale_tbl_info -- tx params and success history for all rates
- *
- * There are two of these in struct il_lq_sta,
- * one for "active", and one for "search".
- */
-struct il_scale_tbl_info {
-       enum il_table_type lq_type;
-       u8 ant_type;
-       u8 is_SGI;              /* 1 = short guard interval */
-       u8 is_ht40;             /* 1 = 40 MHz channel width */
-       u8 is_dup;              /* 1 = duplicated data streams */
-       u8 action;              /* change modulation; IL_[LEGACY/SISO/MIMO]_SWITCH_* */
-       u8 max_search;          /* maximun number of tables we can search */
-       s32 *expected_tpt;      /* throughput metrics; expected_tpt_G, etc. */
-       u32 current_rate;       /* rate_n_flags, uCode API format */
-       struct il_rate_scale_data win[RATE_COUNT];      /* rate histories */
-};
-
-struct il_traffic_load {
-       unsigned long time_stamp;       /* age of the oldest stats */
-       u32 packet_count[TID_QUEUE_MAX_SIZE];   /* packet count in this time
-                                                * slice */
-       u32 total;              /* total num of packets during the
-                                * last TID_MAX_TIME_DIFF */
-       u8 queue_count;         /* number of queues that has
-                                * been used since the last cleanup */
-       u8 head;                /* start of the circular buffer */
-};
-
-/**
- * struct il_lq_sta -- driver's rate scaling ilate structure
- *
- * Pointer to this gets passed back and forth between driver and mac80211.
- */
-struct il_lq_sta {
-       u8 active_tbl;          /* idx of active table, range 0-1 */
-       u8 enable_counter;      /* indicates HT mode */
-       u8 stay_in_tbl;         /* 1: disallow, 0: allow search for new mode */
-       u8 search_better_tbl;   /* 1: currently trying alternate mode */
-       s32 last_tpt;
-
-       /* The following determine when to search for a new mode */
-       u32 table_count_limit;
-       u32 max_failure_limit;  /* # failed frames before new search */
-       u32 max_success_limit;  /* # successful frames before new search */
-       u32 table_count;
-       u32 total_failed;       /* total failed frames, any/all rates */
-       u32 total_success;      /* total successful frames, any/all rates */
-       u64 flush_timer;        /* time staying in mode before new search */
-
-       u8 action_counter;      /* # mode-switch actions tried */
-       u8 is_green;
-       u8 is_dup;
-       enum ieee80211_band band;
-
-       /* The following are bitmaps of rates; RATE_6M_MASK, etc. */
-       u32 supp_rates;
-       u16 active_legacy_rate;
-       u16 active_siso_rate;
-       u16 active_mimo2_rate;
-       s8 max_rate_idx;        /* Max rate set by user */
-       u8 missed_rate_counter;
-
-       struct il_link_quality_cmd lq;
-       struct il_scale_tbl_info lq_info[LQ_SIZE];      /* "active", "search" */
-       struct il_traffic_load load[TID_MAX_LOAD_COUNT];
-       u8 tx_agg_tid_en;
-#ifdef CONFIG_MAC80211_DEBUGFS
-       struct dentry *rs_sta_dbgfs_scale_table_file;
-       struct dentry *rs_sta_dbgfs_stats_table_file;
-       struct dentry *rs_sta_dbgfs_rate_scale_data_file;
-       struct dentry *rs_sta_dbgfs_tx_agg_tid_en_file;
-       u32 dbg_fixed_rate;
-#endif
-       struct il_priv *drv;
-
-       /* used to be in sta_info */
-       int last_txrate_idx;
-       /* last tx rate_n_flags */
-       u32 last_rate_n_flags;
-       /* packets destined for this STA are aggregated */
-       u8 is_agg;
-};
-
-/*
- * il_station_priv: Driver's ilate station information
- *
- * When mac80211 creates a station it reserves some space (hw->sta_data_size)
- * in the structure for use by driver. This structure is places in that
- * space.
- *
- * The common struct MUST be first because it is shared between
- * 3945 and 4965!
- */
-struct il_station_priv {
-       struct il_station_priv_common common;
-       struct il_lq_sta lq_sta;
-       atomic_t pending_frames;
-       bool client;
-       bool asleep;
-};
-
-static inline u8
-il4965_num_of_ant(u8 m)
-{
-       return !!(m & ANT_A) + !!(m & ANT_B) + !!(m & ANT_C);
-}
-
-static inline u8
-il4965_first_antenna(u8 mask)
-{
-       if (mask & ANT_A)
-               return ANT_A;
-       if (mask & ANT_B)
-               return ANT_B;
-       return ANT_C;
-}
-
-/**
- * il3945_rate_scale_init - Initialize the rate scale table based on assoc info
- *
- * The specific throughput table used is based on the type of network
- * the associated with, including A, B, G, and G w/ TGG protection
- */
-void il3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id);
-
-/* Initialize station's rate scaling information after adding station */
-void il4965_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta,
-                        u8 sta_id);
-void il3945_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta,
-                        u8 sta_id);
-
-/**
- * il_rate_control_register - Register the rate control algorithm callbacks
- *
- * Since the rate control algorithm is hardware specific, there is no need
- * or reason to place it as a stand alone module.  The driver can call
- * il_rate_control_register in order to register the rate control callbacks
- * with the mac80211 subsystem.  This should be performed prior to calling
- * ieee80211_register_hw
- *
- */
-int il4965_rate_control_register(void);
-int il3945_rate_control_register(void);
-
-/**
- * il_rate_control_unregister - Unregister the rate control callbacks
- *
- * This should be called after calling ieee80211_unregister_hw, but before
- * the driver is unloaded.
- */
-void il4965_rate_control_unregister(void);
-void il3945_rate_control_unregister(void);
-
-int il_power_update_mode(struct il_priv *il, bool force);
-void il_power_initialize(struct il_priv *il);
-
-extern u32 il_debug_level;
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-/*
- * il_get_debug_level: Return active debug level for device
- *
- * Using sysfs it is possible to set per device debug level. This debug
- * level will be used if set, otherwise the global debug level which can be
- * set via module parameter is used.
- */
-static inline u32
-il_get_debug_level(struct il_priv *il)
-{
-       if (il->debug_level)
-               return il->debug_level;
-       else
-               return il_debug_level;
-}
-#else
-static inline u32
-il_get_debug_level(struct il_priv *il)
-{
-       return il_debug_level;
-}
-#endif
-
-#define il_print_hex_error(il, p, len)                                 \
-do {                                                                   \
-       print_hex_dump(KERN_ERR, "iwl data: ",                          \
-                      DUMP_PREFIX_OFFSET, 16, 1, p, len, 1);           \
-} while (0)
-
-#ifdef CONFIG_IWLEGACY_DEBUG
-#define IL_DBG(level, fmt, args...)                                    \
-do {                                                                   \
-       if (il_get_debug_level(il) & level)                             \
-               dev_err(&il->hw->wiphy->dev, "%c %s " fmt,              \
-                       in_interrupt() ? 'I' : 'U', __func__ , ##args); \
-} while (0)
-
-#define il_print_hex_dump(il, level, p, len)                           \
-do {                                                                   \
-       if (il_get_debug_level(il) & level)                             \
-               print_hex_dump(KERN_DEBUG, "iwl data: ",                \
-                              DUMP_PREFIX_OFFSET, 16, 1, p, len, 1);   \
-} while (0)
-
-#else
-#define IL_DBG(level, fmt, args...)
-static inline void
-il_print_hex_dump(struct il_priv *il, int level, const void *p, u32 len)
-{
-}
-#endif /* CONFIG_IWLEGACY_DEBUG */
-
-#ifdef CONFIG_IWLEGACY_DEBUGFS
-int il_dbgfs_register(struct il_priv *il, const char *name);
-void il_dbgfs_unregister(struct il_priv *il);
-#else
-static inline int
-il_dbgfs_register(struct il_priv *il, const char *name)
-{
-       return 0;
-}
-
-static inline void
-il_dbgfs_unregister(struct il_priv *il)
-{
-}
-#endif /* CONFIG_IWLEGACY_DEBUGFS */
-
-/*
- * To use the debug system:
- *
- * If you are defining a new debug classification, simply add it to the #define
- * list here in the form of
- *
- * #define IL_DL_xxxx VALUE
- *
- * where xxxx should be the name of the classification (for example, WEP).
- *
- * You then need to either add a IL_xxxx_DEBUG() macro definition for your
- * classification, or use IL_DBG(IL_DL_xxxx, ...) whenever you want
- * to send output to that classification.
- *
- * The active debug levels can be accessed via files
- *
- *     /sys/module/iwl4965/parameters/debug
- *     /sys/module/iwl3945/parameters/debug
- *     /sys/class/net/wlan0/device/debug_level
- *
- * when CONFIG_IWLEGACY_DEBUG=y.
- */
-
-/* 0x0000000F - 0x00000001 */
-#define IL_DL_INFO             (1 << 0)
-#define IL_DL_MAC80211         (1 << 1)
-#define IL_DL_HCMD             (1 << 2)
-#define IL_DL_STATE            (1 << 3)
-/* 0x000000F0 - 0x00000010 */
-#define IL_DL_MACDUMP          (1 << 4)
-#define IL_DL_HCMD_DUMP                (1 << 5)
-#define IL_DL_EEPROM           (1 << 6)
-#define IL_DL_RADIO            (1 << 7)
-/* 0x00000F00 - 0x00000100 */
-#define IL_DL_POWER            (1 << 8)
-#define IL_DL_TEMP             (1 << 9)
-#define IL_DL_NOTIF            (1 << 10)
-#define IL_DL_SCAN             (1 << 11)
-/* 0x0000F000 - 0x00001000 */
-#define IL_DL_ASSOC            (1 << 12)
-#define IL_DL_DROP             (1 << 13)
-#define IL_DL_TXPOWER          (1 << 14)
-#define IL_DL_AP               (1 << 15)
-/* 0x000F0000 - 0x00010000 */
-#define IL_DL_FW               (1 << 16)
-#define IL_DL_RF_KILL          (1 << 17)
-#define IL_DL_FW_ERRORS                (1 << 18)
-#define IL_DL_LED              (1 << 19)
-/* 0x00F00000 - 0x00100000 */
-#define IL_DL_RATE             (1 << 20)
-#define IL_DL_CALIB            (1 << 21)
-#define IL_DL_WEP              (1 << 22)
-#define IL_DL_TX               (1 << 23)
-/* 0x0F000000 - 0x01000000 */
-#define IL_DL_RX               (1 << 24)
-#define IL_DL_ISR              (1 << 25)
-#define IL_DL_HT               (1 << 26)
-/* 0xF0000000 - 0x10000000 */
-#define IL_DL_11H              (1 << 28)
-#define IL_DL_STATS            (1 << 29)
-#define IL_DL_TX_REPLY         (1 << 30)
-#define IL_DL_QOS              (1 << 31)
-
-#define D_INFO(f, a...)                IL_DBG(IL_DL_INFO, f, ## a)
-#define D_MAC80211(f, a...)    IL_DBG(IL_DL_MAC80211, f, ## a)
-#define D_MACDUMP(f, a...)     IL_DBG(IL_DL_MACDUMP, f, ## a)
-#define D_TEMP(f, a...)                IL_DBG(IL_DL_TEMP, f, ## a)
-#define D_SCAN(f, a...)                IL_DBG(IL_DL_SCAN, f, ## a)
-#define D_RX(f, a...)          IL_DBG(IL_DL_RX, f, ## a)
-#define D_TX(f, a...)          IL_DBG(IL_DL_TX, f, ## a)
-#define D_ISR(f, a...)         IL_DBG(IL_DL_ISR, f, ## a)
-#define D_LED(f, a...)         IL_DBG(IL_DL_LED, f, ## a)
-#define D_WEP(f, a...)         IL_DBG(IL_DL_WEP, f, ## a)
-#define D_HC(f, a...)          IL_DBG(IL_DL_HCMD, f, ## a)
-#define D_HC_DUMP(f, a...)     IL_DBG(IL_DL_HCMD_DUMP, f, ## a)
-#define D_EEPROM(f, a...)      IL_DBG(IL_DL_EEPROM, f, ## a)
-#define D_CALIB(f, a...)       IL_DBG(IL_DL_CALIB, f, ## a)
-#define D_FW(f, a...)          IL_DBG(IL_DL_FW, f, ## a)
-#define D_RF_KILL(f, a...)     IL_DBG(IL_DL_RF_KILL, f, ## a)
-#define D_DROP(f, a...)                IL_DBG(IL_DL_DROP, f, ## a)
-#define D_AP(f, a...)          IL_DBG(IL_DL_AP, f, ## a)
-#define D_TXPOWER(f, a...)     IL_DBG(IL_DL_TXPOWER, f, ## a)
-#define D_RATE(f, a...)                IL_DBG(IL_DL_RATE, f, ## a)
-#define D_NOTIF(f, a...)       IL_DBG(IL_DL_NOTIF, f, ## a)
-#define D_ASSOC(f, a...)       IL_DBG(IL_DL_ASSOC, f, ## a)
-#define D_HT(f, a...)          IL_DBG(IL_DL_HT, f, ## a)
-#define D_STATS(f, a...)       IL_DBG(IL_DL_STATS, f, ## a)
-#define D_TX_REPLY(f, a...)    IL_DBG(IL_DL_TX_REPLY, f, ## a)
-#define D_QOS(f, a...)         IL_DBG(IL_DL_QOS, f, ## a)
-#define D_RADIO(f, a...)       IL_DBG(IL_DL_RADIO, f, ## a)
-#define D_POWER(f, a...)       IL_DBG(IL_DL_POWER, f, ## a)
-#define D_11H(f, a...)         IL_DBG(IL_DL_11H, f, ## a)
-
-#endif /* __il_core_h__ */
diff --git a/drivers/net/wireless/iwlegacy/csr.h b/drivers/net/wireless/iwlegacy/csr.h
deleted file mode 100644 (file)
index 9138e15..0000000
+++ /dev/null
@@ -1,419 +0,0 @@
-/******************************************************************************
- *
- * This file is provided under a dual BSD/GPLv2 license.  When using or
- * redistributing this file, you may do so under either license.
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- * BSD LICENSE
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *  * Neither the name Intel Corporation nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *****************************************************************************/
-#ifndef __il_csr_h__
-#define __il_csr_h__
-/*
- * CSR (control and status registers)
- *
- * CSR registers are mapped directly into PCI bus space, and are accessible
- * whenever platform supplies power to device, even when device is in
- * low power states due to driver-invoked device resets
- * (e.g. CSR_RESET_REG_FLAG_SW_RESET) or uCode-driven power-saving modes.
- *
- * Use _il_wr() and _il_rd() family to access these registers;
- * these provide simple PCI bus access, without waking up the MAC.
- * Do not use il_wr() family for these registers;
- * no need to "grab nic access" via CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ.
- * The MAC (uCode processor, etc.) does not need to be powered up for accessing
- * the CSR registers.
- *
- * NOTE:  Device does need to be awake in order to read this memory
- *        via CSR_EEPROM register
- */
-#define CSR_BASE    (0x000)
-
-#define CSR_HW_IF_CONFIG_REG    (CSR_BASE+0x000)       /* hardware interface config */
-#define CSR_INT_COALESCING      (CSR_BASE+0x004)       /* accum ints, 32-usec units */
-#define CSR_INT                 (CSR_BASE+0x008)       /* host interrupt status/ack */
-#define CSR_INT_MASK            (CSR_BASE+0x00c)       /* host interrupt enable */
-#define CSR_FH_INT_STATUS       (CSR_BASE+0x010)       /* busmaster int status/ack */
-#define CSR_GPIO_IN             (CSR_BASE+0x018)       /* read external chip pins */
-#define CSR_RESET               (CSR_BASE+0x020)       /* busmaster enable, NMI, etc */
-#define CSR_GP_CNTRL            (CSR_BASE+0x024)
-
-/* 2nd byte of CSR_INT_COALESCING, not accessible via _il_wr()! */
-#define CSR_INT_PERIODIC_REG   (CSR_BASE+0x005)
-
-/*
- * Hardware revision info
- * Bit fields:
- * 31-8:  Reserved
- *  7-4:  Type of device:  see CSR_HW_REV_TYPE_xxx definitions
- *  3-2:  Revision step:  0 = A, 1 = B, 2 = C, 3 = D
- *  1-0:  "Dash" (-) value, as in A-1, etc.
- *
- * NOTE:  Revision step affects calculation of CCK txpower for 4965.
- * NOTE:  See also CSR_HW_REV_WA_REG (work-around for bug in 4965).
- */
-#define CSR_HW_REV              (CSR_BASE+0x028)
-
-/*
- * EEPROM memory reads
- *
- * NOTE:  Device must be awake, initialized via apm_ops.init(),
- *        in order to read.
- */
-#define CSR_EEPROM_REG          (CSR_BASE+0x02c)
-#define CSR_EEPROM_GP           (CSR_BASE+0x030)
-
-#define CSR_GIO_REG            (CSR_BASE+0x03C)
-#define CSR_GP_UCODE_REG       (CSR_BASE+0x048)
-#define CSR_GP_DRIVER_REG      (CSR_BASE+0x050)
-
-/*
- * UCODE-DRIVER GP (general purpose) mailbox registers.
- * SET/CLR registers set/clear bit(s) if "1" is written.
- */
-#define CSR_UCODE_DRV_GP1       (CSR_BASE+0x054)
-#define CSR_UCODE_DRV_GP1_SET   (CSR_BASE+0x058)
-#define CSR_UCODE_DRV_GP1_CLR   (CSR_BASE+0x05c)
-#define CSR_UCODE_DRV_GP2       (CSR_BASE+0x060)
-
-#define CSR_LED_REG             (CSR_BASE+0x094)
-#define CSR_DRAM_INT_TBL_REG   (CSR_BASE+0x0A0)
-
-/* GIO Chicken Bits (PCI Express bus link power management) */
-#define CSR_GIO_CHICKEN_BITS    (CSR_BASE+0x100)
-
-/* Analog phase-lock-loop configuration  */
-#define CSR_ANA_PLL_CFG         (CSR_BASE+0x20c)
-
-/*
- * CSR Hardware Revision Workaround Register.  Indicates hardware rev;
- * "step" determines CCK backoff for txpower calculation.  Used for 4965 only.
- * See also CSR_HW_REV register.
- * Bit fields:
- *  3-2:  0 = A, 1 = B, 2 = C, 3 = D step
- *  1-0:  "Dash" (-) value, as in C-1, etc.
- */
-#define CSR_HW_REV_WA_REG              (CSR_BASE+0x22C)
-
-#define CSR_DBG_HPET_MEM_REG           (CSR_BASE+0x240)
-#define CSR_DBG_LINK_PWR_MGMT_REG      (CSR_BASE+0x250)
-
-/* Bits for CSR_HW_IF_CONFIG_REG */
-#define CSR49_HW_IF_CONFIG_REG_BIT_4965_R      (0x00000010)
-#define CSR_HW_IF_CONFIG_REG_MSK_BOARD_VER     (0x00000C00)
-#define CSR_HW_IF_CONFIG_REG_BIT_MAC_SI        (0x00000100)
-#define CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI      (0x00000200)
-
-#define CSR39_HW_IF_CONFIG_REG_BIT_3945_MB         (0x00000100)
-#define CSR39_HW_IF_CONFIG_REG_BIT_3945_MM         (0x00000200)
-#define CSR39_HW_IF_CONFIG_REG_BIT_SKU_MRC            (0x00000400)
-#define CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE         (0x00000800)
-#define CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_A    (0x00000000)
-#define CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_B    (0x00001000)
-
-#define CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A  (0x00080000)
-#define CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM        (0x00200000)
-#define CSR_HW_IF_CONFIG_REG_BIT_NIC_READY     (0x00400000)    /* PCI_OWN_SEM */
-#define CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE (0x02000000) /* ME_OWN */
-#define CSR_HW_IF_CONFIG_REG_PREPARE             (0x08000000)  /* WAKE_ME */
-
-#define CSR_INT_PERIODIC_DIS                   (0x00)  /* disable periodic int */
-#define CSR_INT_PERIODIC_ENA                   (0xFF)  /* 255*32 usec ~ 8 msec */
-
-/* interrupt flags in INTA, set by uCode or hardware (e.g. dma),
- * acknowledged (reset) by host writing "1" to flagged bits. */
-#define CSR_INT_BIT_FH_RX        (1 << 31)     /* Rx DMA, cmd responses, FH_INT[17:16] */
-#define CSR_INT_BIT_HW_ERR       (1 << 29)     /* DMA hardware error FH_INT[31] */
-#define CSR_INT_BIT_RX_PERIODIC         (1 << 28)      /* Rx periodic */
-#define CSR_INT_BIT_FH_TX        (1 << 27)     /* Tx DMA FH_INT[1:0] */
-#define CSR_INT_BIT_SCD          (1 << 26)     /* TXQ pointer advanced */
-#define CSR_INT_BIT_SW_ERR       (1 << 25)     /* uCode error */
-#define CSR_INT_BIT_RF_KILL      (1 << 7)      /* HW RFKILL switch GP_CNTRL[27] toggled */
-#define CSR_INT_BIT_CT_KILL      (1 << 6)      /* Critical temp (chip too hot) rfkill */
-#define CSR_INT_BIT_SW_RX        (1 << 3)      /* Rx, command responses, 3945 */
-#define CSR_INT_BIT_WAKEUP       (1 << 1)      /* NIC controller waking up (pwr mgmt) */
-#define CSR_INT_BIT_ALIVE        (1 << 0)      /* uCode interrupts once it initializes */
-
-#define CSR_INI_SET_MASK       (CSR_INT_BIT_FH_RX   | \
-                                CSR_INT_BIT_HW_ERR  | \
-                                CSR_INT_BIT_FH_TX   | \
-                                CSR_INT_BIT_SW_ERR  | \
-                                CSR_INT_BIT_RF_KILL | \
-                                CSR_INT_BIT_SW_RX   | \
-                                CSR_INT_BIT_WAKEUP  | \
-                                CSR_INT_BIT_ALIVE)
-
-/* interrupt flags in FH (flow handler) (PCI busmaster DMA) */
-#define CSR_FH_INT_BIT_ERR       (1 << 31)     /* Error */
-#define CSR_FH_INT_BIT_HI_PRIOR  (1 << 30)     /* High priority Rx, bypass coalescing */
-#define CSR39_FH_INT_BIT_RX_CHNL2  (1 << 18)   /* Rx channel 2 (3945 only) */
-#define CSR_FH_INT_BIT_RX_CHNL1  (1 << 17)     /* Rx channel 1 */
-#define CSR_FH_INT_BIT_RX_CHNL0  (1 << 16)     /* Rx channel 0 */
-#define CSR39_FH_INT_BIT_TX_CHNL6  (1 << 6)    /* Tx channel 6 (3945 only) */
-#define CSR_FH_INT_BIT_TX_CHNL1  (1 << 1)      /* Tx channel 1 */
-#define CSR_FH_INT_BIT_TX_CHNL0  (1 << 0)      /* Tx channel 0 */
-
-#define CSR39_FH_INT_RX_MASK   (CSR_FH_INT_BIT_HI_PRIOR | \
-                                CSR39_FH_INT_BIT_RX_CHNL2 | \
-                                CSR_FH_INT_BIT_RX_CHNL1 | \
-                                CSR_FH_INT_BIT_RX_CHNL0)
-
-#define CSR39_FH_INT_TX_MASK   (CSR39_FH_INT_BIT_TX_CHNL6 | \
-                                CSR_FH_INT_BIT_TX_CHNL1 | \
-                                CSR_FH_INT_BIT_TX_CHNL0)
-
-#define CSR49_FH_INT_RX_MASK   (CSR_FH_INT_BIT_HI_PRIOR | \
-                                CSR_FH_INT_BIT_RX_CHNL1 | \
-                                CSR_FH_INT_BIT_RX_CHNL0)
-
-#define CSR49_FH_INT_TX_MASK   (CSR_FH_INT_BIT_TX_CHNL1 | \
-                                CSR_FH_INT_BIT_TX_CHNL0)
-
-/* GPIO */
-#define CSR_GPIO_IN_BIT_AUX_POWER                   (0x00000200)
-#define CSR_GPIO_IN_VAL_VAUX_PWR_SRC                (0x00000000)
-#define CSR_GPIO_IN_VAL_VMAIN_PWR_SRC               (0x00000200)
-
-/* RESET */
-#define CSR_RESET_REG_FLAG_NEVO_RESET                (0x00000001)
-#define CSR_RESET_REG_FLAG_FORCE_NMI                 (0x00000002)
-#define CSR_RESET_REG_FLAG_SW_RESET                  (0x00000080)
-#define CSR_RESET_REG_FLAG_MASTER_DISABLED           (0x00000100)
-#define CSR_RESET_REG_FLAG_STOP_MASTER               (0x00000200)
-#define CSR_RESET_LINK_PWR_MGMT_DISABLED             (0x80000000)
-
-/*
- * GP (general purpose) CONTROL REGISTER
- * Bit fields:
- *    27:  HW_RF_KILL_SW
- *         Indicates state of (platform's) hardware RF-Kill switch
- * 26-24:  POWER_SAVE_TYPE
- *         Indicates current power-saving mode:
- *         000 -- No power saving
- *         001 -- MAC power-down
- *         010 -- PHY (radio) power-down
- *         011 -- Error
- *   9-6:  SYS_CONFIG
- *         Indicates current system configuration, reflecting pins on chip
- *         as forced high/low by device circuit board.
- *     4:  GOING_TO_SLEEP
- *         Indicates MAC is entering a power-saving sleep power-down.
- *         Not a good time to access device-internal resources.
- *     3:  MAC_ACCESS_REQ
- *         Host sets this to request and maintain MAC wakeup, to allow host
- *         access to device-internal resources.  Host must wait for
- *         MAC_CLOCK_READY (and !GOING_TO_SLEEP) before accessing non-CSR
- *         device registers.
- *     2:  INIT_DONE
- *         Host sets this to put device into fully operational D0 power mode.
- *         Host resets this after SW_RESET to put device into low power mode.
- *     0:  MAC_CLOCK_READY
- *         Indicates MAC (ucode processor, etc.) is powered up and can run.
- *         Internal resources are accessible.
- *         NOTE:  This does not indicate that the processor is actually running.
- *         NOTE:  This does not indicate that 4965 or 3945 has completed
- *                init or post-power-down restore of internal SRAM memory.
- *                Use CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP as indication that
- *                SRAM is restored and uCode is in normal operation mode.
- *                Later devices (5xxx/6xxx/1xxx) use non-volatile SRAM, and
- *                do not need to save/restore it.
- *         NOTE:  After device reset, this bit remains "0" until host sets
- *                INIT_DONE
- */
-#define CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY        (0x00000001)
-#define CSR_GP_CNTRL_REG_FLAG_INIT_DONE              (0x00000004)
-#define CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ         (0x00000008)
-#define CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP         (0x00000010)
-
-#define CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN           (0x00000001)
-
-#define CSR_GP_CNTRL_REG_MSK_POWER_SAVE_TYPE         (0x07000000)
-#define CSR_GP_CNTRL_REG_FLAG_MAC_POWER_SAVE         (0x04000000)
-#define CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW          (0x08000000)
-
-/* EEPROM REG */
-#define CSR_EEPROM_REG_READ_VALID_MSK  (0x00000001)
-#define CSR_EEPROM_REG_BIT_CMD         (0x00000002)
-#define CSR_EEPROM_REG_MSK_ADDR                (0x0000FFFC)
-#define CSR_EEPROM_REG_MSK_DATA                (0xFFFF0000)
-
-/* EEPROM GP */
-#define CSR_EEPROM_GP_VALID_MSK                (0x00000007)    /* signature */
-#define CSR_EEPROM_GP_IF_OWNER_MSK     (0x00000180)
-#define CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K                (0x00000002)
-#define CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K                (0x00000004)
-
-/* GP REG */
-#define CSR_GP_REG_POWER_SAVE_STATUS_MSK            (0x03000000)       /* bit 24/25 */
-#define CSR_GP_REG_NO_POWER_SAVE            (0x00000000)
-#define CSR_GP_REG_MAC_POWER_SAVE           (0x01000000)
-#define CSR_GP_REG_PHY_POWER_SAVE           (0x02000000)
-#define CSR_GP_REG_POWER_SAVE_ERROR         (0x03000000)
-
-/* CSR GIO */
-#define CSR_GIO_REG_VAL_L0S_ENABLED    (0x00000002)
-
-/*
- * UCODE-DRIVER GP (general purpose) mailbox register 1
- * Host driver and uCode write and/or read this register to communicate with
- * each other.
- * Bit fields:
- *     4:  UCODE_DISABLE
- *         Host sets this to request permanent halt of uCode, same as
- *         sending CARD_STATE command with "halt" bit set.
- *     3:  CT_KILL_EXIT
- *         Host sets this to request exit from CT_KILL state, i.e. host thinks
- *         device temperature is low enough to continue normal operation.
- *     2:  CMD_BLOCKED
- *         Host sets this during RF KILL power-down sequence (HW, SW, CT KILL)
- *         to release uCode to clear all Tx and command queues, enter
- *         unassociated mode, and power down.
- *         NOTE:  Some devices also use HBUS_TARG_MBX_C register for this bit.
- *     1:  SW_BIT_RFKILL
- *         Host sets this when issuing CARD_STATE command to request
- *         device sleep.
- *     0:  MAC_SLEEP
- *         uCode sets this when preparing a power-saving power-down.
- *         uCode resets this when power-up is complete and SRAM is sane.
- *         NOTE:  3945/4965 saves internal SRAM data to host when powering down,
- *                and must restore this data after powering back up.
- *                MAC_SLEEP is the best indication that restore is complete.
- *                Later devices (5xxx/6xxx/1xxx) use non-volatile SRAM, and
- *                do not need to save/restore it.
- */
-#define CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP             (0x00000001)
-#define CSR_UCODE_SW_BIT_RFKILL                     (0x00000002)
-#define CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED           (0x00000004)
-#define CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT      (0x00000008)
-
-/* GIO Chicken Bits (PCI Express bus link power management) */
-#define CSR_GIO_CHICKEN_BITS_REG_BIT_L1A_NO_L0S_RX  (0x00800000)
-#define CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER  (0x20000000)
-
-/* LED */
-#define CSR_LED_BSM_CTRL_MSK (0xFFFFFFDF)
-#define CSR_LED_REG_TRUN_ON (0x78)
-#define CSR_LED_REG_TRUN_OFF (0x38)
-
-/* ANA_PLL */
-#define CSR39_ANA_PLL_CFG_VAL        (0x01000000)
-
-/* HPET MEM debug */
-#define CSR_DBG_HPET_MEM_REG_VAL       (0xFFFF0000)
-
-/* DRAM INT TBL */
-#define CSR_DRAM_INT_TBL_ENABLE                (1 << 31)
-#define CSR_DRAM_INIT_TBL_WRAP_CHECK   (1 << 27)
-
-/*
- * HBUS (Host-side Bus)
- *
- * HBUS registers are mapped directly into PCI bus space, but are used
- * to indirectly access device's internal memory or registers that
- * may be powered-down.
- *
- * Use il_wr()/il_rd() family
- * for these registers;
- * host must "grab nic access" via CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
- * to make sure the MAC (uCode processor, etc.) is powered up for accessing
- * internal resources.
- *
- * Do not use _il_wr()/_il_rd() family to access these registers;
- * these provide only simple PCI bus access, without waking up the MAC.
- */
-#define HBUS_BASE      (0x400)
-
-/*
- * Registers for accessing device's internal SRAM memory (e.g. SCD SRAM
- * structures, error log, event log, verifying uCode load).
- * First write to address register, then read from or write to data register
- * to complete the job.  Once the address register is set up, accesses to
- * data registers auto-increment the address by one dword.
- * Bit usage for address registers (read or write):
- *  0-31:  memory address within device
- */
-#define HBUS_TARG_MEM_RADDR     (HBUS_BASE+0x00c)
-#define HBUS_TARG_MEM_WADDR     (HBUS_BASE+0x010)
-#define HBUS_TARG_MEM_WDAT      (HBUS_BASE+0x018)
-#define HBUS_TARG_MEM_RDAT      (HBUS_BASE+0x01c)
-
-/* Mailbox C, used as workaround alternative to CSR_UCODE_DRV_GP1 mailbox */
-#define HBUS_TARG_MBX_C         (HBUS_BASE+0x030)
-#define HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED         (0x00000004)
-
-/*
- * Registers for accessing device's internal peripheral registers
- * (e.g. SCD, BSM, etc.).  First write to address register,
- * then read from or write to data register to complete the job.
- * Bit usage for address registers (read or write):
- *  0-15:  register address (offset) within device
- * 24-25:  (# bytes - 1) to read or write (e.g. 3 for dword)
- */
-#define HBUS_TARG_PRPH_WADDR    (HBUS_BASE+0x044)
-#define HBUS_TARG_PRPH_RADDR    (HBUS_BASE+0x048)
-#define HBUS_TARG_PRPH_WDAT     (HBUS_BASE+0x04c)
-#define HBUS_TARG_PRPH_RDAT     (HBUS_BASE+0x050)
-
-/*
- * Per-Tx-queue write pointer (idx, really!)
- * Indicates idx to next TFD that driver will fill (1 past latest filled).
- * Bit usage:
- *  0-7:  queue write idx
- * 11-8:  queue selector
- */
-#define HBUS_TARG_WRPTR         (HBUS_BASE+0x060)
-
-#endif /* !__il_csr_h__ */
diff --git a/drivers/net/wireless/iwlegacy/debug.c b/drivers/net/wireless/iwlegacy/debug.c
deleted file mode 100644 (file)
index 908b9f4..0000000
+++ /dev/null
@@ -1,1426 +0,0 @@
-/******************************************************************************
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *****************************************************************************/
-#include <linux/ieee80211.h>
-#include <linux/export.h>
-#include <net/mac80211.h>
-
-#include "common.h"
-
-static void
-il_clear_traffic_stats(struct il_priv *il)
-{
-       memset(&il->tx_stats, 0, sizeof(struct traffic_stats));
-       memset(&il->rx_stats, 0, sizeof(struct traffic_stats));
-}
-
-/*
- * il_update_stats function record all the MGMT, CTRL and DATA pkt for
- * both TX and Rx . Use debugfs to display the rx/rx_stats
- */
-void
-il_update_stats(struct il_priv *il, bool is_tx, __le16 fc, u16 len)
-{
-       struct traffic_stats *stats;
-
-       if (is_tx)
-               stats = &il->tx_stats;
-       else
-               stats = &il->rx_stats;
-
-       if (ieee80211_is_mgmt(fc)) {
-               switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
-               case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
-                       stats->mgmt[MANAGEMENT_ASSOC_REQ]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
-                       stats->mgmt[MANAGEMENT_ASSOC_RESP]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
-                       stats->mgmt[MANAGEMENT_REASSOC_REQ]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
-                       stats->mgmt[MANAGEMENT_REASSOC_RESP]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
-                       stats->mgmt[MANAGEMENT_PROBE_REQ]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
-                       stats->mgmt[MANAGEMENT_PROBE_RESP]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_BEACON):
-                       stats->mgmt[MANAGEMENT_BEACON]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_ATIM):
-                       stats->mgmt[MANAGEMENT_ATIM]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
-                       stats->mgmt[MANAGEMENT_DISASSOC]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_AUTH):
-                       stats->mgmt[MANAGEMENT_AUTH]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
-                       stats->mgmt[MANAGEMENT_DEAUTH]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_ACTION):
-                       stats->mgmt[MANAGEMENT_ACTION]++;
-                       break;
-               }
-       } else if (ieee80211_is_ctl(fc)) {
-               switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
-               case cpu_to_le16(IEEE80211_STYPE_BACK_REQ):
-                       stats->ctrl[CONTROL_BACK_REQ]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_BACK):
-                       stats->ctrl[CONTROL_BACK]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_PSPOLL):
-                       stats->ctrl[CONTROL_PSPOLL]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_RTS):
-                       stats->ctrl[CONTROL_RTS]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_CTS):
-                       stats->ctrl[CONTROL_CTS]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_ACK):
-                       stats->ctrl[CONTROL_ACK]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_CFEND):
-                       stats->ctrl[CONTROL_CFEND]++;
-                       break;
-               case cpu_to_le16(IEEE80211_STYPE_CFENDACK):
-                       stats->ctrl[CONTROL_CFENDACK]++;
-                       break;
-               }
-       } else {
-               /* data */
-               stats->data_cnt++;
-               stats->data_bytes += len;
-       }
-}
-EXPORT_SYMBOL(il_update_stats);
-
-/* create and remove of files */
-#define DEBUGFS_ADD_FILE(name, parent, mode) do {                      \
-       if (!debugfs_create_file(#name, mode, parent, il,               \
-                        &il_dbgfs_##name##_ops))               \
-               goto err;                                               \
-} while (0)
-
-#define DEBUGFS_ADD_BOOL(name, parent, ptr) do {                       \
-       struct dentry *__tmp;                                           \
-       __tmp = debugfs_create_bool(#name, S_IWUSR | S_IRUSR,           \
-                                   parent, ptr);                       \
-       if (IS_ERR(__tmp) || !__tmp)                                    \
-               goto err;                                               \
-} while (0)
-
-#define DEBUGFS_ADD_X32(name, parent, ptr) do {                                \
-       struct dentry *__tmp;                                           \
-       __tmp = debugfs_create_x32(#name, S_IWUSR | S_IRUSR,            \
-                                  parent, ptr);                        \
-       if (IS_ERR(__tmp) || !__tmp)                                    \
-               goto err;                                               \
-} while (0)
-
-/* file operation */
-#define DEBUGFS_READ_FUNC(name)                                         \
-static ssize_t il_dbgfs_##name##_read(struct file *file,               \
-                                       char __user *user_buf,          \
-                                       size_t count, loff_t *ppos);
-
-#define DEBUGFS_WRITE_FUNC(name)                                        \
-static ssize_t il_dbgfs_##name##_write(struct file *file,              \
-                                       const char __user *user_buf,    \
-                                       size_t count, loff_t *ppos);
-
-
-#define DEBUGFS_READ_FILE_OPS(name)                            \
-       DEBUGFS_READ_FUNC(name);                                \
-static const struct file_operations il_dbgfs_##name##_ops = {  \
-       .read = il_dbgfs_##name##_read,                         \
-       .open = simple_open,                                    \
-       .llseek = generic_file_llseek,                          \
-};
-
-#define DEBUGFS_WRITE_FILE_OPS(name)                           \
-       DEBUGFS_WRITE_FUNC(name);                               \
-static const struct file_operations il_dbgfs_##name##_ops = {  \
-       .write = il_dbgfs_##name##_write,                       \
-       .open = simple_open,                                    \
-       .llseek = generic_file_llseek,                          \
-};
-
-#define DEBUGFS_READ_WRITE_FILE_OPS(name)                      \
-       DEBUGFS_READ_FUNC(name);                                \
-       DEBUGFS_WRITE_FUNC(name);                               \
-static const struct file_operations il_dbgfs_##name##_ops = {  \
-       .write = il_dbgfs_##name##_write,                       \
-       .read = il_dbgfs_##name##_read,                         \
-       .open = simple_open,                                    \
-       .llseek = generic_file_llseek,                          \
-};
-
-static const char *
-il_get_mgmt_string(int cmd)
-{
-       switch (cmd) {
-       IL_CMD(MANAGEMENT_ASSOC_REQ);
-       IL_CMD(MANAGEMENT_ASSOC_RESP);
-       IL_CMD(MANAGEMENT_REASSOC_REQ);
-       IL_CMD(MANAGEMENT_REASSOC_RESP);
-       IL_CMD(MANAGEMENT_PROBE_REQ);
-       IL_CMD(MANAGEMENT_PROBE_RESP);
-       IL_CMD(MANAGEMENT_BEACON);
-       IL_CMD(MANAGEMENT_ATIM);
-       IL_CMD(MANAGEMENT_DISASSOC);
-       IL_CMD(MANAGEMENT_AUTH);
-       IL_CMD(MANAGEMENT_DEAUTH);
-       IL_CMD(MANAGEMENT_ACTION);
-       default:
-               return "UNKNOWN";
-
-       }
-}
-
-static const char *
-il_get_ctrl_string(int cmd)
-{
-       switch (cmd) {
-       IL_CMD(CONTROL_BACK_REQ);
-       IL_CMD(CONTROL_BACK);
-       IL_CMD(CONTROL_PSPOLL);
-       IL_CMD(CONTROL_RTS);
-       IL_CMD(CONTROL_CTS);
-       IL_CMD(CONTROL_ACK);
-       IL_CMD(CONTROL_CFEND);
-       IL_CMD(CONTROL_CFENDACK);
-       default:
-               return "UNKNOWN";
-
-       }
-}
-
-static ssize_t
-il_dbgfs_tx_stats_read(struct file *file, char __user *user_buf, size_t count,
-                      loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       char *buf;
-       int pos = 0;
-
-       int cnt;
-       ssize_t ret;
-       const size_t bufsz =
-           100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX);
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf)
-               return -ENOMEM;
-       pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
-       for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
-                             il_get_mgmt_string(cnt), il->tx_stats.mgmt[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "Control\n");
-       for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
-                             il_get_ctrl_string(cnt), il->tx_stats.ctrl[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
-                     il->tx_stats.data_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
-                     il->tx_stats.data_bytes);
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_clear_traffic_stats_write(struct file *file,
-                                  const char __user *user_buf, size_t count,
-                                  loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       u32 clear_flag;
-       char buf[8];
-       int buf_size;
-
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-       if (sscanf(buf, "%x", &clear_flag) != 1)
-               return -EFAULT;
-       il_clear_traffic_stats(il);
-
-       return count;
-}
-
-static ssize_t
-il_dbgfs_rx_stats_read(struct file *file, char __user *user_buf, size_t count,
-                      loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       char *buf;
-       int pos = 0;
-       int cnt;
-       ssize_t ret;
-       const size_t bufsz =
-           100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX);
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf)
-               return -ENOMEM;
-
-       pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
-       for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
-                             il_get_mgmt_string(cnt), il->rx_stats.mgmt[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "Control:\n");
-       for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
-                             il_get_ctrl_string(cnt), il->rx_stats.ctrl[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
-                     il->rx_stats.data_cnt);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
-                     il->rx_stats.data_bytes);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-#define BYTE1_MASK 0x000000ff;
-#define BYTE2_MASK 0x0000ffff;
-#define BYTE3_MASK 0x00ffffff;
-static ssize_t
-il_dbgfs_sram_read(struct file *file, char __user *user_buf, size_t count,
-                  loff_t *ppos)
-{
-       u32 val;
-       char *buf;
-       ssize_t ret;
-       int i;
-       int pos = 0;
-       struct il_priv *il = file->private_data;
-       size_t bufsz;
-
-       /* default is to dump the entire data segment */
-       if (!il->dbgfs_sram_offset && !il->dbgfs_sram_len) {
-               il->dbgfs_sram_offset = 0x800000;
-               if (il->ucode_type == UCODE_INIT)
-                       il->dbgfs_sram_len = il->ucode_init_data.len;
-               else
-                       il->dbgfs_sram_len = il->ucode_data.len;
-       }
-       bufsz = 30 + il->dbgfs_sram_len * sizeof(char) * 10;
-       buf = kmalloc(bufsz, GFP_KERNEL);
-       if (!buf)
-               return -ENOMEM;
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "sram_len: 0x%x\n",
-                     il->dbgfs_sram_len);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "sram_offset: 0x%x\n",
-                     il->dbgfs_sram_offset);
-       for (i = il->dbgfs_sram_len; i > 0; i -= 4) {
-               val =
-                   il_read_targ_mem(il,
-                                    il->dbgfs_sram_offset +
-                                    il->dbgfs_sram_len - i);
-               if (i < 4) {
-                       switch (i) {
-                       case 1:
-                               val &= BYTE1_MASK;
-                               break;
-                       case 2:
-                               val &= BYTE2_MASK;
-                               break;
-                       case 3:
-                               val &= BYTE3_MASK;
-                               break;
-                       }
-               }
-               if (!(i % 16))
-                       pos += scnprintf(buf + pos, bufsz - pos, "\n");
-               pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "\n");
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_sram_write(struct file *file, const char __user *user_buf,
-                   size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char buf[64];
-       int buf_size;
-       u32 offset, len;
-
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-
-       if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
-               il->dbgfs_sram_offset = offset;
-               il->dbgfs_sram_len = len;
-       } else {
-               il->dbgfs_sram_offset = 0;
-               il->dbgfs_sram_len = 0;
-       }
-
-       return count;
-}
-
-static ssize_t
-il_dbgfs_stations_read(struct file *file, char __user *user_buf, size_t count,
-                      loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       struct il_station_entry *station;
-       int max_sta = il->hw_params.max_stations;
-       char *buf;
-       int i, j, pos = 0;
-       ssize_t ret;
-       /* Add 30 for initial string */
-       const size_t bufsz = 30 + sizeof(char) * 500 * (il->num_stations);
-
-       buf = kmalloc(bufsz, GFP_KERNEL);
-       if (!buf)
-               return -ENOMEM;
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
-                     il->num_stations);
-
-       for (i = 0; i < max_sta; i++) {
-               station = &il->stations[i];
-               if (!station->used)
-                       continue;
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "station %d - addr: %pM, flags: %#x\n", i,
-                             station->sta.sta.addr,
-                             station->sta.station_flags_msk);
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "TID\tseq_num\ttxq_id\tframes\ttfds\t");
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "start_idx\tbitmap\t\t\trate_n_flags\n");
-
-               for (j = 0; j < MAX_TID_COUNT; j++) {
-                       pos +=
-                           scnprintf(buf + pos, bufsz - pos,
-                                     "%d:\t%#x\t%#x\t%u\t%u\t%u\t\t%#.16llx\t%#x",
-                                     j, station->tid[j].seq_number,
-                                     station->tid[j].agg.txq_id,
-                                     station->tid[j].agg.frame_count,
-                                     station->tid[j].tfds_in_queue,
-                                     station->tid[j].agg.start_idx,
-                                     station->tid[j].agg.bitmap,
-                                     station->tid[j].agg.rate_n_flags);
-
-                       if (station->tid[j].agg.wait_for_ba)
-                               pos +=
-                                   scnprintf(buf + pos, bufsz - pos,
-                                             " - waitforba");
-                       pos += scnprintf(buf + pos, bufsz - pos, "\n");
-               }
-
-               pos += scnprintf(buf + pos, bufsz - pos, "\n");
-       }
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_nvm_read(struct file *file, char __user *user_buf, size_t count,
-                 loff_t *ppos)
-{
-       ssize_t ret;
-       struct il_priv *il = file->private_data;
-       int pos = 0, ofs = 0, buf_size = 0;
-       const u8 *ptr;
-       char *buf;
-       u16 eeprom_ver;
-       size_t eeprom_len = il->cfg->eeprom_size;
-       buf_size = 4 * eeprom_len + 256;
-
-       if (eeprom_len % 16) {
-               IL_ERR("NVM size is not multiple of 16.\n");
-               return -ENODATA;
-       }
-
-       ptr = il->eeprom;
-       if (!ptr) {
-               IL_ERR("Invalid EEPROM memory\n");
-               return -ENOMEM;
-       }
-
-       /* 4 characters for byte 0xYY */
-       buf = kzalloc(buf_size, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-       eeprom_ver = il_eeprom_query16(il, EEPROM_VERSION);
-       pos +=
-           scnprintf(buf + pos, buf_size - pos, "EEPROM " "version: 0x%x\n",
-                     eeprom_ver);
-       for (ofs = 0; ofs < eeprom_len; ofs += 16) {
-               pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x %16ph\n",
-                                ofs, ptr + ofs);
-       }
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_channels_read(struct file *file, char __user *user_buf, size_t count,
-                      loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       struct ieee80211_channel *channels = NULL;
-       const struct ieee80211_supported_band *supp_band = NULL;
-       int pos = 0, i, bufsz = PAGE_SIZE;
-       char *buf;
-       ssize_t ret;
-
-       if (!test_bit(S_GEO_CONFIGURED, &il->status))
-               return -EAGAIN;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       supp_band = il_get_hw_mode(il, IEEE80211_BAND_2GHZ);
-       if (supp_band) {
-               channels = supp_band->channels;
-
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "Displaying %d channels in 2.4GHz band 802.11bg):\n",
-                             supp_band->n_channels);
-
-               for (i = 0; i < supp_band->n_channels; i++)
-                       pos +=
-                           scnprintf(buf + pos, bufsz - pos,
-                                     "%d: %ddBm: BSS%s%s, %s.\n",
-                                     channels[i].hw_value,
-                                     channels[i].max_power,
-                                     channels[i].
-                                     flags & IEEE80211_CHAN_RADAR ?
-                                     " (IEEE 802.11h required)" : "",
-                                     ((channels[i].
-                                       flags & IEEE80211_CHAN_NO_IR) ||
-                                      (channels[i].
-                                       flags & IEEE80211_CHAN_RADAR)) ? "" :
-                                     ", IBSS",
-                                     channels[i].
-                                     flags & IEEE80211_CHAN_NO_IR ?
-                                     "passive only" : "active/passive");
-       }
-       supp_band = il_get_hw_mode(il, IEEE80211_BAND_5GHZ);
-       if (supp_band) {
-               channels = supp_band->channels;
-
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "Displaying %d channels in 5.2GHz band (802.11a)\n",
-                             supp_band->n_channels);
-
-               for (i = 0; i < supp_band->n_channels; i++)
-                       pos +=
-                           scnprintf(buf + pos, bufsz - pos,
-                                     "%d: %ddBm: BSS%s%s, %s.\n",
-                                     channels[i].hw_value,
-                                     channels[i].max_power,
-                                     channels[i].
-                                     flags & IEEE80211_CHAN_RADAR ?
-                                     " (IEEE 802.11h required)" : "",
-                                     ((channels[i].
-                                       flags & IEEE80211_CHAN_NO_IR) ||
-                                      (channels[i].
-                                       flags & IEEE80211_CHAN_RADAR)) ? "" :
-                                     ", IBSS",
-                                     channels[i].
-                                     flags & IEEE80211_CHAN_NO_IR ?
-                                     "passive only" : "active/passive");
-       }
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_status_read(struct file *file, char __user *user_buf, size_t count,
-                    loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       char buf[512];
-       int pos = 0;
-       const size_t bufsz = sizeof(buf);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_HCMD_ACTIVE:\t %d\n",
-                     test_bit(S_HCMD_ACTIVE, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_INT_ENABLED:\t %d\n",
-                     test_bit(S_INT_ENABLED, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_RFKILL:\t %d\n",
-                     test_bit(S_RFKILL, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_CT_KILL:\t\t %d\n",
-                     test_bit(S_CT_KILL, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_INIT:\t\t %d\n",
-                     test_bit(S_INIT, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_ALIVE:\t\t %d\n",
-                     test_bit(S_ALIVE, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_READY:\t\t %d\n",
-                     test_bit(S_READY, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_TEMPERATURE:\t %d\n",
-                     test_bit(S_TEMPERATURE, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_GEO_CONFIGURED:\t %d\n",
-                     test_bit(S_GEO_CONFIGURED, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_EXIT_PENDING:\t %d\n",
-                     test_bit(S_EXIT_PENDING, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_STATS:\t %d\n",
-                     test_bit(S_STATS, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_SCANNING:\t %d\n",
-                     test_bit(S_SCANNING, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_SCAN_ABORTING:\t %d\n",
-                     test_bit(S_SCAN_ABORTING, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_SCAN_HW:\t\t %d\n",
-                     test_bit(S_SCAN_HW, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_POWER_PMI:\t %d\n",
-                     test_bit(S_POWER_PMI, &il->status));
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "S_FW_ERROR:\t %d\n",
-                     test_bit(S_FW_ERROR, &il->status));
-       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-}
-
-static ssize_t
-il_dbgfs_interrupt_read(struct file *file, char __user *user_buf, size_t count,
-                       loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       int cnt = 0;
-       char *buf;
-       int bufsz = 24 * 64;    /* 24 items * 64 char per item */
-       ssize_t ret;
-
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "Interrupt Statistics Report:\n");
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "HW Error:\t\t\t %u\n",
-                     il->isr_stats.hw);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "SW Error:\t\t\t %u\n",
-                     il->isr_stats.sw);
-       if (il->isr_stats.sw || il->isr_stats.hw) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "\tLast Restarting Code:  0x%X\n",
-                             il->isr_stats.err_code);
-       }
-#ifdef CONFIG_IWLEGACY_DEBUG
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "Frame transmitted:\t\t %u\n",
-                     il->isr_stats.sch);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "Alive interrupt:\t\t %u\n",
-                     il->isr_stats.alive);
-#endif
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "HW RF KILL switch toggled:\t %u\n",
-                     il->isr_stats.rfkill);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "CT KILL:\t\t\t %u\n",
-                     il->isr_stats.ctkill);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "Wakeup Interrupt:\t\t %u\n",
-                     il->isr_stats.wakeup);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "Rx command responses:\t\t %u\n",
-                     il->isr_stats.rx);
-       for (cnt = 0; cnt < IL_CN_MAX; cnt++) {
-               if (il->isr_stats.handlers[cnt] > 0)
-                       pos +=
-                           scnprintf(buf + pos, bufsz - pos,
-                                     "\tRx handler[%36s]:\t\t %u\n",
-                                     il_get_cmd_string(cnt),
-                                     il->isr_stats.handlers[cnt]);
-       }
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "Tx/FH interrupt:\t\t %u\n",
-                     il->isr_stats.tx);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "Unexpected INTA:\t\t %u\n",
-                     il->isr_stats.unhandled);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_interrupt_write(struct file *file, const char __user *user_buf,
-                        size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char buf[8];
-       int buf_size;
-       u32 reset_flag;
-
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-       if (sscanf(buf, "%x", &reset_flag) != 1)
-               return -EFAULT;
-       if (reset_flag == 0)
-               il_clear_isr_stats(il);
-
-       return count;
-}
-
-static ssize_t
-il_dbgfs_qos_read(struct file *file, char __user *user_buf, size_t count,
-                 loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       int pos = 0, i;
-       char buf[256];
-       const size_t bufsz = sizeof(buf);
-
-       for (i = 0; i < AC_NUM; i++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "\tcw_min\tcw_max\taifsn\ttxop\n");
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "AC[%d]\t%u\t%u\t%u\t%u\n", i,
-                             il->qos_data.def_qos_parm.ac[i].cw_min,
-                             il->qos_data.def_qos_parm.ac[i].cw_max,
-                             il->qos_data.def_qos_parm.ac[i].aifsn,
-                             il->qos_data.def_qos_parm.ac[i].edca_txop);
-       }
-
-       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-}
-
-static ssize_t
-il_dbgfs_disable_ht40_write(struct file *file, const char __user *user_buf,
-                           size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char buf[8];
-       int buf_size;
-       int ht40;
-
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-       if (sscanf(buf, "%d", &ht40) != 1)
-               return -EFAULT;
-       if (!il_is_any_associated(il))
-               il->disable_ht40 = ht40 ? true : false;
-       else {
-               IL_ERR("Sta associated with AP - "
-                      "Change to 40MHz channel support is not allowed\n");
-               return -EINVAL;
-       }
-
-       return count;
-}
-
-static ssize_t
-il_dbgfs_disable_ht40_read(struct file *file, char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char buf[100];
-       int pos = 0;
-       const size_t bufsz = sizeof(buf);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "11n 40MHz Mode: %s\n",
-                     il->disable_ht40 ? "Disabled" : "Enabled");
-       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-}
-
-DEBUGFS_READ_WRITE_FILE_OPS(sram);
-DEBUGFS_READ_FILE_OPS(nvm);
-DEBUGFS_READ_FILE_OPS(stations);
-DEBUGFS_READ_FILE_OPS(channels);
-DEBUGFS_READ_FILE_OPS(status);
-DEBUGFS_READ_WRITE_FILE_OPS(interrupt);
-DEBUGFS_READ_FILE_OPS(qos);
-DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40);
-
-static ssize_t
-il_dbgfs_tx_queue_read(struct file *file, char __user *user_buf, size_t count,
-                      loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       struct il_tx_queue *txq;
-       struct il_queue *q;
-       char *buf;
-       int pos = 0;
-       int cnt;
-       int ret;
-       const size_t bufsz =
-           sizeof(char) * 64 * il->cfg->num_of_queues;
-
-       if (!il->txq) {
-               IL_ERR("txq not ready\n");
-               return -EAGAIN;
-       }
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf)
-               return -ENOMEM;
-
-       for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
-               txq = &il->txq[cnt];
-               q = &txq->q;
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "hwq %.2d: read=%u write=%u stop=%d"
-                             " swq_id=%#.2x (ac %d/hwq %d)\n", cnt,
-                             q->read_ptr, q->write_ptr,
-                             !!test_bit(cnt, il->queue_stopped),
-                             txq->swq_id, txq->swq_id & 3,
-                             (txq->swq_id >> 2) & 0x1f);
-               if (cnt >= 4)
-                       continue;
-               /* for the ACs, display the stop count too */
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "        stop-count: %d\n",
-                             atomic_read(&il->queue_stop_count[cnt]));
-       }
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_rx_queue_read(struct file *file, char __user *user_buf, size_t count,
-                      loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       struct il_rx_queue *rxq = &il->rxq;
-       char buf[256];
-       int pos = 0;
-       const size_t bufsz = sizeof(buf);
-
-       pos += scnprintf(buf + pos, bufsz - pos, "read: %u\n", rxq->read);
-       pos += scnprintf(buf + pos, bufsz - pos, "write: %u\n", rxq->write);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "free_count: %u\n",
-                     rxq->free_count);
-       if (rxq->rb_stts) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, "closed_rb_num: %u\n",
-                             le16_to_cpu(rxq->rb_stts->
-                                         closed_rb_num) & 0x0FFF);
-       } else {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos,
-                             "closed_rb_num: Not Allocated\n");
-       }
-       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-}
-
-static ssize_t
-il_dbgfs_ucode_rx_stats_read(struct file *file, char __user *user_buf,
-                            size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-
-       return il->debugfs_ops->rx_stats_read(file, user_buf, count, ppos);
-}
-
-static ssize_t
-il_dbgfs_ucode_tx_stats_read(struct file *file, char __user *user_buf,
-                            size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-
-       return il->debugfs_ops->tx_stats_read(file, user_buf, count, ppos);
-}
-
-static ssize_t
-il_dbgfs_ucode_general_stats_read(struct file *file, char __user *user_buf,
-                                 size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-
-       return il->debugfs_ops->general_stats_read(file, user_buf, count, ppos);
-}
-
-static ssize_t
-il_dbgfs_sensitivity_read(struct file *file, char __user *user_buf,
-                         size_t count, loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       int cnt = 0;
-       char *buf;
-       int bufsz = sizeof(struct il_sensitivity_data) * 4 + 100;
-       ssize_t ret;
-       struct il_sensitivity_data *data;
-
-       data = &il->sensitivity_data;
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm:\t\t\t %u\n",
-                     data->auto_corr_ofdm);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc:\t\t %u\n",
-                     data->auto_corr_ofdm_mrc);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_x1:\t\t %u\n",
-                     data->auto_corr_ofdm_x1);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc_x1:\t\t %u\n",
-                     data->auto_corr_ofdm_mrc_x1);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "auto_corr_cck:\t\t\t %u\n",
-                     data->auto_corr_cck);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "auto_corr_cck_mrc:\t\t %u\n",
-                     data->auto_corr_cck_mrc);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "last_bad_plcp_cnt_ofdm:\t\t %u\n",
-                     data->last_bad_plcp_cnt_ofdm);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_ofdm:\t\t %u\n",
-                     data->last_fa_cnt_ofdm);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "last_bad_plcp_cnt_cck:\t\t %u\n",
-                     data->last_bad_plcp_cnt_cck);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_cck:\t\t %u\n",
-                     data->last_fa_cnt_cck);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "nrg_curr_state:\t\t\t %u\n",
-                     data->nrg_curr_state);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "nrg_prev_state:\t\t\t %u\n",
-                     data->nrg_prev_state);
-       pos += scnprintf(buf + pos, bufsz - pos, "nrg_value:\t\t\t");
-       for (cnt = 0; cnt < 10; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, " %u",
-                             data->nrg_value[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "\n");
-       pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_rssi:\t\t");
-       for (cnt = 0; cnt < NRG_NUM_PREV_STAT_L; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, " %u",
-                             data->nrg_silence_rssi[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "\n");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "nrg_silence_ref:\t\t %u\n",
-                     data->nrg_silence_ref);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "nrg_energy_idx:\t\t\t %u\n",
-                     data->nrg_energy_idx);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "nrg_silence_idx:\t\t %u\n",
-                     data->nrg_silence_idx);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "nrg_th_cck:\t\t\t %u\n",
-                     data->nrg_th_cck);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "nrg_auto_corr_silence_diff:\t %u\n",
-                     data->nrg_auto_corr_silence_diff);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "num_in_cck_no_fa:\t\t %u\n",
-                     data->num_in_cck_no_fa);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "nrg_th_ofdm:\t\t\t %u\n",
-                     data->nrg_th_ofdm);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_chain_noise_read(struct file *file, char __user *user_buf,
-                         size_t count, loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       int cnt = 0;
-       char *buf;
-       int bufsz = sizeof(struct il_chain_noise_data) * 4 + 100;
-       ssize_t ret;
-       struct il_chain_noise_data *data;
-
-       data = &il->chain_noise_data;
-       buf = kzalloc(bufsz, GFP_KERNEL);
-       if (!buf) {
-               IL_ERR("Can not allocate Buffer\n");
-               return -ENOMEM;
-       }
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "active_chains:\t\t\t %u\n",
-                     data->active_chains);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "chain_noise_a:\t\t\t %u\n",
-                     data->chain_noise_a);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "chain_noise_b:\t\t\t %u\n",
-                     data->chain_noise_b);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "chain_noise_c:\t\t\t %u\n",
-                     data->chain_noise_c);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "chain_signal_a:\t\t\t %u\n",
-                     data->chain_signal_a);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "chain_signal_b:\t\t\t %u\n",
-                     data->chain_signal_b);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "chain_signal_c:\t\t\t %u\n",
-                     data->chain_signal_c);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "beacon_count:\t\t\t %u\n",
-                     data->beacon_count);
-
-       pos += scnprintf(buf + pos, bufsz - pos, "disconn_array:\t\t\t");
-       for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, " %u",
-                             data->disconn_array[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "\n");
-       pos += scnprintf(buf + pos, bufsz - pos, "delta_gain_code:\t\t");
-       for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
-               pos +=
-                   scnprintf(buf + pos, bufsz - pos, " %u",
-                             data->delta_gain_code[cnt]);
-       }
-       pos += scnprintf(buf + pos, bufsz - pos, "\n");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "radio_write:\t\t\t %u\n",
-                     data->radio_write);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "state:\t\t\t\t %u\n",
-                     data->state);
-
-       ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-       kfree(buf);
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_power_save_status_read(struct file *file, char __user *user_buf,
-                               size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char buf[60];
-       int pos = 0;
-       const size_t bufsz = sizeof(buf);
-       u32 pwrsave_status;
-
-       pwrsave_status =
-           _il_rd(il, CSR_GP_CNTRL) & CSR_GP_REG_POWER_SAVE_STATUS_MSK;
-
-       pos += scnprintf(buf + pos, bufsz - pos, "Power Save Status: ");
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "%s\n",
-                     (pwrsave_status == CSR_GP_REG_NO_POWER_SAVE) ? "none" :
-                     (pwrsave_status == CSR_GP_REG_MAC_POWER_SAVE) ? "MAC" :
-                     (pwrsave_status == CSR_GP_REG_PHY_POWER_SAVE) ? "PHY" :
-                     "error");
-
-       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-}
-
-static ssize_t
-il_dbgfs_clear_ucode_stats_write(struct file *file,
-                                const char __user *user_buf, size_t count,
-                                loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char buf[8];
-       int buf_size;
-       int clear;
-
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-       if (sscanf(buf, "%d", &clear) != 1)
-               return -EFAULT;
-
-       /* make request to uCode to retrieve stats information */
-       mutex_lock(&il->mutex);
-       il_send_stats_request(il, CMD_SYNC, true);
-       mutex_unlock(&il->mutex);
-
-       return count;
-}
-
-static ssize_t
-il_dbgfs_rxon_flags_read(struct file *file, char __user *user_buf,
-                        size_t count, loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       int len = 0;
-       char buf[20];
-
-       len = sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.flags));
-       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
-}
-
-static ssize_t
-il_dbgfs_rxon_filter_flags_read(struct file *file, char __user *user_buf,
-                               size_t count, loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       int len = 0;
-       char buf[20];
-
-       len =
-           sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.filter_flags));
-       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
-}
-
-static ssize_t
-il_dbgfs_fh_reg_read(struct file *file, char __user *user_buf, size_t count,
-                    loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char *buf;
-       int pos = 0;
-       ssize_t ret = -EFAULT;
-
-       if (il->ops->dump_fh) {
-               ret = pos = il->ops->dump_fh(il, &buf, true);
-               if (buf) {
-                       ret =
-                           simple_read_from_buffer(user_buf, count, ppos, buf,
-                                                   pos);
-                       kfree(buf);
-               }
-       }
-
-       return ret;
-}
-
-static ssize_t
-il_dbgfs_missed_beacon_read(struct file *file, char __user *user_buf,
-                           size_t count, loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char buf[12];
-       const size_t bufsz = sizeof(buf);
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "%d\n",
-                     il->missed_beacon_threshold);
-
-       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-}
-
-static ssize_t
-il_dbgfs_missed_beacon_write(struct file *file, const char __user *user_buf,
-                            size_t count, loff_t *ppos)
-{
-       struct il_priv *il = file->private_data;
-       char buf[8];
-       int buf_size;
-       int missed;
-
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-       if (sscanf(buf, "%d", &missed) != 1)
-               return -EINVAL;
-
-       if (missed < IL_MISSED_BEACON_THRESHOLD_MIN ||
-           missed > IL_MISSED_BEACON_THRESHOLD_MAX)
-               il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
-       else
-               il->missed_beacon_threshold = missed;
-
-       return count;
-}
-
-static ssize_t
-il_dbgfs_force_reset_read(struct file *file, char __user *user_buf,
-                         size_t count, loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       int pos = 0;
-       char buf[300];
-       const size_t bufsz = sizeof(buf);
-       struct il_force_reset *force_reset;
-
-       force_reset = &il->force_reset;
-
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "\tnumber of reset request: %d\n",
-                     force_reset->reset_request_count);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "\tnumber of reset request success: %d\n",
-                     force_reset->reset_success_count);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos,
-                     "\tnumber of reset request reject: %d\n",
-                     force_reset->reset_reject_count);
-       pos +=
-           scnprintf(buf + pos, bufsz - pos, "\treset duration: %lu\n",
-                     force_reset->reset_duration);
-
-       return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
-}
-
-static ssize_t
-il_dbgfs_force_reset_write(struct file *file, const char __user *user_buf,
-                          size_t count, loff_t *ppos)
-{
-
-       int ret;
-       struct il_priv *il = file->private_data;
-
-       ret = il_force_reset(il, true);
-
-       return ret ? ret : count;
-}
-
-static ssize_t
-il_dbgfs_wd_timeout_write(struct file *file, const char __user *user_buf,
-                         size_t count, loff_t *ppos)
-{
-
-       struct il_priv *il = file->private_data;
-       char buf[8];
-       int buf_size;
-       int timeout;
-
-       memset(buf, 0, sizeof(buf));
-       buf_size = min(count, sizeof(buf) - 1);
-       if (copy_from_user(buf, user_buf, buf_size))
-               return -EFAULT;
-       if (sscanf(buf, "%d", &timeout) != 1)
-               return -EINVAL;
-       if (timeout < 0 || timeout > IL_MAX_WD_TIMEOUT)
-               timeout = IL_DEF_WD_TIMEOUT;
-
-       il->cfg->wd_timeout = timeout;
-       il_setup_watchdog(il);
-       return count;
-}
-
-DEBUGFS_READ_FILE_OPS(rx_stats);
-DEBUGFS_READ_FILE_OPS(tx_stats);
-DEBUGFS_READ_FILE_OPS(rx_queue);
-DEBUGFS_READ_FILE_OPS(tx_queue);
-DEBUGFS_READ_FILE_OPS(ucode_rx_stats);
-DEBUGFS_READ_FILE_OPS(ucode_tx_stats);
-DEBUGFS_READ_FILE_OPS(ucode_general_stats);
-DEBUGFS_READ_FILE_OPS(sensitivity);
-DEBUGFS_READ_FILE_OPS(chain_noise);
-DEBUGFS_READ_FILE_OPS(power_save_status);
-DEBUGFS_WRITE_FILE_OPS(clear_ucode_stats);
-DEBUGFS_WRITE_FILE_OPS(clear_traffic_stats);
-DEBUGFS_READ_FILE_OPS(fh_reg);
-DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon);
-DEBUGFS_READ_WRITE_FILE_OPS(force_reset);
-DEBUGFS_READ_FILE_OPS(rxon_flags);
-DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
-DEBUGFS_WRITE_FILE_OPS(wd_timeout);
-
-/*
- * Create the debugfs files and directories
- *
- */
-int
-il_dbgfs_register(struct il_priv *il, const char *name)
-{
-       struct dentry *phyd = il->hw->wiphy->debugfsdir;
-       struct dentry *dir_drv, *dir_data, *dir_rf, *dir_debug;
-
-       dir_drv = debugfs_create_dir(name, phyd);
-       if (!dir_drv)
-               return -ENOMEM;
-
-       il->debugfs_dir = dir_drv;
-
-       dir_data = debugfs_create_dir("data", dir_drv);
-       if (!dir_data)
-               goto err;
-       dir_rf = debugfs_create_dir("rf", dir_drv);
-       if (!dir_rf)
-               goto err;
-       dir_debug = debugfs_create_dir("debug", dir_drv);
-       if (!dir_debug)
-               goto err;
-
-       DEBUGFS_ADD_FILE(nvm, dir_data, S_IRUSR);
-       DEBUGFS_ADD_FILE(sram, dir_data, S_IWUSR | S_IRUSR);
-       DEBUGFS_ADD_FILE(stations, dir_data, S_IRUSR);
-       DEBUGFS_ADD_FILE(channels, dir_data, S_IRUSR);
-       DEBUGFS_ADD_FILE(status, dir_data, S_IRUSR);
-       DEBUGFS_ADD_FILE(interrupt, dir_data, S_IWUSR | S_IRUSR);
-       DEBUGFS_ADD_FILE(qos, dir_data, S_IRUSR);
-       DEBUGFS_ADD_FILE(disable_ht40, dir_data, S_IWUSR | S_IRUSR);
-       DEBUGFS_ADD_FILE(rx_stats, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(tx_stats, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(rx_queue, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(tx_queue, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(power_save_status, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(clear_ucode_stats, dir_debug, S_IWUSR);
-       DEBUGFS_ADD_FILE(clear_traffic_stats, dir_debug, S_IWUSR);
-       DEBUGFS_ADD_FILE(fh_reg, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(missed_beacon, dir_debug, S_IWUSR);
-       DEBUGFS_ADD_FILE(force_reset, dir_debug, S_IWUSR | S_IRUSR);
-       DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(ucode_general_stats, dir_debug, S_IRUSR);
-
-       if (il->cfg->sensitivity_calib_by_driver)
-               DEBUGFS_ADD_FILE(sensitivity, dir_debug, S_IRUSR);
-       if (il->cfg->chain_noise_calib_by_driver)
-               DEBUGFS_ADD_FILE(chain_noise, dir_debug, S_IRUSR);
-       DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR);
-       DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR);
-       DEBUGFS_ADD_FILE(wd_timeout, dir_debug, S_IWUSR);
-       if (il->cfg->sensitivity_calib_by_driver)
-               DEBUGFS_ADD_BOOL(disable_sensitivity, dir_rf,
-                                &il->disable_sens_cal);
-       if (il->cfg->chain_noise_calib_by_driver)
-               DEBUGFS_ADD_BOOL(disable_chain_noise, dir_rf,
-                                &il->disable_chain_noise_cal);
-       DEBUGFS_ADD_BOOL(disable_tx_power, dir_rf, &il->disable_tx_power_cal);
-       return 0;
-
-err:
-       IL_ERR("Can't create the debugfs directory\n");
-       il_dbgfs_unregister(il);
-       return -ENOMEM;
-}
-EXPORT_SYMBOL(il_dbgfs_register);
-
-/**
- * Remove the debugfs files and directories
- *
- */
-void
-il_dbgfs_unregister(struct il_priv *il)
-{
-       if (!il->debugfs_dir)
-               return;
-
-       debugfs_remove_recursive(il->debugfs_dir);
-       il->debugfs_dir = NULL;
-}
-EXPORT_SYMBOL(il_dbgfs_unregister);
diff --git a/drivers/net/wireless/iwlegacy/iwl-spectrum.h b/drivers/net/wireless/iwlegacy/iwl-spectrum.h
deleted file mode 100644 (file)
index 85fe48e..0000000
+++ /dev/null
@@ -1,92 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * Portions of this file are derived from the ieee80211 subsystem header files.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#ifndef __il_spectrum_h__
-#define __il_spectrum_h__
-enum {                         /* ieee80211_basic_report.map */
-       IEEE80211_BASIC_MAP_BSS = (1 << 0),
-       IEEE80211_BASIC_MAP_OFDM = (1 << 1),
-       IEEE80211_BASIC_MAP_UNIDENTIFIED = (1 << 2),
-       IEEE80211_BASIC_MAP_RADAR = (1 << 3),
-       IEEE80211_BASIC_MAP_UNMEASURED = (1 << 4),
-       /* Bits 5-7 are reserved */
-
-};
-struct ieee80211_basic_report {
-       u8 channel;
-       __le64 start_time;
-       __le16 duration;
-       u8 map;
-} __packed;
-
-enum {                         /* ieee80211_measurement_request.mode */
-       /* Bit 0 is reserved */
-       IEEE80211_MEASUREMENT_ENABLE = (1 << 1),
-       IEEE80211_MEASUREMENT_REQUEST = (1 << 2),
-       IEEE80211_MEASUREMENT_REPORT = (1 << 3),
-       /* Bits 4-7 are reserved */
-};
-
-enum {
-       IEEE80211_REPORT_BASIC = 0,     /* required */
-       IEEE80211_REPORT_CCA = 1,       /* optional */
-       IEEE80211_REPORT_RPI = 2,       /* optional */
-       /* 3-255 reserved */
-};
-
-struct ieee80211_measurement_params {
-       u8 channel;
-       __le64 start_time;
-       __le16 duration;
-} __packed;
-
-struct ieee80211_info_element {
-       u8 id;
-       u8 len;
-       u8 data[0];
-} __packed;
-
-struct ieee80211_measurement_request {
-       struct ieee80211_info_element ie;
-       u8 token;
-       u8 mode;
-       u8 type;
-       struct ieee80211_measurement_params params[0];
-} __packed;
-
-struct ieee80211_measurement_report {
-       struct ieee80211_info_element ie;
-       u8 token;
-       u8 mode;
-       u8 type;
-       union {
-               struct ieee80211_basic_report basic[0];
-       } u;
-} __packed;
-
-#endif
diff --git a/drivers/net/wireless/iwlegacy/prph.h b/drivers/net/wireless/iwlegacy/prph.h
deleted file mode 100644 (file)
index ffec4b4..0000000
+++ /dev/null
@@ -1,522 +0,0 @@
-/******************************************************************************
- *
- * This file is provided under a dual BSD/GPLv2 license.  When using or
- * redistributing this file, you may do so under either license.
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
- * USA
- *
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- * BSD LICENSE
- *
- * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *  * Neither the name Intel Corporation nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-#ifndef        __il_prph_h__
-#define __il_prph_h__
-
-/*
- * Registers in this file are internal, not PCI bus memory mapped.
- * Driver accesses these via HBUS_TARG_PRPH_* registers.
- */
-#define PRPH_BASE      (0x00000)
-#define PRPH_END       (0xFFFFF)
-
-/* APMG (power management) constants */
-#define APMG_BASE                      (PRPH_BASE + 0x3000)
-#define APMG_CLK_CTRL_REG              (APMG_BASE + 0x0000)
-#define APMG_CLK_EN_REG                        (APMG_BASE + 0x0004)
-#define APMG_CLK_DIS_REG               (APMG_BASE + 0x0008)
-#define APMG_PS_CTRL_REG               (APMG_BASE + 0x000c)
-#define APMG_PCIDEV_STT_REG            (APMG_BASE + 0x0010)
-#define APMG_RFKILL_REG                        (APMG_BASE + 0x0014)
-#define APMG_RTC_INT_STT_REG           (APMG_BASE + 0x001c)
-#define APMG_RTC_INT_MSK_REG           (APMG_BASE + 0x0020)
-#define APMG_DIGITAL_SVR_REG           (APMG_BASE + 0x0058)
-#define APMG_ANALOG_SVR_REG            (APMG_BASE + 0x006C)
-
-#define APMS_CLK_VAL_MRB_FUNC_MODE     (0x00000001)
-#define APMG_CLK_VAL_DMA_CLK_RQT       (0x00000200)
-#define APMG_CLK_VAL_BSM_CLK_RQT       (0x00000800)
-
-#define APMG_PS_CTRL_EARLY_PWR_OFF_RESET_DIS   (0x00400000)
-#define APMG_PS_CTRL_VAL_RESET_REQ             (0x04000000)
-#define APMG_PS_CTRL_MSK_PWR_SRC               (0x03000000)
-#define APMG_PS_CTRL_VAL_PWR_SRC_VMAIN         (0x00000000)
-#define APMG_PS_CTRL_VAL_PWR_SRC_MAX           (0x01000000)    /* 3945 only */
-#define APMG_PS_CTRL_VAL_PWR_SRC_VAUX          (0x02000000)
-#define APMG_SVR_VOLTAGE_CONFIG_BIT_MSK        (0x000001E0)    /* bit 8:5 */
-#define APMG_SVR_DIGITAL_VOLTAGE_1_32          (0x00000060)
-
-#define APMG_PCIDEV_STT_VAL_L1_ACT_DIS         (0x00000800)
-
-/**
- * BSM (Bootstrap State Machine)
- *
- * The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
- * in special SRAM that does not power down when the embedded control
- * processor is sleeping (e.g. for periodic power-saving shutdowns of radio).
- *
- * When powering back up after sleeps (or during initial uCode load), the BSM
- * internally loads the short bootstrap program from the special SRAM into the
- * embedded processor's instruction SRAM, and starts the processor so it runs
- * the bootstrap program.
- *
- * This bootstrap program loads (via PCI busmaster DMA) instructions and data
- * images for a uCode program from host DRAM locations.  The host driver
- * indicates DRAM locations and sizes for instruction and data images via the
- * four BSM_DRAM_* registers.  Once the bootstrap program loads the new program,
- * the new program starts automatically.
- *
- * The uCode used for open-source drivers includes two programs:
- *
- * 1)  Initialization -- performs hardware calibration and sets up some
- *     internal data, then notifies host via "initialize alive" notification
- *     (struct il_init_alive_resp) that it has completed all of its work.
- *     After signal from host, it then loads and starts the runtime program.
- *     The initialization program must be used when initially setting up the
- *     NIC after loading the driver.
- *
- * 2)  Runtime/Protocol -- performs all normal runtime operations.  This
- *     notifies host via "alive" notification (struct il_alive_resp) that it
- *     is ready to be used.
- *
- * When initializing the NIC, the host driver does the following procedure:
- *
- * 1)  Load bootstrap program (instructions only, no data image for bootstrap)
- *     into bootstrap memory.  Use dword writes starting at BSM_SRAM_LOWER_BOUND
- *
- * 2)  Point (via BSM_DRAM_*) to the "initialize" uCode data and instruction
- *     images in host DRAM.
- *
- * 3)  Set up BSM to copy from BSM SRAM into uCode instruction SRAM when asked:
- *     BSM_WR_MEM_SRC_REG = 0
- *     BSM_WR_MEM_DST_REG = RTC_INST_LOWER_BOUND
- *     BSM_WR_MEM_DWCOUNT_REG = # dwords in bootstrap instruction image
- *
- * 4)  Load bootstrap into instruction SRAM:
- *     BSM_WR_CTRL_REG = BSM_WR_CTRL_REG_BIT_START
- *
- * 5)  Wait for load completion:
- *     Poll BSM_WR_CTRL_REG for BSM_WR_CTRL_REG_BIT_START = 0
- *
- * 6)  Enable future boot loads whenever NIC's power management triggers it:
- *     BSM_WR_CTRL_REG = BSM_WR_CTRL_REG_BIT_START_EN
- *
- * 7)  Start the NIC by removing all reset bits:
- *     CSR_RESET = 0
- *
- *     The bootstrap uCode (already in instruction SRAM) loads initialization
- *     uCode.  Initialization uCode performs data initialization, sends
- *     "initialize alive" notification to host, and waits for a signal from
- *     host to load runtime code.
- *
- * 4)  Point (via BSM_DRAM_*) to the "runtime" uCode data and instruction
- *     images in host DRAM.  The last register loaded must be the instruction
- *     byte count register ("1" in MSbit tells initialization uCode to load
- *     the runtime uCode):
- *     BSM_DRAM_INST_BYTECOUNT_REG = byte count | BSM_DRAM_INST_LOAD
- *
- * 5)  Wait for "alive" notification, then issue normal runtime commands.
- *
- * Data caching during power-downs:
- *
- * Just before the embedded controller powers down (e.g for automatic
- * power-saving modes, or for RFKILL), uCode stores (via PCI busmaster DMA)
- * a current snapshot of the embedded processor's data SRAM into host DRAM.
- * This caches the data while the embedded processor's memory is powered down.
- * Location and size are controlled by BSM_DRAM_DATA_* registers.
- *
- * NOTE:  Instruction SRAM does not need to be saved, since that doesn't
- *        change during operation; the original image (from uCode distribution
- *        file) can be used for reload.
- *
- * When powering back up, the BSM loads the bootstrap program.  Bootstrap looks
- * at the BSM_DRAM_* registers, which now point to the runtime instruction
- * image and the cached (modified) runtime data (*not* the initialization
- * uCode).  Bootstrap reloads these runtime images into SRAM, and restarts the
- * uCode from where it left off before the power-down.
- *
- * NOTE:  Initialization uCode does *not* run as part of the save/restore
- *        procedure.
- *
- * This save/restore method is mostly for autonomous power management during
- * normal operation (result of C_POWER_TBL).  Platform suspend/resume and
- * RFKILL should use complete restarts (with total re-initialization) of uCode,
- * allowing total shutdown (including BSM memory).
- *
- * Note that, during normal operation, the host DRAM that held the initial
- * startup data for the runtime code is now being used as a backup data cache
- * for modified data!  If you need to completely re-initialize the NIC, make
- * sure that you use the runtime data image from the uCode distribution file,
- * not the modified/saved runtime data.  You may want to store a separate
- * "clean" runtime data image in DRAM to avoid disk reads of distribution file.
- */
-
-/* BSM bit fields */
-#define BSM_WR_CTRL_REG_BIT_START     (0x80000000)     /* start boot load now */
-#define BSM_WR_CTRL_REG_BIT_START_EN  (0x40000000)     /* enable boot after pwrup */
-#define BSM_DRAM_INST_LOAD            (0x80000000)     /* start program load now */
-
-/* BSM addresses */
-#define BSM_BASE                     (PRPH_BASE + 0x3400)
-#define BSM_END                      (PRPH_BASE + 0x3800)
-
-#define BSM_WR_CTRL_REG              (BSM_BASE + 0x000)        /* ctl and status */
-#define BSM_WR_MEM_SRC_REG           (BSM_BASE + 0x004)        /* source in BSM mem */
-#define BSM_WR_MEM_DST_REG           (BSM_BASE + 0x008)        /* dest in SRAM mem */
-#define BSM_WR_DWCOUNT_REG           (BSM_BASE + 0x00C)        /* bytes */
-#define BSM_WR_STATUS_REG            (BSM_BASE + 0x010)        /* bit 0:  1 == done */
-
-/*
- * Pointers and size regs for bootstrap load and data SRAM save/restore.
- * NOTE:  3945 pointers use bits 31:0 of DRAM address.
- *        4965 pointers use bits 35:4 of DRAM address.
- */
-#define BSM_DRAM_INST_PTR_REG        (BSM_BASE + 0x090)
-#define BSM_DRAM_INST_BYTECOUNT_REG  (BSM_BASE + 0x094)
-#define BSM_DRAM_DATA_PTR_REG        (BSM_BASE + 0x098)
-#define BSM_DRAM_DATA_BYTECOUNT_REG  (BSM_BASE + 0x09C)
-
-/*
- * BSM special memory, stays powered on during power-save sleeps.
- * Read/write, address range from LOWER_BOUND to (LOWER_BOUND + SIZE -1)
- */
-#define BSM_SRAM_LOWER_BOUND         (PRPH_BASE + 0x3800)
-#define BSM_SRAM_SIZE                  (1024)  /* bytes */
-
-/* 3945 Tx scheduler registers */
-#define ALM_SCD_BASE                        (PRPH_BASE + 0x2E00)
-#define ALM_SCD_MODE_REG                    (ALM_SCD_BASE + 0x000)
-#define ALM_SCD_ARASTAT_REG                 (ALM_SCD_BASE + 0x004)
-#define ALM_SCD_TXFACT_REG                  (ALM_SCD_BASE + 0x010)
-#define ALM_SCD_TXF4MF_REG                  (ALM_SCD_BASE + 0x014)
-#define ALM_SCD_TXF5MF_REG                  (ALM_SCD_BASE + 0x020)
-#define ALM_SCD_SBYP_MODE_1_REG             (ALM_SCD_BASE + 0x02C)
-#define ALM_SCD_SBYP_MODE_2_REG             (ALM_SCD_BASE + 0x030)
-
-/**
- * Tx Scheduler
- *
- * The Tx Scheduler selects the next frame to be transmitted, choosing TFDs
- * (Transmit Frame Descriptors) from up to 16 circular Tx queues resident in
- * host DRAM.  It steers each frame's Tx command (which contains the frame
- * data) into one of up to 7 prioritized Tx DMA FIFO channels within the
- * device.  A queue maps to only one (selectable by driver) Tx DMA channel,
- * but one DMA channel may take input from several queues.
- *
- * Tx DMA FIFOs have dedicated purposes.  For 4965, they are used as follows
- * (cf. default_queue_to_tx_fifo in 4965.c):
- *
- * 0 -- EDCA BK (background) frames, lowest priority
- * 1 -- EDCA BE (best effort) frames, normal priority
- * 2 -- EDCA VI (video) frames, higher priority
- * 3 -- EDCA VO (voice) and management frames, highest priority
- * 4 -- Commands (e.g. RXON, etc.)
- * 5 -- unused (HCCA)
- * 6 -- unused (HCCA)
- * 7 -- not used by driver (device-internal only)
- *
- *
- * Driver should normally map queues 0-6 to Tx DMA/FIFO channels 0-6.
- * In addition, driver can map the remaining queues to Tx DMA/FIFO
- * channels 0-3 to support 11n aggregation via EDCA DMA channels.
- *
- * The driver sets up each queue to work in one of two modes:
- *
- * 1)  Scheduler-Ack, in which the scheduler automatically supports a
- *     block-ack (BA) win of up to 64 TFDs.  In this mode, each queue
- *     contains TFDs for a unique combination of Recipient Address (RA)
- *     and Traffic Identifier (TID), that is, traffic of a given
- *     Quality-Of-Service (QOS) priority, destined for a single station.
- *
- *     In scheduler-ack mode, the scheduler keeps track of the Tx status of
- *     each frame within the BA win, including whether it's been transmitted,
- *     and whether it's been acknowledged by the receiving station.  The device
- *     automatically processes block-acks received from the receiving STA,
- *     and reschedules un-acked frames to be retransmitted (successful
- *     Tx completion may end up being out-of-order).
- *
- *     The driver must maintain the queue's Byte Count table in host DRAM
- *     (struct il4965_sched_queue_byte_cnt_tbl) for this mode.
- *     This mode does not support fragmentation.
- *
- * 2)  FIFO (a.k.a. non-Scheduler-ACK), in which each TFD is processed in order.
- *     The device may automatically retry Tx, but will retry only one frame
- *     at a time, until receiving ACK from receiving station, or reaching
- *     retry limit and giving up.
- *
- *     The command queue (#4/#9) must use this mode!
- *     This mode does not require use of the Byte Count table in host DRAM.
- *
- * Driver controls scheduler operation via 3 means:
- * 1)  Scheduler registers
- * 2)  Shared scheduler data base in internal 4956 SRAM
- * 3)  Shared data in host DRAM
- *
- * Initialization:
- *
- * When loading, driver should allocate memory for:
- * 1)  16 TFD circular buffers, each with space for (typically) 256 TFDs.
- * 2)  16 Byte Count circular buffers in 16 KBytes contiguous memory
- *     (1024 bytes for each queue).
- *
- * After receiving "Alive" response from uCode, driver must initialize
- * the scheduler (especially for queue #4/#9, the command queue, otherwise
- * the driver can't issue commands!):
- */
-
-/**
- * Max Tx win size is the max number of contiguous TFDs that the scheduler
- * can keep track of at one time when creating block-ack chains of frames.
- * Note that "64" matches the number of ack bits in a block-ack packet.
- * Driver should use SCD_WIN_SIZE and SCD_FRAME_LIMIT values to initialize
- * IL49_SCD_CONTEXT_QUEUE_OFFSET(x) values.
- */
-#define SCD_WIN_SIZE                           64
-#define SCD_FRAME_LIMIT                                64
-
-/* SCD registers are internal, must be accessed via HBUS_TARG_PRPH regs */
-#define IL49_SCD_START_OFFSET          0xa02c00
-
-/*
- * 4965 tells driver SRAM address for internal scheduler structs via this reg.
- * Value is valid only after "Alive" response from uCode.
- */
-#define IL49_SCD_SRAM_BASE_ADDR           (IL49_SCD_START_OFFSET + 0x0)
-
-/*
- * Driver may need to update queue-empty bits after changing queue's
- * write and read pointers (idxes) during (re-)initialization (i.e. when
- * scheduler is not tracking what's happening).
- * Bit fields:
- * 31-16:  Write mask -- 1: update empty bit, 0: don't change empty bit
- * 15-00:  Empty state, one for each queue -- 1: empty, 0: non-empty
- * NOTE:  This register is not used by Linux driver.
- */
-#define IL49_SCD_EMPTY_BITS               (IL49_SCD_START_OFFSET + 0x4)
-
-/*
- * Physical base address of array of byte count (BC) circular buffers (CBs).
- * Each Tx queue has a BC CB in host DRAM to support Scheduler-ACK mode.
- * This register points to BC CB for queue 0, must be on 1024-byte boundary.
- * Others are spaced by 1024 bytes.
- * Each BC CB is 2 bytes * (256 + 64) = 740 bytes, followed by 384 bytes pad.
- * (Index into a queue's BC CB) = (idx into queue's TFD CB) = (SSN & 0xff).
- * Bit fields:
- * 25-00:  Byte Count CB physical address [35:10], must be 1024-byte aligned.
- */
-#define IL49_SCD_DRAM_BASE_ADDR           (IL49_SCD_START_OFFSET + 0x10)
-
-/*
- * Enables any/all Tx DMA/FIFO channels.
- * Scheduler generates requests for only the active channels.
- * Set this to 0xff to enable all 8 channels (normal usage).
- * Bit fields:
- *  7- 0:  Enable (1), disable (0), one bit for each channel 0-7
- */
-#define IL49_SCD_TXFACT                   (IL49_SCD_START_OFFSET + 0x1c)
-/*
- * Queue (x) Write Pointers (idxes, really!), one for each Tx queue.
- * Initialized and updated by driver as new TFDs are added to queue.
- * NOTE:  If using Block Ack, idx must correspond to frame's
- *        Start Sequence Number; idx = (SSN & 0xff)
- * NOTE:  Alternative to HBUS_TARG_WRPTR, which is what Linux driver uses?
- */
-#define IL49_SCD_QUEUE_WRPTR(x)  (IL49_SCD_START_OFFSET + 0x24 + (x) * 4)
-
-/*
- * Queue (x) Read Pointers (idxes, really!), one for each Tx queue.
- * For FIFO mode, idx indicates next frame to transmit.
- * For Scheduler-ACK mode, idx indicates first frame in Tx win.
- * Initialized by driver, updated by scheduler.
- */
-#define IL49_SCD_QUEUE_RDPTR(x)  (IL49_SCD_START_OFFSET + 0x64 + (x) * 4)
-
-/*
- * Select which queues work in chain mode (1) vs. not (0).
- * Use chain mode to build chains of aggregated frames.
- * Bit fields:
- * 31-16:  Reserved
- * 15-00:  Mode, one bit for each queue -- 1: Chain mode, 0: one-at-a-time
- * NOTE:  If driver sets up queue for chain mode, it should be also set up
- *        Scheduler-ACK mode as well, via SCD_QUEUE_STATUS_BITS(x).
- */
-#define IL49_SCD_QUEUECHAIN_SEL  (IL49_SCD_START_OFFSET + 0xd0)
-
-/*
- * Select which queues interrupt driver when scheduler increments
- * a queue's read pointer (idx).
- * Bit fields:
- * 31-16:  Reserved
- * 15-00:  Interrupt enable, one bit for each queue -- 1: enabled, 0: disabled
- * NOTE:  This functionality is apparently a no-op; driver relies on interrupts
- *        from Rx queue to read Tx command responses and update Tx queues.
- */
-#define IL49_SCD_INTERRUPT_MASK  (IL49_SCD_START_OFFSET + 0xe4)
-
-/*
- * Queue search status registers.  One for each queue.
- * Sets up queue mode and assigns queue to Tx DMA channel.
- * Bit fields:
- * 19-10: Write mask/enable bits for bits 0-9
- *     9: Driver should init to "0"
- *     8: Scheduler-ACK mode (1), non-Scheduler-ACK (i.e. FIFO) mode (0).
- *        Driver should init to "1" for aggregation mode, or "0" otherwise.
- *   7-6: Driver should init to "0"
- *     5: Window Size Left; indicates whether scheduler can request
- *        another TFD, based on win size, etc.  Driver should init
- *        this bit to "1" for aggregation mode, or "0" for non-agg.
- *   4-1: Tx FIFO to use (range 0-7).
- *     0: Queue is active (1), not active (0).
- * Other bits should be written as "0"
- *
- * NOTE:  If enabling Scheduler-ACK mode, chain mode should also be enabled
- *        via SCD_QUEUECHAIN_SEL.
- */
-#define IL49_SCD_QUEUE_STATUS_BITS(x)\
-       (IL49_SCD_START_OFFSET + 0x104 + (x) * 4)
-
-/* Bit field positions */
-#define IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE     (0)
-#define IL49_SCD_QUEUE_STTS_REG_POS_TXF        (1)
-#define IL49_SCD_QUEUE_STTS_REG_POS_WSL        (5)
-#define IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACK    (8)
-
-/* Write masks */
-#define IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN (10)
-#define IL49_SCD_QUEUE_STTS_REG_MSK            (0x0007FC00)
-
-/**
- * 4965 internal SRAM structures for scheduler, shared with driver ...
- *
- * Driver should clear and initialize the following areas after receiving
- * "Alive" response from 4965 uCode, i.e. after initial
- * uCode load, or after a uCode load done for error recovery:
- *
- * SCD_CONTEXT_DATA_OFFSET (size 128 bytes)
- * SCD_TX_STTS_BITMAP_OFFSET (size 256 bytes)
- * SCD_TRANSLATE_TBL_OFFSET (size 32 bytes)
- *
- * Driver accesses SRAM via HBUS_TARG_MEM_* registers.
- * Driver reads base address of this scheduler area from SCD_SRAM_BASE_ADDR.
- * All OFFSET values must be added to this base address.
- */
-
-/*
- * Queue context.  One 8-byte entry for each of 16 queues.
- *
- * Driver should clear this entire area (size 0x80) to 0 after receiving
- * "Alive" notification from uCode.  Additionally, driver should init
- * each queue's entry as follows:
- *
- * LS Dword bit fields:
- *  0-06:  Max Tx win size for Scheduler-ACK.  Driver should init to 64.
- *
- * MS Dword bit fields:
- * 16-22:  Frame limit.  Driver should init to 10 (0xa).
- *
- * Driver should init all other bits to 0.
- *
- * Init must be done after driver receives "Alive" response from 4965 uCode,
- * and when setting up queue for aggregation.
- */
-#define IL49_SCD_CONTEXT_DATA_OFFSET                   0x380
-#define IL49_SCD_CONTEXT_QUEUE_OFFSET(x) \
-                       (IL49_SCD_CONTEXT_DATA_OFFSET + ((x) * 8))
-
-#define IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS           (0)
-#define IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK           (0x0000007F)
-#define IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS        (16)
-#define IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK        (0x007F0000)
-
-/*
- * Tx Status Bitmap
- *
- * Driver should clear this entire area (size 0x100) to 0 after receiving
- * "Alive" notification from uCode.  Area is used only by device itself;
- * no other support (besides clearing) is required from driver.
- */
-#define IL49_SCD_TX_STTS_BITMAP_OFFSET         0x400
-
-/*
- * RAxTID to queue translation mapping.
- *
- * When queue is in Scheduler-ACK mode, frames placed in a that queue must be
- * for only one combination of receiver address (RA) and traffic ID (TID), i.e.
- * one QOS priority level destined for one station (for this wireless link,
- * not final destination).  The SCD_TRANSLATE_TBL area provides 16 16-bit
- * mappings, one for each of the 16 queues.  If queue is not in Scheduler-ACK
- * mode, the device ignores the mapping value.
- *
- * Bit fields, for each 16-bit map:
- * 15-9:  Reserved, set to 0
- *  8-4:  Index into device's station table for recipient station
- *  3-0:  Traffic ID (tid), range 0-15
- *
- * Driver should clear this entire area (size 32 bytes) to 0 after receiving
- * "Alive" notification from uCode.  To update a 16-bit map value, driver
- * must read a dword-aligned value from device SRAM, replace the 16-bit map
- * value of interest, and write the dword value back into device SRAM.
- */
-#define IL49_SCD_TRANSLATE_TBL_OFFSET          0x500
-
-/* Find translation table dword to read/write for given queue */
-#define IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(x) \
-       ((IL49_SCD_TRANSLATE_TBL_OFFSET + ((x) * 2)) & 0xfffffffc)
-
-#define IL_SCD_TXFIFO_POS_TID                  (0)
-#define IL_SCD_TXFIFO_POS_RA                   (4)
-#define IL_SCD_QUEUE_RA_TID_MAP_RATID_MSK      (0x01FF)
-
-/*********************** END TX SCHEDULER *************************************/
-
-#endif /* __il_prph_h__ */