iwl-4965-rs.c 76.6 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-core.h"
42
43
44
45
#include "iwl-helpers.h"

#define RS_NAME "iwl-4965-rs"

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

50
51
52
53
54
55
#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)
56
57
58
59
60
61
62
63
64
65
66

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
};

67
68
69
70
71
72
73
74
75
76
77
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,
};

78
79
80
/**
 * struct iwl4965_rate_scale_data -- tx success history for one rate
 */
Christoph Hellwig's avatar
Christoph Hellwig committed
81
struct iwl4965_rate_scale_data {
82
83
84
85
86
	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 */
87
88
89
	unsigned long stamp;
};

90
91
92
/**
 * struct iwl4965_scale_tbl_info -- tx params and success history for all rates
 *
93
 * There are two of these in struct iwl4965_lq_sta,
94
95
 * one for "active", and one for "search".
 */
Christoph Hellwig's avatar
Christoph Hellwig committed
96
struct iwl4965_scale_tbl_info {
97
98
	enum iwl_table_type lq_type;
	u8 ant_type;
99
100
101
102
103
	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
104
	u32 current_rate;  /* rate_n_flags, uCode API format */
105
	struct iwl4965_rate_scale_data win[IWL_RATE_COUNT]; /* rate histories */
106
107
};

108
109
110
111
112
113
114
115
116
117
118
struct iwl4965_traffic_load {
	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 */
};

119
/**
120
 * struct iwl4965_lq_sta -- driver's rate scaling private structure
121
122
123
 *
 * Pointer to this gets passed back and forth between driver and mac80211.
 */
124
struct iwl4965_lq_sta {
125
126
127
128
	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 */
129
	s32 last_tpt;
130
131

	/* The following determine when to search for a new mode */
132
	u32 table_count_limit;
133
134
	u32 max_failure_limit;	/* # failed frames before new search */
	u32 max_success_limit;	/* # successful frames before new search */
135
	u32 table_count;
136
137
138
139
140
	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 */
141
142
	u8 is_green;
	u8 is_dup;
143
	enum ieee80211_band band;
144
	u8 ibss_sta_added;
145
146

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

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

167
static void rs_rate_scale_perform(struct iwl_priv *priv,
168
169
170
				   struct net_device *dev,
				   struct ieee80211_hdr *hdr,
				   struct sta_info *sta);
171
172
static void rs_fill_link_cmd(const struct iwl_priv *priv,
			     struct iwl4965_lq_sta *lq_sta,
Guy Cohen's avatar
Guy Cohen committed
173
			     u32 rate_n_flags);
174
175


176
#ifdef CONFIG_MAC80211_DEBUGFS
177
static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
Guy Cohen's avatar
Guy Cohen committed
178
					u32 *rate_n_flags, int index);
179
#else
180
static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
Guy Cohen's avatar
Guy Cohen committed
181
					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);
}

Christoph Hellwig's avatar
Christoph Hellwig committed
236
static void rs_rate_scale_clear_window(struct iwl4965_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
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
/*
 *	removes the old data from the statistics. All data that is older than
 *	TID_MAX_TIME_DIFF, will be deleted.
 */
static void rs_tl_rm_old_stats(struct iwl4965_traffic_load *tl, u32 curr_time)
{
	/* 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
277
static void rs_tl_add_packet(struct iwl4965_lq_sta *lq_data,
			     struct ieee80211_hdr *hdr)
278
279
280
281
282
{
	u32 curr_time = jiffies_to_msecs(jiffies);
	u32 time_diff;
	s32 index;
	struct iwl4965_traffic_load *tl = NULL;
283
284
	u16 fc = le16_to_cpu(hdr->frame_control);
	u8 tid;
285

286
287
288
289
	if (ieee80211_is_qos_data(fc)) {
		u8 *qc = ieee80211_get_qos_ctrl(hdr, ieee80211_get_hdrlen(fc));
		tid = qc[0] & 0xf;
	} else
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
		return;

	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;
		return;
	}

	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;
}

/*
	get the traffic load value for tid
*/
static u32 rs_tl_get_load(struct iwl4965_lq_sta *lq_data, u8 tid)
{
	u32 curr_time = jiffies_to_msecs(jiffies);
	u32 time_diff;
	s32 index;
	struct iwl4965_traffic_load *tl = NULL;

	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;
}

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

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

	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);
	}
}

372
static void rs_tl_turn_on_agg(struct iwl_priv *priv, u8 tid,
373
374
375
376
377
378
379
380
381
382
				struct iwl4965_lq_sta *lq_data,
				struct sta_info *sta)
{
	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
383
static inline int get_num_of_ant_from_rate(u32 rate_n_flags)
384
{
Guy Cohen's avatar
Guy Cohen committed
385
386
387
	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));
388
389
}

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

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

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

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

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

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

431
432
433
434
435
436
		/* 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
437
		window->data <<= 1;;
438
		if (successes > 0) {
Guy Cohen's avatar
Guy Cohen committed
439
			window->success_counter++;
440
441
442
			window->data |= 0x1;
			successes--;
		}
443

444
		retries--;
445
446
	}

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

456
	/* Calculate average throughput, if we have enough history. */
457
458
459
460
461
462
	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;

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

466
	return 0;
467
468
}

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

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

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

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

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

Guy Cohen's avatar
Guy Cohen committed
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
	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");
			}
		}
520
	}
Guy Cohen's avatar
Guy Cohen committed
521
	return rate_n_flags;
522
523
}

524
525
526
527
/*
 * Interpret uCode API's rate_n_flags format,
 * fill "search" or "active" tx mode table.
 */
Guy Cohen's avatar
Guy Cohen committed
528
static int rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
529
530
				    enum ieee80211_band band,
				    struct iwl4965_scale_tbl_info *tbl,
531
532
				    int *rate_idx)
{
Guy Cohen's avatar
Guy Cohen committed
533
534
535
	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;
536

Guy Cohen's avatar
Guy Cohen committed
537
	*rate_idx = iwl4965_hwrate_to_plcp_idx(rate_n_flags);
538

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

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

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

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

Guy Cohen's avatar
Guy Cohen committed
569
		mcs = rs_extract_rate(rate_n_flags);
570

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

/* 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,
			      struct iwl4965_scale_tbl_info *tbl)
592
{
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
	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;
614
615
}

Guy Cohen's avatar
Guy Cohen committed
616
/* FIXME:RS: in 4965 we don't use greenfield at all */
Guy Cohen's avatar
Guy Cohen committed
617
618
619
/* 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)
620
{
621
622
623
	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
624
}
625
#endif
Guy Cohen's avatar
Guy Cohen committed
626
627
static inline u8 rs_use_green(struct iwl_priv *priv, struct ieee80211_conf *conf)
{
628
	return 0;
629
630
631
632
633
634
635
636
637
}

/**
 * rs_get_supported_rates - get the available rates
 *
 * if management frame or broadcast frame only return
 * basic available rates.
 *
 */
638
static u16 rs_get_supported_rates(struct iwl4965_lq_sta *lq_sta,
639
				   struct ieee80211_hdr *hdr,
640
				   enum iwl_table_type rate_type)
641
{
642
643
644
645
646
647
648
	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 {
649
		if (is_siso(rate_type))
650
			return lq_sta->active_siso_rate;
651
		else if (is_mimo2(rate_type))
652
			return lq_sta->active_mimo2_rate;
653
		else
654
			return lq_sta->active_mimo3_rate;
655
	}
656
657
}

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

664
	/* 802.11A or ht walks to the next literal adjacent rate in
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
692
	 * 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) {
693
		low = iwl_rates[low].prev_rs;
694
695
696
697
698
699
700
701
702
		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) {
703
		high = iwl_rates[high].next_rs;
704
705
706
707
708
709
710
711
712
713
		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;
}

Guy Cohen's avatar
Guy Cohen committed
714
static u32 rs_get_lower_rate(struct iwl4965_lq_sta *lq_sta,
Christoph Hellwig's avatar
Christoph Hellwig committed
715
			     struct iwl4965_scale_tbl_info *tbl, u8 scale_index,
Guy Cohen's avatar
Guy Cohen committed
716
			     u8 ht_possible)
717
718
719
720
721
{
	s32 low;
	u16 rate_mask;
	u16 high_low;
	u8 switch_to_legacy = 0;
722
	u8 is_green = lq_sta->is_green;
723
724
725
726
727
728
729

	/* 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];
730
		if (lq_sta->band == IEEE80211_BAND_5GHZ)
731
732
733
734
			tbl->lq_type = LQ_A;
		else
			tbl->lq_type = LQ_G;

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

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

742
	rate_mask = rs_get_supported_rates(lq_sta, NULL, tbl->lq_type);
743

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

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

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

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

out:
	return rate_n_flags_from_tbl(tbl, low, is_green);
769
770
}

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

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

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

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

807
	retries = info->status.retry_count;
808
809
810
811

	if (retries > 15)
		retries = 15;

812
	rcu_read_lock();
813
814
815

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

816
817
818
	if (!sta || !sta->rate_ctrl_priv)
		goto out;

819

820
	lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
821
822

	if (!priv->lq_mngr.lq_ready)
823
		goto out;
824

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

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

832
833
	curr_tbl = &(lq_sta->lq_info[active_index]);
	search_tbl = &(lq_sta->lq_info[(1 - active_index)]);
Christoph Hellwig's avatar
Christoph Hellwig committed
834
	window = (struct iwl4965_rate_scale_data *)
835
	    &(curr_tbl->win[0]);
Christoph Hellwig's avatar
Christoph Hellwig committed
836
	search_win = (struct iwl4965_rate_scale_data *)
837
838
	    &(search_tbl->win[0]);

839
840
841
842
843
844
845
846
	/*
	 * 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
847
848
	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);
849
850
851
	if (priv->band == IEEE80211_BAND_5GHZ)
		rs_index -= IWL_FIRST_OFDM_RATE;

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

870
	/* Update frame history window with "failure" for each Tx retry. */
871
	while (retries) {
872
873
		/* 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
874
875
		tx_rate = le32_to_cpu(table->rs_table[index].rate_n_flags);
		rs_get_tbl_info_from_mcs(tx_rate, priv->band,
876
877
					  &tbl_type, &rs_index);

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

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

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

	}

910
911
912
913
914
	/*
	 * 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
915
916
	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);
917

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

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

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

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

977
978
979
980
981
982
983
984
/*
 * 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.
 */
985
static void rs_set_stay_in_table(struct iwl_priv *priv, u8 is_legacy,
986
				 struct iwl4965_lq_sta *lq_sta)
987
{
988
	IWL_DEBUG_RATE("we are staying in the same table\n");
989
	lq_sta->stay_in_tbl = 1;	/* only place this gets set */
990
	if (is_legacy) {
991
992
993
		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;
994
	} else {
995
996
997
		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;
998
	}
999
1000
	lq_sta->table_count = 0;
	lq_sta->total_failed = 0;
For faster browsing, not all history is shown. View entire blame