1 files changed, 163 insertions, 153 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-calib.c b/drivers/net/wireless/iwlwifi/iwl-agn-calib.c
index c4c5691032a6..c9255def1080 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-calib.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-calib.c
@@ -5,7 +5,7 @@
  *
  * GPL LICENSE SUMMARY
  *
- * Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.
+ * 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
@@ -30,7 +30,7 @@
  *
  * BSD LICENSE
  *
- * Copyright(c) 2005 - 2010 Intel Corporation. All rights reserved.
+ * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -65,7 +65,7 @@
 
 #include "iwl-dev.h"
 #include "iwl-core.h"
-#include "iwl-calib.h"
+#include "iwl-agn-calib.h"
 
 /*****************************************************************************
  * INIT calibrations framework
@@ -87,14 +87,14 @@ int iwl_send_calib_results(struct iwl_priv *priv)
 
         struct iwl_host_cmd hcmd = {
                 .id = REPLY_PHY_CALIBRATION_CMD,
-                .flags = CMD_SIZE_HUGE,
         };
 
         for (i = 0; i < IWL_CALIB_MAX; i++) {
                 if ((BIT(i) & priv->hw_params.calib_init_cfg) &&
                     priv->calib_results[i].buf) {
-                        hcmd.len = priv->calib_results[i].buf_len;
-                        hcmd.data = priv->calib_results[i].buf;
+                        hcmd.len[0] = priv->calib_results[i].buf_len;
+                        hcmd.data[0] = priv->calib_results[i].buf;
+                        hcmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
                         ret = iwl_send_cmd_sync(priv, &hcmd);
                         if (ret) {
                                 IWL_ERR(priv, "Error %d iteration %d\n",
@@ -456,9 +456,9 @@ static int iwl_sensitivity_write(struct iwl_priv *priv)
         struct iwl_sensitivity_data *data = NULL;
         struct iwl_host_cmd cmd_out = {
                 .id = SENSITIVITY_CMD,
-                .len = sizeof(struct iwl_sensitivity_cmd),
+                .len = { sizeof(struct iwl_sensitivity_cmd), },
                 .flags = CMD_ASYNC,
-                .data = &cmd,
+                .data = { &cmd, },
         };
 
         data = &(priv->sensitivity_data);
@@ -491,9 +491,9 @@ static int iwl_enhance_sensitivity_write(struct iwl_priv *priv)
         struct iwl_sensitivity_data *data = NULL;
         struct iwl_host_cmd cmd_out = {
                 .id = SENSITIVITY_CMD,
-                .len = sizeof(struct iwl_enhance_sensitivity_cmd),
+                .len = { sizeof(struct iwl_enhance_sensitivity_cmd), },
                 .flags = CMD_ASYNC,
-                .data = &cmd,
+                .data = { &cmd, },
         };
 
         data = &(priv->sensitivity_data);
@@ -605,7 +605,7 @@ void iwl_init_sensitivity(struct iwl_priv *priv)
         IWL_DEBUG_CALIB(priv, "<<return 0x%X\n", ret);
 }
 
-void iwl_sensitivity_calibration(struct iwl_priv *priv, void *resp)
+void iwl_sensitivity_calibration(struct iwl_priv *priv)
 {
         u32 rx_enable_time;
         u32 fa_cck;
@@ -625,22 +625,15 @@ void iwl_sensitivity_calibration(struct iwl_priv *priv, void *resp)
 
         data = &(priv->sensitivity_data);
 
-        if (!iwl_is_associated(priv)) {
+        if (!iwl_is_any_associated(priv)) {
                 IWL_DEBUG_CALIB(priv, "<< - not associated\n");
                 return;
         }
 
         spin_lock_irqsave(&priv->lock, flags);
-        if (priv->cfg->bt_statistics) {
-                rx_info = &(((struct iwl_bt_notif_statistics *)resp)->
-                              rx.general.common);
-                ofdm = &(((struct iwl_bt_notif_statistics *)resp)->rx.ofdm);
-                cck = &(((struct iwl_bt_notif_statistics *)resp)->rx.cck);
-        } else {
-                rx_info = &(((struct iwl_notif_statistics *)resp)->rx.general);
-                ofdm = &(((struct iwl_notif_statistics *)resp)->rx.ofdm);
-                cck = &(((struct iwl_notif_statistics *)resp)->rx.cck);
-        }
+        rx_info = &priv->statistics.rx_non_phy;
+        ofdm = &priv->statistics.rx_ofdm;
+        cck = &priv->statistics.rx_cck;
         if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
                 IWL_DEBUG_CALIB(priv, "<< invalid data.\n");
                 spin_unlock_irqrestore(&priv->lock, flags);
@@ -731,13 +724,127 @@ static inline u8 find_first_chain(u8 mask)
         return CHAIN_C;
 }
 
+/**
+ * Run disconnected antenna algorithm to find out which antennas are
+ * disconnected.
+ */
+static void iwl_find_disconn_antenna(struct iwl_priv *priv, u32* average_sig,
+                                     struct iwl_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 /
+                         priv->cfg->base_params->chain_noise_num_beacons;
+        average_sig[1] = data->chain_signal_b /
+                         priv->cfg->base_params->chain_noise_num_beacons;
+        average_sig[2] = data->chain_signal_c /
+                         priv->cfg->base_params->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);
+        }
+
+        IWL_DEBUG_CALIB(priv, "average_sig: a %d b %d c %d\n",
+                     average_sig[0], average_sig[1], average_sig[2]);
+        IWL_DEBUG_CALIB(priv, "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);
+                        IWL_DEBUG_CALIB(priv, "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 &= priv->hw_params.valid_rx_ant;
+
+        num_tx_chains = 0;
+        for (i = 0; i < NUM_RX_CHAINS; i++) {
+                /* loops on all the bits of
+                 * priv->hw_setting.valid_tx_ant */
+                u8 ant_msk = (1 << i);
+                if (!(priv->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 == priv->hw_params.tx_chains_num &&
+                    data->disconn_array[i]) {
+                        /*
+                         * If all chains are disconnected
+                         * connect the first valid tx chain
+                         */
+                        first_chain =
+                                find_first_chain(priv->cfg->valid_tx_ant);
+                        data->disconn_array[first_chain] = 0;
+                        active_chains |= BIT(first_chain);
+                        IWL_DEBUG_CALIB(priv,
+                                        "All Tx chains are disconnected W/A - declare %d as connected\n",
+                                        first_chain);
+                        break;
+                }
+        }
+
+        if (active_chains != priv->hw_params.valid_rx_ant &&
+            active_chains != priv->chain_noise_data.active_chains)
+                IWL_DEBUG_CALIB(priv,
+                                "Detected that not all antennas are connected! "
+                                "Connected: %#x, valid: %#x.\n",
+                                active_chains, priv->hw_params.valid_rx_ant);
+
+        /* Save for use within RXON, TX, SCAN commands, etc. */
+        data->active_chains = active_chains;
+        IWL_DEBUG_CALIB(priv, "active_chains (bitwise) = 0x%x\n",
+                        active_chains);
+}
+
+
 /*
- * Accumulate 20 beacons of signal and noise statistics for each of
+ * Accumulate 16 beacons of signal and noise statistics 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 iwl_chain_noise_calibration(struct iwl_priv *priv, void *stat_resp)
+void iwl_chain_noise_calibration(struct iwl_priv *priv)
 {
         struct iwl_chain_noise_data *data = NULL;
 
@@ -749,8 +856,6 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv, void *stat_resp)
         u32 chain_sig_c;
         u32 average_sig[NUM_RX_CHAINS] = {INITIALIZATION_VALUE};
         u32 average_noise[NUM_RX_CHAINS] = {INITIALIZATION_VALUE};
-        u32 max_average_sig;
-        u16 max_average_sig_antenna_i;
         u32 min_average_noise = MIN_AVERAGE_NOISE_MAX_VALUE;
         u16 min_average_noise_antenna_i = INITIALIZATION_VALUE;
         u16 i = 0;
@@ -758,11 +863,15 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv, void *stat_resp)
         u16 stat_chnum = INITIALIZATION_VALUE;
         u8 rxon_band24;
         u8 stat_band24;
-        u32 active_chains = 0;
-        u8 num_tx_chains;
         unsigned long flags;
         struct statistics_rx_non_phy *rx_info;
-        u8 first_chain;
+
+        /*
+         * MULTI-FIXME:
+         * When we support multiple interfaces on different channels,
+         * this must be modified/fixed.
+         */
+        struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
 
         if (priv->disable_chain_noise_cal)
                 return;
@@ -780,34 +889,20 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv, void *stat_resp)
         }
 
         spin_lock_irqsave(&priv->lock, flags);
-        if (priv->cfg->bt_statistics) {
-                rx_info = &(((struct iwl_bt_notif_statistics *)stat_resp)->
-                              rx.general.common);
-        } else {
-                rx_info = &(((struct iwl_notif_statistics *)stat_resp)->
-                              rx.general);
-        }
+
+        rx_info = &priv->statistics.rx_non_phy;
+
         if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
                 IWL_DEBUG_CALIB(priv, " << Interference data unavailable\n");
                 spin_unlock_irqrestore(&priv->lock, flags);
                 return;
         }
 
-        rxon_band24 = !!(priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK);
-        rxon_chnum = le16_to_cpu(priv->staging_rxon.channel);
-        if (priv->cfg->bt_statistics) {
-                stat_band24 = !!(((struct iwl_bt_notif_statistics *)
-                                 stat_resp)->flag &
-                                 STATISTICS_REPLY_FLG_BAND_24G_MSK);
-                stat_chnum = le32_to_cpu(((struct iwl_bt_notif_statistics *)
-                                         stat_resp)->flag) >> 16;
-        } else {
-                stat_band24 = !!(((struct iwl_notif_statistics *)
-                                 stat_resp)->flag &
-                                 STATISTICS_REPLY_FLG_BAND_24G_MSK);
-                stat_chnum = le32_to_cpu(((struct iwl_notif_statistics *)
-                                         stat_resp)->flag) >> 16;
-        }
+        rxon_band24 = !!(ctx->staging.flags & RXON_FLG_BAND_24G_MSK);
+        rxon_chnum = le16_to_cpu(ctx->staging.channel);
+        stat_band24 =
+                !!(priv->statistics.flag & STATISTICS_REPLY_FLG_BAND_24G_MSK);
+        stat_chnum = le32_to_cpu(priv->statistics.flag) >> 16;
 
         /* Make sure we accumulate data for just the associated channel
          *   (even if scanning). */
@@ -855,114 +950,29 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv, void *stat_resp)
         /* 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 != priv->cfg->chain_noise_num_beacons)
+        if (data->beacon_count !=
+                priv->cfg->base_params->chain_noise_num_beacons)
                 return;
 
         /* Analyze signal for disconnected antenna */
-        average_sig[0] =
-                (data->chain_signal_a) / priv->cfg->chain_noise_num_beacons;
-        average_sig[1] =
-                (data->chain_signal_b) / priv->cfg->chain_noise_num_beacons;
-        average_sig[2] =
-                (data->chain_signal_c) / priv->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);
-        }
-
-        IWL_DEBUG_CALIB(priv, "average_sig: a %d b %d c %d\n",
-                     average_sig[0], average_sig[1], average_sig[2]);
-        IWL_DEBUG_CALIB(priv, "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)
+        if (priv->cfg->bt_params &&
+            priv->cfg->bt_params->advanced_bt_coexist) {
+                /* Disable disconnected antenna algorithm for advanced
+                   bt coex, assuming valid antennas are connected */
+                data->active_chains = priv->hw_params.valid_rx_ant;
+                for (i = 0; i < NUM_RX_CHAINS; i++)
+                        if (!(data->active_chains & (1<<i)))
                                 data->disconn_array[i] = 1;
-                        else
-                                active_chains |= (1 << i);
-                        IWL_DEBUG_CALIB(priv, "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 &= priv->hw_params.valid_rx_ant;
-
-        num_tx_chains = 0;
-        for (i = 0; i < NUM_RX_CHAINS; i++) {
-                /* loops on all the bits of
-                 * priv->hw_setting.valid_tx_ant */
-                u8 ant_msk = (1 << i);
-                if (!(priv->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 == priv->hw_params.tx_chains_num &&
-                    data->disconn_array[i]) {
-                        /*
-                         * If all chains are disconnected
-                         * connect the first valid tx chain
-                         */
-                        first_chain =
-                                find_first_chain(priv->cfg->valid_tx_ant);
-                        data->disconn_array[first_chain] = 0;
-                        active_chains |= BIT(first_chain);
-                        IWL_DEBUG_CALIB(priv, "All Tx chains are disconnected W/A - declare %d as connected\n",
-                                        first_chain);
-                        break;
-                }
-        }
-
-        if (active_chains != priv->hw_params.valid_rx_ant &&
-            active_chains != priv->chain_noise_data.active_chains)
-                IWL_DEBUG_CALIB(priv,
-                                "Detected that not all antennas are connected! "
-                                "Connected: %#x, valid: %#x.\n",
-                                active_chains, priv->hw_params.valid_rx_ant);
-
-        /* Save for use within RXON, TX, SCAN commands, etc. */
-        priv->chain_noise_data.active_chains = active_chains;
-        IWL_DEBUG_CALIB(priv, "active_chains (bitwise) = 0x%x\n",
-                        active_chains);
+        } else
+                iwl_find_disconn_antenna(priv, average_sig, data);
 
         /* Analyze noise for rx balance */
-        average_noise[0] =
-                ((data->chain_noise_a) / priv->cfg->chain_noise_num_beacons);
-        average_noise[1] =
-                ((data->chain_noise_b) / priv->cfg->chain_noise_num_beacons);
-        average_noise[2] =
-                ((data->chain_noise_c) / priv->cfg->chain_noise_num_beacons);
+        average_noise[0] = data->chain_noise_a /
+                           priv->cfg->base_params->chain_noise_num_beacons;
+        average_noise[1] = data->chain_noise_b /
+                           priv->cfg->base_params->chain_noise_num_beacons;
+        average_noise[2] = data->chain_noise_c /
+                           priv->cfg->base_params->chain_noise_num_beacons;
 
         for (i = 0; i < NUM_RX_CHAINS; i++) {
                 if (!(data->disconn_array[i]) &&