1 files changed, 40 insertions, 40 deletions

diff --git a/drivers/net/wireless/iwlegacy/iwl-4965-calib.c b/drivers/net/wireless/iwlegacy/iwl-4965-calib.c
index 7807dc59e9c5..7f858344b920 100644
--- a/drivers/net/wireless/iwlegacy/iwl-4965-calib.c
+++ b/drivers/net/wireless/iwlegacy/iwl-4965-calib.c
@@ -160,7 +160,7 @@ static int il4965_sens_energy_cck(struct il_priv *il,
                 val = data->nrg_silence_rssi[i];
                 silence_ref = max(silence_ref, val);
         }
-        IL_DEBUG_CALIB(il, "silence a %u, b %u, c %u, 20-bcn max %u\n",
+        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);
 
@@ -184,7 +184,7 @@ static int il4965_sens_energy_cck(struct il_priv *il,
                 max_nrg_cck = (u32) max(max_nrg_cck, (data->nrg_value[i]));
         max_nrg_cck += 6;
 
-        IL_DEBUG_CALIB(il, "rx energy a %u, b %u, c %u, 10-bcn max/min %u\n",
+        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);
 
@@ -194,15 +194,15 @@ static int il4965_sens_energy_cck(struct il_priv *il,
                 data->num_in_cck_no_fa++;
         else
                 data->num_in_cck_no_fa = 0;
-        IL_DEBUG_CALIB(il, "consecutive bcns with few false alarms = %u\n",
+        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)) {
-                IL_DEBUG_CALIB(il, "norm FA %u > max FA %u\n",
+                D_CALIB("norm FA %u > max FA %u\n",
                      false_alarms, max_false_alarms);
-                IL_DEBUG_CALIB(il, "... reducing sensitivity\n");
+                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;
@@ -219,7 +219,7 @@ static int il4965_sens_energy_cck(struct il_priv *il,
                 data->nrg_auto_corr_silence_diff = (s32)data->nrg_silence_ref -
                                                    (s32)silence_ref;
 
-                IL_DEBUG_CALIB(il,
+                D_CALIB(
                          "norm FA %u < min FA %u, silence diff %d\n",
                          false_alarms, min_false_alarms,
                          data->nrg_auto_corr_silence_diff);
@@ -234,18 +234,18 @@ static int il4965_sens_energy_cck(struct il_priv *il,
                         ((data->nrg_auto_corr_silence_diff > NRG_DIFF) ||
                         (data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA))) {
 
-                        IL_DEBUG_CALIB(il, "... increasing sensitivity\n");
+                        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 {
-                        IL_DEBUG_CALIB(il,
+                        D_CALIB(
                                          "... but not changing sensitivity\n");
                 }
 
         /* Else we got a healthy number of false alarms, keep status quo */
         } else {
-                IL_DEBUG_CALIB(il, " FA in safe zone\n");
+                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 */
@@ -255,7 +255,7 @@ static int il4965_sens_energy_cck(struct il_priv *il,
                  *   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) {
-                        IL_DEBUG_CALIB(il, "... increasing margin\n");
+                        D_CALIB("... increasing margin\n");
                         if (data->nrg_th_cck > (max_nrg_cck + NRG_MARGIN))
                                 data->nrg_th_cck -= NRG_MARGIN;
                         else
@@ -269,7 +269,7 @@ static int il4965_sens_energy_cck(struct il_priv *il,
          * Lower value is higher energy, so we use max()!
          */
         data->nrg_th_cck = max(max_nrg_cck, data->nrg_th_cck);
-        IL_DEBUG_CALIB(il, "new nrg_th_cck %u\n", data->nrg_th_cck);
+        D_CALIB("new nrg_th_cck %u\n", data->nrg_th_cck);
 
         data->nrg_prev_state = data->nrg_curr_state;
 
@@ -322,7 +322,7 @@ static int il4965_sens_auto_corr_ofdm(struct il_priv *il,
         /* If we got too many false alarms this time, reduce sensitivity */
         if (false_alarms > max_false_alarms) {
 
-                IL_DEBUG_CALIB(il, "norm FA %u > max FA %u)\n",
+                D_CALIB("norm FA %u > max FA %u)\n",
                              false_alarms, max_false_alarms);
 
                 val = data->auto_corr_ofdm + AUTO_CORR_STEP_OFDM;
@@ -345,7 +345,7 @@ static int il4965_sens_auto_corr_ofdm(struct il_priv *il,
         /* Else if we got fewer than desired, increase sensitivity */
         else if (false_alarms < min_false_alarms) {
 
-                IL_DEBUG_CALIB(il, "norm FA %u < min FA %u\n",
+                D_CALIB("norm FA %u < min FA %u\n",
                              false_alarms, min_false_alarms);
 
                 val = data->auto_corr_ofdm - AUTO_CORR_STEP_OFDM;
@@ -364,7 +364,7 @@ static int il4965_sens_auto_corr_ofdm(struct il_priv *il,
                 data->auto_corr_ofdm_mrc_x1 =
                         max((u32)ranges->auto_corr_min_ofdm_mrc_x1, val);
         } else {
-                IL_DEBUG_CALIB(il, "min FA %u < norm FA %u < max FA %u OK\n",
+                D_CALIB("min FA %u < norm FA %u < max FA %u OK\n",
                          min_false_alarms, false_alarms, max_false_alarms);
         }
         return 0;
@@ -400,12 +400,12 @@ static void il4965_prepare_legacy_sensitivity_tbl(struct il_priv *il,
         tbl[HD_OFDM_ENERGY_TH_IN_INDEX] =
                                 cpu_to_le16(data->nrg_th_cca);
 
-        IL_DEBUG_CALIB(il, "ofdm: ac %u mrc %u x1 %u mrc_x1 %u thresh %u\n",
+        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);
 
-        IL_DEBUG_CALIB(il, "cck: ac %u mrc %u thresh %u\n",
+        D_CALIB("cck: ac %u mrc %u thresh %u\n",
                         data->auto_corr_cck, data->auto_corr_cck_mrc,
                         data->nrg_th_cck);
 }
@@ -434,7 +434,7 @@ static int il4965_sensitivity_write(struct il_priv *il)
         /* Don't send command to uCode if nothing has changed */
         if (!memcmp(&cmd.table[0], &(il->sensitivity_tbl[0]),
                     sizeof(u16)*HD_TABLE_SIZE)) {
-                IL_DEBUG_CALIB(il, "No change in SENSITIVITY_CMD\n");
+                D_CALIB("No change in SENSITIVITY_CMD\n");
                 return 0;
         }
 
@@ -455,7 +455,7 @@ void il4965_init_sensitivity(struct il_priv *il)
         if (il->disable_sens_cal)
                 return;
 
-        IL_DEBUG_CALIB(il, "Start il4965_init_sensitivity\n");
+        D_CALIB("Start il4965_init_sensitivity\n");
 
         /* Clear driver's sensitivity algo data */
         data = &(il->sensitivity_data);
@@ -496,7 +496,7 @@ void il4965_init_sensitivity(struct il_priv *il)
         data->last_fa_cnt_cck = 0;
 
         ret |= il4965_sensitivity_write(il);
-        IL_DEBUG_CALIB(il, "<<return 0x%X\n", ret);
+        D_CALIB("<<return 0x%X\n", ret);
 }
 
 void il4965_sensitivity_calibration(struct il_priv *il, void *resp)
@@ -520,7 +520,7 @@ void il4965_sensitivity_calibration(struct il_priv *il, void *resp)
         data = &(il->sensitivity_data);
 
         if (!il_is_any_associated(il)) {
-                IL_DEBUG_CALIB(il, "<< - not associated\n");
+                D_CALIB("<< - not associated\n");
                 return;
         }
 
@@ -531,7 +531,7 @@ void il4965_sensitivity_calibration(struct il_priv *il, void *resp)
         cck = &(((struct il_notif_statistics *)resp)->rx.cck);
 
         if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
-                IL_DEBUG_CALIB(il, "<< invalid data.\n");
+                D_CALIB("<< invalid data.\n");
                 spin_unlock_irqrestore(&il->lock, flags);
                 return;
         }
@@ -558,10 +558,10 @@ void il4965_sensitivity_calibration(struct il_priv *il, void *resp)
 
         spin_unlock_irqrestore(&il->lock, flags);
 
-        IL_DEBUG_CALIB(il, "rx_enable_time = %u usecs\n", rx_enable_time);
+        D_CALIB("rx_enable_time = %u usecs\n", rx_enable_time);
 
         if (!rx_enable_time) {
-                IL_DEBUG_CALIB(il, "<< RX Enable Time == 0!\n");
+                D_CALIB("<< RX Enable Time == 0!\n");
                 return;
         }
 
@@ -600,7 +600,7 @@ void il4965_sensitivity_calibration(struct il_priv *il, void *resp)
         norm_fa_ofdm = fa_ofdm + bad_plcp_ofdm;
         norm_fa_cck = fa_cck + bad_plcp_cck;
 
-        IL_DEBUG_CALIB(il,
+        D_CALIB(
                          "cck: fa %u badp %u  ofdm: fa %u badp %u\n", fa_cck,
                         bad_plcp_cck, fa_ofdm, bad_plcp_ofdm);
 
@@ -657,9 +657,9 @@ il4965_find_disconn_antenna(struct il_priv *il, u32* average_sig,
                 active_chains = (1 << max_average_sig_antenna_i);
         }
 
-        IL_DEBUG_CALIB(il, "average_sig: a %d b %d c %d\n",
+        D_CALIB("average_sig: a %d b %d c %d\n",
                      average_sig[0], average_sig[1], average_sig[2]);
-        IL_DEBUG_CALIB(il, "max_average_sig = %d, antenna %d\n",
+        D_CALIB("max_average_sig = %d, antenna %d\n",
                      max_average_sig, max_average_sig_antenna_i);
 
         /* Compare signal strengths for all 3 receivers. */
@@ -673,7 +673,7 @@ il4965_find_disconn_antenna(struct il_priv *il, u32* average_sig,
                                 data->disconn_array[i] = 1;
                         else
                                 active_chains |= (1 << i);
-                        IL_DEBUG_CALIB(il, "i = %d  rssiDelta = %d  "
+                        D_CALIB("i = %d  rssiDelta = %d  "
                              "disconn_array[i] = %d\n",
                              i, rssi_delta, data->disconn_array[i]);
                 }
@@ -713,7 +713,7 @@ il4965_find_disconn_antenna(struct il_priv *il, u32* average_sig,
                         il4965_find_first_chain(il->cfg->valid_tx_ant);
                         data->disconn_array[first_chain] = 0;
                         active_chains |= BIT(first_chain);
-                        IL_DEBUG_CALIB(il,
+                        D_CALIB(
                                         "All Tx chains are disconnected W/A - declare %d as connected\n",
                                         first_chain);
                         break;
@@ -722,14 +722,14 @@ il4965_find_disconn_antenna(struct il_priv *il, u32* average_sig,
 
         if (active_chains != il->hw_params.valid_rx_ant &&
             active_chains != il->chain_noise_data.active_chains)
-                IL_DEBUG_CALIB(il,
+                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;
-        IL_DEBUG_CALIB(il, "active_chains (bitwise) = 0x%x\n",
+        D_CALIB("active_chains (bitwise) = 0x%x\n",
                         active_chains);
 }
 
@@ -762,7 +762,7 @@ static void il4965_gain_computation(struct il_priv *il,
                         data->delta_gain_code[i] = 0;
                 }
         }
-        IL_DEBUG_CALIB(il, "delta_gain_codes: a %d b %d c %d\n",
+        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]);
@@ -780,7 +780,7 @@ static void il4965_gain_computation(struct il_priv *il,
                 ret = il_send_cmd_pdu(il, REPLY_PHY_CALIBRATION_CMD,
                                       sizeof(cmd), &cmd);
                 if (ret)
-                        IL_DEBUG_CALIB(il, "fail sending cmd "
+                        D_CALIB("fail sending cmd "
                                      "REPLY_PHY_CALIBRATION_CMD\n");
 
                 /* TODO we might want recalculate
@@ -834,7 +834,7 @@ void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
          */
         if (data->state != IL_CHAIN_NOISE_ACCUMULATE) {
                 if (data->state == IL_CHAIN_NOISE_ALIVE)
-                        IL_DEBUG_CALIB(il, "Wait for noise calib reset\n");
+                        D_CALIB("Wait for noise calib reset\n");
                 return;
         }
 
@@ -844,7 +844,7 @@ void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
                       rx.general);
 
         if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
-                IL_DEBUG_CALIB(il, " << Interference data unavailable\n");
+                D_CALIB(" << Interference data unavailable\n");
                 spin_unlock_irqrestore(&il->lock, flags);
                 return;
         }
@@ -861,7 +861,7 @@ void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
         /* Make sure we accumulate data for just the associated channel
          *   (even if scanning). */
         if ((rxon_chnum != stat_chnum) || (rxon_band24 != stat_band24)) {
-                IL_DEBUG_CALIB(il, "Stats not from chan=%d, band24=%d\n",
+                D_CALIB("Stats not from chan=%d, band24=%d\n",
                                 rxon_chnum, rxon_band24);
                 spin_unlock_irqrestore(&il->lock, flags);
                 return;
@@ -894,11 +894,11 @@ void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
         data->chain_signal_b = (chain_sig_b + data->chain_signal_b);
         data->chain_signal_c = (chain_sig_c + data->chain_signal_c);
 
-        IL_DEBUG_CALIB(il, "chan=%d, band24=%d, beacon=%d\n",
+        D_CALIB("chan=%d, band24=%d, beacon=%d\n",
                         rxon_chnum, rxon_band24, data->beacon_count);
-        IL_DEBUG_CALIB(il, "chain_sig: a %d b %d c %d\n",
+        D_CALIB("chain_sig: a %d b %d c %d\n",
                         chain_sig_a, chain_sig_b, chain_sig_c);
-        IL_DEBUG_CALIB(il, "chain_noise: a %d b %d c %d\n",
+        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:
@@ -929,11 +929,11 @@ void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
                 }
         }
 
-        IL_DEBUG_CALIB(il, "average_noise: a %d b %d c %d\n",
+        D_CALIB("average_noise: a %d b %d c %d\n",
                         average_noise[0], average_noise[1],
                         average_noise[2]);
 
-        IL_DEBUG_CALIB(il, "min_average_noise = %d, antenna %d\n",
+        D_CALIB("min_average_noise = %d, antenna %d\n",
                         min_average_noise, min_average_noise_antenna_i);
 
         il4965_gain_computation(il, average_noise,