2 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
3 <http://rt2x00.serialmonkey.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <http://www.gnu.org/licenses/>.
21 Abstract: rt2x00 generic link tuning routines.
24 #include <linux/kernel.h>
25 #include <linux/module.h>
28 #include "rt2x00lib.h"
31 * When we lack RSSI information return something less then -80 to
32 * tell the driver to tune the device to maximum sensitivity.
34 #define DEFAULT_RSSI -128
36 static inline int rt2x00link_get_avg_rssi(struct ewma_rssi
*ewma
)
40 avg
= ewma_rssi_read(ewma
);
47 static int rt2x00link_antenna_get_link_rssi(struct rt2x00_dev
*rt2x00dev
)
49 struct link_ant
*ant
= &rt2x00dev
->link
.ant
;
51 if (rt2x00dev
->link
.qual
.rx_success
)
52 return rt2x00link_get_avg_rssi(&ant
->rssi_ant
);
57 static int rt2x00link_antenna_get_rssi_history(struct rt2x00_dev
*rt2x00dev
)
59 struct link_ant
*ant
= &rt2x00dev
->link
.ant
;
61 if (ant
->rssi_history
)
62 return ant
->rssi_history
;
66 static void rt2x00link_antenna_update_rssi_history(struct rt2x00_dev
*rt2x00dev
,
69 struct link_ant
*ant
= &rt2x00dev
->link
.ant
;
70 ant
->rssi_history
= rssi
;
73 static void rt2x00link_antenna_reset(struct rt2x00_dev
*rt2x00dev
)
75 ewma_rssi_init(&rt2x00dev
->link
.ant
.rssi_ant
);
78 static void rt2x00lib_antenna_diversity_sample(struct rt2x00_dev
*rt2x00dev
)
80 struct link_ant
*ant
= &rt2x00dev
->link
.ant
;
81 struct antenna_setup new_ant
;
84 int sample_current
= rt2x00link_antenna_get_link_rssi(rt2x00dev
);
85 int sample_other
= rt2x00link_antenna_get_rssi_history(rt2x00dev
);
87 memcpy(&new_ant
, &ant
->active
, sizeof(new_ant
));
90 * We are done sampling. Now we should evaluate the results.
92 ant
->flags
&= ~ANTENNA_MODE_SAMPLE
;
95 * During the last period we have sampled the RSSI
96 * from both antennas. It now is time to determine
97 * which antenna demonstrated the best performance.
98 * When we are already on the antenna with the best
99 * performance, just create a good starting point
100 * for the history and we are done.
102 if (sample_current
>= sample_other
) {
103 rt2x00link_antenna_update_rssi_history(rt2x00dev
,
108 other_antenna
= (ant
->active
.rx
== ANTENNA_A
) ? ANTENNA_B
: ANTENNA_A
;
110 if (ant
->flags
& ANTENNA_RX_DIVERSITY
)
111 new_ant
.rx
= other_antenna
;
113 if (ant
->flags
& ANTENNA_TX_DIVERSITY
)
114 new_ant
.tx
= other_antenna
;
116 rt2x00lib_config_antenna(rt2x00dev
, new_ant
);
119 static void rt2x00lib_antenna_diversity_eval(struct rt2x00_dev
*rt2x00dev
)
121 struct link_ant
*ant
= &rt2x00dev
->link
.ant
;
122 struct antenna_setup new_ant
;
126 memcpy(&new_ant
, &ant
->active
, sizeof(new_ant
));
129 * Get current RSSI value along with the historical value,
130 * after that update the history with the current value.
132 rssi_curr
= rt2x00link_antenna_get_link_rssi(rt2x00dev
);
133 rssi_old
= rt2x00link_antenna_get_rssi_history(rt2x00dev
);
134 rt2x00link_antenna_update_rssi_history(rt2x00dev
, rssi_curr
);
137 * Legacy driver indicates that we should swap antenna's
138 * when the difference in RSSI is greater that 5. This
139 * also should be done when the RSSI was actually better
140 * then the previous sample.
141 * When the difference exceeds the threshold we should
142 * sample the rssi from the other antenna to make a valid
143 * comparison between the 2 antennas.
145 if (abs(rssi_curr
- rssi_old
) < 5)
148 ant
->flags
|= ANTENNA_MODE_SAMPLE
;
150 if (ant
->flags
& ANTENNA_RX_DIVERSITY
)
151 new_ant
.rx
= (new_ant
.rx
== ANTENNA_A
) ? ANTENNA_B
: ANTENNA_A
;
153 if (ant
->flags
& ANTENNA_TX_DIVERSITY
)
154 new_ant
.tx
= (new_ant
.tx
== ANTENNA_A
) ? ANTENNA_B
: ANTENNA_A
;
156 rt2x00lib_config_antenna(rt2x00dev
, new_ant
);
159 static bool rt2x00lib_antenna_diversity(struct rt2x00_dev
*rt2x00dev
)
161 struct link_ant
*ant
= &rt2x00dev
->link
.ant
;
164 * Determine if software diversity is enabled for
165 * either the TX or RX antenna (or both).
167 if (!(ant
->flags
& ANTENNA_RX_DIVERSITY
) &&
168 !(ant
->flags
& ANTENNA_TX_DIVERSITY
)) {
174 * If we have only sampled the data over the last period
175 * we should now harvest the data. Otherwise just evaluate
176 * the data. The latter should only be performed once
179 if (ant
->flags
& ANTENNA_MODE_SAMPLE
) {
180 rt2x00lib_antenna_diversity_sample(rt2x00dev
);
182 } else if (rt2x00dev
->link
.count
& 1) {
183 rt2x00lib_antenna_diversity_eval(rt2x00dev
);
190 void rt2x00link_update_stats(struct rt2x00_dev
*rt2x00dev
,
192 struct rxdone_entry_desc
*rxdesc
)
194 struct link
*link
= &rt2x00dev
->link
;
195 struct link_qual
*qual
= &rt2x00dev
->link
.qual
;
196 struct link_ant
*ant
= &rt2x00dev
->link
.ant
;
197 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
200 * No need to update the stats for !=STA interfaces
202 if (!rt2x00dev
->intf_sta_count
)
206 * Frame was received successfully since non-succesfull
207 * frames would have been dropped by the hardware.
212 * We are only interested in quality statistics from
213 * beacons which came from the BSS which we are
216 if (!ieee80211_is_beacon(hdr
->frame_control
) ||
217 !(rxdesc
->dev_flags
& RXDONE_MY_BSS
))
223 ewma_rssi_add(&link
->avg_rssi
, -rxdesc
->rssi
);
226 * Update antenna RSSI
228 ewma_rssi_add(&ant
->rssi_ant
, -rxdesc
->rssi
);
231 void rt2x00link_start_tuner(struct rt2x00_dev
*rt2x00dev
)
233 struct link
*link
= &rt2x00dev
->link
;
236 * Link tuning should only be performed when
237 * an active sta interface exists. AP interfaces
238 * don't need link tuning and monitor mode interfaces
239 * should never have to work with link tuners.
241 if (!rt2x00dev
->intf_sta_count
)
245 * While scanning, link tuning is disabled. By default
246 * the most sensitive settings will be used to make sure
247 * that all beacons and probe responses will be received
250 if (test_bit(DEVICE_STATE_SCANNING
, &rt2x00dev
->flags
))
253 rt2x00link_reset_tuner(rt2x00dev
, false);
255 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
256 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
257 &link
->work
, LINK_TUNE_INTERVAL
);
260 void rt2x00link_stop_tuner(struct rt2x00_dev
*rt2x00dev
)
262 cancel_delayed_work_sync(&rt2x00dev
->link
.work
);
265 void rt2x00link_reset_tuner(struct rt2x00_dev
*rt2x00dev
, bool antenna
)
267 struct link_qual
*qual
= &rt2x00dev
->link
.qual
;
268 u8 vgc_level
= qual
->vgc_level_reg
;
270 if (!test_bit(DEVICE_STATE_ENABLED_RADIO
, &rt2x00dev
->flags
))
274 * Reset link information.
275 * Both the currently active vgc level as well as
276 * the link tuner counter should be reset. Resetting
277 * the counter is important for devices where the
278 * device should only perform link tuning during the
279 * first minute after being enabled.
281 rt2x00dev
->link
.count
= 0;
282 memset(qual
, 0, sizeof(*qual
));
283 ewma_rssi_init(&rt2x00dev
->link
.avg_rssi
);
286 * Restore the VGC level as stored in the registers,
287 * the driver can use this to determine if the register
288 * must be updated during reset or not.
290 qual
->vgc_level_reg
= vgc_level
;
293 * Reset the link tuner.
295 rt2x00dev
->ops
->lib
->reset_tuner(rt2x00dev
, qual
);
298 rt2x00link_antenna_reset(rt2x00dev
);
301 static void rt2x00link_reset_qual(struct rt2x00_dev
*rt2x00dev
)
303 struct link_qual
*qual
= &rt2x00dev
->link
.qual
;
305 qual
->rx_success
= 0;
307 qual
->tx_success
= 0;
311 static void rt2x00link_tuner(struct work_struct
*work
)
313 struct rt2x00_dev
*rt2x00dev
=
314 container_of(work
, struct rt2x00_dev
, link
.work
.work
);
315 struct link
*link
= &rt2x00dev
->link
;
316 struct link_qual
*qual
= &rt2x00dev
->link
.qual
;
319 * When the radio is shutting down we should
320 * immediately cease all link tuning.
322 if (!test_bit(DEVICE_STATE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
323 test_bit(DEVICE_STATE_SCANNING
, &rt2x00dev
->flags
))
329 rt2x00dev
->ops
->lib
->link_stats(rt2x00dev
, qual
);
330 rt2x00dev
->low_level_stats
.dot11FCSErrorCount
+= qual
->rx_failed
;
333 * Update quality RSSI for link tuning,
334 * when we have received some frames and we managed to
335 * collect the RSSI data we could use this. Otherwise we
336 * must fallback to the default RSSI value.
338 if (!qual
->rx_success
)
339 qual
->rssi
= DEFAULT_RSSI
;
341 qual
->rssi
= rt2x00link_get_avg_rssi(&link
->avg_rssi
);
344 * Check if link tuning is supported by the hardware, some hardware
345 * do not support link tuning at all, while other devices can disable
346 * the feature from the EEPROM.
348 if (rt2x00_has_cap_link_tuning(rt2x00dev
))
349 rt2x00dev
->ops
->lib
->link_tuner(rt2x00dev
, qual
, link
->count
);
352 * Send a signal to the led to update the led signal strength.
354 rt2x00leds_led_quality(rt2x00dev
, qual
->rssi
);
357 * Evaluate antenna setup, make this the last step when
358 * rt2x00lib_antenna_diversity made changes the quality
359 * statistics will be reset.
361 if (rt2x00lib_antenna_diversity(rt2x00dev
))
362 rt2x00link_reset_qual(rt2x00dev
);
365 * Increase tuner counter, and reschedule the next link tuner run.
369 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
370 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
371 &link
->work
, LINK_TUNE_INTERVAL
);
374 void rt2x00link_start_watchdog(struct rt2x00_dev
*rt2x00dev
)
376 struct link
*link
= &rt2x00dev
->link
;
378 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
) &&
379 rt2x00dev
->ops
->lib
->watchdog
)
380 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
381 &link
->watchdog_work
,
385 void rt2x00link_stop_watchdog(struct rt2x00_dev
*rt2x00dev
)
387 cancel_delayed_work_sync(&rt2x00dev
->link
.watchdog_work
);
390 static void rt2x00link_watchdog(struct work_struct
*work
)
392 struct rt2x00_dev
*rt2x00dev
=
393 container_of(work
, struct rt2x00_dev
, link
.watchdog_work
.work
);
394 struct link
*link
= &rt2x00dev
->link
;
397 * When the radio is shutting down we should
398 * immediately cease the watchdog monitoring.
400 if (!test_bit(DEVICE_STATE_ENABLED_RADIO
, &rt2x00dev
->flags
))
403 rt2x00dev
->ops
->lib
->watchdog(rt2x00dev
);
405 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
406 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
407 &link
->watchdog_work
,
411 void rt2x00link_start_agc(struct rt2x00_dev
*rt2x00dev
)
413 struct link
*link
= &rt2x00dev
->link
;
415 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
) &&
416 rt2x00dev
->ops
->lib
->gain_calibration
)
417 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
422 void rt2x00link_start_vcocal(struct rt2x00_dev
*rt2x00dev
)
424 struct link
*link
= &rt2x00dev
->link
;
426 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
) &&
427 rt2x00dev
->ops
->lib
->vco_calibration
)
428 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
433 void rt2x00link_stop_agc(struct rt2x00_dev
*rt2x00dev
)
435 cancel_delayed_work_sync(&rt2x00dev
->link
.agc_work
);
438 void rt2x00link_stop_vcocal(struct rt2x00_dev
*rt2x00dev
)
440 cancel_delayed_work_sync(&rt2x00dev
->link
.vco_work
);
443 static void rt2x00link_agc(struct work_struct
*work
)
445 struct rt2x00_dev
*rt2x00dev
=
446 container_of(work
, struct rt2x00_dev
, link
.agc_work
.work
);
447 struct link
*link
= &rt2x00dev
->link
;
450 * When the radio is shutting down we should
451 * immediately cease the watchdog monitoring.
453 if (!test_bit(DEVICE_STATE_ENABLED_RADIO
, &rt2x00dev
->flags
))
456 rt2x00dev
->ops
->lib
->gain_calibration(rt2x00dev
);
458 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
459 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
464 static void rt2x00link_vcocal(struct work_struct
*work
)
466 struct rt2x00_dev
*rt2x00dev
=
467 container_of(work
, struct rt2x00_dev
, link
.vco_work
.work
);
468 struct link
*link
= &rt2x00dev
->link
;
471 * When the radio is shutting down we should
472 * immediately cease the VCO calibration.
474 if (!test_bit(DEVICE_STATE_ENABLED_RADIO
, &rt2x00dev
->flags
))
477 rt2x00dev
->ops
->lib
->vco_calibration(rt2x00dev
);
479 if (test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
480 ieee80211_queue_delayed_work(rt2x00dev
->hw
,
485 void rt2x00link_register(struct rt2x00_dev
*rt2x00dev
)
487 INIT_DELAYED_WORK(&rt2x00dev
->link
.agc_work
, rt2x00link_agc
);
488 if (rt2x00_has_cap_vco_recalibration(rt2x00dev
))
489 INIT_DELAYED_WORK(&rt2x00dev
->link
.vco_work
, rt2x00link_vcocal
);
490 INIT_DELAYED_WORK(&rt2x00dev
->link
.watchdog_work
, rt2x00link_watchdog
);
491 INIT_DELAYED_WORK(&rt2x00dev
->link
.work
, rt2x00link_tuner
);