rs.c 117.4 KB
Newer Older
J
Johannes Berg 已提交
1 2
/******************************************************************************
 *
3
 * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
4
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
5
 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
6
 * Copyright(c) 2018 Intel Corporation
J
Johannes Berg 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
21
 *  Intel Linux Wireless <linuxwifi@intel.com>
J
Johannes Berg 已提交
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/
#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <net/mac80211.h>

#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/delay.h>

#include <linux/workqueue.h>
#include "rs.h"
#include "fw-api.h"
#include "sta.h"
#include "iwl-op-mode.h"
#include "mvm.h"
40
#include "debugfs.h"
J
Johannes Berg 已提交
41 42 43

#define IWL_RATE_MAX_WINDOW		62	/* # tx in history window */

44 45 46 47
/* Calculations of success ratio are done in fixed point where 12800 is 100%.
 * Use this macro when dealing with thresholds consts set as a percentage
 */
#define RS_PERCENT(x) (128 * x)
J
Johannes Berg 已提交
48 49

static u8 rs_ht_to_legacy[] = {
50 51 52 53 54 55 56 57 58 59
	[IWL_RATE_MCS_0_INDEX] = IWL_RATE_6M_INDEX,
	[IWL_RATE_MCS_1_INDEX] = IWL_RATE_9M_INDEX,
	[IWL_RATE_MCS_2_INDEX] = IWL_RATE_12M_INDEX,
	[IWL_RATE_MCS_3_INDEX] = IWL_RATE_18M_INDEX,
	[IWL_RATE_MCS_4_INDEX] = IWL_RATE_24M_INDEX,
	[IWL_RATE_MCS_5_INDEX] = IWL_RATE_36M_INDEX,
	[IWL_RATE_MCS_6_INDEX] = IWL_RATE_48M_INDEX,
	[IWL_RATE_MCS_7_INDEX] = IWL_RATE_54M_INDEX,
	[IWL_RATE_MCS_8_INDEX] = IWL_RATE_54M_INDEX,
	[IWL_RATE_MCS_9_INDEX] = IWL_RATE_54M_INDEX,
J
Johannes Berg 已提交
60 61 62
};

static const u8 ant_toggle_lookup[] = {
63 64
	[ANT_NONE] = ANT_NONE,
	[ANT_A] = ANT_B,
65 66
	[ANT_B] = ANT_A,
	[ANT_AB] = ANT_AB,
J
Johannes Berg 已提交
67 68
};

E
Eyal Shapira 已提交
69 70 71 72 73 74 75
#define IWL_DECLARE_RATE_INFO(r, s, rp, rn)			      \
	[IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP,	      \
				    IWL_RATE_HT_SISO_MCS_##s##_PLCP,  \
				    IWL_RATE_HT_MIMO2_MCS_##s##_PLCP, \
				    IWL_RATE_VHT_SISO_MCS_##s##_PLCP, \
				    IWL_RATE_VHT_MIMO2_MCS_##s##_PLCP,\
				    IWL_RATE_##rp##M_INDEX,	      \
76
				    IWL_RATE_##rn##M_INDEX }
J
Johannes Berg 已提交
77

E
Eyal Shapira 已提交
78 79 80 81 82 83 84 85 86
#define IWL_DECLARE_MCS_RATE(s)						  \
	[IWL_RATE_MCS_##s##_INDEX] = { IWL_RATE_INVM_PLCP,		  \
				       IWL_RATE_HT_SISO_MCS_##s##_PLCP,	  \
				       IWL_RATE_HT_MIMO2_MCS_##s##_PLCP,  \
				       IWL_RATE_VHT_SISO_MCS_##s##_PLCP,  \
				       IWL_RATE_VHT_MIMO2_MCS_##s##_PLCP, \
				       IWL_RATE_INVM_INDEX,	          \
				       IWL_RATE_INVM_INDEX }

J
Johannes Berg 已提交
87 88
/*
 * Parameter order:
89
 *   rate, ht rate, prev rate, next rate
J
Johannes Berg 已提交
90 91 92 93 94 95
 *
 * If there isn't a valid next or previous rate then INV is used which
 * maps to IWL_RATE_INVALID
 *
 */
static const struct iwl_rs_rate_info iwl_rates[IWL_RATE_COUNT] = {
96 97 98 99
	IWL_DECLARE_RATE_INFO(1, INV, INV, 2),   /*  1mbps */
	IWL_DECLARE_RATE_INFO(2, INV, 1, 5),     /*  2mbps */
	IWL_DECLARE_RATE_INFO(5, INV, 2, 11),    /*5.5mbps */
	IWL_DECLARE_RATE_INFO(11, INV, 9, 12),   /* 11mbps */
E
Eyal Shapira 已提交
100 101 102 103 104 105 106 107 108 109 110
	IWL_DECLARE_RATE_INFO(6, 0, 5, 11),      /*  6mbps ; MCS 0 */
	IWL_DECLARE_RATE_INFO(9, INV, 6, 11),    /*  9mbps */
	IWL_DECLARE_RATE_INFO(12, 1, 11, 18),    /* 12mbps ; MCS 1 */
	IWL_DECLARE_RATE_INFO(18, 2, 12, 24),    /* 18mbps ; MCS 2 */
	IWL_DECLARE_RATE_INFO(24, 3, 18, 36),    /* 24mbps ; MCS 3 */
	IWL_DECLARE_RATE_INFO(36, 4, 24, 48),    /* 36mbps ; MCS 4 */
	IWL_DECLARE_RATE_INFO(48, 5, 36, 54),    /* 48mbps ; MCS 5 */
	IWL_DECLARE_RATE_INFO(54, 6, 48, INV),   /* 54mbps ; MCS 6 */
	IWL_DECLARE_MCS_RATE(7),                 /* MCS 7 */
	IWL_DECLARE_MCS_RATE(8),                 /* MCS 8 */
	IWL_DECLARE_MCS_RATE(9),                 /* MCS 9 */
J
Johannes Berg 已提交
111 112
};

113 114 115 116 117 118
enum rs_action {
	RS_ACTION_STAY = 0,
	RS_ACTION_DOWNSCALE = -1,
	RS_ACTION_UPSCALE = 1,
};

119 120 121 122 123 124 125
enum rs_column_mode {
	RS_INVALID = 0,
	RS_LEGACY,
	RS_SISO,
	RS_MIMO2,
};

126
#define MAX_NEXT_COLUMNS 7
127 128
#define MAX_COLUMN_CHECKS 3

129 130
struct rs_tx_column;

131 132
typedef bool (*allow_column_func_t) (struct iwl_mvm *mvm,
				     struct ieee80211_sta *sta,
133
				     struct rs_rate *rate,
134
				     const struct rs_tx_column *next_col);
135 136 137 138 139 140 141 142 143

struct rs_tx_column {
	enum rs_column_mode mode;
	u8 ant;
	bool sgi;
	enum rs_column next_columns[MAX_NEXT_COLUMNS];
	allow_column_func_t checks[MAX_COLUMN_CHECKS];
};

144
static bool rs_ant_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
145
			 struct rs_rate *rate,
146
			 const struct rs_tx_column *next_col)
147
{
148
	return iwl_mvm_bt_coex_is_ant_avail(mvm, next_col->ant);
149 150
}

151
static bool rs_mimo_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
152
			  struct rs_rate *rate,
153
			  const struct rs_tx_column *next_col)
154 155 156 157 158 159 160
{
	if (!sta->ht_cap.ht_supported)
		return false;

	if (sta->smps_mode == IEEE80211_SMPS_STATIC)
		return false;

161
	if (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) < 2)
162 163 164 165 166
		return false;

	if (!iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta))
		return false;

167 168 169
	if (mvm->nvm_data->sku_cap_mimo_disabled)
		return false;

170 171 172 173
	return true;
}

static bool rs_siso_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
174
			  struct rs_rate *rate,
175
			  const struct rs_tx_column *next_col)
176 177 178 179 180 181 182 183
{
	if (!sta->ht_cap.ht_supported)
		return false;

	return true;
}

static bool rs_sgi_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
184
			 struct rs_rate *rate,
185
			 const struct rs_tx_column *next_col)
186 187 188 189 190 191 192 193 194 195 196 197 198
{
	struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
	struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;

	if (is_ht20(rate) && (ht_cap->cap &
			     IEEE80211_HT_CAP_SGI_20))
		return true;
	if (is_ht40(rate) && (ht_cap->cap &
			     IEEE80211_HT_CAP_SGI_40))
		return true;
	if (is_ht80(rate) && (vht_cap->cap &
			     IEEE80211_VHT_CAP_SHORT_GI_80))
		return true;
199 200 201
	if (is_ht160(rate) && (vht_cap->cap &
			     IEEE80211_VHT_CAP_SHORT_GI_160))
		return true;
202 203 204 205 206 207 208 209 210 211 212

	return false;
}

static const struct rs_tx_column rs_tx_columns[] = {
	[RS_COLUMN_LEGACY_ANT_A] = {
		.mode = RS_LEGACY,
		.ant = ANT_A,
		.next_columns = {
			RS_COLUMN_LEGACY_ANT_B,
			RS_COLUMN_SISO_ANT_A,
213
			RS_COLUMN_MIMO2,
214 215
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
216 217
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
218
		},
219 220 221
		.checks = {
			rs_ant_allow,
		},
222 223 224 225 226 227 228
	},
	[RS_COLUMN_LEGACY_ANT_B] = {
		.mode = RS_LEGACY,
		.ant = ANT_B,
		.next_columns = {
			RS_COLUMN_LEGACY_ANT_A,
			RS_COLUMN_SISO_ANT_B,
229
			RS_COLUMN_MIMO2,
230 231
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
232 233
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
234
		},
235 236 237
		.checks = {
			rs_ant_allow,
		},
238 239 240 241 242 243 244 245
	},
	[RS_COLUMN_SISO_ANT_A] = {
		.mode = RS_SISO,
		.ant = ANT_A,
		.next_columns = {
			RS_COLUMN_SISO_ANT_B,
			RS_COLUMN_MIMO2,
			RS_COLUMN_SISO_ANT_A_SGI,
246 247
			RS_COLUMN_LEGACY_ANT_A,
			RS_COLUMN_LEGACY_ANT_B,
248
			RS_COLUMN_INVALID,
249
			RS_COLUMN_INVALID,
250 251 252
		},
		.checks = {
			rs_siso_allow,
253
			rs_ant_allow,
254 255 256 257 258 259 260 261 262
		},
	},
	[RS_COLUMN_SISO_ANT_B] = {
		.mode = RS_SISO,
		.ant = ANT_B,
		.next_columns = {
			RS_COLUMN_SISO_ANT_A,
			RS_COLUMN_MIMO2,
			RS_COLUMN_SISO_ANT_B_SGI,
263 264
			RS_COLUMN_LEGACY_ANT_A,
			RS_COLUMN_LEGACY_ANT_B,
265
			RS_COLUMN_INVALID,
266
			RS_COLUMN_INVALID,
267 268 269
		},
		.checks = {
			rs_siso_allow,
270
			rs_ant_allow,
271 272 273 274 275 276 277 278 279 280
		},
	},
	[RS_COLUMN_SISO_ANT_A_SGI] = {
		.mode = RS_SISO,
		.ant = ANT_A,
		.sgi = true,
		.next_columns = {
			RS_COLUMN_SISO_ANT_B_SGI,
			RS_COLUMN_MIMO2_SGI,
			RS_COLUMN_SISO_ANT_A,
281 282
			RS_COLUMN_LEGACY_ANT_A,
			RS_COLUMN_LEGACY_ANT_B,
283 284
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
285 286 287
		},
		.checks = {
			rs_siso_allow,
288
			rs_ant_allow,
289 290 291 292 293 294 295 296 297 298 299
			rs_sgi_allow,
		},
	},
	[RS_COLUMN_SISO_ANT_B_SGI] = {
		.mode = RS_SISO,
		.ant = ANT_B,
		.sgi = true,
		.next_columns = {
			RS_COLUMN_SISO_ANT_A_SGI,
			RS_COLUMN_MIMO2_SGI,
			RS_COLUMN_SISO_ANT_B,
300 301
			RS_COLUMN_LEGACY_ANT_A,
			RS_COLUMN_LEGACY_ANT_B,
302 303
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
304 305 306
		},
		.checks = {
			rs_siso_allow,
307
			rs_ant_allow,
308 309 310 311 312 313 314 315 316
			rs_sgi_allow,
		},
	},
	[RS_COLUMN_MIMO2] = {
		.mode = RS_MIMO2,
		.ant = ANT_AB,
		.next_columns = {
			RS_COLUMN_SISO_ANT_A,
			RS_COLUMN_MIMO2_SGI,
317 318
			RS_COLUMN_LEGACY_ANT_A,
			RS_COLUMN_LEGACY_ANT_B,
319 320 321
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
322 323 324 325 326 327 328 329 330 331 332 333
		},
		.checks = {
			rs_mimo_allow,
		},
	},
	[RS_COLUMN_MIMO2_SGI] = {
		.mode = RS_MIMO2,
		.ant = ANT_AB,
		.sgi = true,
		.next_columns = {
			RS_COLUMN_SISO_ANT_A_SGI,
			RS_COLUMN_MIMO2,
334 335
			RS_COLUMN_LEGACY_ANT_A,
			RS_COLUMN_LEGACY_ANT_B,
336 337 338
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
			RS_COLUMN_INVALID,
339 340 341 342 343 344 345 346
		},
		.checks = {
			rs_mimo_allow,
			rs_sgi_allow,
		},
	},
};

J
Johannes Berg 已提交
347 348 349 350 351 352 353 354 355 356 357
static inline u8 rs_extract_rate(u32 rate_n_flags)
{
	/* also works for HT because bits 7:6 are zero there */
	return (u8)(rate_n_flags & RATE_LEGACY_RATE_MSK);
}

static int iwl_hwrate_to_plcp_idx(u32 rate_n_flags)
{
	int idx = 0;

	if (rate_n_flags & RATE_MCS_HT_MSK) {
E
Eyal Shapira 已提交
358 359
		idx = rate_n_flags & RATE_HT_MCS_RATE_CODE_MSK;
		idx += IWL_RATE_MCS_0_INDEX;
J
Johannes Berg 已提交
360

E
Eyal Shapira 已提交
361
		/* skip 9M not supported in HT*/
J
Johannes Berg 已提交
362 363
		if (idx >= IWL_RATE_9M_INDEX)
			idx += 1;
364
		if ((idx >= IWL_FIRST_HT_RATE) && (idx <= IWL_LAST_HT_RATE))
J
Johannes Berg 已提交
365
			return idx;
366 367
	} else if (rate_n_flags & RATE_MCS_VHT_MSK ||
		   rate_n_flags & RATE_MCS_HE_MSK) {
E
Eyal Shapira 已提交
368 369
		idx = rate_n_flags & RATE_VHT_MCS_RATE_CODE_MSK;
		idx += IWL_RATE_MCS_0_INDEX;
J
Johannes Berg 已提交
370

E
Eyal Shapira 已提交
371 372 373 374 375
		/* skip 9M not supported in VHT*/
		if (idx >= IWL_RATE_9M_INDEX)
			idx++;
		if ((idx >= IWL_FIRST_VHT_RATE) && (idx <= IWL_LAST_VHT_RATE))
			return idx;
376 377 378
		if ((rate_n_flags & RATE_MCS_HE_MSK) &&
		    (idx <= IWL_LAST_HE_RATE))
			return idx;
J
Johannes Berg 已提交
379
	} else {
E
Eyal Shapira 已提交
380 381 382
		/* legacy rate format, search for match in table */

		u8 legacy_rate = rs_extract_rate(rate_n_flags);
J
Johannes Berg 已提交
383
		for (idx = 0; idx < ARRAY_SIZE(iwl_rates); idx++)
E
Eyal Shapira 已提交
384
			if (iwl_rates[idx].plcp == legacy_rate)
J
Johannes Berg 已提交
385 386 387
				return idx;
	}

388
	return IWL_RATE_INVALID;
J
Johannes Berg 已提交
389 390 391
}

static void rs_rate_scale_perform(struct iwl_mvm *mvm,
392 393
				  struct ieee80211_sta *sta,
				  struct iwl_lq_sta *lq_sta,
394
				  int tid, bool ndp);
395 396 397 398
static void rs_fill_lq_cmd(struct iwl_mvm *mvm,
			   struct ieee80211_sta *sta,
			   struct iwl_lq_sta *lq_sta,
			   const struct rs_rate *initial_rate);
J
Johannes Berg 已提交
399 400 401 402 403 404 405 406 407 408 409 410 411
static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search);

/**
 * The following tables contain the expected throughput metrics for all rates
 *
 *	1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 60 MBits
 *
 * where invalid entries are zeros.
 *
 * CCK rates are only valid in legacy table and will only be used in G
 * (2.4 GHz) band.
 */

412
static const u16 expected_tpt_legacy[IWL_RATE_COUNT] = {
413
	7, 13, 35, 58, 40, 57, 72, 98, 121, 154, 177, 186, 0, 0, 0
J
Johannes Berg 已提交
414 415
};

416 417 418
/* Expected TpT tables. 4 indexes:
 * 0 - NGI, 1 - SGI, 2 - AGG+NGI, 3 - AGG+SGI
 */
419
static const u16 expected_tpt_siso_20MHz[4][IWL_RATE_COUNT] = {
420 421 422 423
	{0, 0, 0, 0, 42, 0,  76, 102, 124, 159, 183, 193, 202, 216, 0},
	{0, 0, 0, 0, 46, 0,  82, 110, 132, 168, 192, 202, 210, 225, 0},
	{0, 0, 0, 0, 49, 0,  97, 145, 192, 285, 375, 420, 464, 551, 0},
	{0, 0, 0, 0, 54, 0, 108, 160, 213, 315, 415, 465, 513, 608, 0},
J
Johannes Berg 已提交
424 425
};

426
static const u16 expected_tpt_siso_40MHz[4][IWL_RATE_COUNT] = {
427 428 429 430
	{0, 0, 0, 0,  77, 0, 127, 160, 184, 220, 242, 250,  257,  269,  275},
	{0, 0, 0, 0,  83, 0, 135, 169, 193, 229, 250, 257,  264,  275,  280},
	{0, 0, 0, 0, 101, 0, 199, 295, 389, 570, 744, 828,  911, 1070, 1173},
	{0, 0, 0, 0, 112, 0, 220, 326, 429, 629, 819, 912, 1000, 1173, 1284},
J
Johannes Berg 已提交
431 432
};

433
static const u16 expected_tpt_siso_80MHz[4][IWL_RATE_COUNT] = {
E
Eyal Shapira 已提交
434 435 436 437 438 439
	{0, 0, 0, 0, 130, 0, 191, 223, 244,  273,  288,  294,  298,  305,  308},
	{0, 0, 0, 0, 138, 0, 200, 231, 251,  279,  293,  298,  302,  308,  312},
	{0, 0, 0, 0, 217, 0, 429, 634, 834, 1220, 1585, 1760, 1931, 2258, 2466},
	{0, 0, 0, 0, 241, 0, 475, 701, 921, 1343, 1741, 1931, 2117, 2468, 2691},
};

440 441 442 443 444 445 446
static const u16 expected_tpt_siso_160MHz[4][IWL_RATE_COUNT] = {
	{0, 0, 0, 0, 191, 0, 244, 288,  298,  308,  313,  318,  323,  328,  330},
	{0, 0, 0, 0, 200, 0, 251, 293,  302,  312,  317,  322,  327,  332,  334},
	{0, 0, 0, 0, 439, 0, 875, 1307, 1736, 2584, 3419, 3831, 4240, 5049, 5581},
	{0, 0, 0, 0, 488, 0, 972, 1451, 1925, 2864, 3785, 4240, 4691, 5581, 6165},
};

447
static const u16 expected_tpt_mimo2_20MHz[4][IWL_RATE_COUNT] = {
448 449 450 451
	{0, 0, 0, 0,  74, 0, 123, 155, 179, 213, 235, 243, 250,  261, 0},
	{0, 0, 0, 0,  81, 0, 131, 164, 187, 221, 242, 250, 256,  267, 0},
	{0, 0, 0, 0,  98, 0, 193, 286, 375, 550, 718, 799, 878, 1032, 0},
	{0, 0, 0, 0, 109, 0, 214, 316, 414, 607, 790, 879, 965, 1132, 0},
J
Johannes Berg 已提交
452 453
};

454
static const u16 expected_tpt_mimo2_40MHz[4][IWL_RATE_COUNT] = {
455 456 457 458
	{0, 0, 0, 0, 123, 0, 182, 214, 235,  264,  279,  285,  289,  296,  300},
	{0, 0, 0, 0, 131, 0, 191, 222, 242,  270,  284,  289,  293,  300,  303},
	{0, 0, 0, 0, 200, 0, 390, 571, 741, 1067, 1365, 1505, 1640, 1894, 2053},
	{0, 0, 0, 0, 221, 0, 430, 630, 816, 1169, 1490, 1641, 1784, 2053, 2221},
J
Johannes Berg 已提交
459 460
};

461
static const u16 expected_tpt_mimo2_80MHz[4][IWL_RATE_COUNT] = {
E
Eyal Shapira 已提交
462 463 464 465 466 467
	{0, 0, 0, 0, 182, 0, 240,  264,  278,  299,  308,  311,  313,  317,  319},
	{0, 0, 0, 0, 190, 0, 247,  269,  282,  302,  310,  313,  315,  319,  320},
	{0, 0, 0, 0, 428, 0, 833, 1215, 1577, 2254, 2863, 3147, 3418, 3913, 4219},
	{0, 0, 0, 0, 474, 0, 920, 1338, 1732, 2464, 3116, 3418, 3705, 4225, 4545},
};

468 469 470 471 472 473 474
static const u16 expected_tpt_mimo2_160MHz[4][IWL_RATE_COUNT] = {
	{0, 0, 0, 0, 240, 0, 278,  308,  313,  319,  322,  324,  328,  330,   334},
	{0, 0, 0, 0, 247, 0, 282,  310,  315,  320,  323,  325,  329,  332,   338},
	{0, 0, 0, 0, 875, 0, 1735, 2582, 3414, 5043, 6619, 7389, 8147, 9629,  10592},
	{0, 0, 0, 0, 971, 0, 1925, 2861, 3779, 5574, 7304, 8147, 8976, 10592, 11640},
};

J
Johannes Berg 已提交
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
/* mbps, mcs */
static const struct iwl_rate_mcs_info iwl_rate_mcs[IWL_RATE_COUNT] = {
	{  "1", "BPSK DSSS"},
	{  "2", "QPSK DSSS"},
	{"5.5", "BPSK CCK"},
	{ "11", "QPSK CCK"},
	{  "6", "BPSK 1/2"},
	{  "9", "BPSK 1/2"},
	{ "12", "QPSK 1/2"},
	{ "18", "QPSK 3/4"},
	{ "24", "16QAM 1/2"},
	{ "36", "16QAM 3/4"},
	{ "48", "64QAM 2/3"},
	{ "54", "64QAM 3/4"},
	{ "60", "64QAM 5/6"},
};

#define MCS_INDEX_PER_STREAM	(8)

494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
static const char *rs_pretty_ant(u8 ant)
{
	static const char * const ant_name[] = {
		[ANT_NONE] = "None",
		[ANT_A]    = "A",
		[ANT_B]    = "B",
		[ANT_AB]   = "AB",
		[ANT_C]    = "C",
		[ANT_AC]   = "AC",
		[ANT_BC]   = "BC",
		[ANT_ABC]  = "ABC",
	};

	if (ant > ANT_ABC)
		return "UNKNOWN";

	return ant_name[ant];
}

static const char *rs_pretty_lq_type(enum iwl_table_type type)
{
	static const char * const lq_types[] = {
		[LQ_NONE] = "NONE",
		[LQ_LEGACY_A] = "LEGACY_A",
		[LQ_LEGACY_G] = "LEGACY_G",
		[LQ_HT_SISO] = "HT SISO",
		[LQ_HT_MIMO2] = "HT MIMO",
		[LQ_VHT_SISO] = "VHT SISO",
		[LQ_VHT_MIMO2] = "VHT MIMO",
523 524
		[LQ_HE_SISO] = "HE SISO",
		[LQ_HE_MIMO2] = "HE MIMO",
525 526 527 528 529 530 531 532
	};

	if (type < LQ_NONE || type >= LQ_MAX)
		return "UNKNOWN";

	return lq_types[type];
}

533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
static char *rs_pretty_rate(const struct rs_rate *rate)
{
	static char buf[40];
	static const char * const legacy_rates[] = {
		[IWL_RATE_1M_INDEX] = "1M",
		[IWL_RATE_2M_INDEX] = "2M",
		[IWL_RATE_5M_INDEX] = "5.5M",
		[IWL_RATE_11M_INDEX] = "11M",
		[IWL_RATE_6M_INDEX] = "6M",
		[IWL_RATE_9M_INDEX] = "9M",
		[IWL_RATE_12M_INDEX] = "12M",
		[IWL_RATE_18M_INDEX] = "18M",
		[IWL_RATE_24M_INDEX] = "24M",
		[IWL_RATE_36M_INDEX] = "36M",
		[IWL_RATE_48M_INDEX] = "48M",
		[IWL_RATE_54M_INDEX] = "54M",
	};
	static const char *const ht_vht_rates[] = {
		[IWL_RATE_MCS_0_INDEX] = "MCS0",
		[IWL_RATE_MCS_1_INDEX] = "MCS1",
		[IWL_RATE_MCS_2_INDEX] = "MCS2",
		[IWL_RATE_MCS_3_INDEX] = "MCS3",
		[IWL_RATE_MCS_4_INDEX] = "MCS4",
		[IWL_RATE_MCS_5_INDEX] = "MCS5",
		[IWL_RATE_MCS_6_INDEX] = "MCS6",
		[IWL_RATE_MCS_7_INDEX] = "MCS7",
		[IWL_RATE_MCS_8_INDEX] = "MCS8",
		[IWL_RATE_MCS_9_INDEX] = "MCS9",
	};
	const char *rate_str;

564
	if (is_type_legacy(rate->type) && (rate->index <= IWL_RATE_54M_INDEX))
565
		rate_str = legacy_rates[rate->index];
566
	else if ((is_type_ht(rate->type) || is_type_vht(rate->type)) &&
567
		 (rate->index >= IWL_RATE_MCS_0_INDEX) &&
568
		 (rate->index <= IWL_RATE_MCS_9_INDEX))
569 570 571 572 573 574 575 576 577
		rate_str = ht_vht_rates[rate->index];
	else
		rate_str = "BAD_RATE";

	sprintf(buf, "(%s|%s|%s)", rs_pretty_lq_type(rate->type),
		rs_pretty_ant(rate->ant), rate_str);
	return buf;
}

578 579 580
static inline void rs_dump_rate(struct iwl_mvm *mvm, const struct rs_rate *rate,
				const char *prefix)
{
581
	IWL_DEBUG_RATE(mvm,
582 583 584
		       "%s: %s BW: %d SGI: %d LDPC: %d STBC: %d\n",
		       prefix, rs_pretty_rate(rate), rate->bw,
		       rate->sgi, rate->ldpc, rate->stbc);
585 586
}

J
Johannes Berg 已提交
587 588 589 590 591 592 593 594 595
static void rs_rate_scale_clear_window(struct iwl_rate_scale_data *window)
{
	window->data = 0;
	window->success_counter = 0;
	window->success_ratio = IWL_INVALID_VALUE;
	window->counter = 0;
	window->average_tpt = IWL_INVALID_VALUE;
}

596 597
static void rs_rate_scale_clear_tbl_windows(struct iwl_mvm *mvm,
					    struct iwl_scale_tbl_info *tbl)
598 599 600
{
	int i;

601
	IWL_DEBUG_RATE(mvm, "Clearing up window stats\n");
602 603
	for (i = 0; i < IWL_RATE_COUNT; i++)
		rs_rate_scale_clear_window(&tbl->win[i]);
604 605 606

	for (i = 0; i < ARRAY_SIZE(tbl->tpc_win); i++)
		rs_rate_scale_clear_window(&tbl->tpc_win[i]);
607 608
}

J
Johannes Berg 已提交
609 610 611 612 613 614
static inline u8 rs_is_valid_ant(u8 valid_antenna, u8 ant_type)
{
	return (ant_type & valid_antenna) == ant_type;
}

static int rs_tl_turn_on_agg_for_tid(struct iwl_mvm *mvm,
615 616
				     struct iwl_lq_sta *lq_data, u8 tid,
				     struct ieee80211_sta *sta)
J
Johannes Berg 已提交
617 618 619
{
	int ret = -EAGAIN;

620 621
	IWL_DEBUG_HT(mvm, "Starting Tx agg: STA: %pM tid: %d\n",
		     sta->addr, tid);
622 623 624

	/* start BA session until the peer sends del BA */
	ret = ieee80211_start_tx_ba_session(sta, tid, 0);
625 626 627 628 629 630 631 632 633
	if (ret == -EAGAIN) {
		/*
		 * driver and mac80211 is out of sync
		 * this might be cause by reloading firmware
		 * stop the tx ba session here
		 */
		IWL_ERR(mvm, "Fail start Tx agg on tid: %d\n",
			tid);
		ieee80211_stop_tx_ba_session(sta, tid);
J
Johannes Berg 已提交
634 635 636 637
	}
	return ret;
}

638 639
static void rs_tl_turn_on_agg(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta,
			      u8 tid, struct iwl_lq_sta *lq_sta,
J
Johannes Berg 已提交
640 641
			      struct ieee80211_sta *sta)
{
642 643 644 645 646 647 648
	struct iwl_mvm_tid_data *tid_data;

	/*
	 * In AP mode, tid can be equal to IWL_MAX_TID_COUNT
	 * when the frame is not QoS
	 */
	if (WARN_ON_ONCE(tid > IWL_MAX_TID_COUNT)) {
J
Johannes Berg 已提交
649 650
		IWL_ERR(mvm, "tid exceeds max TID count: %d/%d\n",
			tid, IWL_MAX_TID_COUNT);
651 652 653 654 655 656
		return;
	} else if (tid == IWL_MAX_TID_COUNT) {
		return;
	}

	tid_data = &mvmsta->tid_data[tid];
657 658
	if (mvmsta->sta_state >= IEEE80211_STA_AUTHORIZED &&
	    tid_data->state == IWL_AGG_OFF &&
659
	    (lq_sta->tx_agg_tid_en & BIT(tid)) &&
660
	    tid_data->tx_count_last >= IWL_MVM_RS_AGG_START_THRESHOLD) {
661
		IWL_DEBUG_RATE(mvm, "try to aggregate tid %d\n", tid);
662 663
		if (rs_tl_turn_on_agg_for_tid(mvm, lq_sta, tid, sta) == 0)
			tid_data->state = IWL_AGG_QUEUED;
664
	}
J
Johannes Berg 已提交
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
}

static inline int get_num_of_ant_from_rate(u32 rate_n_flags)
{
	return !!(rate_n_flags & RATE_MCS_ANT_A_MSK) +
	       !!(rate_n_flags & RATE_MCS_ANT_B_MSK) +
	       !!(rate_n_flags & RATE_MCS_ANT_C_MSK);
}

/*
 * Static function to get the expected throughput from an iwl_scale_tbl_info
 * that wraps a NULL pointer check
 */
static s32 get_expected_tpt(struct iwl_scale_tbl_info *tbl, int rs_index)
{
	if (tbl->expected_tpt)
		return tbl->expected_tpt[rs_index];
	return 0;
}

/**
 * rs_collect_tx_data - Update the success/failure sliding window
 *
 * We keep a sliding window of the last 62 packets transmitted
 * at this rate.  window->data contains the bitmask of successful
 * packets.
 */
692 693
static int _rs_collect_tx_data(struct iwl_mvm *mvm,
			       struct iwl_scale_tbl_info *tbl,
694 695
			       int scale_index, int attempts, int successes,
			       struct iwl_rate_scale_data *window)
J
Johannes Berg 已提交
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
{
	static const u64 mask = (((u64)1) << (IWL_RATE_MAX_WINDOW - 1));
	s32 fail_count, tpt;

	/* Get expected throughput */
	tpt = get_expected_tpt(tbl, scale_index);

	/*
	 * Keep track of only the latest 62 tx frame attempts in this rate's
	 * history window; anything older isn't really relevant any more.
	 * If we have filled up the sliding window, drop the oldest attempt;
	 * if the oldest attempt (highest bit in bitmap) shows "success",
	 * subtract "1" from the success counter (this is the main reason
	 * we keep these bitmaps!).
	 */
	while (attempts > 0) {
		if (window->counter >= IWL_RATE_MAX_WINDOW) {
			/* remove earliest */
			window->counter = IWL_RATE_MAX_WINDOW - 1;

			if (window->data & mask) {
				window->data &= ~mask;
				window->success_counter--;
			}
		}

		/* Increment frames-attempted counter */
		window->counter++;

		/* Shift bitmap by one frame to throw away oldest history */
		window->data <<= 1;

		/* Mark the most recent #successes attempts as successful */
		if (successes > 0) {
			window->success_counter++;
			window->data |= 0x1;
			successes--;
		}

		attempts--;
	}

	/* Calculate current success ratio, avoid divide-by-0! */
	if (window->counter > 0)
		window->success_ratio = 128 * (100 * window->success_counter)
					/ window->counter;
	else
		window->success_ratio = IWL_INVALID_VALUE;

	fail_count = window->counter - window->success_counter;

	/* Calculate average throughput, if we have enough history. */
748 749
	if ((fail_count >= IWL_MVM_RS_RATE_MIN_FAILURE_TH) ||
	    (window->success_counter >= IWL_MVM_RS_RATE_MIN_SUCCESS_TH))
J
Johannes Berg 已提交
750 751 752 753 754 755 756
		window->average_tpt = (window->success_ratio * tpt + 64) / 128;
	else
		window->average_tpt = IWL_INVALID_VALUE;

	return 0;
}

757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
static int rs_collect_tpc_data(struct iwl_mvm *mvm,
			       struct iwl_lq_sta *lq_sta,
			       struct iwl_scale_tbl_info *tbl,
			       int scale_index, int attempts, int successes,
			       u8 reduced_txp)
{
	struct iwl_rate_scale_data *window = NULL;

	if (WARN_ON_ONCE(reduced_txp > TPC_MAX_REDUCTION))
		return -EINVAL;

	window = &tbl->tpc_win[reduced_txp];
	return  _rs_collect_tx_data(mvm, tbl, scale_index, attempts, successes,
				    window);
}

773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
static void rs_update_tid_tpt_stats(struct iwl_mvm *mvm,
				    struct iwl_mvm_sta *mvmsta,
				    u8 tid, int successes)
{
	struct iwl_mvm_tid_data *tid_data;

	if (tid >= IWL_MAX_TID_COUNT)
		return;

	tid_data = &mvmsta->tid_data[tid];

	/*
	 * Measure if there're enough successful transmits per second.
	 * These statistics are used only to decide if we can start a
	 * BA session, so it should be updated only when A-MPDU is
	 * off.
	 */
	if (tid_data->state != IWL_AGG_OFF)
		return;

	if (time_is_before_jiffies(tid_data->tpt_meas_start + HZ) ||
	    (tid_data->tx_count >= IWL_MVM_RS_AGG_START_THRESHOLD)) {
		tid_data->tx_count_last = tid_data->tx_count;
		tid_data->tx_count = 0;
		tid_data->tpt_meas_start = jiffies;
	} else {
		tid_data->tx_count += successes;
	}
}

803
static int rs_collect_tlc_data(struct iwl_mvm *mvm,
804
			       struct iwl_mvm_sta *mvmsta, u8 tid,
805 806
			       struct iwl_scale_tbl_info *tbl,
			       int scale_index, int attempts, int successes)
807 808 809 810 811 812
{
	struct iwl_rate_scale_data *window = NULL;

	if (scale_index < 0 || scale_index >= IWL_RATE_COUNT)
		return -EINVAL;

813
	if (tbl->column != RS_COLUMN_INVALID) {
814
		struct lq_sta_pers *pers = &mvmsta->lq_sta.rs_drv.pers;
815 816 817

		pers->tx_stats[tbl->column][scale_index].total += attempts;
		pers->tx_stats[tbl->column][scale_index].success += successes;
818 819
	}

820 821
	rs_update_tid_tpt_stats(mvm, mvmsta, tid, successes);

822 823
	/* Select window for current tx bit rate */
	window = &(tbl->win[scale_index]);
824
	return _rs_collect_tx_data(mvm, tbl, scale_index, attempts, successes,
825 826 827
				   window);
}

828 829
/* Convert rs_rate object into ucode rate bitmask */
static u32 ucode_rate_from_rs_rate(struct iwl_mvm *mvm,
830
				  struct rs_rate *rate)
J
Johannes Berg 已提交
831
{
832 833
	u32 ucode_rate = 0;
	int index = rate->index;
J
Johannes Berg 已提交
834

835
	ucode_rate |= ((rate->ant << RATE_MCS_ANT_POS) &
E
Eyal Shapira 已提交
836 837
			 RATE_MCS_ANT_ABC_MSK);

838 839
	if (is_legacy(rate)) {
		ucode_rate |= iwl_rates[index].plcp;
J
Johannes Berg 已提交
840
		if (index >= IWL_FIRST_CCK_RATE && index <= IWL_LAST_CCK_RATE)
841 842
			ucode_rate |= RATE_MCS_CCK_MSK;
		return ucode_rate;
E
Eyal Shapira 已提交
843 844
	}

845
	if (is_ht(rate)) {
E
Eyal Shapira 已提交
846
		if (index < IWL_FIRST_HT_RATE || index > IWL_LAST_HT_RATE) {
J
Johannes Berg 已提交
847
			IWL_ERR(mvm, "Invalid HT rate index %d\n", index);
848
			index = IWL_LAST_HT_RATE;
J
Johannes Berg 已提交
849
		}
850
		ucode_rate |= RATE_MCS_HT_MSK;
J
Johannes Berg 已提交
851

852 853 854 855
		if (is_ht_siso(rate))
			ucode_rate |= iwl_rates[index].plcp_ht_siso;
		else if (is_ht_mimo2(rate))
			ucode_rate |= iwl_rates[index].plcp_ht_mimo2;
J
Johannes Berg 已提交
856
		else
857
			WARN_ON_ONCE(1);
858
	} else if (is_vht(rate)) {
E
Eyal Shapira 已提交
859 860 861 862
		if (index < IWL_FIRST_VHT_RATE || index > IWL_LAST_VHT_RATE) {
			IWL_ERR(mvm, "Invalid VHT rate index %d\n", index);
			index = IWL_LAST_VHT_RATE;
		}
863 864 865 866 867
		ucode_rate |= RATE_MCS_VHT_MSK;
		if (is_vht_siso(rate))
			ucode_rate |= iwl_rates[index].plcp_vht_siso;
		else if (is_vht_mimo2(rate))
			ucode_rate |= iwl_rates[index].plcp_vht_mimo2;
E
Eyal Shapira 已提交
868 869 870
		else
			WARN_ON_ONCE(1);

J
Johannes Berg 已提交
871
	} else {
872
		IWL_ERR(mvm, "Invalid rate->type %d\n", rate->type);
J
Johannes Berg 已提交
873 874
	}

875 876 877
	if (is_siso(rate) && rate->stbc) {
		/* To enable STBC we need to set both a flag and ANT_AB */
		ucode_rate |= RATE_MCS_ANT_AB_MSK;
878
		ucode_rate |= RATE_MCS_STBC_MSK;
879 880
	}

881 882 883
	ucode_rate |= rate->bw;
	if (rate->sgi)
		ucode_rate |= RATE_MCS_SGI_MSK;
E
Eyal Shapira 已提交
884 885
	if (rate->ldpc)
		ucode_rate |= RATE_MCS_LDPC_MSK;
E
Eyal Shapira 已提交
886

887
	return ucode_rate;
J
Johannes Berg 已提交
888 889
}

890 891
/* Convert a ucode rate into an rs_rate object */
static int rs_rate_from_ucode_rate(const u32 ucode_rate,
892
				   enum nl80211_band band,
893
				   struct rs_rate *rate)
J
Johannes Berg 已提交
894
{
895 896
	u32 ant_msk = ucode_rate & RATE_MCS_ANT_ABC_MSK;
	u8 num_of_ant = get_num_of_ant_from_rate(ucode_rate);
E
Eyal Shapira 已提交
897
	u8 nss;
J
Johannes Berg 已提交
898

899
	memset(rate, 0, sizeof(*rate));
900
	rate->index = iwl_hwrate_to_plcp_idx(ucode_rate);
J
Johannes Berg 已提交
901

902
	if (rate->index == IWL_RATE_INVALID)
J
Johannes Berg 已提交
903
		return -EINVAL;
904 905

	rate->ant = (ant_msk >> RATE_MCS_ANT_POS);
J
Johannes Berg 已提交
906

E
Eyal Shapira 已提交
907
	/* Legacy */
908
	if (!(ucode_rate & RATE_MCS_HT_MSK) &&
909 910
	    !(ucode_rate & RATE_MCS_VHT_MSK) &&
	    !(ucode_rate & RATE_MCS_HE_MSK)) {
J
Johannes Berg 已提交
911
		if (num_of_ant == 1) {
912
			if (band == NL80211_BAND_5GHZ)
913
				rate->type = LQ_LEGACY_A;
J
Johannes Berg 已提交
914
			else
915
				rate->type = LQ_LEGACY_G;
J
Johannes Berg 已提交
916
		}
E
Eyal Shapira 已提交
917 918 919 920

		return 0;
	}

921
	/* HT, VHT or HE */
922 923
	if (ucode_rate & RATE_MCS_SGI_MSK)
		rate->sgi = true;
E
Eyal Shapira 已提交
924 925
	if (ucode_rate & RATE_MCS_LDPC_MSK)
		rate->ldpc = true;
926
	if (ucode_rate & RATE_MCS_STBC_MSK)
927
		rate->stbc = true;
928 929
	if (ucode_rate & RATE_MCS_BF_MSK)
		rate->bfer = true;
E
Eyal Shapira 已提交
930

931
	rate->bw = ucode_rate & RATE_MCS_CHAN_WIDTH_MSK;
E
Eyal Shapira 已提交
932

933 934
	if (ucode_rate & RATE_MCS_HT_MSK) {
		nss = ((ucode_rate & RATE_HT_MCS_NSS_MSK) >>
E
Eyal Shapira 已提交
935 936 937
		       RATE_HT_MCS_NSS_POS) + 1;

		if (nss == 1) {
938
			rate->type = LQ_HT_SISO;
939 940 941
			WARN_ONCE(!rate->stbc && !rate->bfer && num_of_ant != 1,
				  "stbc %d bfer %d",
				  rate->stbc, rate->bfer);
E
Eyal Shapira 已提交
942
		} else if (nss == 2) {
943
			rate->type = LQ_HT_MIMO2;
E
Eyal Shapira 已提交
944
			WARN_ON_ONCE(num_of_ant != 2);
J
Johannes Berg 已提交
945
		} else {
E
Eyal Shapira 已提交
946 947
			WARN_ON_ONCE(1);
		}
948 949
	} else if (ucode_rate & RATE_MCS_VHT_MSK) {
		nss = ((ucode_rate & RATE_VHT_MCS_NSS_MSK) >>
E
Eyal Shapira 已提交
950 951 952
		       RATE_VHT_MCS_NSS_POS) + 1;

		if (nss == 1) {
953
			rate->type = LQ_VHT_SISO;
954 955 956
			WARN_ONCE(!rate->stbc && !rate->bfer && num_of_ant != 1,
				  "stbc %d bfer %d",
				  rate->stbc, rate->bfer);
E
Eyal Shapira 已提交
957
		} else if (nss == 2) {
958
			rate->type = LQ_VHT_MIMO2;
E
Eyal Shapira 已提交
959 960 961
			WARN_ON_ONCE(num_of_ant != 2);
		} else {
			WARN_ON_ONCE(1);
J
Johannes Berg 已提交
962
		}
963 964 965 966 967 968 969 970 971 972 973 974 975 976
	} else if (ucode_rate & RATE_MCS_HE_MSK) {
		nss = ((ucode_rate & RATE_VHT_MCS_NSS_MSK) >>
		      RATE_VHT_MCS_NSS_POS) + 1;

		if (nss == 1) {
			rate->type = LQ_HE_SISO;
			WARN_ONCE(!rate->stbc && !rate->bfer && num_of_ant != 1,
				  "stbc %d bfer %d", rate->stbc, rate->bfer);
		} else if (nss == 2) {
			rate->type = LQ_HE_MIMO2;
			WARN_ON_ONCE(num_of_ant != 2);
		} else {
			WARN_ON_ONCE(1);
		}
J
Johannes Berg 已提交
977
	}
E
Eyal Shapira 已提交
978

979
	WARN_ON_ONCE(rate->bw == RATE_MCS_CHAN_WIDTH_80 &&
980
		     !is_he(rate) && !is_vht(rate));
E
Eyal Shapira 已提交
981

J
Johannes Berg 已提交
982 983 984 985 986
	return 0;
}

/* switch to another antenna/antennas and return 1 */
/* if no other valid antenna found, return 0 */
987
static int rs_toggle_antenna(u32 valid_ant, struct rs_rate *rate)
J
Johannes Berg 已提交
988 989 990
{
	u8 new_ant_type;

991
	if (!rate->ant || WARN_ON_ONCE(rate->ant & ANT_C))
J
Johannes Berg 已提交
992 993
		return 0;

994
	if (!rs_is_valid_ant(valid_ant, rate->ant))
J
Johannes Berg 已提交
995 996
		return 0;

997
	new_ant_type = ant_toggle_lookup[rate->ant];
J
Johannes Berg 已提交
998

999
	while ((new_ant_type != rate->ant) &&
J
Johannes Berg 已提交
1000 1001 1002
	       !rs_is_valid_ant(valid_ant, new_ant_type))
		new_ant_type = ant_toggle_lookup[new_ant_type];

1003
	if (new_ant_type == rate->ant)
J
Johannes Berg 已提交
1004 1005
		return 0;

1006 1007
	rate->ant = new_ant_type;

J
Johannes Berg 已提交
1008 1009 1010 1011
	return 1;
}

static u16 rs_get_supported_rates(struct iwl_lq_sta *lq_sta,
1012
				  struct rs_rate *rate)
J
Johannes Berg 已提交
1013
{
1014
	if (is_legacy(rate))
J
Johannes Berg 已提交
1015
		return lq_sta->active_legacy_rate;
1016
	else if (is_siso(rate))
E
Eyal Shapira 已提交
1017
		return lq_sta->active_siso_rate;
1018
	else if (is_mimo2(rate))
E
Eyal Shapira 已提交
1019 1020 1021 1022
		return lq_sta->active_mimo2_rate;

	WARN_ON_ONCE(1);
	return 0;
J
Johannes Berg 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
}

static u16 rs_get_adjacent_rate(struct iwl_mvm *mvm, u8 index, u16 rate_mask,
				int rate_type)
{
	u8 high = IWL_RATE_INVALID;
	u8 low = IWL_RATE_INVALID;

	/* 802.11A or ht walks to the next literal adjacent rate in
	 * the rate table */
1033
	if (is_type_a_band(rate_type) || !is_type_legacy(rate_type)) {
J
Johannes Berg 已提交
1034 1035 1036 1037 1038
		int i;
		u32 mask;

		/* Find the previous rate that is in the rate mask */
		i = index - 1;
1039 1040 1041
		if (i >= 0)
			mask = BIT(i);
		for (; i >= 0; i--, mask >>= 1) {
J
Johannes Berg 已提交
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
			if (rate_mask & mask) {
				low = i;
				break;
			}
		}

		/* Find the next rate that is in the rate mask */
		i = index + 1;
		for (mask = (1 << i); i < IWL_RATE_COUNT; i++, mask <<= 1) {
			if (rate_mask & mask) {
				high = i;
				break;
			}
		}

		return (high << 8) | low;
	}

	low = index;
	while (low != IWL_RATE_INVALID) {
		low = iwl_rates[low].prev_rs;
		if (low == IWL_RATE_INVALID)
			break;
		if (rate_mask & (1 << low))
			break;
	}

	high = index;
	while (high != IWL_RATE_INVALID) {
		high = iwl_rates[high].next_rs;
		if (high == IWL_RATE_INVALID)
			break;
		if (rate_mask & (1 << high))
			break;
	}

	return (high << 8) | low;
}

1081 1082
static inline bool rs_rate_supported(struct iwl_lq_sta *lq_sta,
				     struct rs_rate *rate)
J
Johannes Berg 已提交
1083
{
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
	return BIT(rate->index) & rs_get_supported_rates(lq_sta, rate);
}

/* Get the next supported lower rate in the current column.
 * Return true if bottom rate in the current column was reached
 */
static bool rs_get_lower_rate_in_column(struct iwl_lq_sta *lq_sta,
					struct rs_rate *rate)
{
	u8 low;
J
Johannes Berg 已提交
1094
	u16 high_low;
1095
	u16 rate_mask;
1096
	struct iwl_mvm *mvm = lq_sta->pers.drv;
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114

	rate_mask = rs_get_supported_rates(lq_sta, rate);
	high_low = rs_get_adjacent_rate(mvm, rate->index, rate_mask,
					rate->type);
	low = high_low & 0xff;

	/* Bottom rate of column reached */
	if (low == IWL_RATE_INVALID)
		return true;

	rate->index = low;
	return false;
}

/* Get the next rate to use following a column downgrade */
static void rs_get_lower_rate_down_column(struct iwl_lq_sta *lq_sta,
					  struct rs_rate *rate)
{
1115
	struct iwl_mvm *mvm = lq_sta->pers.drv;
J
Johannes Berg 已提交
1116

1117 1118 1119 1120 1121
	if (is_legacy(rate)) {
		/* No column to downgrade from Legacy */
		return;
	} else if (is_siso(rate)) {
		/* Downgrade to Legacy if we were in SISO */
1122
		if (lq_sta->band == NL80211_BAND_5GHZ)
1123
			rate->type = LQ_LEGACY_A;
J
Johannes Berg 已提交
1124
		else
1125
			rate->type = LQ_LEGACY_G;
J
Johannes Berg 已提交
1126

1127
		rate->bw = RATE_MCS_CHAN_WIDTH_20;
J
Johannes Berg 已提交
1128

1129
		WARN_ON_ONCE(rate->index < IWL_RATE_MCS_0_INDEX ||
1130
			     rate->index > IWL_RATE_MCS_9_INDEX);
J
Johannes Berg 已提交
1131

1132
		rate->index = rs_ht_to_legacy[rate->index];
E
Eyal Shapira 已提交
1133
		rate->ldpc = false;
1134 1135 1136 1137
	} else {
		/* Downgrade to SISO with same MCS if in MIMO  */
		rate->type = is_vht_mimo2(rate) ?
			LQ_VHT_SISO : LQ_HT_SISO;
J
Johannes Berg 已提交
1138 1139
	}

1140
	if (num_of_ant(rate->ant) > 1)
1141
		rate->ant = first_antenna(iwl_mvm_get_valid_tx_ant(mvm));
J
Johannes Berg 已提交
1142

1143 1144 1145 1146 1147
	/* Relevant in both switching to SISO or Legacy */
	rate->sgi = false;

	if (!rs_rate_supported(lq_sta, rate))
		rs_get_lower_rate_in_column(lq_sta, rate);
J
Johannes Berg 已提交
1148 1149
}

1150 1151 1152
/* Check if both rates share the same column */
static inline bool rs_rate_column_match(struct rs_rate *a,
					struct rs_rate *b)
J
Johannes Berg 已提交
1153
{
1154 1155
	bool ant_match;

1156
	if (a->stbc || a->bfer)
1157 1158 1159 1160 1161 1162
		ant_match = (b->ant == ANT_A || b->ant == ANT_B);
	else
		ant_match = (a->ant == b->ant);

	return (a->type == b->type) && (a->bw == b->bw) && (a->sgi == b->sgi)
		&& ant_match;
J
Johannes Berg 已提交
1163 1164
}

1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
static inline enum rs_column rs_get_column_from_rate(struct rs_rate *rate)
{
	if (is_legacy(rate)) {
		if (rate->ant == ANT_A)
			return RS_COLUMN_LEGACY_ANT_A;

		if (rate->ant == ANT_B)
			return RS_COLUMN_LEGACY_ANT_B;

		goto err;
	}

	if (is_siso(rate)) {
		if (rate->ant == ANT_A || rate->stbc || rate->bfer)
			return rate->sgi ? RS_COLUMN_SISO_ANT_A_SGI :
				RS_COLUMN_SISO_ANT_A;

		if (rate->ant == ANT_B)
			return rate->sgi ? RS_COLUMN_SISO_ANT_B_SGI :
				RS_COLUMN_SISO_ANT_B;

		goto err;
	}

	if (is_mimo(rate))
		return rate->sgi ? RS_COLUMN_MIMO2_SGI : RS_COLUMN_MIMO2;

err:
	return RS_COLUMN_INVALID;
}

1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
static u8 rs_get_tid(struct ieee80211_hdr *hdr)
{
	u8 tid = IWL_MAX_TID_COUNT;

	if (ieee80211_is_data_qos(hdr->frame_control)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
		tid = qc[0] & 0xf;
	}

	if (unlikely(tid > IWL_MAX_TID_COUNT))
		tid = IWL_MAX_TID_COUNT;

	return tid;
}

void iwl_mvm_rs_tx_status(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
1212
			  int tid, struct ieee80211_tx_info *info, bool ndp)
J
Johannes Berg 已提交
1213 1214 1215
{
	int legacy_success;
	int retries;
1216
	int i;
J
Johannes Berg 已提交
1217
	struct iwl_lq_cmd *table;
1218 1219
	u32 lq_hwrate;
	struct rs_rate lq_rate, tx_resp_rate;
J
Johannes Berg 已提交
1220
	struct iwl_scale_tbl_info *curr_tbl, *other_tbl, *tmp_tbl;
1221 1222 1223
	u32 tlc_info = (uintptr_t)info->status.status_driver_data[0];
	u8 reduced_txp = tlc_info & RS_DRV_DATA_TXP_MSK;
	u8 lq_color = RS_DRV_DATA_LQ_COLOR_GET(tlc_info);
1224
	u32 tx_resp_hwrate = (uintptr_t)info->status.status_driver_data[1];
1225
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1226
	struct iwl_lq_sta *lq_sta = &mvmsta->lq_sta.rs_drv;
J
Johannes Berg 已提交
1227 1228 1229 1230 1231

	/* Treat uninitialized rate scaling data same as non-existing. */
	if (!lq_sta) {
		IWL_DEBUG_RATE(mvm, "Station rate scaling not created yet.\n");
		return;
1232
	} else if (!lq_sta->pers.drv) {
J
Johannes Berg 已提交
1233 1234 1235 1236
		IWL_DEBUG_RATE(mvm, "Rate scaling not initialized yet.\n");
		return;
	}

1237 1238 1239 1240 1241 1242 1243
	/* This packet was aggregated but doesn't carry status info */
	if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
	    !(info->flags & IEEE80211_TX_STAT_AMPDU))
		return;

	rs_rate_from_ucode_rate(tx_resp_hwrate, info->band, &tx_resp_rate);

1244
#ifdef CONFIG_MAC80211_DEBUGFS
1245 1246
	/* Disable last tx check if we are debugging with fixed rate but
	 * update tx stats */
1247
	if (lq_sta->pers.dbg_fixed_rate) {
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
		int index = tx_resp_rate.index;
		enum rs_column column;
		int attempts, success;

		column = rs_get_column_from_rate(&tx_resp_rate);
		if (WARN_ONCE(column == RS_COLUMN_INVALID,
			      "Can't map rate 0x%x to column",
			      tx_resp_hwrate))
			return;

		if (info->flags & IEEE80211_TX_STAT_AMPDU) {
			attempts = info->status.ampdu_len;
			success = info->status.ampdu_ack_len;
		} else {
			attempts = info->status.rates[0].count;
			success = !!(info->flags & IEEE80211_TX_STAT_ACK);
		}

		lq_sta->pers.tx_stats[column][index].total += attempts;
		lq_sta->pers.tx_stats[column][index].success += success;

		IWL_DEBUG_RATE(mvm, "Fixed rate 0x%x success %d attempts %d\n",
			       tx_resp_hwrate, success, attempts);
1271 1272 1273
		return;
	}
#endif
J
Johannes Berg 已提交
1274

1275
	if (time_after(jiffies,
1276 1277
		       (unsigned long)(lq_sta->last_tx +
				       (IWL_MVM_RS_IDLE_TIMEOUT * HZ)))) {
1278
		IWL_DEBUG_RATE(mvm, "Tx idle for too long. reinit rs\n");
1279
		iwl_mvm_rs_rate_init(mvm, sta, info->band, true);
1280 1281 1282 1283
		return;
	}
	lq_sta->last_tx = jiffies;

1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
	/* Ignore this Tx frame response if its initial rate doesn't match
	 * that of latest Link Quality command.  There may be stragglers
	 * from a previous Link Quality command, but we're no longer interested
	 * in those; they're either from the "active" mode while we're trying
	 * to check "search" mode, or a prior "search" mode after we've moved
	 * to a new "search" mode (which might become the new "active" mode).
	 */
	table = &lq_sta->lq;
	lq_hwrate = le32_to_cpu(table->rs_table[0]);
	rs_rate_from_ucode_rate(lq_hwrate, info->band, &lq_rate);

J
Johannes Berg 已提交
1295
	/* Here we actually compare this rate to the latest LQ command */
1296
	if (lq_color != LQ_FLAG_COLOR_GET(table->flags)) {
J
Johannes Berg 已提交
1297
		IWL_DEBUG_RATE(mvm,
1298 1299
			       "tx resp color 0x%x does not match 0x%x\n",
			       lq_color, LQ_FLAG_COLOR_GET(table->flags));
1300

J
Johannes Berg 已提交
1301 1302 1303 1304 1305 1306
		/*
		 * Since rates mis-match, the last LQ command may have failed.
		 * After IWL_MISSED_RATE_MAX mis-matches, resync the uCode with
		 * ... driver.
		 */
		lq_sta->missed_rate_counter++;
1307
		if (lq_sta->missed_rate_counter > IWL_MVM_RS_MISSED_RATE_MAX) {
J
Johannes Berg 已提交
1308
			lq_sta->missed_rate_counter = 0;
1309 1310 1311
			IWL_DEBUG_RATE(mvm,
				       "Too many rates mismatch. Send sync LQ. rs_state %d\n",
				       lq_sta->rs_state);
1312
			iwl_mvm_send_lq_cmd(mvm, &lq_sta->lq, false);
J
Johannes Berg 已提交
1313 1314 1315 1316 1317 1318 1319
		}
		/* Regardless, ignore this status info for outdated rate */
		return;
	} else
		/* Rate did match, so reset the missed_rate_counter */
		lq_sta->missed_rate_counter = 0;

1320
	if (!lq_sta->search_better_tbl) {
J
Johannes Berg 已提交
1321 1322
		curr_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
		other_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
1323
	} else {
J
Johannes Berg 已提交
1324 1325
		curr_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
		other_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1326 1327
	}

1328
	if (WARN_ON_ONCE(!rs_rate_column_match(&lq_rate, &curr_tbl->rate))) {
J
Johannes Berg 已提交
1329 1330 1331
		IWL_DEBUG_RATE(mvm,
			       "Neither active nor search matches tx rate\n");
		tmp_tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
1332
		rs_dump_rate(mvm, &tmp_tbl->rate, "ACTIVE");
J
Johannes Berg 已提交
1333
		tmp_tbl = &(lq_sta->lq_info[1 - lq_sta->active_tbl]);
1334
		rs_dump_rate(mvm, &tmp_tbl->rate, "SEARCH");
1335
		rs_dump_rate(mvm, &lq_rate, "ACTUAL");
1336

J
Johannes Berg 已提交
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
		/*
		 * no matching table found, let's by-pass the data collection
		 * and continue to perform rate scale to find the rate table
		 */
		rs_stay_in_table(lq_sta, true);
		goto done;
	}

	/*
	 * Updating the frame history depends on whether packets were
	 * aggregated.
	 *
	 * For aggregation, all packets were transmitted at the same rate, the
	 * first index into rate scale table.
	 */
	if (info->flags & IEEE80211_TX_STAT_AMPDU) {
1353
		rs_collect_tpc_data(mvm, lq_sta, curr_tbl, tx_resp_rate.index,
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
				    info->status.ampdu_len,
				    info->status.ampdu_ack_len,
				    reduced_txp);

		/* ampdu_ack_len = 0 marks no BA was received. For TLC, treat
		 * it as a single frame loss as we don't want the success ratio
		 * to dip too quickly because a BA wasn't received.
		 * For TPC, there's no need for this optimisation since we want
		 * to recover very quickly from a bad power reduction and,
		 * therefore we'd like the success ratio to get an immediate hit
		 * when failing to get a BA, so we'd switch back to a lower or
		 * zero power reduction. When FW transmits agg with a rate
		 * different from the initial rate, it will not use reduced txp
		 * and will send BA notification twice (one empty with reduced
		 * txp equal to the value from LQ and one with reduced txp 0).
		 * We need to update counters for each txp level accordingly.
1370 1371 1372 1373
		 */
		if (info->status.ampdu_ack_len == 0)
			info->status.ampdu_len = 1;

1374
		rs_collect_tlc_data(mvm, mvmsta, tid, curr_tbl, tx_resp_rate.index,
1375 1376
				    info->status.ampdu_len,
				    info->status.ampdu_ack_len);
J
Johannes Berg 已提交
1377 1378

		/* Update success/fail counts if not searching for new mode */
1379
		if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN) {
J
Johannes Berg 已提交
1380 1381 1382 1383 1384
			lq_sta->total_success += info->status.ampdu_ack_len;
			lq_sta->total_failed += (info->status.ampdu_len -
					info->status.ampdu_ack_len);
		}
	} else {
1385
		/* For legacy, update frame history with for each Tx retry. */
J
Johannes Berg 已提交
1386 1387 1388 1389 1390 1391 1392 1393
		retries = info->status.rates[0].count - 1;
		/* HW doesn't send more than 15 retries */
		retries = min(retries, 15);

		/* The last transmission may have been successful */
		legacy_success = !!(info->flags & IEEE80211_TX_STAT_ACK);
		/* Collect data for each rate used during failed TX attempts */
		for (i = 0; i <= retries; ++i) {
1394 1395 1396
			lq_hwrate = le32_to_cpu(table->rs_table[i]);
			rs_rate_from_ucode_rate(lq_hwrate, info->band,
						&lq_rate);
J
Johannes Berg 已提交
1397 1398 1399 1400
			/*
			 * Only collect stats if retried rate is in the same RS
			 * table as active/search.
			 */
1401
			if (rs_rate_column_match(&lq_rate, &curr_tbl->rate))
J
Johannes Berg 已提交
1402
				tmp_tbl = curr_tbl;
1403 1404
			else if (rs_rate_column_match(&lq_rate,
						      &other_tbl->rate))
J
Johannes Berg 已提交
1405
				tmp_tbl = other_tbl;
1406
			else
J
Johannes Berg 已提交
1407
				continue;
1408

1409
			rs_collect_tpc_data(mvm, lq_sta, tmp_tbl,
1410
					    tx_resp_rate.index, 1,
1411 1412
					    i < retries ? 0 : legacy_success,
					    reduced_txp);
1413
			rs_collect_tlc_data(mvm, mvmsta, tid, tmp_tbl,
1414
					    tx_resp_rate.index, 1,
1415
					    i < retries ? 0 : legacy_success);
J
Johannes Berg 已提交
1416 1417 1418
		}

		/* Update success/fail counts if not searching for new mode */
1419
		if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN) {
J
Johannes Berg 已提交
1420 1421 1422 1423 1424
			lq_sta->total_success += legacy_success;
			lq_sta->total_failed += retries + (1 - legacy_success);
		}
	}
	/* The last TX rate is cached in lq_sta; it's set in if/else above */
1425
	lq_sta->last_rate_n_flags = lq_hwrate;
1426
	IWL_DEBUG_RATE(mvm, "reduced txpower: %d\n", reduced_txp);
J
Johannes Berg 已提交
1427 1428
done:
	/* See if there's a better rate or modulation mode to try. */
1429
	if (sta->supp_rates[info->band])
1430
		rs_rate_scale_perform(mvm, sta, lq_sta, tid, ndp);
1431 1432 1433 1434 1435
}

/*
 * mac80211 sends us Tx status
 */
1436 1437 1438 1439
static void rs_drv_mac80211_tx_status(void *mvm_r,
				      struct ieee80211_supported_band *sband,
				      struct ieee80211_sta *sta, void *priv_sta,
				      struct sk_buff *skb)
1440 1441
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1442
	struct iwl_op_mode *op_mode = mvm_r;
1443 1444 1445
	struct iwl_mvm *mvm = IWL_OP_MODE_GET_MVM(op_mode);
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

1446 1447 1448
	if (!iwl_mvm_sta_from_mac80211(sta)->vif)
		return;

1449 1450 1451 1452
	if (!ieee80211_is_data(hdr->frame_control) ||
	    info->flags & IEEE80211_TX_CTL_NO_ACK)
		return;

1453 1454
	iwl_mvm_rs_tx_status(mvm, sta, rs_get_tid(hdr), info,
			     ieee80211_is_qos_nullfunc(hdr->frame_control));
J
Johannes Berg 已提交
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
}

/*
 * Begin a period of staying with a selected modulation mode.
 * Set "stay_in_tbl" flag to prevent any mode switches.
 * Set frame tx success limits according to legacy vs. high-throughput,
 * and reset overall (spanning all rates) tx success history statistics.
 * These control how long we stay using same modulation mode before
 * searching for a new mode.
 */
static void rs_set_stay_in_table(struct iwl_mvm *mvm, u8 is_legacy,
				 struct iwl_lq_sta *lq_sta)
{
1468 1469
	IWL_DEBUG_RATE(mvm, "Moving to RS_STATE_STAY_IN_COLUMN\n");
	lq_sta->rs_state = RS_STATE_STAY_IN_COLUMN;
J
Johannes Berg 已提交
1470
	if (is_legacy) {
1471 1472 1473
		lq_sta->table_count_limit = IWL_MVM_RS_LEGACY_TABLE_COUNT;
		lq_sta->max_failure_limit = IWL_MVM_RS_LEGACY_FAILURE_LIMIT;
		lq_sta->max_success_limit = IWL_MVM_RS_LEGACY_SUCCESS_LIMIT;
J
Johannes Berg 已提交
1474
	} else {
1475 1476 1477
		lq_sta->table_count_limit = IWL_MVM_RS_NON_LEGACY_TABLE_COUNT;
		lq_sta->max_failure_limit = IWL_MVM_RS_NON_LEGACY_FAILURE_LIMIT;
		lq_sta->max_success_limit = IWL_MVM_RS_NON_LEGACY_SUCCESS_LIMIT;
J
Johannes Berg 已提交
1478 1479 1480 1481 1482
	}
	lq_sta->table_count = 0;
	lq_sta->total_failed = 0;
	lq_sta->total_success = 0;
	lq_sta->flush_timer = jiffies;
1483
	lq_sta->visited_columns = 0;
J
Johannes Berg 已提交
1484 1485
}

1486 1487 1488 1489 1490 1491 1492
static inline int rs_get_max_rate_from_mask(unsigned long rate_mask)
{
	if (rate_mask)
		return find_last_bit(&rate_mask, BITS_PER_LONG);
	return IWL_RATE_INVALID;
}

1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
static int rs_get_max_allowed_rate(struct iwl_lq_sta *lq_sta,
				   const struct rs_tx_column *column)
{
	switch (column->mode) {
	case RS_LEGACY:
		return lq_sta->max_legacy_rate_idx;
	case RS_SISO:
		return lq_sta->max_siso_rate_idx;
	case RS_MIMO2:
		return lq_sta->max_mimo2_rate_idx;
	default:
		WARN_ON_ONCE(1);
	}

	return lq_sta->max_legacy_rate_idx;
}

1510
static const u16 *rs_get_expected_tpt_table(struct iwl_lq_sta *lq_sta,
1511 1512
					    const struct rs_tx_column *column,
					    u32 bw)
J
Johannes Berg 已提交
1513 1514
{
	/* Used to choose among HT tables */
1515
	const u16 (*ht_tbl_pointer)[IWL_RATE_COUNT];
J
Johannes Berg 已提交
1516

1517 1518 1519 1520
	if (WARN_ON_ONCE(column->mode != RS_LEGACY &&
			 column->mode != RS_SISO &&
			 column->mode != RS_MIMO2))
		return expected_tpt_legacy;
J
Johannes Berg 已提交
1521 1522

	/* Legacy rates have only one table */
1523 1524
	if (column->mode == RS_LEGACY)
		return expected_tpt_legacy;
J
Johannes Berg 已提交
1525

E
Eyal Shapira 已提交
1526
	ht_tbl_pointer = expected_tpt_mimo2_20MHz;
J
Johannes Berg 已提交
1527
	/* Choose among many HT tables depending on number of streams
E
Eyal Shapira 已提交
1528
	 * (SISO/MIMO2), channel width (20/40/80), SGI, and aggregation
J
Johannes Berg 已提交
1529
	 * status */
1530 1531
	if (column->mode == RS_SISO) {
		switch (bw) {
E
Eyal Shapira 已提交
1532 1533 1534 1535 1536 1537 1538 1539 1540
		case RATE_MCS_CHAN_WIDTH_20:
			ht_tbl_pointer = expected_tpt_siso_20MHz;
			break;
		case RATE_MCS_CHAN_WIDTH_40:
			ht_tbl_pointer = expected_tpt_siso_40MHz;
			break;
		case RATE_MCS_CHAN_WIDTH_80:
			ht_tbl_pointer = expected_tpt_siso_80MHz;
			break;
1541 1542 1543
		case RATE_MCS_CHAN_WIDTH_160:
			ht_tbl_pointer = expected_tpt_siso_160MHz;
			break;
E
Eyal Shapira 已提交
1544 1545 1546
		default:
			WARN_ON_ONCE(1);
		}
1547 1548
	} else if (column->mode == RS_MIMO2) {
		switch (bw) {
E
Eyal Shapira 已提交
1549 1550 1551 1552 1553 1554 1555 1556 1557
		case RATE_MCS_CHAN_WIDTH_20:
			ht_tbl_pointer = expected_tpt_mimo2_20MHz;
			break;
		case RATE_MCS_CHAN_WIDTH_40:
			ht_tbl_pointer = expected_tpt_mimo2_40MHz;
			break;
		case RATE_MCS_CHAN_WIDTH_80:
			ht_tbl_pointer = expected_tpt_mimo2_80MHz;
			break;
1558 1559 1560
		case RATE_MCS_CHAN_WIDTH_160:
			ht_tbl_pointer = expected_tpt_mimo2_160MHz;
			break;
E
Eyal Shapira 已提交
1561 1562 1563 1564 1565
		default:
			WARN_ON_ONCE(1);
		}
	} else {
		WARN_ON_ONCE(1);
1566
	}
J
Johannes Berg 已提交
1567

1568 1569 1570 1571 1572 1573
	if (!column->sgi && !lq_sta->is_agg)		/* Normal */
		return ht_tbl_pointer[0];
	else if (column->sgi && !lq_sta->is_agg)        /* SGI */
		return ht_tbl_pointer[1];
	else if (!column->sgi && lq_sta->is_agg)        /* AGG */
		return ht_tbl_pointer[2];
J
Johannes Berg 已提交
1574
	else						/* AGG+SGI */
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
		return ht_tbl_pointer[3];
}

static void rs_set_expected_tpt_table(struct iwl_lq_sta *lq_sta,
				      struct iwl_scale_tbl_info *tbl)
{
	struct rs_rate *rate = &tbl->rate;
	const struct rs_tx_column *column = &rs_tx_columns[tbl->column];

	tbl->expected_tpt = rs_get_expected_tpt_table(lq_sta, column, rate->bw);
J
Johannes Berg 已提交
1585 1586 1587 1588 1589
}

static s32 rs_get_best_rate(struct iwl_mvm *mvm,
			    struct iwl_lq_sta *lq_sta,
			    struct iwl_scale_tbl_info *tbl,	/* "search" */
1590
			    unsigned long rate_mask, s8 index)
J
Johannes Berg 已提交
1591 1592 1593
{
	struct iwl_scale_tbl_info *active_tbl =
	    &(lq_sta->lq_info[lq_sta->active_tbl]);
1594 1595
	s32 success_ratio = active_tbl->win[index].success_ratio;
	u16 expected_current_tpt = active_tbl->expected_tpt[index];
1596
	const u16 *tpt_tbl = tbl->expected_tpt;
J
Johannes Berg 已提交
1597
	u16 high_low;
1598 1599
	u32 target_tpt;
	int rate_idx;
J
Johannes Berg 已提交
1600

1601
	if (success_ratio >= RS_PERCENT(IWL_MVM_RS_SR_NO_DECREASE)) {
1602 1603 1604 1605 1606 1607 1608
		target_tpt = 100 * expected_current_tpt;
		IWL_DEBUG_RATE(mvm,
			       "SR %d high. Find rate exceeding EXPECTED_CURRENT %d\n",
			       success_ratio, target_tpt);
	} else {
		target_tpt = lq_sta->last_tpt;
		IWL_DEBUG_RATE(mvm,
1609
			       "SR %d not that good. Find rate exceeding ACTUAL_TPT %d\n",
1610 1611
			       success_ratio, target_tpt);
	}
J
Johannes Berg 已提交
1612

1613
	rate_idx = find_first_bit(&rate_mask, BITS_PER_LONG);
J
Johannes Berg 已提交
1614

1615 1616 1617
	while (rate_idx != IWL_RATE_INVALID) {
		if (target_tpt < (100 * tpt_tbl[rate_idx]))
			break;
J
Johannes Berg 已提交
1618

1619 1620
		high_low = rs_get_adjacent_rate(mvm, rate_idx, rate_mask,
						tbl->rate.type);
J
Johannes Berg 已提交
1621

1622
		rate_idx = (high_low >> 8) & 0xff;
J
Johannes Berg 已提交
1623 1624
	}

1625 1626 1627 1628 1629 1630
	IWL_DEBUG_RATE(mvm, "Best rate found %d target_tp %d expected_new %d\n",
		       rate_idx, target_tpt,
		       rate_idx != IWL_RATE_INVALID ?
		       100 * tpt_tbl[rate_idx] : IWL_INVALID_VALUE);

	return rate_idx;
J
Johannes Berg 已提交
1631 1632
}

1633
static u32 rs_bw_from_sta_bw(struct ieee80211_sta *sta)
E
Eyal Shapira 已提交
1634
{
1635 1636 1637 1638
	switch (sta->bandwidth) {
	case IEEE80211_STA_RX_BW_160:
		return RATE_MCS_CHAN_WIDTH_160;
	case IEEE80211_STA_RX_BW_80:
1639
		return RATE_MCS_CHAN_WIDTH_80;
1640
	case IEEE80211_STA_RX_BW_40:
1641
		return RATE_MCS_CHAN_WIDTH_40;
1642 1643 1644 1645
	case IEEE80211_STA_RX_BW_20:
	default:
		return RATE_MCS_CHAN_WIDTH_20;
	}
E
Eyal Shapira 已提交
1646 1647
}

J
Johannes Berg 已提交
1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
/*
 * Check whether we should continue using same modulation mode, or
 * begin search for a new mode, based on:
 * 1) # tx successes or failures while using this mode
 * 2) # times calling this function
 * 3) elapsed time in this mode (not used, for now)
 */
static void rs_stay_in_table(struct iwl_lq_sta *lq_sta, bool force_search)
{
	struct iwl_scale_tbl_info *tbl;
	int active_tbl;
	int flush_interval_passed = 0;
	struct iwl_mvm *mvm;

1662
	mvm = lq_sta->pers.drv;
J
Johannes Berg 已提交
1663 1664 1665 1666 1667
	active_tbl = lq_sta->active_tbl;

	tbl = &(lq_sta->lq_info[active_tbl]);

	/* If we've been disallowing search, see if we should now allow it */
1668
	if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN) {
J
Johannes Berg 已提交
1669 1670 1671 1672 1673
		/* Elapsed time using current modulation mode */
		if (lq_sta->flush_timer)
			flush_interval_passed =
				time_after(jiffies,
					   (unsigned long)(lq_sta->flush_timer +
1674
							   (IWL_MVM_RS_STAY_IN_COLUMN_TIMEOUT * HZ)));
J
Johannes Berg 已提交
1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695

		/*
		 * Check if we should allow search for new modulation mode.
		 * If many frames have failed or succeeded, or we've used
		 * this same modulation for a long time, allow search, and
		 * reset history stats that keep track of whether we should
		 * allow a new search.  Also (below) reset all bitmaps and
		 * stats in active history.
		 */
		if (force_search ||
		    (lq_sta->total_failed > lq_sta->max_failure_limit) ||
		    (lq_sta->total_success > lq_sta->max_success_limit) ||
		    ((!lq_sta->search_better_tbl) &&
		     (lq_sta->flush_timer) && (flush_interval_passed))) {
			IWL_DEBUG_RATE(mvm,
				       "LQ: stay is expired %d %d %d\n",
				     lq_sta->total_failed,
				     lq_sta->total_success,
				     flush_interval_passed);

			/* Allow search for new mode */
1696 1697 1698
			lq_sta->rs_state = RS_STATE_SEARCH_CYCLE_STARTED;
			IWL_DEBUG_RATE(mvm,
				       "Moving to RS_STATE_SEARCH_CYCLE_STARTED\n");
J
Johannes Berg 已提交
1699 1700 1701
			lq_sta->total_failed = 0;
			lq_sta->total_success = 0;
			lq_sta->flush_timer = 0;
1702 1703
			/* mark the current column as visited */
			lq_sta->visited_columns = BIT(tbl->column);
J
Johannes Berg 已提交
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
		/*
		 * Else if we've used this modulation mode enough repetitions
		 * (regardless of elapsed time or success/failure), reset
		 * history bitmaps and rate-specific stats for all rates in
		 * active table.
		 */
		} else {
			lq_sta->table_count++;
			if (lq_sta->table_count >=
			    lq_sta->table_count_limit) {
				lq_sta->table_count = 0;

				IWL_DEBUG_RATE(mvm,
					       "LQ: stay in table clear win\n");
1718
				rs_rate_scale_clear_tbl_windows(mvm, tbl);
J
Johannes Berg 已提交
1719 1720 1721 1722 1723 1724
			}
		}

		/* If transitioning to allow "search", reset all history
		 * bitmaps and stats in active table (this will become the new
		 * "search" table). */
1725
		if (lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_STARTED) {
1726
			rs_rate_scale_clear_tbl_windows(mvm, tbl);
J
Johannes Berg 已提交
1727 1728 1729 1730
		}
	}
}

1731 1732 1733 1734
static void rs_set_amsdu_len(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
			     struct iwl_scale_tbl_info *tbl,
			     enum rs_action scale_action)
{
1735
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
1736

1737 1738 1739 1740
	/*
	 * In case TLC offload is not active amsdu_enabled is either 0xFFFF
	 * or 0, since there is no per-TID alg.
	 */
1741 1742 1743
	if ((!is_vht(&tbl->rate) && !is_ht(&tbl->rate)) ||
	    tbl->rate.index < IWL_RATE_MCS_5_INDEX ||
	    scale_action == RS_ACTION_DOWNSCALE)
1744
		mvmsta->amsdu_enabled = 0;
1745
	else
1746 1747 1748
		mvmsta->amsdu_enabled = 0xFFFF;

	mvmsta->max_amsdu_len = sta->max_amsdu_len;
1749 1750
}

J
Johannes Berg 已提交
1751 1752 1753 1754
/*
 * setup rate table in uCode
 */
static void rs_update_rate_tbl(struct iwl_mvm *mvm,
1755
			       struct ieee80211_sta *sta,
J
Johannes Berg 已提交
1756
			       struct iwl_lq_sta *lq_sta,
1757
			       struct iwl_scale_tbl_info *tbl)
J
Johannes Berg 已提交
1758
{
1759
	rs_fill_lq_cmd(mvm, sta, lq_sta, &tbl->rate);
1760
	iwl_mvm_send_lq_cmd(mvm, &lq_sta->lq, false);
J
Johannes Berg 已提交
1761 1762
}

1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
static bool rs_tweak_rate_tbl(struct iwl_mvm *mvm,
			      struct ieee80211_sta *sta,
			      struct iwl_lq_sta *lq_sta,
			      struct iwl_scale_tbl_info *tbl,
			      enum rs_action scale_action)
{
	if (sta->bandwidth != IEEE80211_STA_RX_BW_80)
		return false;

	if (!is_vht_siso(&tbl->rate))
		return false;

	if ((tbl->rate.bw == RATE_MCS_CHAN_WIDTH_80) &&
	    (tbl->rate.index == IWL_RATE_MCS_0_INDEX) &&
	    (scale_action == RS_ACTION_DOWNSCALE)) {
		tbl->rate.bw = RATE_MCS_CHAN_WIDTH_20;
		tbl->rate.index = IWL_RATE_MCS_4_INDEX;
		IWL_DEBUG_RATE(mvm, "Switch 80Mhz SISO MCS0 -> 20Mhz MCS4\n");
		goto tweaked;
	}

	/* Go back to 80Mhz MCS1 only if we've established that 20Mhz MCS5 is
	 * sustainable, i.e. we're past the test window. We can't go back
	 * if MCS5 is just tested as this will happen always after switching
	 * to 20Mhz MCS4 because the rate stats are cleared.
	 */
	if ((tbl->rate.bw == RATE_MCS_CHAN_WIDTH_20) &&
	    (((tbl->rate.index == IWL_RATE_MCS_5_INDEX) &&
	     (scale_action == RS_ACTION_STAY)) ||
	     ((tbl->rate.index > IWL_RATE_MCS_5_INDEX) &&
	      (scale_action == RS_ACTION_UPSCALE)))) {
		tbl->rate.bw = RATE_MCS_CHAN_WIDTH_80;
		tbl->rate.index = IWL_RATE_MCS_1_INDEX;
		IWL_DEBUG_RATE(mvm, "Switch 20Mhz SISO MCS5 -> 80Mhz MCS1\n");
		goto tweaked;
	}

	return false;

tweaked:
	rs_set_expected_tpt_table(lq_sta, tbl);
	rs_rate_scale_clear_tbl_windows(mvm, tbl);
	return true;
}

1808 1809 1810 1811 1812
static enum rs_column rs_get_next_column(struct iwl_mvm *mvm,
					 struct iwl_lq_sta *lq_sta,
					 struct ieee80211_sta *sta,
					 struct iwl_scale_tbl_info *tbl)
{
1813
	int i, j, max_rate;
1814 1815 1816 1817
	enum rs_column next_col_id;
	const struct rs_tx_column *curr_col = &rs_tx_columns[tbl->column];
	const struct rs_tx_column *next_col;
	allow_column_func_t allow_func;
1818
	u8 valid_ants = iwl_mvm_get_valid_tx_ant(mvm);
1819
	const u16 *expected_tpt_tbl;
1820
	u16 tpt, max_expected_tpt;
1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844

	for (i = 0; i < MAX_NEXT_COLUMNS; i++) {
		next_col_id = curr_col->next_columns[i];

		if (next_col_id == RS_COLUMN_INVALID)
			continue;

		if (lq_sta->visited_columns & BIT(next_col_id)) {
			IWL_DEBUG_RATE(mvm, "Skip already visited column %d\n",
				       next_col_id);
			continue;
		}

		next_col = &rs_tx_columns[next_col_id];

		if (!rs_is_valid_ant(valid_ants, next_col->ant)) {
			IWL_DEBUG_RATE(mvm,
				       "Skip column %d as ANT config isn't supported by chip. valid_ants 0x%x column ant 0x%x\n",
				       next_col_id, valid_ants, next_col->ant);
			continue;
		}

		for (j = 0; j < MAX_COLUMN_CHECKS; j++) {
			allow_func = next_col->checks[j];
1845 1846
			if (allow_func && !allow_func(mvm, sta, &tbl->rate,
						      next_col))
1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859
				break;
		}

		if (j != MAX_COLUMN_CHECKS) {
			IWL_DEBUG_RATE(mvm,
				       "Skip column %d: not allowed (check %d failed)\n",
				       next_col_id, j);

			continue;
		}

		tpt = lq_sta->last_tpt / 100;
		expected_tpt_tbl = rs_get_expected_tpt_table(lq_sta, next_col,
1860
						     rs_bw_from_sta_bw(sta));
1861 1862 1863
		if (WARN_ON_ONCE(!expected_tpt_tbl))
			continue;

1864
		max_rate = rs_get_max_allowed_rate(lq_sta, next_col);
1865 1866 1867 1868
		if (max_rate == IWL_RATE_INVALID) {
			IWL_DEBUG_RATE(mvm,
				       "Skip column %d: no rate is allowed in this column\n",
				       next_col_id);
1869
			continue;
1870
		}
1871

1872
		max_expected_tpt = expected_tpt_tbl[max_rate];
1873 1874 1875 1876 1877 1878 1879
		if (tpt >= max_expected_tpt) {
			IWL_DEBUG_RATE(mvm,
				       "Skip column %d: can't beat current TPT. Max expected %d current %d\n",
				       next_col_id, max_expected_tpt, tpt);
			continue;
		}

1880 1881 1882
		IWL_DEBUG_RATE(mvm,
			       "Found potential column %d. Max expected %d current %d\n",
			       next_col_id, max_expected_tpt, tpt);
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
		break;
	}

	if (i == MAX_NEXT_COLUMNS)
		return RS_COLUMN_INVALID;

	return next_col_id;
}

static int rs_switch_to_column(struct iwl_mvm *mvm,
			       struct iwl_lq_sta *lq_sta,
			       struct ieee80211_sta *sta,
			       enum rs_column col_id)
{
	struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
	struct iwl_scale_tbl_info *search_tbl =
				&(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
	struct rs_rate *rate = &search_tbl->rate;
	const struct rs_tx_column *column = &rs_tx_columns[col_id];
	const struct rs_tx_column *curr_column = &rs_tx_columns[tbl->column];
1903
	unsigned long rate_mask = 0;
1904 1905
	u32 rate_idx = 0;

1906
	memcpy(search_tbl, tbl, offsetof(struct iwl_scale_tbl_info, win));
1907 1908 1909 1910 1911

	rate->sgi = column->sgi;
	rate->ant = column->ant;

	if (column->mode == RS_LEGACY) {
1912
		if (lq_sta->band == NL80211_BAND_5GHZ)
1913 1914 1915 1916
			rate->type = LQ_LEGACY_A;
		else
			rate->type = LQ_LEGACY_G;

1917 1918
		rate->bw = RATE_MCS_CHAN_WIDTH_20;
		rate->ldpc = false;
1919 1920 1921 1922 1923 1924 1925 1926
		rate_mask = lq_sta->active_legacy_rate;
	} else if (column->mode == RS_SISO) {
		rate->type = lq_sta->is_vht ? LQ_VHT_SISO : LQ_HT_SISO;
		rate_mask = lq_sta->active_siso_rate;
	} else if (column->mode == RS_MIMO2) {
		rate->type = lq_sta->is_vht ? LQ_VHT_MIMO2 : LQ_HT_MIMO2;
		rate_mask = lq_sta->active_mimo2_rate;
	} else {
1927
		WARN_ONCE(1, "Bad column mode");
1928 1929
	}

1930 1931 1932 1933 1934
	if (column->mode != RS_LEGACY) {
		rate->bw = rs_bw_from_sta_bw(sta);
		rate->ldpc = lq_sta->ldpc;
	}

1935 1936 1937
	search_tbl->column = col_id;
	rs_set_expected_tpt_table(lq_sta, search_tbl);

1938 1939
	lq_sta->visited_columns |= BIT(col_id);

1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
	/* Get the best matching rate if we're changing modes. e.g.
	 * SISO->MIMO, LEGACY->SISO, MIMO->SISO
	 */
	if (curr_column->mode != column->mode) {
		rate_idx = rs_get_best_rate(mvm, lq_sta, search_tbl,
					    rate_mask, rate->index);

		if ((rate_idx == IWL_RATE_INVALID) ||
		    !(BIT(rate_idx) & rate_mask)) {
			IWL_DEBUG_RATE(mvm,
				       "can not switch with index %d"
1951
				       " rate mask %lx\n",
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
				       rate_idx, rate_mask);

			goto err;
		}

		rate->index = rate_idx;
	}

	IWL_DEBUG_RATE(mvm, "Switched to column %d: Index %d\n",
		       col_id, rate->index);

	return 0;

err:
	rate->type = LQ_NONE;
	return -1;
}

1970 1971 1972 1973 1974 1975 1976 1977
static enum rs_action rs_get_rate_action(struct iwl_mvm *mvm,
					 struct iwl_scale_tbl_info *tbl,
					 s32 sr, int low, int high,
					 int current_tpt,
					 int low_tpt, int high_tpt)
{
	enum rs_action action = RS_ACTION_STAY;

1978 1979
	if ((sr <= RS_PERCENT(IWL_MVM_RS_SR_FORCE_DECREASE)) ||
	    (current_tpt == 0)) {
1980
		IWL_DEBUG_RATE(mvm,
1981 1982
			       "Decrease rate because of low SR\n");
		return RS_ACTION_DOWNSCALE;
1983 1984
	}

1985 1986 1987
	if ((low_tpt == IWL_INVALID_VALUE) &&
	    (high_tpt == IWL_INVALID_VALUE) &&
	    (high != IWL_RATE_INVALID)) {
1988
		IWL_DEBUG_RATE(mvm,
1989 1990
			       "No data about high/low rates. Increase rate\n");
		return RS_ACTION_UPSCALE;
1991 1992
	}

1993 1994 1995 1996 1997 1998 1999 2000
	if ((high_tpt == IWL_INVALID_VALUE) &&
	    (high != IWL_RATE_INVALID) &&
	    (low_tpt != IWL_INVALID_VALUE) &&
	    (low_tpt < current_tpt)) {
		IWL_DEBUG_RATE(mvm,
			       "No data about high rate and low rate is worse. Increase rate\n");
		return RS_ACTION_UPSCALE;
	}
2001

2002 2003 2004 2005 2006
	if ((high_tpt != IWL_INVALID_VALUE) &&
	    (high_tpt > current_tpt)) {
		IWL_DEBUG_RATE(mvm,
			       "Higher rate is better. Increate rate\n");
		return RS_ACTION_UPSCALE;
2007 2008
	}

2009 2010 2011 2012
	if ((low_tpt != IWL_INVALID_VALUE) &&
	    (high_tpt != IWL_INVALID_VALUE) &&
	    (low_tpt < current_tpt) &&
	    (high_tpt < current_tpt)) {
2013
		IWL_DEBUG_RATE(mvm,
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027
			       "Both high and low are worse. Maintain rate\n");
		return RS_ACTION_STAY;
	}

	if ((low_tpt != IWL_INVALID_VALUE) &&
	    (low_tpt > current_tpt)) {
		IWL_DEBUG_RATE(mvm,
			       "Lower rate is better\n");
		action = RS_ACTION_DOWNSCALE;
		goto out;
	}

	if ((low_tpt == IWL_INVALID_VALUE) &&
	    (low != IWL_RATE_INVALID)) {
2028
		IWL_DEBUG_RATE(mvm,
2029 2030 2031 2032 2033 2034 2035 2036 2037
			       "No data about lower rate\n");
		action = RS_ACTION_DOWNSCALE;
		goto out;
	}

	IWL_DEBUG_RATE(mvm, "Maintain rate\n");

out:
	if ((action == RS_ACTION_DOWNSCALE) && (low != IWL_RATE_INVALID)) {
2038
		if (sr >= RS_PERCENT(IWL_MVM_RS_SR_NO_DECREASE)) {
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048
			IWL_DEBUG_RATE(mvm,
				       "SR is above NO DECREASE. Avoid downscale\n");
			action = RS_ACTION_STAY;
		} else if (current_tpt > (100 * tbl->expected_tpt[low])) {
			IWL_DEBUG_RATE(mvm,
				       "Current TPT is higher than max expected in low rate. Avoid downscale\n");
			action = RS_ACTION_STAY;
		} else {
			IWL_DEBUG_RATE(mvm, "Decrease rate\n");
		}
2049 2050 2051 2052
	}

	return action;
}
2053

2054 2055 2056 2057 2058 2059
static bool rs_stbc_allow(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
			  struct iwl_lq_sta *lq_sta)
{
	/* Our chip supports Tx STBC and the peer is an HT/VHT STA which
	 * supports STBC of at least 1*SS
	 */
2060
	if (!lq_sta->stbc_capable)
2061 2062 2063 2064 2065 2066 2067 2068
		return false;

	if (!iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta))
		return false;

	return true;
}

2069 2070 2071
static void rs_get_adjacent_txp(struct iwl_mvm *mvm, int index,
				int *weaker, int *stronger)
{
2072
	*weaker = index + IWL_MVM_RS_TPC_TX_POWER_STEP;
2073 2074 2075
	if (*weaker > TPC_MAX_REDUCTION)
		*weaker = TPC_INVALID;

2076
	*stronger = index - IWL_MVM_RS_TPC_TX_POWER_STEP;
2077 2078 2079 2080
	if (*stronger < 0)
		*stronger = TPC_INVALID;
}

2081
static bool rs_tpc_allowed(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2082
			   struct rs_rate *rate, enum nl80211_band band)
2083 2084
{
	int index = rate->index;
2085 2086 2087
	bool cam = (iwlmvm_mod_params.power_scheme == IWL_POWER_SCHEME_CAM);
	bool sta_ps_disabled = (vif->type == NL80211_IFTYPE_STATION &&
				!vif->bss_conf.ps);
2088

2089 2090
	IWL_DEBUG_RATE(mvm, "cam: %d sta_ps_disabled %d\n",
		       cam, sta_ps_disabled);
2091 2092 2093 2094
	/*
	 * allow tpc only if power management is enabled, or bt coex
	 * activity grade allows it and we are on 2.4Ghz.
	 */
2095
	if ((cam || sta_ps_disabled) &&
2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
	    !iwl_mvm_bt_coex_is_tpc_allowed(mvm, band))
		return false;

	IWL_DEBUG_RATE(mvm, "check rate, table type: %d\n", rate->type);
	if (is_legacy(rate))
		return index == IWL_RATE_54M_INDEX;
	if (is_ht(rate))
		return index == IWL_RATE_MCS_7_INDEX;
	if (is_vht(rate))
		return index == IWL_RATE_MCS_7_INDEX ||
		       index == IWL_RATE_MCS_8_INDEX ||
		       index == IWL_RATE_MCS_9_INDEX;

	WARN_ON_ONCE(1);
	return false;
}

enum tpc_action {
	TPC_ACTION_STAY,
	TPC_ACTION_DECREASE,
	TPC_ACTION_INCREASE,
	TPC_ACTION_NO_RESTIRCTION,
};

static enum tpc_action rs_get_tpc_action(struct iwl_mvm *mvm,
					 s32 sr, int weak, int strong,
					 int current_tpt,
					 int weak_tpt, int strong_tpt)
{
	/* stay until we have valid tpt */
	if (current_tpt == IWL_INVALID_VALUE) {
		IWL_DEBUG_RATE(mvm, "no current tpt. stay.\n");
		return TPC_ACTION_STAY;
	}

	/* Too many failures, increase txp */
2132 2133
	if (sr <= RS_PERCENT(IWL_MVM_RS_TPC_SR_FORCE_INCREASE) ||
	    current_tpt == 0) {
2134 2135 2136 2137 2138
		IWL_DEBUG_RATE(mvm, "increase txp because of weak SR\n");
		return TPC_ACTION_NO_RESTIRCTION;
	}

	/* try decreasing first if applicable */
2139 2140
	if (sr >= RS_PERCENT(IWL_MVM_RS_TPC_SR_NO_INCREASE) &&
	    weak != TPC_INVALID) {
2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
		if (weak_tpt == IWL_INVALID_VALUE &&
		    (strong_tpt == IWL_INVALID_VALUE ||
		     current_tpt >= strong_tpt)) {
			IWL_DEBUG_RATE(mvm,
				       "no weak txp measurement. decrease txp\n");
			return TPC_ACTION_DECREASE;
		}

		if (weak_tpt > current_tpt) {
			IWL_DEBUG_RATE(mvm,
				       "lower txp has better tpt. decrease txp\n");
			return TPC_ACTION_DECREASE;
		}
	}

	/* next, increase if needed */
2157 2158
	if (sr < RS_PERCENT(IWL_MVM_RS_TPC_SR_NO_INCREASE) &&
	    strong != TPC_INVALID) {
2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184
		if (weak_tpt == IWL_INVALID_VALUE &&
		    strong_tpt != IWL_INVALID_VALUE &&
		    current_tpt < strong_tpt) {
			IWL_DEBUG_RATE(mvm,
				       "higher txp has better tpt. increase txp\n");
			return TPC_ACTION_INCREASE;
		}

		if (weak_tpt < current_tpt &&
		    (strong_tpt == IWL_INVALID_VALUE ||
		     strong_tpt > current_tpt)) {
			IWL_DEBUG_RATE(mvm,
				       "lower txp has worse tpt. increase txp\n");
			return TPC_ACTION_INCREASE;
		}
	}

	IWL_DEBUG_RATE(mvm, "no need to increase or decrease txp - stay\n");
	return TPC_ACTION_STAY;
}

static bool rs_tpc_perform(struct iwl_mvm *mvm,
			   struct ieee80211_sta *sta,
			   struct iwl_lq_sta *lq_sta,
			   struct iwl_scale_tbl_info *tbl)
{
2185
	struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
2186 2187
	struct ieee80211_vif *vif = mvm_sta->vif;
	struct ieee80211_chanctx_conf *chanctx_conf;
2188
	enum nl80211_band band;
2189 2190 2191 2192 2193 2194 2195 2196 2197
	struct iwl_rate_scale_data *window;
	struct rs_rate *rate = &tbl->rate;
	enum tpc_action action;
	s32 sr;
	u8 cur = lq_sta->lq.reduced_tpc;
	int current_tpt;
	int weak, strong;
	int weak_tpt = IWL_INVALID_VALUE, strong_tpt = IWL_INVALID_VALUE;

2198
#ifdef CONFIG_MAC80211_DEBUGFS
2199
	if (lq_sta->pers.dbg_fixed_txp_reduction <= TPC_MAX_REDUCTION) {
2200
		IWL_DEBUG_RATE(mvm, "fixed tpc: %d\n",
2201 2202 2203
			       lq_sta->pers.dbg_fixed_txp_reduction);
		lq_sta->lq.reduced_tpc = lq_sta->pers.dbg_fixed_txp_reduction;
		return cur != lq_sta->pers.dbg_fixed_txp_reduction;
2204 2205 2206
	}
#endif

2207 2208 2209
	rcu_read_lock();
	chanctx_conf = rcu_dereference(vif->chanctx_conf);
	if (WARN_ON(!chanctx_conf))
2210
		band = NUM_NL80211_BANDS;
2211 2212 2213 2214
	else
		band = chanctx_conf->def.chan->band;
	rcu_read_unlock();

2215
	if (!rs_tpc_allowed(mvm, vif, rate, band)) {
2216
		IWL_DEBUG_RATE(mvm,
2217
			       "tpc is not allowed. remove txp restrictions\n");
2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
		lq_sta->lq.reduced_tpc = TPC_NO_REDUCTION;
		return cur != TPC_NO_REDUCTION;
	}

	rs_get_adjacent_txp(mvm, cur, &weak, &strong);

	/* Collect measured throughputs for current and adjacent rates */
	window = tbl->tpc_win;
	sr = window[cur].success_ratio;
	current_tpt = window[cur].average_tpt;
	if (weak != TPC_INVALID)
		weak_tpt = window[weak].average_tpt;
	if (strong != TPC_INVALID)
		strong_tpt = window[strong].average_tpt;

	IWL_DEBUG_RATE(mvm,
		       "(TPC: %d): cur_tpt %d SR %d weak %d strong %d weak_tpt %d strong_tpt %d\n",
		       cur, current_tpt, sr, weak, strong,
		       weak_tpt, strong_tpt);

	action = rs_get_tpc_action(mvm, sr, weak, strong,
				   current_tpt, weak_tpt, strong_tpt);

	/* override actions if we are on the edge */
	if (weak == TPC_INVALID && action == TPC_ACTION_DECREASE) {
2243
		IWL_DEBUG_RATE(mvm, "already in lowest txp, stay\n");
2244 2245 2246 2247
		action = TPC_ACTION_STAY;
	} else if (strong == TPC_INVALID &&
		   (action == TPC_ACTION_INCREASE ||
		    action == TPC_ACTION_NO_RESTIRCTION)) {
2248
		IWL_DEBUG_RATE(mvm, "already in highest txp, stay\n");
2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
		action = TPC_ACTION_STAY;
	}

	switch (action) {
	case TPC_ACTION_DECREASE:
		lq_sta->lq.reduced_tpc = weak;
		return true;
	case TPC_ACTION_INCREASE:
		lq_sta->lq.reduced_tpc = strong;
		return true;
	case TPC_ACTION_NO_RESTIRCTION:
		lq_sta->lq.reduced_tpc = TPC_NO_REDUCTION;
		return true;
	case TPC_ACTION_STAY:
		/* do nothing */
		break;
	}
	return false;
}

J
Johannes Berg 已提交
2269 2270 2271 2272 2273
/*
 * Do rate scaling and search for new modulation mode.
 */
static void rs_rate_scale_perform(struct iwl_mvm *mvm,
				  struct ieee80211_sta *sta,
2274
				  struct iwl_lq_sta *lq_sta,
2275
				  int tid, bool ndp)
J
Johannes Berg 已提交
2276 2277 2278 2279 2280 2281 2282 2283 2284
{
	int low = IWL_RATE_INVALID;
	int high = IWL_RATE_INVALID;
	int index;
	struct iwl_rate_scale_data *window = NULL;
	int current_tpt = IWL_INVALID_VALUE;
	int low_tpt = IWL_INVALID_VALUE;
	int high_tpt = IWL_INVALID_VALUE;
	u32 fail_count;
2285
	enum rs_action scale_action = RS_ACTION_STAY;
J
Johannes Berg 已提交
2286 2287 2288 2289 2290 2291 2292
	u16 rate_mask;
	u8 update_lq = 0;
	struct iwl_scale_tbl_info *tbl, *tbl1;
	u8 active_tbl = 0;
	u8 done_search = 0;
	u16 high_low;
	s32 sr;
2293
	u8 prev_agg = lq_sta->is_agg;
2294
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2295
	struct rs_rate *rate;
J
Johannes Berg 已提交
2296

2297
	lq_sta->is_agg = !!mvmsta->agg_tids;
J
Johannes Berg 已提交
2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309

	/*
	 * Select rate-scale / modulation-mode table to work with in
	 * the rest of this function:  "search" if searching for better
	 * modulation mode, or "active" if doing rate scaling within a mode.
	 */
	if (!lq_sta->search_better_tbl)
		active_tbl = lq_sta->active_tbl;
	else
		active_tbl = 1 - lq_sta->active_tbl;

	tbl = &(lq_sta->lq_info[active_tbl]);
2310
	rate = &tbl->rate;
J
Johannes Berg 已提交
2311

2312 2313 2314 2315 2316
	if (prev_agg != lq_sta->is_agg) {
		IWL_DEBUG_RATE(mvm,
			       "Aggregation changed: prev %d current %d. Update expected TPT table\n",
			       prev_agg, lq_sta->is_agg);
		rs_set_expected_tpt_table(lq_sta, tbl);
2317
		rs_rate_scale_clear_tbl_windows(mvm, tbl);
2318 2319
	}

J
Johannes Berg 已提交
2320
	/* current tx rate */
2321
	index = rate->index;
J
Johannes Berg 已提交
2322 2323

	/* rates available for this association, and for modulation mode */
2324
	rate_mask = rs_get_supported_rates(lq_sta, rate);
J
Johannes Berg 已提交
2325

2326
	if (!(BIT(index) & rate_mask)) {
J
Johannes Berg 已提交
2327 2328 2329
		IWL_ERR(mvm, "Current Rate is not valid\n");
		if (lq_sta->search_better_tbl) {
			/* revert to active table if search table is not valid*/
2330
			rate->type = LQ_NONE;
J
Johannes Berg 已提交
2331 2332
			lq_sta->search_better_tbl = 0;
			tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
2333
			rs_update_rate_tbl(mvm, sta, lq_sta, tbl);
J
Johannes Berg 已提交
2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
		}
		return;
	}

	/* Get expected throughput table and history window for current rate */
	if (!tbl->expected_tpt) {
		IWL_ERR(mvm, "tbl->expected_tpt is NULL\n");
		return;
	}

2344
	/* TODO: handle rate_idx_mask and rate_idx_mcs_mask */
J
Johannes Berg 已提交
2345 2346 2347 2348 2349 2350 2351 2352 2353 2354
	window = &(tbl->win[index]);

	/*
	 * If there is not enough history to calculate actual average
	 * throughput, keep analyzing results of more tx frames, without
	 * changing rate or mode (bypass most of the rest of this function).
	 * Set up new rate table in uCode only if old rate is not supported
	 * in current association (use new rate found above).
	 */
	fail_count = window->counter - window->success_counter;
2355 2356
	if ((fail_count < IWL_MVM_RS_RATE_MIN_FAILURE_TH) &&
	    (window->success_counter < IWL_MVM_RS_RATE_MIN_SUCCESS_TH)) {
J
Johannes Berg 已提交
2357
		IWL_DEBUG_RATE(mvm,
2358 2359 2360
			       "%s: Test Window: succ %d total %d\n",
			       rs_pretty_rate(rate),
			       window->success_counter, window->counter);
J
Johannes Berg 已提交
2361 2362 2363 2364 2365 2366 2367 2368

		/* Can't calculate this yet; not enough history */
		window->average_tpt = IWL_INVALID_VALUE;

		/* Should we stay with this modulation mode,
		 * or search for a new one? */
		rs_stay_in_table(lq_sta, false);

2369
		return;
J
Johannes Berg 已提交
2370 2371 2372 2373 2374 2375 2376 2377 2378
	}

	/* If we are searching for better modulation mode, check success. */
	if (lq_sta->search_better_tbl) {
		/* If good success, continue using the "search" mode;
		 * no need to send new link quality command, since we're
		 * continuing to use the setup that we've been trying. */
		if (window->average_tpt > lq_sta->last_tpt) {
			IWL_DEBUG_RATE(mvm,
2379 2380
				       "SWITCHING TO NEW TABLE SR: %d "
				       "cur-tpt %d old-tpt %d\n",
J
Johannes Berg 已提交
2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
				       window->success_ratio,
				       window->average_tpt,
				       lq_sta->last_tpt);

			/* Swap tables; "search" becomes "active" */
			lq_sta->active_tbl = active_tbl;
			current_tpt = window->average_tpt;
		/* Else poor success; go back to mode in "active" table */
		} else {
			IWL_DEBUG_RATE(mvm,
2391 2392
				       "GOING BACK TO THE OLD TABLE: SR %d "
				       "cur-tpt %d old-tpt %d\n",
J
Johannes Berg 已提交
2393 2394 2395 2396 2397
				       window->success_ratio,
				       window->average_tpt,
				       lq_sta->last_tpt);

			/* Nullify "search" table */
2398
			rate->type = LQ_NONE;
J
Johannes Berg 已提交
2399 2400 2401 2402 2403 2404

			/* Revert to "active" table */
			active_tbl = lq_sta->active_tbl;
			tbl = &(lq_sta->lq_info[active_tbl]);

			/* Revert to "active" rate and throughput info */
2405
			index = tbl->rate.index;
J
Johannes Berg 已提交
2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
			current_tpt = lq_sta->last_tpt;

			/* Need to set up a new rate table in uCode */
			update_lq = 1;
		}

		/* Either way, we've made a decision; modulation mode
		 * search is done, allow rate adjustment next time. */
		lq_sta->search_better_tbl = 0;
		done_search = 1;	/* Don't switch modes below! */
		goto lq_update;
	}

	/* (Else) not in search of better modulation mode, try for better
	 * starting rate, while staying in this mode. */
2421
	high_low = rs_get_adjacent_rate(mvm, index, rate_mask, rate->type);
J
Johannes Berg 已提交
2422 2423 2424
	low = high_low & 0xff;
	high = (high_low >> 8) & 0xff;

2425
	/* TODO: handle rate_idx_mask and rate_idx_mcs_mask */
J
Johannes Berg 已提交
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435

	sr = window->success_ratio;

	/* Collect measured throughputs for current and adjacent rates */
	current_tpt = window->average_tpt;
	if (low != IWL_RATE_INVALID)
		low_tpt = tbl->win[low].average_tpt;
	if (high != IWL_RATE_INVALID)
		high_tpt = tbl->win[high].average_tpt;

2436
	IWL_DEBUG_RATE(mvm,
2437 2438
		       "%s: cur_tpt %d SR %d low %d high %d low_tpt %d high_tpt %d\n",
		       rs_pretty_rate(rate), current_tpt, sr,
2439
		       low, high, low_tpt, high_tpt);
2440

2441 2442
	scale_action = rs_get_rate_action(mvm, tbl, sr, low, high,
					  current_tpt, low_tpt, high_tpt);
J
Johannes Berg 已提交
2443

2444
	/* Force a search in case BT doesn't like us being in MIMO */
2445
	if (is_mimo(rate) &&
2446
	    !iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta)) {
2447 2448
		IWL_DEBUG_RATE(mvm,
			       "BT Coex forbids MIMO. Search for new config\n");
2449 2450 2451 2452
		rs_stay_in_table(lq_sta, true);
		goto lq_update;
	}

J
Johannes Berg 已提交
2453
	switch (scale_action) {
2454
	case RS_ACTION_DOWNSCALE:
J
Johannes Berg 已提交
2455 2456 2457 2458
		/* Decrease starting rate, update uCode's rate table */
		if (low != IWL_RATE_INVALID) {
			update_lq = 1;
			index = low;
2459 2460 2461
		} else {
			IWL_DEBUG_RATE(mvm,
				       "At the bottom rate. Can't decrease\n");
J
Johannes Berg 已提交
2462 2463 2464
		}

		break;
2465
	case RS_ACTION_UPSCALE:
J
Johannes Berg 已提交
2466 2467 2468 2469
		/* Increase starting rate, update uCode's rate table */
		if (high != IWL_RATE_INVALID) {
			update_lq = 1;
			index = high;
2470 2471 2472
		} else {
			IWL_DEBUG_RATE(mvm,
				       "At the top rate. Can't increase\n");
J
Johannes Berg 已提交
2473 2474 2475
		}

		break;
2476
	case RS_ACTION_STAY:
J
Johannes Berg 已提交
2477
		/* No change */
2478 2479
		if (lq_sta->rs_state == RS_STATE_STAY_IN_COLUMN)
			update_lq = rs_tpc_perform(mvm, sta, lq_sta, tbl);
2480
		break;
J
Johannes Berg 已提交
2481 2482 2483 2484 2485 2486
	default:
		break;
	}

lq_update:
	/* Replace uCode's rate table for the destination station. */
2487 2488
	if (update_lq) {
		tbl->rate.index = index;
2489 2490
		if (IWL_MVM_RS_80_20_FAR_RANGE_TWEAK)
			rs_tweak_rate_tbl(mvm, sta, lq_sta, tbl, scale_action);
2491
		rs_set_amsdu_len(mvm, sta, tbl, scale_action);
2492
		rs_update_rate_tbl(mvm, sta, lq_sta, tbl);
2493
	}
J
Johannes Berg 已提交
2494 2495 2496 2497 2498 2499 2500 2501 2502 2503

	rs_stay_in_table(lq_sta, false);

	/*
	 * Search for new modulation mode if we're:
	 * 1)  Not changing rates right now
	 * 2)  Not just finishing up a search
	 * 3)  Allowing a new search
	 */
	if (!update_lq && !done_search &&
2504 2505 2506 2507
	    lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_STARTED
	    && window->counter) {
		enum rs_column next_column;

J
Johannes Berg 已提交
2508 2509 2510
		/* Save current throughput to compare with "search" throughput*/
		lq_sta->last_tpt = current_tpt;

2511
		IWL_DEBUG_RATE(mvm,
2512 2513
			       "Start Search: update_lq %d done_search %d rs_state %d win->counter %d\n",
			       update_lq, done_search, lq_sta->rs_state,
2514
			       window->counter);
2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526

		next_column = rs_get_next_column(mvm, lq_sta, sta, tbl);
		if (next_column != RS_COLUMN_INVALID) {
			int ret = rs_switch_to_column(mvm, lq_sta, sta,
						      next_column);
			if (!ret)
				lq_sta->search_better_tbl = 1;
		} else {
			IWL_DEBUG_RATE(mvm,
				       "No more columns to explore in search cycle. Go to RS_STATE_SEARCH_CYCLE_ENDED\n");
			lq_sta->rs_state = RS_STATE_SEARCH_CYCLE_ENDED;
		}
J
Johannes Berg 已提交
2527 2528 2529 2530 2531

		/* If new "search" mode was selected, set up in uCode table */
		if (lq_sta->search_better_tbl) {
			/* Access the "search" table, clear its history. */
			tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
2532
			rs_rate_scale_clear_tbl_windows(mvm, tbl);
J
Johannes Berg 已提交
2533 2534

			/* Use new "search" start rate */
2535
			index = tbl->rate.index;
J
Johannes Berg 已提交
2536

2537 2538
			rs_dump_rate(mvm, &tbl->rate,
				     "Switch to SEARCH TABLE:");
2539
			rs_update_rate_tbl(mvm, sta, lq_sta, tbl);
J
Johannes Berg 已提交
2540 2541 2542 2543 2544
		} else {
			done_search = 1;
		}
	}

2545 2546 2547
	if (!ndp)
		rs_tl_turn_on_agg(mvm, mvmsta, tid, lq_sta, sta);

2548
	if (done_search && lq_sta->rs_state == RS_STATE_SEARCH_CYCLE_ENDED) {
J
Johannes Berg 已提交
2549
		tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
2550
		rs_set_stay_in_table(mvm, is_legacy(&tbl1->rate), lq_sta);
J
Johannes Berg 已提交
2551 2552 2553
	}
}

2554 2555 2556 2557 2558
struct rs_init_rate_info {
	s8 rssi;
	u8 rate_idx;
};

2559
static const struct rs_init_rate_info rs_optimal_rates_24ghz_legacy[] = {
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571
	{ -60, IWL_RATE_54M_INDEX },
	{ -64, IWL_RATE_48M_INDEX },
	{ -68, IWL_RATE_36M_INDEX },
	{ -80, IWL_RATE_24M_INDEX },
	{ -84, IWL_RATE_18M_INDEX },
	{ -85, IWL_RATE_12M_INDEX },
	{ -86, IWL_RATE_11M_INDEX },
	{ -88, IWL_RATE_5M_INDEX  },
	{ -90, IWL_RATE_2M_INDEX  },
	{ S8_MIN, IWL_RATE_1M_INDEX },
};

2572
static const struct rs_init_rate_info rs_optimal_rates_5ghz_legacy[] = {
2573 2574 2575 2576 2577 2578 2579 2580 2581 2582
	{ -60, IWL_RATE_54M_INDEX },
	{ -64, IWL_RATE_48M_INDEX },
	{ -72, IWL_RATE_36M_INDEX },
	{ -80, IWL_RATE_24M_INDEX },
	{ -84, IWL_RATE_18M_INDEX },
	{ -85, IWL_RATE_12M_INDEX },
	{ -87, IWL_RATE_9M_INDEX  },
	{ S8_MIN, IWL_RATE_6M_INDEX },
};

2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593
static const struct rs_init_rate_info rs_optimal_rates_ht[] = {
	{ -60, IWL_RATE_MCS_7_INDEX },
	{ -64, IWL_RATE_MCS_6_INDEX },
	{ -68, IWL_RATE_MCS_5_INDEX },
	{ -72, IWL_RATE_MCS_4_INDEX },
	{ -80, IWL_RATE_MCS_3_INDEX },
	{ -84, IWL_RATE_MCS_2_INDEX },
	{ -85, IWL_RATE_MCS_1_INDEX },
	{ S8_MIN, IWL_RATE_MCS_0_INDEX},
};

2594 2595 2596
/* MCS index 9 is not valid for 20MHz VHT channel width,
 * but is ok for 40, 80 and 160MHz channels.
 */
2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608
static const struct rs_init_rate_info rs_optimal_rates_vht_20mhz[] = {
	{ -60, IWL_RATE_MCS_8_INDEX },
	{ -64, IWL_RATE_MCS_7_INDEX },
	{ -68, IWL_RATE_MCS_6_INDEX },
	{ -72, IWL_RATE_MCS_5_INDEX },
	{ -80, IWL_RATE_MCS_4_INDEX },
	{ -84, IWL_RATE_MCS_3_INDEX },
	{ -85, IWL_RATE_MCS_2_INDEX },
	{ -87, IWL_RATE_MCS_1_INDEX },
	{ S8_MIN, IWL_RATE_MCS_0_INDEX},
};

2609
static const struct rs_init_rate_info rs_optimal_rates_vht[] = {
2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621
	{ -60, IWL_RATE_MCS_9_INDEX },
	{ -64, IWL_RATE_MCS_8_INDEX },
	{ -68, IWL_RATE_MCS_7_INDEX },
	{ -72, IWL_RATE_MCS_6_INDEX },
	{ -80, IWL_RATE_MCS_5_INDEX },
	{ -84, IWL_RATE_MCS_4_INDEX },
	{ -85, IWL_RATE_MCS_3_INDEX },
	{ -87, IWL_RATE_MCS_2_INDEX },
	{ -88, IWL_RATE_MCS_1_INDEX },
	{ S8_MIN, IWL_RATE_MCS_0_INDEX },
};

2622 2623
#define IWL_RS_LOW_RSSI_THRESHOLD (-76) /* dBm */

2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637
/* Init the optimal rate based on STA caps
 * This combined with rssi is used to report the last tx rate
 * to userspace when we haven't transmitted enough frames.
 */
static void rs_init_optimal_rate(struct iwl_mvm *mvm,
				 struct ieee80211_sta *sta,
				 struct iwl_lq_sta *lq_sta)
{
	struct rs_rate *rate = &lq_sta->optimal_rate;

	if (lq_sta->max_mimo2_rate_idx != IWL_RATE_INVALID)
		rate->type = lq_sta->is_vht ? LQ_VHT_MIMO2 : LQ_HT_MIMO2;
	else if (lq_sta->max_siso_rate_idx != IWL_RATE_INVALID)
		rate->type = lq_sta->is_vht ? LQ_VHT_SISO : LQ_HT_SISO;
2638
	else if (lq_sta->band == NL80211_BAND_5GHZ)
2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654
		rate->type = LQ_LEGACY_A;
	else
		rate->type = LQ_LEGACY_G;

	rate->bw = rs_bw_from_sta_bw(sta);
	rate->sgi = rs_sgi_allow(mvm, sta, rate, NULL);

	/* ANT/LDPC/STBC aren't relevant for the rate reported to userspace */

	if (is_mimo(rate)) {
		lq_sta->optimal_rate_mask = lq_sta->active_mimo2_rate;
	} else if (is_siso(rate)) {
		lq_sta->optimal_rate_mask = lq_sta->active_siso_rate;
	} else {
		lq_sta->optimal_rate_mask = lq_sta->active_legacy_rate;

2655
		if (lq_sta->band == NL80211_BAND_5GHZ) {
2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671
			lq_sta->optimal_rates = rs_optimal_rates_5ghz_legacy;
			lq_sta->optimal_nentries =
				ARRAY_SIZE(rs_optimal_rates_5ghz_legacy);
		} else {
			lq_sta->optimal_rates = rs_optimal_rates_24ghz_legacy;
			lq_sta->optimal_nentries =
				ARRAY_SIZE(rs_optimal_rates_24ghz_legacy);
		}
	}

	if (is_vht(rate)) {
		if (rate->bw == RATE_MCS_CHAN_WIDTH_20) {
			lq_sta->optimal_rates = rs_optimal_rates_vht_20mhz;
			lq_sta->optimal_nentries =
				ARRAY_SIZE(rs_optimal_rates_vht_20mhz);
		} else {
2672
			lq_sta->optimal_rates = rs_optimal_rates_vht;
2673
			lq_sta->optimal_nentries =
2674
				ARRAY_SIZE(rs_optimal_rates_vht);
2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704
		}
	} else if (is_ht(rate)) {
		lq_sta->optimal_rates = rs_optimal_rates_ht;
		lq_sta->optimal_nentries = ARRAY_SIZE(rs_optimal_rates_ht);
	}
}

/* Compute the optimal rate index based on RSSI */
static struct rs_rate *rs_get_optimal_rate(struct iwl_mvm *mvm,
					   struct iwl_lq_sta *lq_sta)
{
	struct rs_rate *rate = &lq_sta->optimal_rate;
	int i;

	rate->index = find_first_bit(&lq_sta->optimal_rate_mask,
				     BITS_PER_LONG);

	for (i = 0; i < lq_sta->optimal_nentries; i++) {
		int rate_idx = lq_sta->optimal_rates[i].rate_idx;

		if ((lq_sta->pers.last_rssi >= lq_sta->optimal_rates[i].rssi) &&
		    (BIT(rate_idx) & lq_sta->optimal_rate_mask)) {
			rate->index = rate_idx;
			break;
		}
	}

	return rate;
}

2705 2706 2707 2708
/* Choose an initial legacy rate and antenna to use based on the RSSI
 * of last Rx
 */
static void rs_get_initial_rate(struct iwl_mvm *mvm,
2709
				struct ieee80211_sta *sta,
2710
				struct iwl_lq_sta *lq_sta,
2711
				enum nl80211_band band,
2712
				struct rs_rate *rate)
2713
{
2714
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2715
	int i, nentries;
2716
	unsigned long active_rate;
2717 2718
	s8 best_rssi = S8_MIN;
	u8 best_ant = ANT_NONE;
2719
	u8 valid_tx_ant = iwl_mvm_get_valid_tx_ant(mvm);
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746
	const struct rs_init_rate_info *initial_rates;

	for (i = 0; i < ARRAY_SIZE(lq_sta->pers.chain_signal); i++) {
		if (!(lq_sta->pers.chains & BIT(i)))
			continue;

		if (lq_sta->pers.chain_signal[i] > best_rssi) {
			best_rssi = lq_sta->pers.chain_signal[i];
			best_ant = BIT(i);
		}
	}

	IWL_DEBUG_RATE(mvm, "Best ANT: %s Best RSSI: %d\n",
		       rs_pretty_ant(best_ant), best_rssi);

	if (best_ant != ANT_A && best_ant != ANT_B)
		rate->ant = first_antenna(valid_tx_ant);
	else
		rate->ant = best_ant;

	rate->sgi = false;
	rate->ldpc = false;
	rate->bw = RATE_MCS_CHAN_WIDTH_20;

	rate->index = find_first_bit(&lq_sta->active_legacy_rate,
				     BITS_PER_LONG);

2747
	if (band == NL80211_BAND_5GHZ) {
2748
		rate->type = LQ_LEGACY_A;
2749 2750
		initial_rates = rs_optimal_rates_5ghz_legacy;
		nentries = ARRAY_SIZE(rs_optimal_rates_5ghz_legacy);
2751 2752
	} else {
		rate->type = LQ_LEGACY_G;
2753 2754
		initial_rates = rs_optimal_rates_24ghz_legacy;
		nentries = ARRAY_SIZE(rs_optimal_rates_24ghz_legacy);
2755 2756
	}

2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
	if (!IWL_MVM_RS_RSSI_BASED_INIT_RATE)
		goto out;

	/* Start from a higher rate if the corresponding debug capability
	 * is enabled. The rate is chosen according to AP capabilities.
	 * In case of VHT/HT when the rssi is low fallback to the case of
	 * legacy rates.
	 */
	if (sta->vht_cap.vht_supported &&
	    best_rssi > IWL_RS_LOW_RSSI_THRESHOLD) {
2767 2768 2769 2770 2771 2772 2773 2774 2775
		/*
		 * In AP mode, when a new station associates, rs is initialized
		 * immediately upon association completion, before the phy
		 * context is updated with the association parameters, so the
		 * sta bandwidth might be wider than the phy context allows.
		 * To avoid this issue, always initialize rs with 20mhz
		 * bandwidth rate, and after authorization, when the phy context
		 * is already up-to-date, re-init rs with the correct bw.
		 */
2776 2777
		u32 bw = mvmsta->sta_state < IEEE80211_STA_AUTHORIZED ?
				RATE_MCS_CHAN_WIDTH_20 : rs_bw_from_sta_bw(sta);
2778 2779 2780 2781 2782

		switch (bw) {
		case RATE_MCS_CHAN_WIDTH_40:
		case RATE_MCS_CHAN_WIDTH_80:
		case RATE_MCS_CHAN_WIDTH_160:
2783 2784 2785
			initial_rates = rs_optimal_rates_vht;
			nentries = ARRAY_SIZE(rs_optimal_rates_vht);
			break;
2786
		case RATE_MCS_CHAN_WIDTH_20:
2787 2788
			initial_rates = rs_optimal_rates_vht_20mhz;
			nentries = ARRAY_SIZE(rs_optimal_rates_vht_20mhz);
2789 2790
			break;
		default:
2791 2792
			IWL_ERR(mvm, "Invalid BW %d\n", sta->bandwidth);
			goto out;
2793
		}
2794

2795 2796
		active_rate = lq_sta->active_siso_rate;
		rate->type = LQ_VHT_SISO;
2797
		rate->bw = bw;
2798 2799 2800 2801 2802 2803 2804 2805
	} else if (sta->ht_cap.ht_supported &&
		   best_rssi > IWL_RS_LOW_RSSI_THRESHOLD) {
		initial_rates = rs_optimal_rates_ht;
		nentries = ARRAY_SIZE(rs_optimal_rates_ht);
		active_rate = lq_sta->active_siso_rate;
		rate->type = LQ_HT_SISO;
	} else {
		active_rate = lq_sta->active_legacy_rate;
2806 2807
	}

2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
	for (i = 0; i < nentries; i++) {
		int rate_idx = initial_rates[i].rate_idx;

		if ((best_rssi >= initial_rates[i].rssi) &&
		    (BIT(rate_idx) & active_rate)) {
			rate->index = rate_idx;
			break;
		}
	}

out:
	rs_dump_rate(mvm, rate, "INITIAL");
2820 2821 2822 2823
}

/* Save info about RSSI of last Rx */
void rs_update_last_rssi(struct iwl_mvm *mvm,
2824
			 struct iwl_mvm_sta *mvmsta,
2825 2826
			 struct ieee80211_rx_status *rx_status)
{
2827
	struct iwl_lq_sta *lq_sta = &mvmsta->lq_sta.rs_drv;
2828 2829
	int i;

2830 2831 2832 2833
	lq_sta->pers.chains = rx_status->chains;
	lq_sta->pers.chain_signal[0] = rx_status->chain_signal[0];
	lq_sta->pers.chain_signal[1] = rx_status->chain_signal[1];
	lq_sta->pers.chain_signal[2] = rx_status->chain_signal[2];
2834 2835 2836 2837 2838 2839 2840 2841 2842
	lq_sta->pers.last_rssi = S8_MIN;

	for (i = 0; i < ARRAY_SIZE(lq_sta->pers.chain_signal); i++) {
		if (!(lq_sta->pers.chains & BIT(i)))
			continue;

		if (lq_sta->pers.chain_signal[i] > lq_sta->pers.last_rssi)
			lq_sta->pers.last_rssi = lq_sta->pers.chain_signal[i];
	}
2843 2844
}

J
Johannes Berg 已提交
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861
/**
 * rs_initialize_lq - Initialize a station's hardware rate table
 *
 * The uCode's station table contains a table of fallback rates
 * for automatic fallback during transmission.
 *
 * NOTE: This sets up a default set of values.  These will be replaced later
 *       if the driver's iwl-agn-rs rate scaling algorithm is used, instead of
 *       rc80211_simple.
 *
 * NOTE: Run REPLY_ADD_STA command to set up station table entry, before
 *       calling this function (which runs REPLY_TX_LINK_QUALITY_CMD,
 *       which requires station table entry to exist).
 */
static void rs_initialize_lq(struct iwl_mvm *mvm,
			     struct ieee80211_sta *sta,
			     struct iwl_lq_sta *lq_sta,
2862
			     enum nl80211_band band, bool update)
J
Johannes Berg 已提交
2863 2864
{
	struct iwl_scale_tbl_info *tbl;
2865
	struct rs_rate *rate;
J
Johannes Berg 已提交
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876
	u8 active_tbl = 0;

	if (!sta || !lq_sta)
		return;

	if (!lq_sta->search_better_tbl)
		active_tbl = lq_sta->active_tbl;
	else
		active_tbl = 1 - lq_sta->active_tbl;

	tbl = &(lq_sta->lq_info[active_tbl]);
2877
	rate = &tbl->rate;
J
Johannes Berg 已提交
2878

2879
	rs_get_initial_rate(mvm, sta, lq_sta, band, rate);
2880
	rs_init_optimal_rate(mvm, sta, lq_sta);
J
Johannes Berg 已提交
2881

2882 2883 2884 2885 2886
	WARN_ONCE(rate->ant != ANT_A && rate->ant != ANT_B,
		  "ant: 0x%x, chains 0x%x, fw tx ant: 0x%x, nvm tx ant: 0x%x\n",
		  rate->ant, lq_sta->pers.chains, mvm->fw->valid_tx_ant,
		  mvm->nvm_data ? mvm->nvm_data->valid_tx_ant : ANT_INVALID);

2887
	tbl->column = rs_get_column_from_rate(rate);
2888

J
Johannes Berg 已提交
2889
	rs_set_expected_tpt_table(lq_sta, tbl);
2890
	rs_fill_lq_cmd(mvm, sta, lq_sta, rate);
J
Johannes Berg 已提交
2891
	/* TODO restore station should remember the lq cmd */
2892
	iwl_mvm_send_lq_cmd(mvm, &lq_sta->lq, !update);
J
Johannes Berg 已提交
2893 2894
}

2895 2896 2897
static void rs_drv_get_rate(void *mvm_r, struct ieee80211_sta *sta,
			    void *mvm_sta,
			    struct ieee80211_tx_rate_control *txrc)
J
Johannes Berg 已提交
2898
{
2899
	struct iwl_op_mode *op_mode = mvm_r;
J
Johannes Berg 已提交
2900
	struct iwl_mvm *mvm __maybe_unused = IWL_OP_MODE_GET_MVM(op_mode);
2901
	struct sk_buff *skb = txrc->skb;
J
Johannes Berg 已提交
2902
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2903
	struct iwl_lq_sta *lq_sta;
2904 2905
	struct rs_rate *optimal_rate;
	u32 last_ucode_rate;
J
Johannes Berg 已提交
2906

2907 2908 2909 2910 2911 2912 2913 2914
	if (sta && !iwl_mvm_sta_from_mac80211(sta)->vif) {
		/* if vif isn't initialized mvm doesn't know about
		 * this station, so don't do anything with the it
		 */
		sta = NULL;
		mvm_sta = NULL;
	}

J
Johannes Berg 已提交
2915 2916 2917 2918
	/* Send management frames and NO_ACK data using lowest rate. */
	if (rate_control_send_low(sta, mvm_sta, txrc))
		return;

2919 2920 2921 2922
	if (!mvm_sta)
		return;

	lq_sta = mvm_sta;
E
Eyal Shapira 已提交
2923 2924
	iwl_mvm_hwrate_to_tx_rate(lq_sta->last_rate_n_flags,
				  info->band, &info->control.rates[0]);
2925
	info->control.rates[0].count = 1;
2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936

	/* Report the optimal rate based on rssi and STA caps if we haven't
	 * converged yet (too little traffic) or exploring other modulations
	 */
	if (lq_sta->rs_state != RS_STATE_STAY_IN_COLUMN) {
		optimal_rate = rs_get_optimal_rate(mvm, lq_sta);
		last_ucode_rate = ucode_rate_from_rs_rate(mvm,
							  optimal_rate);
		iwl_mvm_hwrate_to_tx_rate(last_ucode_rate, info->band,
					  &txrc->reported_rate);
	}
J
Johannes Berg 已提交
2937 2938
}

2939 2940
static void *rs_drv_alloc_sta(void *mvm_rate, struct ieee80211_sta *sta,
			      gfp_t gfp)
J
Johannes Berg 已提交
2941
{
2942
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
2943 2944
	struct iwl_op_mode *op_mode = (struct iwl_op_mode *)mvm_rate;
	struct iwl_mvm *mvm  = IWL_OP_MODE_GET_MVM(op_mode);
2945
	struct iwl_lq_sta *lq_sta = &mvmsta->lq_sta.rs_drv;
J
Johannes Berg 已提交
2946 2947 2948

	IWL_DEBUG_RATE(mvm, "create station rate scale window\n");

2949 2950 2951 2952
	lq_sta->pers.drv = mvm;
#ifdef CONFIG_MAC80211_DEBUGFS
	lq_sta->pers.dbg_fixed_rate = 0;
	lq_sta->pers.dbg_fixed_txp_reduction = TPC_INVALID;
2953
	lq_sta->pers.ss_force = RS_SS_FORCE_NONE;
2954
#endif
2955 2956
	lq_sta->pers.chains = 0;
	memset(lq_sta->pers.chain_signal, 0, sizeof(lq_sta->pers.chain_signal));
2957
	lq_sta->pers.last_rssi = S8_MIN;
2958

2959
	return lq_sta;
J
Johannes Berg 已提交
2960 2961
}

E
Eyal Shapira 已提交
2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979
static int rs_vht_highest_rx_mcs_index(struct ieee80211_sta_vht_cap *vht_cap,
				       int nss)
{
	u16 rx_mcs = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) &
		(0x3 << (2 * (nss - 1)));
	rx_mcs >>= (2 * (nss - 1));

	if (rx_mcs == IEEE80211_VHT_MCS_SUPPORT_0_7)
		return IWL_RATE_MCS_7_INDEX;
	else if (rx_mcs == IEEE80211_VHT_MCS_SUPPORT_0_8)
		return IWL_RATE_MCS_8_INDEX;
	else if (rx_mcs == IEEE80211_VHT_MCS_SUPPORT_0_9)
		return IWL_RATE_MCS_9_INDEX;

	WARN_ON_ONCE(rx_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED);
	return -1;
}

2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991
static void rs_vht_set_enabled_rates(struct ieee80211_sta *sta,
				     struct ieee80211_sta_vht_cap *vht_cap,
				     struct iwl_lq_sta *lq_sta)
{
	int i;
	int highest_mcs = rs_vht_highest_rx_mcs_index(vht_cap, 1);

	if (highest_mcs >= IWL_RATE_MCS_0_INDEX) {
		for (i = IWL_RATE_MCS_0_INDEX; i <= highest_mcs; i++) {
			if (i == IWL_RATE_9M_INDEX)
				continue;

2992 2993 2994 2995 2996
			/* VHT MCS9 isn't valid for 20Mhz for NSS=1,2 */
			if (i == IWL_RATE_MCS_9_INDEX &&
			    sta->bandwidth == IEEE80211_STA_RX_BW_20)
				continue;

2997 2998 2999 3000
			lq_sta->active_siso_rate |= BIT(i);
		}
	}

3001 3002 3003
	if (sta->rx_nss < 2)
		return;

3004 3005 3006 3007 3008 3009
	highest_mcs = rs_vht_highest_rx_mcs_index(vht_cap, 2);
	if (highest_mcs >= IWL_RATE_MCS_0_INDEX) {
		for (i = IWL_RATE_MCS_0_INDEX; i <= highest_mcs; i++) {
			if (i == IWL_RATE_9M_INDEX)
				continue;

3010 3011 3012 3013 3014
			/* VHT MCS9 isn't valid for 20Mhz for NSS=1,2 */
			if (i == IWL_RATE_MCS_9_INDEX &&
			    sta->bandwidth == IEEE80211_STA_RX_BW_20)
				continue;

3015 3016 3017 3018 3019
			lq_sta->active_mimo2_rate |= BIT(i);
		}
	}
}

3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045
static void rs_ht_init(struct iwl_mvm *mvm,
		       struct ieee80211_sta *sta,
		       struct iwl_lq_sta *lq_sta,
		       struct ieee80211_sta_ht_cap *ht_cap)
{
	/* active_siso_rate mask includes 9 MBits (bit 5),
	 * and CCK (bits 0-3), supp_rates[] does not;
	 * shift to convert format, force 9 MBits off.
	 */
	lq_sta->active_siso_rate = ht_cap->mcs.rx_mask[0] << 1;
	lq_sta->active_siso_rate |= ht_cap->mcs.rx_mask[0] & 0x1;
	lq_sta->active_siso_rate &= ~((u16)0x2);
	lq_sta->active_siso_rate <<= IWL_FIRST_OFDM_RATE;

	lq_sta->active_mimo2_rate = ht_cap->mcs.rx_mask[1] << 1;
	lq_sta->active_mimo2_rate |= ht_cap->mcs.rx_mask[1] & 0x1;
	lq_sta->active_mimo2_rate &= ~((u16)0x2);
	lq_sta->active_mimo2_rate <<= IWL_FIRST_OFDM_RATE;

	if (mvm->cfg->ht_params->ldpc &&
	    (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING))
		lq_sta->ldpc = true;

	if (mvm->cfg->ht_params->stbc &&
	    (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) > 1) &&
	    (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC))
3046
		lq_sta->stbc_capable = true;
3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064

	lq_sta->is_vht = false;
}

static void rs_vht_init(struct iwl_mvm *mvm,
			struct ieee80211_sta *sta,
			struct iwl_lq_sta *lq_sta,
			struct ieee80211_sta_vht_cap *vht_cap)
{
	rs_vht_set_enabled_rates(sta, vht_cap, lq_sta);

	if (mvm->cfg->ht_params->ldpc &&
	    (vht_cap->cap & IEEE80211_VHT_CAP_RXLDPC))
		lq_sta->ldpc = true;

	if (mvm->cfg->ht_params->stbc &&
	    (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) > 1) &&
	    (vht_cap->cap & IEEE80211_VHT_CAP_RXSTBC_MASK))
3065 3066
		lq_sta->stbc_capable = true;

3067
	if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_BEAMFORMER) &&
3068 3069 3070
	    (num_of_ant(iwl_mvm_get_valid_tx_ant(mvm)) > 1) &&
	    (vht_cap->cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE))
		lq_sta->bfer_capable = true;
3071 3072 3073 3074

	lq_sta->is_vht = true;
}

3075
#ifdef CONFIG_IWLWIFI_DEBUGFS
3076
void iwl_mvm_reset_frame_stats(struct iwl_mvm *mvm)
3077 3078
{
	spin_lock_bh(&mvm->drv_stats_lock);
3079
	memset(&mvm->drv_rx_stats, 0, sizeof(mvm->drv_rx_stats));
3080 3081 3082
	spin_unlock_bh(&mvm->drv_stats_lock);
}

3083
void iwl_mvm_update_frame_stats(struct iwl_mvm *mvm, u32 rate, bool agg)
3084
{
3085
	u8 nss = 0;
3086 3087 3088 3089

	spin_lock(&mvm->drv_stats_lock);

	if (agg)
3090
		mvm->drv_rx_stats.agg_frames++;
3091

3092
	mvm->drv_rx_stats.success_frames++;
3093 3094 3095

	switch (rate & RATE_MCS_CHAN_WIDTH_MSK) {
	case RATE_MCS_CHAN_WIDTH_20:
3096
		mvm->drv_rx_stats.bw_20_frames++;
3097 3098
		break;
	case RATE_MCS_CHAN_WIDTH_40:
3099
		mvm->drv_rx_stats.bw_40_frames++;
3100 3101
		break;
	case RATE_MCS_CHAN_WIDTH_80:
3102
		mvm->drv_rx_stats.bw_80_frames++;
3103
		break;
3104 3105 3106
	case RATE_MCS_CHAN_WIDTH_160:
		mvm->drv_rx_stats.bw_160_frames++;
		break;
3107 3108 3109 3110 3111
	default:
		WARN_ONCE(1, "bad BW. rate 0x%x", rate);
	}

	if (rate & RATE_MCS_HT_MSK) {
3112
		mvm->drv_rx_stats.ht_frames++;
3113 3114
		nss = ((rate & RATE_HT_MCS_NSS_MSK) >> RATE_HT_MCS_NSS_POS) + 1;
	} else if (rate & RATE_MCS_VHT_MSK) {
3115
		mvm->drv_rx_stats.vht_frames++;
3116 3117 3118
		nss = ((rate & RATE_VHT_MCS_NSS_MSK) >>
		       RATE_VHT_MCS_NSS_POS) + 1;
	} else {
3119
		mvm->drv_rx_stats.legacy_frames++;
3120 3121 3122
	}

	if (nss == 1)
3123
		mvm->drv_rx_stats.siso_frames++;
3124
	else if (nss == 2)
3125
		mvm->drv_rx_stats.mimo2_frames++;
3126 3127

	if (rate & RATE_MCS_SGI_MSK)
3128
		mvm->drv_rx_stats.sgi_frames++;
3129
	else
3130
		mvm->drv_rx_stats.ngi_frames++;
3131

3132 3133 3134 3135
	mvm->drv_rx_stats.last_rates[mvm->drv_rx_stats.last_frame_idx] = rate;
	mvm->drv_rx_stats.last_frame_idx =
		(mvm->drv_rx_stats.last_frame_idx + 1) %
			ARRAY_SIZE(mvm->drv_rx_stats.last_rates);
3136 3137 3138 3139 3140

	spin_unlock(&mvm->drv_stats_lock);
}
#endif

J
Johannes Berg 已提交
3141 3142 3143
/*
 * Called after adding a new station to initialize rate scaling
 */
3144
static void rs_drv_rate_init(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
3145
			     enum nl80211_band band, bool update)
J
Johannes Berg 已提交
3146 3147 3148 3149
{
	int i, j;
	struct ieee80211_hw *hw = mvm->hw;
	struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
E
Eyal Shapira 已提交
3150
	struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
3151
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
3152
	struct iwl_lq_sta *lq_sta = &mvmsta->lq_sta.rs_drv;
J
Johannes Berg 已提交
3153 3154 3155
	struct ieee80211_supported_band *sband;
	unsigned long supp; /* must be unsigned long for for_each_set_bit */

3156 3157
	/* clear all non-persistent lq data */
	memset(lq_sta, 0, offsetof(typeof(*lq_sta), pers));
3158

J
Johannes Berg 已提交
3159 3160
	sband = hw->wiphy->bands[band];

3161
	lq_sta->lq.sta_id = mvmsta->sta_id;
3162 3163
	mvmsta->amsdu_enabled = 0;
	mvmsta->max_amsdu_len = sta->max_amsdu_len;
J
Johannes Berg 已提交
3164 3165

	for (j = 0; j < LQ_SIZE; j++)
3166
		rs_rate_scale_clear_tbl_windows(mvm, &lq_sta->lq_info[j]);
J
Johannes Berg 已提交
3167 3168

	lq_sta->flush_timer = 0;
3169
	lq_sta->last_tx = jiffies;
J
Johannes Berg 已提交
3170 3171 3172

	IWL_DEBUG_RATE(mvm,
		       "LQ: *** rate scale station global init for station %d ***\n",
3173
		       mvmsta->sta_id);
J
Johannes Berg 已提交
3174 3175 3176 3177 3178
	/* TODO: what is a good starting rate for STA? About middle? Maybe not
	 * the lowest or the highest rate.. Could consider using RSSI from
	 * previous packets? Need to have IEEE 802.1X auth succeed immediately
	 * after assoc.. */

3179
	lq_sta->missed_rate_counter = IWL_MVM_RS_MISSED_RATE_MAX;
J
Johannes Berg 已提交
3180 3181 3182 3183 3184 3185 3186 3187 3188
	lq_sta->band = sband->band;
	/*
	 * active legacy rates as per supported rates bitmap
	 */
	supp = sta->supp_rates[sband->band];
	lq_sta->active_legacy_rate = 0;
	for_each_set_bit(i, &supp, BITS_PER_LONG)
		lq_sta->active_legacy_rate |= BIT(sband->bitrates[i].hw_value);

E
Eyal Shapira 已提交
3189
	/* TODO: should probably account for rx_highest for both HT/VHT */
3190 3191 3192 3193
	if (!vht_cap || !vht_cap->vht_supported)
		rs_ht_init(mvm, sta, lq_sta, ht_cap);
	else
		rs_vht_init(mvm, sta, lq_sta, vht_cap);
J
Johannes Berg 已提交
3194

3195 3196 3197 3198 3199 3200
	lq_sta->max_legacy_rate_idx =
		rs_get_max_rate_from_mask(lq_sta->active_legacy_rate);
	lq_sta->max_siso_rate_idx =
		rs_get_max_rate_from_mask(lq_sta->active_siso_rate);
	lq_sta->max_mimo2_rate_idx =
		rs_get_max_rate_from_mask(lq_sta->active_mimo2_rate);
3201

E
Eyal Shapira 已提交
3202
	IWL_DEBUG_RATE(mvm,
3203
		       "LEGACY=%lX SISO=%lX MIMO2=%lX VHT=%d LDPC=%d STBC=%d BFER=%d\n",
3204
		       lq_sta->active_legacy_rate,
J
Johannes Berg 已提交
3205
		       lq_sta->active_siso_rate,
E
Eyal Shapira 已提交
3206
		       lq_sta->active_mimo2_rate,
3207 3208
		       lq_sta->is_vht, lq_sta->ldpc, lq_sta->stbc_capable,
		       lq_sta->bfer_capable);
3209 3210 3211 3212
	IWL_DEBUG_RATE(mvm, "MAX RATE: LEGACY=%d SISO=%d MIMO2=%d\n",
		       lq_sta->max_legacy_rate_idx,
		       lq_sta->max_siso_rate_idx,
		       lq_sta->max_mimo2_rate_idx);
J
Johannes Berg 已提交
3213 3214 3215

	/* These values will be overridden later */
	lq_sta->lq.single_stream_ant_msk =
3216
		iwl_mvm_bt_coex_get_single_ant_msk(mvm, iwl_mvm_get_valid_tx_ant(mvm));
3217
	lq_sta->lq.dual_stream_ant_msk = ANT_AB;
J
Johannes Berg 已提交
3218 3219 3220 3221

	/* as default allow aggregation for all tids */
	lq_sta->tx_agg_tid_en = IWL_AGG_ALL_TID;
	lq_sta->is_agg = 0;
3222
#ifdef CONFIG_IWLWIFI_DEBUGFS
3223
	iwl_mvm_reset_frame_stats(mvm);
3224
#endif
3225
	rs_initialize_lq(mvm, sta, lq_sta, band, update);
3226 3227
}

3228 3229 3230 3231 3232
static void rs_drv_rate_update(void *mvm_r,
			       struct ieee80211_supported_band *sband,
			       struct cfg80211_chan_def *chandef,
			       struct ieee80211_sta *sta,
			       void *priv_sta, u32 changed)
3233
{
3234 3235
	struct iwl_op_mode *op_mode = mvm_r;
	struct iwl_mvm *mvm __maybe_unused = IWL_OP_MODE_GET_MVM(op_mode);
3236 3237
	u8 tid;

3238 3239 3240
	if (!iwl_mvm_sta_from_mac80211(sta)->vif)
		return;

3241 3242 3243 3244
	/* Stop any ongoing aggregations as rs starts off assuming no agg */
	for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++)
		ieee80211_stop_tx_ba_session(sta, tid);

3245
	iwl_mvm_rs_rate_init(mvm, sta, sband->band, true);
J
Johannes Berg 已提交
3246 3247
}

3248 3249 3250
#ifdef CONFIG_MAC80211_DEBUGFS
static void rs_build_rates_table_from_fixed(struct iwl_mvm *mvm,
					    struct iwl_lq_cmd *lq_cmd,
3251
					    enum nl80211_band band,
3252 3253 3254 3255 3256 3257
					    u32 ucode_rate)
{
	struct rs_rate rate;
	int i;
	int num_rates = ARRAY_SIZE(lq_cmd->rs_table);
	__le32 ucode_rate_le32 = cpu_to_le32(ucode_rate);
3258
	u8 ant = (ucode_rate & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS;
3259 3260 3261 3262 3263 3264 3265 3266 3267 3268

	for (i = 0; i < num_rates; i++)
		lq_cmd->rs_table[i] = ucode_rate_le32;

	rs_rate_from_ucode_rate(ucode_rate, band, &rate);

	if (is_mimo(&rate))
		lq_cmd->mimo_delim = num_rates - 1;
	else
		lq_cmd->mimo_delim = 0;
3269 3270 3271 3272 3273 3274

	lq_cmd->reduced_tpc = 0;

	if (num_of_ant(ant) == 1)
		lq_cmd->single_stream_ant_msk = ant;

3275 3276 3277 3278 3279
	if (!mvm->trans->cfg->gen2)
		lq_cmd->agg_frame_cnt_limit = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
	else
		lq_cmd->agg_frame_cnt_limit =
			LINK_QUAL_AGG_FRAME_LIMIT_GEN2_DEF;
3280 3281 3282
}
#endif /* CONFIG_MAC80211_DEBUGFS */

3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297
static void rs_fill_rates_for_column(struct iwl_mvm *mvm,
				     struct iwl_lq_sta *lq_sta,
				     struct rs_rate *rate,
				     __le32 *rs_table, int *rs_table_index,
				     int num_rates, int num_retries,
				     u8 valid_tx_ant, bool toggle_ant)
{
	int i, j;
	__le32 ucode_rate;
	bool bottom_reached = false;
	int prev_rate_idx = rate->index;
	int end = LINK_QUAL_MAX_RETRY_NUM;
	int index = *rs_table_index;

	for (i = 0; i < num_rates && index < end; i++) {
3298 3299 3300
		for (j = 0; j < num_retries && index < end; j++, index++) {
			ucode_rate = cpu_to_le32(ucode_rate_from_rs_rate(mvm,
									 rate));
3301
			rs_table[index] = ucode_rate;
3302 3303 3304
			if (toggle_ant)
				rs_toggle_antenna(valid_tx_ant, rate);
		}
3305 3306 3307 3308 3309 3310 3311

		prev_rate_idx = rate->index;
		bottom_reached = rs_get_lower_rate_in_column(lq_sta, rate);
		if (bottom_reached && !is_legacy(rate))
			break;
	}

3312
	if (!bottom_reached && !is_legacy(rate))
3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337
		rate->index = prev_rate_idx;

	*rs_table_index = index;
}

/* Building the rate table is non trivial. When we're in MIMO2/VHT/80Mhz/SGI
 * column the rate table should look like this:
 *
 * rate[0] 0x400D019 VHT | ANT: AB BW: 80Mhz MCS: 9 NSS: 2 SGI
 * rate[1] 0x400D019 VHT | ANT: AB BW: 80Mhz MCS: 9 NSS: 2 SGI
 * rate[2] 0x400D018 VHT | ANT: AB BW: 80Mhz MCS: 8 NSS: 2 SGI
 * rate[3] 0x400D018 VHT | ANT: AB BW: 80Mhz MCS: 8 NSS: 2 SGI
 * rate[4] 0x400D017 VHT | ANT: AB BW: 80Mhz MCS: 7 NSS: 2 SGI
 * rate[5] 0x400D017 VHT | ANT: AB BW: 80Mhz MCS: 7 NSS: 2 SGI
 * rate[6] 0x4005007 VHT | ANT: A BW: 80Mhz MCS: 7 NSS: 1 NGI
 * rate[7] 0x4009006 VHT | ANT: B BW: 80Mhz MCS: 6 NSS: 1 NGI
 * rate[8] 0x4005005 VHT | ANT: A BW: 80Mhz MCS: 5 NSS: 1 NGI
 * rate[9] 0x800B Legacy | ANT: B Rate: 36 Mbps
 * rate[10] 0x4009 Legacy | ANT: A Rate: 24 Mbps
 * rate[11] 0x8007 Legacy | ANT: B Rate: 18 Mbps
 * rate[12] 0x4005 Legacy | ANT: A Rate: 12 Mbps
 * rate[13] 0x800F Legacy | ANT: B Rate: 9 Mbps
 * rate[14] 0x400D Legacy | ANT: A Rate: 6 Mbps
 * rate[15] 0x800D Legacy | ANT: B Rate: 6 Mbps
 */
3338
static void rs_build_rates_table(struct iwl_mvm *mvm,
3339
				 struct ieee80211_sta *sta,
3340 3341
				 struct iwl_lq_sta *lq_sta,
				 const struct rs_rate *initial_rate)
J
Johannes Berg 已提交
3342
{
3343
	struct rs_rate rate;
3344
	int num_rates, num_retries, index = 0;
J
Johannes Berg 已提交
3345 3346
	u8 valid_tx_ant = 0;
	struct iwl_lq_cmd *lq_cmd = &lq_sta->lq;
3347
	bool toggle_ant = false;
3348
	u32 color;
J
Johannes Berg 已提交
3349

3350
	memcpy(&rate, initial_rate, sizeof(rate));
3351

3352
	valid_tx_ant = iwl_mvm_get_valid_tx_ant(mvm);
3353

3354
	/* TODO: remove old API when min FW API hits 14 */
3355
	if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_LQ_SS_PARAMS) &&
3356 3357
	    rs_stbc_allow(mvm, sta, lq_sta))
		rate.stbc = true;
J
Johannes Berg 已提交
3358

3359
	if (is_siso(&rate)) {
3360 3361
		num_rates = IWL_MVM_RS_INITIAL_SISO_NUM_RATES;
		num_retries = IWL_MVM_RS_HT_VHT_RETRIES_PER_RATE;
3362
	} else if (is_mimo(&rate)) {
3363 3364
		num_rates = IWL_MVM_RS_INITIAL_MIMO_NUM_RATES;
		num_retries = IWL_MVM_RS_HT_VHT_RETRIES_PER_RATE;
J
Johannes Berg 已提交
3365
	} else {
3366
		num_rates = IWL_MVM_RS_INITIAL_LEGACY_NUM_RATES;
3367
		num_retries = IWL_MVM_RS_INITIAL_LEGACY_RETRIES;
3368
		toggle_ant = true;
J
Johannes Berg 已提交
3369 3370
	}

3371 3372 3373
	rs_fill_rates_for_column(mvm, lq_sta, &rate, lq_cmd->rs_table, &index,
				 num_rates, num_retries, valid_tx_ant,
				 toggle_ant);
J
Johannes Berg 已提交
3374

3375
	rs_get_lower_rate_down_column(lq_sta, &rate);
J
Johannes Berg 已提交
3376

3377
	if (is_siso(&rate)) {
3378 3379
		num_rates = IWL_MVM_RS_SECONDARY_SISO_NUM_RATES;
		num_retries = IWL_MVM_RS_SECONDARY_SISO_RETRIES;
3380
		lq_cmd->mimo_delim = index;
3381
	} else if (is_legacy(&rate)) {
3382
		num_rates = IWL_MVM_RS_SECONDARY_LEGACY_NUM_RATES;
3383
		num_retries = IWL_MVM_RS_SECONDARY_LEGACY_RETRIES;
3384 3385 3386
	} else {
		WARN_ON_ONCE(1);
	}
J
Johannes Berg 已提交
3387

3388
	toggle_ant = true;
J
Johannes Berg 已提交
3389

3390 3391 3392
	rs_fill_rates_for_column(mvm, lq_sta, &rate, lq_cmd->rs_table, &index,
				 num_rates, num_retries, valid_tx_ant,
				 toggle_ant);
J
Johannes Berg 已提交
3393

3394
	rs_get_lower_rate_down_column(lq_sta, &rate);
J
Johannes Berg 已提交
3395

3396
	num_rates = IWL_MVM_RS_SECONDARY_LEGACY_NUM_RATES;
3397
	num_retries = IWL_MVM_RS_SECONDARY_LEGACY_RETRIES;
J
Johannes Berg 已提交
3398

3399 3400 3401
	rs_fill_rates_for_column(mvm, lq_sta, &rate, lq_cmd->rs_table, &index,
				 num_rates, num_retries, valid_tx_ant,
				 toggle_ant);
J
Johannes Berg 已提交
3402

3403 3404 3405
	/* update the color of the LQ command (as a counter at bits 1-3) */
	color = LQ_FLAGS_COLOR_INC(LQ_FLAG_COLOR_GET(lq_cmd->flags));
	lq_cmd->flags = LQ_FLAG_COLOR_SET(lq_cmd->flags, color);
3406 3407
}

3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
struct rs_bfer_active_iter_data {
	struct ieee80211_sta *exclude_sta;
	struct iwl_mvm_sta *bfer_mvmsta;
};

static void rs_bfer_active_iter(void *_data,
				struct ieee80211_sta *sta)
{
	struct rs_bfer_active_iter_data *data = _data;
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
3418
	struct iwl_lq_cmd *lq_cmd = &mvmsta->lq_sta.rs_drv.lq;
3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486
	u32 ss_params = le32_to_cpu(lq_cmd->ss_params);

	if (sta == data->exclude_sta)
		return;

	/* The current sta has BFER allowed */
	if (ss_params & LQ_SS_BFER_ALLOWED) {
		WARN_ON_ONCE(data->bfer_mvmsta != NULL);

		data->bfer_mvmsta = mvmsta;
	}
}

static int rs_bfer_priority(struct iwl_mvm_sta *sta)
{
	int prio = -1;
	enum nl80211_iftype viftype = ieee80211_vif_type_p2p(sta->vif);

	switch (viftype) {
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_P2P_GO:
		prio = 3;
		break;
	case NL80211_IFTYPE_P2P_CLIENT:
		prio = 2;
		break;
	case NL80211_IFTYPE_STATION:
		prio = 1;
		break;
	default:
		WARN_ONCE(true, "viftype %d sta_id %d", viftype, sta->sta_id);
		prio = -1;
	}

	return prio;
}

/* Returns >0 if sta1 has a higher BFER priority compared to sta2 */
static int rs_bfer_priority_cmp(struct iwl_mvm_sta *sta1,
				struct iwl_mvm_sta *sta2)
{
	int prio1 = rs_bfer_priority(sta1);
	int prio2 = rs_bfer_priority(sta2);

	if (prio1 > prio2)
		return 1;
	if (prio1 < prio2)
		return -1;
	return 0;
}

static void rs_set_lq_ss_params(struct iwl_mvm *mvm,
				struct ieee80211_sta *sta,
				struct iwl_lq_sta *lq_sta,
				const struct rs_rate *initial_rate)
{
	struct iwl_lq_cmd *lq_cmd = &lq_sta->lq;
	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
	struct rs_bfer_active_iter_data data = {
		.exclude_sta = sta,
		.bfer_mvmsta = NULL,
	};
	struct iwl_mvm_sta *bfer_mvmsta = NULL;
	u32 ss_params = LQ_SS_PARAMS_VALID;

	if (!iwl_mvm_bt_coex_is_mimo_allowed(mvm, sta))
		goto out;

3487
#ifdef CONFIG_MAC80211_DEBUGFS
3488 3489 3490
	/* Check if forcing the decision is configured.
	 * Note that SISO is forced by not allowing STBC or BFER
	 */
3491
	if (lq_sta->pers.ss_force == RS_SS_FORCE_STBC)
3492
		ss_params |= (LQ_SS_STBC_1SS_ALLOWED | LQ_SS_FORCE);
3493
	else if (lq_sta->pers.ss_force == RS_SS_FORCE_BFER)
3494 3495
		ss_params |= (LQ_SS_BFER_ALLOWED | LQ_SS_FORCE);

3496
	if (lq_sta->pers.ss_force != RS_SS_FORCE_NONE) {
3497
		IWL_DEBUG_RATE(mvm, "Forcing single stream Tx decision %d\n",
3498
			       lq_sta->pers.ss_force);
3499 3500
		goto out;
	}
3501
#endif
3502

3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529
	if (lq_sta->stbc_capable)
		ss_params |= LQ_SS_STBC_1SS_ALLOWED;

	if (!lq_sta->bfer_capable)
		goto out;

	ieee80211_iterate_stations_atomic(mvm->hw,
					  rs_bfer_active_iter,
					  &data);
	bfer_mvmsta = data.bfer_mvmsta;

	/* This code is safe as it doesn't run concurrently for different
	 * stations. This is guaranteed by the fact that calls to
	 * ieee80211_tx_status wouldn't run concurrently for a single HW.
	 */
	if (!bfer_mvmsta) {
		IWL_DEBUG_RATE(mvm, "No sta with BFER allowed found. Allow\n");

		ss_params |= LQ_SS_BFER_ALLOWED;
		goto out;
	}

	IWL_DEBUG_RATE(mvm, "Found existing sta %d with BFER activated\n",
		       bfer_mvmsta->sta_id);

	/* Disallow BFER on another STA if active and we're a higher priority */
	if (rs_bfer_priority_cmp(mvmsta, bfer_mvmsta) > 0) {
3530 3531
		struct iwl_lq_cmd *bfersta_lq_cmd =
			&bfer_mvmsta->lq_sta.rs_drv.lq;
3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546
		u32 bfersta_ss_params = le32_to_cpu(bfersta_lq_cmd->ss_params);

		bfersta_ss_params &= ~LQ_SS_BFER_ALLOWED;
		bfersta_lq_cmd->ss_params = cpu_to_le32(bfersta_ss_params);
		iwl_mvm_send_lq_cmd(mvm, bfersta_lq_cmd, false);

		ss_params |= LQ_SS_BFER_ALLOWED;
		IWL_DEBUG_RATE(mvm,
			       "Lower priority BFER sta found (%d). Switch BFER\n",
			       bfer_mvmsta->sta_id);
	}
out:
	lq_cmd->ss_params = cpu_to_le32(ss_params);
}

3547 3548 3549 3550 3551 3552
static void rs_fill_lq_cmd(struct iwl_mvm *mvm,
			   struct ieee80211_sta *sta,
			   struct iwl_lq_sta *lq_sta,
			   const struct rs_rate *initial_rate)
{
	struct iwl_lq_cmd *lq_cmd = &lq_sta->lq;
3553 3554 3555
	struct iwl_mvm_sta *mvmsta;
	struct iwl_mvm_vif *mvmvif;

3556
	lq_cmd->agg_disable_start_th = IWL_MVM_RS_AGG_DISABLE_START;
3557
	lq_cmd->agg_time_limit =
3558
		cpu_to_le16(IWL_MVM_RS_AGG_TIME_LIMIT);
3559 3560

#ifdef CONFIG_MAC80211_DEBUGFS
3561
	if (lq_sta->pers.dbg_fixed_rate) {
3562 3563
		rs_build_rates_table_from_fixed(mvm, lq_cmd,
						lq_sta->band,
3564
						lq_sta->pers.dbg_fixed_rate);
3565 3566
		return;
	}
3567
#endif
3568 3569
	if (WARN_ON_ONCE(!sta || !initial_rate))
		return;
3570

3571
	rs_build_rates_table(mvm, sta, lq_sta, initial_rate);
J
Johannes Berg 已提交
3572

3573
	if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_LQ_SS_PARAMS))
3574 3575
		rs_set_lq_ss_params(mvm, sta, lq_sta, initial_rate);

3576 3577
	mvmsta = iwl_mvm_sta_from_mac80211(sta);
	mvmvif = iwl_mvm_vif_from_mac80211(mvmsta->vif);
3578

3579 3580
	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_COEX_SCHEMA_2) &&
	    num_of_ant(initial_rate->ant) == 1)
3581 3582 3583 3584 3585
		lq_cmd->single_stream_ant_msk = initial_rate->ant;

	lq_cmd->agg_frame_cnt_limit = mvmsta->max_agg_bufsize;

	/*
S
Sara Sharon 已提交
3586
	 * In case of low latency, tell the firmware to leave a frame in the
3587 3588 3589
	 * Tx Fifo so that it can start a transaction in the same TxOP. This
	 * basically allows the firmware to send bursts.
	 */
3590
	if (iwl_mvm_vif_low_latency(mvmvif))
3591 3592
		lq_cmd->agg_frame_cnt_limit--;

3593 3594 3595
	if (mvmsta->vif->p2p)
		lq_cmd->flags |= LQ_FLAG_USE_RTS_MSK;

3596
	lq_cmd->agg_time_limit =
3597
			cpu_to_le16(iwl_mvm_coex_agg_time_limit(mvm, sta));
J
Johannes Berg 已提交
3598 3599 3600 3601 3602 3603
}

static void *rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
{
	return hw->priv;
}
3604

J
Johannes Berg 已提交
3605 3606 3607 3608 3609 3610
/* rate scale requires free function to be implemented */
static void rs_free(void *mvm_rate)
{
	return;
}

3611
static void rs_free_sta(void *mvm_r, struct ieee80211_sta *sta, void *mvm_sta)
J
Johannes Berg 已提交
3612 3613 3614 3615 3616 3617 3618 3619 3620
{
	struct iwl_op_mode *op_mode __maybe_unused = mvm_r;
	struct iwl_mvm *mvm __maybe_unused = IWL_OP_MODE_GET_MVM(op_mode);

	IWL_DEBUG_RATE(mvm, "enter\n");
	IWL_DEBUG_RATE(mvm, "leave\n");
}

#ifdef CONFIG_MAC80211_DEBUGFS
3621
int rs_pretty_print_rate(char *buf, int bufsz, const u32 rate)
3622 3623
{

3624 3625 3626 3627 3628
	char *type, *bw;
	u8 mcs = 0, nss = 0;
	u8 ant = (rate & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS;

	if (!(rate & RATE_MCS_HT_MSK) &&
3629 3630
	    !(rate & RATE_MCS_VHT_MSK) &&
	    !(rate & RATE_MCS_HE_MSK)) {
3631 3632
		int index = iwl_hwrate_to_plcp_idx(rate);

3633 3634 3635 3636
		return scnprintf(buf, bufsz, "Legacy | ANT: %s Rate: %s Mbps\n",
				 rs_pretty_ant(ant),
				 index == IWL_RATE_INVALID ? "BAD" :
				 iwl_rate_mcs[index].mbps);
3637 3638 3639 3640 3641 3642 3643 3644 3645 3646
	}

	if (rate & RATE_MCS_VHT_MSK) {
		type = "VHT";
		mcs = rate & RATE_VHT_MCS_RATE_CODE_MSK;
		nss = ((rate & RATE_VHT_MCS_NSS_MSK)
		       >> RATE_VHT_MCS_NSS_POS) + 1;
	} else if (rate & RATE_MCS_HT_MSK) {
		type = "HT";
		mcs = rate & RATE_HT_MCS_INDEX_MSK;
3647 3648
		nss = ((rate & RATE_HT_MCS_NSS_MSK)
		       >> RATE_HT_MCS_NSS_POS) + 1;
3649 3650 3651 3652 3653
	} else if (rate & RATE_MCS_HE_MSK) {
		type = "HE";
		mcs = rate & RATE_VHT_MCS_RATE_CODE_MSK;
		nss = ((rate & RATE_VHT_MCS_NSS_MSK)
		       >> RATE_VHT_MCS_NSS_POS) + 1;
3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674
	} else {
		type = "Unknown"; /* shouldn't happen */
	}

	switch (rate & RATE_MCS_CHAN_WIDTH_MSK) {
	case RATE_MCS_CHAN_WIDTH_20:
		bw = "20Mhz";
		break;
	case RATE_MCS_CHAN_WIDTH_40:
		bw = "40Mhz";
		break;
	case RATE_MCS_CHAN_WIDTH_80:
		bw = "80Mhz";
		break;
	case RATE_MCS_CHAN_WIDTH_160:
		bw = "160Mhz";
		break;
	default:
		bw = "BAD BW";
	}

3675 3676 3677 3678 3679 3680 3681
	return scnprintf(buf, bufsz,
			 "%s | ANT: %s BW: %s MCS: %d NSS: %d %s%s%s%s\n",
			 type, rs_pretty_ant(ant), bw, mcs, nss,
			 (rate & RATE_MCS_SGI_MSK) ? "SGI " : "NGI ",
			 (rate & RATE_MCS_STBC_MSK) ? "STBC " : "",
			 (rate & RATE_MCS_LDPC_MSK) ? "LDPC " : "",
			 (rate & RATE_MCS_BF_MSK) ? "BF " : "");
3682 3683
}

3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697
/**
 * Program the device to use fixed rate for frame transmit
 * This is for debugging/testing only
 * once the device start use fixed rate, we need to reload the module
 * to being back the normal operation.
 */
static void rs_program_fix_rate(struct iwl_mvm *mvm,
				struct iwl_lq_sta *lq_sta)
{
	lq_sta->active_legacy_rate = 0x0FFF;	/* 1 - 54 MBits, includes CCK */
	lq_sta->active_siso_rate   = 0x1FD0;	/* 6 - 60 MBits, no 9, no CCK */
	lq_sta->active_mimo2_rate  = 0x1FD0;	/* 6 - 60 MBits, no 9, no CCK */

	IWL_DEBUG_RATE(mvm, "sta_id %d rate 0x%X\n",
3698
		       lq_sta->lq.sta_id, lq_sta->pers.dbg_fixed_rate);
3699

3700
	if (lq_sta->pers.dbg_fixed_rate) {
3701
		rs_fill_lq_cmd(mvm, NULL, lq_sta, NULL);
3702
		iwl_mvm_send_lq_cmd(lq_sta->pers.drv, &lq_sta->lq, false);
3703 3704 3705
	}
}

3706 3707 3708 3709 3710 3711 3712 3713 3714
static ssize_t rs_sta_dbgfs_scale_table_write(struct file *file,
			const char __user *user_buf, size_t count, loff_t *ppos)
{
	struct iwl_lq_sta *lq_sta = file->private_data;
	struct iwl_mvm *mvm;
	char buf[64];
	size_t buf_size;
	u32 parsed_rate;

3715
	mvm = lq_sta->pers.drv;
3716 3717 3718 3719 3720 3721
	memset(buf, 0, sizeof(buf));
	buf_size = min(count, sizeof(buf) -  1);
	if (copy_from_user(buf, user_buf, buf_size))
		return -EFAULT;

	if (sscanf(buf, "%x", &parsed_rate) == 1)
3722
		lq_sta->pers.dbg_fixed_rate = parsed_rate;
3723
	else
3724
		lq_sta->pers.dbg_fixed_rate = 0;
3725 3726 3727 3728 3729 3730

	rs_program_fix_rate(mvm, lq_sta);

	return count;
}

J
Johannes Berg 已提交
3731 3732 3733 3734 3735 3736 3737
static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file,
			char __user *user_buf, size_t count, loff_t *ppos)
{
	char *buff;
	int desc = 0;
	int i = 0;
	ssize_t ret;
3738
	static const size_t bufsz = 2048;
J
Johannes Berg 已提交
3739 3740

	struct iwl_lq_sta *lq_sta = file->private_data;
3741
	struct iwl_mvm_sta *mvmsta =
3742
		container_of(lq_sta, struct iwl_mvm_sta, lq_sta.rs_drv);
J
Johannes Berg 已提交
3743 3744
	struct iwl_mvm *mvm;
	struct iwl_scale_tbl_info *tbl = &(lq_sta->lq_info[lq_sta->active_tbl]);
3745
	struct rs_rate *rate = &tbl->rate;
3746
	u32 ss_params;
3747

3748
	mvm = lq_sta->pers.drv;
3749
	buff = kmalloc(bufsz, GFP_KERNEL);
J
Johannes Berg 已提交
3750 3751 3752
	if (!buff)
		return -ENOMEM;

3753 3754 3755 3756 3757 3758 3759 3760 3761
	desc += scnprintf(buff + desc, bufsz - desc,
			  "sta_id %d\n", lq_sta->lq.sta_id);
	desc += scnprintf(buff + desc, bufsz - desc,
			  "failed=%d success=%d rate=0%lX\n",
			  lq_sta->total_failed, lq_sta->total_success,
			  lq_sta->active_legacy_rate);
	desc += scnprintf(buff + desc, bufsz - desc, "fixed rate 0x%X\n",
			  lq_sta->pers.dbg_fixed_rate);
	desc += scnprintf(buff + desc, bufsz - desc, "valid_tx_ant %s%s%s\n",
3762 3763 3764
	    (iwl_mvm_get_valid_tx_ant(mvm) & ANT_A) ? "ANT_A," : "",
	    (iwl_mvm_get_valid_tx_ant(mvm) & ANT_B) ? "ANT_B," : "",
	    (iwl_mvm_get_valid_tx_ant(mvm) & ANT_C) ? "ANT_C" : "");
3765 3766 3767
	desc += scnprintf(buff + desc, bufsz - desc, "lq type %s\n",
			  (is_legacy(rate)) ? "legacy" :
			  is_vht(rate) ? "VHT" : "HT");
3768
	if (!is_legacy(rate)) {
3769
		desc += scnprintf(buff + desc, bufsz - desc, " %s",
3770
		   (is_siso(rate)) ? "SISO" : "MIMO2");
3771
		desc += scnprintf(buff + desc, bufsz - desc, " %s",
3772 3773
				(is_ht20(rate)) ? "20MHz" :
				(is_ht40(rate)) ? "40MHz" :
3774 3775
				(is_ht80(rate)) ? "80MHz" :
				(is_ht160(rate)) ? "160MHz" : "BAD BW");
3776
		desc += scnprintf(buff + desc, bufsz - desc, " %s %s %s %s\n",
3777 3778
				(rate->sgi) ? "SGI" : "NGI",
				(rate->ldpc) ? "LDPC" : "BCC",
3779
				(lq_sta->is_agg) ? "AGG on" : "",
3780
				(mvmsta->amsdu_enabled) ? "AMSDU on" : "");
J
Johannes Berg 已提交
3781
	}
3782
	desc += scnprintf(buff + desc, bufsz - desc, "last tx rate=0x%X\n",
J
Johannes Berg 已提交
3783
			lq_sta->last_rate_n_flags);
3784
	desc += scnprintf(buff + desc, bufsz - desc,
3785
			"general: flags=0x%X mimo-d=%d s-ant=0x%x d-ant=0x%x\n",
J
Johannes Berg 已提交
3786 3787 3788 3789 3790
			lq_sta->lq.flags,
			lq_sta->lq.mimo_delim,
			lq_sta->lq.single_stream_ant_msk,
			lq_sta->lq.dual_stream_ant_msk);

3791
	desc += scnprintf(buff + desc, bufsz - desc,
J
Johannes Berg 已提交
3792 3793 3794 3795 3796
			"agg: time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
			le16_to_cpu(lq_sta->lq.agg_time_limit),
			lq_sta->lq.agg_disable_start_th,
			lq_sta->lq.agg_frame_cnt_limit);

3797 3798
	desc += scnprintf(buff + desc, bufsz - desc, "reduced tpc=%d\n",
			  lq_sta->lq.reduced_tpc);
3799
	ss_params = le32_to_cpu(lq_sta->lq.ss_params);
3800 3801
	desc += scnprintf(buff + desc, bufsz - desc,
			"single stream params: %s%s%s%s\n",
3802
			(ss_params & LQ_SS_PARAMS_VALID) ?
3803
			"VALID" : "INVALID",
3804
			(ss_params & LQ_SS_BFER_ALLOWED) ?
3805
			", BFER" : "",
3806
			(ss_params & LQ_SS_STBC_1SS_ALLOWED) ?
3807
			", STBC" : "",
3808
			(ss_params & LQ_SS_FORCE) ?
3809
			", FORCE" : "");
3810
	desc += scnprintf(buff + desc, bufsz - desc,
J
Johannes Berg 已提交
3811 3812 3813 3814 3815 3816 3817
			"Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
			lq_sta->lq.initial_rate_index[0],
			lq_sta->lq.initial_rate_index[1],
			lq_sta->lq.initial_rate_index[2],
			lq_sta->lq.initial_rate_index[3]);

	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
3818
		u32 r = le32_to_cpu(lq_sta->lq.rs_table[i]);
3819

3820 3821 3822
		desc += scnprintf(buff + desc, bufsz - desc,
				  " rate[%d] 0x%X ", i, r);
		desc += rs_pretty_print_rate(buff + desc, bufsz - desc, r);
J
Johannes Berg 已提交
3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842
	}

	ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
	kfree(buff);
	return ret;
}

static const struct file_operations rs_sta_dbgfs_scale_table_ops = {
	.write = rs_sta_dbgfs_scale_table_write,
	.read = rs_sta_dbgfs_scale_table_read,
	.open = simple_open,
	.llseek = default_llseek,
};
static ssize_t rs_sta_dbgfs_stats_table_read(struct file *file,
			char __user *user_buf, size_t count, loff_t *ppos)
{
	char *buff;
	int desc = 0;
	int i, j;
	ssize_t ret;
E
Eyal Shapira 已提交
3843
	struct iwl_scale_tbl_info *tbl;
3844
	struct rs_rate *rate;
J
Johannes Berg 已提交
3845 3846 3847 3848 3849 3850 3851
	struct iwl_lq_sta *lq_sta = file->private_data;

	buff = kmalloc(1024, GFP_KERNEL);
	if (!buff)
		return -ENOMEM;

	for (i = 0; i < LQ_SIZE; i++) {
E
Eyal Shapira 已提交
3852
		tbl = &(lq_sta->lq_info[i]);
3853
		rate = &tbl->rate;
J
Johannes Berg 已提交
3854
		desc += sprintf(buff+desc,
3855
				"%s type=%d SGI=%d BW=%s DUP=0\n"
3856
				"index=%d\n",
J
Johannes Berg 已提交
3857
				lq_sta->active_tbl == i ? "*" : "x",
3858 3859
				rate->type,
				rate->sgi,
3860 3861 3862 3863
				is_ht20(rate) ? "20MHz" :
				is_ht40(rate) ? "40MHz" :
				is_ht80(rate) ? "80MHz" :
				is_ht160(rate) ? "160MHz" : "ERR",
3864
				rate->index);
J
Johannes Berg 已提交
3865 3866 3867
		for (j = 0; j < IWL_RATE_COUNT; j++) {
			desc += sprintf(buff+desc,
				"counter=%d success=%d %%=%d\n",
E
Eyal Shapira 已提交
3868 3869 3870
				tbl->win[j].counter,
				tbl->win[j].success_counter,
				tbl->win[j].success_ratio);
J
Johannes Berg 已提交
3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883
		}
	}
	ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);
	kfree(buff);
	return ret;
}

static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
	.read = rs_sta_dbgfs_stats_table_read,
	.open = simple_open,
	.llseek = default_llseek,
};

3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914
static ssize_t rs_sta_dbgfs_drv_tx_stats_read(struct file *file,
					      char __user *user_buf,
					      size_t count, loff_t *ppos)
{
	static const char * const column_name[] = {
		[RS_COLUMN_LEGACY_ANT_A] = "LEGACY_ANT_A",
		[RS_COLUMN_LEGACY_ANT_B] = "LEGACY_ANT_B",
		[RS_COLUMN_SISO_ANT_A] = "SISO_ANT_A",
		[RS_COLUMN_SISO_ANT_B] = "SISO_ANT_B",
		[RS_COLUMN_SISO_ANT_A_SGI] = "SISO_ANT_A_SGI",
		[RS_COLUMN_SISO_ANT_B_SGI] = "SISO_ANT_B_SGI",
		[RS_COLUMN_MIMO2] = "MIMO2",
		[RS_COLUMN_MIMO2_SGI] = "MIMO2_SGI",
	};

	static const char * const rate_name[] = {
		[IWL_RATE_1M_INDEX] = "1M",
		[IWL_RATE_2M_INDEX] = "2M",
		[IWL_RATE_5M_INDEX] = "5.5M",
		[IWL_RATE_11M_INDEX] = "11M",
		[IWL_RATE_6M_INDEX] = "6M|MCS0",
		[IWL_RATE_9M_INDEX] = "9M",
		[IWL_RATE_12M_INDEX] = "12M|MCS1",
		[IWL_RATE_18M_INDEX] = "18M|MCS2",
		[IWL_RATE_24M_INDEX] = "24M|MCS3",
		[IWL_RATE_36M_INDEX] = "36M|MCS4",
		[IWL_RATE_48M_INDEX] = "48M|MCS5",
		[IWL_RATE_54M_INDEX] = "54M|MCS6",
		[IWL_RATE_MCS_7_INDEX] = "MCS7",
		[IWL_RATE_MCS_8_INDEX] = "MCS8",
		[IWL_RATE_MCS_9_INDEX] = "MCS9",
3915 3916
		[IWL_RATE_MCS_10_INDEX] = "MCS10",
		[IWL_RATE_MCS_11_INDEX] = "MCS11",
3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942
	};

	char *buff, *pos, *endpos;
	int col, rate;
	ssize_t ret;
	struct iwl_lq_sta *lq_sta = file->private_data;
	struct rs_rate_stats *stats;
	static const size_t bufsz = 1024;

	buff = kmalloc(bufsz, GFP_KERNEL);
	if (!buff)
		return -ENOMEM;

	pos = buff;
	endpos = pos + bufsz;

	pos += scnprintf(pos, endpos - pos, "COLUMN,");
	for (rate = 0; rate < IWL_RATE_COUNT; rate++)
		pos += scnprintf(pos, endpos - pos, "%s,", rate_name[rate]);
	pos += scnprintf(pos, endpos - pos, "\n");

	for (col = 0; col < RS_COLUMN_COUNT; col++) {
		pos += scnprintf(pos, endpos - pos,
				 "%s,", column_name[col]);

		for (rate = 0; rate < IWL_RATE_COUNT; rate++) {
3943
			stats = &(lq_sta->pers.tx_stats[col][rate]);
3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961
			pos += scnprintf(pos, endpos - pos,
					 "%llu/%llu,",
					 stats->success,
					 stats->total);
		}
		pos += scnprintf(pos, endpos - pos, "\n");
	}

	ret = simple_read_from_buffer(user_buf, count, ppos, buff, pos - buff);
	kfree(buff);
	return ret;
}

static ssize_t rs_sta_dbgfs_drv_tx_stats_write(struct file *file,
					       const char __user *user_buf,
					       size_t count, loff_t *ppos)
{
	struct iwl_lq_sta *lq_sta = file->private_data;
3962
	memset(lq_sta->pers.tx_stats, 0, sizeof(lq_sta->pers.tx_stats));
3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973

	return count;
}

static const struct file_operations rs_sta_dbgfs_drv_tx_stats_ops = {
	.read = rs_sta_dbgfs_drv_tx_stats_read,
	.write = rs_sta_dbgfs_drv_tx_stats_write,
	.open = simple_open,
	.llseek = default_llseek,
};

3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989
static ssize_t iwl_dbgfs_ss_force_read(struct file *file,
				       char __user *user_buf,
				       size_t count, loff_t *ppos)
{
	struct iwl_lq_sta *lq_sta = file->private_data;
	char buf[12];
	int bufsz = sizeof(buf);
	int pos = 0;
	static const char * const ss_force_name[] = {
		[RS_SS_FORCE_NONE] = "none",
		[RS_SS_FORCE_STBC] = "stbc",
		[RS_SS_FORCE_BFER] = "bfer",
		[RS_SS_FORCE_SISO] = "siso",
	};

	pos += scnprintf(buf+pos, bufsz-pos, "%s\n",
3990
			 ss_force_name[lq_sta->pers.ss_force]);
3991 3992 3993 3994 3995 3996 3997 3998 3999 4000
	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
}

static ssize_t iwl_dbgfs_ss_force_write(struct iwl_lq_sta *lq_sta, char *buf,
					size_t count, loff_t *ppos)
{
	struct iwl_mvm *mvm = lq_sta->pers.drv;
	int ret = 0;

	if (!strncmp("none", buf, 4)) {
4001
		lq_sta->pers.ss_force = RS_SS_FORCE_NONE;
4002
	} else if (!strncmp("siso", buf, 4)) {
4003
		lq_sta->pers.ss_force = RS_SS_FORCE_SISO;
4004 4005
	} else if (!strncmp("stbc", buf, 4)) {
		if (lq_sta->stbc_capable) {
4006
			lq_sta->pers.ss_force = RS_SS_FORCE_STBC;
4007 4008 4009 4010 4011 4012 4013
		} else {
			IWL_ERR(mvm,
				"can't force STBC. peer doesn't support\n");
			ret = -EINVAL;
		}
	} else if (!strncmp("bfer", buf, 4)) {
		if (lq_sta->bfer_capable) {
4014
			lq_sta->pers.ss_force = RS_SS_FORCE_BFER;
4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036
		} else {
			IWL_ERR(mvm,
				"can't force BFER. peer doesn't support\n");
			ret = -EINVAL;
		}
	} else {
		IWL_ERR(mvm, "valid values none|siso|stbc|bfer\n");
		ret = -EINVAL;
	}
	return ret ?: count;
}

#define MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \
	_MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct iwl_lq_sta)
#define MVM_DEBUGFS_ADD_FILE_RS(name, parent, mode) do {		\
		if (!debugfs_create_file(#name, mode, parent, lq_sta,	\
					 &iwl_dbgfs_##name##_ops))	\
			goto err;					\
	} while (0)

MVM_DEBUGFS_READ_WRITE_FILE_OPS(ss_force, 32);

4037 4038
static void rs_drv_add_sta_debugfs(void *mvm, void *priv_sta,
				   struct dentry *dir)
J
Johannes Berg 已提交
4039
{
4040 4041 4042
	struct iwl_lq_sta *lq_sta = priv_sta;
	struct iwl_mvm_sta *mvmsta;

4043
	mvmsta = container_of(lq_sta, struct iwl_mvm_sta, lq_sta.rs_drv);
4044 4045 4046

	if (!mvmsta->vif)
		return;
4047

4048
	debugfs_create_file("rate_scale_table", 0600, dir,
4049
			    lq_sta, &rs_sta_dbgfs_scale_table_ops);
4050
	debugfs_create_file("rate_stats_table", 0400, dir,
4051
			    lq_sta, &rs_sta_dbgfs_stats_table_ops);
4052
	debugfs_create_file("drv_tx_stats", 0600, dir,
4053
			    lq_sta, &rs_sta_dbgfs_drv_tx_stats_ops);
4054
	debugfs_create_u8("tx_agg_tid_enable", 0600, dir,
4055
			  &lq_sta->tx_agg_tid_en);
4056
	debugfs_create_u8("reduced_tpc", 0600, dir,
4057
			  &lq_sta->pers.dbg_fixed_txp_reduction);
4058

4059
	MVM_DEBUGFS_ADD_FILE_RS(ss_force, dir, 0600);
4060 4061 4062
	return;
err:
	IWL_ERR((struct iwl_mvm *)mvm, "Can't create debugfs entity\n");
J
Johannes Berg 已提交
4063 4064
}

4065
void rs_remove_sta_debugfs(void *mvm, void *mvm_sta)
J
Johannes Berg 已提交
4066 4067 4068 4069 4070 4071 4072 4073 4074
{
}
#endif

/*
 * Initialization of rate scaling information is done by driver after
 * the station is added. Since mac80211 calls this function before a
 * station is added we ignore it.
 */
4075 4076 4077 4078
static void rs_rate_init_ops(void *mvm_r,
			     struct ieee80211_supported_band *sband,
			     struct cfg80211_chan_def *chandef,
			     struct ieee80211_sta *sta, void *mvm_sta)
J
Johannes Berg 已提交
4079 4080
{
}
4081

4082 4083
/* ops for rate scaling implemented in the driver */
static const struct rate_control_ops rs_mvm_ops_drv = {
J
Johannes Berg 已提交
4084
	.name = RS_NAME,
4085 4086 4087
	.tx_status = rs_drv_mac80211_tx_status,
	.get_rate = rs_drv_get_rate,
	.rate_init = rs_rate_init_ops,
J
Johannes Berg 已提交
4088 4089
	.alloc = rs_alloc,
	.free = rs_free,
4090
	.alloc_sta = rs_drv_alloc_sta,
J
Johannes Berg 已提交
4091
	.free_sta = rs_free_sta,
4092
	.rate_update = rs_drv_rate_update,
J
Johannes Berg 已提交
4093
#ifdef CONFIG_MAC80211_DEBUGFS
4094 4095
	.add_sta_debugfs = rs_drv_add_sta_debugfs,
	.remove_sta_debugfs = rs_remove_sta_debugfs,
J
Johannes Berg 已提交
4096 4097 4098
#endif
};

4099
void iwl_mvm_rs_rate_init(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
4100
			  enum nl80211_band band, bool update)
4101
{
4102
	if (iwl_mvm_has_tlc_offload(mvm))
4103
		rs_fw_rate_init(mvm, sta, band, update);
4104
	else
4105
		rs_drv_rate_init(mvm, sta, band, update);
4106 4107
}

J
Johannes Berg 已提交
4108 4109
int iwl_mvm_rate_control_register(void)
{
4110
	return ieee80211_rate_control_register(&rs_mvm_ops_drv);
J
Johannes Berg 已提交
4111 4112 4113 4114
}

void iwl_mvm_rate_control_unregister(void)
{
4115
	ieee80211_rate_control_unregister(&rs_mvm_ops_drv);
J
Johannes Berg 已提交
4116
}
4117

4118 4119
static int rs_drv_tx_protection(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta,
				bool enable)
4120
{
4121
	struct iwl_lq_cmd *lq = &mvmsta->lq_sta.rs_drv.lq;
4122

4123 4124 4125 4126
	lockdep_assert_held(&mvm->mutex);

	if (enable) {
		if (mvmsta->tx_protection == 0)
4127
			lq->flags |= LQ_FLAG_USE_RTS_MSK;
4128 4129 4130 4131
		mvmsta->tx_protection++;
	} else {
		mvmsta->tx_protection--;
		if (mvmsta->tx_protection == 0)
4132
			lq->flags &= ~LQ_FLAG_USE_RTS_MSK;
4133 4134
	}

4135
	return iwl_mvm_send_lq_cmd(mvm, lq, false);
4136
}
4137 4138 4139 4140 4141 4142 4143 4144 4145

/**
 * iwl_mvm_tx_protection - ask FW to enable RTS/CTS protection
 * @mvmsta: The station
 * @enable: Enable Tx protection?
 */
int iwl_mvm_tx_protection(struct iwl_mvm *mvm, struct iwl_mvm_sta *mvmsta,
			  bool enable)
{
4146
	if (iwl_mvm_has_tlc_offload(mvm))
4147 4148 4149 4150
		return rs_fw_tx_protection(mvm, mvmsta, enable);
	else
		return rs_drv_tx_protection(mvm, mvmsta, enable);
}