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