iwl-sta.c 40.6 KB
Newer Older
1 2
/******************************************************************************
 *
3
 * Copyright(c) 2003 - 2010 Intel Corporation. All rights reserved.
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * Portions of this file are derived from the ipw3945 project, as well
 * as portions of the ieee80211 subsystem header files.
 *
 * 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:
25
 *  Intel Linux Wireless <ilw@linux.intel.com>
26 27 28 29 30
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

#include <net/mac80211.h>
31
#include <linux/etherdevice.h>
32
#include <linux/sched.h>
33

34
#include "iwl-dev.h"
35 36
#include "iwl-core.h"
#include "iwl-sta.h"
37

38 39 40 41 42 43 44
u8 iwl_find_station(struct iwl_priv *priv, const u8 *addr)
{
	int i;
	int start = 0;
	int ret = IWL_INVALID_STATION;
	unsigned long flags;

45 46
	if ((priv->iw_mode == NL80211_IFTYPE_ADHOC) ||
	    (priv->iw_mode == NL80211_IFTYPE_AP))
47 48 49 50 51 52 53 54 55 56 57 58 59 60
		start = IWL_STA_ID;

	if (is_broadcast_ether_addr(addr))
		return priv->hw_params.bcast_sta_id;

	spin_lock_irqsave(&priv->sta_lock, flags);
	for (i = start; i < priv->hw_params.max_stations; i++)
		if (priv->stations[i].used &&
		    (!compare_ether_addr(priv->stations[i].sta.sta.addr,
					 addr))) {
			ret = i;
			goto out;
		}

61
	IWL_DEBUG_ASSOC_LIMIT(priv, "can not find STA %pM total %d\n",
J
Johannes Berg 已提交
62
			      addr, priv->num_stations);
63 64

 out:
65 66 67 68 69 70 71 72 73
	/*
	 * It may be possible that more commands interacting with stations
	 * arrive before we completed processing the adding of
	 * station
	 */
	if (ret != IWL_INVALID_STATION &&
	    (!(priv->stations[ret].used & IWL_STA_UCODE_ACTIVE) ||
	     ((priv->stations[ret].used & IWL_STA_UCODE_ACTIVE) &&
	      (priv->stations[ret].used & IWL_STA_UCODE_INPROGRESS)))) {
74
		IWL_ERR(priv, "Requested station info for sta %d before ready.\n",
75 76 77
			ret);
		ret = IWL_INVALID_STATION;
	}
78 79 80 81 82
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return ret;
}
EXPORT_SYMBOL(iwl_find_station);

83 84
int iwl_get_ra_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
{
85
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
86 87 88
		return IWL_AP_ID;
	} else {
		u8 *da = ieee80211_get_DA(hdr);
89
		return iwl_find_station(priv, da);
90 91 92 93
	}
}
EXPORT_SYMBOL(iwl_get_ra_sta_id);

94
/* priv->sta_lock must be held */
95 96 97
static void iwl_sta_ucode_activate(struct iwl_priv *priv, u8 sta_id)
{

98
	if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE))
99 100
		IWL_ERR(priv, "ACTIVATE a non DRIVER active station id %u addr %pM\n",
			sta_id, priv->stations[sta_id].sta.sta.addr);
101

102 103 104 105 106 107 108 109 110
	if (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) {
		IWL_DEBUG_ASSOC(priv,
				"STA id %u addr %pM already present in uCode (according to driver)\n",
				sta_id, priv->stations[sta_id].sta.sta.addr);
	} else {
		priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE;
		IWL_DEBUG_ASSOC(priv, "Added STA id %u addr %pM to uCode\n",
				sta_id, priv->stations[sta_id].sta.sta.addr);
	}
111 112
}

113 114 115 116
static void iwl_process_add_sta_resp(struct iwl_priv *priv,
				     struct iwl_addsta_cmd *addsta,
				     struct iwl_rx_packet *pkt,
				     bool sync)
117
{
118
	u8 sta_id = addsta->sta.sta_id;
119
	unsigned long flags;
120

Z
Zhu Yi 已提交
121
	if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
122
		IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
123
			pkt->hdr.flags);
124
		return;
125 126
	}

127 128 129 130 131
	IWL_DEBUG_INFO(priv, "Processing response for adding station %u\n",
		       sta_id);

	spin_lock_irqsave(&priv->sta_lock, flags);

Z
Zhu Yi 已提交
132
	switch (pkt->u.add_sta.status) {
133
	case ADD_STA_SUCCESS_MSK:
134
		IWL_DEBUG_INFO(priv, "REPLY_ADD_STA PASSED\n");
135
		iwl_sta_ucode_activate(priv, sta_id);
136 137 138 139 140 141 142 143 144 145
		break;
	case ADD_STA_NO_ROOM_IN_TABLE:
		IWL_ERR(priv, "Adding station %d failed, no room in table.\n",
			sta_id);
		break;
	case ADD_STA_NO_BLOCK_ACK_RESOURCE:
		IWL_ERR(priv, "Adding station %d failed, no block ack resource.\n",
			sta_id);
		break;
	case ADD_STA_MODIFY_NON_EXIST_STA:
146
		IWL_ERR(priv, "Attempting to modify non-existing station %d\n",
147 148
			sta_id);
		break;
149
	default:
150 151
		IWL_DEBUG_ASSOC(priv, "Received REPLY_ADD_STA:(0x%08X)\n",
				pkt->u.add_sta.status);
152 153
		break;
	}
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183

	IWL_DEBUG_INFO(priv, "%s station id %u addr %pM\n",
		       priv->stations[sta_id].sta.mode ==
		       STA_CONTROL_MODIFY_MSK ?  "Modified" : "Added",
		       sta_id, priv->stations[sta_id].sta.sta.addr);

	/*
	 * XXX: The MAC address in the command buffer is often changed from
	 * the original sent to the device. That is, the MAC address
	 * written to the command buffer often is not the same MAC adress
	 * read from the command buffer when the command returns. This
	 * issue has not yet been resolved and this debugging is left to
	 * observe the problem.
	 */
	IWL_DEBUG_INFO(priv, "%s station according to cmd buffer %pM\n",
		       priv->stations[sta_id].sta.mode ==
		       STA_CONTROL_MODIFY_MSK ? "Modified" : "Added",
		       addsta->sta.addr);
	spin_unlock_irqrestore(&priv->sta_lock, flags);
}

static void iwl_add_sta_callback(struct iwl_priv *priv,
				 struct iwl_device_cmd *cmd,
				 struct iwl_rx_packet *pkt)
{
	struct iwl_addsta_cmd *addsta =
		(struct iwl_addsta_cmd *)cmd->cmd.payload;

	iwl_process_add_sta_resp(priv, addsta, pkt, false);

184 185
}

186
int iwl_send_add_sta(struct iwl_priv *priv,
187 188
		     struct iwl_addsta_cmd *sta, u8 flags)
{
Z
Zhu Yi 已提交
189
	struct iwl_rx_packet *pkt = NULL;
190 191 192 193
	int ret = 0;
	u8 data[sizeof(*sta)];
	struct iwl_host_cmd cmd = {
		.id = REPLY_ADD_STA,
J
Johannes Berg 已提交
194
		.flags = flags,
195 196
		.data = data,
	};
197
	u8 sta_id __maybe_unused = sta->sta.sta_id;
198 199 200

	IWL_DEBUG_INFO(priv, "Adding sta %u (%pM) %ssynchronously\n",
		       sta_id, sta->sta.addr, flags & CMD_ASYNC ?  "a" : "");
201

202
	if (flags & CMD_ASYNC)
J
Johannes Berg 已提交
203
		cmd.callback = iwl_add_sta_callback;
204
	else
J
Johannes Berg 已提交
205
		cmd.flags |= CMD_WANT_SKB;
206 207 208 209 210 211 212 213

	cmd.len = priv->cfg->ops->utils->build_addsta_hcmd(sta, data);
	ret = iwl_send_cmd(priv, &cmd);

	if (ret || (flags & CMD_ASYNC))
		return ret;

	if (ret == 0) {
214 215
		pkt = (struct iwl_rx_packet *)cmd.reply_page;
		iwl_process_add_sta_resp(priv, sta, pkt, true);
216
	}
217
	iwl_free_pages(priv, cmd.reply_page);
218 219 220

	return ret;
}
221
EXPORT_SYMBOL(iwl_send_add_sta);
222

223
static void iwl_set_ht_add_station(struct iwl_priv *priv, u8 index,
J
Johannes Berg 已提交
224
				   struct ieee80211_sta_ht_cap *sta_ht_inf)
225 226 227 228 229 230 231
{
	__le32 sta_flags;
	u8 mimo_ps_mode;

	if (!sta_ht_inf || !sta_ht_inf->ht_supported)
		goto done;

232
	mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2;
233 234 235 236 237
	IWL_DEBUG_ASSOC(priv, "spatial multiplexing power save mode: %s\n",
			(mimo_ps_mode == WLAN_HT_CAP_SM_PS_STATIC) ?
			"static" :
			(mimo_ps_mode == WLAN_HT_CAP_SM_PS_DYNAMIC) ?
			"dynamic" : "disabled");
238 239 240 241 242 243

	sta_flags = priv->stations[index].sta.station_flags;

	sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK);

	switch (mimo_ps_mode) {
244
	case WLAN_HT_CAP_SM_PS_STATIC:
245 246
		sta_flags |= STA_FLG_MIMO_DIS_MSK;
		break;
247
	case WLAN_HT_CAP_SM_PS_DYNAMIC:
248 249
		sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK;
		break;
250
	case WLAN_HT_CAP_SM_PS_DISABLED:
251 252
		break;
	default:
253
		IWL_WARN(priv, "Invalid MIMO PS mode %d\n", mimo_ps_mode);
254 255 256 257 258 259 260 261 262
		break;
	}

	sta_flags |= cpu_to_le32(
	      (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);

	sta_flags |= cpu_to_le32(
	      (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);

263 264
	if (iwl_is_ht40_tx_allowed(priv, sta_ht_inf))
		sta_flags |= STA_FLG_HT40_EN_MSK;
265
	else
266
		sta_flags &= ~STA_FLG_HT40_EN_MSK;
267 268 269 270 271 272 273

	priv->stations[index].sta.station_flags = sta_flags;
 done:
	return;
}

/**
274 275 276
 * iwl_prep_station - Prepare station information for addition
 *
 * should be called with sta_lock held
277
 */
278 279 280
static u8 iwl_prep_station(struct iwl_priv *priv, const u8 *addr,
			   bool is_ap,
			   struct ieee80211_sta_ht_cap *ht_info)
281 282
{
	struct iwl_station_entry *station;
283
	int i;
284
	u8 sta_id = IWL_INVALID_STATION;
285
	u16 rate;
286 287

	if (is_ap)
288
		sta_id = IWL_AP_ID;
289
	else if (is_broadcast_ether_addr(addr))
290
		sta_id = priv->hw_params.bcast_sta_id;
291 292 293 294
	else
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++) {
			if (!compare_ether_addr(priv->stations[i].sta.sta.addr,
						addr)) {
295
				sta_id = i;
296 297 298 299
				break;
			}

			if (!priv->stations[i].used &&
300 301
			    sta_id == IWL_INVALID_STATION)
				sta_id = i;
302 303
		}

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
	/*
	 * These two conditions have the same outcome, but keep them
	 * separate
	 */
	if (unlikely(sta_id == IWL_INVALID_STATION))
		return sta_id;

	/*
	 * uCode is not able to deal with multiple requests to add a
	 * station. Keep track if one is in progress so that we do not send
	 * another.
	 */
	if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
		IWL_DEBUG_INFO(priv, "STA %d already in process of being added.\n",
				sta_id);
319
		return sta_id;
320 321
	}

322 323
	if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
	    (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) &&
324
	    !compare_ether_addr(priv->stations[sta_id].sta.sta.addr, addr)) {
325 326
		IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not adding again.\n",
				sta_id, addr);
327
		return sta_id;
328 329
	}

330 331
	station = &priv->stations[sta_id];
	station->used = IWL_STA_DRIVER_ACTIVE;
332
	IWL_DEBUG_ASSOC(priv, "Add STA to driver ID %d: %pM\n",
J
Johannes Berg 已提交
333
			sta_id, addr);
334 335 336 337 338 339
	priv->num_stations++;

	/* Set up the REPLY_ADD_STA command to send to device */
	memset(&station->sta, 0, sizeof(struct iwl_addsta_cmd));
	memcpy(station->sta.sta.addr, addr, ETH_ALEN);
	station->sta.mode = 0;
340
	station->sta.sta.sta_id = sta_id;
341 342 343
	station->sta.station_flags = 0;

	/* BCAST station and IBSS stations do not work in HT mode */
344
	if (sta_id != priv->hw_params.bcast_sta_id &&
345
	    priv->iw_mode != NL80211_IFTYPE_ADHOC)
346
		iwl_set_ht_add_station(priv, sta_id, ht_info);
347

348 349 350 351 352 353
	/* 3945 only */
	rate = (priv->band == IEEE80211_BAND_5GHZ) ?
		IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP;
	/* Turn on both antennas for the station... */
	station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK);

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 392 393 394 395 396 397 398 399 400 401 402 403 404
	return sta_id;

}

#define STA_WAIT_TIMEOUT (HZ/2)

/**
 * iwl_add_station_common -
 */
int iwl_add_station_common(struct iwl_priv *priv, const u8 *addr,
				  bool is_ap,
				  struct ieee80211_sta_ht_cap *ht_info,
				  u8 *sta_id_r)
{
	struct iwl_station_entry *station;
	unsigned long flags_spin;
	int ret = 0;
	u8 sta_id;

	*sta_id_r = 0;
	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	sta_id = iwl_prep_station(priv, addr, is_ap, ht_info);
	if (sta_id == IWL_INVALID_STATION) {
		IWL_ERR(priv, "Unable to prepare station %pM for addition\n",
			addr);
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return -EINVAL;
	}

	/*
	 * uCode is not able to deal with multiple requests to add a
	 * station. Keep track if one is in progress so that we do not send
	 * another.
	 */
	if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
		IWL_DEBUG_INFO(priv, "STA %d already in process of being added.\n",
			       sta_id);
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return -EEXIST;
	}

	if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
	    (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
		IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not adding again.\n",
				sta_id, addr);
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return -EEXIST;
	}

	priv->stations[sta_id].used |= IWL_STA_UCODE_INPROGRESS;
	station = &priv->stations[sta_id];
405 406 407
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);

	/* Add station to device's station table */
408 409 410 411 412 413 414 415 416 417
	ret = iwl_send_add_sta(priv, &station->sta, CMD_SYNC);
	if (ret) {
		IWL_ERR(priv, "Adding station %pM failed.\n", station->sta.sta.addr);
		spin_lock_irqsave(&priv->sta_lock, flags_spin);
		priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
		priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
	}
	*sta_id_r = sta_id;
	return ret;
418
}
419
EXPORT_SYMBOL(iwl_add_station_common);
420

421
static void iwl_sta_init_lq(struct iwl_priv *priv, const u8 *addr, bool is_ap)
422
{
423 424 425 426 427
	int i, r;
	struct iwl_link_quality_cmd link_cmd = {
		.reserved1 = 0,
	};
	u32 rate_flags;
W
Wey-Yi Guy 已提交
428
	int ret = 0;
429 430 431 432 433 434 435 436 437

	/* Set up the rate scaling to start at selected rate, fall back
	 * all the way down to 1M in IEEE order, and then spin on 1M */
	if (is_ap)
		r = IWL_RATE_54M_INDEX;
	else if (priv->band == IEEE80211_BAND_5GHZ)
		r = IWL_RATE_6M_INDEX;
	else
		r = IWL_RATE_1M_INDEX;
438

439 440 441 442
	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
		rate_flags = 0;
		if (r >= IWL_FIRST_CCK_RATE && r <= IWL_LAST_CCK_RATE)
			rate_flags |= RATE_MCS_CCK_MSK;
443

444 445
		rate_flags |= first_antenna(priv->hw_params.valid_tx_ant) <<
				RATE_MCS_ANT_POS;
446

447 448 449 450
		link_cmd.rs_table[i].rate_n_flags =
			iwl_hw_set_rate_n_flags(iwl_rates[r].plcp, rate_flags);
		r = iwl_get_prev_ieee_rate(r);
	}
451

452 453
	link_cmd.general_params.single_stream_ant_msk =
				first_antenna(priv->hw_params.valid_tx_ant);
454 455 456 457 458 459 460 461 462 463 464

	link_cmd.general_params.dual_stream_ant_msk =
		priv->hw_params.valid_tx_ant &
		~first_antenna(priv->hw_params.valid_tx_ant);
	if (!link_cmd.general_params.dual_stream_ant_msk) {
		link_cmd.general_params.dual_stream_ant_msk = ANT_AB;
	} else if (num_of_ant(priv->hw_params.valid_tx_ant) == 2) {
		link_cmd.general_params.dual_stream_ant_msk =
			priv->hw_params.valid_tx_ant;
	}

465 466 467
	link_cmd.agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
	link_cmd.agg_params.agg_time_limit =
		cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
468

469 470
	/* Update the rate scaling for control frame Tx to AP */
	link_cmd.sta_id = is_ap ? IWL_AP_ID : priv->hw_params.bcast_sta_id;
471

W
Wey-Yi Guy 已提交
472
	ret = iwl_send_cmd_pdu(priv, REPLY_TX_LINK_QUALITY_CMD,
473
			       sizeof(link_cmd), &link_cmd);
W
Wey-Yi Guy 已提交
474 475
	if (ret)
		IWL_ERR(priv, "REPLY_TX_LINK_QUALITY_CMD failed (%d)\n", ret);
476 477
}

478 479 480 481 482 483 484 485 486
/*
 * iwl_add_local_stations - Add stations not requested by mac80211
 *
 * This will be either the broadcast station or the bssid station needed by
 * ad-hoc.
 *
 * Function sleeps.
 */
int iwl_add_local_station(struct iwl_priv *priv, const u8 *addr, bool init_rs)
487
{
488 489
	int ret;
	u8 sta_id;
490

491 492 493 494
	ret = iwl_add_station_common(priv, addr, 0, NULL, &sta_id);
	if (ret) {
		IWL_ERR(priv, "Unable to add station %pM\n", addr);
		return ret;
495 496
	}

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
	if (init_rs)
		/* Set up default rate scaling table in device's station table */
		iwl_sta_init_lq(priv, addr, false);
	return 0;
}
EXPORT_SYMBOL(iwl_add_local_station);

/**
 * iwl_sta_ucode_deactivate - deactivate ucode status for a station
 *
 * priv->sta_lock must be held
 */
static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, u8 sta_id)
{
	/* Ucode must be active and driver must be non active */
	if (priv->stations[sta_id].used != IWL_STA_UCODE_ACTIVE)
		IWL_ERR(priv, "removed non active STA %u\n", sta_id);

	priv->stations[sta_id].used &= ~IWL_STA_UCODE_ACTIVE;

	memset(&priv->stations[sta_id], 0, sizeof(struct iwl_station_entry));
	IWL_DEBUG_ASSOC(priv, "Removed STA %u\n", sta_id);
519 520
}

521 522
static int iwl_send_remove_station(struct iwl_priv *priv,
				   struct iwl_station_entry *station)
523
{
Z
Zhu Yi 已提交
524
	struct iwl_rx_packet *pkt;
525 526
	int ret;

527
	unsigned long flags_spin;
528 529 530 531 532
	struct iwl_rem_sta_cmd rm_sta_cmd;

	struct iwl_host_cmd cmd = {
		.id = REPLY_REMOVE_STA,
		.len = sizeof(struct iwl_rem_sta_cmd),
533
		.flags = CMD_SYNC,
534 535 536 537 538
		.data = &rm_sta_cmd,
	};

	memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
	rm_sta_cmd.num_sta = 1;
539 540 541
	memcpy(&rm_sta_cmd.addr, &station->sta.sta.addr , ETH_ALEN);

	cmd.flags |= CMD_WANT_SKB;
542 543 544

	ret = iwl_send_cmd(priv, &cmd);

545
	if (ret)
546 547
		return ret;

Z
Zhu Yi 已提交
548 549
	pkt = (struct iwl_rx_packet *)cmd.reply_page;
	if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
550
		IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
Z
Zhu Yi 已提交
551
			  pkt->hdr.flags);
552 553 554 555
		ret = -EIO;
	}

	if (!ret) {
Z
Zhu Yi 已提交
556
		switch (pkt->u.rem_sta.status) {
557
		case REM_STA_SUCCESS_MSK:
558 559 560
			spin_lock_irqsave(&priv->sta_lock, flags_spin);
			iwl_sta_ucode_deactivate(priv, station->sta.sta.sta_id);
			spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
561
			IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n");
562 563 564
			break;
		default:
			ret = -EIO;
565
			IWL_ERR(priv, "REPLY_REMOVE_STA failed\n");
566 567 568
			break;
		}
	}
569
	iwl_free_pages(priv, cmd.reply_page);
570 571 572

	return ret;
}
573

574 575 576
/**
 * iwl_remove_station - Remove driver's knowledge of station.
 */
577
static int iwl_remove_station(struct iwl_priv *priv, struct ieee80211_sta *sta)
578
{
579 580
	int sta_id = IWL_INVALID_STATION;
	int i, ret = -EINVAL;
581
	unsigned long flags;
582 583 584 585 586
	bool is_ap = priv->iw_mode == NL80211_IFTYPE_STATION;
	struct iwl_station_entry *station;

	if (!iwl_is_ready(priv)) {
		IWL_DEBUG_INFO(priv,
587
			"Unable to remove station %pM, device not ready.\n",
588 589 590 591 592 593 594 595
			sta->addr);
		/*
		 * It is typical for stations to be removed when we are
		 * going down. Return success since device will be down
		 * soon anyway
		 */
		return 0;
	}
596 597 598 599

	spin_lock_irqsave(&priv->sta_lock, flags);

	if (is_ap)
600
		sta_id = IWL_AP_ID;
601 602 603 604
	else
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++)
			if (priv->stations[i].used &&
			    !compare_ether_addr(priv->stations[i].sta.sta.addr,
605
						sta->addr)) {
606
				sta_id = i;
607 608 609
				break;
			}

610
	if (unlikely(sta_id == IWL_INVALID_STATION))
611 612
		goto out;

613
	IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d  %pM\n",
614
		sta_id, sta->addr);
615 616

	if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
617 618
		IWL_DEBUG_INFO(priv, "Removing %pM but non DRIVER active\n",
				sta->addr);
619 620 621 622
		goto out;
	}

	if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
623 624
		IWL_DEBUG_INFO(priv, "Removing %pM but non UCODE active\n",
				sta->addr);
625
		goto out;
626 627
	}

628 629 630 631 632

	priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;

	priv->num_stations--;

633
	BUG_ON(priv->num_stations < 0);
634

635
	station = &priv->stations[sta_id];
636
	spin_unlock_irqrestore(&priv->sta_lock, flags);
637

638
	ret = iwl_send_remove_station(priv, station);
639
	return ret;
640 641
out:
	spin_unlock_irqrestore(&priv->sta_lock, flags);
642
	return ret;
643
}
644

645
/**
646 647 648 649 650 651
 * iwl_clear_ucode_stations() - clear entire station table driver and/or ucode
 * @priv:
 * @force: If set then the uCode station table needs to be cleared here. If
 *         not set then the uCode station table has already been cleared,
 *         for example after sending it a RXON command without ASSOC bit
 *         set, and we just need to change driver state here.
652
 */
653
void iwl_clear_ucode_stations(struct iwl_priv *priv, bool force)
654
{
655
	int i;
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
	unsigned long flags_spin;
	bool cleared = false;

	IWL_DEBUG_INFO(priv, "Clearing ucode stations in driver%s\n",
			force ? " and ucode" : "");

	if (force) {
		if (!iwl_is_ready(priv)) {
			/*
			 * If device is not ready at this point the station
			 * table is likely already empty (uCode not ready
			 * to receive station requests) or will soon be
			 * due to interface going down.
			 */
			IWL_DEBUG_INFO(priv, "Unable to remove stations from device - device not ready\n");
		} else {
			iwl_send_cmd_pdu_async(priv, REPLY_REMOVE_ALL_STA, 0, NULL, NULL);
		}
	}
675

676 677 678 679 680 681 682 683
	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	if (force) {
		IWL_DEBUG_INFO(priv, "Clearing all station information in driver\n");
		priv->num_stations = 0;
		memset(priv->stations, 0, sizeof(priv->stations));
	} else {
		for (i = 0; i < priv->hw_params.max_stations; i++) {
			if (priv->stations[i].used & IWL_STA_UCODE_ACTIVE) {
684
				IWL_DEBUG_INFO(priv, "Clearing ucode active for station %d\n", i);
685 686 687 688 689 690 691 692 693 694 695
				priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE;
				cleared = true;
			}
		}
	}
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);

	if (!cleared)
		IWL_DEBUG_INFO(priv, "No active stations found to be cleared\n");
}
EXPORT_SYMBOL(iwl_clear_ucode_stations);
696

697 698 699 700 701
/**
 * iwl_restore_stations() - Restore driver known stations to device
 *
 * All stations considered active by driver, but not present in ucode, is
 * restored.
702 703
 *
 * Function sleeps.
704 705 706
 */
void iwl_restore_stations(struct iwl_priv *priv)
{
707
	struct iwl_station_entry *station;
708 709 710
	unsigned long flags_spin;
	int i;
	bool found = false;
711
	int ret;
712

713 714 715 716
	if (!iwl_is_ready(priv)) {
		IWL_DEBUG_INFO(priv, "Not ready yet, not restoring any stations.\n");
		return;
	}
717

718 719 720 721 722 723 724 725 726 727 728 729
	IWL_DEBUG_ASSOC(priv, "Restoring all known stations ... start.\n");
	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	for (i = 0; i < priv->hw_params.max_stations; i++) {
		if ((priv->stations[i].used & IWL_STA_DRIVER_ACTIVE) &&
			    !(priv->stations[i].used & IWL_STA_UCODE_ACTIVE)) {
			IWL_DEBUG_ASSOC(priv, "Restoring sta %pM\n",
					priv->stations[i].sta.sta.addr);
			priv->stations[i].sta.mode = 0;
			priv->stations[i].used |= IWL_STA_UCODE_INPROGRESS;
			found = true;
		}
	}
730

731 732
	for (i = 0; i < priv->hw_params.max_stations; i++) {
		if ((priv->stations[i].used & IWL_STA_UCODE_INPROGRESS)) {
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
			spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
			station = &priv->stations[i];
			ret = iwl_send_add_sta(priv, &priv->stations[i].sta, CMD_SYNC);
			if (ret) {
				IWL_ERR(priv, "Adding station %pM failed.\n",
					station->sta.sta.addr);
				spin_lock_irqsave(&priv->sta_lock, flags_spin);
				priv->stations[i].used &= ~IWL_STA_DRIVER_ACTIVE;
				priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS;
				spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
			}
			/*
			 * Rate scaling has already been initialized, send
			 * current LQ command
			 */
			if (station->lq)
				iwl_send_lq_cmd(priv, station->lq, CMD_SYNC, true);
			spin_lock_irqsave(&priv->sta_lock, flags_spin);
751 752
			priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS;
		}
753 754
	}

755 756 757 758
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
	if (!found)
		IWL_DEBUG_INFO(priv, "Restoring all known stations .... no stations to be restored.\n");
	else
759
		IWL_DEBUG_INFO(priv, "Restoring all known stations .... complete.\n");
760
}
761
EXPORT_SYMBOL(iwl_restore_stations);
762

763
int iwl_get_free_ucode_key_index(struct iwl_priv *priv)
764 765 766 767
{
	int i;

	for (i = 0; i < STA_KEY_MAX_NUM; i++)
768
		if (!test_and_set_bit(i, &priv->ucode_key_table))
769 770
			return i;

771
	return WEP_INVALID_OFFSET;
772
}
773
EXPORT_SYMBOL(iwl_get_free_ucode_key_index);
774

775
static int iwl_send_static_wepkey_cmd(struct iwl_priv *priv, u8 send_if_empty)
776 777 778 779 780 781 782 783 784
{
	int i, not_empty = 0;
	u8 buff[sizeof(struct iwl_wep_cmd) +
		sizeof(struct iwl_wep_key) * WEP_KEYS_MAX];
	struct iwl_wep_cmd *wep_cmd = (struct iwl_wep_cmd *)buff;
	size_t cmd_size  = sizeof(struct iwl_wep_cmd);
	struct iwl_host_cmd cmd = {
		.id = REPLY_WEPKEY,
		.data = wep_cmd,
785
		.flags = CMD_SYNC,
786 787
	};

788 789
	might_sleep();

790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818
	memset(wep_cmd, 0, cmd_size +
			(sizeof(struct iwl_wep_key) * WEP_KEYS_MAX));

	for (i = 0; i < WEP_KEYS_MAX ; i++) {
		wep_cmd->key[i].key_index = i;
		if (priv->wep_keys[i].key_size) {
			wep_cmd->key[i].key_offset = i;
			not_empty = 1;
		} else {
			wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
		}

		wep_cmd->key[i].key_size = priv->wep_keys[i].key_size;
		memcpy(&wep_cmd->key[i].key[3], priv->wep_keys[i].key,
				priv->wep_keys[i].key_size);
	}

	wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
	wep_cmd->num_keys = WEP_KEYS_MAX;

	cmd_size += sizeof(struct iwl_wep_key) * WEP_KEYS_MAX;

	cmd.len = cmd_size;

	if (not_empty || send_if_empty)
		return iwl_send_cmd(priv, &cmd);
	else
		return 0;
}
819 820 821 822 823 824 825 826

int iwl_restore_default_wep_keys(struct iwl_priv *priv)
{
	WARN_ON(!mutex_is_locked(&priv->mutex));

	return iwl_send_static_wepkey_cmd(priv, 0);
}
EXPORT_SYMBOL(iwl_restore_default_wep_keys);
827 828

int iwl_remove_default_wep_key(struct iwl_priv *priv,
829
			       struct ieee80211_key_conf *keyconf)
830 831 832
{
	int ret;

833 834
	WARN_ON(!mutex_is_locked(&priv->mutex));

835 836
	IWL_DEBUG_WEP(priv, "Removing default WEP key: idx=%d\n",
		      keyconf->keyidx);
837 838

	memset(&priv->wep_keys[keyconf->keyidx], 0, sizeof(priv->wep_keys[0]));
839 840
	if (iwl_is_rfkill(priv)) {
		IWL_DEBUG_WEP(priv, "Not sending REPLY_WEPKEY command due to RFKILL.\n");
841
		/* but keys in device are clear anyway so return success */
842 843
		return 0;
	}
844
	ret = iwl_send_static_wepkey_cmd(priv, 1);
845
	IWL_DEBUG_WEP(priv, "Remove default WEP key: idx=%d ret=%d\n",
846
		      keyconf->keyidx, ret);
847 848 849

	return ret;
}
850
EXPORT_SYMBOL(iwl_remove_default_wep_key);
851 852 853 854 855

int iwl_set_default_wep_key(struct iwl_priv *priv,
			    struct ieee80211_key_conf *keyconf)
{
	int ret;
856 857

	WARN_ON(!mutex_is_locked(&priv->mutex));
858

859 860
	if (keyconf->keylen != WEP_KEY_LEN_128 &&
	    keyconf->keylen != WEP_KEY_LEN_64) {
861
		IWL_DEBUG_WEP(priv, "Bad WEP key length %d\n", keyconf->keylen);
862 863 864
		return -EINVAL;
	}

865
	keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
866
	keyconf->hw_key_idx = HW_KEY_DEFAULT;
867 868 869 870 871 872 873
	priv->stations[IWL_AP_ID].keyinfo.alg = ALG_WEP;

	priv->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
	memcpy(&priv->wep_keys[keyconf->keyidx].key, &keyconf->key,
							keyconf->keylen);

	ret = iwl_send_static_wepkey_cmd(priv, 0);
874
	IWL_DEBUG_WEP(priv, "Set default WEP key: len=%d idx=%d ret=%d\n",
875
		keyconf->keylen, keyconf->keyidx, ret);
876 877 878

	return ret;
}
879
EXPORT_SYMBOL(iwl_set_default_wep_key);
880

881
static int iwl_set_wep_dynamic_key_info(struct iwl_priv *priv,
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
				struct ieee80211_key_conf *keyconf,
				u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;
	int ret;

	keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;

	key_flags |= (STA_KEY_FLG_WEP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
	key_flags &= ~STA_KEY_FLG_INVALID;

	if (keyconf->keylen == WEP_KEY_LEN_128)
		key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;

T
Tomas Winkler 已提交
898
	if (sta_id == priv->hw_params.bcast_sta_id)
899 900 901 902 903 904 905 906 907 908 909 910 911 912
		key_flags |= STA_KEY_MULTICAST_MSK;

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->stations[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;
	priv->stations[sta_id].keyinfo.keyidx = keyconf->keyidx;

	memcpy(priv->stations[sta_id].keyinfo.key,
				keyconf->key, keyconf->keylen);

	memcpy(&priv->stations[sta_id].sta.key.key[3],
				keyconf->key, keyconf->keylen);

913 914 915
	if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
			== STA_KEY_FLG_NO_ENC)
		priv->stations[sta_id].sta.key.key_offset =
916
				 iwl_get_free_ucode_key_index(priv);
917 918
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */
919

920
	WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
J
Jiri Slaby 已提交
921
		"no space for a new key");
922

923
	priv->stations[sta_id].sta.key.key_flags = key_flags;
924 925 926
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

927
	ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
928 929 930 931 932

	spin_unlock_irqrestore(&priv->sta_lock, flags);

	return ret;
}
933 934 935 936 937 938 939

static int iwl_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;
940
	int ret;
941 942 943 944 945

	key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
	key_flags &= ~STA_KEY_FLG_INVALID;

T
Tomas Winkler 已提交
946
	if (sta_id == priv->hw_params.bcast_sta_id)
947 948 949 950 951 952 953 954 955 956 957 958 959 960
		key_flags |= STA_KEY_MULTICAST_MSK;

	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;

	spin_lock_irqsave(&priv->sta_lock, flags);
	priv->stations[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;

	memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key,
	       keyconf->keylen);

	memcpy(priv->stations[sta_id].sta.key.key, keyconf->key,
	       keyconf->keylen);

961 962 963 964 965 966 967
	if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
			== STA_KEY_FLG_NO_ENC)
		priv->stations[sta_id].sta.key.key_offset =
				 iwl_get_free_ucode_key_index(priv);
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */

968
	WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
J
Jiri Slaby 已提交
969
		"no space for a new key");
970

971 972 973 974
	priv->stations[sta_id].sta.key.key_flags = key_flags;
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

975 976
	ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);

977 978
	spin_unlock_irqrestore(&priv->sta_lock, flags);

979
	return ret;
980 981 982 983 984 985 986 987
}

static int iwl_set_tkip_dynamic_key_info(struct iwl_priv *priv,
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	int ret = 0;
988 989 990 991 992 993 994 995
	__le16 key_flags = 0;

	key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
	key_flags &= ~STA_KEY_FLG_INVALID;

	if (sta_id == priv->hw_params.bcast_sta_id)
		key_flags |= STA_KEY_MULTICAST_MSK;
996 997 998 999 1000 1001 1002 1003

	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->stations[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations[sta_id].keyinfo.keylen = 16;
1004 1005 1006 1007

	if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
			== STA_KEY_FLG_NO_ENC)
		priv->stations[sta_id].sta.key.key_offset =
1008
				 iwl_get_free_ucode_key_index(priv);
1009 1010
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */
1011

1012
	WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
J
Jiri Slaby 已提交
1013
		"no space for a new key");
1014

1015 1016 1017
	priv->stations[sta_id].sta.key.key_flags = key_flags;


1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
	/* This copy is acutally not needed: we get the key with each TX */
	memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key, 16);

	memcpy(priv->stations[sta_id].sta.key.key, keyconf->key, 16);

	spin_unlock_irqrestore(&priv->sta_lock, flags);

	return ret;
}

1028 1029 1030 1031 1032 1033 1034 1035
void iwl_update_tkip_key(struct iwl_priv *priv,
			struct ieee80211_key_conf *keyconf,
			const u8 *addr, u32 iv32, u16 *phase1key)
{
	u8 sta_id = IWL_INVALID_STATION;
	unsigned long flags;
	int i;

1036
	sta_id = iwl_find_station(priv, addr);
1037
	if (sta_id == IWL_INVALID_STATION) {
1038
		IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
				   addr);
		return;
	}

	if (iwl_scan_cancel(priv)) {
		/* cancel scan failed, just live w/ bad key and rely
		   briefly on SW decryption */
		return;
	}

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->stations[sta_id].sta.key.tkip_rx_tsc_byte2 = (u8) iv32;

	for (i = 0; i < 5; i++)
		priv->stations[sta_id].sta.key.tkip_rx_ttak[i] =
			cpu_to_le16(phase1key[i]);

	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

	iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);

	spin_unlock_irqrestore(&priv->sta_lock, flags);

}
EXPORT_SYMBOL(iwl_update_tkip_key);

1067 1068 1069
int iwl_remove_dynamic_key(struct iwl_priv *priv,
				struct ieee80211_key_conf *keyconf,
				u8 sta_id)
1070 1071
{
	unsigned long flags;
1072 1073 1074
	int ret = 0;
	u16 key_flags;
	u8 keyidx;
1075

1076
	priv->key_mapping_key--;
1077 1078

	spin_lock_irqsave(&priv->sta_lock, flags);
1079 1080 1081
	key_flags = le16_to_cpu(priv->stations[sta_id].sta.key.key_flags);
	keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;

1082
	IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
1083 1084
		      keyconf->keyidx, sta_id);

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
	if (keyconf->keyidx != keyidx) {
		/* We need to remove a key with index different that the one
		 * in the uCode. This means that the key we need to remove has
		 * been replaced by another one with different index.
		 * Don't do anything and return ok
		 */
		spin_unlock_irqrestore(&priv->sta_lock, flags);
		return 0;
	}

1095
	if (priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
1096
		IWL_WARN(priv, "Removing wrong key %d 0x%x\n",
1097 1098 1099 1100 1101
			    keyconf->keyidx, key_flags);
		spin_unlock_irqrestore(&priv->sta_lock, flags);
		return 0;
	}

1102 1103
	if (!test_and_clear_bit(priv->stations[sta_id].sta.key.key_offset,
		&priv->ucode_key_table))
1104
		IWL_ERR(priv, "index %d not used in uCode key table.\n",
1105 1106
			priv->stations[sta_id].sta.key.key_offset);
	memset(&priv->stations[sta_id].keyinfo, 0,
1107
					sizeof(struct iwl_hw_key));
1108 1109
	memset(&priv->stations[sta_id].sta.key, 0,
					sizeof(struct iwl4965_keyinfo));
1110 1111 1112
	priv->stations[sta_id].sta.key.key_flags =
			STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
	priv->stations[sta_id].sta.key.key_offset = WEP_INVALID_OFFSET;
1113 1114 1115
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

1116
	if (iwl_is_rfkill(priv)) {
1117
		IWL_DEBUG_WEP(priv, "Not sending REPLY_ADD_STA command because RFKILL enabled.\n");
1118 1119 1120
		spin_unlock_irqrestore(&priv->sta_lock, flags);
		return 0;
	}
1121
	ret =  iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
1122 1123
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return ret;
1124
}
1125
EXPORT_SYMBOL(iwl_remove_dynamic_key);
1126 1127

int iwl_set_dynamic_key(struct iwl_priv *priv,
1128
				struct ieee80211_key_conf *keyconf, u8 sta_id)
1129 1130 1131
{
	int ret;

1132 1133
	priv->key_mapping_key++;
	keyconf->hw_key_idx = HW_KEY_DYNAMIC;
1134

1135
	switch (keyconf->alg) {
1136
	case ALG_CCMP:
1137
		ret = iwl_set_ccmp_dynamic_key_info(priv, keyconf, sta_id);
1138 1139
		break;
	case ALG_TKIP:
1140
		ret = iwl_set_tkip_dynamic_key_info(priv, keyconf, sta_id);
1141 1142
		break;
	case ALG_WEP:
1143
		ret = iwl_set_wep_dynamic_key_info(priv, keyconf, sta_id);
1144 1145
		break;
	default:
1146 1147
		IWL_ERR(priv,
			"Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
1148 1149 1150
		ret = -EINVAL;
	}

1151
	IWL_DEBUG_WEP(priv, "Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n",
1152 1153 1154
		      keyconf->alg, keyconf->keylen, keyconf->keyidx,
		      sta_id, ret);

1155 1156
	return ret;
}
1157
EXPORT_SYMBOL(iwl_set_dynamic_key);
1158

1159 1160 1161 1162 1163
#ifdef CONFIG_IWLWIFI_DEBUG
static void iwl_dump_lq_cmd(struct iwl_priv *priv,
			   struct iwl_link_quality_cmd *lq)
{
	int i;
1164 1165
	IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id);
	IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n",
1166 1167 1168 1169
		       lq->general_params.single_stream_ant_msk,
		       lq->general_params.dual_stream_ant_msk);

	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
1170
		IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n",
1171 1172 1173 1174 1175 1176 1177 1178 1179
			       i, lq->rs_table[i].rate_n_flags);
}
#else
static inline void iwl_dump_lq_cmd(struct iwl_priv *priv,
				   struct iwl_link_quality_cmd *lq)
{
}
#endif

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
/**
 * iwl_send_lq_cmd() - Send link quality command
 * @init: This command is sent as part of station initialization right
 *        after station has been added.
 *
 * The link quality command is sent as the last step of station creation.
 * This is the special case in which init is set and we call a callback in
 * this case to clear the state indicating that station creation is in
 * progress.
 */
1190
int iwl_send_lq_cmd(struct iwl_priv *priv,
1191
		    struct iwl_link_quality_cmd *lq, u8 flags, bool init)
1192
{
1193 1194 1195
	int ret = 0;
	unsigned long flags_spin;

1196 1197 1198
	struct iwl_host_cmd cmd = {
		.id = REPLY_TX_LINK_QUALITY_CMD,
		.len = sizeof(struct iwl_link_quality_cmd),
J
Johannes Berg 已提交
1199
		.flags = flags,
1200 1201 1202
		.data = lq,
	};

1203
	if (WARN_ON(lq->sta_id == IWL_INVALID_STATION))
1204 1205
		return -EINVAL;

1206
	iwl_dump_lq_cmd(priv, lq);
1207
	BUG_ON(init && (cmd.flags & CMD_ASYNC));
1208

1209 1210 1211
	ret = iwl_send_cmd(priv, &cmd);
	if (ret || (cmd.flags & CMD_ASYNC))
		return ret;
1212

1213
	if (init) {
1214
		IWL_DEBUG_INFO(priv, "init LQ command complete, clearing sta addition status for sta %d\n",
1215 1216 1217 1218 1219
			       lq->sta_id);
		spin_lock_irqsave(&priv->sta_lock, flags_spin);
		priv->stations[lq->sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
	}
1220 1221 1222 1223
	return 0;
}
EXPORT_SYMBOL(iwl_send_lq_cmd);

1224 1225 1226 1227 1228
/**
 * iwl_add_bcast_station - add broadcast station into station table.
 */
void iwl_add_bcast_station(struct iwl_priv *priv)
{
1229
	IWL_DEBUG_INFO(priv, "Adding broadcast station to station table\n");
1230
	iwl_add_local_station(priv, iwl_bcast_addr, true);
1231 1232 1233
}
EXPORT_SYMBOL(iwl_add_bcast_station);

1234 1235 1236 1237 1238 1239
/**
 * iwl3945_add_bcast_station - add broadcast station into station table.
 */
void iwl3945_add_bcast_station(struct iwl_priv *priv)
{
	IWL_DEBUG_INFO(priv, "Adding broadcast station to station table\n");
1240 1241 1242 1243 1244 1245 1246 1247
	iwl_add_local_station(priv, iwl_bcast_addr, false);
	/*
	 * It is assumed that when station is added more initialization
	 * needs to be done, but for 3945 it is not the case and we can
	 * just release station table access right here.
	 */
	priv->stations[priv->hw_params.bcast_sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;

1248 1249 1250
}
EXPORT_SYMBOL(iwl3945_add_bcast_station);

1251 1252 1253 1254 1255 1256 1257 1258
/**
 * iwl_get_sta_id - Find station's index within station table
 *
 * If new IBSS station, create new entry in station table
 */
int iwl_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
{
	int sta_id;
1259
	__le16 fc = hdr->frame_control;
1260 1261

	/* If this frame is broadcast or management, use broadcast station id */
1262
	if (!ieee80211_is_data(fc) ||  is_multicast_ether_addr(hdr->addr1))
1263 1264 1265 1266 1267 1268
		return priv->hw_params.bcast_sta_id;

	switch (priv->iw_mode) {

	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
1269
	case NL80211_IFTYPE_STATION:
1270 1271 1272 1273 1274 1275 1276
		/*
		 * If addition of station not complete yet, which means
		 * that rate scaling has not been initialized, then return
		 * the broadcast station.
		 */
		if (!(priv->stations[IWL_AP_ID].used & IWL_STA_UCODE_ACTIVE))
			return priv->hw_params.bcast_sta_id;
1277 1278 1279
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
1280
	case NL80211_IFTYPE_AP:
1281
		sta_id = iwl_find_station(priv, hdr->addr1);
1282 1283 1284 1285 1286 1287
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
		return priv->hw_params.bcast_sta_id;

	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
1288
	case NL80211_IFTYPE_ADHOC:
1289
		sta_id = iwl_find_station(priv, hdr->addr1);
1290 1291 1292
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

1293
		IWL_DEBUG_DROP(priv, "Station %pM not in station map. "
1294
			       "Defaulting to broadcast...\n",
J
Johannes Berg 已提交
1295
			       hdr->addr1);
1296
		iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
1297 1298 1299
		return priv->hw_params.bcast_sta_id;

	default:
1300 1301
		IWL_WARN(priv, "Unknown mode of operation: %d\n",
			priv->iw_mode);
1302 1303 1304 1305 1306
		return priv->hw_params.bcast_sta_id;
	}
}
EXPORT_SYMBOL(iwl_get_sta_id);

1307
/**
1308
 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
1309
 */
1310
void iwl_sta_tx_modify_enable_tid(struct iwl_priv *priv, int sta_id, int tid)
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
{
	unsigned long flags;

	/* Remove "disable" flag, to enable Tx for this TID */
	spin_lock_irqsave(&priv->sta_lock, flags);
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
	priv->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	spin_unlock_irqrestore(&priv->sta_lock, flags);

	iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
}
1323 1324 1325 1326 1327 1328 1329 1330
EXPORT_SYMBOL(iwl_sta_tx_modify_enable_tid);

int iwl_sta_rx_agg_start(struct iwl_priv *priv,
			 const u8 *addr, int tid, u16 ssn)
{
	unsigned long flags;
	int sta_id;

1331
	sta_id = iwl_find_station(priv, addr);
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
	if (sta_id == IWL_INVALID_STATION)
		return -ENXIO;

	spin_lock_irqsave(&priv->sta_lock, flags);
	priv->stations[sta_id].sta.station_flags_msk = 0;
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
	priv->stations[sta_id].sta.add_immediate_ba_tid = (u8)tid;
	priv->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	spin_unlock_irqrestore(&priv->sta_lock, flags);

	return iwl_send_add_sta(priv, &priv->stations[sta_id].sta,
					CMD_ASYNC);
}
EXPORT_SYMBOL(iwl_sta_rx_agg_start);

int iwl_sta_rx_agg_stop(struct iwl_priv *priv, const u8 *addr, int tid)
{
	unsigned long flags;
	int sta_id;

1353
	sta_id = iwl_find_station(priv, addr);
1354 1355
	if (sta_id == IWL_INVALID_STATION) {
		IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
1356
		return -ENXIO;
1357
	}
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370

	spin_lock_irqsave(&priv->sta_lock, flags);
	priv->stations[sta_id].sta.station_flags_msk = 0;
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
	priv->stations[sta_id].sta.remove_immediate_ba_tid = (u8)tid;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	spin_unlock_irqrestore(&priv->sta_lock, flags);

	return iwl_send_add_sta(priv, &priv->stations[sta_id].sta,
					CMD_ASYNC);
}
EXPORT_SYMBOL(iwl_sta_rx_agg_stop);

1371
void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
1372 1373 1374 1375 1376 1377 1378
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
	priv->stations[sta_id].sta.station_flags &= ~STA_FLG_PWR_SAVE_MSK;
	priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
	priv->stations[sta_id].sta.sta.modify_mask = 0;
1379
	priv->stations[sta_id].sta.sleep_tx_count = 0;
1380 1381 1382 1383 1384
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	spin_unlock_irqrestore(&priv->sta_lock, flags);

	iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
}
1385
EXPORT_SYMBOL(iwl_sta_modify_ps_wake);
1386

1387
void iwl_sta_modify_sleep_tx_count(struct iwl_priv *priv, int sta_id, int cnt)
1388
{
1389
	unsigned long flags;
1390

1391 1392 1393 1394 1395 1396 1397 1398
	spin_lock_irqsave(&priv->sta_lock, flags);
	priv->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
	priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
	priv->stations[sta_id].sta.sta.modify_mask =
					STA_MODIFY_SLEEP_TX_COUNT_MSK;
	priv->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	spin_unlock_irqrestore(&priv->sta_lock, flags);
1399

1400
	iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
1401
}
1402
EXPORT_SYMBOL(iwl_sta_modify_sleep_tx_count);
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418

int iwl_mac_sta_remove(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta)
{
	int ret;
	struct iwl_priv *priv = hw->priv;
	IWL_DEBUG_INFO(priv, "received request to remove station %pM\n",
			sta->addr);
	ret = iwl_remove_station(priv, sta);
	if (ret)
		IWL_ERR(priv, "Error removing station %pM\n",
			sta->addr);
	return ret;
}
EXPORT_SYMBOL(iwl_mac_sta_remove);