iwl-agn-rs.c 73.5 KB
Newer Older
1
2
/******************************************************************************
 *
3
 * Copyright(c) 2005 - 2008 Intel Corporation. All rights reserved.
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
 * James P. Ketrenos <ipw2100-admin@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/wireless.h>
#include <net/mac80211.h>

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

#include <linux/workqueue.h>

Johannes Berg's avatar
Johannes Berg committed
38
#include "../net/mac80211/rate.h"
39

40
#include "iwl-dev.h"
41
#include "iwl-sta.h"
42
#include "iwl-core.h"
43
44
#include "iwl-helpers.h"

45
#define RS_NAME "iwl-agn-rs"
46

47
#define NUM_TRY_BEFORE_ANT_TOGGLE 1
48
49
50
#define IWL_NUMBER_TRY      1
#define IWL_HT_NUMBER_TRY   3

51
52
53
54
55
56
#define IWL_RATE_MAX_WINDOW		62	/* # tx in history window */
#define IWL_RATE_MIN_FAILURE_TH		6	/* min failures to calc tpt */
#define IWL_RATE_MIN_SUCCESS_TH		8	/* min successes to calc tpt */

/* max time to accum history 2 seconds */
#define IWL_RATE_SCALE_FLUSH_INTVL   (2*HZ)
57
58
59
60
61
62
63
64
65
66
67

static u8 rs_ht_to_legacy[] = {
	IWL_RATE_6M_INDEX, IWL_RATE_6M_INDEX,
	IWL_RATE_6M_INDEX, IWL_RATE_6M_INDEX,
	IWL_RATE_6M_INDEX,
	IWL_RATE_6M_INDEX, IWL_RATE_9M_INDEX,
	IWL_RATE_12M_INDEX, IWL_RATE_18M_INDEX,
	IWL_RATE_24M_INDEX, IWL_RATE_36M_INDEX,
	IWL_RATE_48M_INDEX, IWL_RATE_54M_INDEX
};

68
69
70
71
72
73
74
75
76
77
78
static const u8 ant_toggle_lookup[] = {
	/*ANT_NONE -> */ ANT_NONE,
	/*ANT_A    -> */ ANT_B,
	/*ANT_B    -> */ ANT_C,
	/*ANT_AB   -> */ ANT_BC,
	/*ANT_C    -> */ ANT_A,
	/*ANT_AC   -> */ ANT_AB,
	/*ANT_BC   -> */ ANT_AC,
	/*ANT_ABC  -> */ ANT_ABC,
};

79
/**
80
 * struct iwl_rate_scale_data -- tx success history for one rate
81
 */
82
struct iwl_rate_scale_data {
83
84
85
86
87
	u64 data;		/* bitmap of successful frames */
	s32 success_counter;	/* number of frames successful */
	s32 success_ratio;	/* per-cent * 128  */
	s32 counter;		/* number of frames attempted */
	s32 average_tpt;	/* success ratio * expected throughput */
88
89
90
	unsigned long stamp;
};

91
/**
92
 * struct iwl_scale_tbl_info -- tx params and success history for all rates
93
 *
94
 * There are two of these in struct iwl_lq_sta,
95
96
 * one for "active", and one for "search".
 */
97
struct iwl_scale_tbl_info {
98
99
	enum iwl_table_type lq_type;
	u8 ant_type;
100
101
102
103
104
	u8 is_SGI;	/* 1 = short guard interval */
	u8 is_fat;	/* 1 = 40 MHz channel width */
	u8 is_dup;	/* 1 = duplicated data streams */
	u8 action;	/* change modulation; IWL_[LEGACY/SISO/MIMO]_SWITCH_* */
	s32 *expected_tpt;	/* throughput metrics; expected_tpt_G, etc. */
Guy Cohen's avatar
Guy Cohen committed
105
	u32 current_rate;  /* rate_n_flags, uCode API format */
106
	struct iwl_rate_scale_data win[IWL_RATE_COUNT]; /* rate histories */
107
108
};

109
struct iwl_traffic_load {
110
111
112
113
114
115
116
117
118
119
	unsigned long time_stamp;	/* age of the oldest statistics */
	u32 packet_count[TID_QUEUE_MAX_SIZE];   /* packet count in this time
						 * slice */
	u32 total;			/* total num of packets during the
					 * last TID_MAX_TIME_DIFF */
	u8 queue_count;			/* number of queues that has
					 * been used since the last cleanup */
	u8 head;			/* start of the circular buffer */
};

120
/**
121
 * struct iwl_lq_sta -- driver's rate scaling private structure
122
123
124
 *
 * Pointer to this gets passed back and forth between driver and mac80211.
 */
125
struct iwl_lq_sta {
126
127
128
129
	u8 active_tbl;		/* index of active table, range 0-1 */
	u8 enable_counter;	/* indicates HT mode */
	u8 stay_in_tbl;		/* 1: disallow, 0: allow search for new mode */
	u8 search_better_tbl;	/* 1: currently trying alternate mode */
130
	s32 last_tpt;
131
132

	/* The following determine when to search for a new mode */
133
	u32 table_count_limit;
134
135
	u32 max_failure_limit;	/* # failed frames before new search */
	u32 max_success_limit;	/* # successful frames before new search */
136
	u32 table_count;
137
138
139
140
141
	u32 total_failed;	/* total failed frames, any/all rates */
	u32 total_success;	/* total successful frames, any/all rates */
	u32 flush_timer;	/* time staying in mode before new search */

	u8 action_counter;	/* # mode-switch actions tried */
142
143
	u8 is_green;
	u8 is_dup;
144
	enum ieee80211_band band;
145
	u8 ibss_sta_added;
146
147

	/* The following are bitmaps of rates; IWL_RATE_6M_MASK, etc. */
148
	u32 supp_rates;
Guy Cohen's avatar
Guy Cohen committed
149
	u16 active_legacy_rate;
150
	u16 active_siso_rate;
151
152
	u16 active_mimo2_rate;
	u16 active_mimo3_rate;
153
	u16 active_rate_basic;
154

155
	struct iwl_link_quality_cmd lq;
156
157
	struct iwl_scale_tbl_info lq_info[LQ_SIZE]; /* "active", "search" */
	struct iwl_traffic_load load[TID_MAX_LOAD_COUNT];
158
	u8 tx_agg_tid_en;
159
#ifdef CONFIG_MAC80211_DEBUGFS
160
	struct dentry *rs_sta_dbgfs_scale_table_file;
161
	struct dentry *rs_sta_dbgfs_stats_table_file;
162
	struct dentry *rs_sta_dbgfs_tx_agg_tid_en_file;
Guy Cohen's avatar
Guy Cohen committed
163
	u32 dbg_fixed_rate;
164
#endif
165
	struct iwl_priv *drv;
166
167
};

168
static void rs_rate_scale_perform(struct iwl_priv *priv,
169
170
171
				   struct net_device *dev,
				   struct ieee80211_hdr *hdr,
				   struct sta_info *sta);
172
static void rs_fill_link_cmd(const struct iwl_priv *priv,
173
			     struct iwl_lq_sta *lq_sta, u32 rate_n_flags);
174
175


176
#ifdef CONFIG_MAC80211_DEBUGFS
177
178
static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
			     u32 *rate_n_flags, int index);
179
#else
180
181
static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
			     u32 *rate_n_flags, int index)
182
183
{}
#endif
184
185
186
187
188
189

/*
 * Expected throughput metrics for following rates:
 * 1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 60 MBits
 * "G" is the only table that supports CCK (the first 4 rates).
 */
190
/*FIXME:RS:need to spearate tables for MIMO2/MIMO3*/
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
static s32 expected_tpt_A[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186, 186
};

static s32 expected_tpt_G[IWL_RATE_COUNT] = {
	7, 13, 35, 58, 40, 57, 72, 98, 121, 154, 177, 186, 186
};

static s32 expected_tpt_siso20MHz[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 42, 42, 76, 102, 124, 159, 183, 193, 202
};

static s32 expected_tpt_siso20MHzSGI[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 46, 46, 82, 110, 132, 168, 192, 202, 211
};

static s32 expected_tpt_mimo20MHz[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 74, 74, 123, 155, 179, 214, 236, 244, 251
};

static s32 expected_tpt_mimo20MHzSGI[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 81, 81, 131, 164, 188, 222, 243, 251, 257
};

static s32 expected_tpt_siso40MHz[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 77, 77, 127, 160, 184, 220, 242, 250, 257
};

static s32 expected_tpt_siso40MHzSGI[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 83, 83, 135, 169, 193, 229, 250, 257, 264
};

static s32 expected_tpt_mimo40MHz[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 123, 123, 182, 214, 235, 264, 279, 285, 289
};

static s32 expected_tpt_mimo40MHzSGI[IWL_RATE_COUNT] = {
	0, 0, 0, 0, 131, 131, 191, 222, 242, 270, 284, 289, 293
};

Guy Cohen's avatar
Guy Cohen committed
231
static inline u8 rs_extract_rate(u32 rate_n_flags)
232
233
234
235
{
	return (u8)(rate_n_flags & 0xFF);
}

236
static void rs_rate_scale_clear_window(struct iwl_rate_scale_data *window)
237
238
239
240
241
242
243
244
245
{
	window->data = 0;
	window->success_counter = 0;
	window->success_ratio = IWL_INVALID_VALUE;
	window->counter = 0;
	window->average_tpt = IWL_INVALID_VALUE;
	window->stamp = 0;
}

246
247
248
249
250
static inline u8 rs_is_valid_ant(u8 valid_antenna, u8 ant_type)
{
	return ((ant_type & valid_antenna) == ant_type);
}

251
252
253
254
/*
 *	removes the old data from the statistics. All data that is older than
 *	TID_MAX_TIME_DIFF, will be deleted.
 */
255
static void rs_tl_rm_old_stats(struct iwl_traffic_load *tl, u32 curr_time)
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
{
	/* The oldest age we want to keep */
	u32 oldest_time = curr_time - TID_MAX_TIME_DIFF;

	while (tl->queue_count &&
	       (tl->time_stamp < oldest_time)) {
		tl->total -= tl->packet_count[tl->head];
		tl->packet_count[tl->head] = 0;
		tl->time_stamp += TID_QUEUE_CELL_SPACING;
		tl->queue_count--;
		tl->head++;
		if (tl->head >= TID_QUEUE_MAX_SIZE)
			tl->head = 0;
	}
}

/*
 *	increment traffic load value for tid and also remove
 *	any old values if passed the certain time period
 */
276
static u8 rs_tl_add_packet(struct iwl_lq_sta *lq_data,
277
			   struct ieee80211_hdr *hdr)
278
279
280
281
{
	u32 curr_time = jiffies_to_msecs(jiffies);
	u32 time_diff;
	s32 index;
282
	struct iwl_traffic_load *tl = NULL;
283
	__le16 fc = hdr->frame_control;
284
	u8 tid;
285

286
287
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
288
289
		tid = qc[0] & 0xf;
	} else
290
		return MAX_TID_COUNT;
291
292
293
294
295
296
297
298
299
300
301
302

	tl = &lq_data->load[tid];

	curr_time -= curr_time % TID_ROUND_VALUE;

	/* Happens only for the first packet. Initialize the data */
	if (!(tl->queue_count)) {
		tl->total = 1;
		tl->time_stamp = curr_time;
		tl->queue_count = 1;
		tl->head = 0;
		tl->packet_count[0] = 1;
303
		return MAX_TID_COUNT;
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
	}

	time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
	index = time_diff / TID_QUEUE_CELL_SPACING;

	/* The history is too long: remove data that is older than */
	/* TID_MAX_TIME_DIFF */
	if (index >= TID_QUEUE_MAX_SIZE)
		rs_tl_rm_old_stats(tl, curr_time);

	index = (tl->head + index) % TID_QUEUE_MAX_SIZE;
	tl->packet_count[index] = tl->packet_count[index] + 1;
	tl->total = tl->total + 1;

	if ((index + 1) > tl->queue_count)
		tl->queue_count = index + 1;
320
321

	return tid;
322
323
324
325
326
}

/*
	get the traffic load value for tid
*/
327
static u32 rs_tl_get_load(struct iwl_lq_sta *lq_data, u8 tid)
328
329
330
331
{
	u32 curr_time = jiffies_to_msecs(jiffies);
	u32 time_diff;
	s32 index;
332
	struct iwl_traffic_load *tl = NULL;
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354

	if (tid >= TID_MAX_LOAD_COUNT)
		return 0;

	tl = &(lq_data->load[tid]);

	curr_time -= curr_time % TID_ROUND_VALUE;

	if (!(tl->queue_count))
		return 0;

	time_diff = TIME_WRAP_AROUND(tl->time_stamp, curr_time);
	index = time_diff / TID_QUEUE_CELL_SPACING;

	/* The history is too long: remove data that is older than */
	/* TID_MAX_TIME_DIFF */
	if (index >= TID_QUEUE_MAX_SIZE)
		rs_tl_rm_old_stats(tl, curr_time);

	return tl->total;
}

355
static void rs_tl_turn_on_agg_for_tid(struct iwl_priv *priv,
356
357
				      struct iwl_lq_sta *lq_data, u8 tid,
				      struct sta_info *sta)
358
359
360
361
{
	unsigned long state;
	DECLARE_MAC_BUF(mac);

362
	spin_lock_bh(&sta->lock);
363
	state = sta->ampdu_mlme.tid_state_tx[tid];
364
	spin_unlock_bh(&sta->lock);
365
366
367
368
369
370
371
372
373

	if (state == HT_AGG_STATE_IDLE &&
	    rs_tl_get_load(lq_data, tid) > IWL_AGG_LOAD_THRESHOLD) {
		IWL_DEBUG_HT("Starting Tx agg: STA: %s tid: %d\n",
				print_mac(mac, sta->addr), tid);
		ieee80211_start_tx_ba_session(priv->hw, sta->addr, tid);
	}
}

374
static void rs_tl_turn_on_agg(struct iwl_priv *priv, u8 tid,
375
376
			      struct iwl_lq_sta *lq_data,
			      struct sta_info *sta)
377
378
379
380
381
382
383
384
{
	if ((tid < TID_MAX_LOAD_COUNT))
		rs_tl_turn_on_agg_for_tid(priv, lq_data, tid, sta);
	else if (tid == IWL_AGG_ALL_TID)
		for (tid = 0; tid < TID_MAX_LOAD_COUNT; tid++)
			rs_tl_turn_on_agg_for_tid(priv, lq_data, tid, sta);
}

Guy Cohen's avatar
Guy Cohen committed
385
static inline int get_num_of_ant_from_rate(u32 rate_n_flags)
386
{
Guy Cohen's avatar
Guy Cohen committed
387
388
389
	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));
390
391
}

392
393
394
395
396
397
398
/**
 * 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.
 */
399
static int rs_collect_tx_data(struct iwl_rate_scale_data *windows,
400
401
			      int scale_index, s32 tpt, int retries,
			      int successes)
402
{
403
	struct iwl_rate_scale_data *window = NULL;
Guy Cohen's avatar
Guy Cohen committed
404
	static const u64 mask = (((u64)1) << (IWL_RATE_MAX_WINDOW - 1));
405
406
	s32 fail_count;

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

410
	/* Select data for current tx bit rate */
411
412
	window = &(windows[scale_index]);

413
414
415
416
417
418
419
420
	/*
	 * 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!).
	 */
421
	while (retries > 0) {
Guy Cohen's avatar
Guy Cohen committed
422
423
424
425
426
		if (window->counter >= IWL_RATE_MAX_WINDOW) {

			/* remove earliest */
			window->counter = IWL_RATE_MAX_WINDOW - 1;

427
428
			if (window->data & mask) {
				window->data &= ~mask;
Guy Cohen's avatar
Guy Cohen committed
429
				window->success_counter--;
430
			}
431
432
		}

433
434
435
436
437
438
		/* Increment frames-attempted counter */
		window->counter++;

		/* Shift bitmap by one frame (throw away oldest history),
		 * OR in "1", and increment "success" if this
		 * frame was successful. */
Guy Cohen's avatar
Guy Cohen committed
439
		window->data <<= 1;;
440
		if (successes > 0) {
Guy Cohen's avatar
Guy Cohen committed
441
			window->success_counter++;
442
443
444
			window->data |= 0x1;
			successes--;
		}
445

446
		retries--;
447
448
	}

449
	/* Calculate current success ratio, avoid divide-by-0! */
450
451
452
453
454
455
456
457
	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;

458
	/* Calculate average throughput, if we have enough history. */
459
460
461
462
463
464
	if ((fail_count >= IWL_RATE_MIN_FAILURE_TH) ||
	    (window->success_counter >= IWL_RATE_MIN_SUCCESS_TH))
		window->average_tpt = (window->success_ratio * tpt + 64) / 128;
	else
		window->average_tpt = IWL_INVALID_VALUE;

465
	/* Tag this window as having been updated */
466
467
	window->stamp = jiffies;

468
	return 0;
469
470
}

471
472
473
/*
 * Fill uCode API rate_n_flags field, based on "search" or "active" table.
 */
Guy Cohen's avatar
Guy Cohen committed
474
/* FIXME:RS:remove this function and put the flags statically in the table */
475
static u32 rate_n_flags_from_tbl(struct iwl_scale_tbl_info *tbl,
Guy Cohen's avatar
Guy Cohen committed
476
				       int index, u8 use_green)
477
{
Guy Cohen's avatar
Guy Cohen committed
478
479
	u32 rate_n_flags = 0;

480
	if (is_legacy(tbl->lq_type)) {
481
		rate_n_flags = iwl_rates[index].plcp;
482
		if (index >= IWL_FIRST_CCK_RATE && index <= IWL_LAST_CCK_RATE)
Guy Cohen's avatar
Guy Cohen committed
483
			rate_n_flags |= RATE_MCS_CCK_MSK;
484

485
486
487
	} else if (is_Ht(tbl->lq_type)) {
		if (index > IWL_LAST_OFDM_RATE) {
			IWL_ERROR("invalid HT rate index %d\n", index);
488
			index = IWL_LAST_OFDM_RATE;
489
		}
Guy Cohen's avatar
Guy Cohen committed
490
		rate_n_flags = RATE_MCS_HT_MSK;
491
492

		if (is_siso(tbl->lq_type))
493
			rate_n_flags |=	iwl_rates[index].plcp_siso;
494
		else if (is_mimo2(tbl->lq_type))
495
			rate_n_flags |=	iwl_rates[index].plcp_mimo2;
496
		else
497
			rate_n_flags |=	iwl_rates[index].plcp_mimo3;
498
	} else {
499
		IWL_ERROR("Invalid tbl->lq_type %d\n", tbl->lq_type);
500
501
	}

Guy Cohen's avatar
Guy Cohen committed
502
	rate_n_flags |= ((tbl->ant_type << RATE_MCS_ANT_POS) &
503
						     RATE_MCS_ANT_ABC_MSK);
504

Guy Cohen's avatar
Guy Cohen committed
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
	if (is_Ht(tbl->lq_type)) {
		if (tbl->is_fat) {
			if (tbl->is_dup)
				rate_n_flags |= RATE_MCS_DUP_MSK;
			else
				rate_n_flags |= RATE_MCS_FAT_MSK;
		}
		if (tbl->is_SGI)
			rate_n_flags |= RATE_MCS_SGI_MSK;

		if (use_green) {
			rate_n_flags |= RATE_MCS_GF_MSK;
			if (is_siso(tbl->lq_type) && tbl->is_SGI) {
				rate_n_flags &= ~RATE_MCS_SGI_MSK;
				IWL_ERROR("GF was set with SGI:SISO\n");
			}
		}
522
	}
Guy Cohen's avatar
Guy Cohen committed
523
	return rate_n_flags;
524
525
}

526
527
528
529
/*
 * Interpret uCode API's rate_n_flags format,
 * fill "search" or "active" tx mode table.
 */
Guy Cohen's avatar
Guy Cohen committed
530
static int rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
531
				    enum ieee80211_band band,
532
				    struct iwl_scale_tbl_info *tbl,
533
534
				    int *rate_idx)
{
Guy Cohen's avatar
Guy Cohen committed
535
536
537
	u32 ant_msk = (rate_n_flags & RATE_MCS_ANT_ABC_MSK);
	u8 num_of_ant = get_num_of_ant_from_rate(rate_n_flags);
	u8 mcs;
538

539
	*rate_idx = iwl_hwrate_to_plcp_idx(rate_n_flags);
540

541
	if (*rate_idx  == IWL_RATE_INVALID) {
542
		*rate_idx = -1;
543
		return -EINVAL;
544
	}
545
	tbl->is_SGI = 0;	/* default legacy setup */
546
547
	tbl->is_fat = 0;
	tbl->is_dup = 0;
548
549
	tbl->ant_type = (ant_msk >> RATE_MCS_ANT_POS);
	tbl->lq_type = LQ_NONE;
550

551
	/* legacy rate format */
Guy Cohen's avatar
Guy Cohen committed
552
	if (!(rate_n_flags & RATE_MCS_HT_MSK)) {
553
		if (num_of_ant == 1) {
554
			if (band == IEEE80211_BAND_5GHZ)
555
556
557
558
				tbl->lq_type = LQ_A;
			else
				tbl->lq_type = LQ_G;
		}
559
	/* HT rate format */
560
	} else {
Guy Cohen's avatar
Guy Cohen committed
561
		if (rate_n_flags & RATE_MCS_SGI_MSK)
562
563
			tbl->is_SGI = 1;

Guy Cohen's avatar
Guy Cohen committed
564
565
		if ((rate_n_flags & RATE_MCS_FAT_MSK) ||
		    (rate_n_flags & RATE_MCS_DUP_MSK))
566
567
			tbl->is_fat = 1;

Guy Cohen's avatar
Guy Cohen committed
568
		if (rate_n_flags & RATE_MCS_DUP_MSK)
569
			tbl->is_dup = 1;
570

Guy Cohen's avatar
Guy Cohen committed
571
		mcs = rs_extract_rate(rate_n_flags);
572

Guy Cohen's avatar
Guy Cohen committed
573
574
		/* SISO */
		if (mcs <= IWL_RATE_SISO_60M_PLCP) {
575
576
577
			if (num_of_ant == 1)
				tbl->lq_type = LQ_SISO; /*else NONE*/
		/* MIMO2 */
Guy Cohen's avatar
Guy Cohen committed
578
		} else if (mcs <= IWL_RATE_MIMO2_60M_PLCP) {
579
580
581
582
583
584
585
			if (num_of_ant == 2)
				tbl->lq_type = LQ_MIMO2;
		/* MIMO3 */
		} else {
			if (num_of_ant == 3)
				tbl->lq_type = LQ_MIMO3;
		}
586
587
588
	}
	return 0;
}
589
590
591
592

/* switch to another antenna/antennas and return 1 */
/* if no other valid antenna found, return 0 */
static int rs_toggle_antenna(u32 valid_ant, u32 *rate_n_flags,
593
			     struct iwl_scale_tbl_info *tbl)
594
{
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
	u8 new_ant_type;

	if (!tbl->ant_type || tbl->ant_type > ANT_ABC)
		return 0;

	if (!rs_is_valid_ant(valid_ant, tbl->ant_type))
		return 0;

	new_ant_type = ant_toggle_lookup[tbl->ant_type];

	while ((new_ant_type != tbl->ant_type) &&
	       !rs_is_valid_ant(valid_ant, new_ant_type))
		new_ant_type = ant_toggle_lookup[new_ant_type];

	if (new_ant_type == tbl->ant_type)
		return 0;

	tbl->ant_type = new_ant_type;
	*rate_n_flags &= ~RATE_MCS_ANT_ABC_MSK;
	*rate_n_flags |= new_ant_type << RATE_MCS_ANT_POS;
	return 1;
616
617
}

Guy Cohen's avatar
Guy Cohen committed
618
/* FIXME:RS: in 4965 we don't use greenfield at all */
Guy Cohen's avatar
Guy Cohen committed
619
620
621
/* FIXME:RS: don't use greenfield for now in TX */
#if 0
static inline u8 rs_use_green(struct iwl_priv *priv, struct ieee80211_conf *conf)
622
{
623
624
625
	return ((conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) &&
		priv->current_ht_config.is_green_field &&
		!priv->current_ht_config.non_GF_STA_present);
Guy Cohen's avatar
Guy Cohen committed
626
}
627
#endif
Guy Cohen's avatar
Guy Cohen committed
628
629
static inline u8 rs_use_green(struct iwl_priv *priv, struct ieee80211_conf *conf)
{
630
	return 0;
631
632
633
634
635
636
637
638
639
}

/**
 * rs_get_supported_rates - get the available rates
 *
 * if management frame or broadcast frame only return
 * basic available rates.
 *
 */
640
641
642
static u16 rs_get_supported_rates(struct iwl_lq_sta *lq_sta,
				  struct ieee80211_hdr *hdr,
				  enum iwl_table_type rate_type)
643
{
644
645
646
647
648
649
650
	if (hdr && is_multicast_ether_addr(hdr->addr1) &&
	    lq_sta->active_rate_basic)
		return lq_sta->active_rate_basic;

	if (is_legacy(rate_type)) {
		return lq_sta->active_legacy_rate;
	} else {
651
		if (is_siso(rate_type))
652
			return lq_sta->active_siso_rate;
653
		else if (is_mimo2(rate_type))
654
			return lq_sta->active_mimo2_rate;
655
		else
656
			return lq_sta->active_mimo3_rate;
657
	}
658
659
}

660
661
static u16 rs_get_adjacent_rate(struct iwl_priv *priv, u8 index, u16 rate_mask,
				int rate_type)
662
663
664
665
{
	u8 high = IWL_RATE_INVALID;
	u8 low = IWL_RATE_INVALID;

666
	/* 802.11A or ht walks to the next literal adjacent rate in
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
692
693
694
	 * the rate table */
	if (is_a_band(rate_type) || !is_legacy(rate_type)) {
		int i;
		u32 mask;

		/* Find the previous rate that is in the rate mask */
		i = index - 1;
		for (mask = (1 << i); i >= 0; i--, mask >>= 1) {
			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) {
695
		low = iwl_rates[low].prev_rs;
696
697
698
699
700
701
702
703
704
		if (low == IWL_RATE_INVALID)
			break;
		if (rate_mask & (1 << low))
			break;
		IWL_DEBUG_RATE("Skipping masked lower rate: %d\n", low);
	}

	high = index;
	while (high != IWL_RATE_INVALID) {
705
		high = iwl_rates[high].next_rs;
706
707
708
709
710
711
712
713
714
715
		if (high == IWL_RATE_INVALID)
			break;
		if (rate_mask & (1 << high))
			break;
		IWL_DEBUG_RATE("Skipping masked higher rate: %d\n", high);
	}

	return (high << 8) | low;
}

716
717
718
static u32 rs_get_lower_rate(struct iwl_lq_sta *lq_sta,
			     struct iwl_scale_tbl_info *tbl,
			     u8 scale_index, u8 ht_possible)
719
720
721
722
723
{
	s32 low;
	u16 rate_mask;
	u16 high_low;
	u8 switch_to_legacy = 0;
724
	u8 is_green = lq_sta->is_green;
725
726
727
728
729
730
731

	/* check if we need to switch from HT to legacy rates.
	 * assumption is that mandatory rates (1Mbps or 6Mbps)
	 * are always supported (spec demand) */
	if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_index)) {
		switch_to_legacy = 1;
		scale_index = rs_ht_to_legacy[scale_index];
732
		if (lq_sta->band == IEEE80211_BAND_5GHZ)
733
734
735
736
			tbl->lq_type = LQ_A;
		else
			tbl->lq_type = LQ_G;

737
		if (num_of_ant(tbl->ant_type) > 1)
738
			tbl->ant_type = ANT_A;/*FIXME:RS*/
739
740
741
742
743

		tbl->is_fat = 0;
		tbl->is_SGI = 0;
	}

744
	rate_mask = rs_get_supported_rates(lq_sta, NULL, tbl->lq_type);
745

746
	/* Mask with station rate restriction */
747
	if (is_legacy(tbl->lq_type)) {
748
		/* supp_rates has no CCK bits in A mode */
749
		if (lq_sta->band == IEEE80211_BAND_5GHZ)
750
			rate_mask  = (u16)(rate_mask &
751
			   (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
752
		else
753
			rate_mask = (u16)(rate_mask & lq_sta->supp_rates);
754
755
	}

756
	/* If we switched from HT to legacy, check current rate */
757
	if (switch_to_legacy && (rate_mask & (1 << scale_index))) {
Guy Cohen's avatar
Guy Cohen committed
758
759
		low = scale_index;
		goto out;
760
761
	}

762
763
	high_low = rs_get_adjacent_rate(lq_sta->drv, scale_index, rate_mask,
					tbl->lq_type);
764
765
	low = high_low & 0xff;

Guy Cohen's avatar
Guy Cohen committed
766
767
768
769
770
	if (low == IWL_RATE_INVALID)
		low = scale_index;

out:
	return rate_n_flags_from_tbl(tbl, low, is_green);
771
772
}

773
774
775
/*
 * mac80211 sends us Tx status
 */
776
static void rs_tx_status(void *priv_rate, struct net_device *dev,
777
			 struct sk_buff *skb)
778
779
780
781
{
	int status;
	u8 retries;
	int rs_index, index = 0;
782
	struct iwl_lq_sta *lq_sta;
783
	struct iwl_link_quality_cmd *table;
784
785
	struct sta_info *sta;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
786
	struct iwl_priv *priv = (struct iwl_priv *)priv_rate;
787
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
788
	struct ieee80211_hw *hw = local_to_hw(local);
789
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
790
791
	struct iwl_rate_scale_data *window = NULL;
	struct iwl_rate_scale_data *search_win = NULL;
Guy Cohen's avatar
Guy Cohen committed
792
	u32 tx_rate;
793
794
	struct iwl_scale_tbl_info tbl_type;
	struct iwl_scale_tbl_info *curr_tbl, *search_tbl;
795
	u8 active_index = 0;
796
	__le16 fc = hdr->frame_control;
797
798
	s32 tpt = 0;

799
	IWL_DEBUG_RATE_LIMIT("get frame ack response, update rate scale window\n");
800
801
802
803

	if (!ieee80211_is_data(fc) || is_multicast_ether_addr(hdr->addr1))
		return;

804
	/* This packet was aggregated but doesn't carry rate scale info */
805
806
	if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
	    !(info->flags & IEEE80211_TX_STAT_AMPDU))
807
808
		return;

809
	retries = info->status.retry_count;
810
811
812
813

	if (retries > 15)
		retries = 15;

814
	rcu_read_lock();
815
816
817

	sta = sta_info_get(local, hdr->addr1);

818
819
820
	if (!sta || !sta->rate_ctrl_priv)
		goto out;

821

822
	lq_sta = (struct iwl_lq_sta *)sta->rate_ctrl_priv;
823

824
825
	if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
	    !lq_sta->ibss_sta_added)
826
		goto out;
827

828
829
	table = &lq_sta->lq;
	active_index = lq_sta->active_tbl;
830

831
832
	curr_tbl = &(lq_sta->lq_info[active_index]);
	search_tbl = &(lq_sta->lq_info[(1 - active_index)]);
833
834
	window = (struct iwl_rate_scale_data *)&(curr_tbl->win[0]);
	search_win = (struct iwl_rate_scale_data *)&(search_tbl->win[0]);
835

836
837
838
839
840
841
842
843
	/*
	 * 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).
	 */
Guy Cohen's avatar
Guy Cohen committed
844
845
	tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
	rs_get_tbl_info_from_mcs(tx_rate, priv->band, &tbl_type, &rs_index);
846
847
848
	if (priv->band == IEEE80211_BAND_5GHZ)
		rs_index -= IWL_FIRST_OFDM_RATE;

849
	if ((info->tx_rate_idx < 0) ||
850
	    (tbl_type.is_SGI ^
851
		!!(info->flags & IEEE80211_TX_CTL_SHORT_GI)) ||
852
	    (tbl_type.is_fat ^
853
		!!(info->flags & IEEE80211_TX_CTL_40_MHZ_WIDTH)) ||
854
	    (tbl_type.is_dup ^
855
856
		!!(info->flags & IEEE80211_TX_CTL_DUP_DATA)) ||
	    (tbl_type.ant_type ^ info->antenna_sel_tx) ||
Guy Cohen's avatar
Guy Cohen committed
857
	    (!!(tx_rate & RATE_MCS_HT_MSK) ^
858
		!!(info->flags & IEEE80211_TX_CTL_OFDM_HT)) ||
Guy Cohen's avatar
Guy Cohen committed
859
	    (!!(tx_rate & RATE_MCS_GF_MSK) ^
860
		!!(info->flags & IEEE80211_TX_CTL_GREEN_FIELD)) ||
861
	    (hw->wiphy->bands[priv->band]->bitrates[rs_index].bitrate !=
862
	     hw->wiphy->bands[info->band]->bitrates[info->tx_rate_idx].bitrate)) {
Guy Cohen's avatar
Guy Cohen committed
863
		IWL_DEBUG_RATE("initial rate does not match 0x%x\n", tx_rate);
864
		goto out;
865
866
	}

867
	/* Update frame history window with "failure" for each Tx retry. */
868
	while (retries) {
869
870
		/* Look up the rate and other info used for each tx attempt.
		 * Each tx attempt steps one entry deeper in the rate table. */
Guy Cohen's avatar
Guy Cohen committed
871
872
		tx_rate = le32_to_cpu(table->rs_table[index].rate_n_flags);
		rs_get_tbl_info_from_mcs(tx_rate, priv->band,
873
874
					  &tbl_type, &rs_index);

875
876
		/* If type matches "search" table,
		 * add failure to "search" history */
877
		if ((tbl_type.lq_type == search_tbl->lq_type) &&
878
		    (tbl_type.ant_type == search_tbl->ant_type) &&
879
880
881
882
883
		    (tbl_type.is_SGI == search_tbl->is_SGI)) {
			if (search_tbl->expected_tpt)
				tpt = search_tbl->expected_tpt[rs_index];
			else
				tpt = 0;
884
			rs_collect_tx_data(search_win, rs_index, tpt, 1, 0);
885
886
887

		/* Else if type matches "current/active" table,
		 * add failure to "current/active" history */
888
		} else if ((tbl_type.lq_type == curr_tbl->lq_type) &&
889
			   (tbl_type.ant_type == curr_tbl->ant_type) &&
890
891
892
893
894
			   (tbl_type.is_SGI == curr_tbl->is_SGI)) {
			if (curr_tbl->expected_tpt)
				tpt = curr_tbl->expected_tpt[rs_index];
			else
				tpt = 0;
895
			rs_collect_tx_data(window, rs_index, tpt, 1, 0);
896
		}
897
898
899

		/* If not searching for a new mode, increment failed counter
		 * ... this helps determine when to start searching again */
900
901
		if (lq_sta->stay_in_tbl)
			lq_sta->total_failed++;
902
903
904
905
906
		--retries;
		index++;

	}

907
908
909
910
911
	/*
	 * Find (by rate) the history window to update with final Tx attempt;
	 * if Tx was successful first try, use original rate,
	 * else look up the rate that was, finally, successful.
	 */
Guy Cohen's avatar
Guy Cohen committed
912
913
	tx_rate = le32_to_cpu(table->rs_table[index].rate_n_flags);
	rs_get_tbl_info_from_mcs(tx_rate, priv->band, &tbl_type, &rs_index);
914

915
	/* Update frame history window with "success" if Tx got ACKed ... */
916
	status = !!(info->flags & IEEE80211_TX_STAT_ACK);
917

918
919
	/* If type matches "search" table,
	 * add final tx status to "search" history */
920
	if ((tbl_type.lq_type == search_tbl->lq_type) &&
921
	    (tbl_type.ant_type == search_tbl->ant_type) &&
922
923
924
925
926
	    (tbl_type.is_SGI == search_tbl->is_SGI)) {
		if (search_tbl->expected_tpt)
			tpt = search_tbl->expected_tpt[rs_index];
		else
			tpt = 0;
927
		if (info->flags & IEEE80211_TX_CTL_AMPDU)
928
			rs_collect_tx_data(search_win, rs_index, tpt,
929
930
					   info->status.ampdu_ack_len,
					   info->status.ampdu_ack_map);
931
932
933
		else
			rs_collect_tx_data(search_win, rs_index, tpt,
					   1, status);
934
935
	/* Else if type matches "current/active" table,
	 * add final tx status to "current/active" history */
936
	} else if ((tbl_type.lq_type == curr_tbl->lq_type) &&
937
		   (tbl_type.ant_type == curr_tbl->ant_type) &&
938
939
940
941
942
		   (tbl_type.is_SGI == curr_tbl->is_SGI)) {
		if (curr_tbl->expected_tpt)
			tpt = curr_tbl->expected_tpt[rs_index];
		else
			tpt = 0;
943
		if (info->flags & IEEE80211_TX_CTL_AMPDU)
944
			rs_collect_tx_data(window, rs_index, tpt,
945
946
					   info->status.ampdu_ack_len,
					   info->status.ampdu_ack_map);
947
948
949
		else
			rs_collect_tx_data(window, rs_index, tpt,
					   1, status);
950
951
	}

952
953
	/* If not searching for new mode, increment success/failed counter
	 * ... these help determine when to start searching again */
954
	if (lq_sta->stay_in_tbl) {
955
956
		if (info->flags & IEEE80211_TX_CTL_AMPDU) {
			lq_sta->total_success += info->status.ampdu_ack_map;
957
			lq_sta->total_failed +=
958
			     (info->status.ampdu_ack_len - info->status.ampdu_ack_map);
959
960
961
962
963
964
		} else {
			if (status)
				lq_sta->total_success++;
			else
				lq_sta->total_failed++;
		}
965
966
	}

967
	/* See if there's a better rate or modulation mode to try. */
968
	rs_rate_scale_perform(priv, dev, hdr, sta);
969
out:
970
	rcu_read_unlock();
971
972
973
	return;
}

974
975
976
977
978
979
980
981
/*
 * 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.
 */
982
static void rs_set_stay_in_table(struct iwl_priv *priv, u8 is_legacy,
983
				 struct iwl_lq_sta *lq_sta)
984
{
985
	IWL_DEBUG_RATE("we are staying in the same table\n");
986
	lq_sta->stay_in_tbl = 1;	/* only place this gets set */
987
	if (is_legacy) {
988
989
990
		lq_sta->table_count_limit = IWL_LEGACY_TABLE_COUNT;
		lq_sta->max_failure_limit = IWL_LEGACY_FAILURE_LIMIT;
		lq_sta->max_success_limit = IWL_LEGACY_SUCCESS_LIMIT;
991
	} else {
992
993
994
		lq_sta->table_count_limit = IWL_NONE_LEGACY_TABLE_COUNT;
		lq_sta->max_failure_limit = IWL_NONE_LEGACY_FAILURE_LIMIT;
		lq_sta->max_success_limit = IWL_NONE_LEGACY_SUCCESS_LIMIT;
995
	}
996
997
998
	lq_sta->table_count = 0;
	lq_sta->total_failed = 0;
	lq_sta->total_success = 0;
999
1000
}

1001
1002
1003
/*
 * Find correct throughput table for given mode of modulation
 */
1004
1005
static void rs_set_expected_tpt_table(struct iwl_lq_sta *lq_sta,
				      struct iwl_scale_tbl_info *tbl)
1006
1007
1008
1009
1010
1011
1012
{
	if (is_legacy(tbl->lq_type)) {
		if (!is_a_band(tbl->lq_type))
			tbl->expected_tpt = expected_tpt_G;
		else
			tbl->expected_tpt = expected_tpt_A;
	} else if (is_siso(tbl->lq_type)) {
1013
		if (tbl->is_fat && !lq_sta->is_dup)
1014
1015
1016
1017
1018
1019
1020
1021
1022
			if (tbl->is_SGI)
				tbl->expected_tpt = expected_tpt_siso40MHzSGI;
			else
				tbl->expected_tpt = expected_tpt_siso40MHz;
		else if (tbl->is_SGI)
			tbl->expected_tpt = expected_tpt_siso20MHzSGI;
		else
			tbl->expected_tpt = expected_tpt_siso20MHz;

1023
	} else if (is_mimo(tbl->lq_type)) { /* FIXME:need to separate mimo2/3 */
1024
		if (tbl->is_fat && !lq_sta->is_dup)
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
			if (tbl->is_SGI)
				tbl->expected_tpt = expected_tpt_mimo40MHzSGI;
			else
				tbl->expected_tpt = expected_tpt_mimo40MHz;
		else if (tbl->is_SGI)
			tbl->expected_tpt = expected_tpt_mimo20MHzSGI;
		else
			tbl->expected_tpt = expected_tpt_mimo20MHz;
	} else
		tbl->expected_tpt = expected_tpt_G;
}

1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
/*
 * Find starting rate for new "search" high-throughput mode of modulation.
 * Goal is to find lowest expected rate (under perfect conditions) that is
 * above the current measured throughput of "active" mode, to give new mode
 * a fair chance to prove itself without too many challenges.
 *
 * This gets called when transitioning to more aggressive modulation
 * (i.e. legacy to SISO or MIMO, or SISO to MIMO), as well as less aggressive
 * (i.e. MIMO to SISO).  When moving to MIMO, bit rate will typically need
 * to decrease to match "active" throughput.  When moving from MIMO to SISO,
 * bit rate will typically need to increase, but not if performance was bad.
 */
1049
static s32 rs_get_best_rate(struct iwl_priv *priv,
1050
1051
			    struct iwl_lq_sta *lq_sta,
			    struct iwl_scale_tbl_info *tbl,	/* "search" */
Guy Cohen's avatar
Guy Cohen committed
1052
			    u16 rate_mask, s8 index)
1053
{
1054
	/* "active" values */
1055
	struct iwl_scale_tbl_info *active_tbl =
1056
	    &(lq_sta->lq_info[lq_sta->active_tbl]);
1057
1058
	s32 active_sr = active_tbl->win[index].success_ratio;
	s32 active_tpt = active_tbl->expected_tpt[index];
1059
1060
1061
1062
1063

	/* expected "search" throughput */
	s32 *tpt_tbl = tbl->expected_tpt;

	s32 new_rate, high, low, start_hi;
1064
	u16 high_low;
Guy Cohen's avatar
Guy Cohen committed
1065
	s8 rate = index;
1066
1067
1068
1069

	new_rate = high = low = start_hi = IWL_RATE_INVALID;

	for (; ;) {
1070
1071
		high_low = rs_get_adjacent_rate(priv, rate, rate_mask,
						tbl->lq_type);
1072
1073
1074
1075

		low = high_low & 0xff;
		high = (high_low >> 8) & 0xff;

1076
1077
1078