aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlwifi/dvm/rs.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/iwlwifi/dvm/rs.c')
-rw-r--r--drivers/net/wireless/iwlwifi/dvm/rs.c3367
1 files changed, 3367 insertions, 0 deletions
diff --git a/drivers/net/wireless/iwlwifi/dvm/rs.c b/drivers/net/wireless/iwlwifi/dvm/rs.c
new file mode 100644
index 000000000000..6fddd2785e6e
--- /dev/null
+++ b/drivers/net/wireless/iwlwifi/dvm/rs.c
@@ -0,0 +1,3367 @@
1/******************************************************************************
2 *
3 * Copyright(c) 2005 - 2012 Intel Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 * The full GNU General Public License is included in this distribution in the
19 * file called LICENSE.
20 *
21 * Contact Information:
22 * Intel Linux Wireless <ilw@linux.intel.com>
23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24 *
25 *****************************************************************************/
26#include <linux/kernel.h>
27#include <linux/init.h>
28#include <linux/skbuff.h>
29#include <linux/slab.h>
30#include <net/mac80211.h>
31
32#include <linux/netdevice.h>
33#include <linux/etherdevice.h>
34#include <linux/delay.h>
35
36#include <linux/workqueue.h>
37
38#include "dev.h"
39#include "agn.h"
40
41#define RS_NAME "iwl-agn-rs"
42
43#define NUM_TRY_BEFORE_ANT_TOGGLE 1
44#define IWL_NUMBER_TRY 1
45#define IWL_HT_NUMBER_TRY 3
46
47#define IWL_RATE_MAX_WINDOW 62 /* # tx in history window */
48#define IWL_RATE_MIN_FAILURE_TH 6 /* min failures to calc tpt */
49#define IWL_RATE_MIN_SUCCESS_TH 8 /* min successes to calc tpt */
50
51/* max allowed rate miss before sync LQ cmd */
52#define IWL_MISSED_RATE_MAX 15
53/* max time to accum history 2 seconds */
54#define IWL_RATE_SCALE_FLUSH_INTVL (3*HZ)
55
56static u8 rs_ht_to_legacy[] = {
57 IWL_RATE_6M_INDEX, IWL_RATE_6M_INDEX,
58 IWL_RATE_6M_INDEX, IWL_RATE_6M_INDEX,
59 IWL_RATE_6M_INDEX,
60 IWL_RATE_6M_INDEX, IWL_RATE_9M_INDEX,
61 IWL_RATE_12M_INDEX, IWL_RATE_18M_INDEX,
62 IWL_RATE_24M_INDEX, IWL_RATE_36M_INDEX,
63 IWL_RATE_48M_INDEX, IWL_RATE_54M_INDEX
64};
65
66static const u8 ant_toggle_lookup[] = {
67 /*ANT_NONE -> */ ANT_NONE,
68 /*ANT_A -> */ ANT_B,
69 /*ANT_B -> */ ANT_C,
70 /*ANT_AB -> */ ANT_BC,
71 /*ANT_C -> */ ANT_A,
72 /*ANT_AC -> */ ANT_AB,
73 /*ANT_BC -> */ ANT_AC,
74 /*ANT_ABC -> */ ANT_ABC,
75};
76
77#define IWL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np) \
78 [IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP, \
79 IWL_RATE_SISO_##s##M_PLCP, \
80 IWL_RATE_MIMO2_##s##M_PLCP,\
81 IWL_RATE_MIMO3_##s##M_PLCP,\
82 IWL_RATE_##r##M_IEEE, \
83 IWL_RATE_##ip##M_INDEX, \
84 IWL_RATE_##in##M_INDEX, \
85 IWL_RATE_##rp##M_INDEX, \
86 IWL_RATE_##rn##M_INDEX, \
87 IWL_RATE_##pp##M_INDEX, \
88 IWL_RATE_##np##M_INDEX }
89
90/*
91 * Parameter order:
92 * rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
93 *
94 * If there isn't a valid next or previous rate then INV is used which
95 * maps to IWL_RATE_INVALID
96 *
97 */
98const struct iwl_rate_info iwl_rates[IWL_RATE_COUNT] = {
99 IWL_DECLARE_RATE_INFO(1, INV, INV, 2, INV, 2, INV, 2), /* 1mbps */
100 IWL_DECLARE_RATE_INFO(2, INV, 1, 5, 1, 5, 1, 5), /* 2mbps */
101 IWL_DECLARE_RATE_INFO(5, INV, 2, 6, 2, 11, 2, 11), /*5.5mbps */
102 IWL_DECLARE_RATE_INFO(11, INV, 9, 12, 9, 12, 5, 18), /* 11mbps */
103 IWL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11), /* 6mbps */
104 IWL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11), /* 9mbps */
105 IWL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18), /* 12mbps */
106 IWL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24), /* 18mbps */
107 IWL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36), /* 24mbps */
108 IWL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48), /* 36mbps */
109 IWL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54), /* 48mbps */
110 IWL_DECLARE_RATE_INFO(54, 54, 48, INV, 48, INV, 48, INV),/* 54mbps */
111 IWL_DECLARE_RATE_INFO(60, 60, 48, INV, 48, INV, 48, INV),/* 60mbps */
112 /* FIXME:RS: ^^ should be INV (legacy) */
113};
114
115static inline u8 rs_extract_rate(u32 rate_n_flags)
116{
117 return (u8)(rate_n_flags & RATE_MCS_RATE_MSK);
118}
119
120static int iwl_hwrate_to_plcp_idx(u32 rate_n_flags)
121{
122 int idx = 0;
123
124 /* HT rate format */
125 if (rate_n_flags & RATE_MCS_HT_MSK) {
126 idx = rs_extract_rate(rate_n_flags);
127
128 if (idx >= IWL_RATE_MIMO3_6M_PLCP)
129 idx = idx - IWL_RATE_MIMO3_6M_PLCP;
130 else if (idx >= IWL_RATE_MIMO2_6M_PLCP)
131 idx = idx - IWL_RATE_MIMO2_6M_PLCP;
132
133 idx += IWL_FIRST_OFDM_RATE;
134 /* skip 9M not supported in ht*/
135 if (idx >= IWL_RATE_9M_INDEX)
136 idx += 1;
137 if ((idx >= IWL_FIRST_OFDM_RATE) && (idx <= IWL_LAST_OFDM_RATE))
138 return idx;
139
140 /* legacy rate format, search for match in table */
141 } else {
142 for (idx = 0; idx < ARRAY_SIZE(iwl_rates); idx++)
143 if (iwl_rates[idx].plcp ==
144 rs_extract_rate(rate_n_flags))
145 return idx;
146 }
147
148 return -1;
149}
150
151static void rs_rate_scale_perform(struct iwl_priv *priv,
152 struct sk_buff *skb,
153 struct ieee80211_sta *sta,
154 struct iwl_lq_sta *lq_sta);
155static void rs_fill_link_cmd(struct iwl_priv *priv,
156 struct iwl_lq_sta *lq_sta, u32 rate_n_flags);
157static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search);
158
159
160#ifdef CONFIG_MAC80211_DEBUGFS
161static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
162 u32 *rate_n_flags, int index);
163#else
164static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
165 u32 *rate_n_flags, int index)
166{}
167#endif
168
169/**
170 * The following tables contain the expected throughput metrics for all rates
171 *
172 * 1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 60 MBits
173 *
174 * where invalid entries are zeros.
175 *
176 * CCK rates are only valid in legacy table and will only be used in G
177 * (2.4 GHz) band.
178 */
179
180static s32 expected_tpt_legacy[IWL_RATE_COUNT] = {
181 7, 13, 35, 58, 40, 57, 72, 98, 121, 154, 177, 186, 0
182};
183
184static s32 expected_tpt_siso20MHz[4][IWL_RATE_COUNT] = {
185 {0, 0, 0, 0, 42, 0, 76, 102, 124, 159, 183, 193, 202}, /* Norm */
186 {0, 0, 0, 0, 46, 0, 82, 110, 132, 168, 192, 202, 210}, /* SGI */
187 {0, 0, 0, 0, 47, 0, 91, 133, 171, 242, 305, 334, 362}, /* AGG */
188 {0, 0, 0, 0, 52, 0, 101, 145, 187, 264, 330, 361, 390}, /* AGG+SGI */
189};
190
191static s32 expected_tpt_siso40MHz[4][IWL_RATE_COUNT] = {
192 {0, 0, 0, 0, 77, 0, 127, 160, 184, 220, 242, 250, 257}, /* Norm */
193 {0, 0, 0, 0, 83, 0, 135, 169, 193, 229, 250, 257, 264}, /* SGI */
194 {0, 0, 0, 0, 94, 0, 177, 249, 313, 423, 512, 550, 586}, /* AGG */
195 {0, 0, 0, 0, 104, 0, 193, 270, 338, 454, 545, 584, 620}, /* AGG+SGI */
196};
197
198static s32 expected_tpt_mimo2_20MHz[4][IWL_RATE_COUNT] = {
199 {0, 0, 0, 0, 74, 0, 123, 155, 179, 214, 236, 244, 251}, /* Norm */
200 {0, 0, 0, 0, 81, 0, 131, 164, 188, 223, 243, 251, 257}, /* SGI */
201 {0, 0, 0, 0, 89, 0, 167, 235, 296, 402, 488, 526, 560}, /* AGG */
202 {0, 0, 0, 0, 97, 0, 182, 255, 320, 431, 520, 558, 593}, /* AGG+SGI*/
203};
204
205static s32 expected_tpt_mimo2_40MHz[4][IWL_RATE_COUNT] = {
206 {0, 0, 0, 0, 123, 0, 182, 214, 235, 264, 279, 285, 289}, /* Norm */
207 {0, 0, 0, 0, 131, 0, 191, 222, 242, 270, 284, 289, 293}, /* SGI */
208 {0, 0, 0, 0, 171, 0, 305, 410, 496, 634, 731, 771, 805}, /* AGG */
209 {0, 0, 0, 0, 186, 0, 329, 439, 527, 667, 764, 803, 838}, /* AGG+SGI */
210};
211
212static s32 expected_tpt_mimo3_20MHz[4][IWL_RATE_COUNT] = {
213 {0, 0, 0, 0, 99, 0, 153, 186, 208, 239, 256, 263, 268}, /* Norm */
214 {0, 0, 0, 0, 106, 0, 162, 194, 215, 246, 262, 268, 273}, /* SGI */
215 {0, 0, 0, 0, 134, 0, 249, 346, 431, 574, 685, 732, 775}, /* AGG */
216 {0, 0, 0, 0, 148, 0, 272, 376, 465, 614, 727, 775, 818}, /* AGG+SGI */
217};
218
219static s32 expected_tpt_mimo3_40MHz[4][IWL_RATE_COUNT] = {
220 {0, 0, 0, 0, 152, 0, 211, 239, 255, 279, 290, 294, 297}, /* Norm */
221 {0, 0, 0, 0, 160, 0, 219, 245, 261, 284, 294, 297, 300}, /* SGI */
222 {0, 0, 0, 0, 254, 0, 443, 584, 695, 868, 984, 1030, 1070}, /* AGG */
223 {0, 0, 0, 0, 277, 0, 478, 624, 737, 911, 1026, 1070, 1109}, /* AGG+SGI */
224};
225
226/* mbps, mcs */
227static const struct iwl_rate_mcs_info iwl_rate_mcs[IWL_RATE_COUNT] = {
228 { "1", "BPSK DSSS"},
229 { "2", "QPSK DSSS"},
230 {"5.5", "BPSK CCK"},
231 { "11", "QPSK CCK"},
232 { "6", "BPSK 1/2"},
233 { "9", "BPSK 1/2"},
234 { "12", "QPSK 1/2"},
235 { "18", "QPSK 3/4"},
236 { "24", "16QAM 1/2"},
237 { "36", "16QAM 3/4"},
238 { "48", "64QAM 2/3"},
239 { "54", "64QAM 3/4"},
240 { "60", "64QAM 5/6"},
241};
242
243#define MCS_INDEX_PER_STREAM (8)
244
245static void rs_rate_scale_clear_window(struct iwl_rate_scale_data *window)
246{
247 window->data = 0;
248 window->success_counter = 0;
249 window->success_ratio = IWL_INVALID_VALUE;
250 window->counter = 0;
251 window->average_tpt = IWL_INVALID_VALUE;
252 window->stamp = 0;
253}
254
255static inline u8 rs_is_valid_ant(u8 valid_antenna, u8 ant_type)
256{
257 return (ant_type & valid_antenna) == ant_type;
258}
259
260/*
261 * removes the old data from the statistics. All data that is older than
262 * TID_MAX_TIME_DIFF, will be deleted.
263 */
264static void rs_tl_rm_old_stats(struct iwl_traffic_load *tl, u32 curr_time)
265{
266 /* The oldest age we want to keep */
267 u32 oldest_time = curr_time - TID_MAX_TIME_DIFF;
268
269 while (tl->queue_count &&
270 (tl->time_stamp < oldest_time)) {
271 tl->total -= tl->packet_count[tl->head];
272 tl->packet_count[tl->head] = 0;
273 tl->time_stamp += TID_QUEUE_CELL_SPACING;
274 tl->queue_count--;
275 tl->head++;
276 if (tl->head >= TID_QUEUE_MAX_SIZE)
277 tl->head = 0;
278 }
279}
280
281/*
282 * increment traffic load value for tid and also remove
283 * any old values if passed the certain time period
284 */
285static u8 rs_tl_add_packet(struct iwl_lq_sta *lq_data,
286 struct ieee80211_hdr *hdr)
287{
288 u32 curr_time = jiffies_to_msecs(jiffies);
289 u32 time_diff;
290 s32 index;
291 struct iwl_traffic_load *tl = NULL;
292 u8 tid;
293
294 if (ieee80211_is_data_qos(hdr->frame_control)) {
295 u8 *qc = ieee80211_get_qos_ctl(hdr);
296 tid = qc[0] & 0xf;
297 } else
298 return IWL_MAX_TID_COUNT;
299
300 if (unlikely(tid >= IWL_MAX_TID_COUNT))
301 return IWL_MAX_TID_COUNT;
302
303 tl = &lq_data->load[tid];
304
305 curr_time -= curr_time % TID_ROUND_VALUE;
306
307 /* Happens only for the first packet. Initialize the data */
308 if (!(tl->queue_count)) {
309 tl->total = 1;
310 tl->time_stamp = curr_time;
311 tl->queue_count = 1;
312 tl->head = 0;
313 tl->packet_count[0] = 1;
314 return IWL_MAX_TID_COUNT;
315 }
316
317 time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
318 index = time_diff / TID_QUEUE_CELL_SPACING;
319
320 /* The history is too long: remove data that is older than */
321 /* TID_MAX_TIME_DIFF */
322 if (index >= TID_QUEUE_MAX_SIZE)
323 rs_tl_rm_old_stats(tl, curr_time);
324
325 index = (tl->head + index) % TID_QUEUE_MAX_SIZE;
326 tl->packet_count[index] = tl->packet_count[index] + 1;
327 tl->total = tl->total + 1;
328
329 if ((index + 1) > tl->queue_count)
330 tl->queue_count = index + 1;
331
332 return tid;
333}
334
335#ifdef CONFIG_MAC80211_DEBUGFS
336/**
337 * Program the device to use fixed rate for frame transmit
338 * This is for debugging/testing only
339 * once the device start use fixed rate, we need to reload the module
340 * to being back the normal operation.
341 */
342static void rs_program_fix_rate(struct iwl_priv *priv,
343 struct iwl_lq_sta *lq_sta)
344{
345 struct iwl_station_priv *sta_priv =
346 container_of(lq_sta, struct iwl_station_priv, lq_sta);
347 struct iwl_rxon_context *ctx = sta_priv->ctx;
348
349 lq_sta->active_legacy_rate = 0x0FFF; /* 1 - 54 MBits, includes CCK */
350 lq_sta->active_siso_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
351 lq_sta->active_mimo2_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
352 lq_sta->active_mimo3_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
353
354#ifdef CONFIG_IWLWIFI_DEVICE_TESTMODE
355 /* testmode has higher priority to overwirte the fixed rate */
356 if (priv->tm_fixed_rate)
357 lq_sta->dbg_fixed_rate = priv->tm_fixed_rate;
358#endif
359
360 IWL_DEBUG_RATE(priv, "sta_id %d rate 0x%X\n",
361 lq_sta->lq.sta_id, lq_sta->dbg_fixed_rate);
362
363 if (lq_sta->dbg_fixed_rate) {
364 rs_fill_link_cmd(NULL, lq_sta, lq_sta->dbg_fixed_rate);
365 iwl_send_lq_cmd(lq_sta->drv, ctx, &lq_sta->lq, CMD_ASYNC,
366 false);
367 }
368}
369#endif
370
371/*
372 get the traffic load value for tid
373*/
374static u32 rs_tl_get_load(struct iwl_lq_sta *lq_data, u8 tid)
375{
376 u32 curr_time = jiffies_to_msecs(jiffies);
377 u32 time_diff;
378 s32 index;
379 struct iwl_traffic_load *tl = NULL;
380
381 if (tid >= IWL_MAX_TID_COUNT)
382 return 0;
383
384 tl = &(lq_data->load[tid]);
385
386 curr_time -= curr_time % TID_ROUND_VALUE;
387
388 if (!(tl->queue_count))
389 return 0;
390
391 time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
392 index = time_diff / TID_QUEUE_CELL_SPACING;
393
394 /* The history is too long: remove data that is older than */
395 /* TID_MAX_TIME_DIFF */
396 if (index >= TID_QUEUE_MAX_SIZE)
397 rs_tl_rm_old_stats(tl, curr_time);
398
399 return tl->total;
400}
401
402static int rs_tl_turn_on_agg_for_tid(struct iwl_priv *priv,
403 struct iwl_lq_sta *lq_data, u8 tid,
404 struct ieee80211_sta *sta)
405{
406 int ret = -EAGAIN;
407 u32 load;
408
409 /*
410 * Don't create TX aggregation sessions when in high
411 * BT traffic, as they would just be disrupted by BT.
412 */
413 if (priv->bt_traffic_load >= IWL_BT_COEX_TRAFFIC_LOAD_HIGH) {
414 IWL_ERR(priv, "BT traffic (%d), no aggregation allowed\n",
415 priv->bt_traffic_load);
416 return ret;
417 }
418
419 load = rs_tl_get_load(lq_data, tid);
420
421 if ((iwlwifi_mod_params.auto_agg) || (load > IWL_AGG_LOAD_THRESHOLD)) {
422 IWL_DEBUG_HT(priv, "Starting Tx agg: STA: %pM tid: %d\n",
423 sta->addr, tid);
424 ret = ieee80211_start_tx_ba_session(sta, tid, 5000);
425 if (ret == -EAGAIN) {
426 /*
427 * driver and mac80211 is out of sync
428 * this might be cause by reloading firmware
429 * stop the tx ba session here
430 */
431 IWL_ERR(priv, "Fail start Tx agg on tid: %d\n",
432 tid);
433 ieee80211_stop_tx_ba_session(sta, tid);
434 }
435 } else {
436 IWL_DEBUG_HT(priv, "Aggregation not enabled for tid %d "
437 "because load = %u\n", tid, load);
438 }
439 return ret;
440}
441
442static void rs_tl_turn_on_agg(struct iwl_priv *priv, u8 tid,
443 struct iwl_lq_sta *lq_data,
444 struct ieee80211_sta *sta)
445{
446 if (tid < IWL_MAX_TID_COUNT)
447 rs_tl_turn_on_agg_for_tid(priv, lq_data, tid, sta);
448 else
449 IWL_ERR(priv, "tid exceeds max TID count: %d/%d\n",
450 tid, IWL_MAX_TID_COUNT);
451}
452
453static inline int get_num_of_ant_from_rate(u32 rate_n_flags)
454{
455 return !!(rate_n_flags & RATE_MCS_ANT_A_MSK) +
456 !!(rate_n_flags & RATE_MCS_ANT_B_MSK) +
457 !!(rate_n_flags & RATE_MCS_ANT_C_MSK);
458}
459
460/*
461 * Static function to get the expected throughput from an iwl_scale_tbl_info
462 * that wraps a NULL pointer check
463 */
464static s32 get_expected_tpt(struct iwl_scale_tbl_info *tbl, int rs_index)
465{
466 if (tbl->expected_tpt)
467 return tbl->expected_tpt[rs_index];
468 return 0;
469}
470
471/**
472 * rs_collect_tx_data - Update the success/failure sliding window
473 *
474 * We keep a sliding window of the last 62 packets transmitted
475 * at this rate. window->data contains the bitmask of successful
476 * packets.
477 */
478static int rs_collect_tx_data(struct iwl_scale_tbl_info *tbl,
479 int scale_index, int attempts, int successes)
480{
481 struct iwl_rate_scale_data *window = NULL;
482 static const u64 mask = (((u64)1) << (IWL_RATE_MAX_WINDOW - 1));
483 s32 fail_count, tpt;
484
485 if (scale_index < 0 || scale_index >= IWL_RATE_COUNT)
486 return -EINVAL;
487
488 /* Select window for current tx bit rate */
489 window = &(tbl->win[scale_index]);
490
491 /* Get expected throughput */
492 tpt = get_expected_tpt(tbl, scale_index);
493
494 /*
495 * Keep track of only the latest 62 tx frame attempts in this rate's
496 * history window; anything older isn't really relevant any more.
497 * If we have filled up the sliding window, drop the oldest attempt;
498 * if the oldest attempt (highest bit in bitmap) shows "success",
499 * subtract "1" from the success counter (this is the main reason
500 * we keep these bitmaps!).
501 */
502 while (attempts > 0) {
503 if (window->counter >= IWL_RATE_MAX_WINDOW) {
504
505 /* remove earliest */
506 window->counter = IWL_RATE_MAX_WINDOW - 1;
507
508 if (window->data & mask) {
509 window->data &= ~mask;
510 window->success_counter--;
511 }
512 }
513
514 /* Increment frames-attempted counter */
515 window->counter++;
516
517 /* Shift bitmap by one frame to throw away oldest history */
518 window->data <<= 1;
519
520 /* Mark the most recent #successes attempts as successful */
521 if (successes > 0) {
522 window->success_counter++;
523 window->data |= 0x1;
524 successes--;
525 }
526
527 attempts--;
528 }
529
530 /* Calculate current success ratio, avoid divide-by-0! */
531 if (window->counter > 0)
532 window->success_ratio = 128 * (100 * window->success_counter)
533 / window->counter;
534 else
535 window->success_ratio = IWL_INVALID_VALUE;
536
537 fail_count = window->counter - window->success_counter;
538
539 /* Calculate average throughput, if we have enough history. */
540 if ((fail_count >= IWL_RATE_MIN_FAILURE_TH) ||
541 (window->success_counter >= IWL_RATE_MIN_SUCCESS_TH))
542 window->average_tpt = (window->success_ratio * tpt + 64) / 128;
543 else
544 window->average_tpt = IWL_INVALID_VALUE;
545
546 /* Tag this window as having been updated */
547 window->stamp = jiffies;
548
549 return 0;
550}
551
552/*
553 * Fill uCode API rate_n_flags field, based on "search" or "active" table.
554 */
555/* FIXME:RS:remove this function and put the flags statically in the table */
556static u32 rate_n_flags_from_tbl(struct iwl_priv *priv,
557 struct iwl_scale_tbl_info *tbl,
558 int index, u8 use_green)
559{
560 u32 rate_n_flags = 0;
561
562 if (is_legacy(tbl->lq_type)) {
563 rate_n_flags = iwl_rates[index].plcp;
564 if (index >= IWL_FIRST_CCK_RATE && index <= IWL_LAST_CCK_RATE)
565 rate_n_flags |= RATE_MCS_CCK_MSK;
566
567 } else if (is_Ht(tbl->lq_type)) {
568 if (index > IWL_LAST_OFDM_RATE) {
569 IWL_ERR(priv, "Invalid HT rate index %d\n", index);
570 index = IWL_LAST_OFDM_RATE;
571 }
572 rate_n_flags = RATE_MCS_HT_MSK;
573
574 if (is_siso(tbl->lq_type))
575 rate_n_flags |= iwl_rates[index].plcp_siso;
576 else if (is_mimo2(tbl->lq_type))
577 rate_n_flags |= iwl_rates[index].plcp_mimo2;
578 else
579 rate_n_flags |= iwl_rates[index].plcp_mimo3;
580 } else {
581 IWL_ERR(priv, "Invalid tbl->lq_type %d\n", tbl->lq_type);
582 }
583
584 rate_n_flags |= ((tbl->ant_type << RATE_MCS_ANT_POS) &
585 RATE_MCS_ANT_ABC_MSK);
586
587 if (is_Ht(tbl->lq_type)) {
588 if (tbl->is_ht40) {
589 if (tbl->is_dup)
590 rate_n_flags |= RATE_MCS_DUP_MSK;
591 else
592 rate_n_flags |= RATE_MCS_HT40_MSK;
593 }
594 if (tbl->is_SGI)
595 rate_n_flags |= RATE_MCS_SGI_MSK;
596
597 if (use_green) {
598 rate_n_flags |= RATE_MCS_GF_MSK;
599 if (is_siso(tbl->lq_type) && tbl->is_SGI) {
600 rate_n_flags &= ~RATE_MCS_SGI_MSK;
601 IWL_ERR(priv, "GF was set with SGI:SISO\n");
602 }
603 }
604 }
605 return rate_n_flags;
606}
607
608/*
609 * Interpret uCode API's rate_n_flags format,
610 * fill "search" or "active" tx mode table.
611 */
612static int rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
613 enum ieee80211_band band,
614 struct iwl_scale_tbl_info *tbl,
615 int *rate_idx)
616{
617 u32 ant_msk = (rate_n_flags & RATE_MCS_ANT_ABC_MSK);
618 u8 num_of_ant = get_num_of_ant_from_rate(rate_n_flags);
619 u8 mcs;
620
621 memset(tbl, 0, sizeof(struct iwl_scale_tbl_info));
622 *rate_idx = iwl_hwrate_to_plcp_idx(rate_n_flags);
623
624 if (*rate_idx == IWL_RATE_INVALID) {
625 *rate_idx = -1;
626 return -EINVAL;
627 }
628 tbl->is_SGI = 0; /* default legacy setup */
629 tbl->is_ht40 = 0;
630 tbl->is_dup = 0;
631 tbl->ant_type = (ant_msk >> RATE_MCS_ANT_POS);
632 tbl->lq_type = LQ_NONE;
633 tbl->max_search = IWL_MAX_SEARCH;
634
635 /* legacy rate format */
636 if (!(rate_n_flags & RATE_MCS_HT_MSK)) {
637 if (num_of_ant == 1) {
638 if (band == IEEE80211_BAND_5GHZ)
639 tbl->lq_type = LQ_A;
640 else
641 tbl->lq_type = LQ_G;
642 }
643 /* HT rate format */
644 } else {
645 if (rate_n_flags & RATE_MCS_SGI_MSK)
646 tbl->is_SGI = 1;
647
648 if ((rate_n_flags & RATE_MCS_HT40_MSK) ||
649 (rate_n_flags & RATE_MCS_DUP_MSK))
650 tbl->is_ht40 = 1;
651
652 if (rate_n_flags & RATE_MCS_DUP_MSK)
653 tbl->is_dup = 1;
654
655 mcs = rs_extract_rate(rate_n_flags);
656
657 /* SISO */
658 if (mcs <= IWL_RATE_SISO_60M_PLCP) {
659 if (num_of_ant == 1)
660 tbl->lq_type = LQ_SISO; /*else NONE*/
661 /* MIMO2 */
662 } else if (mcs <= IWL_RATE_MIMO2_60M_PLCP) {
663 if (num_of_ant == 2)
664 tbl->lq_type = LQ_MIMO2;
665 /* MIMO3 */
666 } else {
667 if (num_of_ant == 3) {
668 tbl->max_search = IWL_MAX_11N_MIMO3_SEARCH;
669 tbl->lq_type = LQ_MIMO3;
670 }
671 }
672 }
673 return 0;
674}
675
676/* switch to another antenna/antennas and return 1 */
677/* if no other valid antenna found, return 0 */
678static int rs_toggle_antenna(u32 valid_ant, u32 *rate_n_flags,
679 struct iwl_scale_tbl_info *tbl)
680{
681 u8 new_ant_type;
682
683 if (!tbl->ant_type || tbl->ant_type > ANT_ABC)
684 return 0;
685
686 if (!rs_is_valid_ant(valid_ant, tbl->ant_type))
687 return 0;
688
689 new_ant_type = ant_toggle_lookup[tbl->ant_type];
690
691 while ((new_ant_type != tbl->ant_type) &&
692 !rs_is_valid_ant(valid_ant, new_ant_type))
693 new_ant_type = ant_toggle_lookup[new_ant_type];
694
695 if (new_ant_type == tbl->ant_type)
696 return 0;
697
698 tbl->ant_type = new_ant_type;
699 *rate_n_flags &= ~RATE_MCS_ANT_ABC_MSK;
700 *rate_n_flags |= new_ant_type << RATE_MCS_ANT_POS;
701 return 1;
702}
703
704/**
705 * Green-field mode is valid if the station supports it and
706 * there are no non-GF stations present in the BSS.
707 */
708static bool rs_use_green(struct ieee80211_sta *sta)
709{
710 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
711 struct iwl_rxon_context *ctx = sta_priv->ctx;
712
713 return (sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD) &&
714 !(ctx->ht.non_gf_sta_present);
715}
716
717/**
718 * rs_get_supported_rates - get the available rates
719 *
720 * if management frame or broadcast frame only return
721 * basic available rates.
722 *
723 */
724static u16 rs_get_supported_rates(struct iwl_lq_sta *lq_sta,
725 struct ieee80211_hdr *hdr,
726 enum iwl_table_type rate_type)
727{
728 if (is_legacy(rate_type)) {
729 return lq_sta->active_legacy_rate;
730 } else {
731 if (is_siso(rate_type))
732 return lq_sta->active_siso_rate;
733 else if (is_mimo2(rate_type))
734 return lq_sta->active_mimo2_rate;
735 else
736 return lq_sta->active_mimo3_rate;
737 }
738}
739
740static u16 rs_get_adjacent_rate(struct iwl_priv *priv, u8 index, u16 rate_mask,
741 int rate_type)
742{
743 u8 high = IWL_RATE_INVALID;
744 u8 low = IWL_RATE_INVALID;
745
746 /* 802.11A or ht walks to the next literal adjacent rate in
747 * the rate table */
748 if (is_a_band(rate_type) || !is_legacy(rate_type)) {
749 int i;
750 u32 mask;
751
752 /* Find the previous rate that is in the rate mask */
753 i = index - 1;
754 for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
755 if (rate_mask & mask) {
756 low = i;
757 break;
758 }
759 }
760
761 /* Find the next rate that is in the rate mask */
762 i = index + 1;
763 for (mask = (1 << i); i < IWL_RATE_COUNT; i++, mask <<= 1) {
764 if (rate_mask & mask) {
765 high = i;
766 break;
767 }
768 }
769
770 return (high << 8) | low;
771 }
772
773 low = index;
774 while (low != IWL_RATE_INVALID) {
775 low = iwl_rates[low].prev_rs;
776 if (low == IWL_RATE_INVALID)
777 break;
778 if (rate_mask & (1 << low))
779 break;
780 IWL_DEBUG_RATE(priv, "Skipping masked lower rate: %d\n", low);
781 }
782
783 high = index;
784 while (high != IWL_RATE_INVALID) {
785 high = iwl_rates[high].next_rs;
786 if (high == IWL_RATE_INVALID)
787 break;
788 if (rate_mask & (1 << high))
789 break;
790 IWL_DEBUG_RATE(priv, "Skipping masked higher rate: %d\n", high);
791 }
792
793 return (high << 8) | low;
794}
795
796static u32 rs_get_lower_rate(struct iwl_lq_sta *lq_sta,
797 struct iwl_scale_tbl_info *tbl,
798 u8 scale_index, u8 ht_possible)
799{
800 s32 low;
801 u16 rate_mask;
802 u16 high_low;
803 u8 switch_to_legacy = 0;
804 u8 is_green = lq_sta->is_green;
805 struct iwl_priv *priv = lq_sta->drv;
806
807 /* check if we need to switch from HT to legacy rates.
808 * assumption is that mandatory rates (1Mbps or 6Mbps)
809 * are always supported (spec demand) */
810 if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_index)) {
811 switch_to_legacy = 1;
812 scale_index = rs_ht_to_legacy[scale_index];
813 if (lq_sta->band == IEEE80211_BAND_5GHZ)
814 tbl->lq_type = LQ_A;
815 else
816 tbl->lq_type = LQ_G;
817
818 if (num_of_ant(tbl->ant_type) > 1)
819 tbl->ant_type =
820 first_antenna(priv->eeprom_data->valid_tx_ant);
821
822 tbl->is_ht40 = 0;
823 tbl->is_SGI = 0;
824 tbl->max_search = IWL_MAX_SEARCH;
825 }
826
827 rate_mask = rs_get_supported_rates(lq_sta, NULL, tbl->lq_type);
828
829 /* Mask with station rate restriction */
830 if (is_legacy(tbl->lq_type)) {
831 /* supp_rates has no CCK bits in A mode */
832 if (lq_sta->band == IEEE80211_BAND_5GHZ)
833 rate_mask = (u16)(rate_mask &
834 (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
835 else
836 rate_mask = (u16)(rate_mask & lq_sta->supp_rates);
837 }
838
839 /* If we switched from HT to legacy, check current rate */
840 if (switch_to_legacy && (rate_mask & (1 << scale_index))) {
841 low = scale_index;
842 goto out;
843 }
844
845 high_low = rs_get_adjacent_rate(lq_sta->drv, scale_index, rate_mask,
846 tbl->lq_type);
847 low = high_low & 0xff;
848
849 if (low == IWL_RATE_INVALID)
850 low = scale_index;
851
852out:
853 return rate_n_flags_from_tbl(lq_sta->drv, tbl, low, is_green);
854}
855
856/*
857 * Simple function to compare two rate scale table types
858 */
859static bool table_type_matches(struct iwl_scale_tbl_info *a,
860 struct iwl_scale_tbl_info *b)
861{
862 return (a->lq_type == b->lq_type) && (a->ant_type == b->ant_type) &&
863 (a->is_SGI == b->is_SGI);
864}
865
866static void rs_bt_update_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
867 struct iwl_lq_sta *lq_sta)
868{
869 struct iwl_scale_tbl_info *tbl;
870 bool full_concurrent = priv->bt_full_concurrent;
871
872 if (priv->bt_ant_couple_ok) {
873 /*
874 * Is there a need to switch between
875 * full concurrency and 3-wire?
876 */
877 if (priv->bt_ci_compliance && priv->bt_ant_couple_ok)
878 full_concurrent = true;
879 else
880 full_concurrent = false;
881 }
882 if ((priv->bt_traffic_load != priv->last_bt_traffic_load) ||
883 (priv->bt_full_concurrent != full_concurrent)) {
884 priv->bt_full_concurrent = full_concurrent;
885 priv->last_bt_traffic_load = priv->bt_traffic_load;
886
887 /* Update uCode's rate table. */
888 tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
889 rs_fill_link_cmd(priv, lq_sta, tbl->current_rate);
890 iwl_send_lq_cmd(priv, ctx, &lq_sta->lq, CMD_ASYNC, false);
891
892 queue_work(priv->workqueue, &priv->bt_full_concurrency);
893 }
894}
895
896/*
897 * mac80211 sends us Tx status
898 */
899static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
900 struct ieee80211_sta *sta, void *priv_sta,
901 struct sk_buff *skb)
902{
903 int legacy_success;
904 int retries;
905 int rs_index, mac_index, i;
906 struct iwl_lq_sta *lq_sta = priv_sta;
907 struct iwl_link_quality_cmd *table;
908 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
909 struct iwl_op_mode *op_mode = (struct iwl_op_mode *)priv_r;
910 struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
911 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
912 enum mac80211_rate_control_flags mac_flags;
913 u32 tx_rate;
914 struct iwl_scale_tbl_info tbl_type;
915 struct iwl_scale_tbl_info *curr_tbl, *other_tbl, *tmp_tbl;
916 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
917 struct iwl_rxon_context *ctx = sta_priv->ctx;
918
919 IWL_DEBUG_RATE_LIMIT(priv, "get frame ack response, update rate scale window\n");
920
921 /* Treat uninitialized rate scaling data same as non-existing. */
922 if (!lq_sta) {
923 IWL_DEBUG_RATE(priv, "Station rate scaling not created yet.\n");
924 return;
925 } else if (!lq_sta->drv) {
926 IWL_DEBUG_RATE(priv, "Rate scaling not initialized yet.\n");
927 return;
928 }
929
930 if (!ieee80211_is_data(hdr->frame_control) ||
931 info->flags & IEEE80211_TX_CTL_NO_ACK)
932 return;
933
934 /* This packet was aggregated but doesn't carry status info */
935 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
936 !(info->flags & IEEE80211_TX_STAT_AMPDU))
937 return;
938
939 /*
940 * Ignore this Tx frame response if its initial rate doesn't match
941 * that of latest Link Quality command. There may be stragglers
942 * from a previous Link Quality command, but we're no longer interested
943 * in those; they're either from the "active" mode while we're trying
944 * to check "search" mode, or a prior "search" mode after we've moved
945 * to a new "search" mode (which might become the new "active" mode).
946 */
947 table = &lq_sta->lq;
948 tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
949 rs_get_tbl_info_from_mcs(tx_rate, priv->band, &tbl_type, &rs_index);
950 if (priv->band == IEEE80211_BAND_5GHZ)
951 rs_index -= IWL_FIRST_OFDM_RATE;
952 mac_flags = info->status.rates[0].flags;
953 mac_index = info->status.rates[0].idx;
954 /* For HT packets, map MCS to PLCP */
955 if (mac_flags & IEEE80211_TX_RC_MCS) {
956 mac_index &= RATE_MCS_CODE_MSK; /* Remove # of streams */
957 if (mac_index >= (IWL_RATE_9M_INDEX - IWL_FIRST_OFDM_RATE))
958 mac_index++;
959 /*
960 * mac80211 HT index is always zero-indexed; we need to move
961 * HT OFDM rates after CCK rates in 2.4 GHz band
962 */
963 if (priv->band == IEEE80211_BAND_2GHZ)
964 mac_index += IWL_FIRST_OFDM_RATE;
965 }
966 /* Here we actually compare this rate to the latest LQ command */
967 if ((mac_index < 0) ||
968 (tbl_type.is_SGI != !!(mac_flags & IEEE80211_TX_RC_SHORT_GI)) ||
969 (tbl_type.is_ht40 != !!(mac_flags & IEEE80211_TX_RC_40_MHZ_WIDTH)) ||
970 (tbl_type.is_dup != !!(mac_flags & IEEE80211_TX_RC_DUP_DATA)) ||
971 (tbl_type.ant_type != info->status.antenna) ||
972 (!!(tx_rate & RATE_MCS_HT_MSK) != !!(mac_flags & IEEE80211_TX_RC_MCS)) ||
973 (!!(tx_rate & RATE_MCS_GF_MSK) != !!(mac_flags & IEEE80211_TX_RC_GREEN_FIELD)) ||
974 (rs_index != mac_index)) {
975 IWL_DEBUG_RATE(priv, "initial rate %d does not match %d (0x%x)\n", mac_index, rs_index, tx_rate);
976 /*
977 * Since rates mis-match, the last LQ command may have failed.
978 * After IWL_MISSED_RATE_MAX mis-matches, resync the uCode with
979 * ... driver.
980 */
981 lq_sta->missed_rate_counter++;
982 if (lq_sta->missed_rate_counter > IWL_MISSED_RATE_MAX) {
983 lq_sta->missed_rate_counter = 0;
984 iwl_send_lq_cmd(priv, ctx, &lq_sta->lq, CMD_ASYNC, false);
985 }
986 /* Regardless, ignore this status info for outdated rate */
987 return;
988 } else
989 /* Rate did match, so reset the missed_rate_counter */
990 lq_sta->missed_rate_counter = 0;
991
992 /* Figure out if rate scale algorithm is in active or search table */
993 if (table_type_matches(&tbl_type,
994 &(lq_sta->lq_info[lq_sta->active_tbl]))) {
995 curr_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
996 other_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
997 } else if (table_type_matches(&tbl_type,
998 &lq_sta->lq_info[1 - lq_sta->active_tbl])) {
999 curr_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
1000 other_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1001 } else {
1002 IWL_DEBUG_RATE(priv, "Neither active nor search matches tx rate\n");
1003 tmp_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1004 IWL_DEBUG_RATE(priv, "active- lq:%x, ant:%x, SGI:%d\n",
1005 tmp_tbl->lq_type, tmp_tbl->ant_type, tmp_tbl->is_SGI);
1006 tmp_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
1007 IWL_DEBUG_RATE(priv, "search- lq:%x, ant:%x, SGI:%d\n",
1008 tmp_tbl->lq_type, tmp_tbl->ant_type, tmp_tbl->is_SGI);
1009 IWL_DEBUG_RATE(priv, "actual- lq:%x, ant:%x, SGI:%d\n",
1010 tbl_type.lq_type, tbl_type.ant_type, tbl_type.is_SGI);
1011 /*
1012 * no matching table found, let's by-pass the data collection
1013 * and continue to perform rate scale to find the rate table
1014 */
1015 rs_stay_in_table(lq_sta, true);
1016 goto done;
1017 }
1018
1019 /*
1020 * Updating the frame history depends on whether packets were
1021 * aggregated.
1022 *
1023 * For aggregation, all packets were transmitted at the same rate, the
1024 * first index into rate scale table.
1025 */
1026 if (info->flags & IEEE80211_TX_STAT_AMPDU) {
1027 tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
1028 rs_get_tbl_info_from_mcs(tx_rate, priv->band, &tbl_type,
1029 &rs_index);
1030 rs_collect_tx_data(curr_tbl, rs_index,
1031 info->status.ampdu_len,
1032 info->status.ampdu_ack_len);
1033
1034 /* Update success/fail counts if not searching for new mode */
1035 if (lq_sta->stay_in_tbl) {
1036 lq_sta->total_success += info->status.ampdu_ack_len;
1037 lq_sta->total_failed += (info->status.ampdu_len -
1038 info->status.ampdu_ack_len);
1039 }
1040 } else {
1041 /*
1042 * For legacy, update frame history with for each Tx retry.
1043 */
1044 retries = info->status.rates[0].count - 1;
1045 /* HW doesn't send more than 15 retries */
1046 retries = min(retries, 15);
1047
1048 /* The last transmission may have been successful */
1049 legacy_success = !!(info->flags & IEEE80211_TX_STAT_ACK);
1050 /* Collect data for each rate used during failed TX attempts */
1051 for (i = 0; i <= retries; ++i) {
1052 tx_rate = le32_to_cpu(table->rs_table[i].rate_n_flags);
1053 rs_get_tbl_info_from_mcs(tx_rate, priv->band,
1054 &tbl_type, &rs_index);
1055 /*
1056 * Only collect stats if retried rate is in the same RS
1057 * table as active/search.
1058 */
1059 if (table_type_matches(&tbl_type, curr_tbl))
1060 tmp_tbl = curr_tbl;
1061 else if (table_type_matches(&tbl_type, other_tbl))
1062 tmp_tbl = other_tbl;
1063 else
1064 continue;
1065 rs_collect_tx_data(tmp_tbl, rs_index, 1,
1066 i < retries ? 0 : legacy_success);
1067 }
1068
1069 /* Update success/fail counts if not searching for new mode */
1070 if (lq_sta->stay_in_tbl) {
1071 lq_sta->total_success += legacy_success;
1072 lq_sta->total_failed += retries + (1 - legacy_success);
1073 }
1074 }
1075 /* The last TX rate is cached in lq_sta; it's set in if/else above */
1076 lq_sta->last_rate_n_flags = tx_rate;
1077done:
1078 /* See if there's a better rate or modulation mode to try. */
1079 if (sta && sta->supp_rates[sband->band])
1080 rs_rate_scale_perform(priv, skb, sta, lq_sta);
1081
1082#if defined(CONFIG_MAC80211_DEBUGFS) && defined(CONFIG_IWLWIFI_DEVICE_TESTMODE)
1083 if ((priv->tm_fixed_rate) &&
1084 (priv->tm_fixed_rate != lq_sta->dbg_fixed_rate))
1085 rs_program_fix_rate(priv, lq_sta);
1086#endif
1087 if (priv->cfg->bt_params && priv->cfg->bt_params->advanced_bt_coexist)
1088 rs_bt_update_lq(priv, ctx, lq_sta);
1089}
1090
1091/*
1092 * Begin a period of staying with a selected modulation mode.
1093 * Set "stay_in_tbl" flag to prevent any mode switches.
1094 * Set frame tx success limits according to legacy vs. high-throughput,
1095 * and reset overall (spanning all rates) tx success history statistics.
1096 * These control how long we stay using same modulation mode before
1097 * searching for a new mode.
1098 */
1099static void rs_set_stay_in_table(struct iwl_priv *priv, u8 is_legacy,
1100 struct iwl_lq_sta *lq_sta)
1101{
1102 IWL_DEBUG_RATE(priv, "we are staying in the same table\n");
1103 lq_sta->stay_in_tbl = 1; /* only place this gets set */
1104 if (is_legacy) {
1105 lq_sta->table_count_limit = IWL_LEGACY_TABLE_COUNT;
1106 lq_sta->max_failure_limit = IWL_LEGACY_FAILURE_LIMIT;
1107 lq_sta->max_success_limit = IWL_LEGACY_SUCCESS_LIMIT;
1108 } else {
1109 lq_sta->table_count_limit = IWL_NONE_LEGACY_TABLE_COUNT;
1110 lq_sta->max_failure_limit = IWL_NONE_LEGACY_FAILURE_LIMIT;
1111 lq_sta->max_success_limit = IWL_NONE_LEGACY_SUCCESS_LIMIT;
1112 }
1113 lq_sta->table_count = 0;
1114 lq_sta->total_failed = 0;
1115 lq_sta->total_success = 0;
1116 lq_sta->flush_timer = jiffies;
1117 lq_sta->action_counter = 0;
1118}
1119
1120/*
1121 * Find correct throughput table for given mode of modulation
1122 */
1123static void rs_set_expected_tpt_table(struct iwl_lq_sta *lq_sta,
1124 struct iwl_scale_tbl_info *tbl)
1125{
1126 /* Used to choose among HT tables */
1127 s32 (*ht_tbl_pointer)[IWL_RATE_COUNT];
1128
1129 /* Check for invalid LQ type */
1130 if (WARN_ON_ONCE(!is_legacy(tbl->lq_type) && !is_Ht(tbl->lq_type))) {
1131 tbl->expected_tpt = expected_tpt_legacy;
1132 return;
1133 }
1134
1135 /* Legacy rates have only one table */
1136 if (is_legacy(tbl->lq_type)) {
1137 tbl->expected_tpt = expected_tpt_legacy;
1138 return;
1139 }
1140
1141 /* Choose among many HT tables depending on number of streams
1142 * (SISO/MIMO2/MIMO3), channel width (20/40), SGI, and aggregation
1143 * status */
1144 if (is_siso(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
1145 ht_tbl_pointer = expected_tpt_siso20MHz;
1146 else if (is_siso(tbl->lq_type))
1147 ht_tbl_pointer = expected_tpt_siso40MHz;
1148 else if (is_mimo2(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
1149 ht_tbl_pointer = expected_tpt_mimo2_20MHz;
1150 else if (is_mimo2(tbl->lq_type))
1151 ht_tbl_pointer = expected_tpt_mimo2_40MHz;
1152 else if (is_mimo3(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
1153 ht_tbl_pointer = expected_tpt_mimo3_20MHz;
1154 else /* if (is_mimo3(tbl->lq_type)) <-- must be true */
1155 ht_tbl_pointer = expected_tpt_mimo3_40MHz;
1156
1157 if (!tbl->is_SGI && !lq_sta->is_agg) /* Normal */
1158 tbl->expected_tpt = ht_tbl_pointer[0];
1159 else if (tbl->is_SGI && !lq_sta->is_agg) /* SGI */
1160 tbl->expected_tpt = ht_tbl_pointer[1];
1161 else if (!tbl->is_SGI && lq_sta->is_agg) /* AGG */
1162 tbl->expected_tpt = ht_tbl_pointer[2];
1163 else /* AGG+SGI */
1164 tbl->expected_tpt = ht_tbl_pointer[3];
1165}
1166
1167/*
1168 * Find starting rate for new "search" high-throughput mode of modulation.
1169 * Goal is to find lowest expected rate (under perfect conditions) that is
1170 * above the current measured throughput of "active" mode, to give new mode
1171 * a fair chance to prove itself without too many challenges.
1172 *
1173 * This gets called when transitioning to more aggressive modulation
1174 * (i.e. legacy to SISO or MIMO, or SISO to MIMO), as well as less aggressive
1175 * (i.e. MIMO to SISO). When moving to MIMO, bit rate will typically need
1176 * to decrease to match "active" throughput. When moving from MIMO to SISO,
1177 * bit rate will typically need to increase, but not if performance was bad.
1178 */
1179static s32 rs_get_best_rate(struct iwl_priv *priv,
1180 struct iwl_lq_sta *lq_sta,
1181 struct iwl_scale_tbl_info *tbl, /* "search" */
1182 u16 rate_mask, s8 index)
1183{
1184 /* "active" values */
1185 struct iwl_scale_tbl_info *active_tbl =
1186 &(lq_sta->lq_info[lq_sta->active_tbl]);
1187 s32 active_sr = active_tbl->win[index].success_ratio;
1188 s32 active_tpt = active_tbl->expected_tpt[index];
1189
1190 /* expected "search" throughput */
1191 s32 *tpt_tbl = tbl->expected_tpt;
1192
1193 s32 new_rate, high, low, start_hi;
1194 u16 high_low;
1195 s8 rate = index;
1196
1197 new_rate = high = low = start_hi = IWL_RATE_INVALID;
1198
1199 for (; ;) {
1200 high_low = rs_get_adjacent_rate(priv, rate, rate_mask,
1201 tbl->lq_type);
1202
1203 low = high_low & 0xff;
1204 high = (high_low >> 8) & 0xff;
1205
1206 /*
1207 * Lower the "search" bit rate, to give new "search" mode
1208 * approximately the same throughput as "active" if:
1209 *
1210 * 1) "Active" mode has been working modestly well (but not
1211 * great), and expected "search" throughput (under perfect
1212 * conditions) at candidate rate is above the actual
1213 * measured "active" throughput (but less than expected
1214 * "active" throughput under perfect conditions).
1215 * OR
1216 * 2) "Active" mode has been working perfectly or very well
1217 * and expected "search" throughput (under perfect
1218 * conditions) at candidate rate is above expected
1219 * "active" throughput (under perfect conditions).
1220 */
1221 if ((((100 * tpt_tbl[rate]) > lq_sta->last_tpt) &&
1222 ((active_sr > IWL_RATE_DECREASE_TH) &&
1223 (active_sr <= IWL_RATE_HIGH_TH) &&
1224 (tpt_tbl[rate] <= active_tpt))) ||
1225 ((active_sr >= IWL_RATE_SCALE_SWITCH) &&
1226 (tpt_tbl[rate] > active_tpt))) {
1227
1228 /* (2nd or later pass)
1229 * If we've already tried to raise the rate, and are
1230 * now trying to lower it, use the higher rate. */
1231 if (start_hi != IWL_RATE_INVALID) {
1232 new_rate = start_hi;
1233 break;
1234 }
1235
1236 new_rate = rate;
1237
1238 /* Loop again with lower rate */
1239 if (low != IWL_RATE_INVALID)
1240 rate = low;
1241
1242 /* Lower rate not available, use the original */
1243 else
1244 break;
1245
1246 /* Else try to raise the "search" rate to match "active" */
1247 } else {
1248 /* (2nd or later pass)
1249 * If we've already tried to lower the rate, and are
1250 * now trying to raise it, use the lower rate. */
1251 if (new_rate != IWL_RATE_INVALID)
1252 break;
1253
1254 /* Loop again with higher rate */
1255 else if (high != IWL_RATE_INVALID) {
1256 start_hi = high;
1257 rate = high;
1258
1259 /* Higher rate not available, use the original */
1260 } else {
1261 new_rate = rate;
1262 break;
1263 }
1264 }
1265 }
1266
1267 return new_rate;
1268}
1269
1270/*
1271 * Set up search table for MIMO2
1272 */
1273static int rs_switch_to_mimo2(struct iwl_priv *priv,
1274 struct iwl_lq_sta *lq_sta,
1275 struct ieee80211_conf *conf,
1276 struct ieee80211_sta *sta,
1277 struct iwl_scale_tbl_info *tbl, int index)
1278{
1279 u16 rate_mask;
1280 s32 rate;
1281 s8 is_green = lq_sta->is_green;
1282 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
1283 struct iwl_rxon_context *ctx = sta_priv->ctx;
1284
1285 if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
1286 return -1;
1287
1288 if (((sta->ht_cap.cap & IEEE80211_HT_CAP_SM_PS) >> 2)
1289 == WLAN_HT_CAP_SM_PS_STATIC)
1290 return -1;
1291
1292 /* Need both Tx chains/antennas to support MIMO */
1293 if (priv->hw_params.tx_chains_num < 2)
1294 return -1;
1295
1296 IWL_DEBUG_RATE(priv, "LQ: try to switch to MIMO2\n");
1297
1298 tbl->lq_type = LQ_MIMO2;
1299 tbl->is_dup = lq_sta->is_dup;
1300 tbl->action = 0;
1301 tbl->max_search = IWL_MAX_SEARCH;
1302 rate_mask = lq_sta->active_mimo2_rate;
1303
1304 if (iwl_is_ht40_tx_allowed(priv, ctx, &sta->ht_cap))
1305 tbl->is_ht40 = 1;
1306 else
1307 tbl->is_ht40 = 0;
1308
1309 rs_set_expected_tpt_table(lq_sta, tbl);
1310
1311 rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index);
1312
1313 IWL_DEBUG_RATE(priv, "LQ: MIMO2 best rate %d mask %X\n", rate, rate_mask);
1314 if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) {
1315 IWL_DEBUG_RATE(priv, "Can't switch with index %d rate mask %x\n",
1316 rate, rate_mask);
1317 return -1;
1318 }
1319 tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, rate, is_green);
1320
1321 IWL_DEBUG_RATE(priv, "LQ: Switch to new mcs %X index is green %X\n",
1322 tbl->current_rate, is_green);
1323 return 0;
1324}
1325
1326/*
1327 * Set up search table for MIMO3
1328 */
1329static int rs_switch_to_mimo3(struct iwl_priv *priv,
1330 struct iwl_lq_sta *lq_sta,
1331 struct ieee80211_conf *conf,
1332 struct ieee80211_sta *sta,
1333 struct iwl_scale_tbl_info *tbl, int index)
1334{
1335 u16 rate_mask;
1336 s32 rate;
1337 s8 is_green = lq_sta->is_green;
1338 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
1339 struct iwl_rxon_context *ctx = sta_priv->ctx;
1340
1341 if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
1342 return -1;
1343
1344 if (((sta->ht_cap.cap & IEEE80211_HT_CAP_SM_PS) >> 2)
1345 == WLAN_HT_CAP_SM_PS_STATIC)
1346 return -1;
1347
1348 /* Need both Tx chains/antennas to support MIMO */
1349 if (priv->hw_params.tx_chains_num < 3)
1350 return -1;
1351
1352 IWL_DEBUG_RATE(priv, "LQ: try to switch to MIMO3\n");
1353
1354 tbl->lq_type = LQ_MIMO3;
1355 tbl->is_dup = lq_sta->is_dup;
1356 tbl->action = 0;
1357 tbl->max_search = IWL_MAX_11N_MIMO3_SEARCH;
1358 rate_mask = lq_sta->active_mimo3_rate;
1359
1360 if (iwl_is_ht40_tx_allowed(priv, ctx, &sta->ht_cap))
1361 tbl->is_ht40 = 1;
1362 else
1363 tbl->is_ht40 = 0;
1364
1365 rs_set_expected_tpt_table(lq_sta, tbl);
1366
1367 rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index);
1368
1369 IWL_DEBUG_RATE(priv, "LQ: MIMO3 best rate %d mask %X\n",
1370 rate, rate_mask);
1371 if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) {
1372 IWL_DEBUG_RATE(priv, "Can't switch with index %d rate mask %x\n",
1373 rate, rate_mask);
1374 return -1;
1375 }
1376 tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, rate, is_green);
1377
1378 IWL_DEBUG_RATE(priv, "LQ: Switch to new mcs %X index is green %X\n",
1379 tbl->current_rate, is_green);
1380 return 0;
1381}
1382
1383/*
1384 * Set up search table for SISO
1385 */
1386static int rs_switch_to_siso(struct iwl_priv *priv,
1387 struct iwl_lq_sta *lq_sta,
1388 struct ieee80211_conf *conf,
1389 struct ieee80211_sta *sta,
1390 struct iwl_scale_tbl_info *tbl, int index)
1391{
1392 u16 rate_mask;
1393 u8 is_green = lq_sta->is_green;
1394 s32 rate;
1395 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
1396 struct iwl_rxon_context *ctx = sta_priv->ctx;
1397
1398 if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
1399 return -1;
1400
1401 IWL_DEBUG_RATE(priv, "LQ: try to switch to SISO\n");
1402
1403 tbl->is_dup = lq_sta->is_dup;
1404 tbl->lq_type = LQ_SISO;
1405 tbl->action = 0;
1406 tbl->max_search = IWL_MAX_SEARCH;
1407 rate_mask = lq_sta->active_siso_rate;
1408
1409 if (iwl_is_ht40_tx_allowed(priv, ctx, &sta->ht_cap))
1410 tbl->is_ht40 = 1;
1411 else
1412 tbl->is_ht40 = 0;
1413
1414 if (is_green)
1415 tbl->is_SGI = 0; /*11n spec: no SGI in SISO+Greenfield*/
1416
1417 rs_set_expected_tpt_table(lq_sta, tbl);
1418 rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index);
1419
1420 IWL_DEBUG_RATE(priv, "LQ: get best rate %d mask %X\n", rate, rate_mask);
1421 if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) {
1422 IWL_DEBUG_RATE(priv, "can not switch with index %d rate mask %x\n",
1423 rate, rate_mask);
1424 return -1;
1425 }
1426 tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, rate, is_green);
1427 IWL_DEBUG_RATE(priv, "LQ: Switch to new mcs %X index is green %X\n",
1428 tbl->current_rate, is_green);
1429 return 0;
1430}
1431
1432/*
1433 * Try to switch to new modulation mode from legacy
1434 */
1435static int rs_move_legacy_other(struct iwl_priv *priv,
1436 struct iwl_lq_sta *lq_sta,
1437 struct ieee80211_conf *conf,
1438 struct ieee80211_sta *sta,
1439 int index)
1440{
1441 struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1442 struct iwl_scale_tbl_info *search_tbl =
1443 &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1444 struct iwl_rate_scale_data *window = &(tbl->win[index]);
1445 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1446 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1447 u8 start_action;
1448 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1449 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1450 int ret = 0;
1451 u8 update_search_tbl_counter = 0;
1452
1453 switch (priv->bt_traffic_load) {
1454 case IWL_BT_COEX_TRAFFIC_LOAD_NONE:
1455 /* nothing */
1456 break;
1457 case IWL_BT_COEX_TRAFFIC_LOAD_LOW:
1458 /* avoid antenna B unless MIMO */
1459 if (tbl->action == IWL_LEGACY_SWITCH_ANTENNA2)
1460 tbl->action = IWL_LEGACY_SWITCH_SISO;
1461 break;
1462 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH:
1463 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
1464 /* avoid antenna B and MIMO */
1465 valid_tx_ant =
1466 first_antenna(priv->eeprom_data->valid_tx_ant);
1467 if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2 &&
1468 tbl->action != IWL_LEGACY_SWITCH_SISO)
1469 tbl->action = IWL_LEGACY_SWITCH_SISO;
1470 break;
1471 default:
1472 IWL_ERR(priv, "Invalid BT load %d", priv->bt_traffic_load);
1473 break;
1474 }
1475
1476 if (!iwl_ht_enabled(priv))
1477 /* stay in Legacy */
1478 tbl->action = IWL_LEGACY_SWITCH_ANTENNA1;
1479 else if (iwl_tx_ant_restriction(priv) == IWL_ANT_OK_SINGLE &&
1480 tbl->action > IWL_LEGACY_SWITCH_SISO)
1481 tbl->action = IWL_LEGACY_SWITCH_SISO;
1482
1483 /* configure as 1x1 if bt full concurrency */
1484 if (priv->bt_full_concurrent) {
1485 if (!iwl_ht_enabled(priv))
1486 tbl->action = IWL_LEGACY_SWITCH_ANTENNA1;
1487 else if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2)
1488 tbl->action = IWL_LEGACY_SWITCH_SISO;
1489 valid_tx_ant =
1490 first_antenna(priv->eeprom_data->valid_tx_ant);
1491 }
1492
1493 start_action = tbl->action;
1494 for (; ;) {
1495 lq_sta->action_counter++;
1496 switch (tbl->action) {
1497 case IWL_LEGACY_SWITCH_ANTENNA1:
1498 case IWL_LEGACY_SWITCH_ANTENNA2:
1499 IWL_DEBUG_RATE(priv, "LQ: Legacy toggle Antenna\n");
1500
1501 if ((tbl->action == IWL_LEGACY_SWITCH_ANTENNA1 &&
1502 tx_chains_num <= 1) ||
1503 (tbl->action == IWL_LEGACY_SWITCH_ANTENNA2 &&
1504 tx_chains_num <= 2))
1505 break;
1506
1507 /* Don't change antenna if success has been great */
1508 if (window->success_ratio >= IWL_RS_GOOD_RATIO &&
1509 !priv->bt_full_concurrent &&
1510 priv->bt_traffic_load ==
1511 IWL_BT_COEX_TRAFFIC_LOAD_NONE)
1512 break;
1513
1514 /* Set up search table to try other antenna */
1515 memcpy(search_tbl, tbl, sz);
1516
1517 if (rs_toggle_antenna(valid_tx_ant,
1518 &search_tbl->current_rate, search_tbl)) {
1519 update_search_tbl_counter = 1;
1520 rs_set_expected_tpt_table(lq_sta, search_tbl);
1521 goto out;
1522 }
1523 break;
1524 case IWL_LEGACY_SWITCH_SISO:
1525 IWL_DEBUG_RATE(priv, "LQ: Legacy switch to SISO\n");
1526
1527 /* Set up search table to try SISO */
1528 memcpy(search_tbl, tbl, sz);
1529 search_tbl->is_SGI = 0;
1530 ret = rs_switch_to_siso(priv, lq_sta, conf, sta,
1531 search_tbl, index);
1532 if (!ret) {
1533 lq_sta->action_counter = 0;
1534 goto out;
1535 }
1536
1537 break;
1538 case IWL_LEGACY_SWITCH_MIMO2_AB:
1539 case IWL_LEGACY_SWITCH_MIMO2_AC:
1540 case IWL_LEGACY_SWITCH_MIMO2_BC:
1541 IWL_DEBUG_RATE(priv, "LQ: Legacy switch to MIMO2\n");
1542
1543 /* Set up search table to try MIMO */
1544 memcpy(search_tbl, tbl, sz);
1545 search_tbl->is_SGI = 0;
1546
1547 if (tbl->action == IWL_LEGACY_SWITCH_MIMO2_AB)
1548 search_tbl->ant_type = ANT_AB;
1549 else if (tbl->action == IWL_LEGACY_SWITCH_MIMO2_AC)
1550 search_tbl->ant_type = ANT_AC;
1551 else
1552 search_tbl->ant_type = ANT_BC;
1553
1554 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
1555 break;
1556
1557 ret = rs_switch_to_mimo2(priv, lq_sta, conf, sta,
1558 search_tbl, index);
1559 if (!ret) {
1560 lq_sta->action_counter = 0;
1561 goto out;
1562 }
1563 break;
1564
1565 case IWL_LEGACY_SWITCH_MIMO3_ABC:
1566 IWL_DEBUG_RATE(priv, "LQ: Legacy switch to MIMO3\n");
1567
1568 /* Set up search table to try MIMO3 */
1569 memcpy(search_tbl, tbl, sz);
1570 search_tbl->is_SGI = 0;
1571
1572 search_tbl->ant_type = ANT_ABC;
1573
1574 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
1575 break;
1576
1577 ret = rs_switch_to_mimo3(priv, lq_sta, conf, sta,
1578 search_tbl, index);
1579 if (!ret) {
1580 lq_sta->action_counter = 0;
1581 goto out;
1582 }
1583 break;
1584 }
1585 tbl->action++;
1586 if (tbl->action > IWL_LEGACY_SWITCH_MIMO3_ABC)
1587 tbl->action = IWL_LEGACY_SWITCH_ANTENNA1;
1588
1589 if (tbl->action == start_action)
1590 break;
1591
1592 }
1593 search_tbl->lq_type = LQ_NONE;
1594 return 0;
1595
1596out:
1597 lq_sta->search_better_tbl = 1;
1598 tbl->action++;
1599 if (tbl->action > IWL_LEGACY_SWITCH_MIMO3_ABC)
1600 tbl->action = IWL_LEGACY_SWITCH_ANTENNA1;
1601 if (update_search_tbl_counter)
1602 search_tbl->action = tbl->action;
1603 return 0;
1604
1605}
1606
1607/*
1608 * Try to switch to new modulation mode from SISO
1609 */
1610static int rs_move_siso_to_other(struct iwl_priv *priv,
1611 struct iwl_lq_sta *lq_sta,
1612 struct ieee80211_conf *conf,
1613 struct ieee80211_sta *sta, int index)
1614{
1615 u8 is_green = lq_sta->is_green;
1616 struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1617 struct iwl_scale_tbl_info *search_tbl =
1618 &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1619 struct iwl_rate_scale_data *window = &(tbl->win[index]);
1620 struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1621 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1622 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1623 u8 start_action;
1624 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1625 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1626 u8 update_search_tbl_counter = 0;
1627 int ret;
1628
1629 switch (priv->bt_traffic_load) {
1630 case IWL_BT_COEX_TRAFFIC_LOAD_NONE:
1631 /* nothing */
1632 break;
1633 case IWL_BT_COEX_TRAFFIC_LOAD_LOW:
1634 /* avoid antenna B unless MIMO */
1635 if (tbl->action == IWL_SISO_SWITCH_ANTENNA2)
1636 tbl->action = IWL_SISO_SWITCH_MIMO2_AB;
1637 break;
1638 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH:
1639 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
1640 /* avoid antenna B and MIMO */
1641 valid_tx_ant =
1642 first_antenna(priv->eeprom_data->valid_tx_ant);
1643 if (tbl->action != IWL_SISO_SWITCH_ANTENNA1)
1644 tbl->action = IWL_SISO_SWITCH_ANTENNA1;
1645 break;
1646 default:
1647 IWL_ERR(priv, "Invalid BT load %d", priv->bt_traffic_load);
1648 break;
1649 }
1650
1651 if (iwl_tx_ant_restriction(priv) == IWL_ANT_OK_SINGLE &&
1652 tbl->action > IWL_SISO_SWITCH_ANTENNA2) {
1653 /* stay in SISO */
1654 tbl->action = IWL_SISO_SWITCH_ANTENNA1;
1655 }
1656
1657 /* configure as 1x1 if bt full concurrency */
1658 if (priv->bt_full_concurrent) {
1659 valid_tx_ant =
1660 first_antenna(priv->eeprom_data->valid_tx_ant);
1661 if (tbl->action >= IWL_LEGACY_SWITCH_ANTENNA2)
1662 tbl->action = IWL_SISO_SWITCH_ANTENNA1;
1663 }
1664
1665 start_action = tbl->action;
1666 for (;;) {
1667 lq_sta->action_counter++;
1668 switch (tbl->action) {
1669 case IWL_SISO_SWITCH_ANTENNA1:
1670 case IWL_SISO_SWITCH_ANTENNA2:
1671 IWL_DEBUG_RATE(priv, "LQ: SISO toggle Antenna\n");
1672 if ((tbl->action == IWL_SISO_SWITCH_ANTENNA1 &&
1673 tx_chains_num <= 1) ||
1674 (tbl->action == IWL_SISO_SWITCH_ANTENNA2 &&
1675 tx_chains_num <= 2))
1676 break;
1677
1678 if (window->success_ratio >= IWL_RS_GOOD_RATIO &&
1679 !priv->bt_full_concurrent &&
1680 priv->bt_traffic_load ==
1681 IWL_BT_COEX_TRAFFIC_LOAD_NONE)
1682 break;
1683
1684 memcpy(search_tbl, tbl, sz);
1685 if (rs_toggle_antenna(valid_tx_ant,
1686 &search_tbl->current_rate, search_tbl)) {
1687 update_search_tbl_counter = 1;
1688 goto out;
1689 }
1690 break;
1691 case IWL_SISO_SWITCH_MIMO2_AB:
1692 case IWL_SISO_SWITCH_MIMO2_AC:
1693 case IWL_SISO_SWITCH_MIMO2_BC:
1694 IWL_DEBUG_RATE(priv, "LQ: SISO switch to MIMO2\n");
1695 memcpy(search_tbl, tbl, sz);
1696 search_tbl->is_SGI = 0;
1697
1698 if (tbl->action == IWL_SISO_SWITCH_MIMO2_AB)
1699 search_tbl->ant_type = ANT_AB;
1700 else if (tbl->action == IWL_SISO_SWITCH_MIMO2_AC)
1701 search_tbl->ant_type = ANT_AC;
1702 else
1703 search_tbl->ant_type = ANT_BC;
1704
1705 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
1706 break;
1707
1708 ret = rs_switch_to_mimo2(priv, lq_sta, conf, sta,
1709 search_tbl, index);
1710 if (!ret)
1711 goto out;
1712 break;
1713 case IWL_SISO_SWITCH_GI:
1714 if (!tbl->is_ht40 && !(ht_cap->cap &
1715 IEEE80211_HT_CAP_SGI_20))
1716 break;
1717 if (tbl->is_ht40 && !(ht_cap->cap &
1718 IEEE80211_HT_CAP_SGI_40))
1719 break;
1720
1721 IWL_DEBUG_RATE(priv, "LQ: SISO toggle SGI/NGI\n");
1722
1723 memcpy(search_tbl, tbl, sz);
1724 if (is_green) {
1725 if (!tbl->is_SGI)
1726 break;
1727 else
1728 IWL_ERR(priv,
1729 "SGI was set in GF+SISO\n");
1730 }
1731 search_tbl->is_SGI = !tbl->is_SGI;
1732 rs_set_expected_tpt_table(lq_sta, search_tbl);
1733 if (tbl->is_SGI) {
1734 s32 tpt = lq_sta->last_tpt / 100;
1735 if (tpt >= search_tbl->expected_tpt[index])
1736 break;
1737 }
1738 search_tbl->current_rate =
1739 rate_n_flags_from_tbl(priv, search_tbl,
1740 index, is_green);
1741 update_search_tbl_counter = 1;
1742 goto out;
1743 case IWL_SISO_SWITCH_MIMO3_ABC:
1744 IWL_DEBUG_RATE(priv, "LQ: SISO switch to MIMO3\n");
1745 memcpy(search_tbl, tbl, sz);
1746 search_tbl->is_SGI = 0;
1747 search_tbl->ant_type = ANT_ABC;
1748
1749 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
1750 break;
1751
1752 ret = rs_switch_to_mimo3(priv, lq_sta, conf, sta,
1753 search_tbl, index);
1754 if (!ret)
1755 goto out;
1756 break;
1757 }
1758 tbl->action++;
1759 if (tbl->action > IWL_LEGACY_SWITCH_MIMO3_ABC)
1760 tbl->action = IWL_SISO_SWITCH_ANTENNA1;
1761
1762 if (tbl->action == start_action)
1763 break;
1764 }
1765 search_tbl->lq_type = LQ_NONE;
1766 return 0;
1767
1768 out:
1769 lq_sta->search_better_tbl = 1;
1770 tbl->action++;
1771 if (tbl->action > IWL_SISO_SWITCH_MIMO3_ABC)
1772 tbl->action = IWL_SISO_SWITCH_ANTENNA1;
1773 if (update_search_tbl_counter)
1774 search_tbl->action = tbl->action;
1775
1776 return 0;
1777}
1778
1779/*
1780 * Try to switch to new modulation mode from MIMO2
1781 */
1782static int rs_move_mimo2_to_other(struct iwl_priv *priv,
1783 struct iwl_lq_sta *lq_sta,
1784 struct ieee80211_conf *conf,
1785 struct ieee80211_sta *sta, int index)
1786{
1787 s8 is_green = lq_sta->is_green;
1788 struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1789 struct iwl_scale_tbl_info *search_tbl =
1790 &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1791 struct iwl_rate_scale_data *window = &(tbl->win[index]);
1792 struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1793 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1794 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1795 u8 start_action;
1796 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1797 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1798 u8 update_search_tbl_counter = 0;
1799 int ret;
1800
1801 switch (priv->bt_traffic_load) {
1802 case IWL_BT_COEX_TRAFFIC_LOAD_NONE:
1803 /* nothing */
1804 break;
1805 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH:
1806 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
1807 /* avoid antenna B and MIMO */
1808 if (tbl->action != IWL_MIMO2_SWITCH_SISO_A)
1809 tbl->action = IWL_MIMO2_SWITCH_SISO_A;
1810 break;
1811 case IWL_BT_COEX_TRAFFIC_LOAD_LOW:
1812 /* avoid antenna B unless MIMO */
1813 if (tbl->action == IWL_MIMO2_SWITCH_SISO_B ||
1814 tbl->action == IWL_MIMO2_SWITCH_SISO_C)
1815 tbl->action = IWL_MIMO2_SWITCH_SISO_A;
1816 break;
1817 default:
1818 IWL_ERR(priv, "Invalid BT load %d", priv->bt_traffic_load);
1819 break;
1820 }
1821
1822 if ((iwl_tx_ant_restriction(priv) == IWL_ANT_OK_SINGLE) &&
1823 (tbl->action < IWL_MIMO2_SWITCH_SISO_A ||
1824 tbl->action > IWL_MIMO2_SWITCH_SISO_C)) {
1825 /* switch in SISO */
1826 tbl->action = IWL_MIMO2_SWITCH_SISO_A;
1827 }
1828
1829 /* configure as 1x1 if bt full concurrency */
1830 if (priv->bt_full_concurrent &&
1831 (tbl->action < IWL_MIMO2_SWITCH_SISO_A ||
1832 tbl->action > IWL_MIMO2_SWITCH_SISO_C))
1833 tbl->action = IWL_MIMO2_SWITCH_SISO_A;
1834
1835 start_action = tbl->action;
1836 for (;;) {
1837 lq_sta->action_counter++;
1838 switch (tbl->action) {
1839 case IWL_MIMO2_SWITCH_ANTENNA1:
1840 case IWL_MIMO2_SWITCH_ANTENNA2:
1841 IWL_DEBUG_RATE(priv, "LQ: MIMO2 toggle Antennas\n");
1842
1843 if (tx_chains_num <= 2)
1844 break;
1845
1846 if (window->success_ratio >= IWL_RS_GOOD_RATIO)
1847 break;
1848
1849 memcpy(search_tbl, tbl, sz);
1850 if (rs_toggle_antenna(valid_tx_ant,
1851 &search_tbl->current_rate, search_tbl)) {
1852 update_search_tbl_counter = 1;
1853 goto out;
1854 }
1855 break;
1856 case IWL_MIMO2_SWITCH_SISO_A:
1857 case IWL_MIMO2_SWITCH_SISO_B:
1858 case IWL_MIMO2_SWITCH_SISO_C:
1859 IWL_DEBUG_RATE(priv, "LQ: MIMO2 switch to SISO\n");
1860
1861 /* Set up new search table for SISO */
1862 memcpy(search_tbl, tbl, sz);
1863
1864 if (tbl->action == IWL_MIMO2_SWITCH_SISO_A)
1865 search_tbl->ant_type = ANT_A;
1866 else if (tbl->action == IWL_MIMO2_SWITCH_SISO_B)
1867 search_tbl->ant_type = ANT_B;
1868 else
1869 search_tbl->ant_type = ANT_C;
1870
1871 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
1872 break;
1873
1874 ret = rs_switch_to_siso(priv, lq_sta, conf, sta,
1875 search_tbl, index);
1876 if (!ret)
1877 goto out;
1878
1879 break;
1880
1881 case IWL_MIMO2_SWITCH_GI:
1882 if (!tbl->is_ht40 && !(ht_cap->cap &
1883 IEEE80211_HT_CAP_SGI_20))
1884 break;
1885 if (tbl->is_ht40 && !(ht_cap->cap &
1886 IEEE80211_HT_CAP_SGI_40))
1887 break;
1888
1889 IWL_DEBUG_RATE(priv, "LQ: MIMO2 toggle SGI/NGI\n");
1890
1891 /* Set up new search table for MIMO2 */
1892 memcpy(search_tbl, tbl, sz);
1893 search_tbl->is_SGI = !tbl->is_SGI;
1894 rs_set_expected_tpt_table(lq_sta, search_tbl);
1895 /*
1896 * If active table already uses the fastest possible
1897 * modulation (dual stream with short guard interval),
1898 * and it's working well, there's no need to look
1899 * for a better type of modulation!
1900 */
1901 if (tbl->is_SGI) {
1902 s32 tpt = lq_sta->last_tpt / 100;
1903 if (tpt >= search_tbl->expected_tpt[index])
1904 break;
1905 }
1906 search_tbl->current_rate =
1907 rate_n_flags_from_tbl(priv, search_tbl,
1908 index, is_green);
1909 update_search_tbl_counter = 1;
1910 goto out;
1911
1912 case IWL_MIMO2_SWITCH_MIMO3_ABC:
1913 IWL_DEBUG_RATE(priv, "LQ: MIMO2 switch to MIMO3\n");
1914 memcpy(search_tbl, tbl, sz);
1915 search_tbl->is_SGI = 0;
1916 search_tbl->ant_type = ANT_ABC;
1917
1918 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
1919 break;
1920
1921 ret = rs_switch_to_mimo3(priv, lq_sta, conf, sta,
1922 search_tbl, index);
1923 if (!ret)
1924 goto out;
1925
1926 break;
1927 }
1928 tbl->action++;
1929 if (tbl->action > IWL_MIMO2_SWITCH_MIMO3_ABC)
1930 tbl->action = IWL_MIMO2_SWITCH_ANTENNA1;
1931
1932 if (tbl->action == start_action)
1933 break;
1934 }
1935 search_tbl->lq_type = LQ_NONE;
1936 return 0;
1937 out:
1938 lq_sta->search_better_tbl = 1;
1939 tbl->action++;
1940 if (tbl->action > IWL_MIMO2_SWITCH_MIMO3_ABC)
1941 tbl->action = IWL_MIMO2_SWITCH_ANTENNA1;
1942 if (update_search_tbl_counter)
1943 search_tbl->action = tbl->action;
1944
1945 return 0;
1946
1947}
1948
1949/*
1950 * Try to switch to new modulation mode from MIMO3
1951 */
1952static int rs_move_mimo3_to_other(struct iwl_priv *priv,
1953 struct iwl_lq_sta *lq_sta,
1954 struct ieee80211_conf *conf,
1955 struct ieee80211_sta *sta, int index)
1956{
1957 s8 is_green = lq_sta->is_green;
1958 struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1959 struct iwl_scale_tbl_info *search_tbl =
1960 &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1961 struct iwl_rate_scale_data *window = &(tbl->win[index]);
1962 struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1963 u32 sz = (sizeof(struct iwl_scale_tbl_info) -
1964 (sizeof(struct iwl_rate_scale_data) * IWL_RATE_COUNT));
1965 u8 start_action;
1966 u8 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
1967 u8 tx_chains_num = priv->hw_params.tx_chains_num;
1968 int ret;
1969 u8 update_search_tbl_counter = 0;
1970
1971 switch (priv->bt_traffic_load) {
1972 case IWL_BT_COEX_TRAFFIC_LOAD_NONE:
1973 /* nothing */
1974 break;
1975 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH:
1976 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
1977 /* avoid antenna B and MIMO */
1978 if (tbl->action != IWL_MIMO3_SWITCH_SISO_A)
1979 tbl->action = IWL_MIMO3_SWITCH_SISO_A;
1980 break;
1981 case IWL_BT_COEX_TRAFFIC_LOAD_LOW:
1982 /* avoid antenna B unless MIMO */
1983 if (tbl->action == IWL_MIMO3_SWITCH_SISO_B ||
1984 tbl->action == IWL_MIMO3_SWITCH_SISO_C)
1985 tbl->action = IWL_MIMO3_SWITCH_SISO_A;
1986 break;
1987 default:
1988 IWL_ERR(priv, "Invalid BT load %d", priv->bt_traffic_load);
1989 break;
1990 }
1991
1992 if ((iwl_tx_ant_restriction(priv) == IWL_ANT_OK_SINGLE) &&
1993 (tbl->action < IWL_MIMO3_SWITCH_SISO_A ||
1994 tbl->action > IWL_MIMO3_SWITCH_SISO_C)) {
1995 /* switch in SISO */
1996 tbl->action = IWL_MIMO3_SWITCH_SISO_A;
1997 }
1998
1999 /* configure as 1x1 if bt full concurrency */
2000 if (priv->bt_full_concurrent &&
2001 (tbl->action < IWL_MIMO3_SWITCH_SISO_A ||
2002 tbl->action > IWL_MIMO3_SWITCH_SISO_C))
2003 tbl->action = IWL_MIMO3_SWITCH_SISO_A;
2004
2005 start_action = tbl->action;
2006 for (;;) {
2007 lq_sta->action_counter++;
2008 switch (tbl->action) {
2009 case IWL_MIMO3_SWITCH_ANTENNA1:
2010 case IWL_MIMO3_SWITCH_ANTENNA2:
2011 IWL_DEBUG_RATE(priv, "LQ: MIMO3 toggle Antennas\n");
2012
2013 if (tx_chains_num <= 3)
2014 break;
2015
2016 if (window->success_ratio >= IWL_RS_GOOD_RATIO)
2017 break;
2018
2019 memcpy(search_tbl, tbl, sz);
2020 if (rs_toggle_antenna(valid_tx_ant,
2021 &search_tbl->current_rate, search_tbl))
2022 goto out;
2023 break;
2024 case IWL_MIMO3_SWITCH_SISO_A:
2025 case IWL_MIMO3_SWITCH_SISO_B:
2026 case IWL_MIMO3_SWITCH_SISO_C:
2027 IWL_DEBUG_RATE(priv, "LQ: MIMO3 switch to SISO\n");
2028
2029 /* Set up new search table for SISO */
2030 memcpy(search_tbl, tbl, sz);
2031
2032 if (tbl->action == IWL_MIMO3_SWITCH_SISO_A)
2033 search_tbl->ant_type = ANT_A;
2034 else if (tbl->action == IWL_MIMO3_SWITCH_SISO_B)
2035 search_tbl->ant_type = ANT_B;
2036 else
2037 search_tbl->ant_type = ANT_C;
2038
2039 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
2040 break;
2041
2042 ret = rs_switch_to_siso(priv, lq_sta, conf, sta,
2043 search_tbl, index);
2044 if (!ret)
2045 goto out;
2046
2047 break;
2048
2049 case IWL_MIMO3_SWITCH_MIMO2_AB:
2050 case IWL_MIMO3_SWITCH_MIMO2_AC:
2051 case IWL_MIMO3_SWITCH_MIMO2_BC:
2052 IWL_DEBUG_RATE(priv, "LQ: MIMO3 switch to MIMO2\n");
2053
2054 memcpy(search_tbl, tbl, sz);
2055 search_tbl->is_SGI = 0;
2056 if (tbl->action == IWL_MIMO3_SWITCH_MIMO2_AB)
2057 search_tbl->ant_type = ANT_AB;
2058 else if (tbl->action == IWL_MIMO3_SWITCH_MIMO2_AC)
2059 search_tbl->ant_type = ANT_AC;
2060 else
2061 search_tbl->ant_type = ANT_BC;
2062
2063 if (!rs_is_valid_ant(valid_tx_ant, search_tbl->ant_type))
2064 break;
2065
2066 ret = rs_switch_to_mimo2(priv, lq_sta, conf, sta,
2067 search_tbl, index);
2068 if (!ret)
2069 goto out;
2070
2071 break;
2072
2073 case IWL_MIMO3_SWITCH_GI:
2074 if (!tbl->is_ht40 && !(ht_cap->cap &
2075 IEEE80211_HT_CAP_SGI_20))
2076 break;
2077 if (tbl->is_ht40 && !(ht_cap->cap &
2078 IEEE80211_HT_CAP_SGI_40))
2079 break;
2080
2081 IWL_DEBUG_RATE(priv, "LQ: MIMO3 toggle SGI/NGI\n");
2082
2083 /* Set up new search table for MIMO */
2084 memcpy(search_tbl, tbl, sz);
2085 search_tbl->is_SGI = !tbl->is_SGI;
2086 rs_set_expected_tpt_table(lq_sta, search_tbl);
2087 /*
2088 * If active table already uses the fastest possible
2089 * modulation (dual stream with short guard interval),
2090 * and it's working well, there's no need to look
2091 * for a better type of modulation!
2092 */
2093 if (tbl->is_SGI) {
2094 s32 tpt = lq_sta->last_tpt / 100;
2095 if (tpt >= search_tbl->expected_tpt[index])
2096 break;
2097 }
2098 search_tbl->current_rate =
2099 rate_n_flags_from_tbl(priv, search_tbl,
2100 index, is_green);
2101 update_search_tbl_counter = 1;
2102 goto out;
2103 }
2104 tbl->action++;
2105 if (tbl->action > IWL_MIMO3_SWITCH_GI)
2106 tbl->action = IWL_MIMO3_SWITCH_ANTENNA1;
2107
2108 if (tbl->action == start_action)
2109 break;
2110 }
2111 search_tbl->lq_type = LQ_NONE;
2112 return 0;
2113 out:
2114 lq_sta->search_better_tbl = 1;
2115 tbl->action++;
2116 if (tbl->action > IWL_MIMO3_SWITCH_GI)
2117 tbl->action = IWL_MIMO3_SWITCH_ANTENNA1;
2118 if (update_search_tbl_counter)
2119 search_tbl->action = tbl->action;
2120
2121 return 0;
2122
2123}
2124
2125/*
2126 * Check whether we should continue using same modulation mode, or
2127 * begin search for a new mode, based on:
2128 * 1) # tx successes or failures while using this mode
2129 * 2) # times calling this function
2130 * 3) elapsed time in this mode (not used, for now)
2131 */
2132static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search)
2133{
2134 struct iwl_scale_tbl_info *tbl;
2135 int i;
2136 int active_tbl;
2137 int flush_interval_passed = 0;
2138 struct iwl_priv *priv;
2139
2140 priv = lq_sta->drv;
2141 active_tbl = lq_sta->active_tbl;
2142
2143 tbl = &(lq_sta->lq_info[active_tbl]);
2144
2145 /* If we've been disallowing search, see if we should now allow it */
2146 if (lq_sta->stay_in_tbl) {
2147
2148 /* Elapsed time using current modulation mode */
2149 if (lq_sta->flush_timer)
2150 flush_interval_passed =
2151 time_after(jiffies,
2152 (unsigned long)(lq_sta->flush_timer +
2153 IWL_RATE_SCALE_FLUSH_INTVL));
2154
2155 /*
2156 * Check if we should allow search for new modulation mode.
2157 * If many frames have failed or succeeded, or we've used
2158 * this same modulation for a long time, allow search, and
2159 * reset history stats that keep track of whether we should
2160 * allow a new search. Also (below) reset all bitmaps and
2161 * stats in active history.
2162 */
2163 if (force_search ||
2164 (lq_sta->total_failed > lq_sta->max_failure_limit) ||
2165 (lq_sta->total_success > lq_sta->max_success_limit) ||
2166 ((!lq_sta->search_better_tbl) && (lq_sta->flush_timer)
2167 && (flush_interval_passed))) {
2168 IWL_DEBUG_RATE(priv, "LQ: stay is expired %d %d %d\n",
2169 lq_sta->total_failed,
2170 lq_sta->total_success,
2171 flush_interval_passed);
2172
2173 /* Allow search for new mode */
2174 lq_sta->stay_in_tbl = 0; /* only place reset */
2175 lq_sta->total_failed = 0;
2176 lq_sta->total_success = 0;
2177 lq_sta->flush_timer = 0;
2178
2179 /*
2180 * Else if we've used this modulation mode enough repetitions
2181 * (regardless of elapsed time or success/failure), reset
2182 * history bitmaps and rate-specific stats for all rates in
2183 * active table.
2184 */
2185 } else {
2186 lq_sta->table_count++;
2187 if (lq_sta->table_count >=
2188 lq_sta->table_count_limit) {
2189 lq_sta->table_count = 0;
2190
2191 IWL_DEBUG_RATE(priv, "LQ: stay in table clear win\n");
2192 for (i = 0; i < IWL_RATE_COUNT; i++)
2193 rs_rate_scale_clear_window(
2194 &(tbl->win[i]));
2195 }
2196 }
2197
2198 /* If transitioning to allow "search", reset all history
2199 * bitmaps and stats in active table (this will become the new
2200 * "search" table). */
2201 if (!lq_sta->stay_in_tbl) {
2202 for (i = 0; i < IWL_RATE_COUNT; i++)
2203 rs_rate_scale_clear_window(&(tbl->win[i]));
2204 }
2205 }
2206}
2207
2208/*
2209 * setup rate table in uCode
2210 */
2211static void rs_update_rate_tbl(struct iwl_priv *priv,
2212 struct iwl_rxon_context *ctx,
2213 struct iwl_lq_sta *lq_sta,
2214 struct iwl_scale_tbl_info *tbl,
2215 int index, u8 is_green)
2216{
2217 u32 rate;
2218
2219 /* Update uCode's rate table. */
2220 rate = rate_n_flags_from_tbl(priv, tbl, index, is_green);
2221 rs_fill_link_cmd(priv, lq_sta, rate);
2222 iwl_send_lq_cmd(priv, ctx, &lq_sta->lq, CMD_ASYNC, false);
2223}
2224
2225/*
2226 * Do rate scaling and search for new modulation mode.
2227 */
2228static void rs_rate_scale_perform(struct iwl_priv *priv,
2229 struct sk_buff *skb,
2230 struct ieee80211_sta *sta,
2231 struct iwl_lq_sta *lq_sta)
2232{
2233 struct ieee80211_hw *hw = priv->hw;
2234 struct ieee80211_conf *conf = &hw->conf;
2235 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2236 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2237 int low = IWL_RATE_INVALID;
2238 int high = IWL_RATE_INVALID;
2239 int index;
2240 int i;
2241 struct iwl_rate_scale_data *window = NULL;
2242 int current_tpt = IWL_INVALID_VALUE;
2243 int low_tpt = IWL_INVALID_VALUE;
2244 int high_tpt = IWL_INVALID_VALUE;
2245 u32 fail_count;
2246 s8 scale_action = 0;
2247 u16 rate_mask;
2248 u8 update_lq = 0;
2249 struct iwl_scale_tbl_info *tbl, *tbl1;
2250 u16 rate_scale_index_msk = 0;
2251 u8 is_green = 0;
2252 u8 active_tbl = 0;
2253 u8 done_search = 0;
2254 u16 high_low;
2255 s32 sr;
2256 u8 tid = IWL_MAX_TID_COUNT;
2257 struct iwl_tid_data *tid_data;
2258 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
2259 struct iwl_rxon_context *ctx = sta_priv->ctx;
2260
2261 IWL_DEBUG_RATE(priv, "rate scale calculate new rate for skb\n");
2262
2263 /* Send management frames and NO_ACK data using lowest rate. */
2264 /* TODO: this could probably be improved.. */
2265 if (!ieee80211_is_data(hdr->frame_control) ||
2266 info->flags & IEEE80211_TX_CTL_NO_ACK)
2267 return;
2268
2269 lq_sta->supp_rates = sta->supp_rates[lq_sta->band];
2270
2271 tid = rs_tl_add_packet(lq_sta, hdr);
2272 if ((tid != IWL_MAX_TID_COUNT) &&
2273 (lq_sta->tx_agg_tid_en & (1 << tid))) {
2274 tid_data = &priv->tid_data[lq_sta->lq.sta_id][tid];
2275 if (tid_data->agg.state == IWL_AGG_OFF)
2276 lq_sta->is_agg = 0;
2277 else
2278 lq_sta->is_agg = 1;
2279 } else
2280 lq_sta->is_agg = 0;
2281
2282 /*
2283 * Select rate-scale / modulation-mode table to work with in
2284 * the rest of this function: "search" if searching for better
2285 * modulation mode, or "active" if doing rate scaling within a mode.
2286 */
2287 if (!lq_sta->search_better_tbl)
2288 active_tbl = lq_sta->active_tbl;
2289 else
2290 active_tbl = 1 - lq_sta->active_tbl;
2291
2292 tbl = &(lq_sta->lq_info[active_tbl]);
2293 if (is_legacy(tbl->lq_type))
2294 lq_sta->is_green = 0;
2295 else
2296 lq_sta->is_green = rs_use_green(sta);
2297 is_green = lq_sta->is_green;
2298
2299 /* current tx rate */
2300 index = lq_sta->last_txrate_idx;
2301
2302 IWL_DEBUG_RATE(priv, "Rate scale index %d for type %d\n", index,
2303 tbl->lq_type);
2304
2305 /* rates available for this association, and for modulation mode */
2306 rate_mask = rs_get_supported_rates(lq_sta, hdr, tbl->lq_type);
2307
2308 IWL_DEBUG_RATE(priv, "mask 0x%04X\n", rate_mask);
2309
2310 /* mask with station rate restriction */
2311 if (is_legacy(tbl->lq_type)) {
2312 if (lq_sta->band == IEEE80211_BAND_5GHZ)
2313 /* supp_rates has no CCK bits in A mode */
2314 rate_scale_index_msk = (u16) (rate_mask &
2315 (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
2316 else
2317 rate_scale_index_msk = (u16) (rate_mask &
2318 lq_sta->supp_rates);
2319
2320 } else
2321 rate_scale_index_msk = rate_mask;
2322
2323 if (!rate_scale_index_msk)
2324 rate_scale_index_msk = rate_mask;
2325
2326 if (!((1 << index) & rate_scale_index_msk)) {
2327 IWL_ERR(priv, "Current Rate is not valid\n");
2328 if (lq_sta->search_better_tbl) {
2329 /* revert to active table if search table is not valid*/
2330 tbl->lq_type = LQ_NONE;
2331 lq_sta->search_better_tbl = 0;
2332 tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
2333 /* get "active" rate info */
2334 index = iwl_hwrate_to_plcp_idx(tbl->current_rate);
2335 rs_update_rate_tbl(priv, ctx, lq_sta, tbl,
2336 index, is_green);
2337 }
2338 return;
2339 }
2340
2341 /* Get expected throughput table and history window for current rate */
2342 if (!tbl->expected_tpt) {
2343 IWL_ERR(priv, "tbl->expected_tpt is NULL\n");
2344 return;
2345 }
2346
2347 /* force user max rate if set by user */
2348 if ((lq_sta->max_rate_idx != -1) &&
2349 (lq_sta->max_rate_idx < index)) {
2350 index = lq_sta->max_rate_idx;
2351 update_lq = 1;
2352 window = &(tbl->win[index]);
2353 goto lq_update;
2354 }
2355
2356 window = &(tbl->win[index]);
2357
2358 /*
2359 * If there is not enough history to calculate actual average
2360 * throughput, keep analyzing results of more tx frames, without
2361 * changing rate or mode (bypass most of the rest of this function).
2362 * Set up new rate table in uCode only if old rate is not supported
2363 * in current association (use new rate found above).
2364 */
2365 fail_count = window->counter - window->success_counter;
2366 if ((fail_count < IWL_RATE_MIN_FAILURE_TH) &&
2367 (window->success_counter < IWL_RATE_MIN_SUCCESS_TH)) {
2368 IWL_DEBUG_RATE(priv, "LQ: still below TH. succ=%d total=%d "
2369 "for index %d\n",
2370 window->success_counter, window->counter, index);
2371
2372 /* Can't calculate this yet; not enough history */
2373 window->average_tpt = IWL_INVALID_VALUE;
2374
2375 /* Should we stay with this modulation mode,
2376 * or search for a new one? */
2377 rs_stay_in_table(lq_sta, false);
2378
2379 goto out;
2380 }
2381 /* Else we have enough samples; calculate estimate of
2382 * actual average throughput */
2383 if (window->average_tpt != ((window->success_ratio *
2384 tbl->expected_tpt[index] + 64) / 128)) {
2385 IWL_ERR(priv, "expected_tpt should have been calculated by now\n");
2386 window->average_tpt = ((window->success_ratio *
2387 tbl->expected_tpt[index] + 64) / 128);
2388 }
2389
2390 /* If we are searching for better modulation mode, check success. */
2391 if (lq_sta->search_better_tbl &&
2392 (iwl_tx_ant_restriction(priv) == IWL_ANT_OK_MULTI)) {
2393 /* If good success, continue using the "search" mode;
2394 * no need to send new link quality command, since we're
2395 * continuing to use the setup that we've been trying. */
2396 if (window->average_tpt > lq_sta->last_tpt) {
2397
2398 IWL_DEBUG_RATE(priv, "LQ: SWITCHING TO NEW TABLE "
2399 "suc=%d cur-tpt=%d old-tpt=%d\n",
2400 window->success_ratio,
2401 window->average_tpt,
2402 lq_sta->last_tpt);
2403
2404 if (!is_legacy(tbl->lq_type))
2405 lq_sta->enable_counter = 1;
2406
2407 /* Swap tables; "search" becomes "active" */
2408 lq_sta->active_tbl = active_tbl;
2409 current_tpt = window->average_tpt;
2410
2411 /* Else poor success; go back to mode in "active" table */
2412 } else {
2413
2414 IWL_DEBUG_RATE(priv, "LQ: GOING BACK TO THE OLD TABLE "
2415 "suc=%d cur-tpt=%d old-tpt=%d\n",
2416 window->success_ratio,
2417 window->average_tpt,
2418 lq_sta->last_tpt);
2419
2420 /* Nullify "search" table */
2421 tbl->lq_type = LQ_NONE;
2422
2423 /* Revert to "active" table */
2424 active_tbl = lq_sta->active_tbl;
2425 tbl = &(lq_sta->lq_info[active_tbl]);
2426
2427 /* Revert to "active" rate and throughput info */
2428 index = iwl_hwrate_to_plcp_idx(tbl->current_rate);
2429 current_tpt = lq_sta->last_tpt;
2430
2431 /* Need to set up a new rate table in uCode */
2432 update_lq = 1;
2433 }
2434
2435 /* Either way, we've made a decision; modulation mode
2436 * search is done, allow rate adjustment next time. */
2437 lq_sta->search_better_tbl = 0;
2438 done_search = 1; /* Don't switch modes below! */
2439 goto lq_update;
2440 }
2441
2442 /* (Else) not in search of better modulation mode, try for better
2443 * starting rate, while staying in this mode. */
2444 high_low = rs_get_adjacent_rate(priv, index, rate_scale_index_msk,
2445 tbl->lq_type);
2446 low = high_low & 0xff;
2447 high = (high_low >> 8) & 0xff;
2448
2449 /* If user set max rate, dont allow higher than user constrain */
2450 if ((lq_sta->max_rate_idx != -1) &&
2451 (lq_sta->max_rate_idx < high))
2452 high = IWL_RATE_INVALID;
2453
2454 sr = window->success_ratio;
2455
2456 /* Collect measured throughputs for current and adjacent rates */
2457 current_tpt = window->average_tpt;
2458 if (low != IWL_RATE_INVALID)
2459 low_tpt = tbl->win[low].average_tpt;
2460 if (high != IWL_RATE_INVALID)
2461 high_tpt = tbl->win[high].average_tpt;
2462
2463 scale_action = 0;
2464
2465 /* Too many failures, decrease rate */
2466 if ((sr <= IWL_RATE_DECREASE_TH) || (current_tpt == 0)) {
2467 IWL_DEBUG_RATE(priv, "decrease rate because of low success_ratio\n");
2468 scale_action = -1;
2469
2470 /* No throughput measured yet for adjacent rates; try increase. */
2471 } else if ((low_tpt == IWL_INVALID_VALUE) &&
2472 (high_tpt == IWL_INVALID_VALUE)) {
2473
2474 if (high != IWL_RATE_INVALID && sr >= IWL_RATE_INCREASE_TH)
2475 scale_action = 1;
2476 else if (low != IWL_RATE_INVALID)
2477 scale_action = 0;
2478 }
2479
2480 /* Both adjacent throughputs are measured, but neither one has better
2481 * throughput; we're using the best rate, don't change it! */
2482 else if ((low_tpt != IWL_INVALID_VALUE) &&
2483 (high_tpt != IWL_INVALID_VALUE) &&
2484 (low_tpt < current_tpt) &&
2485 (high_tpt < current_tpt))
2486 scale_action = 0;
2487
2488 /* At least one adjacent rate's throughput is measured,
2489 * and may have better performance. */
2490 else {
2491 /* Higher adjacent rate's throughput is measured */
2492 if (high_tpt != IWL_INVALID_VALUE) {
2493 /* Higher rate has better throughput */
2494 if (high_tpt > current_tpt &&
2495 sr >= IWL_RATE_INCREASE_TH) {
2496 scale_action = 1;
2497 } else {
2498 scale_action = 0;
2499 }
2500
2501 /* Lower adjacent rate's throughput is measured */
2502 } else if (low_tpt != IWL_INVALID_VALUE) {
2503 /* Lower rate has better throughput */
2504 if (low_tpt > current_tpt) {
2505 IWL_DEBUG_RATE(priv,
2506 "decrease rate because of low tpt\n");
2507 scale_action = -1;
2508 } else if (sr >= IWL_RATE_INCREASE_TH) {
2509 scale_action = 1;
2510 }
2511 }
2512 }
2513
2514 /* Sanity check; asked for decrease, but success rate or throughput
2515 * has been good at old rate. Don't change it. */
2516 if ((scale_action == -1) && (low != IWL_RATE_INVALID) &&
2517 ((sr > IWL_RATE_HIGH_TH) ||
2518 (current_tpt > (100 * tbl->expected_tpt[low]))))
2519 scale_action = 0;
2520 if (!iwl_ht_enabled(priv) && !is_legacy(tbl->lq_type))
2521 scale_action = -1;
2522 if (iwl_tx_ant_restriction(priv) != IWL_ANT_OK_MULTI &&
2523 (is_mimo2(tbl->lq_type) || is_mimo3(tbl->lq_type)))
2524 scale_action = -1;
2525
2526 if ((priv->bt_traffic_load >= IWL_BT_COEX_TRAFFIC_LOAD_HIGH) &&
2527 (is_mimo2(tbl->lq_type) || is_mimo3(tbl->lq_type))) {
2528 if (lq_sta->last_bt_traffic > priv->bt_traffic_load) {
2529 /*
2530 * don't set scale_action, don't want to scale up if
2531 * the rate scale doesn't otherwise think that is a
2532 * good idea.
2533 */
2534 } else if (lq_sta->last_bt_traffic <= priv->bt_traffic_load) {
2535 scale_action = -1;
2536 }
2537 }
2538 lq_sta->last_bt_traffic = priv->bt_traffic_load;
2539
2540 if ((priv->bt_traffic_load >= IWL_BT_COEX_TRAFFIC_LOAD_HIGH) &&
2541 (is_mimo2(tbl->lq_type) || is_mimo3(tbl->lq_type))) {
2542 /* search for a new modulation */
2543 rs_stay_in_table(lq_sta, true);
2544 goto lq_update;
2545 }
2546
2547 switch (scale_action) {
2548 case -1:
2549 /* Decrease starting rate, update uCode's rate table */
2550 if (low != IWL_RATE_INVALID) {
2551 update_lq = 1;
2552 index = low;
2553 }
2554
2555 break;
2556 case 1:
2557 /* Increase starting rate, update uCode's rate table */
2558 if (high != IWL_RATE_INVALID) {
2559 update_lq = 1;
2560 index = high;
2561 }
2562
2563 break;
2564 case 0:
2565 /* No change */
2566 default:
2567 break;
2568 }
2569
2570 IWL_DEBUG_RATE(priv, "choose rate scale index %d action %d low %d "
2571 "high %d type %d\n",
2572 index, scale_action, low, high, tbl->lq_type);
2573
2574lq_update:
2575 /* Replace uCode's rate table for the destination station. */
2576 if (update_lq)
2577 rs_update_rate_tbl(priv, ctx, lq_sta, tbl, index, is_green);
2578
2579 if (iwl_tx_ant_restriction(priv) == IWL_ANT_OK_MULTI) {
2580 /* Should we stay with this modulation mode,
2581 * or search for a new one? */
2582 rs_stay_in_table(lq_sta, false);
2583 }
2584 /*
2585 * Search for new modulation mode if we're:
2586 * 1) Not changing rates right now
2587 * 2) Not just finishing up a search
2588 * 3) Allowing a new search
2589 */
2590 if (!update_lq && !done_search && !lq_sta->stay_in_tbl && window->counter) {
2591 /* Save current throughput to compare with "search" throughput*/
2592 lq_sta->last_tpt = current_tpt;
2593
2594 /* Select a new "search" modulation mode to try.
2595 * If one is found, set up the new "search" table. */
2596 if (is_legacy(tbl->lq_type))
2597 rs_move_legacy_other(priv, lq_sta, conf, sta, index);
2598 else if (is_siso(tbl->lq_type))
2599 rs_move_siso_to_other(priv, lq_sta, conf, sta, index);
2600 else if (is_mimo2(tbl->lq_type))
2601 rs_move_mimo2_to_other(priv, lq_sta, conf, sta, index);
2602 else
2603 rs_move_mimo3_to_other(priv, lq_sta, conf, sta, index);
2604
2605 /* If new "search" mode was selected, set up in uCode table */
2606 if (lq_sta->search_better_tbl) {
2607 /* Access the "search" table, clear its history. */
2608 tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
2609 for (i = 0; i < IWL_RATE_COUNT; i++)
2610 rs_rate_scale_clear_window(&(tbl->win[i]));
2611
2612 /* Use new "search" start rate */
2613 index = iwl_hwrate_to_plcp_idx(tbl->current_rate);
2614
2615 IWL_DEBUG_RATE(priv, "Switch current mcs: %X index: %d\n",
2616 tbl->current_rate, index);
2617 rs_fill_link_cmd(priv, lq_sta, tbl->current_rate);
2618 iwl_send_lq_cmd(priv, ctx, &lq_sta->lq, CMD_ASYNC, false);
2619 } else
2620 done_search = 1;
2621 }
2622
2623 if (done_search && !lq_sta->stay_in_tbl) {
2624 /* If the "active" (non-search) mode was legacy,
2625 * and we've tried switching antennas,
2626 * but we haven't been able to try HT modes (not available),
2627 * stay with best antenna legacy modulation for a while
2628 * before next round of mode comparisons. */
2629 tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
2630 if (is_legacy(tbl1->lq_type) && !conf_is_ht(conf) &&
2631 lq_sta->action_counter > tbl1->max_search) {
2632 IWL_DEBUG_RATE(priv, "LQ: STAY in legacy table\n");
2633 rs_set_stay_in_table(priv, 1, lq_sta);
2634 }
2635
2636 /* If we're in an HT mode, and all 3 mode switch actions
2637 * have been tried and compared, stay in this best modulation
2638 * mode for a while before next round of mode comparisons. */
2639 if (lq_sta->enable_counter &&
2640 (lq_sta->action_counter >= tbl1->max_search) &&
2641 iwl_ht_enabled(priv)) {
2642 if ((lq_sta->last_tpt > IWL_AGG_TPT_THREHOLD) &&
2643 (lq_sta->tx_agg_tid_en & (1 << tid)) &&
2644 (tid != IWL_MAX_TID_COUNT)) {
2645 u8 sta_id = lq_sta->lq.sta_id;
2646 tid_data = &priv->tid_data[sta_id][tid];
2647 if (tid_data->agg.state == IWL_AGG_OFF) {
2648 IWL_DEBUG_RATE(priv,
2649 "try to aggregate tid %d\n",
2650 tid);
2651 rs_tl_turn_on_agg(priv, tid,
2652 lq_sta, sta);
2653 }
2654 }
2655 rs_set_stay_in_table(priv, 0, lq_sta);
2656 }
2657 }
2658
2659out:
2660 tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, index, is_green);
2661 lq_sta->last_txrate_idx = index;
2662}
2663
2664/**
2665 * rs_initialize_lq - Initialize a station's hardware rate table
2666 *
2667 * The uCode's station table contains a table of fallback rates
2668 * for automatic fallback during transmission.
2669 *
2670 * NOTE: This sets up a default set of values. These will be replaced later
2671 * if the driver's iwl-agn-rs rate scaling algorithm is used, instead of
2672 * rc80211_simple.
2673 *
2674 * NOTE: Run REPLY_ADD_STA command to set up station table entry, before
2675 * calling this function (which runs REPLY_TX_LINK_QUALITY_CMD,
2676 * which requires station table entry to exist).
2677 */
2678static void rs_initialize_lq(struct iwl_priv *priv,
2679 struct ieee80211_sta *sta,
2680 struct iwl_lq_sta *lq_sta)
2681{
2682 struct iwl_scale_tbl_info *tbl;
2683 int rate_idx;
2684 int i;
2685 u32 rate;
2686 u8 use_green = rs_use_green(sta);
2687 u8 active_tbl = 0;
2688 u8 valid_tx_ant;
2689 struct iwl_station_priv *sta_priv;
2690 struct iwl_rxon_context *ctx;
2691
2692 if (!sta || !lq_sta)
2693 return;
2694
2695 sta_priv = (void *)sta->drv_priv;
2696 ctx = sta_priv->ctx;
2697
2698 i = lq_sta->last_txrate_idx;
2699
2700 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
2701
2702 if (!lq_sta->search_better_tbl)
2703 active_tbl = lq_sta->active_tbl;
2704 else
2705 active_tbl = 1 - lq_sta->active_tbl;
2706
2707 tbl = &(lq_sta->lq_info[active_tbl]);
2708
2709 if ((i < 0) || (i >= IWL_RATE_COUNT))
2710 i = 0;
2711
2712 rate = iwl_rates[i].plcp;
2713 tbl->ant_type = first_antenna(valid_tx_ant);
2714 rate |= tbl->ant_type << RATE_MCS_ANT_POS;
2715
2716 if (i >= IWL_FIRST_CCK_RATE && i <= IWL_LAST_CCK_RATE)
2717 rate |= RATE_MCS_CCK_MSK;
2718
2719 rs_get_tbl_info_from_mcs(rate, priv->band, tbl, &rate_idx);
2720 if (!rs_is_valid_ant(valid_tx_ant, tbl->ant_type))
2721 rs_toggle_antenna(valid_tx_ant, &rate, tbl);
2722
2723 rate = rate_n_flags_from_tbl(priv, tbl, rate_idx, use_green);
2724 tbl->current_rate = rate;
2725 rs_set_expected_tpt_table(lq_sta, tbl);
2726 rs_fill_link_cmd(NULL, lq_sta, rate);
2727 priv->stations[lq_sta->lq.sta_id].lq = &lq_sta->lq;
2728 iwl_send_lq_cmd(priv, ctx, &lq_sta->lq, CMD_SYNC, true);
2729}
2730
2731static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
2732 struct ieee80211_tx_rate_control *txrc)
2733{
2734
2735 struct sk_buff *skb = txrc->skb;
2736 struct ieee80211_supported_band *sband = txrc->sband;
2737 struct iwl_op_mode *op_mode __maybe_unused =
2738 (struct iwl_op_mode *)priv_r;
2739 struct iwl_priv *priv __maybe_unused = IWL_OP_MODE_GET_DVM(op_mode);
2740 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2741 struct iwl_lq_sta *lq_sta = priv_sta;
2742 int rate_idx;
2743
2744 IWL_DEBUG_RATE_LIMIT(priv, "rate scale calculate new rate for skb\n");
2745
2746 /* Get max rate if user set max rate */
2747 if (lq_sta) {
2748 lq_sta->max_rate_idx = txrc->max_rate_idx;
2749 if ((sband->band == IEEE80211_BAND_5GHZ) &&
2750 (lq_sta->max_rate_idx != -1))
2751 lq_sta->max_rate_idx += IWL_FIRST_OFDM_RATE;
2752 if ((lq_sta->max_rate_idx < 0) ||
2753 (lq_sta->max_rate_idx >= IWL_RATE_COUNT))
2754 lq_sta->max_rate_idx = -1;
2755 }
2756
2757 /* Treat uninitialized rate scaling data same as non-existing. */
2758 if (lq_sta && !lq_sta->drv) {
2759 IWL_DEBUG_RATE(priv, "Rate scaling not initialized yet.\n");
2760 priv_sta = NULL;
2761 }
2762
2763 /* Send management frames and NO_ACK data using lowest rate. */
2764 if (rate_control_send_low(sta, priv_sta, txrc))
2765 return;
2766
2767 rate_idx = lq_sta->last_txrate_idx;
2768
2769 if (lq_sta->last_rate_n_flags & RATE_MCS_HT_MSK) {
2770 rate_idx -= IWL_FIRST_OFDM_RATE;
2771 /* 6M and 9M shared same MCS index */
2772 rate_idx = (rate_idx > 0) ? (rate_idx - 1) : 0;
2773 if (rs_extract_rate(lq_sta->last_rate_n_flags) >=
2774 IWL_RATE_MIMO3_6M_PLCP)
2775 rate_idx = rate_idx + (2 * MCS_INDEX_PER_STREAM);
2776 else if (rs_extract_rate(lq_sta->last_rate_n_flags) >=
2777 IWL_RATE_MIMO2_6M_PLCP)
2778 rate_idx = rate_idx + MCS_INDEX_PER_STREAM;
2779 info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
2780 if (lq_sta->last_rate_n_flags & RATE_MCS_SGI_MSK)
2781 info->control.rates[0].flags |= IEEE80211_TX_RC_SHORT_GI;
2782 if (lq_sta->last_rate_n_flags & RATE_MCS_DUP_MSK)
2783 info->control.rates[0].flags |= IEEE80211_TX_RC_DUP_DATA;
2784 if (lq_sta->last_rate_n_flags & RATE_MCS_HT40_MSK)
2785 info->control.rates[0].flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
2786 if (lq_sta->last_rate_n_flags & RATE_MCS_GF_MSK)
2787 info->control.rates[0].flags |= IEEE80211_TX_RC_GREEN_FIELD;
2788 } else {
2789 /* Check for invalid rates */
2790 if ((rate_idx < 0) || (rate_idx >= IWL_RATE_COUNT_LEGACY) ||
2791 ((sband->band == IEEE80211_BAND_5GHZ) &&
2792 (rate_idx < IWL_FIRST_OFDM_RATE)))
2793 rate_idx = rate_lowest_index(sband, sta);
2794 /* On valid 5 GHz rate, adjust index */
2795 else if (sband->band == IEEE80211_BAND_5GHZ)
2796 rate_idx -= IWL_FIRST_OFDM_RATE;
2797 info->control.rates[0].flags = 0;
2798 }
2799 info->control.rates[0].idx = rate_idx;
2800
2801}
2802
2803static void *rs_alloc_sta(void *priv_rate, struct ieee80211_sta *sta,
2804 gfp_t gfp)
2805{
2806 struct iwl_station_priv *sta_priv = (struct iwl_station_priv *) sta->drv_priv;
2807 struct iwl_op_mode *op_mode __maybe_unused =
2808 (struct iwl_op_mode *)priv_rate;
2809 struct iwl_priv *priv __maybe_unused = IWL_OP_MODE_GET_DVM(op_mode);
2810
2811 IWL_DEBUG_RATE(priv, "create station rate scale window\n");
2812
2813 return &sta_priv->lq_sta;
2814}
2815
2816/*
2817 * Called after adding a new station to initialize rate scaling
2818 */
2819void iwl_rs_rate_init(struct iwl_priv *priv, struct ieee80211_sta *sta, u8 sta_id)
2820{
2821 int i, j;
2822 struct ieee80211_hw *hw = priv->hw;
2823 struct ieee80211_conf *conf = &priv->hw->conf;
2824 struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2825 struct iwl_station_priv *sta_priv;
2826 struct iwl_lq_sta *lq_sta;
2827 struct ieee80211_supported_band *sband;
2828 unsigned long supp; /* must be unsigned long for for_each_set_bit */
2829
2830 sta_priv = (struct iwl_station_priv *) sta->drv_priv;
2831 lq_sta = &sta_priv->lq_sta;
2832 sband = hw->wiphy->bands[conf->channel->band];
2833
2834
2835 lq_sta->lq.sta_id = sta_id;
2836
2837 for (j = 0; j < LQ_SIZE; j++)
2838 for (i = 0; i < IWL_RATE_COUNT; i++)
2839 rs_rate_scale_clear_window(&lq_sta->lq_info[j].win[i]);
2840
2841 lq_sta->flush_timer = 0;
2842 lq_sta->supp_rates = sta->supp_rates[sband->band];
2843 for (j = 0; j < LQ_SIZE; j++)
2844 for (i = 0; i < IWL_RATE_COUNT; i++)
2845 rs_rate_scale_clear_window(&lq_sta->lq_info[j].win[i]);
2846
2847 IWL_DEBUG_RATE(priv, "LQ: *** rate scale station global init for station %d ***\n",
2848 sta_id);
2849 /* TODO: what is a good starting rate for STA? About middle? Maybe not
2850 * the lowest or the highest rate.. Could consider using RSSI from
2851 * previous packets? Need to have IEEE 802.1X auth succeed immediately
2852 * after assoc.. */
2853
2854 lq_sta->is_dup = 0;
2855 lq_sta->max_rate_idx = -1;
2856 lq_sta->missed_rate_counter = IWL_MISSED_RATE_MAX;
2857 lq_sta->is_green = rs_use_green(sta);
2858 lq_sta->band = sband->band;
2859 /*
2860 * active legacy rates as per supported rates bitmap
2861 */
2862 supp = sta->supp_rates[sband->band];
2863 lq_sta->active_legacy_rate = 0;
2864 for_each_set_bit(i, &supp, BITS_PER_LONG)
2865 lq_sta->active_legacy_rate |= BIT(sband->bitrates[i].hw_value);
2866
2867 /*
2868 * active_siso_rate mask includes 9 MBits (bit 5), and CCK (bits 0-3),
2869 * supp_rates[] does not; shift to convert format, force 9 MBits off.
2870 */
2871 lq_sta->active_siso_rate = ht_cap->mcs.rx_mask[0] << 1;
2872 lq_sta->active_siso_rate |= ht_cap->mcs.rx_mask[0] & 0x1;
2873 lq_sta->active_siso_rate &= ~((u16)0x2);
2874 lq_sta->active_siso_rate <<= IWL_FIRST_OFDM_RATE;
2875
2876 /* Same here */
2877 lq_sta->active_mimo2_rate = ht_cap->mcs.rx_mask[1] << 1;
2878 lq_sta->active_mimo2_rate |= ht_cap->mcs.rx_mask[1] & 0x1;
2879 lq_sta->active_mimo2_rate &= ~((u16)0x2);
2880 lq_sta->active_mimo2_rate <<= IWL_FIRST_OFDM_RATE;
2881
2882 lq_sta->active_mimo3_rate = ht_cap->mcs.rx_mask[2] << 1;
2883 lq_sta->active_mimo3_rate |= ht_cap->mcs.rx_mask[2] & 0x1;
2884 lq_sta->active_mimo3_rate &= ~((u16)0x2);
2885 lq_sta->active_mimo3_rate <<= IWL_FIRST_OFDM_RATE;
2886
2887 IWL_DEBUG_RATE(priv, "SISO-RATE=%X MIMO2-RATE=%X MIMO3-RATE=%X\n",
2888 lq_sta->active_siso_rate,
2889 lq_sta->active_mimo2_rate,
2890 lq_sta->active_mimo3_rate);
2891
2892 /* These values will be overridden later */
2893 lq_sta->lq.general_params.single_stream_ant_msk =
2894 first_antenna(priv->eeprom_data->valid_tx_ant);
2895 lq_sta->lq.general_params.dual_stream_ant_msk =
2896 priv->eeprom_data->valid_tx_ant &
2897 ~first_antenna(priv->eeprom_data->valid_tx_ant);
2898 if (!lq_sta->lq.general_params.dual_stream_ant_msk) {
2899 lq_sta->lq.general_params.dual_stream_ant_msk = ANT_AB;
2900 } else if (num_of_ant(priv->eeprom_data->valid_tx_ant) == 2) {
2901 lq_sta->lq.general_params.dual_stream_ant_msk =
2902 priv->eeprom_data->valid_tx_ant;
2903 }
2904
2905 /* as default allow aggregation for all tids */
2906 lq_sta->tx_agg_tid_en = IWL_AGG_ALL_TID;
2907 lq_sta->drv = priv;
2908
2909 /* Set last_txrate_idx to lowest rate */
2910 lq_sta->last_txrate_idx = rate_lowest_index(sband, sta);
2911 if (sband->band == IEEE80211_BAND_5GHZ)
2912 lq_sta->last_txrate_idx += IWL_FIRST_OFDM_RATE;
2913 lq_sta->is_agg = 0;
2914#ifdef CONFIG_IWLWIFI_DEVICE_TESTMODE
2915 priv->tm_fixed_rate = 0;
2916#endif
2917#ifdef CONFIG_MAC80211_DEBUGFS
2918 lq_sta->dbg_fixed_rate = 0;
2919#endif
2920
2921 rs_initialize_lq(priv, sta, lq_sta);
2922}
2923
2924static void rs_fill_link_cmd(struct iwl_priv *priv,
2925 struct iwl_lq_sta *lq_sta, u32 new_rate)
2926{
2927 struct iwl_scale_tbl_info tbl_type;
2928 int index = 0;
2929 int rate_idx;
2930 int repeat_rate = 0;
2931 u8 ant_toggle_cnt = 0;
2932 u8 use_ht_possible = 1;
2933 u8 valid_tx_ant = 0;
2934 struct iwl_station_priv *sta_priv =
2935 container_of(lq_sta, struct iwl_station_priv, lq_sta);
2936 struct iwl_link_quality_cmd *lq_cmd = &lq_sta->lq;
2937
2938 /* Override starting rate (index 0) if needed for debug purposes */
2939 rs_dbgfs_set_mcs(lq_sta, &new_rate, index);
2940
2941 /* Interpret new_rate (rate_n_flags) */
2942 rs_get_tbl_info_from_mcs(new_rate, lq_sta->band,
2943 &tbl_type, &rate_idx);
2944
2945 if (priv && priv->bt_full_concurrent) {
2946 /* 1x1 only */
2947 tbl_type.ant_type =
2948 first_antenna(priv->eeprom_data->valid_tx_ant);
2949 }
2950
2951 /* How many times should we repeat the initial rate? */
2952 if (is_legacy(tbl_type.lq_type)) {
2953 ant_toggle_cnt = 1;
2954 repeat_rate = IWL_NUMBER_TRY;
2955 } else {
2956 repeat_rate = min(IWL_HT_NUMBER_TRY,
2957 LINK_QUAL_AGG_DISABLE_START_DEF - 1);
2958 }
2959
2960 lq_cmd->general_params.mimo_delimiter =
2961 is_mimo(tbl_type.lq_type) ? 1 : 0;
2962
2963 /* Fill 1st table entry (index 0) */
2964 lq_cmd->rs_table[index].rate_n_flags = cpu_to_le32(new_rate);
2965
2966 if (num_of_ant(tbl_type.ant_type) == 1) {
2967 lq_cmd->general_params.single_stream_ant_msk =
2968 tbl_type.ant_type;
2969 } else if (num_of_ant(tbl_type.ant_type) == 2) {
2970 lq_cmd->general_params.dual_stream_ant_msk =
2971 tbl_type.ant_type;
2972 } /* otherwise we don't modify the existing value */
2973
2974 index++;
2975 repeat_rate--;
2976 if (priv) {
2977 if (priv->bt_full_concurrent)
2978 valid_tx_ant = ANT_A;
2979 else
2980 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
2981 }
2982
2983 /* Fill rest of rate table */
2984 while (index < LINK_QUAL_MAX_RETRY_NUM) {
2985 /* Repeat initial/next rate.
2986 * For legacy IWL_NUMBER_TRY == 1, this loop will not execute.
2987 * For HT IWL_HT_NUMBER_TRY == 3, this executes twice. */
2988 while (repeat_rate > 0 && (index < LINK_QUAL_MAX_RETRY_NUM)) {
2989 if (is_legacy(tbl_type.lq_type)) {
2990 if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
2991 ant_toggle_cnt++;
2992 else if (priv &&
2993 rs_toggle_antenna(valid_tx_ant,
2994 &new_rate, &tbl_type))
2995 ant_toggle_cnt = 1;
2996 }
2997
2998 /* Override next rate if needed for debug purposes */
2999 rs_dbgfs_set_mcs(lq_sta, &new_rate, index);
3000
3001 /* Fill next table entry */
3002 lq_cmd->rs_table[index].rate_n_flags =
3003 cpu_to_le32(new_rate);
3004 repeat_rate--;
3005 index++;
3006 }
3007
3008 rs_get_tbl_info_from_mcs(new_rate, lq_sta->band, &tbl_type,
3009 &rate_idx);
3010
3011 if (priv && priv->bt_full_concurrent) {
3012 /* 1x1 only */
3013 tbl_type.ant_type =
3014 first_antenna(priv->eeprom_data->valid_tx_ant);
3015 }
3016
3017 /* Indicate to uCode which entries might be MIMO.
3018 * If initial rate was MIMO, this will finally end up
3019 * as (IWL_HT_NUMBER_TRY * 2), after 2nd pass, otherwise 0. */
3020 if (is_mimo(tbl_type.lq_type))
3021 lq_cmd->general_params.mimo_delimiter = index;
3022
3023 /* Get next rate */
3024 new_rate = rs_get_lower_rate(lq_sta, &tbl_type, rate_idx,
3025 use_ht_possible);
3026
3027 /* How many times should we repeat the next rate? */
3028 if (is_legacy(tbl_type.lq_type)) {
3029 if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
3030 ant_toggle_cnt++;
3031 else if (priv &&
3032 rs_toggle_antenna(valid_tx_ant,
3033 &new_rate, &tbl_type))
3034 ant_toggle_cnt = 1;
3035
3036 repeat_rate = IWL_NUMBER_TRY;
3037 } else {
3038 repeat_rate = IWL_HT_NUMBER_TRY;
3039 }
3040
3041 /* Don't allow HT rates after next pass.
3042 * rs_get_lower_rate() will change type to LQ_A or LQ_G. */
3043 use_ht_possible = 0;
3044
3045 /* Override next rate if needed for debug purposes */
3046 rs_dbgfs_set_mcs(lq_sta, &new_rate, index);
3047
3048 /* Fill next table entry */
3049 lq_cmd->rs_table[index].rate_n_flags = cpu_to_le32(new_rate);
3050
3051 index++;
3052 repeat_rate--;
3053 }
3054
3055 lq_cmd->agg_params.agg_frame_cnt_limit =
3056 sta_priv->max_agg_bufsize ?: LINK_QUAL_AGG_FRAME_LIMIT_DEF;
3057 lq_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
3058
3059 lq_cmd->agg_params.agg_time_limit =
3060 cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
3061 /*
3062 * overwrite if needed, pass aggregation time limit
3063 * to uCode in uSec
3064 */
3065 if (priv && priv->cfg->bt_params &&
3066 priv->cfg->bt_params->agg_time_limit &&
3067 priv->bt_traffic_load >= IWL_BT_COEX_TRAFFIC_LOAD_HIGH)
3068 lq_cmd->agg_params.agg_time_limit =
3069 cpu_to_le16(priv->cfg->bt_params->agg_time_limit);
3070}
3071
3072static void *rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
3073{
3074 return hw->priv;
3075}
3076/* rate scale requires free function to be implemented */
3077static void rs_free(void *priv_rate)
3078{
3079 return;
3080}
3081
3082static void rs_free_sta(void *priv_r, struct ieee80211_sta *sta,
3083 void *priv_sta)
3084{
3085 struct iwl_op_mode *op_mode __maybe_unused = priv_r;
3086 struct iwl_priv *priv __maybe_unused = IWL_OP_MODE_GET_DVM(op_mode);
3087
3088 IWL_DEBUG_RATE(priv, "enter\n");
3089 IWL_DEBUG_RATE(priv, "leave\n");
3090}
3091
3092#ifdef CONFIG_MAC80211_DEBUGFS
3093static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
3094 u32 *rate_n_flags, int index)
3095{
3096 struct iwl_priv *priv;
3097 u8 valid_tx_ant;
3098 u8 ant_sel_tx;
3099
3100 priv = lq_sta->drv;
3101 valid_tx_ant = priv->eeprom_data->valid_tx_ant;
3102 if (lq_sta->dbg_fixed_rate) {
3103 ant_sel_tx =
3104 ((lq_sta->dbg_fixed_rate & RATE_MCS_ANT_ABC_MSK)
3105 >> RATE_MCS_ANT_POS);
3106 if ((valid_tx_ant & ant_sel_tx) == ant_sel_tx) {
3107 *rate_n_flags = lq_sta->dbg_fixed_rate;
3108 IWL_DEBUG_RATE(priv, "Fixed rate ON\n");
3109 } else {
3110 lq_sta->dbg_fixed_rate = 0;
3111 IWL_ERR(priv,
3112 "Invalid antenna selection 0x%X, Valid is 0x%X\n",
3113 ant_sel_tx, valid_tx_ant);
3114 IWL_DEBUG_RATE(priv, "Fixed rate OFF\n");
3115 }
3116 } else {
3117 IWL_DEBUG_RATE(priv, "Fixed rate OFF\n");
3118 }
3119}
3120
3121static ssize_t rs_sta_dbgfs_scale_table_write(struct file *file,
3122 const char __user *user_buf, size_t count, loff_t *ppos)
3123{
3124 struct iwl_lq_sta *lq_sta = file->private_data;
3125 struct iwl_priv *priv;
3126 char buf[64];
3127 size_t buf_size;
3128 u32 parsed_rate;
3129
3130
3131 priv = lq_sta->drv;
3132 memset(buf, 0, sizeof(buf));
3133 buf_size = min(count, sizeof(buf) - 1);
3134 if (copy_from_user(buf, user_buf, buf_size))
3135 return -EFAULT;
3136
3137 if (sscanf(buf, "%x", &parsed_rate) == 1)
3138 lq_sta->dbg_fixed_rate = parsed_rate;
3139 else
3140 lq_sta->dbg_fixed_rate = 0;
3141
3142 rs_program_fix_rate(priv, lq_sta);
3143
3144 return count;
3145}
3146
3147static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file,
3148 char __user *user_buf, size_t count, loff_t *ppos)
3149{
3150 char *buff;
3151 int desc = 0;
3152 int i = 0;
3153 int index = 0;
3154 ssize_t ret;
3155
3156 struct iwl_lq_sta *lq_sta = file->private_data;
3157 struct iwl_priv *priv;
3158 struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
3159
3160 priv = lq_sta->drv;
3161 buff = kmalloc(1024, GFP_KERNEL);
3162 if (!buff)
3163 return -ENOMEM;
3164
3165 desc += sprintf(buff+desc, "sta_id %d\n", lq_sta->lq.sta_id);
3166 desc += sprintf(buff+desc, "failed=%d success=%d rate=0%X\n",
3167 lq_sta->total_failed, lq_sta->total_success,
3168 lq_sta->active_legacy_rate);
3169 desc += sprintf(buff+desc, "fixed rate 0x%X\n",
3170 lq_sta->dbg_fixed_rate);
3171 desc += sprintf(buff+desc, "valid_tx_ant %s%s%s\n",
3172 (priv->eeprom_data->valid_tx_ant & ANT_A) ? "ANT_A," : "",
3173 (priv->eeprom_data->valid_tx_ant & ANT_B) ? "ANT_B," : "",
3174 (priv->eeprom_data->valid_tx_ant & ANT_C) ? "ANT_C" : "");
3175 desc += sprintf(buff+desc, "lq type %s\n",
3176 (is_legacy(tbl->lq_type)) ? "legacy" : "HT");
3177 if (is_Ht(tbl->lq_type)) {
3178 desc += sprintf(buff+desc, " %s",
3179 (is_siso(tbl->lq_type)) ? "SISO" :
3180 ((is_mimo2(tbl->lq_type)) ? "MIMO2" : "MIMO3"));
3181 desc += sprintf(buff+desc, " %s",
3182 (tbl->is_ht40) ? "40MHz" : "20MHz");
3183 desc += sprintf(buff+desc, " %s %s %s\n", (tbl->is_SGI) ? "SGI" : "",
3184 (lq_sta->is_green) ? "GF enabled" : "",
3185 (lq_sta->is_agg) ? "AGG on" : "");
3186 }
3187 desc += sprintf(buff+desc, "last tx rate=0x%X\n",
3188 lq_sta->last_rate_n_flags);
3189 desc += sprintf(buff+desc, "general:"
3190 "flags=0x%X mimo-d=%d s-ant0x%x d-ant=0x%x\n",
3191 lq_sta->lq.general_params.flags,
3192 lq_sta->lq.general_params.mimo_delimiter,
3193 lq_sta->lq.general_params.single_stream_ant_msk,
3194 lq_sta->lq.general_params.dual_stream_ant_msk);
3195
3196 desc += sprintf(buff+desc, "agg:"
3197 "time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
3198 le16_to_cpu(lq_sta->lq.agg_params.agg_time_limit),
3199 lq_sta->lq.agg_params.agg_dis_start_th,
3200 lq_sta->lq.agg_params.agg_frame_cnt_limit);
3201
3202 desc += sprintf(buff+desc,
3203 "Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
3204 lq_sta->lq.general_params.start_rate_index[0],
3205 lq_sta->lq.general_params.start_rate_index[1],
3206 lq_sta->lq.general_params.start_rate_index[2],
3207 lq_sta->lq.general_params.start_rate_index[3]);
3208
3209 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
3210 index = iwl_hwrate_to_plcp_idx(
3211 le32_to_cpu(lq_sta->lq.rs_table[i].rate_n_flags));
3212 if (is_legacy(tbl->lq_type)) {
3213 desc += sprintf(buff+desc, " rate[%d] 0x%X %smbps\n",
3214 i, le32_to_cpu(lq_sta->lq.rs_table[i].rate_n_flags),
3215 iwl_rate_mcs[index].mbps);
3216 } else {
3217 desc += sprintf(buff+desc, " rate[%d] 0x%X %smbps (%s)\n",
3218 i, le32_to_cpu(lq_sta->lq.rs_table[i].rate_n_flags),
3219 iwl_rate_mcs[index].mbps, iwl_rate_mcs[index].mcs);
3220 }
3221 }
3222
3223 ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
3224 kfree(buff);
3225 return ret;
3226}
3227
3228static const struct file_operations rs_sta_dbgfs_scale_table_ops = {
3229 .write = rs_sta_dbgfs_scale_table_write,
3230 .read = rs_sta_dbgfs_scale_table_read,
3231 .open = simple_open,
3232 .llseek = default_llseek,
3233};
3234static ssize_t rs_sta_dbgfs_stats_table_read(struct file *file,
3235 char __user *user_buf, size_t count, loff_t *ppos)
3236{
3237 char *buff;
3238 int desc = 0;
3239 int i, j;
3240 ssize_t ret;
3241
3242 struct iwl_lq_sta *lq_sta = file->private_data;
3243
3244 buff = kmalloc(1024, GFP_KERNEL);
3245 if (!buff)
3246 return -ENOMEM;
3247
3248 for (i = 0; i < LQ_SIZE; i++) {
3249 desc += sprintf(buff+desc,
3250 "%s type=%d SGI=%d HT40=%d DUP=%d GF=%d\n"
3251 "rate=0x%X\n",
3252 lq_sta->active_tbl == i ? "*" : "x",
3253 lq_sta->lq_info[i].lq_type,
3254 lq_sta->lq_info[i].is_SGI,
3255 lq_sta->lq_info[i].is_ht40,
3256 lq_sta->lq_info[i].is_dup,
3257 lq_sta->is_green,
3258 lq_sta->lq_info[i].current_rate);
3259 for (j = 0; j < IWL_RATE_COUNT; j++) {
3260 desc += sprintf(buff+desc,
3261 "counter=%d success=%d %%=%d\n",
3262 lq_sta->lq_info[i].win[j].counter,
3263 lq_sta->lq_info[i].win[j].success_counter,
3264 lq_sta->lq_info[i].win[j].success_ratio);
3265 }
3266 }
3267 ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
3268 kfree(buff);
3269 return ret;
3270}
3271
3272static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
3273 .read = rs_sta_dbgfs_stats_table_read,
3274 .open = simple_open,
3275 .llseek = default_llseek,
3276};
3277
3278static ssize_t rs_sta_dbgfs_rate_scale_data_read(struct file *file,
3279 char __user *user_buf, size_t count, loff_t *ppos)
3280{
3281 struct iwl_lq_sta *lq_sta = file->private_data;
3282 struct iwl_scale_tbl_info *tbl = &lq_sta->lq_info[lq_sta->active_tbl];
3283 char buff[120];
3284 int desc = 0;
3285
3286 if (is_Ht(tbl->lq_type))
3287 desc += sprintf(buff+desc,
3288 "Bit Rate= %d Mb/s\n",
3289 tbl->expected_tpt[lq_sta->last_txrate_idx]);
3290 else
3291 desc += sprintf(buff+desc,
3292 "Bit Rate= %d Mb/s\n",
3293 iwl_rates[lq_sta->last_txrate_idx].ieee >> 1);
3294
3295 return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
3296}
3297
3298static const struct file_operations rs_sta_dbgfs_rate_scale_data_ops = {
3299 .read = rs_sta_dbgfs_rate_scale_data_read,
3300 .open = simple_open,
3301 .llseek = default_llseek,
3302};
3303
3304static void rs_add_debugfs(void *priv, void *priv_sta,
3305 struct dentry *dir)
3306{
3307 struct iwl_lq_sta *lq_sta = priv_sta;
3308 lq_sta->rs_sta_dbgfs_scale_table_file =
3309 debugfs_create_file("rate_scale_table", S_IRUSR | S_IWUSR, dir,
3310 lq_sta, &rs_sta_dbgfs_scale_table_ops);
3311 lq_sta->rs_sta_dbgfs_stats_table_file =
3312 debugfs_create_file("rate_stats_table", S_IRUSR, dir,
3313 lq_sta, &rs_sta_dbgfs_stats_table_ops);
3314 lq_sta->rs_sta_dbgfs_rate_scale_data_file =
3315 debugfs_create_file("rate_scale_data", S_IRUSR, dir,
3316 lq_sta, &rs_sta_dbgfs_rate_scale_data_ops);
3317 lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file =
3318 debugfs_create_u8("tx_agg_tid_enable", S_IRUSR | S_IWUSR, dir,
3319 &lq_sta->tx_agg_tid_en);
3320
3321}
3322
3323static void rs_remove_debugfs(void *priv, void *priv_sta)
3324{
3325 struct iwl_lq_sta *lq_sta = priv_sta;
3326 debugfs_remove(lq_sta->rs_sta_dbgfs_scale_table_file);
3327 debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
3328 debugfs_remove(lq_sta->rs_sta_dbgfs_rate_scale_data_file);
3329 debugfs_remove(lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file);
3330}
3331#endif
3332
3333/*
3334 * Initialization of rate scaling information is done by driver after
3335 * the station is added. Since mac80211 calls this function before a
3336 * station is added we ignore it.
3337 */
3338static void rs_rate_init_stub(void *priv_r, struct ieee80211_supported_band *sband,
3339 struct ieee80211_sta *sta, void *priv_sta)
3340{
3341}
3342static struct rate_control_ops rs_ops = {
3343 .module = NULL,
3344 .name = RS_NAME,
3345 .tx_status = rs_tx_status,
3346 .get_rate = rs_get_rate,
3347 .rate_init = rs_rate_init_stub,
3348 .alloc = rs_alloc,
3349 .free = rs_free,
3350 .alloc_sta = rs_alloc_sta,
3351 .free_sta = rs_free_sta,
3352#ifdef CONFIG_MAC80211_DEBUGFS
3353 .add_sta_debugfs = rs_add_debugfs,
3354 .remove_sta_debugfs = rs_remove_debugfs,
3355#endif
3356};
3357
3358int iwlagn_rate_control_register(void)
3359{
3360 return ieee80211_rate_control_register(&rs_ops);
3361}
3362
3363void iwlagn_rate_control_unregister(void)
3364{
3365 ieee80211_rate_control_unregister(&rs_ops);
3366}
3367
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-06 13:41:55 -0500