iwl-sta.c 40.2 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",
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,
194
		.flags = flags,
195 196
		.data = data,
	};
197 198 199 200
	u8 sta_id = sta->sta.sta_id;

	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)
203
		cmd.callback = iwl_add_sta_callback;
204
	else
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,
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",
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 428 429 430 431 432 433 434 435 436
	int i, r;
	struct iwl_link_quality_cmd link_cmd = {
		.reserved1 = 0,
	};
	u32 rate_flags;

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

438 439 440 441
	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;
442

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

446 447 448 449
		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);
	}
450

451 452 453 454 455 456
	link_cmd.general_params.single_stream_ant_msk =
				first_antenna(priv->hw_params.valid_tx_ant);
	link_cmd.general_params.dual_stream_ant_msk = 3;
	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);
457

458 459
	/* 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;
460

461 462
	iwl_send_cmd_pdu(priv, REPLY_TX_LINK_QUALITY_CMD,
			       sizeof(link_cmd), &link_cmd);
463 464
}

465 466 467 468 469 470 471 472 473
/*
 * 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)
474
{
475 476
	int ret;
	u8 sta_id;
477

478 479 480 481
	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;
482 483
	}

484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
	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);
506 507
}

508 509
static int iwl_send_remove_station(struct iwl_priv *priv,
				   struct iwl_station_entry *station)
510
{
Z
Zhu Yi 已提交
511
	struct iwl_rx_packet *pkt;
512 513
	int ret;

514
	unsigned long flags_spin;
515 516 517 518 519
	struct iwl_rem_sta_cmd rm_sta_cmd;

	struct iwl_host_cmd cmd = {
		.id = REPLY_REMOVE_STA,
		.len = sizeof(struct iwl_rem_sta_cmd),
520
		.flags = CMD_SYNC,
521 522 523 524 525
		.data = &rm_sta_cmd,
	};

	memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
	rm_sta_cmd.num_sta = 1;
526 527 528
	memcpy(&rm_sta_cmd.addr, &station->sta.sta.addr , ETH_ALEN);

	cmd.flags |= CMD_WANT_SKB;
529 530 531

	ret = iwl_send_cmd(priv, &cmd);

532
	if (ret)
533 534
		return ret;

Z
Zhu Yi 已提交
535 536
	pkt = (struct iwl_rx_packet *)cmd.reply_page;
	if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
537
		IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
Z
Zhu Yi 已提交
538
			  pkt->hdr.flags);
539 540 541 542
		ret = -EIO;
	}

	if (!ret) {
Z
Zhu Yi 已提交
543
		switch (pkt->u.rem_sta.status) {
544
		case REM_STA_SUCCESS_MSK:
545 546 547
			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);
548
			IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n");
549 550 551
			break;
		default:
			ret = -EIO;
552
			IWL_ERR(priv, "REPLY_REMOVE_STA failed\n");
553 554 555
			break;
		}
	}
556
	iwl_free_pages(priv, cmd.reply_page);
557 558 559

	return ret;
}
560

561 562 563
/**
 * iwl_remove_station - Remove driver's knowledge of station.
 */
564
static int iwl_remove_station(struct iwl_priv *priv, struct ieee80211_sta *sta)
565
{
566 567
	int sta_id = IWL_INVALID_STATION;
	int i, ret = -EINVAL;
568
	unsigned long flags;
569 570 571 572 573
	bool is_ap = priv->iw_mode == NL80211_IFTYPE_STATION;
	struct iwl_station_entry *station;

	if (!iwl_is_ready(priv)) {
		IWL_DEBUG_INFO(priv,
574
			"Unable to remove station %pM, device not ready.\n",
575 576 577 578 579 580 581 582
			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;
	}
583 584 585 586

	spin_lock_irqsave(&priv->sta_lock, flags);

	if (is_ap)
587
		sta_id = IWL_AP_ID;
588 589 590 591
	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,
592
						sta->addr)) {
593
				sta_id = i;
594 595 596
				break;
			}

597
	if (unlikely(sta_id == IWL_INVALID_STATION))
598 599
		goto out;

600
	IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d  %pM\n",
601
		sta_id, sta->addr);
602 603

	if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
604 605
		IWL_DEBUG_INFO(priv, "Removing %pM but non DRIVER active\n",
				sta->addr);
606 607 608 609
		goto out;
	}

	if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
610 611
		IWL_DEBUG_INFO(priv, "Removing %pM but non UCODE active\n",
				sta->addr);
612
		goto out;
613 614
	}

615 616 617 618 619

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

	priv->num_stations--;

620
	BUG_ON(priv->num_stations < 0);
621

622
	station = &priv->stations[sta_id];
623
	spin_unlock_irqrestore(&priv->sta_lock, flags);
624

625
	ret = iwl_send_remove_station(priv, station);
626
	return ret;
627 628
out:
	spin_unlock_irqrestore(&priv->sta_lock, flags);
629
	return ret;
630
}
631

632
/**
633 634 635 636 637 638
 * 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.
639
 */
640
void iwl_clear_ucode_stations(struct iwl_priv *priv, bool force)
641
{
642
	int i;
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
	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);
		}
	}
662

663 664 665 666 667 668 669 670
	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) {
671
				IWL_DEBUG_INFO(priv, "Clearing ucode active for station %d\n", i);
672 673 674 675 676 677 678 679 680 681 682
				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);
683

684 685 686 687 688
/**
 * iwl_restore_stations() - Restore driver known stations to device
 *
 * All stations considered active by driver, but not present in ucode, is
 * restored.
689 690
 *
 * Function sleeps.
691 692 693
 */
void iwl_restore_stations(struct iwl_priv *priv)
{
694
	struct iwl_station_entry *station;
695 696 697
	unsigned long flags_spin;
	int i;
	bool found = false;
698
	int ret;
699

700 701 702 703
	if (!iwl_is_ready(priv)) {
		IWL_DEBUG_INFO(priv, "Not ready yet, not restoring any stations.\n");
		return;
	}
704

705 706 707 708 709 710 711 712 713 714 715 716
	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;
		}
	}
717

718 719
	for (i = 0; i < priv->hw_params.max_stations; i++) {
		if ((priv->stations[i].used & IWL_STA_UCODE_INPROGRESS)) {
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
			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);
738 739
			priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS;
		}
740 741
	}

742 743 744 745
	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
746
		IWL_DEBUG_INFO(priv, "Restoring all known stations .... complete.\n");
747
}
748
EXPORT_SYMBOL(iwl_restore_stations);
749

750
int iwl_get_free_ucode_key_index(struct iwl_priv *priv)
751 752 753 754
{
	int i;

	for (i = 0; i < STA_KEY_MAX_NUM; i++)
755
		if (!test_and_set_bit(i, &priv->ucode_key_table))
756 757
			return i;

758
	return WEP_INVALID_OFFSET;
759
}
760
EXPORT_SYMBOL(iwl_get_free_ucode_key_index);
761

762
static int iwl_send_static_wepkey_cmd(struct iwl_priv *priv, u8 send_if_empty)
763 764 765 766 767 768 769 770 771
{
	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,
772
		.flags = CMD_SYNC,
773 774
	};

775 776
	might_sleep();

777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
	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;
}
806 807 808 809 810 811 812 813

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);
814 815

int iwl_remove_default_wep_key(struct iwl_priv *priv,
816
			       struct ieee80211_key_conf *keyconf)
817 818 819
{
	int ret;

820 821
	WARN_ON(!mutex_is_locked(&priv->mutex));

822 823
	IWL_DEBUG_WEP(priv, "Removing default WEP key: idx=%d\n",
		      keyconf->keyidx);
824 825

	memset(&priv->wep_keys[keyconf->keyidx], 0, sizeof(priv->wep_keys[0]));
826 827
	if (iwl_is_rfkill(priv)) {
		IWL_DEBUG_WEP(priv, "Not sending REPLY_WEPKEY command due to RFKILL.\n");
828
		/* but keys in device are clear anyway so return success */
829 830
		return 0;
	}
831
	ret = iwl_send_static_wepkey_cmd(priv, 1);
832
	IWL_DEBUG_WEP(priv, "Remove default WEP key: idx=%d ret=%d\n",
833
		      keyconf->keyidx, ret);
834 835 836

	return ret;
}
837
EXPORT_SYMBOL(iwl_remove_default_wep_key);
838 839 840 841 842

int iwl_set_default_wep_key(struct iwl_priv *priv,
			    struct ieee80211_key_conf *keyconf)
{
	int ret;
843 844

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

846 847
	if (keyconf->keylen != WEP_KEY_LEN_128 &&
	    keyconf->keylen != WEP_KEY_LEN_64) {
848
		IWL_DEBUG_WEP(priv, "Bad WEP key length %d\n", keyconf->keylen);
849 850 851
		return -EINVAL;
	}

852
	keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
853
	keyconf->hw_key_idx = HW_KEY_DEFAULT;
854 855 856 857 858 859 860
	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);
861
	IWL_DEBUG_WEP(priv, "Set default WEP key: len=%d idx=%d ret=%d\n",
862
		keyconf->keylen, keyconf->keyidx, ret);
863 864 865

	return ret;
}
866
EXPORT_SYMBOL(iwl_set_default_wep_key);
867

868
static int iwl_set_wep_dynamic_key_info(struct iwl_priv *priv,
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884
				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;

885
	if (sta_id == priv->hw_params.bcast_sta_id)
886 887 888 889 890 891 892 893 894 895 896 897 898 899
		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);

900 901 902
	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 =
903
				 iwl_get_free_ucode_key_index(priv);
904 905
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */
906

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

910
	priv->stations[sta_id].sta.key.key_flags = key_flags;
911 912 913
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

914
	ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
915 916 917 918 919

	spin_unlock_irqrestore(&priv->sta_lock, flags);

	return ret;
}
920 921 922 923 924 925 926

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;
927
	int ret;
928 929 930 931 932

	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;

933
	if (sta_id == priv->hw_params.bcast_sta_id)
934 935 936 937 938 939 940 941 942 943 944 945 946 947
		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);

948 949 950 951 952 953 954
	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. */

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

958 959 960 961
	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;

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

964 965
	spin_unlock_irqrestore(&priv->sta_lock, flags);

966
	return ret;
967 968 969 970 971 972 973 974
}

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;
975 976 977 978 979 980 981 982
	__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;
983 984 985 986 987 988 989 990

	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;
991 992 993 994

	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 =
995
				 iwl_get_free_ucode_key_index(priv);
996 997
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */
998

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

1002 1003 1004
	priv->stations[sta_id].sta.key.key_flags = key_flags;


1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
	/* 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;
}

1015 1016 1017 1018 1019 1020 1021 1022
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;

1023
	sta_id = iwl_find_station(priv, addr);
1024
	if (sta_id == IWL_INVALID_STATION) {
1025
		IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
				   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);

1054 1055 1056
int iwl_remove_dynamic_key(struct iwl_priv *priv,
				struct ieee80211_key_conf *keyconf,
				u8 sta_id)
1057 1058
{
	unsigned long flags;
1059 1060 1061
	int ret = 0;
	u16 key_flags;
	u8 keyidx;
1062

1063
	priv->key_mapping_key--;
1064 1065

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

1069
	IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
1070 1071
		      keyconf->keyidx, sta_id);

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
	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;
	}

1082
	if (priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
1083
		IWL_WARN(priv, "Removing wrong key %d 0x%x\n",
1084 1085 1086 1087 1088
			    keyconf->keyidx, key_flags);
		spin_unlock_irqrestore(&priv->sta_lock, flags);
		return 0;
	}

1089 1090
	if (!test_and_clear_bit(priv->stations[sta_id].sta.key.key_offset,
		&priv->ucode_key_table))
1091
		IWL_ERR(priv, "index %d not used in uCode key table.\n",
1092 1093
			priv->stations[sta_id].sta.key.key_offset);
	memset(&priv->stations[sta_id].keyinfo, 0,
1094
					sizeof(struct iwl_hw_key));
1095 1096
	memset(&priv->stations[sta_id].sta.key, 0,
					sizeof(struct iwl4965_keyinfo));
1097 1098 1099
	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;
1100 1101 1102
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

1103
	if (iwl_is_rfkill(priv)) {
1104
		IWL_DEBUG_WEP(priv, "Not sending REPLY_ADD_STA command because RFKILL enabled.\n");
1105 1106 1107
		spin_unlock_irqrestore(&priv->sta_lock, flags);
		return 0;
	}
1108
	ret =  iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
1109 1110
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return ret;
1111
}
1112
EXPORT_SYMBOL(iwl_remove_dynamic_key);
1113 1114

int iwl_set_dynamic_key(struct iwl_priv *priv,
1115
				struct ieee80211_key_conf *keyconf, u8 sta_id)
1116 1117 1118
{
	int ret;

1119 1120
	priv->key_mapping_key++;
	keyconf->hw_key_idx = HW_KEY_DYNAMIC;
1121

1122
	switch (keyconf->alg) {
1123
	case ALG_CCMP:
1124
		ret = iwl_set_ccmp_dynamic_key_info(priv, keyconf, sta_id);
1125 1126
		break;
	case ALG_TKIP:
1127
		ret = iwl_set_tkip_dynamic_key_info(priv, keyconf, sta_id);
1128 1129
		break;
	case ALG_WEP:
1130
		ret = iwl_set_wep_dynamic_key_info(priv, keyconf, sta_id);
1131 1132
		break;
	default:
1133 1134
		IWL_ERR(priv,
			"Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
1135 1136 1137
		ret = -EINVAL;
	}

1138
	IWL_DEBUG_WEP(priv, "Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n",
1139 1140 1141
		      keyconf->alg, keyconf->keylen, keyconf->keyidx,
		      sta_id, ret);

1142 1143
	return ret;
}
1144
EXPORT_SYMBOL(iwl_set_dynamic_key);
1145

1146 1147 1148 1149 1150
#ifdef CONFIG_IWLWIFI_DEBUG
static void iwl_dump_lq_cmd(struct iwl_priv *priv,
			   struct iwl_link_quality_cmd *lq)
{
	int i;
1151 1152
	IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id);
	IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n",
1153 1154 1155 1156
		       lq->general_params.single_stream_ant_msk,
		       lq->general_params.dual_stream_ant_msk);

	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
1157
		IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n",
1158 1159 1160 1161 1162 1163 1164 1165 1166
			       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

1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
/**
 * 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.
 */
1177
int iwl_send_lq_cmd(struct iwl_priv *priv,
1178
		    struct iwl_link_quality_cmd *lq, u8 flags, bool init)
1179
{
1180 1181 1182
	int ret = 0;
	unsigned long flags_spin;

1183 1184 1185
	struct iwl_host_cmd cmd = {
		.id = REPLY_TX_LINK_QUALITY_CMD,
		.len = sizeof(struct iwl_link_quality_cmd),
1186
		.flags = flags,
1187 1188 1189
		.data = lq,
	};

1190
	if (WARN_ON(lq->sta_id == IWL_INVALID_STATION))
1191 1192
		return -EINVAL;

1193
	iwl_dump_lq_cmd(priv, lq);
1194
	BUG_ON(init && (cmd.flags & CMD_ASYNC));
1195

1196 1197 1198 1199
	iwl_dump_lq_cmd(priv, lq);
	ret = iwl_send_cmd(priv, &cmd);
	if (ret || (cmd.flags & CMD_ASYNC))
		return ret;
1200

1201
	if (init) {
1202
		IWL_DEBUG_INFO(priv, "init LQ command complete, clearing sta addition status for sta %d\n",
1203 1204 1205 1206 1207
			       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);
	}
1208 1209 1210 1211
	return 0;
}
EXPORT_SYMBOL(iwl_send_lq_cmd);

1212 1213 1214 1215 1216
/**
 * iwl_add_bcast_station - add broadcast station into station table.
 */
void iwl_add_bcast_station(struct iwl_priv *priv)
{
1217
	IWL_DEBUG_INFO(priv, "Adding broadcast station to station table\n");
1218
	iwl_add_local_station(priv, iwl_bcast_addr, true);
1219 1220 1221
}
EXPORT_SYMBOL(iwl_add_bcast_station);

1222 1223 1224 1225 1226 1227
/**
 * 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");
1228 1229 1230 1231 1232 1233 1234 1235
	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;

1236 1237 1238
}
EXPORT_SYMBOL(iwl3945_add_bcast_station);

1239 1240 1241 1242 1243 1244 1245 1246
/**
 * 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;
1247
	__le16 fc = hdr->frame_control;
1248 1249

	/* If this frame is broadcast or management, use broadcast station id */
1250
	if (!ieee80211_is_data(fc) ||  is_multicast_ether_addr(hdr->addr1))
1251 1252 1253 1254 1255 1256
		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) */
1257
	case NL80211_IFTYPE_STATION:
1258 1259 1260 1261 1262 1263 1264
		/*
		 * 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;
1265 1266 1267
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
1268
	case NL80211_IFTYPE_AP:
1269
		sta_id = iwl_find_station(priv, hdr->addr1);
1270 1271 1272 1273 1274 1275
		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 */
1276
	case NL80211_IFTYPE_ADHOC:
1277
		sta_id = iwl_find_station(priv, hdr->addr1);
1278 1279 1280
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

1281
		IWL_DEBUG_DROP(priv, "Station %pM not in station map. "
1282
			       "Defaulting to broadcast...\n",
1283
			       hdr->addr1);
1284
		iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
1285 1286 1287
		return priv->hw_params.bcast_sta_id;

	default:
1288 1289
		IWL_WARN(priv, "Unknown mode of operation: %d\n",
			priv->iw_mode);
1290 1291 1292 1293 1294
		return priv->hw_params.bcast_sta_id;
	}
}
EXPORT_SYMBOL(iwl_get_sta_id);

1295
/**
1296
 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
1297
 */
1298
void iwl_sta_tx_modify_enable_tid(struct iwl_priv *priv, int sta_id, int tid)
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
{
	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);
}
1311 1312 1313 1314 1315 1316 1317 1318
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;

1319
	sta_id = iwl_find_station(priv, addr);
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
	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;

1341
	sta_id = iwl_find_station(priv, addr);
1342 1343
	if (sta_id == IWL_INVALID_STATION) {
		IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
1344
		return -ENXIO;
1345
	}
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358

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

1359
void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
1360 1361 1362 1363 1364 1365 1366
{
	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;
1367
	priv->stations[sta_id].sta.sleep_tx_count = 0;
1368 1369 1370 1371 1372
	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);
}
1373
EXPORT_SYMBOL(iwl_sta_modify_ps_wake);
1374

1375
void iwl_sta_modify_sleep_tx_count(struct iwl_priv *priv, int sta_id, int cnt)
1376
{
1377
	unsigned long flags;
1378

1379 1380 1381 1382 1383 1384 1385 1386
	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);
1387

1388
	iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
1389
}
1390
EXPORT_SYMBOL(iwl_sta_modify_sleep_tx_count);
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406

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);
新手
引导
客服 返回
顶部