iwl-4965-rs.c 79.7 KB
Newer Older
Z
Zhu Yi 已提交
1 2
/******************************************************************************
 *
R
Reinette Chatre 已提交
3
 * Copyright(c) 2005 - 2008 Intel Corporation. All rights reserved.
Z
Zhu Yi 已提交
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 38 39 40
 *
 * 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 <net/ieee80211.h>

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

#include <linux/workqueue.h>

#include "../net/mac80211/ieee80211_rate.h"

41
#include "iwl-4965.h"
42
#include "iwl-core.h"
Z
Zhu Yi 已提交
43 44 45 46 47 48 49 50
#include "iwl-helpers.h"

#define RS_NAME "iwl-4965-rs"

#define NUM_TRY_BEFORE_ANTENNA_TOGGLE 1
#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)
Z
Zhu Yi 已提交
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
};

C
Christoph Hellwig 已提交
68
struct iwl4965_rate {
Z
Zhu Yi 已提交
69 70 71
	u32 rate_n_flags;
} __attribute__ ((packed));

72 73 74
/**
 * struct iwl4965_rate_scale_data -- tx success history for one rate
 */
C
Christoph Hellwig 已提交
75
struct iwl4965_rate_scale_data {
76 77 78 79 80
	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 */
Z
Zhu Yi 已提交
81 82 83
	unsigned long stamp;
};

84 85 86
/**
 * struct iwl4965_scale_tbl_info -- tx params and success history for all rates
 *
87
 * There are two of these in struct iwl4965_lq_sta,
88 89
 * one for "active", and one for "search".
 */
C
Christoph Hellwig 已提交
90 91 92
struct iwl4965_scale_tbl_info {
	enum iwl4965_table_type lq_type;
	enum iwl4965_antenna_type antenna_type;
93 94 95 96 97 98 99
	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. */
	struct iwl4965_rate current_rate;  /* rate_n_flags, uCode API format */
	struct iwl4965_rate_scale_data win[IWL_RATE_COUNT]; /* rate histories */
Z
Zhu Yi 已提交
100 101
};

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
#ifdef CONFIG_IWL4965_HT

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

#endif /* CONFIG_IWL4965_HT */

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

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

	/* The following are bitmaps of rates; IWL_RATE_6M_MASK, etc. */
147
	u32 supp_rates;
Z
Zhu Yi 已提交
148 149 150 151
	u16 active_rate;
	u16 active_siso_rate;
	u16 active_mimo_rate;
	u16 active_rate_basic;
152

C
Christoph Hellwig 已提交
153
	struct iwl4965_link_quality_cmd lq;
154
	struct iwl4965_scale_tbl_info lq_info[LQ_SIZE]; /* "active", "search" */
155 156 157 158
#ifdef CONFIG_IWL4965_HT
	struct iwl4965_traffic_load load[TID_MAX_LOAD_COUNT];
	u8 tx_agg_tid_en;
#endif
159
#ifdef CONFIG_MAC80211_DEBUGFS
160
	struct dentry *rs_sta_dbgfs_scale_table_file;
161
	struct dentry *rs_sta_dbgfs_stats_table_file;
162 163 164
#ifdef CONFIG_IWL4965_HT
	struct dentry *rs_sta_dbgfs_tx_agg_tid_en_file;
#endif
C
Christoph Hellwig 已提交
165
	struct iwl4965_rate dbg_fixed;
166
	struct iwl_priv *drv;
167
#endif
Z
Zhu Yi 已提交
168 169
};

170
static void rs_rate_scale_perform(struct iwl_priv *priv,
Z
Zhu Yi 已提交
171 172 173
				   struct net_device *dev,
				   struct ieee80211_hdr *hdr,
				   struct sta_info *sta);
174
static void rs_fill_link_cmd(struct iwl4965_lq_sta *lq_sta,
C
Christoph Hellwig 已提交
175 176
			     struct iwl4965_rate *tx_mcs,
			     struct iwl4965_link_quality_cmd *tbl);
Z
Zhu Yi 已提交
177 178


179
#ifdef CONFIG_MAC80211_DEBUGFS
180
static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
C
Christoph Hellwig 已提交
181
				struct iwl4965_rate *mcs, int index);
182
#else
183
static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
C
Christoph Hellwig 已提交
184
				struct iwl4965_rate *mcs, int index)
185 186
{}
#endif
187 188 189 190 191 192

/*
 * 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).
 */
Z
Zhu Yi 已提交
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 231 232
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
};

233
static int iwl4965_lq_sync_callback(struct iwl_priv *priv,
234
				struct iwl_cmd *cmd, struct sk_buff *skb)
Z
Zhu Yi 已提交
235 236 237 238 239
{
	/*We didn't cache the SKB; let the caller free it */
	return 1;
}

C
Christoph Hellwig 已提交
240
static inline u8 iwl4965_rate_get_rate(u32 rate_n_flags)
Z
Zhu Yi 已提交
241 242 243 244
{
	return (u8)(rate_n_flags & 0xFF);
}

245
static int rs_send_lq_cmd(struct iwl_priv *priv,
C
Christoph Hellwig 已提交
246
			  struct iwl4965_link_quality_cmd *lq, u8 flags)
Z
Zhu Yi 已提交
247
{
248
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
249 250
	int i;
#endif
251
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
252
		.id = REPLY_TX_LINK_QUALITY_CMD,
C
Christoph Hellwig 已提交
253
		.len = sizeof(struct iwl4965_link_quality_cmd),
Z
Zhu Yi 已提交
254 255 256 257 258 259
		.meta.flags = flags,
		.data = lq,
	};

	if ((lq->sta_id == 0xFF) &&
	    (priv->iw_mode == IEEE80211_IF_TYPE_IBSS))
260
		return -EINVAL;
Z
Zhu Yi 已提交
261 262 263 264 265 266 267 268

	if (lq->sta_id == 0xFF)
		lq->sta_id = IWL_AP_ID;

	IWL_DEBUG_RATE("lq station id 0x%x\n", lq->sta_id);
	IWL_DEBUG_RATE("lq dta 0x%X 0x%X\n",
		       lq->general_params.single_stream_ant_msk,
		       lq->general_params.dual_stream_ant_msk);
269
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
270 271 272 273 274 275
	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
		IWL_DEBUG_RATE("lq index %d 0x%X\n",
				i, lq->rs_table[i].rate_n_flags);
#endif

	if (flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
276
		cmd.meta.u.callback = iwl4965_lq_sync_callback;
Z
Zhu Yi 已提交
277

278
	if (iwl_is_associated(priv) && priv->assoc_station_added &&
Z
Zhu Yi 已提交
279
	    priv->lq_mngr.lq_ready)
280
		return  iwl_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
281

282
	return 0;
Z
Zhu Yi 已提交
283 284
}

C
Christoph Hellwig 已提交
285
static void rs_rate_scale_clear_window(struct iwl4965_rate_scale_data *window)
Z
Zhu Yi 已提交
286 287 288 289 290 291 292 293 294
{
	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;
}

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 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
#ifdef CONFIG_IWL4965_HT
/*
 *	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
 */
static void rs_tl_add_packet(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;

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

392
static void rs_tl_turn_on_agg_for_tid(struct iwl_priv *priv,
393 394 395 396 397 398 399
				struct iwl4965_lq_sta *lq_data, u8 tid,
				struct sta_info *sta)
{
	unsigned long state;
	DECLARE_MAC_BUF(mac);

	spin_lock_bh(&sta->ampdu_mlme.ampdu_tx);
400
	state = sta->ampdu_mlme.tid_state_tx[tid];
401 402 403 404 405 406 407 408 409 410
	spin_unlock_bh(&sta->ampdu_mlme.ampdu_tx);

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

411
static void rs_tl_turn_on_agg(struct iwl_priv *priv, u8 tid,
412 413 414 415 416 417 418 419 420 421 422 423
				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);
}

#endif /* CONFIG_IWLWIFI_HT */

424 425 426 427 428 429 430
/**
 * 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.
 */
C
Christoph Hellwig 已提交
431
static int rs_collect_tx_data(struct iwl4965_rate_scale_data *windows,
432 433
			      int scale_index, s32 tpt, int retries,
			      int successes)
Z
Zhu Yi 已提交
434
{
C
Christoph Hellwig 已提交
435
	struct iwl4965_rate_scale_data *window = NULL;
Z
Zhu Yi 已提交
436 437 438 439
	u64 mask;
	u8 win_size = IWL_RATE_MAX_WINDOW;
	s32 fail_count;

440 441
	if (scale_index < 0 || scale_index >= IWL_RATE_COUNT)
		return -EINVAL;
Z
Zhu Yi 已提交
442

443
	/* Select data for current tx bit rate */
Z
Zhu Yi 已提交
444 445
	window = &(windows[scale_index]);

446 447 448 449 450 451 452 453
	/*
	 * 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!).
	 */
454 455 456 457 458 459 460 461 462 463
	while (retries > 0) {
		if (window->counter >= win_size) {
			window->counter = win_size - 1;
			mask = 1;
			mask = (mask << (win_size - 1));
			if (window->data & mask) {
				window->data &= ~mask;
				window->success_counter =
					window->success_counter - 1;
			}
Z
Zhu Yi 已提交
464 465
		}

466 467 468 469 470 471 472 473 474 475 476 477 478
		/* 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. */
		mask = window->data;
		window->data = (mask << 1);
		if (successes > 0) {
			window->success_counter = window->success_counter + 1;
			window->data |= 0x1;
			successes--;
		}
479

480
		retries--;
Z
Zhu Yi 已提交
481 482
	}

483
	/* Calculate current success ratio, avoid divide-by-0! */
Z
Zhu Yi 已提交
484 485 486 487 488 489 490 491
	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;

492
	/* Calculate average throughput, if we have enough history. */
Z
Zhu Yi 已提交
493 494 495 496 497 498
	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;

499
	/* Tag this window as having been updated */
Z
Zhu Yi 已提交
500 501
	window->stamp = jiffies;

502
	return 0;
Z
Zhu Yi 已提交
503 504
}

505 506 507
/*
 * Fill uCode API rate_n_flags field, based on "search" or "active" table.
 */
C
Christoph Hellwig 已提交
508 509
static void rs_mcs_from_tbl(struct iwl4965_rate *mcs_rate,
			   struct iwl4965_scale_tbl_info *tbl,
Z
Zhu Yi 已提交
510 511 512
			   int index, u8 use_green)
{
	if (is_legacy(tbl->lq_type)) {
C
Christoph Hellwig 已提交
513
		mcs_rate->rate_n_flags = iwl4965_rates[index].plcp;
Z
Zhu Yi 已提交
514 515 516 517 518 519
		if (index >= IWL_FIRST_CCK_RATE && index <= IWL_LAST_CCK_RATE)
			mcs_rate->rate_n_flags |= RATE_MCS_CCK_MSK;

	} else if (is_siso(tbl->lq_type)) {
		if (index > IWL_LAST_OFDM_RATE)
			index = IWL_LAST_OFDM_RATE;
C
Christoph Hellwig 已提交
520
		 mcs_rate->rate_n_flags = iwl4965_rates[index].plcp_siso |
Z
Zhu Yi 已提交
521 522 523 524
					  RATE_MCS_HT_MSK;
	} else {
		if (index > IWL_LAST_OFDM_RATE)
			index = IWL_LAST_OFDM_RATE;
C
Christoph Hellwig 已提交
525
		mcs_rate->rate_n_flags = iwl4965_rates[index].plcp_mimo |
Z
Zhu Yi 已提交
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
					 RATE_MCS_HT_MSK;
	}

	switch (tbl->antenna_type) {
	case ANT_BOTH:
		mcs_rate->rate_n_flags |= RATE_MCS_ANT_AB_MSK;
		break;
	case ANT_MAIN:
		mcs_rate->rate_n_flags |= RATE_MCS_ANT_A_MSK;
		break;
	case ANT_AUX:
		mcs_rate->rate_n_flags |= RATE_MCS_ANT_B_MSK;
		break;
	case ANT_NONE:
		break;
	}

	if (is_legacy(tbl->lq_type))
544
		return;
Z
Zhu Yi 已提交
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561

	if (tbl->is_fat) {
		if (tbl->is_dup)
			mcs_rate->rate_n_flags |= RATE_MCS_DUP_MSK;
		else
			mcs_rate->rate_n_flags |= RATE_MCS_FAT_MSK;
	}
	if (tbl->is_SGI)
		mcs_rate->rate_n_flags |= RATE_MCS_SGI_MSK;

	if (use_green) {
		mcs_rate->rate_n_flags |= RATE_MCS_GF_MSK;
		if (is_siso(tbl->lq_type))
			mcs_rate->rate_n_flags &= ~RATE_MCS_SGI_MSK;
	}
}

562 563 564 565
/*
 * Interpret uCode API's rate_n_flags format,
 * fill "search" or "active" tx mode table.
 */
C
Christoph Hellwig 已提交
566
static int rs_get_tbl_info_from_mcs(const struct iwl4965_rate *mcs_rate,
567 568
				    enum ieee80211_band band,
				    struct iwl4965_scale_tbl_info *tbl,
Z
Zhu Yi 已提交
569 570 571 572 573
				    int *rate_idx)
{
	int index;
	u32 ant_msk;

574
	index = iwl4965_hwrate_to_plcp_idx(mcs_rate->rate_n_flags);
Z
Zhu Yi 已提交
575 576 577

	if (index  == IWL_RATE_INVALID) {
		*rate_idx = -1;
578
		return -EINVAL;
Z
Zhu Yi 已提交
579
	}
580
	tbl->is_SGI = 0;	/* default legacy setup */
Z
Zhu Yi 已提交
581 582
	tbl->is_fat = 0;
	tbl->is_dup = 0;
583
	tbl->antenna_type = ANT_BOTH;	/* default MIMO setup */
Z
Zhu Yi 已提交
584

585
	/* legacy rate format */
Z
Zhu Yi 已提交
586 587 588 589 590 591 592
	if (!(mcs_rate->rate_n_flags & RATE_MCS_HT_MSK)) {
		ant_msk = (mcs_rate->rate_n_flags & RATE_MCS_ANT_AB_MSK);

		if (ant_msk == RATE_MCS_ANT_AB_MSK)
			tbl->lq_type = LQ_NONE;
		else {

593
			if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
594 595 596 597 598 599 600 601 602 603 604
				tbl->lq_type = LQ_A;
			else
				tbl->lq_type = LQ_G;

			if (mcs_rate->rate_n_flags & RATE_MCS_ANT_A_MSK)
				tbl->antenna_type = ANT_MAIN;
			else
				tbl->antenna_type = ANT_AUX;
		}
		*rate_idx = index;

605
	/* HT rate format, SISO (might be 20 MHz legacy or 40 MHz fat width) */
C
Christoph Hellwig 已提交
606
	} else if (iwl4965_rate_get_rate(mcs_rate->rate_n_flags)
Z
Zhu Yi 已提交
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
					<= IWL_RATE_SISO_60M_PLCP) {
		tbl->lq_type = LQ_SISO;

		ant_msk = (mcs_rate->rate_n_flags & RATE_MCS_ANT_AB_MSK);
		if (ant_msk == RATE_MCS_ANT_AB_MSK)
			tbl->lq_type = LQ_NONE;
		else {
			if (mcs_rate->rate_n_flags & RATE_MCS_ANT_A_MSK)
				tbl->antenna_type = ANT_MAIN;
			else
				tbl->antenna_type = ANT_AUX;
		}
		if (mcs_rate->rate_n_flags & RATE_MCS_SGI_MSK)
			tbl->is_SGI = 1;

		if ((mcs_rate->rate_n_flags & RATE_MCS_FAT_MSK) ||
		    (mcs_rate->rate_n_flags & RATE_MCS_DUP_MSK))
			tbl->is_fat = 1;

		if (mcs_rate->rate_n_flags & RATE_MCS_DUP_MSK)
			tbl->is_dup = 1;

		*rate_idx = index;
630 631

	/* HT rate format, MIMO (might be 20 MHz legacy or 40 MHz fat width) */
Z
Zhu Yi 已提交
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
	} else {
		tbl->lq_type = LQ_MIMO;
		if (mcs_rate->rate_n_flags & RATE_MCS_SGI_MSK)
			tbl->is_SGI = 1;

		if ((mcs_rate->rate_n_flags & RATE_MCS_FAT_MSK) ||
		    (mcs_rate->rate_n_flags & RATE_MCS_DUP_MSK))
			tbl->is_fat = 1;

		if (mcs_rate->rate_n_flags & RATE_MCS_DUP_MSK)
			tbl->is_dup = 1;
		*rate_idx = index;
	}
	return 0;
}

C
Christoph Hellwig 已提交
648 649
static inline void rs_toggle_antenna(struct iwl4965_rate *new_rate,
				     struct iwl4965_scale_tbl_info *tbl)
Z
Zhu Yi 已提交
650 651 652 653 654 655 656 657 658 659 660 661
{
	if (tbl->antenna_type == ANT_AUX) {
		tbl->antenna_type = ANT_MAIN;
		new_rate->rate_n_flags &= ~RATE_MCS_ANT_B_MSK;
		new_rate->rate_n_flags |= RATE_MCS_ANT_A_MSK;
	} else {
		tbl->antenna_type = ANT_AUX;
		new_rate->rate_n_flags &= ~RATE_MCS_ANT_A_MSK;
		new_rate->rate_n_flags |= RATE_MCS_ANT_B_MSK;
	}
}

662
static inline u8 rs_use_green(struct iwl_priv *priv,
663
			      struct ieee80211_conf *conf)
Z
Zhu Yi 已提交
664
{
665
#ifdef CONFIG_IWL4965_HT
666 667 668 669
	return ((conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) &&
		priv->current_ht_config.is_green_field &&
		!priv->current_ht_config.non_GF_STA_present);
#endif	/* CONFIG_IWL4965_HT */
670
	return 0;
Z
Zhu Yi 已提交
671 672 673 674 675 676 677 678 679
}

/**
 * rs_get_supported_rates - get the available rates
 *
 * if management frame or broadcast frame only return
 * basic available rates.
 *
 */
680
static void rs_get_supported_rates(struct iwl4965_lq_sta *lq_sta,
Z
Zhu Yi 已提交
681
				   struct ieee80211_hdr *hdr,
C
Christoph Hellwig 已提交
682
				   enum iwl4965_table_type rate_type,
Z
Zhu Yi 已提交
683 684 685
				   u16 *data_rate)
{
	if (is_legacy(rate_type))
686
		*data_rate = lq_sta->active_rate;
Z
Zhu Yi 已提交
687 688
	else {
		if (is_siso(rate_type))
689
			*data_rate = lq_sta->active_siso_rate;
Z
Zhu Yi 已提交
690
		else
691
			*data_rate = lq_sta->active_mimo_rate;
Z
Zhu Yi 已提交
692 693 694
	}

	if (hdr && is_multicast_ether_addr(hdr->addr1) &&
695 696 697
	    lq_sta->active_rate_basic) {
		*data_rate = lq_sta->active_rate_basic;
	}
Z
Zhu Yi 已提交
698 699 700 701 702 703 704
}

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

705
	/* 802.11A or ht walks to the next literal adjacent rate in
Z
Zhu Yi 已提交
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
	 * 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) {
C
Christoph Hellwig 已提交
734
		low = iwl4965_rates[low].prev_rs;
Z
Zhu Yi 已提交
735 736 737 738 739 740 741 742 743
		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) {
C
Christoph Hellwig 已提交
744
		high = iwl4965_rates[high].next_rs;
Z
Zhu Yi 已提交
745 746 747 748 749 750 751 752 753 754
		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;
}

755
static void rs_get_lower_rate(struct iwl4965_lq_sta *lq_sta,
C
Christoph Hellwig 已提交
756 757
			     struct iwl4965_scale_tbl_info *tbl, u8 scale_index,
			     u8 ht_possible, struct iwl4965_rate *mcs_rate)
Z
Zhu Yi 已提交
758 759 760 761 762
{
	s32 low;
	u16 rate_mask;
	u16 high_low;
	u8 switch_to_legacy = 0;
763
	u8 is_green = lq_sta->is_green;
Z
Zhu Yi 已提交
764 765 766 767 768 769 770

	/* 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];
771
		if (lq_sta->band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
772 773 774 775 776 777 778 779 780 781 782 783
			tbl->lq_type = LQ_A;
		else
			tbl->lq_type = LQ_G;

		if ((tbl->antenna_type == ANT_BOTH) ||
		    (tbl->antenna_type == ANT_NONE))
			tbl->antenna_type = ANT_MAIN;

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

784
	rs_get_supported_rates(lq_sta, NULL, tbl->lq_type, &rate_mask);
Z
Zhu Yi 已提交
785

786
	/* Mask with station rate restriction */
Z
Zhu Yi 已提交
787
	if (is_legacy(tbl->lq_type)) {
788
		/* supp_rates has no CCK bits in A mode */
789
		if (lq_sta->band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
790
			rate_mask  = (u16)(rate_mask &
791
			   (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
Z
Zhu Yi 已提交
792
		else
793
			rate_mask = (u16)(rate_mask & lq_sta->supp_rates);
Z
Zhu Yi 已提交
794 795
	}

796
	/* If we switched from HT to legacy, check current rate */
797
	if (switch_to_legacy && (rate_mask & (1 << scale_index))) {
Z
Zhu Yi 已提交
798
		rs_mcs_from_tbl(mcs_rate, tbl, scale_index, is_green);
799
		return;
Z
Zhu Yi 已提交
800 801 802 803 804 805 806 807 808 809 810
	}

	high_low = rs_get_adjacent_rate(scale_index, rate_mask, tbl->lq_type);
	low = high_low & 0xff;

	if (low != IWL_RATE_INVALID)
		rs_mcs_from_tbl(mcs_rate, tbl, low, is_green);
	else
		rs_mcs_from_tbl(mcs_rate, tbl, scale_index, is_green);
}

811 812 813
/*
 * mac80211 sends us Tx status
 */
814
static void rs_tx_status(void *priv_rate, struct net_device *dev,
Z
Zhu Yi 已提交
815 816 817 818 819 820
			 struct sk_buff *skb,
			 struct ieee80211_tx_status *tx_resp)
{
	int status;
	u8 retries;
	int rs_index, index = 0;
821
	struct iwl4965_lq_sta *lq_sta;
C
Christoph Hellwig 已提交
822
	struct iwl4965_link_quality_cmd *table;
Z
Zhu Yi 已提交
823 824
	struct sta_info *sta;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
825
	struct iwl_priv *priv = (struct iwl_priv *)priv_rate;
Z
Zhu Yi 已提交
826
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
827
	struct ieee80211_hw *hw = local_to_hw(local);
C
Christoph Hellwig 已提交
828 829 830 831 832
	struct iwl4965_rate_scale_data *window = NULL;
	struct iwl4965_rate_scale_data *search_win = NULL;
	struct iwl4965_rate tx_mcs;
	struct iwl4965_scale_tbl_info tbl_type;
	struct iwl4965_scale_tbl_info *curr_tbl, *search_tbl;
Z
Zhu Yi 已提交
833 834 835 836
	u8 active_index = 0;
	u16 fc = le16_to_cpu(hdr->frame_control);
	s32 tpt = 0;

837
	IWL_DEBUG_RATE_LIMIT("get frame ack response, update rate scale window\n");
Z
Zhu Yi 已提交
838 839 840 841

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

842 843 844 845 846
	/* This packet was aggregated but doesn't carry rate scale info */
	if ((tx_resp->control.flags & IEEE80211_TXCTL_AMPDU) &&
	    !(tx_resp->flags & IEEE80211_TX_STATUS_AMPDU))
		return;

Z
Zhu Yi 已提交
847 848 849 850 851
	retries = tx_resp->retry_count;

	if (retries > 15)
		retries = 15;

852
	rcu_read_lock();
Z
Zhu Yi 已提交
853 854 855

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

856 857 858
	if (!sta || !sta->rate_ctrl_priv)
		goto out;

Z
Zhu Yi 已提交
859

860
	lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
Z
Zhu Yi 已提交
861 862

	if (!priv->lq_mngr.lq_ready)
863
		goto out;
Z
Zhu Yi 已提交
864

865 866
	if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
	    !lq_sta->ibss_sta_added)
867
		goto out;
Z
Zhu Yi 已提交
868

869 870
	table = &lq_sta->lq;
	active_index = lq_sta->active_tbl;
Z
Zhu Yi 已提交
871

872
	/* Get mac80211 antenna info */
873 874 875 876
	lq_sta->antenna =
		(lq_sta->valid_antenna & local->hw.conf.antenna_sel_tx);
	if (!lq_sta->antenna)
		lq_sta->antenna = lq_sta->valid_antenna;
Z
Zhu Yi 已提交
877

878
	/* Ignore mac80211 antenna info for now */
879
	lq_sta->antenna = lq_sta->valid_antenna;
880

881 882
	curr_tbl = &(lq_sta->lq_info[active_index]);
	search_tbl = &(lq_sta->lq_info[(1 - active_index)]);
C
Christoph Hellwig 已提交
883
	window = (struct iwl4965_rate_scale_data *)
Z
Zhu Yi 已提交
884
	    &(curr_tbl->win[0]);
C
Christoph Hellwig 已提交
885
	search_win = (struct iwl4965_rate_scale_data *)
Z
Zhu Yi 已提交
886 887
	    &(search_tbl->win[0]);

888 889 890 891 892 893 894 895
	/*
	 * 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).
	 */
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
	tx_mcs.rate_n_flags = le32_to_cpu(table->rs_table[0].rate_n_flags);
	rs_get_tbl_info_from_mcs(&tx_mcs, priv->band, &tbl_type, &rs_index);
	if (priv->band == IEEE80211_BAND_5GHZ)
		rs_index -= IWL_FIRST_OFDM_RATE;

	if ((tx_resp->control.tx_rate == NULL) ||
	    (tbl_type.is_SGI ^
		!!(tx_resp->control.flags & IEEE80211_TXCTL_SHORT_GI)) ||
	    (tbl_type.is_fat ^
		!!(tx_resp->control.flags & IEEE80211_TXCTL_40_MHZ_WIDTH)) ||
	    (tbl_type.is_dup ^
		!!(tx_resp->control.flags & IEEE80211_TXCTL_DUP_DATA)) ||
	    (tbl_type.antenna_type ^
		tx_resp->control.antenna_sel_tx) ||
	    (!!(tx_mcs.rate_n_flags & RATE_MCS_HT_MSK) ^
		!!(tx_resp->control.flags & IEEE80211_TXCTL_OFDM_HT)) ||
	    (!!(tx_mcs.rate_n_flags & RATE_MCS_GF_MSK) ^
		!!(tx_resp->control.flags & IEEE80211_TXCTL_GREEN_FIELD)) ||
	    (hw->wiphy->bands[priv->band]->bitrates[rs_index].bitrate !=
		tx_resp->control.tx_rate->bitrate)) {
		IWL_DEBUG_RATE("initial rate does not match 0x%x\n",
				tx_mcs.rate_n_flags);
918
		goto out;
Z
Zhu Yi 已提交
919 920
	}

921
	/* Update frame history window with "failure" for each Tx retry. */
Z
Zhu Yi 已提交
922
	while (retries) {
923 924
		/* Look up the rate and other info used for each tx attempt.
		 * Each tx attempt steps one entry deeper in the rate table. */
Z
Zhu Yi 已提交
925 926
		tx_mcs.rate_n_flags =
		    le32_to_cpu(table->rs_table[index].rate_n_flags);
927
		rs_get_tbl_info_from_mcs(&tx_mcs, priv->band,
Z
Zhu Yi 已提交
928 929
					  &tbl_type, &rs_index);

930 931
		/* If type matches "search" table,
		 * add failure to "search" history */
Z
Zhu Yi 已提交
932 933 934 935 936 937 938
		if ((tbl_type.lq_type == search_tbl->lq_type) &&
		    (tbl_type.antenna_type == search_tbl->antenna_type) &&
		    (tbl_type.is_SGI == search_tbl->is_SGI)) {
			if (search_tbl->expected_tpt)
				tpt = search_tbl->expected_tpt[rs_index];
			else
				tpt = 0;
939
			rs_collect_tx_data(search_win, rs_index, tpt, 1, 0);
940 941 942

		/* Else if type matches "current/active" table,
		 * add failure to "current/active" history */
Z
Zhu Yi 已提交
943 944 945 946 947 948 949
		} else if ((tbl_type.lq_type == curr_tbl->lq_type) &&
			   (tbl_type.antenna_type == curr_tbl->antenna_type) &&
			   (tbl_type.is_SGI == curr_tbl->is_SGI)) {
			if (curr_tbl->expected_tpt)
				tpt = curr_tbl->expected_tpt[rs_index];
			else
				tpt = 0;
950
			rs_collect_tx_data(window, rs_index, tpt, 1, 0);
Z
Zhu Yi 已提交
951
		}
952 953 954

		/* If not searching for a new mode, increment failed counter
		 * ... this helps determine when to start searching again */
955 956
		if (lq_sta->stay_in_tbl)
			lq_sta->total_failed++;
Z
Zhu Yi 已提交
957 958 959 960 961
		--retries;
		index++;

	}

962 963 964 965 966
	/*
	 * 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.
	 */
967 968
	tx_mcs.rate_n_flags = le32_to_cpu(table->rs_table[index].rate_n_flags);
	rs_get_tbl_info_from_mcs(&tx_mcs, priv->band, &tbl_type, &rs_index);
Z
Zhu Yi 已提交
969

970
	/* Update frame history window with "success" if Tx got ACKed ... */
Z
Zhu Yi 已提交
971 972 973 974 975
	if (tx_resp->flags & IEEE80211_TX_STATUS_ACK)
		status = 1;
	else
		status = 0;

976 977
	/* If type matches "search" table,
	 * add final tx status to "search" history */
Z
Zhu Yi 已提交
978 979 980 981 982 983 984
	if ((tbl_type.lq_type == search_tbl->lq_type) &&
	    (tbl_type.antenna_type == search_tbl->antenna_type) &&
	    (tbl_type.is_SGI == search_tbl->is_SGI)) {
		if (search_tbl->expected_tpt)
			tpt = search_tbl->expected_tpt[rs_index];
		else
			tpt = 0;
985 986 987 988 989 990 991
		if (tx_resp->control.flags & IEEE80211_TXCTL_AMPDU)
			rs_collect_tx_data(search_win, rs_index, tpt,
					   tx_resp->ampdu_ack_len,
					   tx_resp->ampdu_ack_map);
		else
			rs_collect_tx_data(search_win, rs_index, tpt,
					   1, status);
992 993
	/* Else if type matches "current/active" table,
	 * add final tx status to "current/active" history */
Z
Zhu Yi 已提交
994 995 996 997 998 999 1000
	} else if ((tbl_type.lq_type == curr_tbl->lq_type) &&
		   (tbl_type.antenna_type == curr_tbl->antenna_type) &&
		   (tbl_type.is_SGI == curr_tbl->is_SGI)) {
		if (curr_tbl->expected_tpt)
			tpt = curr_tbl->expected_tpt[rs_index];
		else
			tpt = 0;
1001 1002 1003 1004 1005 1006 1007
		if (tx_resp->control.flags & IEEE80211_TXCTL_AMPDU)
			rs_collect_tx_data(window, rs_index, tpt,
					   tx_resp->ampdu_ack_len,
					   tx_resp->ampdu_ack_map);
		else
			rs_collect_tx_data(window, rs_index, tpt,
					   1, status);
Z
Zhu Yi 已提交
1008 1009
	}

1010 1011
	/* If not searching for new mode, increment success/failed counter
	 * ... these help determine when to start searching again */
1012
	if (lq_sta->stay_in_tbl) {
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
		if (tx_resp->control.flags & IEEE80211_TXCTL_AMPDU) {
			lq_sta->total_success += tx_resp->ampdu_ack_map;
			lq_sta->total_failed +=
			     (tx_resp->ampdu_ack_len - tx_resp->ampdu_ack_map);
		} else {
			if (status)
				lq_sta->total_success++;
			else
				lq_sta->total_failed++;
		}
Z
Zhu Yi 已提交
1023 1024
	}

1025
	/* See if there's a better rate or modulation mode to try. */
Z
Zhu Yi 已提交
1026
	rs_rate_scale_perform(priv, dev, hdr, sta);
1027
out:
1028
	rcu_read_unlock();
Z
Zhu Yi 已提交
1029 1030 1031 1032
	return;
}

static u8 rs_is_ant_connected(u8 valid_antenna,
C
Christoph Hellwig 已提交
1033
			      enum iwl4965_antenna_type antenna_type)
Z
Zhu Yi 已提交
1034 1035 1036 1037 1038
{
	if (antenna_type == ANT_AUX)
		return ((valid_antenna & 0x2) ? 1:0);
	else if (antenna_type == ANT_MAIN)
		return ((valid_antenna & 0x1) ? 1:0);
1039 1040
	else if (antenna_type == ANT_BOTH)
		return ((valid_antenna & 0x3) == 0x3);
Z
Zhu Yi 已提交
1041 1042 1043 1044 1045

	return 1;
}

static u8 rs_is_other_ant_connected(u8 valid_antenna,
C
Christoph Hellwig 已提交
1046
				    enum iwl4965_antenna_type antenna_type)
Z
Zhu Yi 已提交
1047 1048
{
	if (antenna_type == ANT_AUX)
1049
		return rs_is_ant_connected(valid_antenna, ANT_MAIN);
Z
Zhu Yi 已提交
1050
	else
1051
		return rs_is_ant_connected(valid_antenna, ANT_AUX);
Z
Zhu Yi 已提交
1052 1053 1054 1055

	return 0;
}

1056 1057 1058 1059 1060 1061 1062 1063
/*
 * 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.
 */
Z
Zhu Yi 已提交
1064
static void rs_set_stay_in_table(u8 is_legacy,
1065
				 struct iwl4965_lq_sta *lq_sta)
Z
Zhu Yi 已提交
1066 1067
{
	IWL_DEBUG_HT("we are staying in the same table\n");
1068
	lq_sta->stay_in_tbl = 1;	/* only place this gets set */
Z
Zhu Yi 已提交
1069
	if (is_legacy) {
1070 1071 1072
		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;
Z
Zhu Yi 已提交
1073
	} else {
1074 1075 1076
		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;
Z
Zhu Yi 已提交
1077
	}
1078 1079 1080
	lq_sta->table_count = 0;
	lq_sta->total_failed = 0;
	lq_sta->total_success = 0;
Z
Zhu Yi 已提交
1081 1082
}

1083 1084 1085
/*
 * Find correct throughput table for given mode of modulation
 */
1086
static void rs_get_expected_tpt_table(struct iwl4965_lq_sta *lq_sta,
C
Christoph Hellwig 已提交
1087
				      struct iwl4965_scale_tbl_info *tbl)
Z
Zhu Yi 已提交
1088 1089 1090 1091 1092 1093 1094
{
	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)) {
1095
		if (tbl->is_fat && !lq_sta->is_dup)
Z
Zhu Yi 已提交
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
			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;

	} else if (is_mimo(tbl->lq_type)) {
1106
		if (tbl->is_fat && !lq_sta->is_dup)
Z
Zhu Yi 已提交
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
			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;
}

1119
#ifdef CONFIG_IWL4965_HT
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
/*
 * 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.
 */
1132
static s32 rs_get_best_rate(struct iwl_priv *priv,
1133
			    struct iwl4965_lq_sta *lq_sta,
1134
			    struct iwl4965_scale_tbl_info *tbl,	/* "search" */
Z
Zhu Yi 已提交
1135 1136
			    u16 rate_mask, s8 index, s8 rate)
{
1137
	/* "active" values */
C
Christoph Hellwig 已提交
1138
	struct iwl4965_scale_tbl_info *active_tbl =
1139
	    &(lq_sta->lq_info[lq_sta->active_tbl]);
Z
Zhu Yi 已提交
1140 1141
	s32 active_sr = active_tbl->win[index].success_ratio;
	s32 active_tpt = active_tbl->expected_tpt[index];
1142 1143 1144 1145 1146

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

	s32 new_rate, high, low, start_hi;
Z
Zhu Yi 已提交
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
	u16 high_low;

	new_rate = high = low = start_hi = IWL_RATE_INVALID;

	for (; ;) {
		high_low = rs_get_adjacent_rate(rate, rate_mask, tbl->lq_type);

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

1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
		/*
		 * Lower the "search" bit rate, to give new "search" mode
		 * approximately the same throughput as "active" if:
		 *
		 * 1) "Active" mode has been working modestly well (but not
		 *    great), and expected "search" throughput (under perfect
		 *    conditions) at candidate rate is above the actual
		 *    measured "active" throughput (but less than expected
		 *    "active" throughput under perfect conditions).
		 * OR
		 * 2) "Active" mode has been working perfectly or very well
		 *    and expected "search" throughput (under perfect
		 *    conditions) at candidate rate is above expected
		 *    "active" throughput (under perfect conditions).
		 */
1172
		if ((((100 * tpt_tbl[rate]) > lq_sta->last_tpt) &&
Z
Zhu Yi 已提交
1173 1174 1175 1176 1177 1178
		     ((active_sr > IWL_RATE_DECREASE_TH) &&
		      (active_sr <= IWL_RATE_HIGH_TH) &&
		      (tpt_tbl[rate] <= active_tpt))) ||
		    ((active_sr >= IWL_RATE_SCALE_SWITCH) &&
		     (tpt_tbl[rate] > active_tpt))) {

1179 1180 1181
			/* (2nd or later pass)
			 * If we've already tried to raise the rate, and are
			 * now trying to lower it, use the higher rate. */
Z
Zhu Yi 已提交
1182 1183 1184 1185
			if (start_hi != IWL_RATE_INVALID) {
				new_rate = start_hi;
				break;
			}
1186

Z
Zhu Yi 已提交
1187
			new_rate = rate;
1188 1189

			/* Loop again with lower rate */
Z
Zhu Yi 已提交
1190 1191
			if (low != IWL_RATE_INVALID)
				rate = low;
1192 1193

			/* Lower rate not available, use the original */
Z
Zhu Yi 已提交
1194 1195
			else
				break;
1196 1197

		/* Else try to raise the "search" rate to match "active" */
Z
Zhu Yi 已提交
1198
		} else {
1199 1200 1201
			/* (2nd or later pass)
			 * If we've already tried to lower the rate, and are
			 * now trying to raise it, use the lower rate. */
Z
Zhu Yi 已提交
1202 1203
			if (new_rate != IWL_RATE_INVALID)
				break;
1204 1205

			/* Loop again with higher rate */
Z
Zhu Yi 已提交
1206 1207 1208
			else if (high != IWL_RATE_INVALID) {
				start_hi = high;
				rate = high;
1209 1210

			/* Higher rate not available, use the original */
Z
Zhu Yi 已提交
1211 1212 1213 1214 1215 1216 1217 1218 1219
			} else {
				new_rate = rate;
				break;
			}
		}
	}

	return new_rate;
}
1220
#endif				/* CONFIG_IWL4965_HT */
Z
Zhu Yi 已提交
1221 1222 1223 1224 1225 1226

static inline u8 rs_is_both_ant_supp(u8 valid_antenna)
{
	return (rs_is_ant_connected(valid_antenna, ANT_BOTH));
}

1227 1228 1229
/*
 * Set up search table for MIMO
 */
1230
static int rs_switch_to_mimo(struct iwl_priv *priv,
1231
			     struct iwl4965_lq_sta *lq_sta,
1232 1233
			     struct ieee80211_conf *conf,
			     struct sta_info *sta,
C
Christoph Hellwig 已提交
1234
			     struct iwl4965_scale_tbl_info *tbl, int index)
Z
Zhu Yi 已提交
1235
{
1236
#ifdef CONFIG_IWL4965_HT
Z
Zhu Yi 已提交
1237 1238
	u16 rate_mask;
	s32 rate;
1239
	s8 is_green = lq_sta->is_green;
Z
Zhu Yi 已提交
1240

1241 1242
	if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) ||
	    !sta->ht_info.ht_supported)
Z
Zhu Yi 已提交
1243 1244 1245 1246
		return -1;

	IWL_DEBUG_HT("LQ: try to switch to MIMO\n");
	tbl->lq_type = LQ_MIMO;
1247
	rs_get_supported_rates(lq_sta, NULL, tbl->lq_type,
Z
Zhu Yi 已提交
1248 1249
				&rate_mask);

1250
	if (priv->current_ht_config.tx_mimo_ps_mode == IWL_MIMO_PS_STATIC)
Z
Zhu Yi 已提交
1251 1252
		return -1;

1253
	/* Need both Tx chains/antennas to support MIMO */
1254
	if (!rs_is_both_ant_supp(lq_sta->antenna))
Z
Zhu Yi 已提交
1255 1256
		return -1;

1257
	tbl->is_dup = lq_sta->is_dup;
Z
Zhu Yi 已提交
1258
	tbl->action = 0;
1259 1260
	if (priv->current_ht_config.supported_chan_width
	    == IWL_CHANNEL_WIDTH_40MHZ)
Z
Zhu Yi 已提交
1261 1262 1263 1264 1265
		tbl->is_fat = 1;
	else
		tbl->is_fat = 0;

	if (tbl->is_fat) {
1266
		if (priv->current_ht_config.sgf & HT_SHORT_GI_40MHZ_ONLY)
Z
Zhu Yi 已提交
1267 1268 1269
			tbl->is_SGI = 1;
		else
			tbl->is_SGI = 0;
1270
	} else if (priv->current_ht_config.sgf & HT_SHORT_GI_20MHZ_ONLY)
Z
Zhu Yi 已提交
1271 1272 1273 1274
		tbl->is_SGI = 1;
	else
		tbl->is_SGI = 0;

1275
	rs_get_expected_tpt_table(lq_sta, tbl);
Z
Zhu Yi 已提交
1276

1277
	rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index, index);
Z
Zhu Yi 已提交
1278 1279 1280 1281 1282 1283 1284 1285

	IWL_DEBUG_HT("LQ: MIMO best rate %d mask %X\n", rate, rate_mask);
	if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask))
		return -1;
	rs_mcs_from_tbl(&tbl->current_rate, tbl, rate, is_green);

	IWL_DEBUG_HT("LQ: Switch to new mcs %X index is green %X\n",
		     tbl->current_rate.rate_n_flags, is_green);
1286
	return 0;
1287 1288
#else
	return -1;
1289
#endif	/*CONFIG_IWL4965_HT */
Z
Zhu Yi 已提交
1290 1291
}

1292 1293 1294
/*
 * Set up search table for SISO
 */
1295
static int rs_switch_to_siso(struct iwl_priv *priv,
1296
			     struct iwl4965_lq_sta *lq_sta,
1297 1298
			     struct ieee80211_conf *conf,
			     struct sta_info *sta,
C
Christoph Hellwig 已提交
1299
			     struct iwl4965_scale_tbl_info *tbl, int index)
Z
Zhu Yi 已提交
1300
{
1301
#ifdef CONFIG_IWL4965_HT
Z
Zhu Yi 已提交
1302
	u16 rate_mask;
1303
	u8 is_green = lq_sta->is_green;
Z
Zhu Yi 已提交
1304 1305 1306
	s32 rate;

	IWL_DEBUG_HT("LQ: try to switch to SISO\n");
1307 1308
	if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) ||
	    !sta->ht_info.ht_supported)
Z
Zhu Yi 已提交
1309 1310
		return -1;

1311
	tbl->is_dup = lq_sta->is_dup;
Z
Zhu Yi 已提交
1312 1313
	tbl->lq_type = LQ_SISO;
	tbl->action = 0;
1314
	rs_get_supported_rates(lq_sta, NULL, tbl->lq_type,
Z
Zhu Yi 已提交
1315 1316
				&rate_mask);

1317 1318
	if (priv->current_ht_config.supported_chan_width
	    == IWL_CHANNEL_WIDTH_40MHZ)
Z
Zhu Yi 已提交
1319 1320 1321 1322 1323
		tbl->is_fat = 1;
	else
		tbl->is_fat = 0;

	if (tbl->is_fat) {
1324
		if (priv->current_ht_config.sgf & HT_SHORT_GI_40MHZ_ONLY)
Z
Zhu Yi 已提交
1325 1326 1327
			tbl->is_SGI = 1;
		else
			tbl->is_SGI = 0;
1328
	} else if (priv->current_ht_config.sgf & HT_SHORT_GI_20MHZ_ONLY)
Z
Zhu Yi 已提交
1329 1330 1331 1332 1333 1334 1335
		tbl->is_SGI = 1;
	else
		tbl->is_SGI = 0;

	if (is_green)
		tbl->is_SGI = 0;

1336 1337
	rs_get_expected_tpt_table(lq_sta, tbl);
	rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index, index);
Z
Zhu Yi 已提交
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347

	IWL_DEBUG_HT("LQ: get best rate %d mask %X\n", rate, rate_mask);
	if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) {
		IWL_DEBUG_HT("can not switch with index %d rate mask %x\n",
			     rate, rate_mask);
		return -1;
	}
	rs_mcs_from_tbl(&tbl->current_rate, tbl, rate, is_green);
	IWL_DEBUG_HT("LQ: Switch to new mcs %X index is green %X\n",
		     tbl->current_rate.rate_n_flags, is_green);
1348 1349 1350
	return 0;
#else
	return -1;
Z
Zhu Yi 已提交
1351

1352
#endif	/*CONFIG_IWL4965_HT */
Z
Zhu Yi 已提交
1353 1354
}

1355 1356 1357
/*
 * Try to switch to new modulation mode from legacy
 */
1358
static int rs_move_legacy_other(struct iwl_priv *priv,
1359
				struct iwl4965_lq_sta *lq_sta,
1360 1361
				struct ieee80211_conf *conf,
				struct sta_info *sta,
Z
Zhu Yi 已提交
1362 1363
				int index)
{
1364
	int ret = 0;
C
Christoph Hellwig 已提交
1365
	struct iwl4965_scale_tbl_info *tbl =
1366
	    &(lq_sta->lq_info[lq_sta->active_tbl]);
C
Christoph Hellwig 已提交
1367
	struct iwl4965_scale_tbl_info *search_tbl =
1368
	    &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
C
Christoph Hellwig 已提交
1369 1370 1371
	struct iwl4965_rate_scale_data *window = &(tbl->win[index]);
	u32 sz = (sizeof(struct iwl4965_scale_tbl_info) -
		  (sizeof(struct iwl4965_rate_scale_data) * IWL_RATE_COUNT));
Z
Zhu Yi 已提交
1372 1373 1374 1375 1376 1377 1378 1379
	u8 start_action = tbl->action;

	for (; ;) {
		switch (tbl->action) {
		case IWL_LEGACY_SWITCH_ANTENNA:
			IWL_DEBUG_HT("LQ Legacy switch Antenna\n");

			search_tbl->lq_type = LQ_NONE;
1380
			lq_sta->action_counter++;
1381 1382

			/* Don't change antenna if success has been great */
Z
Zhu Yi 已提交
1383 1384
			if (window->success_ratio >= IWL_RS_GOOD_RATIO)
				break;
1385 1386

			/* Don't change antenna if other one is not connected */
1387
			if (!rs_is_other_ant_connected(lq_sta->antenna,
Z
Zhu Yi 已提交
1388 1389 1390
							tbl->antenna_type))
				break;

1391
			/* Set up search table to try other antenna */
Z
Zhu Yi 已提交
1392 1393 1394 1395
			memcpy(search_tbl, tbl, sz);

			rs_toggle_antenna(&(search_tbl->current_rate),
					   search_tbl);
1396 1397
			rs_get_expected_tpt_table(lq_sta, search_tbl);
			lq_sta->search_better_tbl = 1;
Z
Zhu Yi 已提交
1398 1399 1400 1401
			goto out;

		case IWL_LEGACY_SWITCH_SISO:
			IWL_DEBUG_HT("LQ: Legacy switch to SISO\n");
1402 1403

			/* Set up search table to try SISO */
Z
Zhu Yi 已提交
1404 1405 1406 1407
			memcpy(search_tbl, tbl, sz);
			search_tbl->lq_type = LQ_SISO;
			search_tbl->is_SGI = 0;
			search_tbl->is_fat = 0;
1408
			ret = rs_switch_to_siso(priv, lq_sta, conf, sta,
1409
						 search_tbl, index);
1410
			if (!ret) {
1411 1412
				lq_sta->search_better_tbl = 1;
				lq_sta->action_counter = 0;
Z
Zhu Yi 已提交
1413
				goto out;
1414
			}
Z
Zhu Yi 已提交
1415 1416 1417 1418

			break;
		case IWL_LEGACY_SWITCH_MIMO:
			IWL_DEBUG_HT("LQ: Legacy switch MIMO\n");
1419 1420

			/* Set up search table to try MIMO */
Z
Zhu Yi 已提交
1421 1422 1423 1424 1425
			memcpy(search_tbl, tbl, sz);
			search_tbl->lq_type = LQ_MIMO;
			search_tbl->is_SGI = 0;
			search_tbl->is_fat = 0;
			search_tbl->antenna_type = ANT_BOTH;
1426
			ret = rs_switch_to_mimo(priv, lq_sta, conf, sta,
1427
						 search_tbl, index);
1428
			if (!ret) {
1429 1430
				lq_sta->search_better_tbl = 1;
				lq_sta->action_counter = 0;
Z
Zhu Yi 已提交
1431
				goto out;
1432
			}
Z
Zhu Yi 已提交
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
			break;
		}
		tbl->action++;
		if (tbl->action > IWL_LEGACY_SWITCH_MIMO)
			tbl->action = IWL_LEGACY_SWITCH_ANTENNA;

		if (tbl->action == start_action)
			break;

	}
	return 0;

 out:
	tbl->action++;
	if (tbl->action > IWL_LEGACY_SWITCH_MIMO)
		tbl->action = IWL_LEGACY_SWITCH_ANTENNA;
	return 0;

}

1453 1454 1455
/*
 * Try to switch to new modulation mode from SISO
 */
1456
static int rs_move_siso_to_other(struct iwl_priv *priv,
1457
				 struct iwl4965_lq_sta *lq_sta,
1458 1459
				 struct ieee80211_conf *conf,
				 struct sta_info *sta,
Z
Zhu Yi 已提交
1460 1461
				 int index)
{
1462
	int ret;
1463
	u8 is_green = lq_sta->is_green;
C
Christoph Hellwig 已提交
1464
	struct iwl4965_scale_tbl_info *tbl =
1465
	    &(lq_sta->lq_info[lq_sta->active_tbl]);
C
Christoph Hellwig 已提交
1466
	struct iwl4965_scale_tbl_info *search_tbl =
1467
	    &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
C
Christoph Hellwig 已提交
1468 1469 1470
	struct iwl4965_rate_scale_data *window = &(tbl->win[index]);
	u32 sz = (sizeof(struct iwl4965_scale_tbl_info) -
		  (sizeof(struct iwl4965_rate_scale_data) * IWL_RATE_COUNT));
Z
Zhu Yi 已提交
1471 1472 1473
	u8 start_action = tbl->action;

	for (;;) {
1474
		lq_sta->action_counter++;
Z
Zhu Yi 已提交
1475 1476 1477 1478 1479 1480
		switch (tbl->action) {
		case IWL_SISO_SWITCH_ANTENNA:
			IWL_DEBUG_HT("LQ: SISO SWITCH ANTENNA SISO\n");
			search_tbl->lq_type = LQ_NONE;
			if (window->success_ratio >= IWL_RS_GOOD_RATIO)
				break;
1481
			if (!rs_is_other_ant_connected(lq_sta->antenna,
Z
Zhu Yi 已提交
1482 1483 1484 1485 1486 1487 1488
						       tbl->antenna_type))
				break;

			memcpy(search_tbl, tbl, sz);
			search_tbl->action = IWL_SISO_SWITCH_MIMO;
			rs_toggle_antenna(&(search_tbl->current_rate),
					   search_tbl);
1489
			lq_sta->search_better_tbl = 1;
Z
Zhu Yi 已提交
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499

			goto out;

		case IWL_SISO_SWITCH_MIMO:
			IWL_DEBUG_HT("LQ: SISO SWITCH TO MIMO FROM SISO\n");
			memcpy(search_tbl, tbl, sz);
			search_tbl->lq_type = LQ_MIMO;
			search_tbl->is_SGI = 0;
			search_tbl->is_fat = 0;
			search_tbl->antenna_type = ANT_BOTH;
1500
			ret = rs_switch_to_mimo(priv, lq_sta, conf, sta,
1501
						 search_tbl, index);
1502
			if (!ret) {
1503
				lq_sta->search_better_tbl = 1;
Z
Zhu Yi 已提交
1504
				goto out;
1505
			}
Z
Zhu Yi 已提交
1506 1507 1508
			break;
		case IWL_SISO_SWITCH_GI:
			IWL_DEBUG_HT("LQ: SISO SWITCH TO GI\n");
1509

Z
Zhu Yi 已提交
1510 1511 1512 1513 1514 1515 1516 1517
			memcpy(search_tbl, tbl, sz);
			search_tbl->action = 0;
			if (search_tbl->is_SGI)
				search_tbl->is_SGI = 0;
			else if (!is_green)
				search_tbl->is_SGI = 1;
			else
				break;
1518
			lq_sta->search_better_tbl = 1;
Z
Zhu Yi 已提交
1519 1520
			if ((tbl->lq_type == LQ_SISO) &&
			    (tbl->is_SGI)) {
1521
				s32 tpt = lq_sta->last_tpt / 100;
Z
Zhu Yi 已提交
1522 1523 1524 1525
				if (((!tbl->is_fat) &&
				     (tpt >= expected_tpt_siso20MHz[index])) ||
				    ((tbl->is_fat) &&
				     (tpt >= expected_tpt_siso40MHz[index])))
1526
					lq_sta->search_better_tbl = 0;
Z
Zhu Yi 已提交
1527
			}
1528
			rs_get_expected_tpt_table(lq_sta, search_tbl);
Z
Zhu Yi 已提交
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
			rs_mcs_from_tbl(&search_tbl->current_rate,
					     search_tbl, index, is_green);
			goto out;
		}
		tbl->action++;
		if (tbl->action > IWL_SISO_SWITCH_GI)
			tbl->action = IWL_SISO_SWITCH_ANTENNA;

		if (tbl->action == start_action)
			break;
	}
	return 0;

 out:
	tbl->action++;
	if (tbl->action > IWL_SISO_SWITCH_GI)
		tbl->action = IWL_SISO_SWITCH_ANTENNA;
	return 0;
}

1549 1550 1551
/*
 * Try to switch to new modulation mode from MIMO
 */
1552
static int rs_move_mimo_to_other(struct iwl_priv *priv,
1553
				 struct iwl4965_lq_sta *lq_sta,
1554 1555
				 struct ieee80211_conf *conf,
				 struct sta_info *sta,
Z
Zhu Yi 已提交
1556 1557
				 int index)
{
1558
	int ret;
1559
	s8 is_green = lq_sta->is_green;
C
Christoph Hellwig 已提交
1560
	struct iwl4965_scale_tbl_info *tbl =
1561
	    &(lq_sta->lq_info[lq_sta->active_tbl]);
C
Christoph Hellwig 已提交
1562
	struct iwl4965_scale_tbl_info *search_tbl =
1563
	    &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
C
Christoph Hellwig 已提交
1564 1565
	u32 sz = (sizeof(struct iwl4965_scale_tbl_info) -
		  (sizeof(struct iwl4965_rate_scale_data) * IWL_RATE_COUNT));
Z
Zhu Yi 已提交
1566 1567 1568
	u8 start_action = tbl->action;

	for (;;) {
1569
		lq_sta->action_counter++;
Z
Zhu Yi 已提交
1570 1571 1572 1573
		switch (tbl->action) {
		case IWL_MIMO_SWITCH_ANTENNA_A:
		case IWL_MIMO_SWITCH_ANTENNA_B:
			IWL_DEBUG_HT("LQ: MIMO SWITCH TO SISO\n");
1574

1575

1576
			/* Set up new search table for SISO */
Z
Zhu Yi 已提交
1577 1578 1579 1580 1581 1582 1583 1584 1585
			memcpy(search_tbl, tbl, sz);
			search_tbl->lq_type = LQ_SISO;
			search_tbl->is_SGI = 0;
			search_tbl->is_fat = 0;
			if (tbl->action == IWL_MIMO_SWITCH_ANTENNA_A)
				search_tbl->antenna_type = ANT_MAIN;
			else
				search_tbl->antenna_type = ANT_AUX;

1586
			ret = rs_switch_to_siso(priv, lq_sta, conf, sta,
1587
						 search_tbl, index);
1588
			if (!ret) {
1589
				lq_sta->search_better_tbl = 1;
Z
Zhu Yi 已提交
1590 1591 1592 1593 1594 1595
				goto out;
			}
			break;

		case IWL_MIMO_SWITCH_GI:
			IWL_DEBUG_HT("LQ: MIMO SWITCH TO GI\n");
1596 1597

			/* Set up new search table for MIMO */
Z
Zhu Yi 已提交
1598 1599 1600 1601 1602 1603 1604 1605
			memcpy(search_tbl, tbl, sz);
			search_tbl->lq_type = LQ_MIMO;
			search_tbl->antenna_type = ANT_BOTH;
			search_tbl->action = 0;
			if (search_tbl->is_SGI)
				search_tbl->is_SGI = 0;
			else
				search_tbl->is_SGI = 1;
1606
			lq_sta->search_better_tbl = 1;
1607 1608 1609 1610 1611 1612 1613

			/*
			 * If active table already uses the fastest possible
			 * modulation (dual stream with short guard interval),
			 * and it's working well, there's no need to look
			 * for a better type of modulation!
			 */
Z
Zhu Yi 已提交
1614 1615
			if ((tbl->lq_type == LQ_MIMO) &&
			    (tbl->is_SGI)) {
1616
				s32 tpt = lq_sta->last_tpt / 100;
Z
Zhu Yi 已提交
1617 1618 1619 1620
				if (((!tbl->is_fat) &&
				     (tpt >= expected_tpt_mimo20MHz[index])) ||
				    ((tbl->is_fat) &&
				     (tpt >= expected_tpt_mimo40MHz[index])))
1621
					lq_sta->search_better_tbl = 0;
Z
Zhu Yi 已提交
1622
			}
1623
			rs_get_expected_tpt_table(lq_sta, search_tbl);
Z
Zhu Yi 已提交
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
			rs_mcs_from_tbl(&search_tbl->current_rate,
					     search_tbl, index, is_green);
			goto out;

		}
		tbl->action++;
		if (tbl->action > IWL_MIMO_SWITCH_GI)
			tbl->action = IWL_MIMO_SWITCH_ANTENNA_A;

		if (tbl->action == start_action)
			break;
	}

	return 0;
 out:
	tbl->action++;
	if (tbl->action > IWL_MIMO_SWITCH_GI)
		tbl->action = IWL_MIMO_SWITCH_ANTENNA_A;
	return 0;

}

1646 1647 1648 1649 1650 1651 1652
/*
 * 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)
 */
1653
static void rs_stay_in_table(struct iwl4965_lq_sta *lq_sta)
Z
Zhu Yi 已提交
1654
{
C
Christoph Hellwig 已提交
1655
	struct iwl4965_scale_tbl_info *tbl;
Z
Zhu Yi 已提交
1656 1657 1658 1659
	int i;
	int active_tbl;
	int flush_interval_passed = 0;

1660
	active_tbl = lq_sta->active_tbl;
Z
Zhu Yi 已提交
1661

1662
	tbl = &(lq_sta->lq_info[active_tbl]);
Z
Zhu Yi 已提交
1663

1664
	/* If we've been disallowing search, see if we should now allow it */
1665
	if (lq_sta->stay_in_tbl) {
Z
Zhu Yi 已提交
1666

1667
		/* Elapsed time using current modulation mode */
1668
		if (lq_sta->flush_timer)
Z
Zhu Yi 已提交
1669 1670
			flush_interval_passed =
			    time_after(jiffies,
1671
				       (unsigned long)(lq_sta->flush_timer +
Z
Zhu Yi 已提交
1672 1673
					IWL_RATE_SCALE_FLUSH_INTVL));

1674
		/* For now, disable the elapsed time criterion */
Z
Zhu Yi 已提交
1675
		flush_interval_passed = 0;
1676 1677 1678 1679 1680 1681 1682 1683 1684

		/*
		 * 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.
		 */
1685 1686 1687
		if ((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)
Z
Zhu Yi 已提交
1688 1689
		     && (flush_interval_passed))) {
			IWL_DEBUG_HT("LQ: stay is expired %d %d %d\n:",
1690 1691
				     lq_sta->total_failed,
				     lq_sta->total_success,
Z
Zhu Yi 已提交
1692
				     flush_interval_passed);
1693 1694

			/* Allow search for new mode */
1695 1696 1697 1698
			lq_sta->stay_in_tbl = 0;	/* only place reset */
			lq_sta->total_failed = 0;
			lq_sta->total_success = 0;
			lq_sta->flush_timer = 0;
1699 1700 1701 1702 1703 1704 1705

		/*
		 * 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.
		 */
1706
		} else {
1707 1708 1709 1710
			lq_sta->table_count++;
			if (lq_sta->table_count >=
			    lq_sta->table_count_limit) {
				lq_sta->table_count = 0;
Z
Zhu Yi 已提交
1711 1712 1713 1714 1715 1716 1717 1718

				IWL_DEBUG_HT("LQ: stay in table clear win\n");
				for (i = 0; i < IWL_RATE_COUNT; i++)
					rs_rate_scale_clear_window(
						&(tbl->win[i]));
			}
		}

1719 1720 1721
		/* If transitioning to allow "search", reset all history
		 * bitmaps and stats in active table (this will become the new
		 * "search" table). */
1722
		if (!lq_sta->stay_in_tbl) {
Z
Zhu Yi 已提交
1723 1724 1725 1726 1727 1728
			for (i = 0; i < IWL_RATE_COUNT; i++)
				rs_rate_scale_clear_window(&(tbl->win[i]));
		}
	}
}

1729 1730 1731
/*
 * Do rate scaling and search for new modulation mode.
 */
1732
static void rs_rate_scale_perform(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1733 1734 1735 1736
				  struct net_device *dev,
				  struct ieee80211_hdr *hdr,
				  struct sta_info *sta)
{
1737 1738 1739
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct ieee80211_hw *hw = local_to_hw(local);
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
1740 1741 1742 1743
	int low = IWL_RATE_INVALID;
	int high = IWL_RATE_INVALID;
	int index;
	int i;
C
Christoph Hellwig 已提交
1744
	struct iwl4965_rate_scale_data *window = NULL;
Z
Zhu Yi 已提交
1745 1746 1747 1748 1749 1750 1751
	int current_tpt = IWL_INVALID_VALUE;
	int low_tpt = IWL_INVALID_VALUE;
	int high_tpt = IWL_INVALID_VALUE;
	u32 fail_count;
	s8 scale_action = 0;
	u16 fc, rate_mask;
	u8 update_lq = 0;
1752
	struct iwl4965_lq_sta *lq_sta;
C
Christoph Hellwig 已提交
1753
	struct iwl4965_scale_tbl_info *tbl, *tbl1;
Z
Zhu Yi 已提交
1754
	u16 rate_scale_index_msk = 0;
C
Christoph Hellwig 已提交
1755
	struct iwl4965_rate mcs_rate;
Z
Zhu Yi 已提交
1756 1757 1758 1759
	u8 is_green = 0;
	u8 active_tbl = 0;
	u8 done_search = 0;
	u16 high_low;
1760 1761 1762 1763
#ifdef CONFIG_IWL4965_HT
	u8 tid = MAX_TID_COUNT;
	__le16 *qc;
#endif
Z
Zhu Yi 已提交
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781

	IWL_DEBUG_RATE("rate scale calculate new rate for skb\n");

	fc = le16_to_cpu(hdr->frame_control);
	if (!ieee80211_is_data(fc) || is_multicast_ether_addr(hdr->addr1)) {
		/* Send management frames and broadcast/multicast data using
		 * lowest rate. */
		/* TODO: this could probably be improved.. */
		return;
	}

	if (!sta || !sta->rate_ctrl_priv)
		return;

	if (!priv->lq_mngr.lq_ready) {
		IWL_DEBUG_RATE("still rate scaling not ready\n");
		return;
	}
1782
	lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
Z
Zhu Yi 已提交
1783

1784 1785 1786 1787 1788 1789 1790
#ifdef CONFIG_IWL4965_HT
	qc = ieee80211_get_qos_ctrl(hdr);
	if (qc) {
		tid = (u8)(le16_to_cpu(*qc) & 0xf);
		rs_tl_add_packet(lq_sta, tid);
	}
#endif
1791 1792 1793 1794 1795
	/*
	 * 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.
	 */
1796 1797
	if (!lq_sta->search_better_tbl)
		active_tbl = lq_sta->active_tbl;
Z
Zhu Yi 已提交
1798
	else
1799
		active_tbl = 1 - lq_sta->active_tbl;
Z
Zhu Yi 已提交
1800

1801 1802
	tbl = &(lq_sta->lq_info[active_tbl]);
	is_green = lq_sta->is_green;
Z
Zhu Yi 已提交
1803

1804
	/* current tx rate */
1805
	index = sta->last_txrate_idx;
Z
Zhu Yi 已提交
1806 1807 1808 1809

	IWL_DEBUG_RATE("Rate scale index %d for type %d\n", index,
		       tbl->lq_type);

1810
	/* rates available for this association, and for modulation mode */
1811
	rs_get_supported_rates(lq_sta, hdr, tbl->lq_type,
Z
Zhu Yi 已提交
1812 1813 1814 1815 1816 1817
				&rate_mask);

	IWL_DEBUG_RATE("mask 0x%04X \n", rate_mask);

	/* mask with station rate restriction */
	if (is_legacy(tbl->lq_type)) {
1818
		if (lq_sta->band == IEEE80211_BAND_5GHZ)
1819
			/* supp_rates has no CCK bits in A mode */
Z
Zhu Yi 已提交
1820
			rate_scale_index_msk = (u16) (rate_mask &
1821
				(lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
Z
Zhu Yi 已提交
1822 1823
		else
			rate_scale_index_msk = (u16) (rate_mask &
1824
						      lq_sta->supp_rates);
Z
Zhu Yi 已提交
1825 1826 1827 1828 1829 1830 1831

	} else
		rate_scale_index_msk = rate_mask;

	if (!rate_scale_index_msk)
		rate_scale_index_msk = rate_mask;

1832 1833
	/* If current rate is no longer supported on current association,
	 * or user changed preferences for rates, find a new supported rate. */
Z
Zhu Yi 已提交
1834 1835 1836 1837
	if (index < 0 || !((1 << index) & rate_scale_index_msk)) {
		index = IWL_INVALID_VALUE;
		update_lq = 1;

1838
		/* get the highest available rate */
Z
Zhu Yi 已提交
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849
		for (i = 0; i <= IWL_RATE_COUNT; i++) {
			if ((1 << i) & rate_scale_index_msk)
				index = i;
		}

		if (index == IWL_INVALID_VALUE) {
			IWL_WARNING("Can not find a suitable rate\n");
			return;
		}
	}

1850
	/* Get expected throughput table and history window for current rate */
Z
Zhu Yi 已提交
1851
	if (!tbl->expected_tpt)
1852
		rs_get_expected_tpt_table(lq_sta, tbl);
Z
Zhu Yi 已提交
1853 1854 1855

	window = &(tbl->win[index]);

1856 1857 1858 1859 1860 1861 1862
	/*
	 * 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).
	 */
Z
Zhu Yi 已提交
1863 1864 1865 1866 1867 1868 1869
	fail_count = window->counter - window->success_counter;
	if (((fail_count < IWL_RATE_MIN_FAILURE_TH) &&
	     (window->success_counter < IWL_RATE_MIN_SUCCESS_TH))
	    || (tbl->expected_tpt == NULL)) {
		IWL_DEBUG_RATE("LQ: still below TH succ %d total %d "
			       "for index %d\n",
			       window->success_counter, window->counter, index);
1870 1871

		/* Can't calculate this yet; not enough history */
Z
Zhu Yi 已提交
1872
		window->average_tpt = IWL_INVALID_VALUE;
1873 1874 1875

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

		/* Set up new rate table in uCode, if needed */
Z
Zhu Yi 已提交
1879 1880
		if (update_lq) {
			rs_mcs_from_tbl(&mcs_rate, tbl, index, is_green);
1881 1882
			rs_fill_link_cmd(lq_sta, &mcs_rate, &lq_sta->lq);
			rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
Z
Zhu Yi 已提交
1883 1884 1885
		}
		goto out;

1886 1887
	/* Else we have enough samples; calculate estimate of
	 * actual average throughput */
Z
Zhu Yi 已提交
1888 1889 1890 1891
	} else
		window->average_tpt = ((window->success_ratio *
					tbl->expected_tpt[index] + 64) / 128);

1892
	/* If we are searching for better modulation mode, check success. */
1893
	if (lq_sta->search_better_tbl) {
Z
Zhu Yi 已提交
1894 1895
		int success_limit = IWL_RATE_SCALE_SWITCH;

1896 1897 1898
		/* 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. */
Z
Zhu Yi 已提交
1899
		if ((window->success_ratio > success_limit) ||
1900
		    (window->average_tpt > lq_sta->last_tpt)) {
Z
Zhu Yi 已提交
1901 1902 1903 1904 1905 1906
			if (!is_legacy(tbl->lq_type)) {
				IWL_DEBUG_HT("LQ: we are switching to HT"
					     " rate suc %d current tpt %d"
					     " old tpt %d\n",
					     window->success_ratio,
					     window->average_tpt,
1907 1908
					     lq_sta->last_tpt);
				lq_sta->enable_counter = 1;
Z
Zhu Yi 已提交
1909
			}
1910
			/* Swap tables; "search" becomes "active" */
1911
			lq_sta->active_tbl = active_tbl;
Z
Zhu Yi 已提交
1912
			current_tpt = window->average_tpt;
1913 1914

		/* Else poor success; go back to mode in "active" table */
Z
Zhu Yi 已提交
1915
		} else {
1916
			/* Nullify "search" table */
Z
Zhu Yi 已提交
1917
			tbl->lq_type = LQ_NONE;
1918 1919

			/* Revert to "active" table */
1920 1921
			active_tbl = lq_sta->active_tbl;
			tbl = &(lq_sta->lq_info[active_tbl]);
Z
Zhu Yi 已提交
1922

1923
			/* Revert to "active" rate and throughput info */
1924
			index = iwl4965_hwrate_to_plcp_idx(
Z
Zhu Yi 已提交
1925
				tbl->current_rate.rate_n_flags);
1926
			current_tpt = lq_sta->last_tpt;
Z
Zhu Yi 已提交
1927

1928
			/* Need to set up a new rate table in uCode */
Z
Zhu Yi 已提交
1929 1930 1931
			update_lq = 1;
			IWL_DEBUG_HT("XXY GO BACK TO OLD TABLE\n");
		}
1932 1933 1934

		/* Either way, we've made a decision; modulation mode
		 * search is done, allow rate adjustment next time. */
1935
		lq_sta->search_better_tbl = 0;
1936
		done_search = 1;	/* Don't switch modes below! */
Z
Zhu Yi 已提交
1937 1938 1939
		goto lq_update;
	}

1940 1941
	/* (Else) not in search of better modulation mode, try for better
	 * starting rate, while staying in this mode. */
Z
Zhu Yi 已提交
1942 1943 1944 1945 1946
	high_low = rs_get_adjacent_rate(index, rate_scale_index_msk,
					tbl->lq_type);
	low = high_low & 0xff;
	high = (high_low >> 8) & 0xff;

1947
	/* Collect measured throughputs for current and adjacent rates */
Z
Zhu Yi 已提交
1948 1949 1950 1951 1952 1953
	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;

1954
	/* Assume rate increase */
Z
Zhu Yi 已提交
1955 1956
	scale_action = 1;

1957
	/* Too many failures, decrease rate */
Z
Zhu Yi 已提交
1958 1959 1960 1961
	if ((window->success_ratio <= IWL_RATE_DECREASE_TH) ||
	    (current_tpt == 0)) {
		IWL_DEBUG_RATE("decrease rate because of low success_ratio\n");
		scale_action = -1;
1962 1963

	/* No throughput measured yet for adjacent rates; try increase. */
Z
Zhu Yi 已提交
1964 1965 1966
	} else if ((low_tpt == IWL_INVALID_VALUE) &&
		   (high_tpt == IWL_INVALID_VALUE))
		scale_action = 1;
1967 1968 1969

	/* Both adjacent throughputs are measured, but neither one has better
	 * throughput; we're using the best rate, don't change it! */
Z
Zhu Yi 已提交
1970 1971 1972 1973 1974
	else if ((low_tpt != IWL_INVALID_VALUE) &&
		 (high_tpt != IWL_INVALID_VALUE) &&
		 (low_tpt < current_tpt) &&
		 (high_tpt < current_tpt))
		scale_action = 0;
1975 1976 1977

	/* At least one adjacent rate's throughput is measured,
	 * and may have better performance. */
Z
Zhu Yi 已提交
1978
	else {
1979
		/* Higher adjacent rate's throughput is measured */
Z
Zhu Yi 已提交
1980
		if (high_tpt != IWL_INVALID_VALUE) {
1981
			/* Higher rate has better throughput */
Z
Zhu Yi 已提交
1982 1983 1984 1985 1986 1987 1988
			if (high_tpt > current_tpt)
				scale_action = 1;
			else {
				IWL_DEBUG_RATE
				    ("decrease rate because of high tpt\n");
				scale_action = -1;
			}
1989 1990

		/* Lower adjacent rate's throughput is measured */
Z
Zhu Yi 已提交
1991
		} else if (low_tpt != IWL_INVALID_VALUE) {
1992
			/* Lower rate has better throughput */
Z
Zhu Yi 已提交
1993 1994 1995 1996 1997 1998 1999 2000 2001
			if (low_tpt > current_tpt) {
				IWL_DEBUG_RATE
				    ("decrease rate because of low tpt\n");
				scale_action = -1;
			} else
				scale_action = 1;
		}
	}

2002 2003
	/* Sanity check; asked for decrease, but success rate or throughput
	 * has been good at old rate.  Don't change it. */
Z
Zhu Yi 已提交
2004 2005 2006 2007 2008
	if (scale_action == -1) {
		if ((low != IWL_RATE_INVALID) &&
		    ((window->success_ratio > IWL_RATE_HIGH_TH) ||
		     (current_tpt > (100 * tbl->expected_tpt[low]))))
			scale_action = 0;
2009 2010 2011

	/* Sanity check; asked for increase, but success rate has not been great
	 * even at old rate, higher rate will be worse.  Don't change it. */
Z
Zhu Yi 已提交
2012 2013 2014 2015 2016 2017
	} else if ((scale_action == 1) &&
		   (window->success_ratio < IWL_RATE_INCREASE_TH))
		scale_action = 0;

	switch (scale_action) {
	case -1:
2018
		/* Decrease starting rate, update uCode's rate table */
Z
Zhu Yi 已提交
2019 2020 2021 2022 2023 2024
		if (low != IWL_RATE_INVALID) {
			update_lq = 1;
			index = low;
		}
		break;
	case 1:
2025
		/* Increase starting rate, update uCode's rate table */
Z
Zhu Yi 已提交
2026 2027 2028 2029 2030 2031 2032
		if (high != IWL_RATE_INVALID) {
			update_lq = 1;
			index = high;
		}

		break;
	case 0:
2033
		/* No change */
Z
Zhu Yi 已提交
2034 2035 2036 2037 2038 2039 2040 2041 2042
	default:
		break;
	}

	IWL_DEBUG_HT("choose rate scale index %d action %d low %d "
		    "high %d type %d\n",
		     index, scale_action, low, high, tbl->lq_type);

 lq_update:
2043
	/* Replace uCode's rate table for the destination station. */
Z
Zhu Yi 已提交
2044 2045
	if (update_lq) {
		rs_mcs_from_tbl(&mcs_rate, tbl, index, is_green);
2046 2047
		rs_fill_link_cmd(lq_sta, &mcs_rate, &lq_sta->lq);
		rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
Z
Zhu Yi 已提交
2048
	}
2049 2050

	/* Should we stay with this modulation mode, or search for a new one? */
2051
	rs_stay_in_table(lq_sta);
Z
Zhu Yi 已提交
2052

2053 2054 2055 2056 2057 2058
	/*
	 * 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
	 */
2059
	if (!update_lq && !done_search && !lq_sta->stay_in_tbl) {
2060
		/* Save current throughput to compare with "search" throughput*/
2061
		lq_sta->last_tpt = current_tpt;
Z
Zhu Yi 已提交
2062

2063 2064
		/* Select a new "search" modulation mode to try.
		 * If one is found, set up the new "search" table. */
Z
Zhu Yi 已提交
2065
		if (is_legacy(tbl->lq_type))
2066
			rs_move_legacy_other(priv, lq_sta, conf, sta, index);
Z
Zhu Yi 已提交
2067
		else if (is_siso(tbl->lq_type))
2068
			rs_move_siso_to_other(priv, lq_sta, conf, sta, index);
Z
Zhu Yi 已提交
2069
		else
2070
			rs_move_mimo_to_other(priv, lq_sta, conf, sta, index);
Z
Zhu Yi 已提交
2071

2072
		/* If new "search" mode was selected, set up in uCode table */
2073
		if (lq_sta->search_better_tbl) {
2074
			/* Access the "search" table, clear its history. */
2075
			tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
Z
Zhu Yi 已提交
2076 2077 2078
			for (i = 0; i < IWL_RATE_COUNT; i++)
				rs_rate_scale_clear_window(&(tbl->win[i]));

2079
			/* Use new "search" start rate */
2080
			index = iwl4965_hwrate_to_plcp_idx(
Z
Zhu Yi 已提交
2081 2082 2083 2084
					tbl->current_rate.rate_n_flags);

			IWL_DEBUG_HT("Switch current  mcs: %X index: %d\n",
				     tbl->current_rate.rate_n_flags, index);
2085 2086 2087
			rs_fill_link_cmd(lq_sta, &tbl->current_rate,
					 &lq_sta->lq);
			rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
Z
Zhu Yi 已提交
2088 2089
		}

2090 2091 2092 2093 2094
		/* If the "active" (non-search) mode was legacy,
		 * and we've tried switching antennas,
		 * but we haven't been able to try HT modes (not available),
		 * stay with best antenna legacy modulation for a while
		 * before next round of mode comparisons. */
2095
		tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
Z
Zhu Yi 已提交
2096
		if (is_legacy(tbl1->lq_type) &&
2097
#ifdef CONFIG_IWL4965_HT
2098
		   (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)) &&
Z
Zhu Yi 已提交
2099
#endif
2100 2101
		    (lq_sta->action_counter >= 1)) {
			lq_sta->action_counter = 0;
Z
Zhu Yi 已提交
2102
			IWL_DEBUG_HT("LQ: STAY in legacy table\n");
2103
			rs_set_stay_in_table(1, lq_sta);
Z
Zhu Yi 已提交
2104 2105
		}

2106 2107 2108
		/* If we're in an HT mode, and all 3 mode switch actions
		 * have been tried and compared, stay in this best modulation
		 * mode for a while before next round of mode comparisons. */
2109 2110
		if (lq_sta->enable_counter &&
		    (lq_sta->action_counter >= IWL_ACTION_LIMIT)) {
2111 2112 2113 2114 2115 2116
#ifdef CONFIG_IWL4965_HT
			if ((lq_sta->last_tpt > IWL_AGG_TPT_THREHOLD) &&
			    (lq_sta->tx_agg_tid_en & (1 << tid)) &&
			    (tid != MAX_TID_COUNT)) {
				IWL_DEBUG_HT("try to aggregate tid %d\n", tid);
				rs_tl_turn_on_agg(priv, tid, lq_sta, sta);
Z
Zhu Yi 已提交
2117
			}
2118
#endif /*CONFIG_IWL4965_HT */
2119 2120
			lq_sta->action_counter = 0;
			rs_set_stay_in_table(0, lq_sta);
Z
Zhu Yi 已提交
2121
		}
2122 2123 2124 2125 2126 2127 2128 2129

	/*
	 * Else, don't search for a new modulation mode.
	 * Put new timestamp in stay-in-modulation-mode flush timer if:
	 * 1)  Not changing rates right now
	 * 2)  Not just finishing up a search
	 * 3)  flush timer is empty
	 */
Z
Zhu Yi 已提交
2130
	} else {
2131 2132
		if ((!update_lq) && (!done_search) && (!lq_sta->flush_timer))
			lq_sta->flush_timer = jiffies;
Z
Zhu Yi 已提交
2133 2134 2135 2136 2137
	}

out:
	rs_mcs_from_tbl(&tbl->current_rate, tbl, index, is_green);
	i = index;
2138
	sta->last_txrate_idx = i;
Z
Zhu Yi 已提交
2139

2140
	/* sta->txrate_idx is an index to A mode rates which start
Z
Zhu Yi 已提交
2141 2142
	 * at IWL_FIRST_OFDM_RATE
	 */
2143 2144
	if (lq_sta->band == IEEE80211_BAND_5GHZ)
		sta->txrate_idx = i - IWL_FIRST_OFDM_RATE;
Z
Zhu Yi 已提交
2145
	else
2146
		sta->txrate_idx = i;
Z
Zhu Yi 已提交
2147 2148 2149 2150 2151

	return;
}


2152
static void rs_initialize_lq(struct iwl_priv *priv,
2153
			     struct ieee80211_conf *conf,
Z
Zhu Yi 已提交
2154 2155 2156
			     struct sta_info *sta)
{
	int i;
2157
	struct iwl4965_lq_sta *lq_sta;
C
Christoph Hellwig 已提交
2158
	struct iwl4965_scale_tbl_info *tbl;
Z
Zhu Yi 已提交
2159 2160
	u8 active_tbl = 0;
	int rate_idx;
2161
	u8 use_green = rs_use_green(priv, conf);
C
Christoph Hellwig 已提交
2162
	struct iwl4965_rate mcs_rate;
Z
Zhu Yi 已提交
2163 2164 2165 2166

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

2167
	lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
2168
	i = sta->last_txrate_idx;
Z
Zhu Yi 已提交
2169

2170
	if ((lq_sta->lq.sta_id == 0xff) &&
Z
Zhu Yi 已提交
2171 2172 2173
	    (priv->iw_mode == IEEE80211_IF_TYPE_IBSS))
		goto out;

2174 2175
	if (!lq_sta->search_better_tbl)
		active_tbl = lq_sta->active_tbl;
Z
Zhu Yi 已提交
2176
	else
2177
		active_tbl = 1 - lq_sta->active_tbl;
Z
Zhu Yi 已提交
2178

2179
	tbl = &(lq_sta->lq_info[active_tbl]);
Z
Zhu Yi 已提交
2180 2181 2182 2183

	if ((i < 0) || (i >= IWL_RATE_COUNT))
		i = 0;

C
Christoph Hellwig 已提交
2184
	mcs_rate.rate_n_flags = iwl4965_rates[i].plcp ;
Z
Zhu Yi 已提交
2185 2186 2187 2188 2189 2190 2191
	mcs_rate.rate_n_flags |= RATE_MCS_ANT_B_MSK;
	mcs_rate.rate_n_flags &= ~RATE_MCS_ANT_A_MSK;

	if (i >= IWL_FIRST_CCK_RATE && i <= IWL_LAST_CCK_RATE)
		mcs_rate.rate_n_flags |= RATE_MCS_CCK_MSK;

	tbl->antenna_type = ANT_AUX;
2192
	rs_get_tbl_info_from_mcs(&mcs_rate, priv->band, tbl, &rate_idx);
Z
Zhu Yi 已提交
2193
	if (!rs_is_ant_connected(priv->valid_antenna, tbl->antenna_type))
2194
	    rs_toggle_antenna(&mcs_rate, tbl);
Z
Zhu Yi 已提交
2195 2196 2197

	rs_mcs_from_tbl(&mcs_rate, tbl, rate_idx, use_green);
	tbl->current_rate.rate_n_flags = mcs_rate.rate_n_flags;
2198 2199 2200
	rs_get_expected_tpt_table(lq_sta, tbl);
	rs_fill_link_cmd(lq_sta, &mcs_rate, &lq_sta->lq);
	rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
Z
Zhu Yi 已提交
2201 2202 2203 2204
 out:
	return;
}

2205
static void rs_get_rate(void *priv_rate, struct net_device *dev,
2206 2207
			struct ieee80211_supported_band *sband,
			struct sk_buff *skb,
2208
			struct rate_selection *sel)
Z
Zhu Yi 已提交
2209 2210 2211 2212
{

	int i;
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2213
	struct ieee80211_conf *conf = &local->hw.conf;
Z
Zhu Yi 已提交
2214 2215
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
	struct sta_info *sta;
2216
	u16 fc;
2217
	struct iwl_priv *priv = (struct iwl_priv *)priv_rate;
2218
	struct iwl4965_lq_sta *lq_sta;
Z
Zhu Yi 已提交
2219

2220
	IWL_DEBUG_RATE_LIMIT("rate scale calculate new rate for skb\n");
Z
Zhu Yi 已提交
2221

2222 2223
	rcu_read_lock();

Z
Zhu Yi 已提交
2224 2225
	sta = sta_info_get(local, hdr->addr1);

2226 2227 2228 2229 2230
	/* Send management frames and broadcast/multicast data using lowest
	 * rate. */
	fc = le16_to_cpu(hdr->frame_control);
	if (!ieee80211_is_data(fc) || is_multicast_ether_addr(hdr->addr1) ||
	    !sta || !sta->rate_ctrl_priv) {
2231
		sel->rate = rate_lowest(local, sband, sta);
2232
		goto out;
Z
Zhu Yi 已提交
2233 2234
	}

2235
	lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
2236
	i = sta->last_txrate_idx;
Z
Zhu Yi 已提交
2237

2238 2239
	if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
	    !lq_sta->ibss_sta_added) {
C
Christoph Hellwig 已提交
2240
		u8 sta_id = iwl4965_hw_find_station(priv, hdr->addr1);
2241
		DECLARE_MAC_BUF(mac);
Z
Zhu Yi 已提交
2242 2243

		if (sta_id == IWL_INVALID_STATION) {
2244 2245
			IWL_DEBUG_RATE("LQ: ADD station %s\n",
				       print_mac(mac, hdr->addr1));
2246 2247
			sta_id = iwl4965_add_station_flags(priv, hdr->addr1,
							0, CMD_ASYNC, NULL);
Z
Zhu Yi 已提交
2248 2249
		}
		if ((sta_id != IWL_INVALID_STATION)) {
2250 2251 2252
			lq_sta->lq.sta_id = sta_id;
			lq_sta->lq.rs_table[0].rate_n_flags = 0;
			lq_sta->ibss_sta_added = 1;
2253
			rs_initialize_lq(priv, conf, sta);
Z
Zhu Yi 已提交
2254
		}
2255
		if (!lq_sta->ibss_sta_added)
Z
Zhu Yi 已提交
2256 2257 2258
			goto done;
	}

2259
done:
2260
	if ((i < 0) || (i > IWL_RATE_COUNT)) {
2261
		sel->rate = rate_lowest(local, sband, sta);
2262
		goto out;
2263
	}
Z
Zhu Yi 已提交
2264

2265
	sel->rate = &priv->ieee_rates[i];
2266 2267
out:
	rcu_read_unlock();
Z
Zhu Yi 已提交
2268 2269 2270 2271
}

static void *rs_alloc_sta(void *priv, gfp_t gfp)
{
2272
	struct iwl4965_lq_sta *lq_sta;
Z
Zhu Yi 已提交
2273 2274 2275 2276
	int i, j;

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

2277
	lq_sta = kzalloc(sizeof(struct iwl4965_lq_sta), gfp);
Z
Zhu Yi 已提交
2278

2279
	if (lq_sta == NULL)
Z
Zhu Yi 已提交
2280
		return NULL;
2281
	lq_sta->lq.sta_id = 0xff;
Z
Zhu Yi 已提交
2282

2283

Z
Zhu Yi 已提交
2284 2285
	for (j = 0; j < LQ_SIZE; j++)
		for (i = 0; i < IWL_RATE_COUNT; i++)
2286
			rs_rate_scale_clear_window(&(lq_sta->lq_info[j].win[i]));
Z
Zhu Yi 已提交
2287

2288
	return lq_sta;
Z
Zhu Yi 已提交
2289 2290 2291 2292 2293 2294 2295
}

static void rs_rate_init(void *priv_rate, void *priv_sta,
			 struct ieee80211_local *local,
			 struct sta_info *sta)
{
	int i, j;
2296
	struct ieee80211_conf *conf = &local->hw.conf;
2297
	struct ieee80211_supported_band *sband;
2298
	struct iwl_priv *priv = (struct iwl_priv *)priv_rate;
2299
	struct iwl4965_lq_sta *lq_sta = priv_sta;
Z
Zhu Yi 已提交
2300

2301 2302
	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

2303
	lq_sta->flush_timer = 0;
2304 2305
	lq_sta->supp_rates = sta->supp_rates[sband->band];
	sta->txrate_idx = 3;
Z
Zhu Yi 已提交
2306 2307
	for (j = 0; j < LQ_SIZE; j++)
		for (i = 0; i < IWL_RATE_COUNT; i++)
2308
			rs_rate_scale_clear_window(&(lq_sta->lq_info[j].win[i]));
Z
Zhu Yi 已提交
2309 2310 2311 2312 2313 2314 2315

	IWL_DEBUG_RATE("rate scale global init\n");
	/* 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.. */

2316
	lq_sta->ibss_sta_added = 0;
Z
Zhu Yi 已提交
2317
	if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
C
Christoph Hellwig 已提交
2318
		u8 sta_id = iwl4965_hw_find_station(priv, sta->addr);
2319 2320
		DECLARE_MAC_BUF(mac);

Z
Zhu Yi 已提交
2321
		/* for IBSS the call are from tasklet */
2322 2323
		IWL_DEBUG_HT("LQ: ADD station %s\n",
			     print_mac(mac, sta->addr));
Z
Zhu Yi 已提交
2324 2325

		if (sta_id == IWL_INVALID_STATION) {
2326 2327
			IWL_DEBUG_RATE("LQ: ADD station %s\n",
				       print_mac(mac, sta->addr));
2328 2329
			sta_id = iwl4965_add_station_flags(priv, sta->addr,
							0, CMD_ASYNC, NULL);
Z
Zhu Yi 已提交
2330 2331
		}
		if ((sta_id != IWL_INVALID_STATION)) {
2332 2333
			lq_sta->lq.sta_id = sta_id;
			lq_sta->lq.rs_table[0].rate_n_flags = 0;
Z
Zhu Yi 已提交
2334 2335 2336 2337 2338
		}
		/* FIXME: this is w/a remove it later */
		priv->assoc_station_added = 1;
	}

2339
	/* Find highest tx rate supported by hardware and destination station */
2340 2341 2342 2343 2344 2345
	for (i = 0; i < sband->n_bitrates; i++)
		if (sta->supp_rates[sband->band] & BIT(i))
			sta->txrate_idx = i;

	sta->last_txrate_idx = sta->txrate_idx;
	/* WTF is with this bogus comment? A doesn't have cck rates */
2346
	/* For MODE_IEEE80211A, cck rates are at end of rate table */
2347 2348
	if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ)
		sta->last_txrate_idx += IWL_FIRST_OFDM_RATE;
Z
Zhu Yi 已提交
2349

2350 2351 2352 2353 2354 2355 2356
	lq_sta->is_dup = 0;
	lq_sta->valid_antenna = priv->valid_antenna;
	lq_sta->antenna = priv->antenna;
	lq_sta->is_green = rs_use_green(priv, conf);
	lq_sta->active_rate = priv->active_rate;
	lq_sta->active_rate &= ~(0x1000);
	lq_sta->active_rate_basic = priv->active_rate_basic;
2357
	lq_sta->band = priv->band;
2358
#ifdef CONFIG_IWL4965_HT
2359 2360 2361 2362
	/*
	 * 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.
	 */
2363 2364
	lq_sta->active_siso_rate = (priv->current_ht_config.supp_mcs_set[0] << 1);
	lq_sta->active_siso_rate |=
2365
			(priv->current_ht_config.supp_mcs_set[0] & 0x1);
2366 2367 2368
	lq_sta->active_siso_rate &= ~((u16)0x2);
	lq_sta->active_siso_rate =
			lq_sta->active_siso_rate << IWL_FIRST_OFDM_RATE;
Z
Zhu Yi 已提交
2369

2370
	/* Same here */
2371 2372
	lq_sta->active_mimo_rate = (priv->current_ht_config.supp_mcs_set[1] << 1);
	lq_sta->active_mimo_rate |=
2373
			(priv->current_ht_config.supp_mcs_set[1] & 0x1);
2374 2375 2376 2377 2378 2379
	lq_sta->active_mimo_rate &= ~((u16)0x2);
	lq_sta->active_mimo_rate =
			lq_sta->active_mimo_rate << IWL_FIRST_OFDM_RATE;
	IWL_DEBUG_HT("SISO RATE 0x%X MIMO RATE 0x%X\n",
		     lq_sta->active_siso_rate,
		     lq_sta->active_mimo_rate);
2380 2381
	/* as default allow aggregation for all tids */
	lq_sta->tx_agg_tid_en = IWL_AGG_ALL_TID;
2382
#endif /*CONFIG_IWL4965_HT*/
2383
#ifdef CONFIG_MAC80211_DEBUGFS
2384
	lq_sta->drv = priv;
2385
#endif
Z
Zhu Yi 已提交
2386 2387 2388 2389

	if (priv->assoc_station_added)
		priv->lq_mngr.lq_ready = 1;

2390
	rs_initialize_lq(priv, conf, sta);
Z
Zhu Yi 已提交
2391 2392
}

2393
static void rs_fill_link_cmd(struct iwl4965_lq_sta *lq_sta,
C
Christoph Hellwig 已提交
2394 2395
			    struct iwl4965_rate *tx_mcs,
			    struct iwl4965_link_quality_cmd *lq_cmd)
Z
Zhu Yi 已提交
2396 2397 2398
{
	int index = 0;
	int rate_idx;
2399
	int repeat_rate = 0;
Z
Zhu Yi 已提交
2400 2401
	u8 ant_toggle_count = 0;
	u8 use_ht_possible = 1;
C
Christoph Hellwig 已提交
2402 2403
	struct iwl4965_rate new_rate;
	struct iwl4965_scale_tbl_info tbl_type = { 0 };
Z
Zhu Yi 已提交
2404

2405
	/* Override starting rate (index 0) if needed for debug purposes */
2406
	rs_dbgfs_set_mcs(lq_sta, tx_mcs, index);
2407

2408
	/* Interpret rate_n_flags */
2409
	rs_get_tbl_info_from_mcs(tx_mcs, lq_sta->band,
Z
Zhu Yi 已提交
2410 2411
				  &tbl_type, &rate_idx);

2412
	/* How many times should we repeat the initial rate? */
Z
Zhu Yi 已提交
2413 2414
	if (is_legacy(tbl_type.lq_type)) {
		ant_toggle_count = 1;
2415
		repeat_rate = IWL_NUMBER_TRY;
Z
Zhu Yi 已提交
2416
	} else
2417
		repeat_rate = IWL_HT_NUMBER_TRY;
Z
Zhu Yi 已提交
2418 2419 2420

	lq_cmd->general_params.mimo_delimiter =
			is_mimo(tbl_type.lq_type) ? 1 : 0;
2421 2422

	/* Fill 1st table entry (index 0) */
Z
Zhu Yi 已提交
2423 2424 2425 2426 2427
	lq_cmd->rs_table[index].rate_n_flags =
			cpu_to_le32(tx_mcs->rate_n_flags);
	new_rate.rate_n_flags = tx_mcs->rate_n_flags;

	if (is_mimo(tbl_type.lq_type) || (tbl_type.antenna_type == ANT_MAIN))
2428 2429
		lq_cmd->general_params.single_stream_ant_msk
			= LINK_QUAL_ANT_A_MSK;
Z
Zhu Yi 已提交
2430
	else
2431 2432
		lq_cmd->general_params.single_stream_ant_msk
			= LINK_QUAL_ANT_B_MSK;
Z
Zhu Yi 已提交
2433 2434

	index++;
2435
	repeat_rate--;
Z
Zhu Yi 已提交
2436

2437
	/* Fill rest of rate table */
Z
Zhu Yi 已提交
2438
	while (index < LINK_QUAL_MAX_RETRY_NUM) {
2439 2440 2441
		/* Repeat initial/next rate.
		 * For legacy IWL_NUMBER_TRY == 1, this loop will not execute.
		 * For HT IWL_HT_NUMBER_TRY == 3, this executes twice. */
2442
		while (repeat_rate > 0 && (index < LINK_QUAL_MAX_RETRY_NUM)) {
Z
Zhu Yi 已提交
2443 2444 2445 2446 2447 2448 2449 2450 2451
			if (is_legacy(tbl_type.lq_type)) {
				if (ant_toggle_count <
				    NUM_TRY_BEFORE_ANTENNA_TOGGLE)
					ant_toggle_count++;
				else {
					rs_toggle_antenna(&new_rate, &tbl_type);
					ant_toggle_count = 1;
				}
			}
2452

2453
			/* Override next rate if needed for debug purposes */
2454
			rs_dbgfs_set_mcs(lq_sta, &new_rate, index);
2455 2456

			/* Fill next table entry */
Z
Zhu Yi 已提交
2457 2458
			lq_cmd->rs_table[index].rate_n_flags =
					cpu_to_le32(new_rate.rate_n_flags);
2459
			repeat_rate--;
Z
Zhu Yi 已提交
2460 2461 2462
			index++;
		}

2463
		rs_get_tbl_info_from_mcs(&new_rate, lq_sta->band, &tbl_type,
Z
Zhu Yi 已提交
2464 2465
						&rate_idx);

2466 2467 2468
		/* Indicate to uCode which entries might be MIMO.
		 * If initial rate was MIMO, this will finally end up
		 * as (IWL_HT_NUMBER_TRY * 2), after 2nd pass, otherwise 0. */
Z
Zhu Yi 已提交
2469 2470 2471
		if (is_mimo(tbl_type.lq_type))
			lq_cmd->general_params.mimo_delimiter = index;

2472
		/* Get next rate */
2473
		rs_get_lower_rate(lq_sta, &tbl_type, rate_idx,
2474
				  use_ht_possible, &new_rate);
Z
Zhu Yi 已提交
2475

2476
		/* How many times should we repeat the next rate? */
Z
Zhu Yi 已提交
2477 2478 2479 2480 2481 2482 2483
		if (is_legacy(tbl_type.lq_type)) {
			if (ant_toggle_count < NUM_TRY_BEFORE_ANTENNA_TOGGLE)
				ant_toggle_count++;
			else {
				rs_toggle_antenna(&new_rate, &tbl_type);
				ant_toggle_count = 1;
			}
2484
			repeat_rate = IWL_NUMBER_TRY;
Z
Zhu Yi 已提交
2485
		} else
2486
			repeat_rate = IWL_HT_NUMBER_TRY;
Z
Zhu Yi 已提交
2487

2488 2489
		/* Don't allow HT rates after next pass.
		 * rs_get_lower_rate() will change type to LQ_A or LQ_G. */
Z
Zhu Yi 已提交
2490 2491
		use_ht_possible = 0;

2492
		/* Override next rate if needed for debug purposes */
2493
		rs_dbgfs_set_mcs(lq_sta, &new_rate, index);
2494 2495

		/* Fill next table entry */
Z
Zhu Yi 已提交
2496 2497 2498 2499
		lq_cmd->rs_table[index].rate_n_flags =
				cpu_to_le32(new_rate.rate_n_flags);

		index++;
2500
		repeat_rate--;
Z
Zhu Yi 已提交
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
	}

	lq_cmd->general_params.dual_stream_ant_msk = 3;
	lq_cmd->agg_params.agg_dis_start_th = 3;
	lq_cmd->agg_params.agg_time_limit = cpu_to_le16(4000);
}

static void *rs_alloc(struct ieee80211_local *local)
{
	return local->hw.priv;
}
/* rate scale requires free function to be implemented */
static void rs_free(void *priv_rate)
{
	return;
}

static void rs_clear(void *priv_rate)
{
2520
	struct iwl_priv *priv = (struct iwl_priv *) priv_rate;
Z
Zhu Yi 已提交
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530

	IWL_DEBUG_RATE("enter\n");

	priv->lq_mngr.lq_ready = 0;

	IWL_DEBUG_RATE("leave\n");
}

static void rs_free_sta(void *priv, void *priv_sta)
{
2531
	struct iwl4965_lq_sta *lq_sta = priv_sta;
Z
Zhu Yi 已提交
2532 2533

	IWL_DEBUG_RATE("enter\n");
2534
	kfree(lq_sta);
Z
Zhu Yi 已提交
2535 2536 2537 2538
	IWL_DEBUG_RATE("leave\n");
}


2539
#ifdef CONFIG_MAC80211_DEBUGFS
2540 2541 2542 2543 2544
static int open_file_generic(struct inode *inode, struct file *file)
{
	file->private_data = inode->i_private;
	return 0;
}
2545
static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
C
Christoph Hellwig 已提交
2546
				struct iwl4965_rate *mcs, int index)
2547
{
2548 2549
	u32 base_rate;

2550
	if (lq_sta->band == IEEE80211_BAND_5GHZ)
2551 2552 2553 2554
		base_rate = 0x800D;
	else
		base_rate = 0x820A;

2555
	if (lq_sta->dbg_fixed.rate_n_flags) {
2556
		if (index < 12)
2557
			mcs->rate_n_flags = lq_sta->dbg_fixed.rate_n_flags;
2558
		else
2559
			mcs->rate_n_flags = base_rate;
2560 2561 2562 2563 2564 2565
		IWL_DEBUG_RATE("Fixed rate ON\n");
		return;
	}

	IWL_DEBUG_RATE("Fixed rate OFF\n");
}
2566

2567 2568 2569
static ssize_t rs_sta_dbgfs_scale_table_write(struct file *file,
			const char __user *user_buf, size_t count, loff_t *ppos)
{
2570
	struct iwl4965_lq_sta *lq_sta = file->private_data;
2571 2572 2573 2574 2575 2576 2577 2578 2579 2580
	char buf[64];
	int buf_size;
	u32 parsed_rate;

	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)
2581
		lq_sta->dbg_fixed.rate_n_flags = parsed_rate;
2582
	else
2583
		lq_sta->dbg_fixed.rate_n_flags = 0;
2584

2585 2586 2587
	lq_sta->active_rate = 0x0FFF;	/* 1 - 54 MBits, includes CCK */
	lq_sta->active_siso_rate = 0x1FD0;	/* 6 - 60 MBits, no 9, no CCK */
	lq_sta->active_mimo_rate = 0x1FD0;	/* 6 - 60 MBits, no 9, no CCK */
2588 2589

	IWL_DEBUG_RATE("sta_id %d rate 0x%X\n",
2590
		lq_sta->lq.sta_id, lq_sta->dbg_fixed.rate_n_flags);
2591

2592 2593 2594
	if (lq_sta->dbg_fixed.rate_n_flags) {
		rs_fill_link_cmd(lq_sta, &lq_sta->dbg_fixed, &lq_sta->lq);
		rs_send_lq_cmd(lq_sta->drv, &lq_sta->lq, CMD_ASYNC);
2595 2596 2597 2598
	}

	return count;
}
2599

2600 2601 2602 2603 2604 2605 2606
static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file,
			char __user *user_buf, size_t count, loff_t *ppos)
{
	char buff[1024];
	int desc = 0;
	int i = 0;

2607
	struct iwl4965_lq_sta *lq_sta = file->private_data;
2608

2609
	desc += sprintf(buff+desc, "sta_id %d\n", lq_sta->lq.sta_id);
2610
	desc += sprintf(buff+desc, "failed=%d success=%d rate=0%X\n",
2611 2612
			lq_sta->total_failed, lq_sta->total_success,
			lq_sta->active_rate);
2613
	desc += sprintf(buff+desc, "fixed rate 0x%X\n",
2614
			lq_sta->dbg_fixed.rate_n_flags);
2615 2616
	desc += sprintf(buff+desc, "general:"
		"flags=0x%X mimo-d=%d s-ant0x%x d-ant=0x%x\n",
2617 2618 2619 2620
		lq_sta->lq.general_params.flags,
		lq_sta->lq.general_params.mimo_delimiter,
		lq_sta->lq.general_params.single_stream_ant_msk,
		lq_sta->lq.general_params.dual_stream_ant_msk);
2621 2622 2623

	desc += sprintf(buff+desc, "agg:"
			"time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
2624 2625 2626
			le16_to_cpu(lq_sta->lq.agg_params.agg_time_limit),
			lq_sta->lq.agg_params.agg_dis_start_th,
			lq_sta->lq.agg_params.agg_frame_cnt_limit);
2627 2628 2629

	desc += sprintf(buff+desc,
			"Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
2630 2631 2632 2633
			lq_sta->lq.general_params.start_rate_index[0],
			lq_sta->lq.general_params.start_rate_index[1],
			lq_sta->lq.general_params.start_rate_index[2],
			lq_sta->lq.general_params.start_rate_index[3]);
2634 2635 2636 2637


	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
		desc += sprintf(buff+desc, " rate[%d] 0x%X\n",
2638
			i, le32_to_cpu(lq_sta->lq.rs_table[i].rate_n_flags));
2639 2640 2641 2642 2643

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

static const struct file_operations rs_sta_dbgfs_scale_table_ops = {
2644
	.write = rs_sta_dbgfs_scale_table_write,
2645 2646 2647
	.read = rs_sta_dbgfs_scale_table_read,
	.open = open_file_generic,
};
2648 2649 2650 2651 2652 2653 2654
static ssize_t rs_sta_dbgfs_stats_table_read(struct file *file,
			char __user *user_buf, size_t count, loff_t *ppos)
{
	char buff[1024];
	int desc = 0;
	int i, j;

2655
	struct iwl4965_lq_sta *lq_sta = file->private_data;
2656 2657 2658
	for (i = 0; i < LQ_SIZE; i++) {
		desc += sprintf(buff+desc, "%s type=%d SGI=%d FAT=%d DUP=%d\n"
				"rate=0x%X\n",
2659 2660 2661 2662 2663 2664
				lq_sta->active_tbl == i?"*":"x",
				lq_sta->lq_info[i].lq_type,
				lq_sta->lq_info[i].is_SGI,
				lq_sta->lq_info[i].is_fat,
				lq_sta->lq_info[i].is_dup,
				lq_sta->lq_info[i].current_rate.rate_n_flags);
2665 2666
		for (j = 0; j < IWL_RATE_COUNT; j++) {
			desc += sprintf(buff+desc,
2667 2668 2669 2670
				"counter=%d success=%d %%=%d\n",
				lq_sta->lq_info[i].win[j].counter,
				lq_sta->lq_info[i].win[j].success_counter,
				lq_sta->lq_info[i].win[j].success_ratio);
2671 2672 2673 2674 2675 2676 2677 2678 2679
		}
	}
	return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
}

static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
	.read = rs_sta_dbgfs_stats_table_read,
	.open = open_file_generic,
};
2680

2681 2682 2683
static void rs_add_debugfs(void *priv, void *priv_sta,
					struct dentry *dir)
{
2684 2685
	struct iwl4965_lq_sta *lq_sta = priv_sta;
	lq_sta->rs_sta_dbgfs_scale_table_file =
2686
		debugfs_create_file("rate_scale_table", 0600, dir,
2687 2688
				lq_sta, &rs_sta_dbgfs_scale_table_ops);
	lq_sta->rs_sta_dbgfs_stats_table_file =
2689
		debugfs_create_file("rate_stats_table", 0600, dir,
2690
			lq_sta, &rs_sta_dbgfs_stats_table_ops);
2691 2692 2693 2694 2695 2696
#ifdef CONFIG_IWL4965_HT
	lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file =
		debugfs_create_u8("tx_agg_tid_enable", 0600, dir,
		&lq_sta->tx_agg_tid_en);
#endif

2697 2698 2699 2700
}

static void rs_remove_debugfs(void *priv, void *priv_sta)
{
2701 2702 2703
	struct iwl4965_lq_sta *lq_sta = priv_sta;
	debugfs_remove(lq_sta->rs_sta_dbgfs_scale_table_file);
	debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
2704 2705 2706
#ifdef CONFIG_IWL4965_HT
	debugfs_remove(lq_sta->rs_sta_dbgfs_tx_agg_tid_en_file);
#endif
2707 2708 2709
}
#endif

Z
Zhu Yi 已提交
2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720
static struct rate_control_ops rs_ops = {
	.module = NULL,
	.name = RS_NAME,
	.tx_status = rs_tx_status,
	.get_rate = rs_get_rate,
	.rate_init = rs_rate_init,
	.clear = rs_clear,
	.alloc = rs_alloc,
	.free = rs_free,
	.alloc_sta = rs_alloc_sta,
	.free_sta = rs_free_sta,
2721 2722 2723 2724
#ifdef CONFIG_MAC80211_DEBUGFS
	.add_sta_debugfs = rs_add_debugfs,
	.remove_sta_debugfs = rs_remove_debugfs,
#endif
Z
Zhu Yi 已提交
2725 2726
};

C
Christoph Hellwig 已提交
2727
int iwl4965_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
Z
Zhu Yi 已提交
2728 2729
{
	struct ieee80211_local *local = hw_to_local(hw);
2730
	struct iwl_priv *priv = hw->priv;
2731
	struct iwl4965_lq_sta *lq_sta;
Z
Zhu Yi 已提交
2732
	struct sta_info *sta;
2733
	int cnt = 0, i;
Z
Zhu Yi 已提交
2734 2735 2736 2737 2738
	u32 samples = 0, success = 0, good = 0;
	unsigned long now = jiffies;
	u32 max_time = 0;
	u8 lq_type, antenna;

2739 2740
	rcu_read_lock();

Z
Zhu Yi 已提交
2741 2742
	sta = sta_info_get(local, priv->stations[sta_id].sta.sta.addr);
	if (!sta || !sta->rate_ctrl_priv) {
2743
		if (sta)
Z
Zhu Yi 已提交
2744
			IWL_DEBUG_RATE("leave - no private rate data!\n");
2745
		else
Z
Zhu Yi 已提交
2746
			IWL_DEBUG_RATE("leave - no station!\n");
2747
		rcu_read_unlock();
Z
Zhu Yi 已提交
2748 2749 2750
		return sprintf(buf, "station %d not found\n", sta_id);
	}

2751
	lq_sta = (void *)sta->rate_ctrl_priv;
Z
Zhu Yi 已提交
2752

2753 2754
	lq_type = lq_sta->lq_info[lq_sta->active_tbl].lq_type;
	antenna = lq_sta->lq_info[lq_sta->active_tbl].antenna_type;
Z
Zhu Yi 已提交
2755 2756 2757 2758 2759 2760 2761 2762

	if (is_legacy(lq_type))
		i = IWL_RATE_54M_INDEX;
	else
		i = IWL_RATE_60M_INDEX;
	while (1) {
		u64 mask;
		int j;
2763
		int active = lq_sta->active_tbl;
Z
Zhu Yi 已提交
2764

2765 2766
		cnt +=
		    sprintf(&buf[cnt], " %2dMbs: ", iwl4965_rates[i].ieee / 2);
Z
Zhu Yi 已提交
2767 2768 2769

		mask = (1ULL << (IWL_RATE_MAX_WINDOW - 1));
		for (j = 0; j < IWL_RATE_MAX_WINDOW; j++, mask >>= 1)
2770 2771
			buf[cnt++] =
				(lq_sta->lq_info[active].win[i].data & mask)
Z
Zhu Yi 已提交
2772 2773
				? '1' : '0';

2774 2775 2776
		samples += lq_sta->lq_info[active].win[i].counter;
		good += lq_sta->lq_info[active].win[i].success_counter;
		success += lq_sta->lq_info[active].win[i].success_counter *
C
Christoph Hellwig 已提交
2777
			   iwl4965_rates[i].ieee;
Z
Zhu Yi 已提交
2778

2779
		if (lq_sta->lq_info[active].win[i].stamp) {
Z
Zhu Yi 已提交
2780 2781
			int delta =
				   jiffies_to_msecs(now -
2782
				   lq_sta->lq_info[active].win[i].stamp);
Z
Zhu Yi 已提交
2783 2784 2785 2786

			if (delta > max_time)
				max_time = delta;

2787
			cnt += sprintf(&buf[cnt], "%5dms\n", delta);
Z
Zhu Yi 已提交
2788
		} else
2789
			buf[cnt++] = '\n';
Z
Zhu Yi 已提交
2790

C
Christoph Hellwig 已提交
2791
		j = iwl4965_get_prev_ieee_rate(i);
Z
Zhu Yi 已提交
2792 2793 2794 2795 2796 2797 2798
		if (j == i)
			break;
		i = j;
	}

	/* Display the average rate of all samples taken.
	 *
2799
	 * NOTE:  We multiply # of samples by 2 since the IEEE measurement
C
Christoph Hellwig 已提交
2800
	 * added from iwl4965_rates is actually 2X the rate */
Z
Zhu Yi 已提交
2801
	if (samples)
2802
		cnt += sprintf(&buf[cnt],
Z
Zhu Yi 已提交
2803 2804 2805 2806 2807
			 "\nAverage rate is %3d.%02dMbs over last %4dms\n"
			 "%3d%% success (%d good packets over %d tries)\n",
			 success / (2 * samples), (success * 5 / samples) % 10,
			 max_time, good * 100 / samples, good, samples);
	else
2808 2809 2810
		cnt += sprintf(&buf[cnt], "\nAverage rate: 0Mbs\n");

	cnt += sprintf(&buf[cnt], "\nrate scale type %d antenna %d "
Z
Zhu Yi 已提交
2811
			 "active_search %d rate index %d\n", lq_type, antenna,
2812
			 lq_sta->search_better_tbl, sta->last_txrate_idx);
Z
Zhu Yi 已提交
2813

2814
	rcu_read_unlock();
2815
	return cnt;
Z
Zhu Yi 已提交
2816 2817
}

C
Christoph Hellwig 已提交
2818
void iwl4965_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
Z
Zhu Yi 已提交
2819
{
2820
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
2821 2822 2823 2824

	priv->lq_mngr.lq_ready = 1;
}

2825
int iwl4965_rate_control_register(void)
Z
Zhu Yi 已提交
2826
{
2827
	return ieee80211_rate_control_register(&rs_ops);
Z
Zhu Yi 已提交
2828 2829
}

2830
void iwl4965_rate_control_unregister(void)
Z
Zhu Yi 已提交
2831 2832 2833 2834
{
	ieee80211_rate_control_unregister(&rs_ops);
}