1 /******************************************************************************
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
8 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * The full GNU General Public License is included in this distribution
25 * in the file called LICENSE.GPL.
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
33 * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
34 * All rights reserved.
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 *****************************************************************************/
63 #include <linux/slab.h>
64 #include <net/mac80211.h>
69 /*****************************************************************************
70 * INIT calibrations framework
71 *****************************************************************************/
73 struct stats_general_data {
74 u32 beacon_silence_rssi_a;
75 u32 beacon_silence_rssi_b;
76 u32 beacon_silence_rssi_c;
82 void il4965_calib_free_results(struct il_priv *il)
86 for (i = 0; i < IL_CALIB_MAX; i++) {
87 kfree(il->calib_results[i].buf);
88 il->calib_results[i].buf = NULL;
89 il->calib_results[i].buf_len = 0;
93 /*****************************************************************************
94 * RUNTIME calibrations framework
95 *****************************************************************************/
97 /* "false alarms" are signals that our DSP tries to lock onto,
98 * but then determines that they are either noise, or transmissions
99 * from a distant wireless network (also "noise", really) that get
100 * "stepped on" by stronger transmissions within our own network.
101 * This algorithm attempts to set a sensitivity level that is high
102 * enough to receive all of our own network traffic, but not so
103 * high that our DSP gets too busy trying to lock onto non-network
105 static int il4965_sens_energy_cck(struct il_priv *il,
108 struct stats_general_data *rx_info)
112 u8 max_silence_rssi = 0;
114 u8 silence_rssi_a = 0;
115 u8 silence_rssi_b = 0;
116 u8 silence_rssi_c = 0;
119 /* "false_alarms" values below are cross-multiplications to assess the
120 * numbers of false alarms within the measured period of actual Rx
121 * (Rx is off when we're txing), vs the min/max expected false alarms
122 * (some should be expected if rx is sensitive enough) in a
123 * hypothetical listening period of 200 time units (TU), 204.8 msec:
125 * MIN_FA/fixed-time < false_alarms/actual-rx-time < MAX_FA/beacon-time
128 u32 false_alarms = norm_fa * 200 * 1024;
129 u32 max_false_alarms = MAX_FA_CCK * rx_enable_time;
130 u32 min_false_alarms = MIN_FA_CCK * rx_enable_time;
131 struct il_sensitivity_data *data = NULL;
132 const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
134 data = &(il->sensitivity_data);
136 data->nrg_auto_corr_silence_diff = 0;
138 /* Find max silence rssi among all 3 receivers.
139 * This is background noise, which may include transmissions from other
140 * networks, measured during silence before our network's beacon */
141 silence_rssi_a = (u8)((rx_info->beacon_silence_rssi_a &
142 ALL_BAND_FILTER) >> 8);
143 silence_rssi_b = (u8)((rx_info->beacon_silence_rssi_b &
144 ALL_BAND_FILTER) >> 8);
145 silence_rssi_c = (u8)((rx_info->beacon_silence_rssi_c &
146 ALL_BAND_FILTER) >> 8);
148 val = max(silence_rssi_b, silence_rssi_c);
149 max_silence_rssi = max(silence_rssi_a, (u8) val);
151 /* Store silence rssi in 20-beacon history table */
152 data->nrg_silence_rssi[data->nrg_silence_idx] = max_silence_rssi;
153 data->nrg_silence_idx++;
154 if (data->nrg_silence_idx >= NRG_NUM_PREV_STAT_L)
155 data->nrg_silence_idx = 0;
157 /* Find max silence rssi across 20 beacon history */
158 for (i = 0; i < NRG_NUM_PREV_STAT_L; i++) {
159 val = data->nrg_silence_rssi[i];
160 silence_ref = max(silence_ref, val);
162 D_CALIB("silence a %u, b %u, c %u, 20-bcn max %u\n",
163 silence_rssi_a, silence_rssi_b, silence_rssi_c,
166 /* Find max rx energy (min value!) among all 3 receivers,
167 * measured during beacon frame.
168 * Save it in 10-beacon history table. */
169 i = data->nrg_energy_idx;
170 val = min(rx_info->beacon_energy_b, rx_info->beacon_energy_c);
171 data->nrg_value[i] = min(rx_info->beacon_energy_a, val);
173 data->nrg_energy_idx++;
174 if (data->nrg_energy_idx >= 10)
175 data->nrg_energy_idx = 0;
177 /* Find min rx energy (max value) across 10 beacon history.
178 * This is the minimum signal level that we want to receive well.
179 * Add backoff (margin so we don't miss slightly lower energy frames).
180 * This establishes an upper bound (min value) for energy threshold. */
181 max_nrg_cck = data->nrg_value[0];
182 for (i = 1; i < 10; i++)
183 max_nrg_cck = (u32) max(max_nrg_cck, (data->nrg_value[i]));
186 D_CALIB("rx energy a %u, b %u, c %u, 10-bcn max/min %u\n",
187 rx_info->beacon_energy_a, rx_info->beacon_energy_b,
188 rx_info->beacon_energy_c, max_nrg_cck - 6);
190 /* Count number of consecutive beacons with fewer-than-desired
192 if (false_alarms < min_false_alarms)
193 data->num_in_cck_no_fa++;
195 data->num_in_cck_no_fa = 0;
196 D_CALIB("consecutive bcns with few false alarms = %u\n",
197 data->num_in_cck_no_fa);
199 /* If we got too many false alarms this time, reduce sensitivity */
200 if (false_alarms > max_false_alarms &&
201 data->auto_corr_cck > AUTO_CORR_MAX_TH_CCK) {
202 D_CALIB("norm FA %u > max FA %u\n",
203 false_alarms, max_false_alarms);
204 D_CALIB("... reducing sensitivity\n");
205 data->nrg_curr_state = IL_FA_TOO_MANY;
206 /* Store for "fewer than desired" on later beacon */
207 data->nrg_silence_ref = silence_ref;
209 /* increase energy threshold (reduce nrg value)
210 * to decrease sensitivity */
211 data->nrg_th_cck = data->nrg_th_cck - NRG_STEP_CCK;
212 /* Else if we got fewer than desired, increase sensitivity */
213 } else if (false_alarms < min_false_alarms) {
214 data->nrg_curr_state = IL_FA_TOO_FEW;
216 /* Compare silence level with silence level for most recent
217 * healthy number or too many false alarms */
218 data->nrg_auto_corr_silence_diff = (s32)data->nrg_silence_ref -
222 "norm FA %u < min FA %u, silence diff %d\n",
223 false_alarms, min_false_alarms,
224 data->nrg_auto_corr_silence_diff);
226 /* Increase value to increase sensitivity, but only if:
227 * 1a) previous beacon did *not* have *too many* false alarms
228 * 1b) AND there's a significant difference in Rx levels
229 * from a previous beacon with too many, or healthy # FAs
230 * OR 2) We've seen a lot of beacons (100) with too few
232 if (data->nrg_prev_state != IL_FA_TOO_MANY &&
233 (data->nrg_auto_corr_silence_diff > NRG_DIFF ||
234 data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA)) {
236 D_CALIB("... increasing sensitivity\n");
237 /* Increase nrg value to increase sensitivity */
238 val = data->nrg_th_cck + NRG_STEP_CCK;
239 data->nrg_th_cck = min((u32)ranges->min_nrg_cck, val);
242 "... but not changing sensitivity\n");
245 /* Else we got a healthy number of false alarms, keep status quo */
247 D_CALIB(" FA in safe zone\n");
248 data->nrg_curr_state = IL_FA_GOOD_RANGE;
250 /* Store for use in "fewer than desired" with later beacon */
251 data->nrg_silence_ref = silence_ref;
253 /* If previous beacon had too many false alarms,
254 * give it some extra margin by reducing sensitivity again
255 * (but don't go below measured energy of desired Rx) */
256 if (IL_FA_TOO_MANY == data->nrg_prev_state) {
257 D_CALIB("... increasing margin\n");
258 if (data->nrg_th_cck > (max_nrg_cck + NRG_MARGIN))
259 data->nrg_th_cck -= NRG_MARGIN;
261 data->nrg_th_cck = max_nrg_cck;
265 /* Make sure the energy threshold does not go above the measured
266 * energy of the desired Rx signals (reduced by backoff margin),
267 * or else we might start missing Rx frames.
268 * Lower value is higher energy, so we use max()!
270 data->nrg_th_cck = max(max_nrg_cck, data->nrg_th_cck);
271 D_CALIB("new nrg_th_cck %u\n", data->nrg_th_cck);
273 data->nrg_prev_state = data->nrg_curr_state;
275 /* Auto-correlation CCK algorithm */
276 if (false_alarms > min_false_alarms) {
278 /* increase auto_corr values to decrease sensitivity
279 * so the DSP won't be disturbed by the noise
281 if (data->auto_corr_cck < AUTO_CORR_MAX_TH_CCK)
282 data->auto_corr_cck = AUTO_CORR_MAX_TH_CCK + 1;
284 val = data->auto_corr_cck + AUTO_CORR_STEP_CCK;
285 data->auto_corr_cck =
286 min((u32)ranges->auto_corr_max_cck, val);
288 val = data->auto_corr_cck_mrc + AUTO_CORR_STEP_CCK;
289 data->auto_corr_cck_mrc =
290 min((u32)ranges->auto_corr_max_cck_mrc, val);
291 } else if (false_alarms < min_false_alarms &&
292 (data->nrg_auto_corr_silence_diff > NRG_DIFF ||
293 data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA)) {
295 /* Decrease auto_corr values to increase sensitivity */
296 val = data->auto_corr_cck - AUTO_CORR_STEP_CCK;
297 data->auto_corr_cck =
298 max((u32)ranges->auto_corr_min_cck, val);
299 val = data->auto_corr_cck_mrc - AUTO_CORR_STEP_CCK;
300 data->auto_corr_cck_mrc =
301 max((u32)ranges->auto_corr_min_cck_mrc, val);
308 static int il4965_sens_auto_corr_ofdm(struct il_priv *il,
313 u32 false_alarms = norm_fa * 200 * 1024;
314 u32 max_false_alarms = MAX_FA_OFDM * rx_enable_time;
315 u32 min_false_alarms = MIN_FA_OFDM * rx_enable_time;
316 struct il_sensitivity_data *data = NULL;
317 const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
319 data = &(il->sensitivity_data);
321 /* If we got too many false alarms this time, reduce sensitivity */
322 if (false_alarms > max_false_alarms) {
324 D_CALIB("norm FA %u > max FA %u)\n",
325 false_alarms, max_false_alarms);
327 val = data->auto_corr_ofdm + AUTO_CORR_STEP_OFDM;
328 data->auto_corr_ofdm =
329 min((u32)ranges->auto_corr_max_ofdm, val);
331 val = data->auto_corr_ofdm_mrc + AUTO_CORR_STEP_OFDM;
332 data->auto_corr_ofdm_mrc =
333 min((u32)ranges->auto_corr_max_ofdm_mrc, val);
335 val = data->auto_corr_ofdm_x1 + AUTO_CORR_STEP_OFDM;
336 data->auto_corr_ofdm_x1 =
337 min((u32)ranges->auto_corr_max_ofdm_x1, val);
339 val = data->auto_corr_ofdm_mrc_x1 + AUTO_CORR_STEP_OFDM;
340 data->auto_corr_ofdm_mrc_x1 =
341 min((u32)ranges->auto_corr_max_ofdm_mrc_x1, val);
344 /* Else if we got fewer than desired, increase sensitivity */
345 else if (false_alarms < min_false_alarms) {
347 D_CALIB("norm FA %u < min FA %u\n",
348 false_alarms, min_false_alarms);
350 val = data->auto_corr_ofdm - AUTO_CORR_STEP_OFDM;
351 data->auto_corr_ofdm =
352 max((u32)ranges->auto_corr_min_ofdm, val);
354 val = data->auto_corr_ofdm_mrc - AUTO_CORR_STEP_OFDM;
355 data->auto_corr_ofdm_mrc =
356 max((u32)ranges->auto_corr_min_ofdm_mrc, val);
358 val = data->auto_corr_ofdm_x1 - AUTO_CORR_STEP_OFDM;
359 data->auto_corr_ofdm_x1 =
360 max((u32)ranges->auto_corr_min_ofdm_x1, val);
362 val = data->auto_corr_ofdm_mrc_x1 - AUTO_CORR_STEP_OFDM;
363 data->auto_corr_ofdm_mrc_x1 =
364 max((u32)ranges->auto_corr_min_ofdm_mrc_x1, val);
366 D_CALIB("min FA %u < norm FA %u < max FA %u OK\n",
367 min_false_alarms, false_alarms, max_false_alarms);
372 static void il4965_prepare_legacy_sensitivity_tbl(struct il_priv *il,
373 struct il_sensitivity_data *data,
376 tbl[HD_AUTO_CORR32_X4_TH_ADD_MIN_IDX] =
377 cpu_to_le16((u16)data->auto_corr_ofdm);
378 tbl[HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_IDX] =
379 cpu_to_le16((u16)data->auto_corr_ofdm_mrc);
380 tbl[HD_AUTO_CORR32_X1_TH_ADD_MIN_IDX] =
381 cpu_to_le16((u16)data->auto_corr_ofdm_x1);
382 tbl[HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_IDX] =
383 cpu_to_le16((u16)data->auto_corr_ofdm_mrc_x1);
385 tbl[HD_AUTO_CORR40_X4_TH_ADD_MIN_IDX] =
386 cpu_to_le16((u16)data->auto_corr_cck);
387 tbl[HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_IDX] =
388 cpu_to_le16((u16)data->auto_corr_cck_mrc);
390 tbl[HD_MIN_ENERGY_CCK_DET_IDX] =
391 cpu_to_le16((u16)data->nrg_th_cck);
392 tbl[HD_MIN_ENERGY_OFDM_DET_IDX] =
393 cpu_to_le16((u16)data->nrg_th_ofdm);
395 tbl[HD_BARKER_CORR_TH_ADD_MIN_IDX] =
396 cpu_to_le16(data->barker_corr_th_min);
397 tbl[HD_BARKER_CORR_TH_ADD_MIN_MRC_IDX] =
398 cpu_to_le16(data->barker_corr_th_min_mrc);
399 tbl[HD_OFDM_ENERGY_TH_IN_IDX] =
400 cpu_to_le16(data->nrg_th_cca);
402 D_CALIB("ofdm: ac %u mrc %u x1 %u mrc_x1 %u thresh %u\n",
403 data->auto_corr_ofdm, data->auto_corr_ofdm_mrc,
404 data->auto_corr_ofdm_x1, data->auto_corr_ofdm_mrc_x1,
407 D_CALIB("cck: ac %u mrc %u thresh %u\n",
408 data->auto_corr_cck, data->auto_corr_cck_mrc,
412 /* Prepare a C_SENSITIVITY, send to uCode if values have changed */
413 static int il4965_sensitivity_write(struct il_priv *il)
415 struct il_sensitivity_cmd cmd;
416 struct il_sensitivity_data *data = NULL;
417 struct il_host_cmd cmd_out = {
419 .len = sizeof(struct il_sensitivity_cmd),
424 data = &(il->sensitivity_data);
426 memset(&cmd, 0, sizeof(cmd));
428 il4965_prepare_legacy_sensitivity_tbl(il, data, &cmd.table[0]);
430 /* Update uCode's "work" table, and copy it to DSP */
431 cmd.control = C_SENSITIVITY_CONTROL_WORK_TBL;
433 /* Don't send command to uCode if nothing has changed */
434 if (!memcmp(&cmd.table[0], &(il->sensitivity_tbl[0]),
435 sizeof(u16)*HD_TBL_SIZE)) {
436 D_CALIB("No change in C_SENSITIVITY\n");
440 /* Copy table for comparison next time */
441 memcpy(&(il->sensitivity_tbl[0]), &(cmd.table[0]),
442 sizeof(u16)*HD_TBL_SIZE);
444 return il_send_cmd(il, &cmd_out);
447 void il4965_init_sensitivity(struct il_priv *il)
451 struct il_sensitivity_data *data = NULL;
452 const struct il_sensitivity_ranges *ranges = il->hw_params.sens;
454 if (il->disable_sens_cal)
457 D_CALIB("Start il4965_init_sensitivity\n");
459 /* Clear driver's sensitivity algo data */
460 data = &(il->sensitivity_data);
465 memset(data, 0, sizeof(struct il_sensitivity_data));
467 data->num_in_cck_no_fa = 0;
468 data->nrg_curr_state = IL_FA_TOO_MANY;
469 data->nrg_prev_state = IL_FA_TOO_MANY;
470 data->nrg_silence_ref = 0;
471 data->nrg_silence_idx = 0;
472 data->nrg_energy_idx = 0;
474 for (i = 0; i < 10; i++)
475 data->nrg_value[i] = 0;
477 for (i = 0; i < NRG_NUM_PREV_STAT_L; i++)
478 data->nrg_silence_rssi[i] = 0;
480 data->auto_corr_ofdm = ranges->auto_corr_min_ofdm;
481 data->auto_corr_ofdm_mrc = ranges->auto_corr_min_ofdm_mrc;
482 data->auto_corr_ofdm_x1 = ranges->auto_corr_min_ofdm_x1;
483 data->auto_corr_ofdm_mrc_x1 = ranges->auto_corr_min_ofdm_mrc_x1;
484 data->auto_corr_cck = AUTO_CORR_CCK_MIN_VAL_DEF;
485 data->auto_corr_cck_mrc = ranges->auto_corr_min_cck_mrc;
486 data->nrg_th_cck = ranges->nrg_th_cck;
487 data->nrg_th_ofdm = ranges->nrg_th_ofdm;
488 data->barker_corr_th_min = ranges->barker_corr_th_min;
489 data->barker_corr_th_min_mrc = ranges->barker_corr_th_min_mrc;
490 data->nrg_th_cca = ranges->nrg_th_cca;
492 data->last_bad_plcp_cnt_ofdm = 0;
493 data->last_fa_cnt_ofdm = 0;
494 data->last_bad_plcp_cnt_cck = 0;
495 data->last_fa_cnt_cck = 0;
497 ret |= il4965_sensitivity_write(il);
498 D_CALIB("<<return 0x%X\n", ret);
501 void il4965_sensitivity_calibration(struct il_priv *il, void *resp)
510 struct il_sensitivity_data *data = NULL;
511 struct stats_rx_non_phy *rx_info;
512 struct stats_rx_phy *ofdm, *cck;
514 struct stats_general_data statis;
516 if (il->disable_sens_cal)
519 data = &(il->sensitivity_data);
521 if (!il_is_any_associated(il)) {
522 D_CALIB("<< - not associated\n");
526 spin_lock_irqsave(&il->lock, flags);
528 rx_info = &(((struct il_notif_stats *)resp)->rx.general);
529 ofdm = &(((struct il_notif_stats *)resp)->rx.ofdm);
530 cck = &(((struct il_notif_stats *)resp)->rx.cck);
532 if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
533 D_CALIB("<< invalid data.\n");
534 spin_unlock_irqrestore(&il->lock, flags);
538 /* Extract Statistics: */
539 rx_enable_time = le32_to_cpu(rx_info->channel_load);
540 fa_cck = le32_to_cpu(cck->false_alarm_cnt);
541 fa_ofdm = le32_to_cpu(ofdm->false_alarm_cnt);
542 bad_plcp_cck = le32_to_cpu(cck->plcp_err);
543 bad_plcp_ofdm = le32_to_cpu(ofdm->plcp_err);
545 statis.beacon_silence_rssi_a =
546 le32_to_cpu(rx_info->beacon_silence_rssi_a);
547 statis.beacon_silence_rssi_b =
548 le32_to_cpu(rx_info->beacon_silence_rssi_b);
549 statis.beacon_silence_rssi_c =
550 le32_to_cpu(rx_info->beacon_silence_rssi_c);
551 statis.beacon_energy_a =
552 le32_to_cpu(rx_info->beacon_energy_a);
553 statis.beacon_energy_b =
554 le32_to_cpu(rx_info->beacon_energy_b);
555 statis.beacon_energy_c =
556 le32_to_cpu(rx_info->beacon_energy_c);
558 spin_unlock_irqrestore(&il->lock, flags);
560 D_CALIB("rx_enable_time = %u usecs\n", rx_enable_time);
562 if (!rx_enable_time) {
563 D_CALIB("<< RX Enable Time == 0!\n");
567 /* These stats increase monotonically, and do not reset
568 * at each beacon. Calculate difference from last value, or just
569 * use the new stats value if it has reset or wrapped around. */
570 if (data->last_bad_plcp_cnt_cck > bad_plcp_cck)
571 data->last_bad_plcp_cnt_cck = bad_plcp_cck;
573 bad_plcp_cck -= data->last_bad_plcp_cnt_cck;
574 data->last_bad_plcp_cnt_cck += bad_plcp_cck;
577 if (data->last_bad_plcp_cnt_ofdm > bad_plcp_ofdm)
578 data->last_bad_plcp_cnt_ofdm = bad_plcp_ofdm;
580 bad_plcp_ofdm -= data->last_bad_plcp_cnt_ofdm;
581 data->last_bad_plcp_cnt_ofdm += bad_plcp_ofdm;
584 if (data->last_fa_cnt_ofdm > fa_ofdm)
585 data->last_fa_cnt_ofdm = fa_ofdm;
587 fa_ofdm -= data->last_fa_cnt_ofdm;
588 data->last_fa_cnt_ofdm += fa_ofdm;
591 if (data->last_fa_cnt_cck > fa_cck)
592 data->last_fa_cnt_cck = fa_cck;
594 fa_cck -= data->last_fa_cnt_cck;
595 data->last_fa_cnt_cck += fa_cck;
598 /* Total aborted signal locks */
599 norm_fa_ofdm = fa_ofdm + bad_plcp_ofdm;
600 norm_fa_cck = fa_cck + bad_plcp_cck;
603 "cck: fa %u badp %u ofdm: fa %u badp %u\n", fa_cck,
604 bad_plcp_cck, fa_ofdm, bad_plcp_ofdm);
606 il4965_sens_auto_corr_ofdm(il, norm_fa_ofdm, rx_enable_time);
607 il4965_sens_energy_cck(il, norm_fa_cck, rx_enable_time, &statis);
609 il4965_sensitivity_write(il);
612 static inline u8 il4965_find_first_chain(u8 mask)
622 * Run disconnected antenna algorithm to find out which antennas are
626 il4965_find_disconn_antenna(struct il_priv *il, u32* average_sig,
627 struct il_chain_noise_data *data)
629 u32 active_chains = 0;
631 u16 max_average_sig_antenna_i;
636 average_sig[0] = data->chain_signal_a /
637 il->cfg->base_params->chain_noise_num_beacons;
638 average_sig[1] = data->chain_signal_b /
639 il->cfg->base_params->chain_noise_num_beacons;
640 average_sig[2] = data->chain_signal_c /
641 il->cfg->base_params->chain_noise_num_beacons;
643 if (average_sig[0] >= average_sig[1]) {
644 max_average_sig = average_sig[0];
645 max_average_sig_antenna_i = 0;
646 active_chains = (1 << max_average_sig_antenna_i);
648 max_average_sig = average_sig[1];
649 max_average_sig_antenna_i = 1;
650 active_chains = (1 << max_average_sig_antenna_i);
653 if (average_sig[2] >= max_average_sig) {
654 max_average_sig = average_sig[2];
655 max_average_sig_antenna_i = 2;
656 active_chains = (1 << max_average_sig_antenna_i);
659 D_CALIB("average_sig: a %d b %d c %d\n",
660 average_sig[0], average_sig[1], average_sig[2]);
661 D_CALIB("max_average_sig = %d, antenna %d\n",
662 max_average_sig, max_average_sig_antenna_i);
664 /* Compare signal strengths for all 3 receivers. */
665 for (i = 0; i < NUM_RX_CHAINS; i++) {
666 if (i != max_average_sig_antenna_i) {
667 s32 rssi_delta = (max_average_sig - average_sig[i]);
669 /* If signal is very weak, compared with
670 * strongest, mark it as disconnected. */
671 if (rssi_delta > MAXIMUM_ALLOWED_PATHLOSS)
672 data->disconn_array[i] = 1;
674 active_chains |= (1 << i);
675 D_CALIB("i = %d rssiDelta = %d "
676 "disconn_array[i] = %d\n",
677 i, rssi_delta, data->disconn_array[i]);
682 * The above algorithm sometimes fails when the ucode
683 * reports 0 for all chains. It's not clear why that
684 * happens to start with, but it is then causing trouble
685 * because this can make us enable more chains than the
686 * hardware really has.
688 * To be safe, simply mask out any chains that we know
689 * are not on the device.
691 active_chains &= il->hw_params.valid_rx_ant;
694 for (i = 0; i < NUM_RX_CHAINS; i++) {
695 /* loops on all the bits of
696 * il->hw_setting.valid_tx_ant */
697 u8 ant_msk = (1 << i);
698 if (!(il->hw_params.valid_tx_ant & ant_msk))
702 if (data->disconn_array[i] == 0)
703 /* there is a Tx antenna connected */
705 if (num_tx_chains == il->hw_params.tx_chains_num &&
706 data->disconn_array[i]) {
708 * If all chains are disconnected
709 * connect the first valid tx chain
712 il4965_find_first_chain(il->cfg->valid_tx_ant);
713 data->disconn_array[first_chain] = 0;
714 active_chains |= BIT(first_chain);
716 "All Tx chains are disconnected W/A - declare %d as connected\n",
722 if (active_chains != il->hw_params.valid_rx_ant &&
723 active_chains != il->chain_noise_data.active_chains)
725 "Detected that not all antennas are connected! "
726 "Connected: %#x, valid: %#x.\n",
727 active_chains, il->hw_params.valid_rx_ant);
729 /* Save for use within RXON, TX, SCAN commands, etc. */
730 data->active_chains = active_chains;
731 D_CALIB("active_chains (bitwise) = 0x%x\n",
735 static void il4965_gain_computation(struct il_priv *il,
737 u16 min_average_noise_antenna_i,
738 u32 min_average_noise,
742 struct il_chain_noise_data *data = &il->chain_noise_data;
744 data->delta_gain_code[min_average_noise_antenna_i] = 0;
746 for (i = default_chain; i < NUM_RX_CHAINS; i++) {
749 if (!data->disconn_array[i] &&
750 data->delta_gain_code[i] == CHAIN_NOISE_DELTA_GAIN_INIT_VAL) {
751 delta_g = average_noise[i] - min_average_noise;
752 data->delta_gain_code[i] = (u8)((delta_g * 10) / 15);
753 data->delta_gain_code[i] =
754 min(data->delta_gain_code[i],
755 (u8) CHAIN_NOISE_MAX_DELTA_GAIN_CODE);
757 data->delta_gain_code[i] =
758 (data->delta_gain_code[i] | (1 << 2));
760 data->delta_gain_code[i] = 0;
763 D_CALIB("delta_gain_codes: a %d b %d c %d\n",
764 data->delta_gain_code[0],
765 data->delta_gain_code[1],
766 data->delta_gain_code[2]);
768 /* Differential gain gets sent to uCode only once */
769 if (!data->radio_write) {
770 struct il_calib_diff_gain_cmd cmd;
771 data->radio_write = 1;
773 memset(&cmd, 0, sizeof(cmd));
774 cmd.hdr.op_code = IL_PHY_CALIBRATE_DIFF_GAIN_CMD;
775 cmd.diff_gain_a = data->delta_gain_code[0];
776 cmd.diff_gain_b = data->delta_gain_code[1];
777 cmd.diff_gain_c = data->delta_gain_code[2];
778 ret = il_send_cmd_pdu(il, C_PHY_CALIBRATION,
781 D_CALIB("fail sending cmd "
782 "C_PHY_CALIBRATION\n");
784 /* TODO we might want recalculate
785 * rx_chain in rxon cmd */
787 /* Mark so we run this algo only once! */
788 data->state = IL_CHAIN_NOISE_CALIBRATED;
795 * Accumulate 16 beacons of signal and noise stats for each of
796 * 3 receivers/antennas/rx-chains, then figure out:
797 * 1) Which antennas are connected.
798 * 2) Differential rx gain settings to balance the 3 receivers.
800 void il4965_chain_noise_calibration(struct il_priv *il, void *stat_resp)
802 struct il_chain_noise_data *data = NULL;
810 u32 average_sig[NUM_RX_CHAINS] = {INITIALIZATION_VALUE};
811 u32 average_noise[NUM_RX_CHAINS] = {INITIALIZATION_VALUE};
812 u32 min_average_noise = MIN_AVERAGE_NOISE_MAX_VALUE;
813 u16 min_average_noise_antenna_i = INITIALIZATION_VALUE;
815 u16 rxon_chnum = INITIALIZATION_VALUE;
816 u16 stat_chnum = INITIALIZATION_VALUE;
820 struct stats_rx_non_phy *rx_info;
822 struct il_rxon_context *ctx = &il->ctx;
824 if (il->disable_chain_noise_cal)
827 data = &(il->chain_noise_data);
830 * Accumulate just the first "chain_noise_num_beacons" after
831 * the first association, then we're done forever.
833 if (data->state != IL_CHAIN_NOISE_ACCUMULATE) {
834 if (data->state == IL_CHAIN_NOISE_ALIVE)
835 D_CALIB("Wait for noise calib reset\n");
839 spin_lock_irqsave(&il->lock, flags);
841 rx_info = &(((struct il_notif_stats *)stat_resp)->
844 if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
845 D_CALIB(" << Interference data unavailable\n");
846 spin_unlock_irqrestore(&il->lock, flags);
850 rxon_band24 = !!(ctx->staging.flags & RXON_FLG_BAND_24G_MSK);
851 rxon_chnum = le16_to_cpu(ctx->staging.channel);
853 stat_band24 = !!(((struct il_notif_stats *)
855 STATS_REPLY_FLG_BAND_24G_MSK);
856 stat_chnum = le32_to_cpu(((struct il_notif_stats *)
857 stat_resp)->flag) >> 16;
859 /* Make sure we accumulate data for just the associated channel
860 * (even if scanning). */
861 if (rxon_chnum != stat_chnum || rxon_band24 != stat_band24) {
862 D_CALIB("Stats not from chan=%d, band24=%d\n",
863 rxon_chnum, rxon_band24);
864 spin_unlock_irqrestore(&il->lock, flags);
869 * Accumulate beacon stats values across
870 * "chain_noise_num_beacons"
872 chain_noise_a = le32_to_cpu(rx_info->beacon_silence_rssi_a) &
874 chain_noise_b = le32_to_cpu(rx_info->beacon_silence_rssi_b) &
876 chain_noise_c = le32_to_cpu(rx_info->beacon_silence_rssi_c) &
879 chain_sig_a = le32_to_cpu(rx_info->beacon_rssi_a) & IN_BAND_FILTER;
880 chain_sig_b = le32_to_cpu(rx_info->beacon_rssi_b) & IN_BAND_FILTER;
881 chain_sig_c = le32_to_cpu(rx_info->beacon_rssi_c) & IN_BAND_FILTER;
883 spin_unlock_irqrestore(&il->lock, flags);
885 data->beacon_count++;
887 data->chain_noise_a = (chain_noise_a + data->chain_noise_a);
888 data->chain_noise_b = (chain_noise_b + data->chain_noise_b);
889 data->chain_noise_c = (chain_noise_c + data->chain_noise_c);
891 data->chain_signal_a = (chain_sig_a + data->chain_signal_a);
892 data->chain_signal_b = (chain_sig_b + data->chain_signal_b);
893 data->chain_signal_c = (chain_sig_c + data->chain_signal_c);
895 D_CALIB("chan=%d, band24=%d, beacon=%d\n",
896 rxon_chnum, rxon_band24, data->beacon_count);
897 D_CALIB("chain_sig: a %d b %d c %d\n",
898 chain_sig_a, chain_sig_b, chain_sig_c);
899 D_CALIB("chain_noise: a %d b %d c %d\n",
900 chain_noise_a, chain_noise_b, chain_noise_c);
902 /* If this is the "chain_noise_num_beacons", determine:
903 * 1) Disconnected antennas (using signal strengths)
904 * 2) Differential gain (using silence noise) to balance receivers */
905 if (data->beacon_count !=
906 il->cfg->base_params->chain_noise_num_beacons)
909 /* Analyze signal for disconnected antenna */
910 il4965_find_disconn_antenna(il, average_sig, data);
912 /* Analyze noise for rx balance */
913 average_noise[0] = data->chain_noise_a /
914 il->cfg->base_params->chain_noise_num_beacons;
915 average_noise[1] = data->chain_noise_b /
916 il->cfg->base_params->chain_noise_num_beacons;
917 average_noise[2] = data->chain_noise_c /
918 il->cfg->base_params->chain_noise_num_beacons;
920 for (i = 0; i < NUM_RX_CHAINS; i++) {
921 if (!data->disconn_array[i] &&
922 average_noise[i] <= min_average_noise) {
923 /* This means that chain i is active and has
924 * lower noise values so far: */
925 min_average_noise = average_noise[i];
926 min_average_noise_antenna_i = i;
930 D_CALIB("average_noise: a %d b %d c %d\n",
931 average_noise[0], average_noise[1],
934 D_CALIB("min_average_noise = %d, antenna %d\n",
935 min_average_noise, min_average_noise_antenna_i);
937 il4965_gain_computation(il, average_noise,
938 min_average_noise_antenna_i, min_average_noise,
939 il4965_find_first_chain(il->cfg->valid_rx_ant));
941 /* Some power changes may have been made during the calibration.
942 * Update and commit the RXON
944 if (il->cfg->ops->lib->update_chain_flags)
945 il->cfg->ops->lib->update_chain_flags(il);
947 data->state = IL_CHAIN_NOISE_DONE;
948 il_power_update_mode(il, false);
951 void il4965_reset_run_time_calib(struct il_priv *il)
954 memset(&(il->sensitivity_data), 0,
955 sizeof(struct il_sensitivity_data));
956 memset(&(il->chain_noise_data), 0,
957 sizeof(struct il_chain_noise_data));
958 for (i = 0; i < NUM_RX_CHAINS; i++)
959 il->chain_noise_data.delta_gain_code[i] =
960 CHAIN_NOISE_DELTA_GAIN_INIT_VAL;
962 /* Ask for stats now, the uCode will send notification
963 * periodically after association */
964 il_send_stats_request(il, CMD_ASYNC, true);