Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
4965-rs.c
Go to the documentation of this file.
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 <[email protected]>
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 
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 
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 
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 
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 
824  D_RATE("get frame ack response, update rate scale win\n");
825 
826  /* Treat uninitialized rate scaling data same as non-existing. */
827  if (!lq_sta) {
828  D_RATE("Station rate scaling not created yet.\n");
829  return;
830  } else if (!lq_sta->drv) {
831  D_RATE("Rate scaling not initialized yet.\n");
832  return;
833  }
834 
835  if (!ieee80211_is_data(hdr->frame_control) ||
836  (info->flags & IEEE80211_TX_CTL_NO_ACK))
837  return;
838 
839  /* This packet was aggregated but doesn't carry status info */
840  if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
841  !(info->flags & IEEE80211_TX_STAT_AMPDU))
842  return;
843 
844  /*
845  * Ignore this Tx frame response if its initial rate doesn't match
846  * that of latest Link Quality command. There may be stragglers
847  * from a previous Link Quality command, but we're no longer interested
848  * in those; they're either from the "active" mode while we're trying
849  * to check "search" mode, or a prior "search" mode after we've moved
850  * to a new "search" mode (which might become the new "active" mode).
851  */
852  table = &lq_sta->lq;
853  tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
854  il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type, &rs_idx);
855  if (il->band == IEEE80211_BAND_5GHZ)
856  rs_idx -= IL_FIRST_OFDM_RATE;
857  mac_flags = info->status.rates[0].flags;
858  mac_idx = info->status.rates[0].idx;
859  /* For HT packets, map MCS to PLCP */
860  if (mac_flags & IEEE80211_TX_RC_MCS) {
861  mac_idx &= RATE_MCS_CODE_MSK; /* Remove # of streams */
862  if (mac_idx >= (RATE_9M_IDX - IL_FIRST_OFDM_RATE))
863  mac_idx++;
864  /*
865  * mac80211 HT idx is always zero-idxed; we need to move
866  * HT OFDM rates after CCK rates in 2.4 GHz band
867  */
868  if (il->band == IEEE80211_BAND_2GHZ)
869  mac_idx += IL_FIRST_OFDM_RATE;
870  }
871  /* Here we actually compare this rate to the latest LQ command */
872  if (mac_idx < 0 ||
873  tbl_type.is_SGI != !!(mac_flags & IEEE80211_TX_RC_SHORT_GI) ||
874  tbl_type.is_ht40 != !!(mac_flags & IEEE80211_TX_RC_40_MHZ_WIDTH) ||
875  tbl_type.is_dup != !!(mac_flags & IEEE80211_TX_RC_DUP_DATA) ||
876  tbl_type.ant_type != info->status.antenna ||
877  !!(tx_rate & RATE_MCS_HT_MSK) != !!(mac_flags & IEEE80211_TX_RC_MCS)
878  || !!(tx_rate & RATE_MCS_GF_MSK) !=
879  !!(mac_flags & IEEE80211_TX_RC_GREEN_FIELD) || rs_idx != mac_idx) {
880  D_RATE("initial rate %d does not match %d (0x%x)\n", mac_idx,
881  rs_idx, tx_rate);
882  /*
883  * Since rates mis-match, the last LQ command may have failed.
884  * After IL_MISSED_RATE_MAX mis-matches, resync the uCode with
885  * ... driver.
886  */
887  lq_sta->missed_rate_counter++;
888  if (lq_sta->missed_rate_counter > IL_MISSED_RATE_MAX) {
889  lq_sta->missed_rate_counter = 0;
890  il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
891  }
892  /* Regardless, ignore this status info for outdated rate */
893  return;
894  } else
895  /* Rate did match, so reset the missed_rate_counter */
896  lq_sta->missed_rate_counter = 0;
897 
898  /* Figure out if rate scale algorithm is in active or search table */
899  if (il4965_table_type_matches
900  (&tbl_type, &(lq_sta->lq_info[lq_sta->active_tbl]))) {
901  curr_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
902  other_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
903  } else
904  if (il4965_table_type_matches
905  (&tbl_type, &lq_sta->lq_info[1 - lq_sta->active_tbl])) {
906  curr_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
907  other_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
908  } else {
909  D_RATE("Neither active nor search matches tx rate\n");
910  tmp_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
911  D_RATE("active- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
912  tmp_tbl->ant_type, tmp_tbl->is_SGI);
913  tmp_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
914  D_RATE("search- lq:%x, ant:%x, SGI:%d\n", tmp_tbl->lq_type,
915  tmp_tbl->ant_type, tmp_tbl->is_SGI);
916  D_RATE("actual- lq:%x, ant:%x, SGI:%d\n", tbl_type.lq_type,
917  tbl_type.ant_type, tbl_type.is_SGI);
918  /*
919  * no matching table found, let's by-pass the data collection
920  * and continue to perform rate scale to find the rate table
921  */
922  il4965_rs_stay_in_table(lq_sta, true);
923  goto done;
924  }
925 
926  /*
927  * Updating the frame history depends on whether packets were
928  * aggregated.
929  *
930  * For aggregation, all packets were transmitted at the same rate, the
931  * first idx into rate scale table.
932  */
933  if (info->flags & IEEE80211_TX_STAT_AMPDU) {
934  tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
935  il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type,
936  &rs_idx);
937  il4965_rs_collect_tx_data(curr_tbl, rs_idx,
938  info->status.ampdu_len,
939  info->status.ampdu_ack_len);
940 
941  /* Update success/fail counts if not searching for new mode */
942  if (lq_sta->stay_in_tbl) {
943  lq_sta->total_success += info->status.ampdu_ack_len;
944  lq_sta->total_failed +=
945  (info->status.ampdu_len -
946  info->status.ampdu_ack_len);
947  }
948  } else {
949  /*
950  * For legacy, update frame history with for each Tx retry.
951  */
952  retries = info->status.rates[0].count - 1;
953  /* HW doesn't send more than 15 retries */
954  retries = min(retries, 15);
955 
956  /* The last transmission may have been successful */
957  legacy_success = !!(info->flags & IEEE80211_TX_STAT_ACK);
958  /* Collect data for each rate used during failed TX attempts */
959  for (i = 0; i <= retries; ++i) {
960  tx_rate = le32_to_cpu(table->rs_table[i].rate_n_flags);
961  il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band,
962  &tbl_type, &rs_idx);
963  /*
964  * Only collect stats if retried rate is in the same RS
965  * table as active/search.
966  */
967  if (il4965_table_type_matches(&tbl_type, curr_tbl))
968  tmp_tbl = curr_tbl;
969  else if (il4965_table_type_matches
970  (&tbl_type, other_tbl))
971  tmp_tbl = other_tbl;
972  else
973  continue;
974  il4965_rs_collect_tx_data(tmp_tbl, rs_idx, 1,
975  i <
976  retries ? 0 : legacy_success);
977  }
978 
979  /* Update success/fail counts if not searching for new mode */
980  if (lq_sta->stay_in_tbl) {
981  lq_sta->total_success += legacy_success;
982  lq_sta->total_failed += retries + (1 - legacy_success);
983  }
984  }
985  /* The last TX rate is cached in lq_sta; it's set in if/else above */
986  lq_sta->last_rate_n_flags = tx_rate;
987 done:
988  /* See if there's a better rate or modulation mode to try. */
989  if (sta->supp_rates[sband->band])
990  il4965_rs_rate_scale_perform(il, skb, sta, lq_sta);
991 }
992 
993 /*
994  * Begin a period of staying with a selected modulation mode.
995  * Set "stay_in_tbl" flag to prevent any mode switches.
996  * Set frame tx success limits according to legacy vs. high-throughput,
997  * and reset overall (spanning all rates) tx success history stats.
998  * These control how long we stay using same modulation mode before
999  * searching for a new mode.
1000  */
1001 static void
1002 il4965_rs_set_stay_in_table(struct il_priv *il, u8 is_legacy,
1003  struct il_lq_sta *lq_sta)
1004 {
1005  D_RATE("we are staying in the same table\n");
1006  lq_sta->stay_in_tbl = 1; /* only place this gets set */
1007  if (is_legacy) {
1008  lq_sta->table_count_limit = IL_LEGACY_TBL_COUNT;
1009  lq_sta->max_failure_limit = IL_LEGACY_FAILURE_LIMIT;
1010  lq_sta->max_success_limit = IL_LEGACY_SUCCESS_LIMIT;
1011  } else {
1012  lq_sta->table_count_limit = IL_NONE_LEGACY_TBL_COUNT;
1013  lq_sta->max_failure_limit = IL_NONE_LEGACY_FAILURE_LIMIT;
1014  lq_sta->max_success_limit = IL_NONE_LEGACY_SUCCESS_LIMIT;
1015  }
1016  lq_sta->table_count = 0;
1017  lq_sta->total_failed = 0;
1018  lq_sta->total_success = 0;
1019  lq_sta->flush_timer = jiffies;
1020  lq_sta->action_counter = 0;
1021 }
1022 
1023 /*
1024  * Find correct throughput table for given mode of modulation
1025  */
1026 static void
1027 il4965_rs_set_expected_tpt_table(struct il_lq_sta *lq_sta,
1028  struct il_scale_tbl_info *tbl)
1029 {
1030  /* Used to choose among HT tables */
1031  s32(*ht_tbl_pointer)[RATE_COUNT];
1032 
1033  /* Check for invalid LQ type */
1034  if (WARN_ON_ONCE(!is_legacy(tbl->lq_type) && !is_Ht(tbl->lq_type))) {
1035  tbl->expected_tpt = expected_tpt_legacy;
1036  return;
1037  }
1038 
1039  /* Legacy rates have only one table */
1040  if (is_legacy(tbl->lq_type)) {
1041  tbl->expected_tpt = expected_tpt_legacy;
1042  return;
1043  }
1044 
1045  /* Choose among many HT tables depending on number of streams
1046  * (SISO/MIMO2), channel width (20/40), SGI, and aggregation
1047  * status */
1048  if (is_siso(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
1049  ht_tbl_pointer = expected_tpt_siso20MHz;
1050  else if (is_siso(tbl->lq_type))
1051  ht_tbl_pointer = expected_tpt_siso40MHz;
1052  else if (is_mimo2(tbl->lq_type) && (!tbl->is_ht40 || lq_sta->is_dup))
1053  ht_tbl_pointer = expected_tpt_mimo2_20MHz;
1054  else /* if (is_mimo2(tbl->lq_type)) <-- must be true */
1055  ht_tbl_pointer = expected_tpt_mimo2_40MHz;
1056 
1057  if (!tbl->is_SGI && !lq_sta->is_agg) /* Normal */
1058  tbl->expected_tpt = ht_tbl_pointer[0];
1059  else if (tbl->is_SGI && !lq_sta->is_agg) /* SGI */
1060  tbl->expected_tpt = ht_tbl_pointer[1];
1061  else if (!tbl->is_SGI && lq_sta->is_agg) /* AGG */
1062  tbl->expected_tpt = ht_tbl_pointer[2];
1063  else /* AGG+SGI */
1064  tbl->expected_tpt = ht_tbl_pointer[3];
1065 }
1066 
1067 /*
1068  * Find starting rate for new "search" high-throughput mode of modulation.
1069  * Goal is to find lowest expected rate (under perfect conditions) that is
1070  * above the current measured throughput of "active" mode, to give new mode
1071  * a fair chance to prove itself without too many challenges.
1072  *
1073  * This gets called when transitioning to more aggressive modulation
1074  * (i.e. legacy to SISO or MIMO, or SISO to MIMO), as well as less aggressive
1075  * (i.e. MIMO to SISO). When moving to MIMO, bit rate will typically need
1076  * to decrease to match "active" throughput. When moving from MIMO to SISO,
1077  * bit rate will typically need to increase, but not if performance was bad.
1078  */
1079 static s32
1080 il4965_rs_get_best_rate(struct il_priv *il, struct il_lq_sta *lq_sta,
1081  struct il_scale_tbl_info *tbl, /* "search" */
1082  u16 rate_mask, s8 idx)
1083 {
1084  /* "active" values */
1085  struct il_scale_tbl_info *active_tbl =
1086  &(lq_sta->lq_info[lq_sta->active_tbl]);
1087  s32 active_sr = active_tbl->win[idx].success_ratio;
1088  s32 active_tpt = active_tbl->expected_tpt[idx];
1089 
1090  /* expected "search" throughput */
1091  s32 *tpt_tbl = tbl->expected_tpt;
1092 
1093  s32 new_rate, high, low, start_hi;
1094  u16 high_low;
1095  s8 rate = idx;
1096 
1097  new_rate = high = low = start_hi = RATE_INVALID;
1098 
1099  for (;;) {
1100  high_low =
1101  il4965_rs_get_adjacent_rate(il, rate, rate_mask,
1102  tbl->lq_type);
1103 
1104  low = high_low & 0xff;
1105  high = (high_low >> 8) & 0xff;
1106 
1107  /*
1108  * Lower the "search" bit rate, to give new "search" mode
1109  * approximately the same throughput as "active" if:
1110  *
1111  * 1) "Active" mode has been working modestly well (but not
1112  * great), and expected "search" throughput (under perfect
1113  * conditions) at candidate rate is above the actual
1114  * measured "active" throughput (but less than expected
1115  * "active" throughput under perfect conditions).
1116  * OR
1117  * 2) "Active" mode has been working perfectly or very well
1118  * and expected "search" throughput (under perfect
1119  * conditions) at candidate rate is above expected
1120  * "active" throughput (under perfect conditions).
1121  */
1122  if ((100 * tpt_tbl[rate] > lq_sta->last_tpt &&
1123  (active_sr > RATE_DECREASE_TH && active_sr <= RATE_HIGH_TH
1124  && tpt_tbl[rate] <= active_tpt)) ||
1125  (active_sr >= RATE_SCALE_SWITCH &&
1126  tpt_tbl[rate] > active_tpt)) {
1127 
1128  /* (2nd or later pass)
1129  * If we've already tried to raise the rate, and are
1130  * now trying to lower it, use the higher rate. */
1131  if (start_hi != RATE_INVALID) {
1132  new_rate = start_hi;
1133  break;
1134  }
1135 
1136  new_rate = rate;
1137 
1138  /* Loop again with lower rate */
1139  if (low != RATE_INVALID)
1140  rate = low;
1141 
1142  /* Lower rate not available, use the original */
1143  else
1144  break;
1145 
1146  /* Else try to raise the "search" rate to match "active" */
1147  } else {
1148  /* (2nd or later pass)
1149  * If we've already tried to lower the rate, and are
1150  * now trying to raise it, use the lower rate. */
1151  if (new_rate != RATE_INVALID)
1152  break;
1153 
1154  /* Loop again with higher rate */
1155  else if (high != RATE_INVALID) {
1156  start_hi = high;
1157  rate = high;
1158 
1159  /* Higher rate not available, use the original */
1160  } else {
1161  new_rate = rate;
1162  break;
1163  }
1164  }
1165  }
1166 
1167  return new_rate;
1168 }
1169 
1170 /*
1171  * Set up search table for MIMO2
1172  */
1173 static int
1174 il4965_rs_switch_to_mimo2(struct il_priv *il, struct il_lq_sta *lq_sta,
1175  struct ieee80211_conf *conf,
1176  struct ieee80211_sta *sta,
1177  struct il_scale_tbl_info *tbl, int idx)
1178 {
1179  u16 rate_mask;
1180  s32 rate;
1181  s8 is_green = lq_sta->is_green;
1182 
1183  if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
1184  return -1;
1185 
1186  if (((sta->ht_cap.cap & IEEE80211_HT_CAP_SM_PS) >> 2) ==
1187  WLAN_HT_CAP_SM_PS_STATIC)
1188  return -1;
1189 
1190  /* Need both Tx chains/antennas to support MIMO */
1191  if (il->hw_params.tx_chains_num < 2)
1192  return -1;
1193 
1194  D_RATE("LQ: try to switch to MIMO2\n");
1195 
1196  tbl->lq_type = LQ_MIMO2;
1197  tbl->is_dup = lq_sta->is_dup;
1198  tbl->action = 0;
1199  tbl->max_search = IL_MAX_SEARCH;
1200  rate_mask = lq_sta->active_mimo2_rate;
1201 
1202  if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
1203  tbl->is_ht40 = 1;
1204  else
1205  tbl->is_ht40 = 0;
1206 
1207  il4965_rs_set_expected_tpt_table(lq_sta, tbl);
1208 
1209  rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
1210 
1211  D_RATE("LQ: MIMO2 best rate %d mask %X\n", rate, rate_mask);
1212  if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
1213  D_RATE("Can't switch with idx %d rate mask %x\n", rate,
1214  rate_mask);
1215  return -1;
1216  }
1217  tbl->current_rate =
1218  il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
1219 
1220  D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
1221  is_green);
1222  return 0;
1223 }
1224 
1225 /*
1226  * Set up search table for SISO
1227  */
1228 static int
1229 il4965_rs_switch_to_siso(struct il_priv *il, struct il_lq_sta *lq_sta,
1230  struct ieee80211_conf *conf, struct ieee80211_sta *sta,
1231  struct il_scale_tbl_info *tbl, int idx)
1232 {
1233  u16 rate_mask;
1234  u8 is_green = lq_sta->is_green;
1235  s32 rate;
1236 
1237  if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
1238  return -1;
1239 
1240  D_RATE("LQ: try to switch to SISO\n");
1241 
1242  tbl->is_dup = lq_sta->is_dup;
1243  tbl->lq_type = LQ_SISO;
1244  tbl->action = 0;
1245  tbl->max_search = IL_MAX_SEARCH;
1246  rate_mask = lq_sta->active_siso_rate;
1247 
1248  if (il_is_ht40_tx_allowed(il, &sta->ht_cap))
1249  tbl->is_ht40 = 1;
1250  else
1251  tbl->is_ht40 = 0;
1252 
1253  if (is_green)
1254  tbl->is_SGI = 0; /*11n spec: no SGI in SISO+Greenfield */
1255 
1256  il4965_rs_set_expected_tpt_table(lq_sta, tbl);
1257  rate = il4965_rs_get_best_rate(il, lq_sta, tbl, rate_mask, idx);
1258 
1259  D_RATE("LQ: get best rate %d mask %X\n", rate, rate_mask);
1260  if (rate == RATE_INVALID || !((1 << rate) & rate_mask)) {
1261  D_RATE("can not switch with idx %d rate mask %x\n", rate,
1262  rate_mask);
1263  return -1;
1264  }
1265  tbl->current_rate =
1266  il4965_rate_n_flags_from_tbl(il, tbl, rate, is_green);
1267  D_RATE("LQ: Switch to new mcs %X idx is green %X\n", tbl->current_rate,
1268  is_green);
1269  return 0;
1270 }
1271 
1272 /*
1273  * Try to switch to new modulation mode from legacy
1274  */
1275 static int
1276 il4965_rs_move_legacy_other(struct il_priv *il, struct il_lq_sta *lq_sta,
1277  struct ieee80211_conf *conf,
1278  struct ieee80211_sta *sta, int idx)
1279 {
1280  struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1281  struct il_scale_tbl_info *search_tbl =
1282  &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1283  struct il_rate_scale_data *win = &(tbl->win[idx]);
1284  u32 sz =
1285  (sizeof(struct il_scale_tbl_info) -
1286  (sizeof(struct il_rate_scale_data) * RATE_COUNT));
1287  u8 start_action;
1288  u8 valid_tx_ant = il->hw_params.valid_tx_ant;
1289  u8 tx_chains_num = il->hw_params.tx_chains_num;
1290  int ret = 0;
1291  u8 update_search_tbl_counter = 0;
1292 
1293  tbl->action = IL_LEGACY_SWITCH_SISO;
1294 
1295  start_action = tbl->action;
1296  for (;;) {
1297  lq_sta->action_counter++;
1298  switch (tbl->action) {
1299  case IL_LEGACY_SWITCH_ANTENNA1:
1300  case IL_LEGACY_SWITCH_ANTENNA2:
1301  D_RATE("LQ: Legacy toggle Antenna\n");
1302 
1303  if ((tbl->action == IL_LEGACY_SWITCH_ANTENNA1 &&
1304  tx_chains_num <= 1) ||
1305  (tbl->action == IL_LEGACY_SWITCH_ANTENNA2 &&
1306  tx_chains_num <= 2))
1307  break;
1308 
1309  /* Don't change antenna if success has been great */
1310  if (win->success_ratio >= IL_RS_GOOD_RATIO)
1311  break;
1312 
1313  /* Set up search table to try other antenna */
1314  memcpy(search_tbl, tbl, sz);
1315 
1316  if (il4965_rs_toggle_antenna
1317  (valid_tx_ant, &search_tbl->current_rate,
1318  search_tbl)) {
1319  update_search_tbl_counter = 1;
1320  il4965_rs_set_expected_tpt_table(lq_sta,
1321  search_tbl);
1322  goto out;
1323  }
1324  break;
1325  case IL_LEGACY_SWITCH_SISO:
1326  D_RATE("LQ: Legacy switch to SISO\n");
1327 
1328  /* Set up search table to try SISO */
1329  memcpy(search_tbl, tbl, sz);
1330  search_tbl->is_SGI = 0;
1331  ret =
1332  il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
1333  search_tbl, idx);
1334  if (!ret) {
1335  lq_sta->action_counter = 0;
1336  goto out;
1337  }
1338 
1339  break;
1340  case IL_LEGACY_SWITCH_MIMO2_AB:
1341  case IL_LEGACY_SWITCH_MIMO2_AC:
1342  case IL_LEGACY_SWITCH_MIMO2_BC:
1343  D_RATE("LQ: Legacy switch to MIMO2\n");
1344 
1345  /* Set up search table to try MIMO */
1346  memcpy(search_tbl, tbl, sz);
1347  search_tbl->is_SGI = 0;
1348 
1349  if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AB)
1350  search_tbl->ant_type = ANT_AB;
1351  else if (tbl->action == IL_LEGACY_SWITCH_MIMO2_AC)
1352  search_tbl->ant_type = ANT_AC;
1353  else
1354  search_tbl->ant_type = ANT_BC;
1355 
1356  if (!il4965_rs_is_valid_ant
1357  (valid_tx_ant, search_tbl->ant_type))
1358  break;
1359 
1360  ret =
1361  il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
1362  search_tbl, idx);
1363  if (!ret) {
1364  lq_sta->action_counter = 0;
1365  goto out;
1366  }
1367  break;
1368  }
1369  tbl->action++;
1370  if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
1371  tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
1372 
1373  if (tbl->action == start_action)
1374  break;
1375 
1376  }
1377  search_tbl->lq_type = LQ_NONE;
1378  return 0;
1379 
1380 out:
1381  lq_sta->search_better_tbl = 1;
1382  tbl->action++;
1383  if (tbl->action > IL_LEGACY_SWITCH_MIMO2_BC)
1384  tbl->action = IL_LEGACY_SWITCH_ANTENNA1;
1385  if (update_search_tbl_counter)
1386  search_tbl->action = tbl->action;
1387  return 0;
1388 
1389 }
1390 
1391 /*
1392  * Try to switch to new modulation mode from SISO
1393  */
1394 static int
1395 il4965_rs_move_siso_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
1396  struct ieee80211_conf *conf,
1397  struct ieee80211_sta *sta, int idx)
1398 {
1399  u8 is_green = lq_sta->is_green;
1400  struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1401  struct il_scale_tbl_info *search_tbl =
1402  &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1403  struct il_rate_scale_data *win = &(tbl->win[idx]);
1404  struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1405  u32 sz =
1406  (sizeof(struct il_scale_tbl_info) -
1407  (sizeof(struct il_rate_scale_data) * RATE_COUNT));
1408  u8 start_action;
1409  u8 valid_tx_ant = il->hw_params.valid_tx_ant;
1410  u8 tx_chains_num = il->hw_params.tx_chains_num;
1411  u8 update_search_tbl_counter = 0;
1412  int ret;
1413 
1414  start_action = tbl->action;
1415 
1416  for (;;) {
1417  lq_sta->action_counter++;
1418  switch (tbl->action) {
1419  case IL_SISO_SWITCH_ANTENNA1:
1420  case IL_SISO_SWITCH_ANTENNA2:
1421  D_RATE("LQ: SISO toggle Antenna\n");
1422  if ((tbl->action == IL_SISO_SWITCH_ANTENNA1 &&
1423  tx_chains_num <= 1) ||
1424  (tbl->action == IL_SISO_SWITCH_ANTENNA2 &&
1425  tx_chains_num <= 2))
1426  break;
1427 
1428  if (win->success_ratio >= IL_RS_GOOD_RATIO)
1429  break;
1430 
1431  memcpy(search_tbl, tbl, sz);
1432  if (il4965_rs_toggle_antenna
1433  (valid_tx_ant, &search_tbl->current_rate,
1434  search_tbl)) {
1435  update_search_tbl_counter = 1;
1436  goto out;
1437  }
1438  break;
1439  case IL_SISO_SWITCH_MIMO2_AB:
1440  case IL_SISO_SWITCH_MIMO2_AC:
1441  case IL_SISO_SWITCH_MIMO2_BC:
1442  D_RATE("LQ: SISO switch to MIMO2\n");
1443  memcpy(search_tbl, tbl, sz);
1444  search_tbl->is_SGI = 0;
1445 
1446  if (tbl->action == IL_SISO_SWITCH_MIMO2_AB)
1447  search_tbl->ant_type = ANT_AB;
1448  else if (tbl->action == IL_SISO_SWITCH_MIMO2_AC)
1449  search_tbl->ant_type = ANT_AC;
1450  else
1451  search_tbl->ant_type = ANT_BC;
1452 
1453  if (!il4965_rs_is_valid_ant
1454  (valid_tx_ant, search_tbl->ant_type))
1455  break;
1456 
1457  ret =
1458  il4965_rs_switch_to_mimo2(il, lq_sta, conf, sta,
1459  search_tbl, idx);
1460  if (!ret)
1461  goto out;
1462  break;
1463  case IL_SISO_SWITCH_GI:
1464  if (!tbl->is_ht40 &&
1465  !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
1466  break;
1467  if (tbl->is_ht40 &&
1468  !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
1469  break;
1470 
1471  D_RATE("LQ: SISO toggle SGI/NGI\n");
1472 
1473  memcpy(search_tbl, tbl, sz);
1474  if (is_green) {
1475  if (!tbl->is_SGI)
1476  break;
1477  else
1478  IL_ERR("SGI was set in GF+SISO\n");
1479  }
1480  search_tbl->is_SGI = !tbl->is_SGI;
1481  il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
1482  if (tbl->is_SGI) {
1483  s32 tpt = lq_sta->last_tpt / 100;
1484  if (tpt >= search_tbl->expected_tpt[idx])
1485  break;
1486  }
1487  search_tbl->current_rate =
1488  il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
1489  is_green);
1490  update_search_tbl_counter = 1;
1491  goto out;
1492  }
1493  tbl->action++;
1494  if (tbl->action > IL_SISO_SWITCH_GI)
1495  tbl->action = IL_SISO_SWITCH_ANTENNA1;
1496 
1497  if (tbl->action == start_action)
1498  break;
1499  }
1500  search_tbl->lq_type = LQ_NONE;
1501  return 0;
1502 
1503 out:
1504  lq_sta->search_better_tbl = 1;
1505  tbl->action++;
1506  if (tbl->action > IL_SISO_SWITCH_GI)
1507  tbl->action = IL_SISO_SWITCH_ANTENNA1;
1508  if (update_search_tbl_counter)
1509  search_tbl->action = tbl->action;
1510 
1511  return 0;
1512 }
1513 
1514 /*
1515  * Try to switch to new modulation mode from MIMO2
1516  */
1517 static int
1518 il4965_rs_move_mimo2_to_other(struct il_priv *il, struct il_lq_sta *lq_sta,
1519  struct ieee80211_conf *conf,
1520  struct ieee80211_sta *sta, int idx)
1521 {
1522  s8 is_green = lq_sta->is_green;
1523  struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1524  struct il_scale_tbl_info *search_tbl =
1525  &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
1526  struct il_rate_scale_data *win = &(tbl->win[idx]);
1527  struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1528  u32 sz =
1529  (sizeof(struct il_scale_tbl_info) -
1530  (sizeof(struct il_rate_scale_data) * RATE_COUNT));
1531  u8 start_action;
1532  u8 valid_tx_ant = il->hw_params.valid_tx_ant;
1533  u8 tx_chains_num = il->hw_params.tx_chains_num;
1534  u8 update_search_tbl_counter = 0;
1535  int ret;
1536 
1537  start_action = tbl->action;
1538  for (;;) {
1539  lq_sta->action_counter++;
1540  switch (tbl->action) {
1541  case IL_MIMO2_SWITCH_ANTENNA1:
1542  case IL_MIMO2_SWITCH_ANTENNA2:
1543  D_RATE("LQ: MIMO2 toggle Antennas\n");
1544 
1545  if (tx_chains_num <= 2)
1546  break;
1547 
1548  if (win->success_ratio >= IL_RS_GOOD_RATIO)
1549  break;
1550 
1551  memcpy(search_tbl, tbl, sz);
1552  if (il4965_rs_toggle_antenna
1553  (valid_tx_ant, &search_tbl->current_rate,
1554  search_tbl)) {
1555  update_search_tbl_counter = 1;
1556  goto out;
1557  }
1558  break;
1559  case IL_MIMO2_SWITCH_SISO_A:
1560  case IL_MIMO2_SWITCH_SISO_B:
1561  case IL_MIMO2_SWITCH_SISO_C:
1562  D_RATE("LQ: MIMO2 switch to SISO\n");
1563 
1564  /* Set up new search table for SISO */
1565  memcpy(search_tbl, tbl, sz);
1566 
1567  if (tbl->action == IL_MIMO2_SWITCH_SISO_A)
1568  search_tbl->ant_type = ANT_A;
1569  else if (tbl->action == IL_MIMO2_SWITCH_SISO_B)
1570  search_tbl->ant_type = ANT_B;
1571  else
1572  search_tbl->ant_type = ANT_C;
1573 
1574  if (!il4965_rs_is_valid_ant
1575  (valid_tx_ant, search_tbl->ant_type))
1576  break;
1577 
1578  ret =
1579  il4965_rs_switch_to_siso(il, lq_sta, conf, sta,
1580  search_tbl, idx);
1581  if (!ret)
1582  goto out;
1583 
1584  break;
1585 
1586  case IL_MIMO2_SWITCH_GI:
1587  if (!tbl->is_ht40 &&
1588  !(ht_cap->cap & IEEE80211_HT_CAP_SGI_20))
1589  break;
1590  if (tbl->is_ht40 &&
1591  !(ht_cap->cap & IEEE80211_HT_CAP_SGI_40))
1592  break;
1593 
1594  D_RATE("LQ: MIMO2 toggle SGI/NGI\n");
1595 
1596  /* Set up new search table for MIMO2 */
1597  memcpy(search_tbl, tbl, sz);
1598  search_tbl->is_SGI = !tbl->is_SGI;
1599  il4965_rs_set_expected_tpt_table(lq_sta, search_tbl);
1600  /*
1601  * If active table already uses the fastest possible
1602  * modulation (dual stream with short guard interval),
1603  * and it's working well, there's no need to look
1604  * for a better type of modulation!
1605  */
1606  if (tbl->is_SGI) {
1607  s32 tpt = lq_sta->last_tpt / 100;
1608  if (tpt >= search_tbl->expected_tpt[idx])
1609  break;
1610  }
1611  search_tbl->current_rate =
1612  il4965_rate_n_flags_from_tbl(il, search_tbl, idx,
1613  is_green);
1614  update_search_tbl_counter = 1;
1615  goto out;
1616 
1617  }
1618  tbl->action++;
1619  if (tbl->action > IL_MIMO2_SWITCH_GI)
1620  tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
1621 
1622  if (tbl->action == start_action)
1623  break;
1624  }
1625  search_tbl->lq_type = LQ_NONE;
1626  return 0;
1627 out:
1628  lq_sta->search_better_tbl = 1;
1629  tbl->action++;
1630  if (tbl->action > IL_MIMO2_SWITCH_GI)
1631  tbl->action = IL_MIMO2_SWITCH_ANTENNA1;
1632  if (update_search_tbl_counter)
1633  search_tbl->action = tbl->action;
1634 
1635  return 0;
1636 
1637 }
1638 
1639 /*
1640  * Check whether we should continue using same modulation mode, or
1641  * begin search for a new mode, based on:
1642  * 1) # tx successes or failures while using this mode
1643  * 2) # times calling this function
1644  * 3) elapsed time in this mode (not used, for now)
1645  */
1646 static void
1647 il4965_rs_stay_in_table(struct il_lq_sta *lq_sta, bool force_search)
1648 {
1649  struct il_scale_tbl_info *tbl;
1650  int i;
1651  int active_tbl;
1652  int flush_interval_passed = 0;
1653  struct il_priv *il;
1654 
1655  il = lq_sta->drv;
1656  active_tbl = lq_sta->active_tbl;
1657 
1658  tbl = &(lq_sta->lq_info[active_tbl]);
1659 
1660  /* If we've been disallowing search, see if we should now allow it */
1661  if (lq_sta->stay_in_tbl) {
1662 
1663  /* Elapsed time using current modulation mode */
1664  if (lq_sta->flush_timer)
1665  flush_interval_passed =
1666  time_after(jiffies,
1667  (unsigned long)(lq_sta->flush_timer +
1668  RATE_SCALE_FLUSH_INTVL));
1669 
1670  /*
1671  * Check if we should allow search for new modulation mode.
1672  * If many frames have failed or succeeded, or we've used
1673  * this same modulation for a long time, allow search, and
1674  * reset history stats that keep track of whether we should
1675  * allow a new search. Also (below) reset all bitmaps and
1676  * stats in active history.
1677  */
1678  if (force_search ||
1679  lq_sta->total_failed > lq_sta->max_failure_limit ||
1680  lq_sta->total_success > lq_sta->max_success_limit ||
1681  (!lq_sta->search_better_tbl && lq_sta->flush_timer &&
1682  flush_interval_passed)) {
1683  D_RATE("LQ: stay is expired %d %d %d\n:",
1684  lq_sta->total_failed, lq_sta->total_success,
1685  flush_interval_passed);
1686 
1687  /* Allow search for new mode */
1688  lq_sta->stay_in_tbl = 0; /* only place reset */
1689  lq_sta->total_failed = 0;
1690  lq_sta->total_success = 0;
1691  lq_sta->flush_timer = 0;
1692 
1693  /*
1694  * Else if we've used this modulation mode enough repetitions
1695  * (regardless of elapsed time or success/failure), reset
1696  * history bitmaps and rate-specific stats for all rates in
1697  * active table.
1698  */
1699  } else {
1700  lq_sta->table_count++;
1701  if (lq_sta->table_count >= lq_sta->table_count_limit) {
1702  lq_sta->table_count = 0;
1703 
1704  D_RATE("LQ: stay in table clear win\n");
1705  for (i = 0; i < RATE_COUNT; i++)
1706  il4965_rs_rate_scale_clear_win(&
1707  (tbl->
1708  win
1709  [i]));
1710  }
1711  }
1712 
1713  /* If transitioning to allow "search", reset all history
1714  * bitmaps and stats in active table (this will become the new
1715  * "search" table). */
1716  if (!lq_sta->stay_in_tbl) {
1717  for (i = 0; i < RATE_COUNT; i++)
1718  il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
1719  }
1720  }
1721 }
1722 
1723 /*
1724  * setup rate table in uCode
1725  */
1726 static void
1727 il4965_rs_update_rate_tbl(struct il_priv *il, struct il_lq_sta *lq_sta,
1728  struct il_scale_tbl_info *tbl, int idx, u8 is_green)
1729 {
1730  u32 rate;
1731 
1732  /* Update uCode's rate table. */
1733  rate = il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
1734  il4965_rs_fill_link_cmd(il, lq_sta, rate);
1735  il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
1736 }
1737 
1738 /*
1739  * Do rate scaling and search for new modulation mode.
1740  */
1741 static void
1742 il4965_rs_rate_scale_perform(struct il_priv *il, struct sk_buff *skb,
1743  struct ieee80211_sta *sta,
1744  struct il_lq_sta *lq_sta)
1745 {
1746  struct ieee80211_hw *hw = il->hw;
1747  struct ieee80211_conf *conf = &hw->conf;
1748  struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1749  struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1750  int low = RATE_INVALID;
1751  int high = RATE_INVALID;
1752  int idx;
1753  int i;
1754  struct il_rate_scale_data *win = NULL;
1755  int current_tpt = IL_INVALID_VALUE;
1756  int low_tpt = IL_INVALID_VALUE;
1757  int high_tpt = IL_INVALID_VALUE;
1758  u32 fail_count;
1759  s8 scale_action = 0;
1760  u16 rate_mask;
1761  u8 update_lq = 0;
1762  struct il_scale_tbl_info *tbl, *tbl1;
1763  u16 rate_scale_idx_msk = 0;
1764  u8 is_green = 0;
1765  u8 active_tbl = 0;
1766  u8 done_search = 0;
1767  u16 high_low;
1768  s32 sr;
1769  u8 tid = MAX_TID_COUNT;
1770  struct il_tid_data *tid_data;
1771 
1772  D_RATE("rate scale calculate new rate for skb\n");
1773 
1774  /* Send management frames and NO_ACK data using lowest rate. */
1775  /* TODO: this could probably be improved.. */
1776  if (!ieee80211_is_data(hdr->frame_control) ||
1777  (info->flags & IEEE80211_TX_CTL_NO_ACK))
1778  return;
1779 
1780  lq_sta->supp_rates = sta->supp_rates[lq_sta->band];
1781 
1782  tid = il4965_rs_tl_add_packet(lq_sta, hdr);
1783  if (tid != MAX_TID_COUNT && (lq_sta->tx_agg_tid_en & (1 << tid))) {
1784  tid_data = &il->stations[lq_sta->lq.sta_id].tid[tid];
1785  if (tid_data->agg.state == IL_AGG_OFF)
1786  lq_sta->is_agg = 0;
1787  else
1788  lq_sta->is_agg = 1;
1789  } else
1790  lq_sta->is_agg = 0;
1791 
1792  /*
1793  * Select rate-scale / modulation-mode table to work with in
1794  * the rest of this function: "search" if searching for better
1795  * modulation mode, or "active" if doing rate scaling within a mode.
1796  */
1797  if (!lq_sta->search_better_tbl)
1798  active_tbl = lq_sta->active_tbl;
1799  else
1800  active_tbl = 1 - lq_sta->active_tbl;
1801 
1802  tbl = &(lq_sta->lq_info[active_tbl]);
1803  if (is_legacy(tbl->lq_type))
1804  lq_sta->is_green = 0;
1805  else
1806  lq_sta->is_green = il4965_rs_use_green(il, sta);
1807  is_green = lq_sta->is_green;
1808 
1809  /* current tx rate */
1810  idx = lq_sta->last_txrate_idx;
1811 
1812  D_RATE("Rate scale idx %d for type %d\n", idx, tbl->lq_type);
1813 
1814  /* rates available for this association, and for modulation mode */
1815  rate_mask = il4965_rs_get_supported_rates(lq_sta, hdr, tbl->lq_type);
1816 
1817  D_RATE("mask 0x%04X\n", rate_mask);
1818 
1819  /* mask with station rate restriction */
1820  if (is_legacy(tbl->lq_type)) {
1821  if (lq_sta->band == IEEE80211_BAND_5GHZ)
1822  /* supp_rates has no CCK bits in A mode */
1823  rate_scale_idx_msk =
1824  (u16) (rate_mask &
1825  (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
1826  else
1827  rate_scale_idx_msk =
1828  (u16) (rate_mask & lq_sta->supp_rates);
1829 
1830  } else
1831  rate_scale_idx_msk = rate_mask;
1832 
1833  if (!rate_scale_idx_msk)
1834  rate_scale_idx_msk = rate_mask;
1835 
1836  if (!((1 << idx) & rate_scale_idx_msk)) {
1837  IL_ERR("Current Rate is not valid\n");
1838  if (lq_sta->search_better_tbl) {
1839  /* revert to active table if search table is not valid */
1840  tbl->lq_type = LQ_NONE;
1841  lq_sta->search_better_tbl = 0;
1842  tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1843  /* get "active" rate info */
1844  idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
1845  il4965_rs_update_rate_tbl(il, lq_sta, tbl, idx,
1846  is_green);
1847  }
1848  return;
1849  }
1850 
1851  /* Get expected throughput table and history win for current rate */
1852  if (!tbl->expected_tpt) {
1853  IL_ERR("tbl->expected_tpt is NULL\n");
1854  return;
1855  }
1856 
1857  /* force user max rate if set by user */
1858  if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < idx) {
1859  idx = lq_sta->max_rate_idx;
1860  update_lq = 1;
1861  win = &(tbl->win[idx]);
1862  goto lq_update;
1863  }
1864 
1865  win = &(tbl->win[idx]);
1866 
1867  /*
1868  * If there is not enough history to calculate actual average
1869  * throughput, keep analyzing results of more tx frames, without
1870  * changing rate or mode (bypass most of the rest of this function).
1871  * Set up new rate table in uCode only if old rate is not supported
1872  * in current association (use new rate found above).
1873  */
1874  fail_count = win->counter - win->success_counter;
1875  if (fail_count < RATE_MIN_FAILURE_TH &&
1876  win->success_counter < RATE_MIN_SUCCESS_TH) {
1877  D_RATE("LQ: still below TH. succ=%d total=%d " "for idx %d\n",
1878  win->success_counter, win->counter, idx);
1879 
1880  /* Can't calculate this yet; not enough history */
1881  win->average_tpt = IL_INVALID_VALUE;
1882 
1883  /* Should we stay with this modulation mode,
1884  * or search for a new one? */
1885  il4965_rs_stay_in_table(lq_sta, false);
1886 
1887  goto out;
1888  }
1889  /* Else we have enough samples; calculate estimate of
1890  * actual average throughput */
1891  if (win->average_tpt !=
1892  ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128)) {
1893  IL_ERR("expected_tpt should have been calculated by now\n");
1894  win->average_tpt =
1895  ((win->success_ratio * tbl->expected_tpt[idx] + 64) / 128);
1896  }
1897 
1898  /* If we are searching for better modulation mode, check success. */
1899  if (lq_sta->search_better_tbl) {
1900  /* If good success, continue using the "search" mode;
1901  * no need to send new link quality command, since we're
1902  * continuing to use the setup that we've been trying. */
1903  if (win->average_tpt > lq_sta->last_tpt) {
1904 
1905  D_RATE("LQ: SWITCHING TO NEW TBL "
1906  "suc=%d cur-tpt=%d old-tpt=%d\n",
1907  win->success_ratio, win->average_tpt,
1908  lq_sta->last_tpt);
1909 
1910  if (!is_legacy(tbl->lq_type))
1911  lq_sta->enable_counter = 1;
1912 
1913  /* Swap tables; "search" becomes "active" */
1914  lq_sta->active_tbl = active_tbl;
1915  current_tpt = win->average_tpt;
1916 
1917  /* Else poor success; go back to mode in "active" table */
1918  } else {
1919 
1920  D_RATE("LQ: GOING BACK TO THE OLD TBL "
1921  "suc=%d cur-tpt=%d old-tpt=%d\n",
1922  win->success_ratio, win->average_tpt,
1923  lq_sta->last_tpt);
1924 
1925  /* Nullify "search" table */
1926  tbl->lq_type = LQ_NONE;
1927 
1928  /* Revert to "active" table */
1929  active_tbl = lq_sta->active_tbl;
1930  tbl = &(lq_sta->lq_info[active_tbl]);
1931 
1932  /* Revert to "active" rate and throughput info */
1933  idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
1934  current_tpt = lq_sta->last_tpt;
1935 
1936  /* Need to set up a new rate table in uCode */
1937  update_lq = 1;
1938  }
1939 
1940  /* Either way, we've made a decision; modulation mode
1941  * search is done, allow rate adjustment next time. */
1942  lq_sta->search_better_tbl = 0;
1943  done_search = 1; /* Don't switch modes below! */
1944  goto lq_update;
1945  }
1946 
1947  /* (Else) not in search of better modulation mode, try for better
1948  * starting rate, while staying in this mode. */
1949  high_low =
1950  il4965_rs_get_adjacent_rate(il, idx, rate_scale_idx_msk,
1951  tbl->lq_type);
1952  low = high_low & 0xff;
1953  high = (high_low >> 8) & 0xff;
1954 
1955  /* If user set max rate, dont allow higher than user constrain */
1956  if (lq_sta->max_rate_idx != -1 && lq_sta->max_rate_idx < high)
1957  high = RATE_INVALID;
1958 
1959  sr = win->success_ratio;
1960 
1961  /* Collect measured throughputs for current and adjacent rates */
1962  current_tpt = win->average_tpt;
1963  if (low != RATE_INVALID)
1964  low_tpt = tbl->win[low].average_tpt;
1965  if (high != RATE_INVALID)
1966  high_tpt = tbl->win[high].average_tpt;
1967 
1968  scale_action = 0;
1969 
1970  /* Too many failures, decrease rate */
1971  if (sr <= RATE_DECREASE_TH || current_tpt == 0) {
1972  D_RATE("decrease rate because of low success_ratio\n");
1973  scale_action = -1;
1974 
1975  /* No throughput measured yet for adjacent rates; try increase. */
1976  } else if (low_tpt == IL_INVALID_VALUE && high_tpt == IL_INVALID_VALUE) {
1977 
1978  if (high != RATE_INVALID && sr >= RATE_INCREASE_TH)
1979  scale_action = 1;
1980  else if (low != RATE_INVALID)
1981  scale_action = 0;
1982  }
1983 
1984  /* Both adjacent throughputs are measured, but neither one has better
1985  * throughput; we're using the best rate, don't change it! */
1986  else if (low_tpt != IL_INVALID_VALUE && high_tpt != IL_INVALID_VALUE &&
1987  low_tpt < current_tpt && high_tpt < current_tpt)
1988  scale_action = 0;
1989 
1990  /* At least one adjacent rate's throughput is measured,
1991  * and may have better performance. */
1992  else {
1993  /* Higher adjacent rate's throughput is measured */
1994  if (high_tpt != IL_INVALID_VALUE) {
1995  /* Higher rate has better throughput */
1996  if (high_tpt > current_tpt && sr >= RATE_INCREASE_TH)
1997  scale_action = 1;
1998  else
1999  scale_action = 0;
2000 
2001  /* Lower adjacent rate's throughput is measured */
2002  } else if (low_tpt != IL_INVALID_VALUE) {
2003  /* Lower rate has better throughput */
2004  if (low_tpt > current_tpt) {
2005  D_RATE("decrease rate because of low tpt\n");
2006  scale_action = -1;
2007  } else if (sr >= RATE_INCREASE_TH) {
2008  scale_action = 1;
2009  }
2010  }
2011  }
2012 
2013  /* Sanity check; asked for decrease, but success rate or throughput
2014  * has been good at old rate. Don't change it. */
2015  if (scale_action == -1 && low != RATE_INVALID &&
2016  (sr > RATE_HIGH_TH || current_tpt > 100 * tbl->expected_tpt[low]))
2017  scale_action = 0;
2018 
2019  switch (scale_action) {
2020  case -1:
2021  /* Decrease starting rate, update uCode's rate table */
2022  if (low != RATE_INVALID) {
2023  update_lq = 1;
2024  idx = low;
2025  }
2026 
2027  break;
2028  case 1:
2029  /* Increase starting rate, update uCode's rate table */
2030  if (high != RATE_INVALID) {
2031  update_lq = 1;
2032  idx = high;
2033  }
2034 
2035  break;
2036  case 0:
2037  /* No change */
2038  default:
2039  break;
2040  }
2041 
2042  D_RATE("choose rate scale idx %d action %d low %d " "high %d type %d\n",
2043  idx, scale_action, low, high, tbl->lq_type);
2044 
2045 lq_update:
2046  /* Replace uCode's rate table for the destination station. */
2047  if (update_lq)
2048  il4965_rs_update_rate_tbl(il, lq_sta, tbl, idx, is_green);
2049 
2050  /* Should we stay with this modulation mode,
2051  * or search for a new one? */
2052  il4965_rs_stay_in_table(lq_sta, false);
2053 
2054  /*
2055  * Search for new modulation mode if we're:
2056  * 1) Not changing rates right now
2057  * 2) Not just finishing up a search
2058  * 3) Allowing a new search
2059  */
2060  if (!update_lq && !done_search && !lq_sta->stay_in_tbl && win->counter) {
2061  /* Save current throughput to compare with "search" throughput */
2062  lq_sta->last_tpt = current_tpt;
2063 
2064  /* Select a new "search" modulation mode to try.
2065  * If one is found, set up the new "search" table. */
2066  if (is_legacy(tbl->lq_type))
2067  il4965_rs_move_legacy_other(il, lq_sta, conf, sta, idx);
2068  else if (is_siso(tbl->lq_type))
2069  il4965_rs_move_siso_to_other(il, lq_sta, conf, sta,
2070  idx);
2071  else /* (is_mimo2(tbl->lq_type)) */
2072  il4965_rs_move_mimo2_to_other(il, lq_sta, conf, sta,
2073  idx);
2074 
2075  /* If new "search" mode was selected, set up in uCode table */
2076  if (lq_sta->search_better_tbl) {
2077  /* Access the "search" table, clear its history. */
2078  tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
2079  for (i = 0; i < RATE_COUNT; i++)
2080  il4965_rs_rate_scale_clear_win(&(tbl->win[i]));
2081 
2082  /* Use new "search" start rate */
2083  idx = il4965_hwrate_to_plcp_idx(tbl->current_rate);
2084 
2085  D_RATE("Switch current mcs: %X idx: %d\n",
2086  tbl->current_rate, idx);
2087  il4965_rs_fill_link_cmd(il, lq_sta, tbl->current_rate);
2088  il_send_lq_cmd(il, &lq_sta->lq, CMD_ASYNC, false);
2089  } else
2090  done_search = 1;
2091  }
2092 
2093  if (done_search && !lq_sta->stay_in_tbl) {
2094  /* If the "active" (non-search) mode was legacy,
2095  * and we've tried switching antennas,
2096  * but we haven't been able to try HT modes (not available),
2097  * stay with best antenna legacy modulation for a while
2098  * before next round of mode comparisons. */
2099  tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
2100  if (is_legacy(tbl1->lq_type) && !conf_is_ht(conf) &&
2101  lq_sta->action_counter > tbl1->max_search) {
2102  D_RATE("LQ: STAY in legacy table\n");
2103  il4965_rs_set_stay_in_table(il, 1, lq_sta);
2104  }
2105 
2106  /* If we're in an HT mode, and all 3 mode switch actions
2107  * have been tried and compared, stay in this best modulation
2108  * mode for a while before next round of mode comparisons. */
2109  if (lq_sta->enable_counter &&
2110  lq_sta->action_counter >= tbl1->max_search) {
2111  if (lq_sta->last_tpt > IL_AGG_TPT_THREHOLD &&
2112  (lq_sta->tx_agg_tid_en & (1 << tid)) &&
2113  tid != MAX_TID_COUNT) {
2114  tid_data =
2115  &il->stations[lq_sta->lq.sta_id].tid[tid];
2116  if (tid_data->agg.state == IL_AGG_OFF) {
2117  D_RATE("try to aggregate tid %d\n",
2118  tid);
2119  il4965_rs_tl_turn_on_agg(il, tid,
2120  lq_sta, sta);
2121  }
2122  }
2123  il4965_rs_set_stay_in_table(il, 0, lq_sta);
2124  }
2125  }
2126 
2127 out:
2128  tbl->current_rate =
2129  il4965_rate_n_flags_from_tbl(il, tbl, idx, is_green);
2130  i = idx;
2131  lq_sta->last_txrate_idx = i;
2132 }
2133 
2148 static void
2149 il4965_rs_initialize_lq(struct il_priv *il, struct ieee80211_conf *conf,
2150  struct ieee80211_sta *sta, struct il_lq_sta *lq_sta)
2151 {
2152  struct il_scale_tbl_info *tbl;
2153  int rate_idx;
2154  int i;
2155  u32 rate;
2156  u8 use_green = il4965_rs_use_green(il, sta);
2157  u8 active_tbl = 0;
2158  u8 valid_tx_ant;
2159  struct il_station_priv *sta_priv;
2160 
2161  if (!sta || !lq_sta)
2162  return;
2163 
2164  sta_priv = (void *)sta->drv_priv;
2165 
2166  i = lq_sta->last_txrate_idx;
2167 
2168  valid_tx_ant = il->hw_params.valid_tx_ant;
2169 
2170  if (!lq_sta->search_better_tbl)
2171  active_tbl = lq_sta->active_tbl;
2172  else
2173  active_tbl = 1 - lq_sta->active_tbl;
2174 
2175  tbl = &(lq_sta->lq_info[active_tbl]);
2176 
2177  if (i < 0 || i >= RATE_COUNT)
2178  i = 0;
2179 
2180  rate = il_rates[i].plcp;
2181  tbl->ant_type = il4965_first_antenna(valid_tx_ant);
2182  rate |= tbl->ant_type << RATE_MCS_ANT_POS;
2183 
2184  if (i >= IL_FIRST_CCK_RATE && i <= IL_LAST_CCK_RATE)
2185  rate |= RATE_MCS_CCK_MSK;
2186 
2187  il4965_rs_get_tbl_info_from_mcs(rate, il->band, tbl, &rate_idx);
2188  if (!il4965_rs_is_valid_ant(valid_tx_ant, tbl->ant_type))
2189  il4965_rs_toggle_antenna(valid_tx_ant, &rate, tbl);
2190 
2191  rate = il4965_rate_n_flags_from_tbl(il, tbl, rate_idx, use_green);
2192  tbl->current_rate = rate;
2193  il4965_rs_set_expected_tpt_table(lq_sta, tbl);
2194  il4965_rs_fill_link_cmd(NULL, lq_sta, rate);
2195  il->stations[lq_sta->lq.sta_id].lq = &lq_sta->lq;
2196  il_send_lq_cmd(il, &lq_sta->lq, CMD_SYNC, true);
2197 }
2198 
2199 static void
2200 il4965_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
2201  struct ieee80211_tx_rate_control *txrc)
2202 {
2203 
2204  struct sk_buff *skb = txrc->skb;
2205  struct ieee80211_supported_band *sband = txrc->sband;
2206  struct il_priv *il __maybe_unused = (struct il_priv *)il_r;
2207  struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2208  struct il_lq_sta *lq_sta = il_sta;
2209  int rate_idx;
2210 
2211  D_RATE("rate scale calculate new rate for skb\n");
2212 
2213  /* Get max rate if user set max rate */
2214  if (lq_sta) {
2215  lq_sta->max_rate_idx = txrc->max_rate_idx;
2216  if (sband->band == IEEE80211_BAND_5GHZ &&
2217  lq_sta->max_rate_idx != -1)
2218  lq_sta->max_rate_idx += IL_FIRST_OFDM_RATE;
2219  if (lq_sta->max_rate_idx < 0 ||
2220  lq_sta->max_rate_idx >= RATE_COUNT)
2221  lq_sta->max_rate_idx = -1;
2222  }
2223 
2224  /* Treat uninitialized rate scaling data same as non-existing. */
2225  if (lq_sta && !lq_sta->drv) {
2226  D_RATE("Rate scaling not initialized yet.\n");
2227  il_sta = NULL;
2228  }
2229 
2230  /* Send management frames and NO_ACK data using lowest rate. */
2231  if (rate_control_send_low(sta, il_sta, txrc))
2232  return;
2233 
2234  if (!lq_sta)
2235  return;
2236 
2237  rate_idx = lq_sta->last_txrate_idx;
2238 
2239  if (lq_sta->last_rate_n_flags & RATE_MCS_HT_MSK) {
2240  rate_idx -= IL_FIRST_OFDM_RATE;
2241  /* 6M and 9M shared same MCS idx */
2242  rate_idx = (rate_idx > 0) ? (rate_idx - 1) : 0;
2243  if (il4965_rs_extract_rate(lq_sta->last_rate_n_flags) >=
2244  RATE_MIMO2_6M_PLCP)
2245  rate_idx = rate_idx + MCS_IDX_PER_STREAM;
2246  info->control.rates[0].flags = IEEE80211_TX_RC_MCS;
2247  if (lq_sta->last_rate_n_flags & RATE_MCS_SGI_MSK)
2248  info->control.rates[0].flags |=
2249  IEEE80211_TX_RC_SHORT_GI;
2250  if (lq_sta->last_rate_n_flags & RATE_MCS_DUP_MSK)
2251  info->control.rates[0].flags |=
2252  IEEE80211_TX_RC_DUP_DATA;
2253  if (lq_sta->last_rate_n_flags & RATE_MCS_HT40_MSK)
2254  info->control.rates[0].flags |=
2255  IEEE80211_TX_RC_40_MHZ_WIDTH;
2256  if (lq_sta->last_rate_n_flags & RATE_MCS_GF_MSK)
2257  info->control.rates[0].flags |=
2258  IEEE80211_TX_RC_GREEN_FIELD;
2259  } else {
2260  /* Check for invalid rates */
2261  if (rate_idx < 0 || rate_idx >= RATE_COUNT_LEGACY ||
2262  (sband->band == IEEE80211_BAND_5GHZ &&
2263  rate_idx < IL_FIRST_OFDM_RATE))
2264  rate_idx = rate_lowest_index(sband, sta);
2265  /* On valid 5 GHz rate, adjust idx */
2266  else if (sband->band == IEEE80211_BAND_5GHZ)
2267  rate_idx -= IL_FIRST_OFDM_RATE;
2268  info->control.rates[0].flags = 0;
2269  }
2270  info->control.rates[0].idx = rate_idx;
2271 
2272 }
2273 
2274 static void *
2275 il4965_rs_alloc_sta(void *il_rate, struct ieee80211_sta *sta, gfp_t gfp)
2276 {
2277  struct il_station_priv *sta_priv =
2278  (struct il_station_priv *)sta->drv_priv;
2279  struct il_priv *il;
2280 
2281  il = (struct il_priv *)il_rate;
2282  D_RATE("create station rate scale win\n");
2283 
2284  return &sta_priv->lq_sta;
2285 }
2286 
2287 /*
2288  * Called after adding a new station to initialize rate scaling
2289  */
2290 void
2291 il4965_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
2292 {
2293  int i, j;
2294  struct ieee80211_hw *hw = il->hw;
2295  struct ieee80211_conf *conf = &il->hw->conf;
2296  struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2297  struct il_station_priv *sta_priv;
2298  struct il_lq_sta *lq_sta;
2299  struct ieee80211_supported_band *sband;
2300 
2301  sta_priv = (struct il_station_priv *)sta->drv_priv;
2302  lq_sta = &sta_priv->lq_sta;
2303  sband = hw->wiphy->bands[conf->channel->band];
2304 
2305  lq_sta->lq.sta_id = sta_id;
2306 
2307  for (j = 0; j < LQ_SIZE; j++)
2308  for (i = 0; i < RATE_COUNT; i++)
2309  il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
2310  win[i]);
2311 
2312  lq_sta->flush_timer = 0;
2313  lq_sta->supp_rates = sta->supp_rates[sband->band];
2314  for (j = 0; j < LQ_SIZE; j++)
2315  for (i = 0; i < RATE_COUNT; i++)
2316  il4965_rs_rate_scale_clear_win(&lq_sta->lq_info[j].
2317  win[i]);
2318 
2319  D_RATE("LQ:" "*** rate scale station global init for station %d ***\n",
2320  sta_id);
2321  /* TODO: what is a good starting rate for STA? About middle? Maybe not
2322  * the lowest or the highest rate.. Could consider using RSSI from
2323  * previous packets? Need to have IEEE 802.1X auth succeed immediately
2324  * after assoc.. */
2325 
2326  lq_sta->is_dup = 0;
2327  lq_sta->max_rate_idx = -1;
2328  lq_sta->missed_rate_counter = IL_MISSED_RATE_MAX;
2329  lq_sta->is_green = il4965_rs_use_green(il, sta);
2330  lq_sta->active_legacy_rate = il->active_rate & ~(0x1000);
2331  lq_sta->band = il->band;
2332  /*
2333  * active_siso_rate mask includes 9 MBits (bit 5), and CCK (bits 0-3),
2334  * supp_rates[] does not; shift to convert format, force 9 MBits off.
2335  */
2336  lq_sta->active_siso_rate = ht_cap->mcs.rx_mask[0] << 1;
2337  lq_sta->active_siso_rate |= ht_cap->mcs.rx_mask[0] & 0x1;
2338  lq_sta->active_siso_rate &= ~((u16) 0x2);
2339  lq_sta->active_siso_rate <<= IL_FIRST_OFDM_RATE;
2340 
2341  /* Same here */
2342  lq_sta->active_mimo2_rate = ht_cap->mcs.rx_mask[1] << 1;
2343  lq_sta->active_mimo2_rate |= ht_cap->mcs.rx_mask[1] & 0x1;
2344  lq_sta->active_mimo2_rate &= ~((u16) 0x2);
2345  lq_sta->active_mimo2_rate <<= IL_FIRST_OFDM_RATE;
2346 
2347  /* These values will be overridden later */
2348  lq_sta->lq.general_params.single_stream_ant_msk =
2349  il4965_first_antenna(il->hw_params.valid_tx_ant);
2350  lq_sta->lq.general_params.dual_stream_ant_msk =
2351  il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
2352  valid_tx_ant);
2353  if (!lq_sta->lq.general_params.dual_stream_ant_msk) {
2354  lq_sta->lq.general_params.dual_stream_ant_msk = ANT_AB;
2355  } else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
2356  lq_sta->lq.general_params.dual_stream_ant_msk =
2357  il->hw_params.valid_tx_ant;
2358  }
2359 
2360  /* as default allow aggregation for all tids */
2361  lq_sta->tx_agg_tid_en = IL_AGG_ALL_TID;
2362  lq_sta->drv = il;
2363 
2364  /* Set last_txrate_idx to lowest rate */
2365  lq_sta->last_txrate_idx = rate_lowest_index(sband, sta);
2366  if (sband->band == IEEE80211_BAND_5GHZ)
2367  lq_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
2368  lq_sta->is_agg = 0;
2369 
2370 #ifdef CONFIG_MAC80211_DEBUGFS
2371  lq_sta->dbg_fixed_rate = 0;
2372 #endif
2373 
2374  il4965_rs_initialize_lq(il, conf, sta, lq_sta);
2375 }
2376 
2377 static void
2378 il4965_rs_fill_link_cmd(struct il_priv *il, struct il_lq_sta *lq_sta,
2379  u32 new_rate)
2380 {
2381  struct il_scale_tbl_info tbl_type;
2382  int idx = 0;
2383  int rate_idx;
2384  int repeat_rate = 0;
2385  u8 ant_toggle_cnt = 0;
2386  u8 use_ht_possible = 1;
2387  u8 valid_tx_ant = 0;
2388  struct il_link_quality_cmd *lq_cmd = &lq_sta->lq;
2389 
2390  /* Override starting rate (idx 0) if needed for debug purposes */
2391  il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
2392 
2393  /* Interpret new_rate (rate_n_flags) */
2394  il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band, &tbl_type,
2395  &rate_idx);
2396 
2397  /* How many times should we repeat the initial rate? */
2398  if (is_legacy(tbl_type.lq_type)) {
2399  ant_toggle_cnt = 1;
2400  repeat_rate = IL_NUMBER_TRY;
2401  } else {
2402  repeat_rate = IL_HT_NUMBER_TRY;
2403  }
2404 
2405  lq_cmd->general_params.mimo_delimiter =
2406  is_mimo(tbl_type.lq_type) ? 1 : 0;
2407 
2408  /* Fill 1st table entry (idx 0) */
2409  lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
2410 
2411  if (il4965_num_of_ant(tbl_type.ant_type) == 1) {
2412  lq_cmd->general_params.single_stream_ant_msk =
2413  tbl_type.ant_type;
2414  } else if (il4965_num_of_ant(tbl_type.ant_type) == 2) {
2415  lq_cmd->general_params.dual_stream_ant_msk = tbl_type.ant_type;
2416  }
2417  /* otherwise we don't modify the existing value */
2418  idx++;
2419  repeat_rate--;
2420  if (il)
2421  valid_tx_ant = il->hw_params.valid_tx_ant;
2422 
2423  /* Fill rest of rate table */
2424  while (idx < LINK_QUAL_MAX_RETRY_NUM) {
2425  /* Repeat initial/next rate.
2426  * For legacy IL_NUMBER_TRY == 1, this loop will not execute.
2427  * For HT IL_HT_NUMBER_TRY == 3, this executes twice. */
2428  while (repeat_rate > 0 && idx < LINK_QUAL_MAX_RETRY_NUM) {
2429  if (is_legacy(tbl_type.lq_type)) {
2430  if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
2431  ant_toggle_cnt++;
2432  else if (il &&
2433  il4965_rs_toggle_antenna(valid_tx_ant,
2434  &new_rate,
2435  &tbl_type))
2436  ant_toggle_cnt = 1;
2437  }
2438 
2439  /* Override next rate if needed for debug purposes */
2440  il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
2441 
2442  /* Fill next table entry */
2443  lq_cmd->rs_table[idx].rate_n_flags =
2444  cpu_to_le32(new_rate);
2445  repeat_rate--;
2446  idx++;
2447  }
2448 
2449  il4965_rs_get_tbl_info_from_mcs(new_rate, lq_sta->band,
2450  &tbl_type, &rate_idx);
2451 
2452  /* Indicate to uCode which entries might be MIMO.
2453  * If initial rate was MIMO, this will finally end up
2454  * as (IL_HT_NUMBER_TRY * 2), after 2nd pass, otherwise 0. */
2455  if (is_mimo(tbl_type.lq_type))
2456  lq_cmd->general_params.mimo_delimiter = idx;
2457 
2458  /* Get next rate */
2459  new_rate =
2460  il4965_rs_get_lower_rate(lq_sta, &tbl_type, rate_idx,
2461  use_ht_possible);
2462 
2463  /* How many times should we repeat the next rate? */
2464  if (is_legacy(tbl_type.lq_type)) {
2465  if (ant_toggle_cnt < NUM_TRY_BEFORE_ANT_TOGGLE)
2466  ant_toggle_cnt++;
2467  else if (il &&
2468  il4965_rs_toggle_antenna(valid_tx_ant,
2469  &new_rate, &tbl_type))
2470  ant_toggle_cnt = 1;
2471 
2472  repeat_rate = IL_NUMBER_TRY;
2473  } else {
2474  repeat_rate = IL_HT_NUMBER_TRY;
2475  }
2476 
2477  /* Don't allow HT rates after next pass.
2478  * il4965_rs_get_lower_rate() will change type to LQ_A or LQ_G. */
2479  use_ht_possible = 0;
2480 
2481  /* Override next rate if needed for debug purposes */
2482  il4965_rs_dbgfs_set_mcs(lq_sta, &new_rate, idx);
2483 
2484  /* Fill next table entry */
2485  lq_cmd->rs_table[idx].rate_n_flags = cpu_to_le32(new_rate);
2486 
2487  idx++;
2488  repeat_rate--;
2489  }
2490 
2491  lq_cmd->agg_params.agg_frame_cnt_limit = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
2492  lq_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
2493 
2494  lq_cmd->agg_params.agg_time_limit =
2495  cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
2496 }
2497 
2498 static void *
2499 il4965_rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
2500 {
2501  return hw->priv;
2502 }
2503 
2504 /* rate scale requires free function to be implemented */
2505 static void
2506 il4965_rs_free(void *il_rate)
2507 {
2508  return;
2509 }
2510 
2511 static void
2512 il4965_rs_free_sta(void *il_r, struct ieee80211_sta *sta, void *il_sta)
2513 {
2514  struct il_priv *il __maybe_unused = il_r;
2515 
2516  D_RATE("enter\n");
2517  D_RATE("leave\n");
2518 }
2519 
2520 #ifdef CONFIG_MAC80211_DEBUGFS
2521 
2522 static void
2523 il4965_rs_dbgfs_set_mcs(struct il_lq_sta *lq_sta, u32 * rate_n_flags, int idx)
2524 {
2525  struct il_priv *il;
2526  u8 valid_tx_ant;
2527  u8 ant_sel_tx;
2528 
2529  il = lq_sta->drv;
2530  valid_tx_ant = il->hw_params.valid_tx_ant;
2531  if (lq_sta->dbg_fixed_rate) {
2532  ant_sel_tx =
2533  ((lq_sta->
2534  dbg_fixed_rate & RATE_MCS_ANT_ABC_MSK) >>
2535  RATE_MCS_ANT_POS);
2536  if ((valid_tx_ant & ant_sel_tx) == ant_sel_tx) {
2537  *rate_n_flags = lq_sta->dbg_fixed_rate;
2538  D_RATE("Fixed rate ON\n");
2539  } else {
2540  lq_sta->dbg_fixed_rate = 0;
2541  IL_ERR
2542  ("Invalid antenna selection 0x%X, Valid is 0x%X\n",
2543  ant_sel_tx, valid_tx_ant);
2544  D_RATE("Fixed rate OFF\n");
2545  }
2546  } else {
2547  D_RATE("Fixed rate OFF\n");
2548  }
2549 }
2550 
2551 static ssize_t
2552 il4965_rs_sta_dbgfs_scale_table_write(struct file *file,
2553  const char __user *user_buf,
2554  size_t count, loff_t *ppos)
2555 {
2556  struct il_lq_sta *lq_sta = file->private_data;
2557  struct il_priv *il;
2558  char buf[64];
2559  size_t buf_size;
2560  u32 parsed_rate;
2561 
2562  il = lq_sta->drv;
2563  memset(buf, 0, sizeof(buf));
2564  buf_size = min(count, sizeof(buf) - 1);
2565  if (copy_from_user(buf, user_buf, buf_size))
2566  return -EFAULT;
2567 
2568  if (sscanf(buf, "%x", &parsed_rate) == 1)
2569  lq_sta->dbg_fixed_rate = parsed_rate;
2570  else
2571  lq_sta->dbg_fixed_rate = 0;
2572 
2573  lq_sta->active_legacy_rate = 0x0FFF; /* 1 - 54 MBits, includes CCK */
2574  lq_sta->active_siso_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
2575  lq_sta->active_mimo2_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
2576 
2577  D_RATE("sta_id %d rate 0x%X\n", lq_sta->lq.sta_id,
2578  lq_sta->dbg_fixed_rate);
2579 
2580  if (lq_sta->dbg_fixed_rate) {
2581  il4965_rs_fill_link_cmd(NULL, lq_sta, lq_sta->dbg_fixed_rate);
2582  il_send_lq_cmd(lq_sta->drv, &lq_sta->lq, CMD_ASYNC, false);
2583  }
2584 
2585  return count;
2586 }
2587 
2588 static ssize_t
2589 il4965_rs_sta_dbgfs_scale_table_read(struct file *file, char __user *user_buf,
2590  size_t count, loff_t *ppos)
2591 {
2592  char *buff;
2593  int desc = 0;
2594  int i = 0;
2595  int idx = 0;
2596  ssize_t ret;
2597 
2598  struct il_lq_sta *lq_sta = file->private_data;
2599  struct il_priv *il;
2600  struct il_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
2601 
2602  il = lq_sta->drv;
2603  buff = kmalloc(1024, GFP_KERNEL);
2604  if (!buff)
2605  return -ENOMEM;
2606 
2607  desc += sprintf(buff + desc, "sta_id %d\n", lq_sta->lq.sta_id);
2608  desc +=
2609  sprintf(buff + desc, "failed=%d success=%d rate=0%X\n",
2610  lq_sta->total_failed, lq_sta->total_success,
2611  lq_sta->active_legacy_rate);
2612  desc +=
2613  sprintf(buff + desc, "fixed rate 0x%X\n", lq_sta->dbg_fixed_rate);
2614  desc +=
2615  sprintf(buff + desc, "valid_tx_ant %s%s%s\n",
2616  (il->hw_params.valid_tx_ant & ANT_A) ? "ANT_A," : "",
2617  (il->hw_params.valid_tx_ant & ANT_B) ? "ANT_B," : "",
2618  (il->hw_params.valid_tx_ant & ANT_C) ? "ANT_C" : "");
2619  desc +=
2620  sprintf(buff + desc, "lq type %s\n",
2621  (is_legacy(tbl->lq_type)) ? "legacy" : "HT");
2622  if (is_Ht(tbl->lq_type)) {
2623  desc +=
2624  sprintf(buff + desc, " %s",
2625  (is_siso(tbl->lq_type)) ? "SISO" : "MIMO2");
2626  desc +=
2627  sprintf(buff + desc, " %s",
2628  (tbl->is_ht40) ? "40MHz" : "20MHz");
2629  desc +=
2630  sprintf(buff + desc, " %s %s %s\n",
2631  (tbl->is_SGI) ? "SGI" : "",
2632  (lq_sta->is_green) ? "GF enabled" : "",
2633  (lq_sta->is_agg) ? "AGG on" : "");
2634  }
2635  desc +=
2636  sprintf(buff + desc, "last tx rate=0x%X\n",
2637  lq_sta->last_rate_n_flags);
2638  desc +=
2639  sprintf(buff + desc,
2640  "general:" "flags=0x%X mimo-d=%d s-ant0x%x d-ant=0x%x\n",
2641  lq_sta->lq.general_params.flags,
2642  lq_sta->lq.general_params.mimo_delimiter,
2643  lq_sta->lq.general_params.single_stream_ant_msk,
2644  lq_sta->lq.general_params.dual_stream_ant_msk);
2645 
2646  desc +=
2647  sprintf(buff + desc,
2648  "agg:"
2649  "time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
2650  le16_to_cpu(lq_sta->lq.agg_params.agg_time_limit),
2651  lq_sta->lq.agg_params.agg_dis_start_th,
2652  lq_sta->lq.agg_params.agg_frame_cnt_limit);
2653 
2654  desc +=
2655  sprintf(buff + desc,
2656  "Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
2657  lq_sta->lq.general_params.start_rate_idx[0],
2658  lq_sta->lq.general_params.start_rate_idx[1],
2659  lq_sta->lq.general_params.start_rate_idx[2],
2660  lq_sta->lq.general_params.start_rate_idx[3]);
2661 
2662  for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
2663  idx =
2664  il4965_hwrate_to_plcp_idx(le32_to_cpu
2665  (lq_sta->lq.rs_table[i].
2666  rate_n_flags));
2667  if (is_legacy(tbl->lq_type)) {
2668  desc +=
2669  sprintf(buff + desc, " rate[%d] 0x%X %smbps\n", i,
2670  le32_to_cpu(lq_sta->lq.rs_table[i].
2671  rate_n_flags),
2672  il_rate_mcs[idx].mbps);
2673  } else {
2674  desc +=
2675  sprintf(buff + desc, " rate[%d] 0x%X %smbps (%s)\n",
2676  i,
2677  le32_to_cpu(lq_sta->lq.rs_table[i].
2678  rate_n_flags),
2679  il_rate_mcs[idx].mbps,
2680  il_rate_mcs[idx].mcs);
2681  }
2682  }
2683 
2684  ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
2685  kfree(buff);
2686  return ret;
2687 }
2688 
2689 static const struct file_operations rs_sta_dbgfs_scale_table_ops = {
2690  .write = il4965_rs_sta_dbgfs_scale_table_write,
2691  .read = il4965_rs_sta_dbgfs_scale_table_read,
2692  .open = simple_open,
2693  .llseek = default_llseek,
2694 };
2695 
2696 static ssize_t
2697 il4965_rs_sta_dbgfs_stats_table_read(struct file *file, char __user *user_buf,
2698  size_t count, loff_t *ppos)
2699 {
2700  char *buff;
2701  int desc = 0;
2702  int i, j;
2703  ssize_t ret;
2704 
2705  struct il_lq_sta *lq_sta = file->private_data;
2706 
2707  buff = kmalloc(1024, GFP_KERNEL);
2708  if (!buff)
2709  return -ENOMEM;
2710 
2711  for (i = 0; i < LQ_SIZE; i++) {
2712  desc +=
2713  sprintf(buff + desc,
2714  "%s type=%d SGI=%d HT40=%d DUP=%d GF=%d\n"
2715  "rate=0x%X\n", lq_sta->active_tbl == i ? "*" : "x",
2716  lq_sta->lq_info[i].lq_type,
2717  lq_sta->lq_info[i].is_SGI,
2718  lq_sta->lq_info[i].is_ht40,
2719  lq_sta->lq_info[i].is_dup, lq_sta->is_green,
2720  lq_sta->lq_info[i].current_rate);
2721  for (j = 0; j < RATE_COUNT; j++) {
2722  desc +=
2723  sprintf(buff + desc,
2724  "counter=%d success=%d %%=%d\n",
2725  lq_sta->lq_info[i].win[j].counter,
2726  lq_sta->lq_info[i].win[j].success_counter,
2727  lq_sta->lq_info[i].win[j].success_ratio);
2728  }
2729  }
2730  ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
2731  kfree(buff);
2732  return ret;
2733 }
2734 
2735 static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
2736  .read = il4965_rs_sta_dbgfs_stats_table_read,
2737  .open = simple_open,
2738  .llseek = default_llseek,
2739 };
2740 
2741 static ssize_t
2742 il4965_rs_sta_dbgfs_rate_scale_data_read(struct file *file,
2743  char __user *user_buf, size_t count,
2744  loff_t *ppos)
2745 {
2746  char buff[120];
2747  int desc = 0;
2748  struct il_lq_sta *lq_sta = file->private_data;
2749  struct il_scale_tbl_info *tbl = &lq_sta->lq_info[lq_sta->active_tbl];
2750 
2751  if (is_Ht(tbl->lq_type))
2752  desc +=
2753  sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
2754  tbl->expected_tpt[lq_sta->last_txrate_idx]);
2755  else
2756  desc +=
2757  sprintf(buff + desc, "Bit Rate= %d Mb/s\n",
2758  il_rates[lq_sta->last_txrate_idx].ieee >> 1);
2759 
2760  return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
2761 }
2762 
2763 static const struct file_operations rs_sta_dbgfs_rate_scale_data_ops = {
2764  .read = il4965_rs_sta_dbgfs_rate_scale_data_read,
2765  .open = simple_open,
2766  .llseek = default_llseek,
2767 };
2768 
2769 static void
2770 il4965_rs_add_debugfs(void *il, void *il_sta, struct dentry *dir)
2771 {
2772  struct il_lq_sta *lq_sta = il_sta;
2773  lq_sta->rs_sta_dbgfs_scale_table_file =
2774  debugfs_create_file("rate_scale_table", S_IRUSR | S_IWUSR, dir,
2775  lq_sta, &rs_sta_dbgfs_scale_table_ops);
2776  lq_sta->rs_sta_dbgfs_stats_table_file =
2777  debugfs_create_file("rate_stats_table", S_IRUSR, dir, lq_sta,
2778  &rs_sta_dbgfs_stats_table_ops);
2779  lq_sta->rs_sta_dbgfs_rate_scale_data_file =
2780  debugfs_create_file("rate_scale_data", S_IRUSR, dir, lq_sta,
2781  &rs_sta_dbgfs_rate_scale_data_ops);
2782  lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file =
2783  debugfs_create_u8("tx_agg_tid_enable", S_IRUSR | S_IWUSR, dir,
2784  &lq_sta->tx_agg_tid_en);
2785 
2786 }
2787 
2788 static void
2789 il4965_rs_remove_debugfs(void *il, void *il_sta)
2790 {
2791  struct il_lq_sta *lq_sta = il_sta;
2792  debugfs_remove(lq_sta->rs_sta_dbgfs_scale_table_file);
2793  debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
2794  debugfs_remove(lq_sta->rs_sta_dbgfs_rate_scale_data_file);
2795  debugfs_remove(lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file);
2796 }
2797 #endif
2798 
2799 /*
2800  * Initialization of rate scaling information is done by driver after
2801  * the station is added. Since mac80211 calls this function before a
2802  * station is added we ignore it.
2803  */
2804 static void
2805 il4965_rs_rate_init_stub(void *il_r, struct ieee80211_supported_band *sband,
2806  struct ieee80211_sta *sta, void *il_sta)
2807 {
2808 }
2809 
2810 static struct rate_control_ops rs_4965_ops = {
2811  .module = NULL,
2812  .name = IL4965_RS_NAME,
2813  .tx_status = il4965_rs_tx_status,
2814  .get_rate = il4965_rs_get_rate,
2815  .rate_init = il4965_rs_rate_init_stub,
2816  .alloc = il4965_rs_alloc,
2817  .free = il4965_rs_free,
2818  .alloc_sta = il4965_rs_alloc_sta,
2819  .free_sta = il4965_rs_free_sta,
2820 #ifdef CONFIG_MAC80211_DEBUGFS
2821  .add_sta_debugfs = il4965_rs_add_debugfs,
2822  .remove_sta_debugfs = il4965_rs_remove_debugfs,
2823 #endif
2824 };
2825 
2826 int
2827 il4965_rate_control_register(void)
2828 {
2829  return ieee80211_rate_control_register(&rs_4965_ops);
2830 }
2831 
2832 void
2833 il4965_rate_control_unregister(void)
2834 {
2835  ieee80211_rate_control_unregister(&rs_4965_ops);
2836 }
Generated on Thu Jan 10 2013 14:11:37 for Linux Kernel by   doxygen 1.8.2