?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlegacy: move ht out of ctx structure
[linux-2.6.git] / drivers / net / wireless / iwlegacy / 4965-rs.c
blobad186d9a598fb613cc14f67e4dda6bc367e004dc
1 /******************************************************************************
2 *
3 * Copyright(c) 2005 - 2011 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 "common.h"
39 #include "4965.h"
40
41 #define IL4965_RS_NAME "iwl-4965-rs"
42
43 #define NUM_TRY_BEFORE_ANT_TOGGLE 1
44 #define IL_NUMBER_TRY 1
45 #define IL_HT_NUMBER_TRY 3
46
47 #define RATE_MAX_WINDOW 62 /* # tx in history win */
48 #define RATE_MIN_FAILURE_TH 6 /* min failures to calc tpt */
49 #define RATE_MIN_SUCCESS_TH 8 /* min successes to calc tpt */
50
51 /* max allowed rate miss before sync LQ cmd */
52 #define IL_MISSED_RATE_MAX 15
53 /* max time to accum history 2 seconds */
54 #define RATE_SCALE_FLUSH_INTVL (3*HZ)
55
56 static u8 rs_ht_to_legacy[] = {
57 RATE_6M_IDX, RATE_6M_IDX,
58 RATE_6M_IDX, RATE_6M_IDX,
59 RATE_6M_IDX,
60 RATE_6M_IDX, RATE_9M_IDX,
61 RATE_12M_IDX, RATE_18M_IDX,
62 RATE_24M_IDX, RATE_36M_IDX,
63 RATE_48M_IDX, RATE_54M_IDX
64 };
65
66 static 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 IL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np) \
78 [RATE_##r##M_IDX] = { RATE_##r##M_PLCP, \
79 RATE_SISO_##s##M_PLCP, \
80 RATE_MIMO2_##s##M_PLCP,\
81 RATE_##r##M_IEEE, \
82 RATE_##ip##M_IDX, \
83 RATE_##in##M_IDX, \
84 RATE_##rp##M_IDX, \
85 RATE_##rn##M_IDX, \
86 RATE_##pp##M_IDX, \
87 RATE_##np##M_IDX }
88
89 /*
90 * Parameter order:
91 * rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
92 *
93 * If there isn't a valid next or previous rate then INV is used which
94 * maps to RATE_INVALID
95 *
96 */
97 const struct il_rate_info il_rates[RATE_COUNT] = {
98 IL_DECLARE_RATE_INFO(1, INV, INV, 2, INV, 2, INV, 2), /* 1mbps */
99 IL_DECLARE_RATE_INFO(2, INV, 1, 5, 1, 5, 1, 5), /* 2mbps */
100 IL_DECLARE_RATE_INFO(5, INV, 2, 6, 2, 11, 2, 11), /*5.5mbps */
101 IL_DECLARE_RATE_INFO(11, INV, 9, 12, 9, 12, 5, 18), /* 11mbps */
102 IL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11), /* 6mbps */
103 IL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11), /* 9mbps */
104 IL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18), /* 12mbps */
105 IL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24), /* 18mbps */
106 IL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36), /* 24mbps */
107 IL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48), /* 36mbps */
108 IL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54), /* 48mbps */
109 IL_DECLARE_RATE_INFO(54, 54, 48, INV, 48, INV, 48, INV),/* 54mbps */
110 IL_DECLARE_RATE_INFO(60, 60, 48, INV, 48, INV, 48, INV),/* 60mbps */
111 };
112
113 static int
114 il4965_hwrate_to_plcp_idx(u32 rate_n_flags)
115 {
116 int idx = 0;
117
118 /* HT rate format */
119 if (rate_n_flags & RATE_MCS_HT_MSK) {
120 idx = (rate_n_flags & 0xff);
121
122 if (idx >= RATE_MIMO2_6M_PLCP)
123 idx = idx - RATE_MIMO2_6M_PLCP;
124
125 idx += IL_FIRST_OFDM_RATE;
126 /* skip 9M not supported in ht */
127 if (idx >= RATE_9M_IDX)
128 idx += 1;
129 if (idx >= IL_FIRST_OFDM_RATE && idx <= IL_LAST_OFDM_RATE)
130 return idx;
131
132 /* legacy rate format, search for match in table */
133 } else {
134 for (idx = 0; idx < ARRAY_SIZE(il_rates); idx++)
135 if (il_rates[idx].plcp == (rate_n_flags & 0xFF))
136 return idx;
137 }
138
139 return -1;
140 }
141
142 static void il4965_rs_rate_scale_perform(struct il_priv *il,
143 struct sk_buff *skb,
144 struct ieee80211_sta *sta,
145 struct il_lq_sta *lq_sta);
146 static void il4965_rs_fill_link_cmd(struct il_priv *il,
147 struct il_lq_sta *lq_sta, u32 rate_n_flags);
148 static void il4965_rs_stay_in_table(struct il_lq_sta *lq_sta,
149 bool force_search);
150
151 #ifdef CONFIG_MAC80211_DEBUGFS
152 static void il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta,
153 u32 *rate_n_flags, int idx);
154 #else
155 static void
156 il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta, u32 * rate_n_flags, int idx)
157 {
158 }
159 #endif
160
161 /**
162 * The following tables contain the expected throughput metrics for all rates
163 *
164 * 1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 60 MBits
165 *
166 * where invalid entries are zeros.
167 *
168 * CCK rates are only valid in legacy table and will only be used in G
169 * (2.4 GHz) band.
170 */
171
172 static s32 expected_tpt_legacy[RATE_COUNT] = {
173 7, 13, 35, 58, 40, 57, 72, 98, 121, 154, 177, 186, 0
174 };
175
176 static s32 expected_tpt_siso20MHz[4][RATE_COUNT] = {
177 {0, 0, 0, 0, 42, 0, 76, 102, 124, 158, 183, 193, 202}, /* Norm */
178 {0, 0, 0, 0, 46, 0, 82, 110, 132, 167, 192, 202, 210}, /* SGI */
179 {0, 0, 0, 0, 48, 0, 93, 135, 176, 251, 319, 351, 381}, /* AGG */
180 {0, 0, 0, 0, 53, 0, 102, 149, 193, 275, 348, 381, 413}, /* AGG+SGI */
181 };
182
183 static s32 expected_tpt_siso40MHz[4][RATE_COUNT] = {
184 {0, 0, 0, 0, 77, 0, 127, 160, 184, 220, 242, 250, 257}, /* Norm */
185 {0, 0, 0, 0, 83, 0, 135, 169, 193, 229, 250, 257, 264}, /* SGI */
186 {0, 0, 0, 0, 96, 0, 182, 259, 328, 451, 553, 598, 640}, /* AGG */
187 {0, 0, 0, 0, 106, 0, 199, 282, 357, 487, 593, 640, 683}, /* AGG+SGI */
188 };
189
190 static s32 expected_tpt_mimo2_20MHz[4][RATE_COUNT] = {
191 {0, 0, 0, 0, 74, 0, 123, 155, 179, 213, 235, 243, 250}, /* Norm */
192 {0, 0, 0, 0, 81, 0, 131, 164, 187, 221, 242, 250, 256}, /* SGI */
193 {0, 0, 0, 0, 92, 0, 175, 250, 317, 436, 534, 578, 619}, /* AGG */
194 {0, 0, 0, 0, 102, 0, 192, 273, 344, 470, 573, 619, 660}, /* AGG+SGI */
195 };
196
197 static s32 expected_tpt_mimo2_40MHz[4][RATE_COUNT] = {
198 {0, 0, 0, 0, 123, 0, 182, 214, 235, 264, 279, 285, 289}, /* Norm */
199 {0, 0, 0, 0, 131, 0, 191, 222, 242, 270, 284, 289, 293}, /* SGI */
200 {0, 0, 0, 0, 180, 0, 327, 446, 545, 708, 828, 878, 922}, /* AGG */
201 {0, 0, 0, 0, 197, 0, 355, 481, 584, 752, 872, 922, 966}, /* AGG+SGI */
202 };
203
204 /* mbps, mcs */
205 static const struct il_rate_mcs_info il_rate_mcs[RATE_COUNT] = {
206 {"1", "BPSK DSSS"},
207 {"2", "QPSK DSSS"},
208 {"5.5", "BPSK CCK"},
209 {"11", "QPSK CCK"},
210 {"6", "BPSK 1/2"},
211 {"9", "BPSK 1/2"},
212 {"12", "QPSK 1/2"},
213 {"18", "QPSK 3/4"},
214 {"24", "16QAM 1/2"},
215 {"36", "16QAM 3/4"},
216 {"48", "64QAM 2/3"},
217 {"54", "64QAM 3/4"},
218 {"60", "64QAM 5/6"},
219 };
220
221 #define MCS_IDX_PER_STREAM (8)
222
223 static inline u8
224 il4965_rs_extract_rate(u32 rate_n_flags)
225 {
226 return (u8) (rate_n_flags & 0xFF);
227 }
228
229 static void
230 il4965_rs_rate_scale_clear_win(struct il_rate_scale_data *win)
231 {
232 win->data = 0;
233 win->success_counter = 0;
234 win->success_ratio = IL_INVALID_VALUE;
235 win->counter = 0;
236 win->average_tpt = IL_INVALID_VALUE;
237 win->stamp = 0;
238 }
239
240 static inline u8
241 il4965_rs_is_valid_ant(u8 valid_antenna, u8 ant_type)
242 {
243 return (ant_type & valid_antenna) == ant_type;
244 }
245
246 /*
247 * removes the old data from the stats. All data that is older than
248 * TID_MAX_TIME_DIFF, will be deleted.
249 */
250 static void
251 il4965_rs_tl_rm_old_stats(struct il_traffic_load *tl, u32 curr_time)
252 {
253 /* The oldest age we want to keep */
254 u32 oldest_time = curr_time - TID_MAX_TIME_DIFF;
255
256 while (tl->queue_count && tl->time_stamp < oldest_time) {
257 tl->total -= tl->packet_count[tl->head];
258 tl->packet_count[tl->head] = 0;
259 tl->time_stamp += TID_QUEUE_CELL_SPACING;
260 tl->queue_count--;
261 tl->head++;
262 if (tl->head >= TID_QUEUE_MAX_SIZE)
263 tl->head = 0;
264 }
265 }
266
267 /*
268 * increment traffic load value for tid and also remove
269 * any old values if passed the certain time period
270 */
271 static u8
272 il4965_rs_tl_add_packet(struct il_lq_sta *lq_data, struct ieee80211_hdr *hdr)
273 {
274 u32 curr_time = jiffies_to_msecs(jiffies);
275 u32 time_diff;
276 s32 idx;
277 struct il_traffic_load *tl = NULL;
278 u8 tid;
279
280 if (ieee80211_is_data_qos(hdr->frame_control)) {
281 u8 *qc = ieee80211_get_qos_ctl(hdr);
282 tid = qc[0] & 0xf;
283 } else
284 return MAX_TID_COUNT;
285
286 if (unlikely(tid >= TID_MAX_LOAD_COUNT))
287 return MAX_TID_COUNT;
288
289 tl = &lq_data->load[tid];
290
291 curr_time -= curr_time % TID_ROUND_VALUE;
292
293 /* Happens only for the first packet. Initialize the data */
294 if (!(tl->queue_count)) {
295 tl->total = 1;
296 tl->time_stamp = curr_time;
297 tl->queue_count = 1;
298 tl->head = 0;
299 tl->packet_count[0] = 1;
300 return MAX_TID_COUNT;
301 }
302
303 time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
304 idx = time_diff / TID_QUEUE_CELL_SPACING;
305
306 /* The history is too long: remove data that is older than */
307 /* TID_MAX_TIME_DIFF */
308 if (idx >= TID_QUEUE_MAX_SIZE)
309 il4965_rs_tl_rm_old_stats(tl, curr_time);
310
311 idx = (tl->head + idx) % TID_QUEUE_MAX_SIZE;
312 tl->packet_count[idx] = tl->packet_count[idx] + 1;
313 tl->total = tl->total + 1;
314
315 if ((idx + 1) > tl->queue_count)
316 tl->queue_count = idx + 1;
317
318 return tid;
319 }
320
321 /*
322 get the traffic load value for tid
323 */
324 static u32
325 il4965_rs_tl_get_load(struct il_lq_sta *lq_data, u8 tid)
326 {
327 u32 curr_time = jiffies_to_msecs(jiffies);
328 u32 time_diff;
329 s32 idx;
330 struct il_traffic_load *tl = NULL;
331
332 if (tid >= TID_MAX_LOAD_COUNT)
333 return 0;
334
335 tl = &(lq_data->load[tid]);
336
337 curr_time -= curr_time % TID_ROUND_VALUE;
338
339 if (!(tl->queue_count))
340 return 0;
341
342 time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
343 idx = time_diff / TID_QUEUE_CELL_SPACING;
344
345 /* The history is too long: remove data that is older than */
346 /* TID_MAX_TIME_DIFF */
347 if (idx >= TID_QUEUE_MAX_SIZE)
348 il4965_rs_tl_rm_old_stats(tl, curr_time);
349
350 return tl->total;
351 }
352
353 static int
354 il4965_rs_tl_turn_on_agg_for_tid(struct il_priv *il, struct il_lq_sta *lq_data,
355 u8 tid, struct ieee80211_sta *sta)
356 {
357 int ret = -EAGAIN;
358 u32 load;
359
360 load = il4965_rs_tl_get_load(lq_data, tid);
361
362 if (load > IL_AGG_LOAD_THRESHOLD) {
363 D_HT("Starting Tx agg: STA: %pM tid: %d\n", sta->addr, tid);
364 ret = ieee80211_start_tx_ba_session(sta, tid, 5000);
365 if (ret == -EAGAIN) {
366 /*
367 * driver and mac80211 is out of sync
368 * this might be cause by reloading firmware
369 * stop the tx ba session here
370 */
371 IL_ERR("Fail start Tx agg on tid: %d\n", tid);
372 ieee80211_stop_tx_ba_session(sta, tid);
373 }
374 } else
375 D_HT("Aggregation not enabled for tid %d because load = %u\n",
376 tid, load);
377
378 return ret;
379 }
380
381 static void
382 il4965_rs_tl_turn_on_agg(struct il_priv *il, u8 tid, struct il_lq_sta *lq_data,
383 struct ieee80211_sta *sta)
384 {
385 if (tid < TID_MAX_LOAD_COUNT)
386 il4965_rs_tl_turn_on_agg_for_tid(il, lq_data, tid, sta);
387 else
388 IL_ERR("tid exceeds max load count: %d/%d\n", tid,
389 TID_MAX_LOAD_COUNT);
390 }
391
392 static inline int
393 il4965_get_il4965_num_of_ant_from_rate(u32 rate_n_flags)
394 {
395 return !!(rate_n_flags & RATE_MCS_ANT_A_MSK) +
396 !!(rate_n_flags & RATE_MCS_ANT_B_MSK) +
397 !!(rate_n_flags & RATE_MCS_ANT_C_MSK);
398 }
399
400 /*
401 * Static function to get the expected throughput from an il_scale_tbl_info
402 * that wraps a NULL pointer check
403 */
404 static s32
405 il4965_get_expected_tpt(struct il_scale_tbl_info *tbl, int rs_idx)
406 {
407 if (tbl->expected_tpt)
408 return tbl->expected_tpt[rs_idx];
409 return 0;
410 }
411
412 /**
413 * il4965_rs_collect_tx_data - Update the success/failure sliding win
414 *
415 * We keep a sliding win of the last 62 packets transmitted
416 * at this rate. win->data contains the bitmask of successful
417 * packets.
418 */
419 static int
420 il4965_rs_collect_tx_data(struct il_scale_tbl_info *tbl, int scale_idx,
421 int attempts, int successes)
422 {
423 struct il_rate_scale_data *win = NULL;
424 static const u64 mask = (((u64) 1) << (RATE_MAX_WINDOW - 1));
425 s32 fail_count, tpt;
426
427 if (scale_idx < 0 || scale_idx >= RATE_COUNT)
428 return -EINVAL;
429
430 /* Select win for current tx bit rate */
431 win = &(tbl->win[scale_idx]);
432
433 /* Get expected throughput */
434 tpt = il4965_get_expected_tpt(tbl, scale_idx);
435
436 /*
437 * Keep track of only the latest 62 tx frame attempts in this rate's
438 * history win; anything older isn't really relevant any more.
439 * If we have filled up the sliding win, drop the oldest attempt;
440 * if the oldest attempt (highest bit in bitmap) shows "success",
441 * subtract "1" from the success counter (this is the main reason
442 * we keep these bitmaps!).
443 */
444 while (attempts > 0) {
445 if (win->counter >= RATE_MAX_WINDOW) {
446
447 /* remove earliest */
448 win->counter = RATE_MAX_WINDOW - 1;
449
450 if (win->data & mask) {
451 win->data &= ~mask;
452 win->success_counter--;
453 }
454 }
455
456 /* Increment frames-attempted counter */
457 win->counter++;
458
459 /* Shift bitmap by one frame to throw away oldest history */
460 win->data <<= 1;
461
462 /* Mark the most recent #successes attempts as successful */
463 if (successes > 0) {
464 win->success_counter++;
465 win->data |= 0x1;
466 successes--;
467 }
468
469 attempts--;
470 }
471
472 /* Calculate current success ratio, avoid divide-by-0! */
473 if (win->counter > 0)
474 win->success_ratio =
475 128 * (100 * win->success_counter) / win->counter;
476 else
477 win->success_ratio = IL_INVALID_VALUE;
478
479 fail_count = win->counter - win->success_counter;
480
481 /* Calculate average throughput, if we have enough history. */
482 if (fail_count >= RATE_MIN_FAILURE_TH ||
483 win->success_counter >= RATE_MIN_SUCCESS_TH)
484 win->average_tpt = (win->success_ratio * tpt + 64) / 128;
485 else
486 win->average_tpt = IL_INVALID_VALUE;
487
488 /* Tag this win as having been updated */
489 win->stamp = jiffies;
490
491 return 0;
492 }
493
494 /*
495 * Fill uCode API rate_n_flags field, based on "search" or "active" table.
496 */
497 static u32
498 il4965_rate_n_flags_from_tbl(struct il_priv *il, struct il_scale_tbl_info *tbl,
499 int idx, u8 use_green)
500 {
501 u32 rate_n_flags = 0;
502
503 if (is_legacy(tbl->lq_type)) {
504 rate_n_flags = il_rates[idx].plcp;
505 if (idx >= IL_FIRST_CCK_RATE && idx <= IL_LAST_CCK_RATE)
506 rate_n_flags |= RATE_MCS_CCK_MSK;
507
508 } else if (is_Ht(tbl->lq_type)) {
509 if (idx > IL_LAST_OFDM_RATE) {
510 IL_ERR("Invalid HT rate idx %d\n", idx);
511 idx = IL_LAST_OFDM_RATE;
512 }
513 rate_n_flags = RATE_MCS_HT_MSK;
514
515 if (is_siso(tbl->lq_type))
516 rate_n_flags |= il_rates[idx].plcp_siso;
517 else
518 rate_n_flags |= il_rates[idx].plcp_mimo2;
519 } else {
520 IL_ERR("Invalid tbl->lq_type %d\n", tbl->lq_type);
521 }
522
523 rate_n_flags |=
524 ((tbl->ant_type << RATE_MCS_ANT_POS) & RATE_MCS_ANT_ABC_MSK);
525
526 if (is_Ht(tbl->lq_type)) {
527 if (tbl->is_ht40) {
528 if (tbl->is_dup)
529 rate_n_flags |= RATE_MCS_DUP_MSK;
530 else
531 rate_n_flags |= RATE_MCS_HT40_MSK;
532 }
533 if (tbl->is_SGI)
534 rate_n_flags |= RATE_MCS_SGI_MSK;
535
536 if (use_green) {
537 rate_n_flags |= RATE_MCS_GF_MSK;
538 if (is_siso(tbl->lq_type) && tbl->is_SGI) {
539 rate_n_flags &= ~RATE_MCS_SGI_MSK;
540 IL_ERR("GF was set with SGI:SISO\n");
541 }
542 }
543 }
544 return rate_n_flags;
545 }
546
547 /*
548 * Interpret uCode API's rate_n_flags format,
549 * fill "search" or "active" tx mode table.
550 */
551 static int
552 il4965_rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
553 enum ieee80211_band band,
554 struct il_scale_tbl_info *tbl, int *rate_idx)
555 {
556 u32 ant_msk = (rate_n_flags & RATE_MCS_ANT_ABC_MSK);
557 u8 il4965_num_of_ant =
558 il4965_get_il4965_num_of_ant_from_rate(rate_n_flags);
559 u8 mcs;
560
561 memset(tbl, 0, sizeof(struct il_scale_tbl_info));
562 *rate_idx = il4965_hwrate_to_plcp_idx(rate_n_flags);
563
564 if (*rate_idx == RATE_INVALID) {
565 *rate_idx = -1;
566 return -EINVAL;
567 }
568 tbl->is_SGI = 0; /* default legacy setup */
569 tbl->is_ht40 = 0;
570 tbl->is_dup = 0;
571 tbl->ant_type = (ant_msk >> RATE_MCS_ANT_POS);
572 tbl->lq_type = LQ_NONE;
573 tbl->max_search = IL_MAX_SEARCH;
574
575 /* legacy rate format */
576 if (!(rate_n_flags & RATE_MCS_HT_MSK)) {
577 if (il4965_num_of_ant == 1) {
578 if (band == IEEE80211_BAND_5GHZ)
579 tbl->lq_type = LQ_A;
580 else
581 tbl->lq_type = LQ_G;
582 }
583 /* HT rate format */
584 } else {
585 if (rate_n_flags & RATE_MCS_SGI_MSK)
586 tbl->is_SGI = 1;
587
588 if ((rate_n_flags & RATE_MCS_HT40_MSK) ||
589 (rate_n_flags & RATE_MCS_DUP_MSK))
590 tbl->is_ht40 = 1;
591
592 if (rate_n_flags & RATE_MCS_DUP_MSK)
593 tbl->is_dup = 1;
594
595 mcs = il4965_rs_extract_rate(rate_n_flags);
596
597 /* SISO */
598 if (mcs <= RATE_SISO_60M_PLCP) {
599 if (il4965_num_of_ant == 1)
600 tbl->lq_type = LQ_SISO; /*else NONE */
601 /* MIMO2 */
602 } else {
603 if (il4965_num_of_ant == 2)
604 tbl->lq_type = LQ_MIMO2;
605 }
606 }
607 return 0;
608 }
609
610 /* switch to another antenna/antennas and return 1 */
611 /* if no other valid antenna found, return 0 */
612 static int
613 il4965_rs_toggle_antenna(u32 valid_ant, u32 *rate_n_flags,
614 struct il_scale_tbl_info *tbl)
615 {
616 u8 new_ant_type;
617
618 if (!tbl->ant_type || tbl->ant_type > ANT_ABC)
619 return 0;
620
621 if (!il4965_rs_is_valid_ant(valid_ant, tbl->ant_type))
622 return 0;
623
624 new_ant_type = ant_toggle_lookup[tbl->ant_type];
625
626 while (new_ant_type != tbl->ant_type &&
627 !il4965_rs_is_valid_ant(valid_ant, new_ant_type))
628 new_ant_type = ant_toggle_lookup[new_ant_type];
629
630 if (new_ant_type == tbl->ant_type)
631 return 0;
632
633 tbl->ant_type = new_ant_type;
634 *rate_n_flags &= ~RATE_MCS_ANT_ABC_MSK;
635 *rate_n_flags |= new_ant_type << RATE_MCS_ANT_POS;
636 return 1;
637 }
638
639 /**
640 * Green-field mode is valid if the station supports it and
641 * there are no non-GF stations present in the BSS.
642 */
643 static bool
644 il4965_rs_use_green(struct il_priv *il, struct ieee80211_sta *sta)
645 {
646 return (sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD) &&
647 !il->ht.non_gf_sta_present;
648 }
649
650 /**
651 * il4965_rs_get_supported_rates - get the available rates
652 *
653 * if management frame or broadcast frame only return
654 * basic available rates.
655 *
656 */
657 static u16
658 il4965_rs_get_supported_rates(struct il_lq_sta *lq_sta,
659 struct ieee80211_hdr *hdr,
660 enum il_table_type rate_type)
661 {
662 if (is_legacy(rate_type)) {
663 return lq_sta->active_legacy_rate;
664 } else {
665 if (is_siso(rate_type))
666 return lq_sta->active_siso_rate;
667 else
668 return lq_sta->active_mimo2_rate;
669 }
670 }
671
672 static u16
673 il4965_rs_get_adjacent_rate(struct il_priv *il, u8 idx, u16 rate_mask,
674 int rate_type)
675 {
676 u8 high = RATE_INVALID;
677 u8 low = RATE_INVALID;
678
679 /* 802.11A or ht walks to the next literal adjacent rate in
680 * the rate table */
681 if (is_a_band(rate_type) || !is_legacy(rate_type)) {
682 int i;
683 u32 mask;
684
685 /* Find the previous rate that is in the rate mask */
686 i = idx - 1;
687 for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
688 if (rate_mask & mask) {
689 low = i;
690 break;
691 }
692 }
693
694 /* Find the next rate that is in the rate mask */
695 i = idx + 1;
696 for (mask = (1 << i); i < RATE_COUNT; i++, mask <<= 1) {
697 if (rate_mask & mask) {
698 high = i;
699 break;
700 }
701 }
702
703 return (high << 8) | low;
704 }
705
706 low = idx;
707 while (low != RATE_INVALID) {
708 low = il_rates[low].prev_rs;
709 if (low == RATE_INVALID)
710 break;
711 if (rate_mask & (1 << low))
712 break;
713 D_RATE("Skipping masked lower rate: %d\n", low);
714 }
715
716 high = idx;
717 while (high != RATE_INVALID) {
718 high = il_rates[high].next_rs;
719 if (high == RATE_INVALID)
720 break;
721 if (rate_mask & (1 << high))
722 break;
723 D_RATE("Skipping masked higher rate: %d\n", high);
724 }
725
726 return (high << 8) | low;
727 }
728
729 static u32
730 il4965_rs_get_lower_rate(struct il_lq_sta *lq_sta,
731 struct il_scale_tbl_info *tbl, u8 scale_idx,
732 u8 ht_possible)
733 {
734 s32 low;
735 u16 rate_mask;
736 u16 high_low;
737 u8 switch_to_legacy = 0;
738 u8 is_green = lq_sta->is_green;
739 struct il_priv *il = lq_sta->drv;
740
741 /* check if we need to switch from HT to legacy rates.
742 * assumption is that mandatory rates (1Mbps or 6Mbps)
743 * are always supported (spec demand) */
744 if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_idx)) {
745 switch_to_legacy = 1;
746 scale_idx = rs_ht_to_legacy[scale_idx];
747 if (lq_sta->band == IEEE80211_BAND_5GHZ)
748 tbl->lq_type = LQ_A;
749 else
750 tbl->lq_type = LQ_G;
751
752 if (il4965_num_of_ant(tbl->ant_type) > 1)
753 tbl->ant_type =
754 il4965_first_antenna(il->hw_params.valid_tx_ant);
755
756 tbl->is_ht40 = 0;
757 tbl->is_SGI = 0;
758 tbl->max_search = IL_MAX_SEARCH;
759 }
760
761 rate_mask = il4965_rs_get_supported_rates(lq_sta, NULL, tbl->lq_type);
762
763 /* Mask with station rate restriction */
764 if (is_legacy(tbl->lq_type)) {
765 /* supp_rates has no CCK bits in A mode */
766 if (lq_sta->band == IEEE80211_BAND_5GHZ)
767 rate_mask =
768 (u16) (rate_mask &
769 (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
770 else
771 rate_mask = (u16) (rate_mask & lq_sta->supp_rates);
772 }
773
774 /* If we switched from HT to legacy, check current rate */
775 if (switch_to_legacy && (rate_mask & (1 << scale_idx))) {
776 low = scale_idx;
777 goto out;
778 }
779
780 high_low =
781 il4965_rs_get_adjacent_rate(lq_sta->drv, scale_idx, rate_mask,
782 tbl->lq_type);
783 low = high_low & 0xff;
784
785 if (low == RATE_INVALID)
786 low = scale_idx;
787
788 out:
789 return il4965_rate_n_flags_from_tbl(lq_sta->drv, tbl, low, is_green);
790 }
791
792 /*
793 * Simple function to compare two rate scale table types
794 */
795 static bool
796 il4965_table_type_matches(struct il_scale_tbl_info *a,
797 struct il_scale_tbl_info *b)
798 {
799 return (a->lq_type == b->lq_type && a->ant_type == b->ant_type &&
800 a->is_SGI == b->is_SGI);
801 }
802
803 /*
804 * mac80211 sends us Tx status
805 */
806 static void
807 il4965_rs_tx_status(void *il_r, struct ieee80211_supported_band *sband,
808 struct ieee80211_sta *sta, void *il_sta,
809 struct sk_buff *skb)
810 {
811 int legacy_success;
812 int retries;
813 int rs_idx, mac_idx, i;
814 struct il_lq_sta *lq_sta = il_sta;
815 struct il_link_quality_cmd *table;
816 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
817 struct il_priv *il = (struct il_priv *)il_r;
818 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
819 enum mac80211_rate_control_flags mac_flags;
820 u32 tx_rate;
821 struct il_scale_tbl_info tbl_type;
822 struct il_scale_tbl_info *curr_tbl, *other_tbl, *tmp_tbl;
823 struct il_station_priv *sta_priv = (void *)sta->drv_priv;
824 struct il_rxon_context *ctx = sta_priv->common.ctx;
825
826 D_RATE("get frame ack response, update rate scale win\n");
827
828 /* Treat uninitialized rate scaling data same as non-existing. */
829 if (!lq_sta) {
830 D_RATE("Station rate scaling not created yet.\n");
831 return;
832 } else if (!lq_sta->drv) {
833 D_RATE("Rate scaling not initialized yet.\n");
834 return;
835 }
836
837 if (!ieee80211_is_data(hdr->frame_control) ||
838 (info->flags & IEEE80211_TX_CTL_NO_ACK))
839 return;
840
841 /* This packet was aggregated but doesn't carry status info */
842 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
843 !(info->flags & IEEE80211_TX_STAT_AMPDU))
844 return;
845
846 /*
847 * Ignore this Tx frame response if its initial rate doesn't match
848 * that of latest Link Quality command. There may be stragglers
849 * from a previous Link Quality command, but we're no longer interested
850 * in those; they're either from the "active" mode while we're trying
851 * to check "search" mode, or a prior "search" mode after we've moved
852 * to a new "search" mode (which might become the new "active" mode).
853 */
854 table = &lq_sta->lq;
855 tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
856 il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type, &rs_idx);
857 if (il->band == IEEE80211_BAND_5GHZ)
858 rs_idx -= IL_FIRST_OFDM_RATE;
859 mac_flags = info->status.rates[0].flags;
860 mac_idx = info->status.rates[0].idx;
861 /* For HT packets, map MCS to PLCP */
862 if (mac_flags & IEEE80211_TX_RC_MCS) {
863 mac_idx &= RATE_MCS_CODE_MSK; /* Remove # of streams */
864 if (mac_idx >= (RATE_9M_IDX - IL_FIRST_OFDM_RATE))
865 mac_idx++;
866 /*
867 * mac80211 HT idx is always zero-idxed; we need to move
868 * HT OFDM rates after CCK rates in 2.4 GHz band
869 */
870 if (il->band == IEEE80211_BAND_2GHZ)
871 mac_idx += IL_FIRST_OFDM_RATE;
872 }
873 /* Here we actually compare this rate to the latest LQ command */
874 if (mac_idx < 0 ||
875 tbl_type.is_SGI != !!(mac_flags & IEEE80211_TX_RC_SHORT_GI) ||
876 tbl_type.is_ht40 != !!(mac_flags & IEEE80211_TX_RC_40_MHZ_WIDTH) ||
877 tbl_type.is_dup != !!(mac_flags & IEEE80211_TX_RC_DUP_DATA) ||
878 tbl_type.ant_type != info->antenna_sel_tx ||
879 !!(tx_rate & RATE_MCS_HT_MSK) != !!(mac_flags & IEEE80211_TX_RC_MCS)
880 || !!(tx_rate & RATE_MCS_GF_MSK) !=
881 !!(mac_flags & IEEE80211_TX_RC_GREEN_FIELD) || rs_idx != mac_idx) {
882 D_RATE("initial rate %d does not match %d (0x%x)\n", mac_idx,
883 rs_idx, tx_rate);
884 /*
885 * Since rates mis-match, the last LQ command may have failed.
886 * After IL_MISSED_RATE_MAX mis-matches, resync the uCode with
887 * ... driver.
888 */
889 lq_sta->missed_rate_counter++;
890 if (lq_sta->missed_rate_counter > IL_MISSED_RATE_MAX) {
891 lq_sta->missed_rate_counter = 0;
892 il_send_lq_cmd(il, ctx, &lq_sta->lq, CMD_ASYNC, false);
893 }
894 /* Regardless, ignore this status info for outdated rate */
895 return;
896 } else
897 /* Rate did match, so reset the missed_rate_counter */
898 lq_sta->missed_rate_counter = 0;
899
900 /* Figure out if rate scale algorithm is in active or search table */
901 if (il4965_table_type_matches
902 (&tbl_type, &(lq_sta->lq_info[lq_sta->active_tbl]))) {
903 curr_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
904 other_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
905 } else
906 if (il4965_table_type_matches
907 (&tbl_type, &lq_sta->lq_info[1 - lq_sta->active_tbl])) {
908 curr_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
909 other_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
910 } else {
911 D_RATE("Neither active nor search matches tx rate\n");
912 tmp_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
913 D_RATE("active- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
914 tmp_tbl->ant_type, tmp_tbl->is_SGI);
915 tmp_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
916 D_RATE("search- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
917 tmp_tbl->ant_type, tmp_tbl->is_SGI);
918 D_RATE("actual- lq:%x, ant:%x, SGI:%d\n", tbl_type.lq_type,
919 tbl_type.ant_type, tbl_type.is_SGI);
920 /*
921 * no matching table found, let's by-pass the data collection
922 * and continue to perform rate scale to find the rate table
923 */
924 il4965_rs_stay_in_table(lq_sta, true);
925 goto done;
926 }
927
928 /*
929 * Updating the frame history depends on whether packets were
930 * aggregated.
931 *
932 * For aggregation, all packets were transmitted at the same rate, the
933 * first idx into rate scale table.
934 */
935 if (info->flags & IEEE80211_TX_STAT_AMPDU) {
936 tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
937 il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type,
938 &rs_idx);
939 il4965_rs_collect_tx_data(curr_tbl, rs_idx,
940 info->status.ampdu_len,
941 info->status.ampdu_ack_len);
942
943 /* Update success/fail counts if not searching for new mode */
944 if (lq_sta->stay_in_tbl) {
945 lq_sta->total_success += info->status.ampdu_ack_len;
946 lq_sta->total_failed +=
947 (info->status.ampdu_len -
948 info->status.ampdu_ack_len);
949 }
950 } else {
951 /*
952 * For legacy, update frame history with for each Tx retry.
953 */
954 retries = info->status.rates[0].count - 1;
955 /* HW doesn't send more than 15 retries */
956 retries = min(retries, 15);
957
958 /* The last transmission may have been successful */
959 legacy_success = !!(info->flags & IEEE80211_TX_STAT_ACK);
960 /* Collect data for each rate used during failed TX attempts */
961 for (i = 0; i <= retries; ++i) {
962 tx_rate = le32_to_cpu(table->rs_table[i].rate_n_flags);
963 il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band,
964 &tbl_type, &rs_idx);
965 /*
966 * Only collect stats if retried rate is in the same RS
967 * table as active/search.
968 */
969 if (il4965_table_type_matches(&tbl_type, curr_tbl))
970 tmp_tbl = curr_tbl;
971 else if (il4965_table_type_matches
972 (&tbl_type, other_tbl))
973 tmp_tbl = other_tbl;
974 else
975 continue;
976 il4965_rs_collect_tx_data(tmp_tbl, rs_idx, 1,
977 i <
978 retries ? 0 : legacy_success);
979 }
980
981 /* Update success/fail counts if not searching for new mode */
982 if (lq_sta->stay_in_tbl) {
983 lq_sta->total_success += legacy_success;
984 lq_sta->total_failed += retries + (1 - legacy_success);
985 }
986 }
987 /* The last TX rate is cached in lq_sta; it's set in if/else above */
988 lq_sta->last_rate_n_flags = tx_rate;
989 done:
990 /* See if there's a better rate or modulation mode to try. */
991 if (sta->supp_rates[sband->band])
992 il4965_rs_rate_scale_perform(il, skb, sta, lq_sta);
993 }
994
995 /*
996 * Begin a period of staying with a selected modulation mode.
997 * Set "stay_in_tbl" flag to prevent any mode switches.
998 * Set frame tx success limits according to legacy vs. high-throughput,
999 * and reset overall (spanning all rates) tx success history stats.
1000 * These control how long we stay using same modulation mode before
1001 * searching for a new mode.
1002 */
1003 static void
1004 il4965_rs_set_stay_in_table(struct il_priv *il, u8 is_legacy,
1005 struct il_lq_sta *lq_sta)
1006 {
1007 D_RATE("we are staying in the same table\n");
1008 lq_sta->stay_in_tbl = 1; /* only place this gets set */
1009 if (is_legacy) {
1010 lq_sta->table_count_limit = IL_LEGACY_TBL_COUNT;
1011 lq_sta->max_failure_limit = IL_LEGACY_FAILURE_LIMIT;
1012 lq_sta->max_success_limit = IL_LEGACY_SUCCESS_LIMIT;
1013 } else {
1014 lq_sta->table_count_limit = IL_NONE_LEGACY_TBL_COUNT;
1015 lq_sta->max_failure_limit = IL_NONE_LEGACY_FAILURE_LIMIT;
1016 lq_sta->max_success_limit = IL_NONE_LEGACY_SUCCESS_LIMIT;
1017 }
1018 lq_sta->table_count = 0;
1019 lq_sta->total_failed = 0;
1020 lq_sta->total_success = 0;
1021 lq_sta->flush_timer = jiffies;
1022 lq_sta->action_counter = 0;
1023 }
1024
1025 /*
1026 * Find correct throughput table for given mode of modulation
1027 */
1028 static void
1029 il4965_rs_set_expected_tpt_table(struct il_lq_sta *lq_sta,
1030 struct il_scale_tbl_info *tbl)
1031 {
1032 /* Used to choose among HT tables */
1033 s32(*ht_tbl_pointer)[RATE_COUNT];
1034
1035 /* Check for invalid LQ type */
1036 if (WARN_ON_ONCE(!is_legacy(tbl->lq_type) && !is_Ht(tbl->lq_type))) {
1037 tbl->expected_tpt = expected_tpt_legacy;
1038 return;
1039 }
1040
1041 /* Legacy rates have only one table */
1042 if (is_legacy(tbl->lq_type)) {
1043 tbl->expected_tpt = expected_tpt_legacy;
1044 return;
1045 }
1046
1047 /* Choose among many HT tables depending on number of streams
1048 * (SISO/MIMO2), channel width (20/40), SGI, and aggregation
1049 * status */
1050 if (is_siso(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
1051 ht_tbl_pointer = expected_tpt_siso20MHz;
1052 else if (is_siso(tbl->lq_type))
1053 ht_tbl_pointer = expected_tpt_siso40MHz;
1054 else if (is_mimo2(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
1055 ht_tbl_pointer = expected_tpt_mimo2_20MHz;
1056 else /* if (is_mimo2(tbl->lq_type)) <-- must be true */
1057 ht_tbl_pointer = expected_tpt_mimo2_40MHz;
1058
1059 if (!tbl->is_SGI && !lq_sta->is_agg) /* Normal */
1060 tbl->expected_tpt = ht_tbl_pointer[0];
1061 else if (tbl->is_SGI && !lq_sta->is_agg) /* SGI */
1062 tbl->expected_tpt = ht_tbl_pointer[1];
1063 else if (!tbl->is_SGI && lq_sta->is_agg) /* AGG */
1064 tbl->expected_tpt = ht_tbl_pointer[2];
1065 else /* AGG+SGI */
1066 tbl->expected_tpt = ht_tbl_pointer[3];
1067 }
1068
1069 /*
1070 * Find starting rate for new "search" high-throughput mode of modulation.
1071 * Goal is to find lowest expected rate (under perfect conditions) that is
1072 * above the current measured throughput of "active" mode, to give new mode
1073 * a fair chance to prove itself without too many challenges.
1074 *
1075 * This gets called when transitioning to more aggressive modulation
1076 * (i.e. legacy to SISO or MIMO, or SISO to MIMO), as well as less aggressive
1077 * (i.e. MIMO to SISO). When moving to MIMO, bit rate will typically need
1078 * to decrease to match "active" throughput. When moving from MIMO to SISO,
1079 * bit rate will typically need to increase, but not if performance was bad.
1080 */
1081 static s32
1082 il4965_rs_get_best_rate(struct il_priv *il, struct il_lq_sta *lq_sta,
1083 struct il_scale_tbl_info *tbl, /* "search" */
1084 u16 rate_mask, s8 idx)
1085 {
1086 /* "active" values */
1087 struct il_scale_tbl_info *active_tbl =
1088 &(lq_sta->lq_info[lq_sta->active_tbl]);
1089 s32 active_sr = active_tbl->win[idx].success_ratio;
1090 s32 active_tpt = active_tbl->expected_tpt[idx];
1091
1092 /* expected "search" throughput */
1093 s32 *tpt_tbl = tbl->expected_tpt;
1094
1095 s32 new_rate, high, low, start_hi;
1096 u16 high_low;
1097 s8 rate = idx;
1098
1099 new_rate = high = low = start_hi = RATE_INVALID;
1100
1101 for (;;) {
1102 high_low =
1103 il4965_rs_get_adjacent_rate(il, rate, rate_mask,
1104 tbl->lq_type);
1105
1106 low = high_low & 0xff;
1107 high = (high_low >> 8) & 0xff;
1108
1109 /*
1110 * Lower the "search" bit rate, to give new "search" mode
1111 * approximately the same throughput as "active" if:
1112 *
1113 * 1) "Active" mode has been working modestly well (but not
1114 * great), and expected "search" throughput (under perfect
1115 * conditions) at candidate rate is above the actual
1116 * measured "active" throughput (but less than expected
1117 * "active" throughput under perfect conditions).
1118 * OR
1119 * 2) "Active" mode has been working perfectly or very well
1120 * and expected "search" throughput (under perfect
1121 * conditions) at candidate rate is above expected
1122 * "active" throughput (under perfect conditions).
1123 */
1124 if ((100 * tpt_tbl[rate] > lq_sta->last_tpt &&
1125 (active_sr > RATE_DECREASE_TH && active_sr <= RATE_HIGH_TH
1126 && tpt_tbl[rate] <= active_tpt)) ||
1127 (active_sr >= RATE_SCALE_SWITCH &&
1128 tpt_tbl[rate] > active_tpt)) {
1129
1130 /* (2nd or later pass)
1131 * If we've already tried to raise the rate, and are
1132 * now trying to lower it, use the higher rate. */
1133 if (start_hi != RATE_INVALID) {
1134 new_rate = start_hi;
1135 break;
1136 }
1137
1138 new_rate = rate;
1139
1140 /* Loop again with lower rate */
1141 if (low != RATE_INVALID)
1142 rate = low;
1143
1144 /* Lower rate not available, use the original */
1145 else
1146 break;
1147
1148 /* Else try to raise the "search" rate to match "active" */
1149 } else {
1150 /* (2nd or later pass)
1151 * If we've already tried to lower the rate, and are
1152 * now trying to raise it, use the lower rate. */
1153 if (new_rate != RATE_INVALID)
1154 break;
1155
1156 /* Loop again with higher rate */
1157 else if (high != RATE_INVALID) {
1158 start_hi = high;
1159 rate = high;
1160
1161 /* Higher rate not available, use the original */
1162 } else {
1163 new_rate = rate;
1164 break;
1165 }
1166 }
1167 }
1168
1169 return new_rate;
1170 }
1171
1172 /*
1173 * Set up search table for MIMO2
1174 */
1175 static int
1176 il4965_rs_switch_to_mimo2(struct il_priv *il, struct il_lq_sta *lq_sta,
1177 struct ieee80211_conf *conf,
1178 struct ieee80211_sta *sta,
1179 struct il_scale_tbl_info *tbl, int idx)
1180 {
1181 u16 rate_mask;
1182 s32 rate;
1183 s8 is_green = lq_sta->is_green;
1184 struct il_station_priv *sta_priv = (void *)sta->drv_priv;
1185 struct il_rxon_context *ctx = sta_priv->common.ctx;
1186
1187 if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
1188 return -1;
1189
1190 if (((sta->ht_cap.cap & IEEE80211_HT_CAP_SM_PS) >> 2) ==
1191 WLAN_HT_CAP_SM_PS_STATIC)
1192 return -1;
1193
1194 /* Need both Tx chains/antennas to support MIMO */
1195 if (il->hw_params.tx_chains_num < 2)
1196 return -1;
1197
1198 D_RATE("LQ: try to switch to MIMO2\n");
1199
1200 tbl->lq_type = LQ_MIMO2;
1201 tbl->is_dup = lq_sta->is_dup;
1202 tbl->action = 0;
1203 tbl->max_search = IL_MAX_SEARCH;
1204 rate_mask = lq_sta->active_mimo2_rate;
1205
1206 if (il_is_ht40_tx_allowed(il, ctx, &sta->ht_cap))
1207 tbl->is_ht40 = 1;
1208 else
1209 tbl->is_ht40 = 0;
1210
1211 il4965_rs_set_expected_tpt_table(lq_sta, tbl);
1212
1213 rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
1214
1215 D_RATE("LQ: MIMO2 best rate %d mask %X\n", rate, rate_mask);
1216 if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
1217 D_RATE("Can't switch with idx %d rate mask %x\n", rate,
1218 rate_mask);
1219 return -1;
1220 }
1221 tbl->current_rate =
1222 il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
1223
1224 D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
1225 is_green);
1226 return 0;
1227 }
1228
1229 /*
1230 * Set up search table for SISO
1231 */
1232 static int
1233 il4965_rs_switch_to_siso(struct il_priv *il, struct il_lq_sta *lq_sta,
1234 struct ieee80211_conf *conf, struct ieee80211_sta *sta,
1235 struct il_scale_tbl_info *tbl, int idx)
1236 {
1237 u16 rate_mask;
1238 u8 is_green = lq_sta->is_green;
1239 s32 rate;
1240 struct il_station_priv *sta_priv = (void *)sta->drv_priv;
1241 struct il_rxon_context *ctx = sta_priv->common.ctx;
1242
1243 if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
1244 return -1;
1245
1246 D_RATE("LQ: try to switch to SISO\n");
1247
1248 tbl->is_dup = lq_sta->is_dup;
1249 tbl->lq_type = LQ_SISO;
1250 tbl->action = 0;
1251 tbl->max_search = IL_MAX_SEARCH;
1252 rate_mask = lq_sta->active_siso_rate;
1253
1254 if (il_is_ht40_tx_allowed(il, ctx, &sta->ht_cap))
1255 tbl->is_ht40 = 1;
1256 else
1257 tbl->is_ht40 = 0;
1258
1259 if (is_green)
1260 tbl->is_SGI = 0; /*11n spec: no SGI in SISO+Greenfield */
1261
1262 il4965_rs_set_expected_tpt_table(lq_sta, tbl);
1263 rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
1264
1265 D_RATE("LQ: get best rate %d mask %X\n", rate, rate_mask);
1266 if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
1267 D_RATE("can not switch with idx %d rate mask %x\n", rate,
1268 rate_mask);
1269 return -1;
1270 }
1271 tbl->current_rate =
1272 il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
1273 D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
1274 is_green);
1275 return 0;
1276 }
1277
1278 /*
1279 * Try to switch to new modulation mode from legacy
1280 */
1281 static int
1282 il4965_rs_move_legacy_other(struct il_priv *il, struct il_lq_sta *lq_sta,
1283 struct ieee80211_conf *conf,
1284 struct ieee80211_sta *sta, int idx)
1285 {
1286 struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1287 struct il_scale_tbl_info *search_tbl =
1288 &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1289 struct il_rate_scale_data *win = &(tbl->win[idx]);
1290 u32 sz =
1291 (sizeof(struct il_scale_tbl_info) -
1292 (sizeof(struct il_rate_scale_data) * RATE_COUNT));
1293 u8 start_action;
1294 u8 valid_tx_ant = il->hw_params.valid_tx_ant;
1295 u8 tx_chains_num = il->hw_params.tx_chains_num;
1296 int ret = 0;
1297 u8 update_search_tbl_counter = 0;
1298
1299 tbl->action = IL_LEGACY_SWITCH_SISO;
1300
1301 start_action = tbl->action;
1302 for (;;) {
1303 lq_sta->action_counter++;
1304 switch (tbl->action) {
1305 case IL_LEGACY_SWITCH_ANTENNA1:
1306 case IL_LEGACY_SWITCH_ANTENNA2:
1307 D_RATE("LQ: Legacy toggle Antenna\n");
1308
1309 if ((tbl->action == IL_LEGACY_SWITCH_ANTENNA1 &&
1310 tx_chains_num <= 1) ||
1311 (tbl->action == IL_LEGACY_SWITCH_ANTENNA2 &&
1312 tx_chains_num <= 2))
1313 break;
1314
1315 /* Don't change antenna if success has been great */
1316 if (win->success_ratio >= IL_RS_GOOD_RATIO)
1317 break;
1318
1319 /* Set up search table to try other antenna */
1320 memcpy(search_tbl, tbl, sz);
1321
1322 if (il4965_rs_toggle_antenna
1323 (valid_tx_ant, &search_tbl->current_rate,
1324 search_tbl)) {
1325 update_search_tbl_counter = 1;
1326 il4965_rs_set_expected_tpt_table(lq_sta,
1327 search_tbl);
1328 goto out;
1329 }
1330 break;
1331 case IL_LEGACY_SWITCH_SISO:
1332 D_RATE("LQ: Legacy switch to SISO\n");
1333
1334 /* Set up search table to try SISO */
1335 memcpy(search_tbl, tbl, sz);
1336 search_tbl->is_SGI = 0;
1337 ret =
1338 il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
1339 search_tbl, idx);
1340 if (!ret) {
1341 lq_sta->action_counter = 0;
1342 goto out;
1343 }
1344
1345 break;
1346 case IL_LEGACY_SWITCH_MIMO2_AB:
1347 case IL_LEGACY_SWITCH_MIMO2_AC:
1348 case IL_LEGACY_SWITCH_MIMO2_BC:
1349 D_RATE("LQ: Legacy switch to MIMO2\n");
1350
1351 /* Set up search table to try MIMO */
1352 memcpy(search_tbl, tbl, sz);
1353 search_tbl->is_SGI = 0;
1354
1355 if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AB)
1356 search_tbl->ant_type = ANT_AB;
1357 else if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AC)
1358 search_tbl->ant_type = ANT_AC;
1359 else
1360 search_tbl->ant_type = ANT_BC;
1361
1362 if (!il4965_rs_is_valid_ant
1363 (valid_tx_ant, search_tbl->ant_type))
1364 break;
1365
1366 ret =
1367 il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
1368 search_tbl, idx);
1369 if (!ret) {
1370 lq_sta->action_counter = 0;
1371 goto out;
1372 }
1373 break;
1374 }
1375 tbl->action++;
1376 if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
1377 tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
1378
1379 if (tbl->action == start_action)
1380 break;
1381
1382 }
1383 search_tbl->lq_type = LQ_NONE;
1384 return 0;
1385
1386 out:
1387 lq_sta->search_better_tbl = 1;
1388 tbl->action++;
1389 if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
1390 tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
1391 if (update_search_tbl_counter)
1392 search_tbl->action = tbl->action;
1393 return 0;
1394
1395 }
1396
1397 /*
1398 * Try to switch to new modulation mode from SISO
1399 */
1400 static int
1401 il4965_rs_move_siso_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
1402 struct ieee80211_conf *conf,
1403 struct ieee80211_sta *sta, int idx)
1404 {
1405 u8 is_green = lq_sta->is_green;
1406 struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1407 struct il_scale_tbl_info *search_tbl =
1408 &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1409 struct il_rate_scale_data *win = &(tbl->win[idx]);
1410 struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1411 u32 sz =
1412 (sizeof(struct il_scale_tbl_info) -
1413 (sizeof(struct il_rate_scale_data) * RATE_COUNT));
1414 u8 start_action;
1415 u8 valid_tx_ant = il->hw_params.valid_tx_ant;
1416 u8 tx_chains_num = il->hw_params.tx_chains_num;
1417 u8 update_search_tbl_counter = 0;
1418 int ret;
1419
1420 start_action = tbl->action;
1421
1422 for (;;) {
1423 lq_sta->action_counter++;
1424 switch (tbl->action) {
1425 case IL_SISO_SWITCH_ANTENNA1:
1426 case IL_SISO_SWITCH_ANTENNA2:
1427 D_RATE("LQ: SISO toggle Antenna\n");
1428 if ((tbl->action == IL_SISO_SWITCH_ANTENNA1 &&
1429 tx_chains_num <= 1) ||
1430 (tbl->action == IL_SISO_SWITCH_ANTENNA2 &&
1431 tx_chains_num <= 2))
1432 break;
1433
1434 if (win->success_ratio >= IL_RS_GOOD_RATIO)
1435 break;
1436
1437 memcpy(search_tbl, tbl, sz);
1438 if (il4965_rs_toggle_antenna
1439 (valid_tx_ant, &search_tbl->current_rate,
1440 search_tbl)) {
1441 update_search_tbl_counter = 1;
1442 goto out;
1443 }
1444 break;
1445 case IL_SISO_SWITCH_MIMO2_AB:
1446 case IL_SISO_SWITCH_MIMO2_AC:
1447 case IL_SISO_SWITCH_MIMO2_BC:
1448 D_RATE("LQ: SISO switch to MIMO2\n");
1449 memcpy(search_tbl, tbl, sz);
1450 search_tbl->is_SGI = 0;
1451
1452 if (tbl->action == IL_SISO_SWITCH_MIMO2_AB)
1453 search_tbl->ant_type = ANT_AB;
1454 else if (tbl->action == IL_SISO_SWITCH_MIMO2_AC)
1455 search_tbl->ant_type = ANT_AC;
1456 else
1457 search_tbl->ant_type = ANT_BC;
1458
1459 if (!il4965_rs_is_valid_ant
1460 (valid_tx_ant, search_tbl->ant_type))
1461 break;
1462
1463 ret =
1464 il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
1465 search_tbl, idx);
1466 if (!ret)
1467 goto out;
1468 break;
1469 case IL_SISO_SWITCH_GI:
1470 if (!tbl->is_ht40 &&
1471 !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
1472 break;
1473 if (tbl->is_ht40 &&
1474 !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
1475 break;
1476
1477 D_RATE("LQ: SISO toggle SGI/NGI\n");
1478
1479 memcpy(search_tbl, tbl, sz);
1480 if (is_green) {
1481 if (!tbl->is_SGI)
1482 break;
1483 else
1484 IL_ERR("SGI was set in GF+SISO\n");
1485 }
1486 search_tbl->is_SGI = !tbl->is_SGI;
1487 il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
1488 if (tbl->is_SGI) {
1489 s32 tpt = lq_sta->last_tpt / 100;
1490 if (tpt >= search_tbl->expected_tpt[idx])
1491 break;
1492 }
1493 search_tbl->current_rate =
1494 il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
1495 is_green);
1496 update_search_tbl_counter = 1;
1497 goto out;
1498 }
1499 tbl->action++;
1500 if (tbl->action > IL_SISO_SWITCH_GI)
1501 tbl->action = IL_SISO_SWITCH_ANTENNA1;
1502
1503 if (tbl->action == start_action)
1504 break;
1505 }
1506 search_tbl->lq_type = LQ_NONE;
1507 return 0;
1508
1509 out:
1510 lq_sta->search_better_tbl = 1;
1511 tbl->action++;
1512 if (tbl->action > IL_SISO_SWITCH_GI)
1513 tbl->action = IL_SISO_SWITCH_ANTENNA1;
1514 if (update_search_tbl_counter)
1515 search_tbl->action = tbl->action;
1516
1517 return 0;
1518 }
1519
1520 /*
1521 * Try to switch to new modulation mode from MIMO2
1522 */
1523 static int
1524 il4965_rs_move_mimo2_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
1525 struct ieee80211_conf *conf,
1526 struct ieee80211_sta *sta, int idx)
1527 {
1528 s8 is_green = lq_sta->is_green;
1529 struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1530 struct il_scale_tbl_info *search_tbl =
1531 &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1532 struct il_rate_scale_data *win = &(tbl->win[idx]);
1533 struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1534 u32 sz =
1535 (sizeof(struct il_scale_tbl_info) -
1536 (sizeof(struct il_rate_scale_data) * RATE_COUNT));
1537 u8 start_action;
1538 u8 valid_tx_ant = il->hw_params.valid_tx_ant;
1539 u8 tx_chains_num = il->hw_params.tx_chains_num;
1540 u8 update_search_tbl_counter = 0;
1541 int ret;
1542
1543 start_action = tbl->action;
1544 for (;;) {
1545 lq_sta->action_counter++;
1546 switch (tbl->action) {
1547 case IL_MIMO2_SWITCH_ANTENNA1:
1548 case IL_MIMO2_SWITCH_ANTENNA2:
1549 D_RATE("LQ: MIMO2 toggle Antennas\n");
1550
1551 if (tx_chains_num <= 2)
1552 break;
1553
1554 if (win->success_ratio >= IL_RS_GOOD_RATIO)
1555 break;
1556
1557 memcpy(search_tbl, tbl, sz);
1558 if (il4965_rs_toggle_antenna
1559 (valid_tx_ant, &search_tbl->current_rate,
1560 search_tbl)) {
1561 update_search_tbl_counter = 1;
1562 goto out;
1563 }
1564 break;
1565 case IL_MIMO2_SWITCH_SISO_A:
1566 case IL_MIMO2_SWITCH_SISO_B:
1567 case IL_MIMO2_SWITCH_SISO_C:
1568 D_RATE("LQ: MIMO2 switch to SISO\n");
1569
1570 /* Set up new search table for SISO */
1571 memcpy(search_tbl, tbl, sz);
1572
1573 if (tbl->action == IL_MIMO2_SWITCH_SISO_A)
1574 search_tbl->ant_type = ANT_A;
1575 else if (tbl->action == IL_MIMO2_SWITCH_SISO_B)
1576 search_tbl->ant_type = ANT_B;
1577 else
1578 search_tbl->ant_type = ANT_C;
1579
1580 if (!il4965_rs_is_valid_ant
1581 (valid_tx_ant, search_tbl->ant_type))
1582 break;
1583
1584 ret =
1585 il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
1586 search_tbl, idx);
1587 if (!ret)
1588 goto out;
1589
1590 break;
1591
1592 case IL_MIMO2_SWITCH_GI:
1593 if (!tbl->is_ht40 &&
1594 !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
1595 break;
1596 if (tbl->is_ht40 &&
1597 !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
1598 break;
1599
1600 D_RATE("LQ: MIMO2 toggle SGI/NGI\n");
1601
1602 /* Set up new search table for MIMO2 */
1603 memcpy(search_tbl, tbl, sz);
1604 search_tbl->is_SGI = !tbl->is_SGI;
1605 il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
1606 /*
1607 * If active table already uses the fastest possible
1608 * modulation (dual stream with short guard interval),
1609 * and it's working well, there's no need to look
1610 * for a better type of modulation!
1611 */
1612 if (tbl->is_SGI) {
1613 s32 tpt = lq_sta->last_tpt / 100;
1614 if (tpt >= search_tbl->expected_tpt[idx])
1615 break;
1616 }
1617 search_tbl->current_rate =
1618 il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
1619 is_green);
1620 update_search_tbl_counter = 1;
1621 goto out;
1622
1623 }
1624 tbl->action++;
1625 if (tbl->action > IL_MIMO2_SWITCH_GI)
1626 tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
1627
1628 if (tbl->action == start_action)
1629 break;
1630 }
1631 search_tbl->lq_type = LQ_NONE;
1632 return 0;
1633 out:
1634 lq_sta->search_better_tbl = 1;
1635 tbl->action++;
1636 if (tbl->action > IL_MIMO2_SWITCH_GI)
1637 tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
1638 if (update_search_tbl_counter)
1639 search_tbl->action = tbl->action;
1640
1641 return 0;
1642
1643 }
1644
1645 /*
1646 * Check whether we should continue using same modulation mode, or
1647 * begin search for a new mode, based on:
1648 * 1) # tx successes or failures while using this mode
1649 * 2) # times calling this function
1650 * 3) elapsed time in this mode (not used, for now)
1651 */
1652 static void
1653 il4965_rs_stay_in_table(struct il_lq_sta *lq_sta, bool force_search)
1654 {
1655 struct il_scale_tbl_info *tbl;
1656 int i;
1657 int active_tbl;
1658 int flush_interval_passed = 0;
1659 struct il_priv *il;
1660
1661 il = lq_sta->drv;
1662 active_tbl = lq_sta->active_tbl;
1663
1664 tbl = &(lq_sta->lq_info[active_tbl]);
1665
1666 /* If we've been disallowing search, see if we should now allow it */
1667 if (lq_sta->stay_in_tbl) {
1668
1669 /* Elapsed time using current modulation mode */
1670 if (lq_sta->flush_timer)
1671 flush_interval_passed =
1672 time_after(jiffies,
1673 (unsigned long)(lq_sta->flush_timer +
1674 RATE_SCALE_FLUSH_INTVL));
1675
1676 /*
1677 * Check if we should allow search for new modulation mode.
1678 * If many frames have failed or succeeded, or we've used
1679 * this same modulation for a long time, allow search, and
1680 * reset history stats that keep track of whether we should
1681 * allow a new search. Also (below) reset all bitmaps and
1682 * stats in active history.
1683 */
1684 if (force_search ||
1685 lq_sta->total_failed > lq_sta->max_failure_limit ||
1686 lq_sta->total_success > lq_sta->max_success_limit ||
1687 (!lq_sta->search_better_tbl && lq_sta->flush_timer &&
1688 flush_interval_passed)) {
1689 D_RATE("LQ: stay is expired %d %d %d\n:",
1690 lq_sta->total_failed, lq_sta->total_success,
1691 flush_interval_passed);
1692
1693 /* Allow search for new mode */
1694 lq_sta->stay_in_tbl = 0; /* only place reset */
1695 lq_sta->total_failed = 0;
1696 lq_sta->total_success = 0;
1697 lq_sta->flush_timer = 0;
1698
1699 /*
1700 * Else if we've used this modulation mode enough repetitions
1701 * (regardless of elapsed time or success/failure), reset
1702 * history bitmaps and rate-specific stats for all rates in
1703 * active table.
1704 */
1705 } else {
1706 lq_sta->table_count++;
1707 if (lq_sta->table_count >= lq_sta->table_count_limit) {
1708 lq_sta->table_count = 0;
1709
1710 D_RATE("LQ: stay in table clear win\n");
1711 for (i = 0; i < RATE_COUNT; i++)
1712 il4965_rs_rate_scale_clear_win(&
1713 (tbl->
1714 win
1715 [i]));
1716 }
1717 }
1718
1719 /* If transitioning to allow "search", reset all history
1720 * bitmaps and stats in active table (this will become the new
1721 * "search" table). */
1722 if (!lq_sta->stay_in_tbl) {
1723 for (i = 0; i < RATE_COUNT; i++)
1724 il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
1725 }
1726 }
1727 }
1728
1729 /*
1730 * setup rate table in uCode
1731 */
1732 static void
1733 il4965_rs_update_rate_tbl(struct il_priv *il, struct il_rxon_context *ctx,
1734 struct il_lq_sta *lq_sta,
1735 struct il_scale_tbl_info *tbl, int idx, u8 is_green)
1736 {
1737 u32 rate;
1738
1739 /* Update uCode's rate table. */
1740 rate = il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
1741 il4965_rs_fill_link_cmd(il, lq_sta, rate);
1742 il_send_lq_cmd(il, ctx, &lq_sta->lq, CMD_ASYNC, false);
1743 }
1744
1745 /*
1746 * Do rate scaling and search for new modulation mode.
1747 */
1748 static void
1749 il4965_rs_rate_scale_perform(struct il_priv *il, struct sk_buff *skb,
1750 struct ieee80211_sta *sta,
1751 struct il_lq_sta *lq_sta)
1752 {
1753 struct ieee80211_hw *hw = il->hw;
1754 struct ieee80211_conf *conf = &hw->conf;
1755 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1756 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1757 int low = RATE_INVALID;
1758 int high = RATE_INVALID;
1759 int idx;
1760 int i;
1761 struct il_rate_scale_data *win = NULL;
1762 int current_tpt = IL_INVALID_VALUE;
1763 int low_tpt = IL_INVALID_VALUE;
1764 int high_tpt = IL_INVALID_VALUE;
1765 u32 fail_count;
1766 s8 scale_action = 0;
1767 u16 rate_mask;
1768 u8 update_lq = 0;
1769 struct il_scale_tbl_info *tbl, *tbl1;
1770 u16 rate_scale_idx_msk = 0;
1771 u8 is_green = 0;
1772 u8 active_tbl = 0;
1773 u8 done_search = 0;
1774 u16 high_low;
1775 s32 sr;
1776 u8 tid = MAX_TID_COUNT;
1777 struct il_tid_data *tid_data;
1778 struct il_station_priv *sta_priv = (void *)sta->drv_priv;
1779 struct il_rxon_context *ctx = sta_priv->common.ctx;
1780
1781 D_RATE("rate scale calculate new rate for skb\n");
1782
1783 /* Send management frames and NO_ACK data using lowest rate. */
1784 /* TODO: this could probably be improved.. */
1785 if (!ieee80211_is_data(hdr->frame_control) ||
1786 (info->flags & IEEE80211_TX_CTL_NO_ACK))
1787 return;
1788
1789 lq_sta->supp_rates = sta->supp_rates[lq_sta->band];
1790
1791 tid = il4965_rs_tl_add_packet(lq_sta, hdr);
1792 if (tid != MAX_TID_COUNT && (lq_sta->tx_agg_tid_en & (1 << tid))) {
1793 tid_data = &il->stations[lq_sta->lq.sta_id].tid[tid];
1794 if (tid_data->agg.state == IL_AGG_OFF)
1795 lq_sta->is_agg = 0;
1796 else
1797 lq_sta->is_agg = 1;
1798 } else
1799 lq_sta->is_agg = 0;
1800
1801 /*
1802 * Select rate-scale / modulation-mode table to work with in
1803 * the rest of this function: "search" if searching for better
1804 * modulation mode, or "active" if doing rate scaling within a mode.
1805 */
1806 if (!lq_sta->search_better_tbl)
1807 active_tbl = lq_sta->active_tbl;
1808 else
1809 active_tbl = 1 - lq_sta->active_tbl;
1810
1811 tbl = &(lq_sta->lq_info[active_tbl]);
1812 if (is_legacy(tbl->lq_type))
1813 lq_sta->is_green = 0;
1814 else
1815 lq_sta->is_green = il4965_rs_use_green(il, sta);
1816 is_green = lq_sta->is_green;
1817
1818 /* current tx rate */
1819 idx = lq_sta->last_txrate_idx;
1820
1821 D_RATE("Rate scale idx %d for type %d\n", idx, tbl->lq_type);
1822
1823 /* rates available for this association, and for modulation mode */
1824 rate_mask = il4965_rs_get_supported_rates(lq_sta, hdr, tbl->lq_type);
1825
1826 D_RATE("mask 0x%04X\n", rate_mask);
1827
1828 /* mask with station rate restriction */
1829 if (is_legacy(tbl->lq_type)) {
1830 if (lq_sta->band == IEEE80211_BAND_5GHZ)
1831 /* supp_rates has no CCK bits in A mode */
1832 rate_scale_idx_msk =
1833 (u16) (rate_mask &
1834 (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
1835 else
1836 rate_scale_idx_msk =
1837 (u16) (rate_mask & lq_sta->supp_rates);
1838
1839 } else
1840 rate_scale_idx_msk = rate_mask;
1841
1842 if (!rate_scale_idx_msk)
1843 rate_scale_idx_msk = rate_mask;
1844
1845 if (!((1 << idx) & rate_scale_idx_msk)) {
1846 IL_ERR("Current Rate is not valid\n");
1847 if (lq_sta->search_better_tbl) {
1848 /* revert to active table if search table is not valid */
1849 tbl->lq_type = LQ_NONE;
1850 lq_sta->search_better_tbl = 0;
1851 tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1852 /* get "active" rate info */
1853 idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
1854 il4965_rs_update_rate_tbl(il, ctx, lq_sta, tbl, idx,
1855 is_green);
1856 }
1857 return;
1858 }
1859
1860 /* Get expected throughput table and history win for current rate */
1861 if (!tbl->expected_tpt) {
1862 IL_ERR("tbl->expected_tpt is NULL\n");
1863 return;
1864 }
1865
1866 /* force user max rate if set by user */
1867 if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < idx) {
1868 idx = lq_sta->max_rate_idx;
1869 update_lq = 1;
1870 win = &(tbl->win[idx]);
1871 goto lq_update;
1872 }
1873
1874 win = &(tbl->win[idx]);
1875
1876 /*
1877 * If there is not enough history to calculate actual average
1878 * throughput, keep analyzing results of more tx frames, without
1879 * changing rate or mode (bypass most of the rest of this function).
1880 * Set up new rate table in uCode only if old rate is not supported
1881 * in current association (use new rate found above).
1882 */
1883 fail_count = win->counter - win->success_counter;
1884 if (fail_count < RATE_MIN_FAILURE_TH &&
1885 win->success_counter < RATE_MIN_SUCCESS_TH) {
1886 D_RATE("LQ: still below TH. succ=%d total=%d " "for idx %d\n",
1887 win->success_counter, win->counter, idx);
1888
1889 /* Can't calculate this yet; not enough history */
1890 win->average_tpt = IL_INVALID_VALUE;
1891
1892 /* Should we stay with this modulation mode,
1893 * or search for a new one? */
1894 il4965_rs_stay_in_table(lq_sta, false);
1895
1896 goto out;
1897 }
1898 /* Else we have enough samples; calculate estimate of
1899 * actual average throughput */
1900 if (win->average_tpt !=
1901 ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128)) {
1902 IL_ERR("expected_tpt should have been calculated by now\n");
1903 win->average_tpt =
1904 ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128);
1905 }
1906
1907 /* If we are searching for better modulation mode, check success. */
1908 if (lq_sta->search_better_tbl) {
1909 /* If good success, continue using the "search" mode;
1910 * no need to send new link quality command, since we're
1911 * continuing to use the setup that we've been trying. */
1912 if (win->average_tpt > lq_sta->last_tpt) {
1913
1914 D_RATE("LQ: SWITCHING TO NEW TBL "
1915 "suc=%d cur-tpt=%d old-tpt=%d\n",
1916 win->success_ratio, win->average_tpt,
1917 lq_sta->last_tpt);
1918
1919 if (!is_legacy(tbl->lq_type))
1920 lq_sta->enable_counter = 1;
1921
1922 /* Swap tables; "search" becomes "active" */
1923 lq_sta->active_tbl = active_tbl;
1924 current_tpt = win->average_tpt;
1925
1926 /* Else poor success; go back to mode in "active" table */
1927 } else {
1928
1929 D_RATE("LQ: GOING BACK TO THE OLD TBL "
1930 "suc=%d cur-tpt=%d old-tpt=%d\n",
1931 win->success_ratio, win->average_tpt,
1932 lq_sta->last_tpt);
1933
1934 /* Nullify "search" table */
1935 tbl->lq_type = LQ_NONE;
1936
1937 /* Revert to "active" table */
1938 active_tbl = lq_sta->active_tbl;
1939 tbl = &(lq_sta->lq_info[active_tbl]);
1940
1941 /* Revert to "active" rate and throughput info */
1942 idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
1943 current_tpt = lq_sta->last_tpt;
1944
1945 /* Need to set up a new rate table in uCode */
1946 update_lq = 1;
1947 }
1948
1949 /* Either way, we've made a decision; modulation mode
1950 * search is done, allow rate adjustment next time. */
1951 lq_sta->search_better_tbl = 0;
1952 done_search = 1; /* Don't switch modes below! */
1953 goto lq_update;
1954 }
1955
1956 /* (Else) not in search of better modulation mode, try for better
1957 * starting rate, while staying in this mode. */
1958 high_low =
1959 il4965_rs_get_adjacent_rate(il, idx, rate_scale_idx_msk,
1960 tbl->lq_type);
1961 low = high_low & 0xff;
1962 high = (high_low >> 8) & 0xff;
1963
1964 /* If user set max rate, dont allow higher than user constrain */
1965 if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < high)
1966 high = RATE_INVALID;
1967
1968 sr = win->success_ratio;
1969
1970 /* Collect measured throughputs for current and adjacent rates */
1971 current_tpt = win->average_tpt;
1972 if (low != RATE_INVALID)
1973 low_tpt = tbl->win[low].average_tpt;
1974 if (high != RATE_INVALID)
1975 high_tpt = tbl->win[high].average_tpt;
1976
1977 scale_action = 0;
1978
1979 /* Too many failures, decrease rate */
1980 if (sr <= RATE_DECREASE_TH || current_tpt == 0) {
1981 D_RATE("decrease rate because of low success_ratio\n");
1982 scale_action = -1;
1983
1984 /* No throughput measured yet for adjacent rates; try increase. */
1985 } else if (low_tpt == IL_INVALID_VALUE && high_tpt == IL_INVALID_VALUE) {
1986
1987 if (high != RATE_INVALID && sr >= RATE_INCREASE_TH)
1988 scale_action = 1;
1989 else if (low != RATE_INVALID)
1990 scale_action = 0;
1991 }
1992
1993 /* Both adjacent throughputs are measured, but neither one has better
1994 * throughput; we're using the best rate, don't change it! */
1995 else if (low_tpt != IL_INVALID_VALUE && high_tpt != IL_INVALID_VALUE &&
1996 low_tpt < current_tpt && high_tpt < current_tpt)
1997 scale_action = 0;
1998
1999 /* At least one adjacent rate's throughput is measured,
2000 * and may have better performance. */
2001 else {
2002 /* Higher adjacent rate's throughput is measured */
2003 if (high_tpt != IL_INVALID_VALUE) {
2004 /* Higher rate has better throughput */
2005 if (high_tpt > current_tpt && sr >= RATE_INCREASE_TH)
2006 scale_action = 1;
2007 else
2008 scale_action = 0;
2009
2010 /* Lower adjacent rate's throughput is measured */
2011 } else if (low_tpt != IL_INVALID_VALUE) {
2012 /* Lower rate has better throughput */
2013 if (low_tpt > current_tpt) {
2014 D_RATE("decrease rate because of low tpt\n");
2015 scale_action = -1;
2016 } else if (sr >= RATE_INCREASE_TH) {
2017 scale_action = 1;
2018 }
2019 }
2020 }
2021
2022 /* Sanity check; asked for decrease, but success rate or throughput
2023 * has been good at old rate. Don't change it. */
2024 if (scale_action == -1 && low != RATE_INVALID &&
2025 (sr > RATE_HIGH_TH || current_tpt > 100 * tbl->expected_tpt[low]))
2026 scale_action = 0;
2027
2028 switch (scale_action) {
2029 case -1:
2030 /* Decrease starting rate, update uCode's rate table */
2031 if (low != RATE_INVALID) {
2032 update_lq = 1;
2033 idx = low;
2034 }
2035
2036 break;
2037 case 1:
2038 /* Increase starting rate, update uCode's rate table */
2039 if (high != RATE_INVALID) {
2040 update_lq = 1;
2041 idx = high;
2042 }
2043
2044 break;
2045 case 0:
2046 /* No change */
2047 default:
2048 break;
2049 }
2050
2051 D_RATE("choose rate scale idx %d action %d low %d " "high %d type %d\n",
2052 idx, scale_action, low, high, tbl->lq_type);
2053
2054 lq_update:
2055 /* Replace uCode's rate table for the destination station. */
2056 if (update_lq)
2057 il4965_rs_update_rate_tbl(il, ctx, lq_sta, tbl, idx,
2058 is_green);
2059
2060 /* Should we stay with this modulation mode,
2061 * or search for a new one? */
2062 il4965_rs_stay_in_table(lq_sta, false);
2063
2064 /*
2065 * Search for new modulation mode if we're:
2066 * 1) Not changing rates right now
2067 * 2) Not just finishing up a search
2068 * 3) Allowing a new search
2069 */
2070 if (!update_lq && !done_search && !lq_sta->stay_in_tbl && win->counter) {
2071 /* Save current throughput to compare with "search" throughput */
2072 lq_sta->last_tpt = current_tpt;
2073
2074 /* Select a new "search" modulation mode to try.
2075 * If one is found, set up the new "search" table. */
2076 if (is_legacy(tbl->lq_type))
2077 il4965_rs_move_legacy_other(il, lq_sta, conf, sta, idx);
2078 else if (is_siso(tbl->lq_type))
2079 il4965_rs_move_siso_to_other(il, lq_sta, conf, sta,
2080 idx);
2081 else /* (is_mimo2(tbl->lq_type)) */
2082 il4965_rs_move_mimo2_to_other(il, lq_sta, conf, sta,
2083 idx);
2084
2085 /* If new "search" mode was selected, set up in uCode table */
2086 if (lq_sta->search_better_tbl) {
2087 /* Access the "search" table, clear its history. */
2088 tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
2089 for (i = 0; i < RATE_COUNT; i++)
2090 il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
2091
2092 /* Use new "search" start rate */
2093 idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
2094
2095 D_RATE("Switch current mcs: %X idx: %d\n",
2096 tbl->current_rate, idx);
2097 il4965_rs_fill_link_cmd(il, lq_sta, tbl->current_rate);
2098 il_send_lq_cmd(il, ctx, &lq_sta->lq, CMD_ASYNC, false);
2099 } else
2100 done_search = 1;
2101 }
2102
2103 if (done_search && !lq_sta->stay_in_tbl) {
2104 /* If the "active" (non-search) mode was legacy,
2105 * and we've tried switching antennas,
2106 * but we haven't been able to try HT modes (not available),
2107 * stay with best antenna legacy modulation for a while
2108 * before next round of mode comparisons. */
2109 tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
2110 if (is_legacy(tbl1->lq_type) && !conf_is_ht(conf) &&
2111 lq_sta->action_counter > tbl1->max_search) {
2112 D_RATE("LQ: STAY in legacy table\n");
2113 il4965_rs_set_stay_in_table(il, 1, lq_sta);
2114 }
2115
2116 /* If we're in an HT mode, and all 3 mode switch actions
2117 * have been tried and compared, stay in this best modulation
2118 * mode for a while before next round of mode comparisons. */
2119 if (lq_sta->enable_counter &&
2120 lq_sta->action_counter >= tbl1->max_search) {
2121 if (lq_sta->last_tpt > IL_AGG_TPT_THREHOLD &&
2122 (lq_sta->tx_agg_tid_en & (1 << tid)) &&
2123 tid != MAX_TID_COUNT) {
2124 tid_data =
2125 &il->stations[lq_sta->lq.sta_id].tid[tid];
2126 if (tid_data->agg.state == IL_AGG_OFF) {
2127 D_RATE("try to aggregate tid %d\n",
2128 tid);
2129 il4965_rs_tl_turn_on_agg(il, tid,
2130 lq_sta, sta);
2131 }
2132 }
2133 il4965_rs_set_stay_in_table(il, 0, lq_sta);
2134 }
2135 }
2136
2137 out:
2138 tbl->current_rate =
2139 il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
2140 i = idx;
2141 lq_sta->last_txrate_idx = i;
2142 }
2143
2144 /**
2145 * il4965_rs_initialize_lq - Initialize a station's hardware rate table
2146 *
2147 * The uCode's station table contains a table of fallback rates
2148 * for automatic fallback during transmission.
2149 *
2150 * NOTE: This sets up a default set of values. These will be replaced later
2151 * if the driver's iwl-4965-rs rate scaling algorithm is used, instead of
2152 * rc80211_simple.
2153 *
2154 * NOTE: Run C_ADD_STA command to set up station table entry, before
2155 * calling this function (which runs C_TX_LINK_QUALITY_CMD,
2156 * which requires station table entry to exist).
2157 */
2158 static void
2159 il4965_rs_initialize_lq(struct il_priv *il, struct ieee80211_conf *conf,
2160 struct ieee80211_sta *sta, struct il_lq_sta *lq_sta)
2161 {
2162 struct il_scale_tbl_info *tbl;
2163 int rate_idx;
2164 int i;
2165 u32 rate;
2166 u8 use_green = il4965_rs_use_green(il, sta);
2167 u8 active_tbl = 0;
2168 u8 valid_tx_ant;
2169 struct il_station_priv *sta_priv;
2170 struct il_rxon_context *ctx;
2171
2172 if (!sta || !lq_sta)
2173 return;
2174
2175 sta_priv = (void *)sta->drv_priv;
2176 ctx = sta_priv->common.ctx;
2177
2178 i = lq_sta->last_txrate_idx;
2179
2180 valid_tx_ant = il->hw_params.valid_tx_ant;
2181
2182 if (!lq_sta->search_better_tbl)
2183 active_tbl = lq_sta->active_tbl;
2184 else
2185 active_tbl = 1 - lq_sta->active_tbl;
2186
2187 tbl = &(lq_sta->lq_info[active_tbl]);
2188
2189 if (i < 0 || i >= RATE_COUNT)
2190 i = 0;
2191
2192 rate = il_rates[i].plcp;
2193 tbl->ant_type = il4965_first_antenna(valid_tx_ant);
2194 rate |= tbl->ant_type << RATE_MCS_ANT_POS;
2195
2196 if (i >= IL_FIRST_CCK_RATE && i <= IL_LAST_CCK_RATE)
2197 rate |= RATE_MCS_CCK_MSK;
2198
2199 il4965_rs_get_tbl_info_from_mcs(rate, il->band, tbl, &rate_idx);
2200 if (!il4965_rs_is_valid_ant(valid_tx_ant, tbl->ant_type))
2201 il4965_rs_toggle_antenna(valid_tx_ant, &rate, tbl);
2202
2203 rate = il4965_rate_n_flags_from_tbl(il, tbl, rate_idx, use_green);
2204 tbl->current_rate = rate;
2205 il4965_rs_set_expected_tpt_table(lq_sta, tbl);
2206 il4965_rs_fill_link_cmd(NULL, lq_sta, rate);
2207 il->stations[lq_sta->lq.sta_id].lq = &lq_sta->lq;
2208 il_send_lq_cmd(il, ctx, &lq_sta->lq, CMD_SYNC, true);
2209 }
2210
2211 static void
2212 il4965_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
2213 struct ieee80211_tx_rate_control *txrc)
2214 {
2215
2216 struct sk_buff *skb = txrc->skb;
2217 struct ieee80211_supported_band *sband = txrc->sband;
2218 struct il_priv *il __maybe_unused = (struct il_priv *)il_r;
2219 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2220 struct il_lq_sta *lq_sta = il_sta;
2221 int rate_idx;
2222
2223 D_RATE("rate scale calculate new rate for skb\n");
2224
2225 /* Get max rate if user set max rate */
2226 if (lq_sta) {
2227 lq_sta->max_rate_idx = txrc->max_rate_idx;
2228 if (sband->band == IEEE80211_BAND_5GHZ &&
2229 lq_sta->max_rate_idx != -1)
2230 lq_sta->max_rate_idx += IL_FIRST_OFDM_RATE;
2231 if (lq_sta->max_rate_idx < 0 ||
2232 lq_sta->max_rate_idx >= RATE_COUNT)
2233 lq_sta->max_rate_idx = -1;
2234 }
2235
2236 /* Treat uninitialized rate scaling data same as non-existing. */
2237 if (lq_sta && !lq_sta->drv) {
2238 D_RATE("Rate scaling not initialized yet.\n");
2239 il_sta = NULL;
2240 }
2241
2242 /* Send management frames and NO_ACK data using lowest rate. */
2243 if (rate_control_send_low(sta, il_sta, txrc))
2244 return;
2245
2246 if (!lq_sta)
2247 return;
2248
2249 rate_idx = lq_sta->last_txrate_idx;
2250
2251 if (lq_sta->last_rate_n_flags & RATE_MCS_HT_MSK) {
2252 rate_idx -= IL_FIRST_OFDM_RATE;
2253 /* 6M and 9M shared same MCS idx */
2254 rate_idx = (rate_idx > 0) ? (rate_idx - 1) : 0;
2255 if (il4965_rs_extract_rate(lq_sta->last_rate_n_flags) >=
2256 RATE_MIMO2_6M_PLCP)
2257 rate_idx = rate_idx + MCS_IDX_PER_STREAM;
2258 info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
2259 if (lq_sta->last_rate_n_flags & RATE_MCS_SGI_MSK)
2260 info->control.rates[0].flags |=
2261 IEEE80211_TX_RC_SHORT_GI;
2262 if (lq_sta->last_rate_n_flags & RATE_MCS_DUP_MSK)
2263 info->control.rates[0].flags |=
2264 IEEE80211_TX_RC_DUP_DATA;
2265 if (lq_sta->last_rate_n_flags & RATE_MCS_HT40_MSK)
2266 info->control.rates[0].flags |=
2267 IEEE80211_TX_RC_40_MHZ_WIDTH;
2268 if (lq_sta->last_rate_n_flags & RATE_MCS_GF_MSK)
2269 info->control.rates[0].flags |=
2270 IEEE80211_TX_RC_GREEN_FIELD;
2271 } else {
2272 /* Check for invalid rates */
2273 if (rate_idx < 0 || rate_idx >= RATE_COUNT_LEGACY ||
2274 (sband->band == IEEE80211_BAND_5GHZ &&
2275 rate_idx < IL_FIRST_OFDM_RATE))
2276 rate_idx = rate_lowest_index(sband, sta);
2277 /* On valid 5 GHz rate, adjust idx */
2278 else if (sband->band == IEEE80211_BAND_5GHZ)
2279 rate_idx -= IL_FIRST_OFDM_RATE;
2280 info->control.rates[0].flags = 0;
2281 }
2282 info->control.rates[0].idx = rate_idx;
2283
2284 }
2285
2286 static void *
2287 il4965_rs_alloc_sta(void *il_rate, struct ieee80211_sta *sta, gfp_t gfp)
2288 {
2289 struct il_station_priv *sta_priv =
2290 (struct il_station_priv *)sta->drv_priv;
2291 struct il_priv *il;
2292
2293 il = (struct il_priv *)il_rate;
2294 D_RATE("create station rate scale win\n");
2295
2296 return &sta_priv->lq_sta;
2297 }
2298
2299 /*
2300 * Called after adding a new station to initialize rate scaling
2301 */
2302 void
2303 il4965_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
2304 {
2305 int i, j;
2306 struct ieee80211_hw *hw = il->hw;
2307 struct ieee80211_conf *conf = &il->hw->conf;
2308 struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2309 struct il_station_priv *sta_priv;
2310 struct il_lq_sta *lq_sta;
2311 struct ieee80211_supported_band *sband;
2312
2313 sta_priv = (struct il_station_priv *)sta->drv_priv;
2314 lq_sta = &sta_priv->lq_sta;
2315 sband = hw->wiphy->bands[conf->channel->band];
2316
2317 lq_sta->lq.sta_id = sta_id;
2318
2319 for (j = 0; j < LQ_SIZE; j++)
2320 for (i = 0; i < RATE_COUNT; i++)
2321 il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
2322 win[i]);
2323
2324 lq_sta->flush_timer = 0;
2325 lq_sta->supp_rates = sta->supp_rates[sband->band];
2326 for (j = 0; j < LQ_SIZE; j++)
2327 for (i = 0; i < RATE_COUNT; i++)
2328 il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
2329 win[i]);
2330
2331 D_RATE("LQ:" "*** rate scale station global init for station %d ***\n",
2332 sta_id);
2333 /* TODO: what is a good starting rate for STA? About middle? Maybe not
2334 * the lowest or the highest rate.. Could consider using RSSI from
2335 * previous packets? Need to have IEEE 802.1X auth succeed immediately
2336 * after assoc.. */
2337
2338 lq_sta->is_dup = 0;
2339 lq_sta->max_rate_idx = -1;
2340 lq_sta->missed_rate_counter = IL_MISSED_RATE_MAX;
2341 lq_sta->is_green = il4965_rs_use_green(il, sta);
2342 lq_sta->active_legacy_rate = il->active_rate & ~(0x1000);
2343 lq_sta->band = il->band;
2344 /*
2345 * active_siso_rate mask includes 9 MBits (bit 5), and CCK (bits 0-3),
2346 * supp_rates[] does not; shift to convert format, force 9 MBits off.
2347 */
2348 lq_sta->active_siso_rate = ht_cap->mcs.rx_mask[0] << 1;
2349 lq_sta->active_siso_rate |= ht_cap->mcs.rx_mask[0] & 0x1;
2350 lq_sta->active_siso_rate &= ~((u16) 0x2);
2351 lq_sta->active_siso_rate <<= IL_FIRST_OFDM_RATE;
2352
2353 /* Same here */
2354 lq_sta->active_mimo2_rate = ht_cap->mcs.rx_mask[1] << 1;
2355 lq_sta->active_mimo2_rate |= ht_cap->mcs.rx_mask[1] & 0x1;
2356 lq_sta->active_mimo2_rate &= ~((u16) 0x2);
2357 lq_sta->active_mimo2_rate <<= IL_FIRST_OFDM_RATE;
2358
2359 /* These values will be overridden later */
2360 lq_sta->lq.general_params.single_stream_ant_msk =
2361 il4965_first_antenna(il->hw_params.valid_tx_ant);
2362 lq_sta->lq.general_params.dual_stream_ant_msk =
2363 il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
2364 valid_tx_ant);
2365 if (!lq_sta->lq.general_params.dual_stream_ant_msk) {
2366 lq_sta->lq.general_params.dual_stream_ant_msk = ANT_AB;
2367 } else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
2368 lq_sta->lq.general_params.dual_stream_ant_msk =
2369 il->hw_params.valid_tx_ant;
2370 }
2371
2372 /* as default allow aggregation for all tids */
2373 lq_sta->tx_agg_tid_en = IL_AGG_ALL_TID;
2374 lq_sta->drv = il;
2375
2376 /* Set last_txrate_idx to lowest rate */
2377 lq_sta->last_txrate_idx = rate_lowest_index(sband, sta);
2378 if (sband->band == IEEE80211_BAND_5GHZ)
2379 lq_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
2380 lq_sta->is_agg = 0;
2381
2382 #ifdef CONFIG_MAC80211_DEBUGFS
2383 lq_sta->dbg_fixed_rate = 0;
2384 #endif
2385
2386 il4965_rs_initialize_lq(il, conf, sta, lq_sta);
2387 }
2388
2389 static void
2390 il4965_rs_fill_link_cmd(struct il_priv *il, struct il_lq_sta *lq_sta,
2391 u32 new_rate)
2392 {
2393 struct il_scale_tbl_info tbl_type;
2394 int idx = 0;
2395 int rate_idx;
2396 int repeat_rate = 0;
2397 u8 ant_toggle_cnt = 0;
2398 u8 use_ht_possible = 1;
2399 u8 valid_tx_ant = 0;
2400 struct il_link_quality_cmd *lq_cmd = &lq_sta->lq;
2401
2402 /* Override starting rate (idx 0) if needed for debug purposes */
2403 il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
2404
2405 /* Interpret new_rate (rate_n_flags) */
2406 il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band, &tbl_type,
2407 &rate_idx);
2408
2409 /* How many times should we repeat the initial rate? */
2410 if (is_legacy(tbl_type.lq_type)) {
2411 ant_toggle_cnt = 1;
2412 repeat_rate = IL_NUMBER_TRY;
2413 } else {
2414 repeat_rate = IL_HT_NUMBER_TRY;
2415 }
2416
2417 lq_cmd->general_params.mimo_delimiter =
2418 is_mimo(tbl_type.lq_type) ? 1 : 0;
2419
2420 /* Fill 1st table entry (idx 0) */
2421 lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
2422
2423 if (il4965_num_of_ant(tbl_type.ant_type) == 1) {
2424 lq_cmd->general_params.single_stream_ant_msk =
2425 tbl_type.ant_type;
2426 } else if (il4965_num_of_ant(tbl_type.ant_type) == 2) {
2427 lq_cmd->general_params.dual_stream_ant_msk = tbl_type.ant_type;
2428 }
2429 /* otherwise we don't modify the existing value */
2430 idx++;
2431 repeat_rate--;
2432 if (il)
2433 valid_tx_ant = il->hw_params.valid_tx_ant;
2434
2435 /* Fill rest of rate table */
2436 while (idx < LINK_QUAL_MAX_RETRY_NUM) {
2437 /* Repeat initial/next rate.
2438 * For legacy IL_NUMBER_TRY == 1, this loop will not execute.
2439 * For HT IL_HT_NUMBER_TRY == 3, this executes twice. */
2440 while (repeat_rate > 0 && idx < LINK_QUAL_MAX_RETRY_NUM) {
2441 if (is_legacy(tbl_type.lq_type)) {
2442 if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
2443 ant_toggle_cnt++;
2444 else if (il &&
2445 il4965_rs_toggle_antenna(valid_tx_ant,
2446 &new_rate,
2447 &tbl_type))
2448 ant_toggle_cnt = 1;
2449 }
2450
2451 /* Override next rate if needed for debug purposes */
2452 il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
2453
2454 /* Fill next table entry */
2455 lq_cmd->rs_table[idx].rate_n_flags =
2456 cpu_to_le32(new_rate);
2457 repeat_rate--;
2458 idx++;
2459 }
2460
2461 il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band,
2462 &tbl_type, &rate_idx);
2463
2464 /* Indicate to uCode which entries might be MIMO.
2465 * If initial rate was MIMO, this will finally end up
2466 * as (IL_HT_NUMBER_TRY * 2), after 2nd pass, otherwise 0. */
2467 if (is_mimo(tbl_type.lq_type))
2468 lq_cmd->general_params.mimo_delimiter = idx;
2469
2470 /* Get next rate */
2471 new_rate =
2472 il4965_rs_get_lower_rate(lq_sta, &tbl_type, rate_idx,
2473 use_ht_possible);
2474
2475 /* How many times should we repeat the next rate? */
2476 if (is_legacy(tbl_type.lq_type)) {
2477 if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
2478 ant_toggle_cnt++;
2479 else if (il &&
2480 il4965_rs_toggle_antenna(valid_tx_ant,
2481 &new_rate, &tbl_type))
2482 ant_toggle_cnt = 1;
2483
2484 repeat_rate = IL_NUMBER_TRY;
2485 } else {
2486 repeat_rate = IL_HT_NUMBER_TRY;
2487 }
2488
2489 /* Don't allow HT rates after next pass.
2490 * il4965_rs_get_lower_rate() will change type to LQ_A or LQ_G. */
2491 use_ht_possible = 0;
2492
2493 /* Override next rate if needed for debug purposes */
2494 il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
2495
2496 /* Fill next table entry */
2497 lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
2498
2499 idx++;
2500 repeat_rate--;
2501 }
2502
2503 lq_cmd->agg_params.agg_frame_cnt_limit = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
2504 lq_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
2505
2506 lq_cmd->agg_params.agg_time_limit =
2507 cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
2508 }
2509
2510 static void *
2511 il4965_rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
2512 {
2513 return hw->priv;
2514 }
2515
2516 /* rate scale requires free function to be implemented */
2517 static void
2518 il4965_rs_free(void *il_rate)
2519 {
2520 return;
2521 }
2522
2523 static void
2524 il4965_rs_free_sta(void *il_r, struct ieee80211_sta *sta, void *il_sta)
2525 {
2526 struct il_priv *il __maybe_unused = il_r;
2527
2528 D_RATE("enter\n");
2529 D_RATE("leave\n");
2530 }
2531
2532 #ifdef CONFIG_MAC80211_DEBUGFS
2533 static int
2534 il4965_open_file_generic(struct inode *inode, struct file *file)
2535 {
2536 file->private_data = inode->i_private;
2537 return 0;
2538 }
2539
2540 static void
2541 il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta, u32 * rate_n_flags, int idx)
2542 {
2543 struct il_priv *il;
2544 u8 valid_tx_ant;
2545 u8 ant_sel_tx;
2546
2547 il = lq_sta->drv;
2548 valid_tx_ant = il->hw_params.valid_tx_ant;
2549 if (lq_sta->dbg_fixed_rate) {
2550 ant_sel_tx =
2551 ((lq_sta->
2552 dbg_fixed_rate & RATE_MCS_ANT_ABC_MSK) >>
2553 RATE_MCS_ANT_POS);
2554 if ((valid_tx_ant & ant_sel_tx) == ant_sel_tx) {
2555 *rate_n_flags = lq_sta->dbg_fixed_rate;
2556 D_RATE("Fixed rate ON\n");
2557 } else {
2558 lq_sta->dbg_fixed_rate = 0;
2559 IL_ERR
2560 ("Invalid antenna selection 0x%X, Valid is 0x%X\n",
2561 ant_sel_tx, valid_tx_ant);
2562 D_RATE("Fixed rate OFF\n");
2563 }
2564 } else {
2565 D_RATE("Fixed rate OFF\n");
2566 }
2567 }
2568
2569 static ssize_t
2570 il4965_rs_sta_dbgfs_scale_table_write(struct file *file,
2571 const char __user *user_buf,
2572 size_t count, loff_t *ppos)
2573 {
2574 struct il_lq_sta *lq_sta = file->private_data;
2575 struct il_priv *il;
2576 char buf[64];
2577 size_t buf_size;
2578 u32 parsed_rate;
2579 struct il_station_priv *sta_priv =
2580 container_of(lq_sta, struct il_station_priv, lq_sta);
2581 struct il_rxon_context *ctx = sta_priv->common.ctx;
2582
2583 il = lq_sta->drv;
2584 memset(buf, 0, sizeof(buf));
2585 buf_size = min(count, sizeof(buf) - 1);
2586 if (copy_from_user(buf, user_buf, buf_size))
2587 return -EFAULT;
2588
2589 if (sscanf(buf, "%x", &parsed_rate) == 1)
2590 lq_sta->dbg_fixed_rate = parsed_rate;
2591 else
2592 lq_sta->dbg_fixed_rate = 0;
2593
2594 lq_sta->active_legacy_rate = 0x0FFF; /* 1 - 54 MBits, includes CCK */
2595 lq_sta->active_siso_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
2596 lq_sta->active_mimo2_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
2597
2598 D_RATE("sta_id %d rate 0x%X\n", lq_sta->lq.sta_id,
2599 lq_sta->dbg_fixed_rate);
2600
2601 if (lq_sta->dbg_fixed_rate) {
2602 il4965_rs_fill_link_cmd(NULL, lq_sta, lq_sta->dbg_fixed_rate);
2603 il_send_lq_cmd(lq_sta->drv, ctx, &lq_sta->lq, CMD_ASYNC, false);
2604 }
2605
2606 return count;
2607 }
2608
2609 static ssize_t
2610 il4965_rs_sta_dbgfs_scale_table_read(struct file *file, char __user *user_buf,
2611 size_t count, loff_t *ppos)
2612 {
2613 char *buff;
2614 int desc = 0;
2615 int i = 0;
2616 int idx = 0;
2617 ssize_t ret;
2618
2619 struct il_lq_sta *lq_sta = file->private_data;
2620 struct il_priv *il;
2621 struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
2622
2623 il = lq_sta->drv;
2624 buff = kmalloc(1024, GFP_KERNEL);
2625 if (!buff)
2626 return -ENOMEM;
2627
2628 desc += sprintf(buff + desc, "sta_id %d\n", lq_sta->lq.sta_id);
2629 desc +=
2630 sprintf(buff + desc, "failed=%d success=%d rate=0%X\n",
2631 lq_sta->total_failed, lq_sta->total_success,
2632 lq_sta->active_legacy_rate);
2633 desc +=
2634 sprintf(buff + desc, "fixed rate 0x%X\n", lq_sta->dbg_fixed_rate);
2635 desc +=
2636 sprintf(buff + desc, "valid_tx_ant %s%s%s\n",
2637 (il->hw_params.valid_tx_ant & ANT_A) ? "ANT_A," : "",
2638 (il->hw_params.valid_tx_ant & ANT_B) ? "ANT_B," : "",
2639 (il->hw_params.valid_tx_ant & ANT_C) ? "ANT_C" : "");
2640 desc +=
2641 sprintf(buff + desc, "lq type %s\n",
2642 (is_legacy(tbl->lq_type)) ? "legacy" : "HT");
2643 if (is_Ht(tbl->lq_type)) {
2644 desc +=
2645 sprintf(buff + desc, " %s",
2646 (is_siso(tbl->lq_type)) ? "SISO" : "MIMO2");
2647 desc +=
2648 sprintf(buff + desc, " %s",
2649 (tbl->is_ht40) ? "40MHz" : "20MHz");
2650 desc +=
2651 sprintf(buff + desc, " %s %s %s\n",
2652 (tbl->is_SGI) ? "SGI" : "",
2653 (lq_sta->is_green) ? "GF enabled" : "",
2654 (lq_sta->is_agg) ? "AGG on" : "");
2655 }
2656 desc +=
2657 sprintf(buff + desc, "last tx rate=0x%X\n",
2658 lq_sta->last_rate_n_flags);
2659 desc +=
2660 sprintf(buff + desc,
2661 "general:" "flags=0x%X mimo-d=%d s-ant0x%x d-ant=0x%x\n",
2662 lq_sta->lq.general_params.flags,
2663 lq_sta->lq.general_params.mimo_delimiter,
2664 lq_sta->lq.general_params.single_stream_ant_msk,
2665 lq_sta->lq.general_params.dual_stream_ant_msk);
2666
2667 desc +=
2668 sprintf(buff + desc,
2669 "agg:"
2670 "time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
2671 le16_to_cpu(lq_sta->lq.agg_params.agg_time_limit),
2672 lq_sta->lq.agg_params.agg_dis_start_th,
2673 lq_sta->lq.agg_params.agg_frame_cnt_limit);
2674
2675 desc +=
2676 sprintf(buff + desc,
2677 "Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
2678 lq_sta->lq.general_params.start_rate_idx[0],
2679 lq_sta->lq.general_params.start_rate_idx[1],
2680 lq_sta->lq.general_params.start_rate_idx[2],
2681 lq_sta->lq.general_params.start_rate_idx[3]);
2682
2683 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
2684 idx =
2685 il4965_hwrate_to_plcp_idx(le32_to_cpu
2686 (lq_sta->lq.rs_table[i].
2687 rate_n_flags));
2688 if (is_legacy(tbl->lq_type)) {
2689 desc +=
2690 sprintf(buff + desc, " rate[%d] 0x%X %smbps\n", i,
2691 le32_to_cpu(lq_sta->lq.rs_table[i].
2692 rate_n_flags),
2693 il_rate_mcs[idx].mbps);
2694 } else {
2695 desc +=
2696 sprintf(buff + desc, " rate[%d] 0x%X %smbps (%s)\n",
2697 i,
2698 le32_to_cpu(lq_sta->lq.rs_table[i].
2699 rate_n_flags),
2700 il_rate_mcs[idx].mbps,
2701 il_rate_mcs[idx].mcs);
2702 }
2703 }
2704
2705 ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
2706 kfree(buff);
2707 return ret;
2708 }
2709
2710 static const struct file_operations rs_sta_dbgfs_scale_table_ops = {
2711 .write = il4965_rs_sta_dbgfs_scale_table_write,
2712 .read = il4965_rs_sta_dbgfs_scale_table_read,
2713 .open = il4965_open_file_generic,
2714 .llseek = default_llseek,
2715 };
2716
2717 static ssize_t
2718 il4965_rs_sta_dbgfs_stats_table_read(struct file *file, char __user *user_buf,
2719 size_t count, loff_t *ppos)
2720 {
2721 char *buff;
2722 int desc = 0;
2723 int i, j;
2724 ssize_t ret;
2725
2726 struct il_lq_sta *lq_sta = file->private_data;
2727
2728 buff = kmalloc(1024, GFP_KERNEL);
2729 if (!buff)
2730 return -ENOMEM;
2731
2732 for (i = 0; i < LQ_SIZE; i++) {
2733 desc +=
2734 sprintf(buff + desc,
2735 "%s type=%d SGI=%d HT40=%d DUP=%d GF=%d\n"
2736 "rate=0x%X\n", lq_sta->active_tbl == i ? "*" : "x",
2737 lq_sta->lq_info[i].lq_type,
2738 lq_sta->lq_info[i].is_SGI,
2739 lq_sta->lq_info[i].is_ht40,
2740 lq_sta->lq_info[i].is_dup, lq_sta->is_green,
2741 lq_sta->lq_info[i].current_rate);
2742 for (j = 0; j < RATE_COUNT; j++) {
2743 desc +=
2744 sprintf(buff + desc,
2745 "counter=%d success=%d %%=%d\n",
2746 lq_sta->lq_info[i].win[j].counter,
2747 lq_sta->lq_info[i].win[j].success_counter,
2748 lq_sta->lq_info[i].win[j].success_ratio);
2749 }
2750 }
2751 ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
2752 kfree(buff);
2753 return ret;
2754 }
2755
2756 static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
2757 .read = il4965_rs_sta_dbgfs_stats_table_read,
2758 .open = il4965_open_file_generic,
2759 .llseek = default_llseek,
2760 };
2761
2762 static ssize_t
2763 il4965_rs_sta_dbgfs_rate_scale_data_read(struct file *file,
2764 char __user *user_buf, size_t count,
2765 loff_t *ppos)
2766 {
2767 char buff[120];
2768 int desc = 0;
2769 struct il_lq_sta *lq_sta = file->private_data;
2770 struct il_scale_tbl_info *tbl = &lq_sta->lq_info[lq_sta->active_tbl];
2771
2772 if (is_Ht(tbl->lq_type))
2773 desc +=
2774 sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
2775 tbl->expected_tpt[lq_sta->last_txrate_idx]);
2776 else
2777 desc +=
2778 sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
2779 il_rates[lq_sta->last_txrate_idx].ieee >> 1);
2780
2781 return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
2782 }
2783
2784 static const struct file_operations rs_sta_dbgfs_rate_scale_data_ops = {
2785 .read = il4965_rs_sta_dbgfs_rate_scale_data_read,
2786 .open = il4965_open_file_generic,
2787 .llseek = default_llseek,
2788 };
2789
2790 static void
2791 il4965_rs_add_debugfs(void *il, void *il_sta, struct dentry *dir)
2792 {
2793 struct il_lq_sta *lq_sta = il_sta;
2794 lq_sta->rs_sta_dbgfs_scale_table_file =
2795 debugfs_create_file("rate_scale_table", S_IRUSR | S_IWUSR, dir,
2796 lq_sta, &rs_sta_dbgfs_scale_table_ops);
2797 lq_sta->rs_sta_dbgfs_stats_table_file =
2798 debugfs_create_file("rate_stats_table", S_IRUSR, dir, lq_sta,
2799 &rs_sta_dbgfs_stats_table_ops);
2800 lq_sta->rs_sta_dbgfs_rate_scale_data_file =
2801 debugfs_create_file("rate_scale_data", S_IRUSR, dir, lq_sta,
2802 &rs_sta_dbgfs_rate_scale_data_ops);
2803 lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file =
2804 debugfs_create_u8("tx_agg_tid_enable", S_IRUSR | S_IWUSR, dir,
2805 &lq_sta->tx_agg_tid_en);
2806
2807 }
2808
2809 static void
2810 il4965_rs_remove_debugfs(void *il, void *il_sta)
2811 {
2812 struct il_lq_sta *lq_sta = il_sta;
2813 debugfs_remove(lq_sta->rs_sta_dbgfs_scale_table_file);
2814 debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
2815 debugfs_remove(lq_sta->rs_sta_dbgfs_rate_scale_data_file);
2816 debugfs_remove(lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file);
2817 }
2818 #endif
2819
2820 /*
2821 * Initialization of rate scaling information is done by driver after
2822 * the station is added. Since mac80211 calls this function before a
2823 * station is added we ignore it.
2824 */
2825 static void
2826 il4965_rs_rate_init_stub(void *il_r, struct ieee80211_supported_band *sband,
2827 struct ieee80211_sta *sta, void *il_sta)
2828 {
2829 }
2830
2831 static struct rate_control_ops rs_4965_ops = {
2832 .module = NULL,
2833 .name = IL4965_RS_NAME,
2834 .tx_status = il4965_rs_tx_status,
2835 .get_rate = il4965_rs_get_rate,
2836 .rate_init = il4965_rs_rate_init_stub,
2837 .alloc = il4965_rs_alloc,
2838 .free = il4965_rs_free,
2839 .alloc_sta = il4965_rs_alloc_sta,
2840 .free_sta = il4965_rs_free_sta,
2841 #ifdef CONFIG_MAC80211_DEBUGFS
2842 .add_sta_debugfs = il4965_rs_add_debugfs,
2843 .remove_sta_debugfs = il4965_rs_remove_debugfs,
2844 #endif
2845 };
2846
2847 int
2848 il4965_rate_control_register(void)
2849 {
2850 return ieee80211_rate_control_register(&rs_4965_ops);
2851 }
2852
2853 void
2854 il4965_rate_control_unregister(void)
2855 {
2856 ieee80211_rate_control_unregister(&rs_4965_ops);
2857 }
Linus' kernel tree